1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
//
// tcp_client.cpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/read.hpp>
#include <boost/asio/write.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/shared_ptr.hpp>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include "high_res_clock.hpp"
using boost::asio::ip::tcp;
using boost::posix_time::ptime;
using boost::posix_time::microsec_clock;
const int num_samples = 100000;
struct transfer_all
{
typedef std::size_t result_type;
std::size_t operator()(const boost::system::error_code& ec, std::size_t)
{
return (ec && ec != boost::asio::error::would_block) ? 0 : ~0;
}
};
int main(int argc, char* argv[])
{
if (argc != 6)
{
std::fprintf(stderr,
"Usage: tcp_client <ip> <port> "
"<nconns> <bufsize> {spin|block}\n");
return 1;
}
const char* ip = argv[1];
unsigned short port = static_cast<unsigned short>(std::atoi(argv[2]));
int num_connections = std::atoi(argv[3]);
std::size_t buf_size = static_cast<std::size_t>(std::atoi(argv[4]));
bool spin = (std::strcmp(argv[5], "spin") == 0);
boost::asio::io_service io_service;
std::vector<boost::shared_ptr<tcp::socket> > sockets;
for (int i = 0; i < num_connections; ++i)
{
boost::shared_ptr<tcp::socket> s(new tcp::socket(io_service));
tcp::endpoint target(boost::asio::ip::address::from_string(ip), port);
s->connect(target);
s->set_option(tcp::no_delay(true));
if (spin)
{
tcp::socket::non_blocking_io nbio(true);
s->io_control(nbio);
}
sockets.push_back(s);
}
std::vector<unsigned char> write_buf(buf_size);
std::vector<unsigned char> read_buf(buf_size);
ptime start = microsec_clock::universal_time();
boost::uint64_t start_hr = high_res_clock();
boost::uint64_t samples[num_samples];
for (int i = 0; i < num_samples; ++i)
{
tcp::socket& socket = *sockets[i % num_connections];
boost::uint64_t t = high_res_clock();
boost::system::error_code ec;
boost::asio::write(socket,
boost::asio::buffer(write_buf),
transfer_all(), ec);
boost::asio::read(socket,
boost::asio::buffer(read_buf),
transfer_all(), ec);
samples[i] = high_res_clock() - t;
}
ptime stop = microsec_clock::universal_time();
boost::uint64_t stop_hr = high_res_clock();
boost::uint64_t elapsed_usec = (stop - start).total_microseconds();
boost::uint64_t elapsed_hr = stop_hr - start_hr;
double scale = 1.0 * elapsed_usec / elapsed_hr;
std::sort(samples, samples + num_samples);
std::printf(" 0.0%%\t%f\n", samples[0] * scale);
std::printf(" 0.1%%\t%f\n", samples[num_samples / 1000 - 1] * scale);
std::printf(" 1.0%%\t%f\n", samples[num_samples / 100 - 1] * scale);
std::printf(" 10.0%%\t%f\n", samples[num_samples / 10 - 1] * scale);
std::printf(" 20.0%%\t%f\n", samples[num_samples * 2 / 10 - 1] * scale);
std::printf(" 30.0%%\t%f\n", samples[num_samples * 3 / 10 - 1] * scale);
std::printf(" 40.0%%\t%f\n", samples[num_samples * 4 / 10 - 1] * scale);
std::printf(" 50.0%%\t%f\n", samples[num_samples * 5 / 10 - 1] * scale);
std::printf(" 60.0%%\t%f\n", samples[num_samples * 6 / 10 - 1] * scale);
std::printf(" 70.0%%\t%f\n", samples[num_samples * 7 / 10 - 1] * scale);
std::printf(" 80.0%%\t%f\n", samples[num_samples * 8 / 10 - 1] * scale);
std::printf(" 90.0%%\t%f\n", samples[num_samples * 9 / 10 - 1] * scale);
std::printf(" 99.0%%\t%f\n", samples[num_samples * 99 / 100 - 1] * scale);
std::printf(" 99.9%%\t%f\n", samples[num_samples * 999 / 1000 - 1] * scale);
std::printf("100.0%%\t%f\n", samples[num_samples - 1] * scale);
double total = 0.0;
for (int i = 0; i < num_samples; ++i) total += samples[i] * scale;
std::printf(" mean\t%f\n", total / num_samples);
}
|
