1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
5 * Copyright (C) 2016 Red Hat Inc.
9 #include "test_ssched.h"
17 namespace test
= crimson::test_simple_scheduler
;
18 namespace ssched
= crimson::simple_scheduler
;
19 namespace sim
= crimson::qos_simulation
;
21 using namespace std::placeholders
;
25 namespace test_simple_scheduler
{
26 void client_data(std::ostream
& out
,
28 test::MySim::ClientFilter client_disp_filter
,
29 int head_w
, int data_w
, int data_prec
);
31 void server_data(std::ostream
& out
,
33 test::MySim::ServerFilter server_disp_filter
,
34 int head_w
, int data_w
, int data_prec
);
35 } // namespace test_simple
36 } // namespace crimson
39 int main(int argc
, char* argv
[]) {
42 const uint server_count
= 100;
43 const uint server_iops
= 40;
44 const uint server_threads
= 1;
48 const uint client_total_ops
= 1000;
49 const uint client_count
= 100;
50 const uint client_server_select_range
= 10;
51 const uint client_wait_count
= 1;
52 const uint client_iops_goal
= 50;
53 const uint client_outstanding_ops
= 100;
54 const std::chrono::seconds
client_wait(10);
56 auto client_disp_filter
= [=] (const ClientId
& i
) -> bool {
57 return i
< 3 || i
>= (client_count
- 3);
60 auto server_disp_filter
= [=] (const ServerId
& i
) -> bool {
61 return i
< 3 || i
>= (server_count
- 3);
65 test::MySim
*simulation
;
67 // lambda to post a request to the identified server; called by client
68 test::SubmitFunc server_post_f
=
69 [&simulation
](const ServerId
& server_id
,
70 const sim::TestRequest
& request
,
71 const ClientId
& client_id
,
72 const ssched::ReqParams
& req_params
) {
73 auto& server
= simulation
->get_server(server_id
);
74 server
.post(request
, client_id
, req_params
);
77 static std::vector
<sim::CliInst
> no_wait
=
78 { { sim::req_op
, client_total_ops
, client_iops_goal
, client_outstanding_ops
} };
79 static std::vector
<sim::CliInst
> wait
=
80 { { sim::wait_op
, client_wait
},
81 { sim::req_op
, client_total_ops
, client_iops_goal
, client_outstanding_ops
} };
83 simulation
= new test::MySim();
86 test::MySim::ClientBasedServerSelectFunc server_select_f
=
87 simulation
->make_server_select_alt_range(client_server_select_range
);
89 test::MySim::ClientBasedServerSelectFunc server_select_f
=
90 std::bind(&test::MySim::server_select_random
, simulation
, _1
, _2
);
92 test::MySim::ClientBasedServerSelectFunc server_select_f
=
93 std::bind(&test::MySim::server_select_0
, simulation
, _1
, _2
);
96 test::SimpleServer::ClientRespFunc client_response_f
=
97 [&simulation
](ClientId client_id
,
98 const sim::TestResponse
& resp
,
99 const ServerId
& server_id
,
100 const ssched::NullData
& resp_params
) {
101 simulation
->get_client(client_id
).receive_response(resp
,
106 test::CreateQueueF create_queue_f
=
107 [&](test::SimpleQueue::CanHandleRequestFunc can_f
,
108 test::SimpleQueue::HandleRequestFunc handle_f
) -> test::SimpleQueue
* {
109 return new test::SimpleQueue(can_f
, handle_f
);
112 auto create_server_f
= [&](ServerId id
) -> test::SimpleServer
* {
113 return new test::SimpleServer(id
,
114 server_iops
, server_threads
,
116 test::simple_server_accumulate_f
,
120 auto create_client_f
= [&](ClientId id
) -> test::SimpleClient
* {
121 return new test::SimpleClient(id
,
123 std::bind(server_select_f
, _1
, id
),
124 test::simple_client_accumulate_f
,
125 id
< (client_count
- client_wait_count
)
129 simulation
->add_servers(server_count
, create_server_f
);
130 simulation
->add_clients(client_count
, create_client_f
);
133 simulation
->display_stats(std::cout
,
134 &test::server_data
, &test::client_data
,
135 server_disp_filter
, client_disp_filter
);
139 void test::client_data(std::ostream
& out
,
141 test::MySim::ClientFilter client_disp_filter
,
142 int head_w
, int data_w
, int data_prec
) {
147 void test::server_data(std::ostream
& out
,
149 test::MySim::ServerFilter server_disp_filter
,
150 int head_w
, int data_w
, int data_prec
) {
151 out
<< std::setw(head_w
) << "requests:";
153 for (uint i
= 0; i
< sim
->get_server_count(); ++i
) {
154 const auto& server
= sim
->get_server(i
);
155 auto req_count
= server
.get_accumulator().request_count
;
156 total_req
+= req_count
;
157 if (!server_disp_filter(i
)) continue;
158 out
<< std::setw(data_w
) << req_count
;
160 out
<< std::setw(data_w
) << std::setprecision(data_prec
) <<
161 std::fixed
<< total_req
<< std::endl
;
164 crimson::ProfileCombiner
<std::chrono::nanoseconds
> art_combiner
;
165 crimson::ProfileCombiner
<std::chrono::nanoseconds
> rct_combiner
;
166 for (uint i
= 0; i
< sim
->get_server_count(); ++i
) {
167 const auto& q
= sim
->get_server(i
).get_priority_queue();
168 const auto& art
= q
.add_request_timer
;
169 art_combiner
.combine(art
);
170 const auto& rct
= q
.request_complete_timer
;
171 rct_combiner
.combine(rct
);
173 out
<< "Server add_request_timer: count:" << art_combiner
.get_count() <<
174 ", mean:" << art_combiner
.get_mean() <<
175 ", std_dev:" << art_combiner
.get_std_dev() <<
176 ", low:" << art_combiner
.get_low() <<
177 ", high:" << art_combiner
.get_high() << std::endl
;
178 out
<< "Server request_complete_timer: count:" << rct_combiner
.get_count() <<
179 ", mean:" << rct_combiner
.get_mean() <<
180 ", std_dev:" << rct_combiner
.get_std_dev() <<
181 ", low:" << rct_combiner
.get_low() <<
182 ", high:" << rct_combiner
.get_high() << std::endl
;
183 out
<< "Server combined mean: " <<
184 (art_combiner
.get_mean() + rct_combiner
.get_mean()) <<