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
|
// 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/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/test_completion_callback.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(const std::string& ip_str,
uint16_t port,
IPEndPoint* address) {
IPAddress ip_address;
if (!ip_address.AssignFromIPLiteral(ip_str))
return;
*address = IPEndPoint(ip_address, 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_t kPort = 9999;
// Setup the server to listen.
IPEndPoint bind_address;
CreateUDPAddress("127.0.0.1", kPort, &bind_address);
scoped_ptr<UDPServerSocket> server(
new UDPServerSocket(nullptr, 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);
scoped_ptr<UDPClientSocket> client(
new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
nullptr, 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
|
