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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/basictypes.h"
#include "base/bind.h"
#include "base/memory/weak_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/test/perf_time_logger.h"
#include "net/base/io_buffer.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_errors.h"
#include "net/base/net_util.h"
#include "net/base/test_completion_callback.h"
#include "net/log/net_log_unittest.h"
#include "net/test/net_test_suite.h"
#include "net/udp/udp_client_socket.h"
#include "net/udp/udp_server_socket.h"
#include "net/udp/udp_socket.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
namespace net {
namespace {
class UDPSocketPerfTest : public PlatformTest {
public:
UDPSocketPerfTest()
: buffer_(new IOBufferWithSize(kPacketSize)), weak_factory_(this) {}
void DoneWritePacketsToSocket(UDPClientSocket* socket,
int num_of_packets,
base::Closure done_callback,
int error) {
WritePacketsToSocket(socket, num_of_packets, done_callback);
}
// Send |num_of_packets| to |socket|. Invoke |done_callback| when done.
void WritePacketsToSocket(UDPClientSocket* socket,
int num_of_packets,
base::Closure done_callback);
// Use non-blocking IO if |use_nonblocking_io| is true. This variable only
// has effect on Windows.
void WriteBenchmark(bool use_nonblocking_io);
protected:
static const int kPacketSize = 1024;
scoped_refptr<IOBufferWithSize> buffer_;
base::WeakPtrFactory<UDPSocketPerfTest> weak_factory_;
};
// Creates and address from an ip/port and returns it in |address|.
void CreateUDPAddress(std::string ip_str, uint16 port, IPEndPoint* address) {
IPAddressNumber ip_number;
bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
if (!rv)
return;
*address = IPEndPoint(ip_number, port);
}
void UDPSocketPerfTest::WritePacketsToSocket(UDPClientSocket* socket,
int num_of_packets,
base::Closure done_callback) {
scoped_refptr<IOBufferWithSize> io_buffer(new IOBufferWithSize(kPacketSize));
memset(io_buffer->data(), 'G', kPacketSize);
while (num_of_packets) {
int rv =
socket->Write(io_buffer.get(), io_buffer->size(),
base::Bind(&UDPSocketPerfTest::DoneWritePacketsToSocket,
weak_factory_.GetWeakPtr(), socket,
num_of_packets - 1, done_callback));
if (rv == ERR_IO_PENDING)
break;
--num_of_packets;
}
if (!num_of_packets) {
done_callback.Run();
return;
}
}
void UDPSocketPerfTest::WriteBenchmark(bool use_nonblocking_io) {
base::MessageLoopForIO message_loop;
const uint16 kPort = 9999;
// Setup the server to listen.
IPEndPoint bind_address;
CreateUDPAddress("127.0.0.1", kPort, &bind_address);
TestNetLog server_log;
scoped_ptr<UDPServerSocket> server(
new UDPServerSocket(&server_log, NetLog::Source()));
#if defined(OS_WIN)
if (use_nonblocking_io)
server->UseNonBlockingIO();
#endif
int rv = server->Listen(bind_address);
ASSERT_EQ(OK, rv);
// Setup the client.
IPEndPoint server_address;
CreateUDPAddress("127.0.0.1", kPort, &server_address);
TestNetLog client_log;
scoped_ptr<UDPClientSocket> client(
new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
&client_log, NetLog::Source()));
#if defined(OS_WIN)
if (use_nonblocking_io)
client->UseNonBlockingIO();
#endif
rv = client->Connect(server_address);
EXPECT_EQ(OK, rv);
base::RunLoop run_loop;
base::TimeTicks start_ticks = base::TimeTicks::Now();
int packets = 100000;
client->SetSendBufferSize(1024);
WritePacketsToSocket(client.get(), packets, run_loop.QuitClosure());
run_loop.Run();
double elapsed = (base::TimeTicks::Now() - start_ticks).InSecondsF();
LOG(INFO) << "Write speed: " << packets / 1024 / elapsed << " MB/s";
}
TEST_F(UDPSocketPerfTest, Write) {
base::PerfTimeLogger timer("UDP_socket_write");
WriteBenchmark(false);
}
#if defined(OS_WIN)
TEST_F(UDPSocketPerfTest, WriteNonBlocking) {
base::PerfTimeLogger timer("UDP_socket_write_nonblocking");
WriteBenchmark(true);
}
#endif
} // namespace
} // namespace net
|
