From 4363837772a4a6ba7842cce87f0f7410ff8d4231 Mon Sep 17 00:00:00 2001 From: "J. Eric Ivancich" Date: Fri, 4 Aug 2017 12:35:34 -0400 Subject: [PATCH] Squashed 'src/dmclock/' changes from 64bcc6e..3408cb8 3408cb8 Merge pull request #33 from ceph/wip-move-make-options-up f2099ec Moved the check for cmake's DO_NOT_DELAY_TAG_CALC to the top level, so it will affect how tests are built. 437b247 Merge pull request #32 from ceph/wip_add_void_comments 18dd014 Add documentation as to why there are empty void references. 3ddfa39 Merge pull request #28 from Yan-waller/wip-waller-0710dmclockgettime 57520df Merge pull request #31 from dingdangzhang/master 4cad292 delete redundant break statement b179f3b Merge pull request #29 from tchaikov/wip-cmake 76d5f35 cmake: build gtest if not found 9896fef Merge pull request #30 from tchaikov/wip-move d72fac1 do FRIEND_TEST manually f4b155d enforce move semantics of request types 8a2ad2a replace gettimeofday() with clock_gettime() function b84ccf9 Merge pull request #27 from ceph/joelin-master-ei 34a6e25 Set compiler flags at higher level CMakeLists.txt file, so they apply to sim and test, and so earlier versions of GCC know to use c++11 standard. Clean up cmake files in general. bad581a Move the PrCtl data structure into a separate header file that can be included where needed in the future. Also, to avoid potential naming conflicts with ceph's PrCtl.h, prefix the filename with "dmc". 1b227bf Merge pull request #25 from badone/wip-test_dmclock_server-coredump ee1866e dmclock: Don't dump core when using EXPECT_DEATH_IF_SUPPORTED git-subtree-dir: src/dmclock git-subtree-split: 3408cb8f3c20d1956d8a08f15958627fbb60e733 --- CMakeLists.txt | 15 ++++++-- cmake/modules/BuildGTest.cmake | 67 ++++++++++++++++++++++++++++++++++ sim/src/sim_client.h | 7 ++-- sim/src/sim_server.h | 8 ++-- sim/src/ssched/ssched_server.h | 5 ++- sim/src/test_dmclock_main.cc | 4 +- sim/src/test_ssched_main.cc | 4 +- src/CMakeLists.txt | 18 +-------- src/dmclock_client.h | 5 +-- src/dmclock_server.h | 45 +++++++++++------------ src/dmclock_util.h | 12 +++++- test/CMakeLists.txt | 6 +++ test/dmcPrCtl.h | 42 +++++++++++++++++++++ test/dmtest-config.h.in | 2 + test/test_dmclock_server.cc | 35 +++++++++--------- 15 files changed, 197 insertions(+), 78 deletions(-) create mode 100644 cmake/modules/BuildGTest.cmake create mode 100644 test/dmcPrCtl.h create mode 100644 test/dmtest-config.h.in diff --git a/CMakeLists.txt b/CMakeLists.txt index 9444ea1e96afd..d133bc6b01506 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,9 +2,19 @@ cmake_minimum_required(VERSION 2.8.11) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/modules") +set(CMAKE_CXX_FLAGS + "${CMAKE_CXX_FLAGS} -std=c++11 -Wno-write-strings -Wall -pthread") + +if(DO_NOT_DELAY_TAG_CALC) + add_definitions(-DDO_NOT_DELAY_TAG_CALC) +endif() + if (NOT(TARGET gtest AND TARGET gtest_main)) - if(NOT(GTEST_FOUND)) - find_package(GTest REQUIRED) + if (NOT GTEST_FOUND) + find_package(GTest QUIET) + if (NOT GTEST_FOUND) + include(BuildGTest) + endif() endif() endif() @@ -12,7 +22,6 @@ if (NOT(BOOST_FOUND)) find_package(Boost REQUIRED) endif() -# add_subdirectory(support/src) add_subdirectory(src) add_subdirectory(sim) diff --git a/cmake/modules/BuildGTest.cmake b/cmake/modules/BuildGTest.cmake new file mode 100644 index 0000000000000..356c7d5ab31dc --- /dev/null +++ b/cmake/modules/BuildGTest.cmake @@ -0,0 +1,67 @@ +macro(_build_gtest gtest_root) + include(ExternalProject) + ExternalProject_Add(googletest + SOURCE_DIR ${gtest_root} + CMAKE_ARGS -DBUILD_GMOCK=OFF -DBUILD_GTEST=ON + INSTALL_COMMAND "" + LOG_CONFIGURE ON + LOG_BUILD ON) + + ExternalProject_Get_Property(googletest source_dir) + set(GTEST_INCLUDE_DIRS ${source_dir}/googletest/include) + set(GMOCK_INCLUDE_DIRS ${source_dir}/googlemock/include) + + find_package(Threads REQUIRED) + + ExternalProject_Get_Property(googletest binary_dir) + set(GTEST_LIBRARY_PATH ${binary_dir}/googletest/${CMAKE_FIND_LIBRARY_PREFIXES}gtest.a) + set(GTEST_LIBRARY gtest) + add_library(${GTEST_LIBRARY} STATIC IMPORTED) + set_target_properties(${GTEST_LIBRARY} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIRS}" + IMPORTED_LOCATION ${GTEST_LIBRARY_PATH} + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LINK_INTERFACE_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) + add_dependencies(${GTEST_LIBRARY} googletest) + set(GTEST_LIBRARIES ${GTEST_LIBRARY}) + + set(GTEST_MAIN_LIBRARY_PATH ${binary_dir}/googletest/${CMAKE_FIND_LIBRARY_PREFIXES}gtest_main.a) + set(GTEST_MAIN_LIBRARY gtest_main) + add_library(${GTEST_MAIN_LIBRARY} STATIC IMPORTED) + set_target_properties(${GTEST_MAIN_LIBRARY} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIRS}" + IMPORTED_LOCATION ${GTEST_MAIN_LIBRARY_PATH} + IMPORTED_LINK_INTERFACE_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) + add_dependencies(${GTEST_MAIN_LIBRARY} googletest) + + set(GMOCK_LIBRARY_PATH ${binary_dir}/googlemock/${CMAKE_FIND_LIBRARY_PREFIXES}gmock.a) + set(GMOCK_LIBRARY gmock) + add_library(${GMOCK_LIBRARY} STATIC IMPORTED) + set_target_properties(${GMOCK_LIBRARY} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${GMOCK_INCLUDE_DIRS}" + IMPORTED_LOCATION "${GMOCK_LIBRARY_PATH}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LINK_INTERFACE_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) + add_dependencies(${GMOCK_LIBRARY} googletest) + + set(GMOCK_MAIN_LIBRARY_PATH ${binary_dir}/googlemock/${CMAKE_FIND_LIBRARY_PREFIXES}gmock_main.a) + set(GMOCK_MAIN_LIBRARY gmock_main) + add_library(${GMOCK_MAIN_LIBRARY} STATIC IMPORTED) + set_target_properties(${GMOCK_MAIN_LIBRARY} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${GMOCK_INCLUDE_DIRS}" + IMPORTED_LOCATION ${GMOCK_MAIN_LIBRARY_PATH} + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LINK_INTERFACE_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) + add_dependencies(${GMOCK_MAIN_LIBRARY} ${GTEST_LIBRARY}) +endmacro() + +find_path(GTEST_ROOT src/gtest.cc + HINTS $ENV{GTEST_ROOT} + PATHS /usr/src/googletest/googletest /usr/src/gtest) + +if(EXISTS ${GTEST_ROOT}) + message(STATUS "Found googletest: ${GTEST_ROOT}") + _build_gtest(${GTEST_ROOT}) +else() + message(SEND_ERROR "Could NOT find googletest") +endif() diff --git a/sim/src/sim_client.h b/sim/src/sim_client.h index 6538dab2c0811..fd4a81c76dac1 100644 --- a/sim/src/sim_client.h +++ b/sim/src/sim_client.h @@ -89,7 +89,7 @@ namespace crimson { using SubmitFunc = std::function; @@ -240,8 +240,9 @@ namespace crimson { count_stats(internal_stats.mtx, internal_stats.get_req_params_count); - TestRequest req(server, o, 12); - submit_f(server, req, id, rp); + submit_f(server, + TestRequest{server, static_cast(o), 12}, + id, rp); ++outstanding_ops; l.lock(); // lock for return to top of loop diff --git a/sim/src/sim_server.h b/sim/src/sim_server.h index e318d6e90ac32..42b5269d78032 100644 --- a/sim/src/sim_server.h +++ b/sim/src/sim_server.h @@ -147,14 +147,15 @@ namespace crimson { delete priority_queue; } - void post(const TestRequest& request, + void post(TestRequest&& request, const ClientId& client_id, const ReqPm& req_params) { time_stats(internal_stats.mtx, internal_stats.add_request_time, [&](){ - priority_queue->add_request(request, client_id, req_params); + priority_queue->add_request(std::move(request), + client_id, req_params); }); count_stats(internal_stats.mtx, internal_stats.add_request_count); @@ -202,10 +203,9 @@ namespace crimson { // notify server of completion std::this_thread::sleep_for(op_time); - TestResponse resp(req->epoch); // TODO: rather than assuming this constructor exists, perhaps // pass in a function that does this mapping? - client_resp_f(client, resp, id, additional); + client_resp_f(client, TestResponse{req->epoch}, id, additional); time_stats(internal_stats.mtx, internal_stats.request_complete_time, diff --git a/sim/src/ssched/ssched_server.h b/sim/src/ssched/ssched_server.h index ee4c1e6e3efff..610c2ef665c43 100644 --- a/sim/src/ssched/ssched_server.h +++ b/sim/src/ssched/ssched_server.h @@ -100,10 +100,11 @@ namespace crimson { finishing = true; } - void add_request(const R& request, + void add_request(R&& request, const C& client_id, const ReqParams& req_params) { - add_request(RequestRef(new R(request)), client_id, req_params); + add_request(RequestRef(new R(std::move(request))), + client_id, req_params); } void add_request(RequestRef&& request, diff --git a/sim/src/test_dmclock_main.cc b/sim/src/test_dmclock_main.cc index 668869b8d72fb..57b733e860ced 100644 --- a/sim/src/test_dmclock_main.cc +++ b/sim/src/test_dmclock_main.cc @@ -136,11 +136,11 @@ int main(int argc, char* argv[]) { // lambda to post a request to the identified server; called by client test::SubmitFunc server_post_f = [&simulation](const ServerId& server, - const sim::TestRequest& request, + sim::TestRequest&& request, const ClientId& client_id, const test::dmc::ReqParams& req_params) { test::DmcServer& s = simulation->get_server(server); - s.post(request, client_id, req_params); + s.post(std::move(request), client_id, req_params); }; std::vector> cli_inst; diff --git a/sim/src/test_ssched_main.cc b/sim/src/test_ssched_main.cc index 6df20dc5f896e..14ff7e9b47040 100644 --- a/sim/src/test_ssched_main.cc +++ b/sim/src/test_ssched_main.cc @@ -67,11 +67,11 @@ int main(int argc, char* argv[]) { // lambda to post a request to the identified server; called by client test::SubmitFunc server_post_f = [&simulation](const ServerId& server_id, - const sim::TestRequest& request, + sim::TestRequest&& request, const ClientId& client_id, const ssched::ReqParams& req_params) { auto& server = simulation->get_server(server_id); - server.post(request, client_id, req_params); + server.post(std::move(request), client_id, req_params); }; static std::vector no_wait = diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 7178f266e2a41..65d09f6a46915 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -2,23 +2,9 @@ include_directories(${GTEST_INCLUDE_DIRS}) include_directories(${Boost_INCLUDE_DIRS}) include_directories(../support/src) -set(local_flags "-std=c++11 -Wno-write-strings -Wall -pthread") - -if(DO_NOT_DELAY_TAG_CALC) - set(local_flags "${local_flags} -DDO_NOT_DELAY_TAG_CALC") -endif() +set(CMAKE_CXX_FLAGS + "${CMAKE_CXX_FLAGS} -std=c++11 -Wno-write-strings -Wall -pthread") set(dmc_srcs dmclock_util.cc ../support/src/run_every.cc) -set_source_files_properties(${dmc_srcs} - PROPERTIES - COMPILE_FLAGS "${local_flags}" - ) - -if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") - set(warnings_off " -Wno-unused-variable -Wno-unused-function") -elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - set(warnings_off " -Wno-unused-but-set-variable -Wno-unused-function") -endif() - add_library(dmclock STATIC ${dmc_srcs}) diff --git a/src/dmclock_client.h b/src/dmclock_client.h index b44e1211b53f6..92f4cf83bb1ab 100644 --- a/src/dmclock_client.h +++ b/src/dmclock_client.h @@ -19,8 +19,6 @@ #include "dmclock_util.h" #include "dmclock_recs.h" -#include "gtest/gtest_prod.h" - namespace crimson { namespace dmclock { @@ -57,7 +55,8 @@ namespace crimson { // S is server identifier type template class ServiceTracker { - FRIEND_TEST(dmclock_client, server_erase); + // we don't want to include gtest.h just for FRIEND_TEST + friend class dmclock_client_server_erase_Test; using TimePoint = decltype(std::chrono::steady_clock::now()); using Duration = std::chrono::milliseconds; diff --git a/src/dmclock_server.h b/src/dmclock_server.h index 8aaad39772648..2c9940dc6c17f 100644 --- a/src/dmclock_server.h +++ b/src/dmclock_server.h @@ -50,8 +50,6 @@ #include "profile.h" #endif -#include "gtest/gtest_prod.h" - namespace crimson { @@ -235,7 +233,8 @@ namespace crimson { // branching factor template class PriorityQueueBase { - FRIEND_TEST(dmclock_server, client_idle_erase); + // we don't want to include gtest.h just for FRIEND_TEST + friend class dmclock_server_client_idle_erase_Test; public: @@ -371,12 +370,12 @@ namespace crimson { // NB: because a deque is the underlying structure, this // operation might be expensive - bool remove_by_req_filter_fw(std::function filter_accum) { + bool remove_by_req_filter_fw(std::function filter_accum) { bool any_removed = false; for (auto i = requests.begin(); i != requests.end(); /* no inc */) { - if (filter_accum(*i->request)) { + if (filter_accum(std::move(*i->request))) { any_removed = true; i = requests.erase(i); } else { @@ -388,12 +387,12 @@ namespace crimson { // NB: because a deque is the underlying structure, this // operation might be expensive - bool remove_by_req_filter_bw(std::function filter_accum) { + bool remove_by_req_filter_bw(std::function filter_accum) { bool any_removed = false; for (auto i = requests.rbegin(); i != requests.rend(); /* no inc */) { - if (filter_accum(*i->request)) { + if (filter_accum(std::move(*i->request))) { any_removed = true; i = decltype(i){ requests.erase(std::next(i).base()) }; } else { @@ -404,7 +403,7 @@ namespace crimson { } inline bool - remove_by_req_filter(std::function filter_accum, + remove_by_req_filter(std::function filter_accum, bool visit_backwards) { if (visit_backwards) { return remove_by_req_filter_bw(filter_accum); @@ -478,7 +477,7 @@ namespace crimson { } - bool remove_by_req_filter(std::function filter_accum, + bool remove_by_req_filter(std::function filter_accum, bool visit_backwards = false) { bool any_removed = false; DataGuard g(data_mtx); @@ -500,14 +499,14 @@ namespace crimson { // use as a default value when no accumulator is provide - static void request_sink(const R& req) { + static void request_sink(R&& req) { // do nothing } void remove_by_client(const C& client, bool reverse = false, - std::function accum = request_sink) { + std::function accum = request_sink) { DataGuard g(data_mtx); auto i = client_map.find(client); @@ -518,13 +517,13 @@ namespace crimson { for (auto j = i->second->requests.rbegin(); j != i->second->requests.rend(); ++j) { - accum(*j->request); + accum(std::move(*j->request)); } } else { for (auto j = i->second->requests.begin(); j != i->second->requests.end(); ++j) { - accum(*j->request); + accum(std::move(*j->request)); } } @@ -881,7 +880,9 @@ namespace crimson { ClientRec& top = heap.top(); RequestRef request = std::move(top.next_request().request); +#ifndef DO_NOT_DELAY_TAG_CALC RequestTag tag = top.next_request().tag; +#endif // pop request and adjust heaps top.pop_request(); @@ -1162,11 +1163,11 @@ namespace crimson { } - inline void add_request(const R& request, + inline void add_request(R&& request, const C& client_id, const ReqParams& req_params, double addl_cost = 0.0) { - add_request(typename super::RequestRef(new R(request)), + add_request(typename super::RequestRef(new R(std::move(request))), client_id, req_params, get_time(), @@ -1174,11 +1175,11 @@ namespace crimson { } - inline void add_request(const R& request, + inline void add_request(R&& request, const C& client_id, double addl_cost = 0.0) { static const ReqParams null_req_params; - add_request(typename super::RequestRef(new R(request)), + add_request(typename super::RequestRef(new R(std::move(request))), client_id, null_req_params, get_time(), @@ -1187,12 +1188,12 @@ namespace crimson { - inline void add_request_time(const R& request, + inline void add_request_time(R&& request, const C& client_id, const ReqParams& req_params, const Time time, double addl_cost = 0.0) { - add_request(typename super::RequestRef(new R(request)), + add_request(typename super::RequestRef(new R(std::move(request))), client_id, req_params, time, @@ -1255,11 +1256,9 @@ namespace crimson { switch(next.type) { case super::NextReqType::none: return result; - break; case super::NextReqType::future: result.data = next.when_ready; return result; - break; case super::NextReqType::returning: // to avoid nesting, break out and let code below handle this case break; @@ -1402,11 +1401,11 @@ namespace crimson { public: - inline void add_request(const R& request, + inline void add_request(R&& request, const C& client_id, const ReqParams& req_params, double addl_cost = 0.0) { - add_request(typename super::RequestRef(new R(request)), + add_request(typename super::RequestRef(new R(std::move(request))), client_id, req_params, get_time(), diff --git a/src/dmclock_util.h b/src/dmclock_util.h index d12c6f9eb63c9..c46d09f39319a 100644 --- a/src/dmclock_util.h +++ b/src/dmclock_util.h @@ -30,11 +30,19 @@ namespace crimson { inline Time get_time() { +#if defined(__linux__) + struct timespec now; + auto result = clock_gettime(CLOCK_REALTIME, &now); + (void) result; // reference result in case assert is compiled out + assert(0 == result); + return now.tv_sec + (now.tv_nsec / 1.0e9); +#else struct timeval now; auto result = gettimeofday(&now, NULL); - (void) result; + (void) result; // reference result in case assert is compiled out assert(0 == result); - return now.tv_sec + (now.tv_usec / 1000000.0); + return now.tv_sec + (now.tv_usec / 1.0e6); +#endif } std::string format_time(const Time& time, uint modulo = 1000); diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 24da2e7320a5d..aff35d5d77581 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,3 +1,8 @@ +INCLUDE (CheckIncludeFiles) +CHECK_INCLUDE_FILES("sys/prctl.h" HAVE_SYS_PRCTL_H) +CONFIGURE_FILE(dmtest-config.h.in dmtest-config.h) + +include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(../src) include_directories(../support/src) include_directories(../sim/src) @@ -15,6 +20,7 @@ set_source_files_properties(${core_srcs} ${test_srcs} ) add_executable(dmclock-tests ${test_srcs} ${support_srcs}) +target_include_directories(dmclock-tests PRIVATE "${GTEST_INCLUDE_DIRS}") if (TARGET gtest AND TARGET gtest_main) add_dependencies(dmclock-tests gtest gtest_main) diff --git a/test/dmcPrCtl.h b/test/dmcPrCtl.h new file mode 100644 index 0000000000000..39f98293dfda2 --- /dev/null +++ b/test/dmcPrCtl.h @@ -0,0 +1,42 @@ +// essentially the same as ceph's PrCtl.h, copied into the dmclock library + +#include +#ifdef HAVE_SYS_PRCTL_H +#include +#include +#include + +struct PrCtl { + int saved_state = -1; + int set_dumpable(int new_state) { + int r = prctl(PR_SET_DUMPABLE, new_state); + if (r) { + r = -errno; + std::cerr << "warning: unable to " << (new_state ? "set" : "unset") + << " dumpable flag: " << strerror(r) + << std::endl; + } + return r; + } + PrCtl(int new_state = 0) { + int r = prctl(PR_GET_DUMPABLE); + if (r == -1) { + r = errno; + std::cerr << "warning: unable to get dumpable flag: " << strerror(r) + << std::endl; + } else if (r != new_state) { + if (!set_dumpable(new_state)) { + saved_state = r; + } + } + } + ~PrCtl() { + if (saved_state < 0) { + return; + } + set_dumpable(saved_state); + } +}; +#else +struct PrCtl {}; +#endif diff --git a/test/dmtest-config.h.in b/test/dmtest-config.h.in new file mode 100644 index 0000000000000..ecd2044a89a58 --- /dev/null +++ b/test/dmtest-config.h.in @@ -0,0 +1,2 @@ +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_PRCTL_H 1 diff --git a/test/test_dmclock_server.cc b/test/test_dmclock_server.cc index 4555e377323e9..95def410fb69f 100644 --- a/test/test_dmclock_server.cc +++ b/test/test_dmclock_server.cc @@ -16,6 +16,9 @@ #include "dmclock_util.h" #include "gtest/gtest.h" +// process control to prevent core dumps during gtest death tests +#include "dmcPrCtl.h" + namespace dmc = crimson::dmclock; @@ -61,17 +64,19 @@ namespace crimson { }; QueueRef pq(new Queue(client_info_f, false)); - Request req; ReqParams req_params(1,1); - EXPECT_DEATH_IF_SUPPORTED(pq->add_request(req, client1, req_params), + // Disable coredumps + PrCtl unset_dumpable; + + EXPECT_DEATH_IF_SUPPORTED(pq->add_request(Request{}, client1, req_params), "Assertion.*reservation.*max_tag.*" "proportion.*max_tag") << "we should fail if a client tries to generate a reservation tag " "where reservation and proportion are both 0"; - EXPECT_DEATH_IF_SUPPORTED(pq->add_request(req, client2, req_params), + EXPECT_DEATH_IF_SUPPORTED(pq->add_request(Request{}, client2, req_params), "Assertion.*reservation.*max_tag.*" "proportion.*max_tag") << "we should fail if a client tries to generate a reservation tag " @@ -548,14 +553,13 @@ namespace crimson { pq = QueueRef(new Queue(client_info_f, false)); - Request req; ReqParams req_params(1,1); auto now = dmc::get_time(); for (int i = 0; i < 5; ++i) { - pq->add_request(req, client1, req_params); - pq->add_request(req, client2, req_params); + pq->add_request(Request{}, client1, req_params); + pq->add_request(Request{}, client2, req_params); now += 0.0001; } @@ -602,15 +606,14 @@ namespace crimson { QueueRef pq(new Queue(client_info_f, false)); - Request req; ReqParams req_params(1,1); // make sure all times are well before now auto old_time = dmc::get_time() - 100.0; for (int i = 0; i < 5; ++i) { - pq->add_request_time(req, client1, req_params, old_time); - pq->add_request_time(req, client2, req_params, old_time); + pq->add_request_time(Request{}, client1, req_params, old_time); + pq->add_request_time(Request{}, client2, req_params, old_time); old_time += 0.001; } @@ -661,7 +664,6 @@ namespace crimson { QueueRef pq(new Queue(client_info_f, false)); - Request req; ReqParams req_params(1,1); // make sure all times are well before now @@ -669,8 +671,8 @@ namespace crimson { // add six requests; for same client reservations spaced one apart for (int i = 0; i < 3; ++i) { - pq->add_request_time(req, client1, req_params, start_time); - pq->add_request_time(req, client2, req_params, start_time); + pq->add_request_time(Request{}, client1, req_params, start_time); + pq->add_request_time(Request{}, client2, req_params, start_time); } Queue::PullReq pr = pq->pull_request(start_time + 0.5); @@ -744,13 +746,12 @@ namespace crimson { QueueRef pq(new Queue(client_info_f, false)); - Request req; ReqParams req_params(1,1); // make sure all times are well before now auto now = dmc::get_time(); - pq->add_request_time(req, client1, req_params, now + 100); + pq->add_request_time(Request{}, client1, req_params, now + 100); Queue::PullReq pr = pq->pull_request(now); EXPECT_EQ(Queue::NextReqType::future, pr.type); @@ -776,13 +777,12 @@ namespace crimson { QueueRef pq(new Queue(client_info_f, true)); - Request req; ReqParams req_params(1,1); // make sure all times are well before now auto now = dmc::get_time(); - pq->add_request_time(req, client1, req_params, now + 100); + pq->add_request_time(Request{}, client1, req_params, now + 100); Queue::PullReq pr = pq->pull_request(now); EXPECT_EQ(Queue::NextReqType::returning, pr.type); @@ -808,13 +808,12 @@ namespace crimson { QueueRef pq(new Queue(client_info_f, true)); - Request req; ReqParams req_params(1,1); // make sure all times are well before now auto now = dmc::get_time(); - pq->add_request_time(req, client1, req_params, now + 100); + pq->add_request_time(Request{}, client1, req_params, now + 100); Queue::PullReq pr = pq->pull_request(now); EXPECT_EQ(Queue::NextReqType::returning, pr.type); -- 2.39.5