1 // Copyright 2015 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/functional/bind.h"
6 #include "base/memory/weak_ptr.h"
7 #include "base/run_loop.h"
8 #include "base/test/task_environment.h"
9 #include "base/timer/elapsed_timer.h"
10 #include "net/base/io_buffer.h"
11 #include "net/base/ip_endpoint.h"
12 #include "net/base/net_errors.h"
13 #include "net/base/test_completion_callback.h"
14 #include "net/log/net_log_source.h"
15 #include "net/socket/udp_client_socket.h"
16 #include "net/socket/udp_server_socket.h"
17 #include "net/socket/udp_socket.h"
18 #include "net/test/gtest_util.h"
19 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
20 #include "testing/gmock/include/gmock/gmock.h"
21 #include "testing/gtest/include/gtest/gtest.h"
22 #include "testing/perf/perf_result_reporter.h"
23 #include "testing/platform_test.h"
24
25 using net::test::IsOk;
26
27 namespace net {
28
29 namespace {
30
31 static constexpr char kMetricPrefixUDPSocket[] = "UDPSocketWrite.";
32 static constexpr char kMetricElapsedTimeMs[] = "elapsed_time";
33 static constexpr char kMetricWriteSpeedBytesPerSecond[] = "write_speed";
34
SetUpUDPSocketReporter(const std::string & story)35 perf_test::PerfResultReporter SetUpUDPSocketReporter(const std::string& story) {
36 perf_test::PerfResultReporter reporter(kMetricPrefixUDPSocket, story);
37 reporter.RegisterImportantMetric(kMetricElapsedTimeMs, "ms");
38 reporter.RegisterImportantMetric(kMetricWriteSpeedBytesPerSecond,
39 "bytesPerSecond_biggerIsBetter");
40 return reporter;
41 }
42
43 class UDPSocketPerfTest : public PlatformTest {
44 public:
UDPSocketPerfTest()45 UDPSocketPerfTest()
46 : buffer_(base::MakeRefCounted<IOBufferWithSize>(kPacketSize)) {}
47
DoneWritePacketsToSocket(UDPClientSocket * socket,int num_of_packets,base::OnceClosure * done_callback,int error)48 void DoneWritePacketsToSocket(UDPClientSocket* socket,
49 int num_of_packets,
50 base::OnceClosure* done_callback,
51 int error) {
52 WritePacketsToSocket(socket, num_of_packets, done_callback);
53 }
54
55 // Send |num_of_packets| to |socket|. Invoke |done_callback| when done.
56 void WritePacketsToSocket(UDPClientSocket* socket,
57 int num_of_packets,
58 base::OnceClosure* done_callback);
59
60 // Use non-blocking IO if |use_nonblocking_io| is true. This variable only
61 // has effect on Windows.
62 void WriteBenchmark(bool use_nonblocking_io);
63
64 protected:
65 static const int kPacketSize = 1024;
66 scoped_refptr<IOBufferWithSize> buffer_;
67 base::WeakPtrFactory<UDPSocketPerfTest> weak_factory_{this};
68 };
69
70 const int UDPSocketPerfTest::kPacketSize;
71
72 // Creates and address from an ip/port and returns it in |address|.
CreateUDPAddress(const std::string & ip_str,uint16_t port,IPEndPoint * address)73 void CreateUDPAddress(const std::string& ip_str,
74 uint16_t port,
75 IPEndPoint* address) {
76 IPAddress ip_address;
77 if (!ip_address.AssignFromIPLiteral(ip_str))
78 return;
79 *address = IPEndPoint(ip_address, port);
80 }
81
WritePacketsToSocket(UDPClientSocket * socket,int num_of_packets,base::OnceClosure * done_callback)82 void UDPSocketPerfTest::WritePacketsToSocket(UDPClientSocket* socket,
83 int num_of_packets,
84 base::OnceClosure* done_callback) {
85 scoped_refptr<IOBufferWithSize> io_buffer =
86 base::MakeRefCounted<IOBufferWithSize>(kPacketSize);
87 memset(io_buffer->data(), 'G', kPacketSize);
88
89 while (num_of_packets) {
90 int rv = socket->Write(
91 io_buffer.get(), io_buffer->size(),
92 base::BindOnce(&UDPSocketPerfTest::DoneWritePacketsToSocket,
93 weak_factory_.GetWeakPtr(), socket, num_of_packets - 1,
94 done_callback),
95 TRAFFIC_ANNOTATION_FOR_TESTS);
96 if (rv == ERR_IO_PENDING)
97 break;
98 --num_of_packets;
99 }
100 if (!num_of_packets) {
101 std::move(*done_callback).Run();
102 return;
103 }
104 }
105
WriteBenchmark(bool use_nonblocking_io)106 void UDPSocketPerfTest::WriteBenchmark(bool use_nonblocking_io) {
107 base::ElapsedTimer total_elapsed_timer;
108 base::test::SingleThreadTaskEnvironment task_environment(
109 base::test::SingleThreadTaskEnvironment::MainThreadType::IO);
110 const uint16_t kPort = 9999;
111
112 // Setup the server to listen.
113 IPEndPoint bind_address;
114 CreateUDPAddress("127.0.0.1", kPort, &bind_address);
115 auto server = std::make_unique<UDPServerSocket>(nullptr, NetLogSource());
116 if (use_nonblocking_io)
117 server->UseNonBlockingIO();
118 int rv = server->Listen(bind_address);
119 ASSERT_THAT(rv, IsOk());
120
121 // Setup the client.
122 IPEndPoint server_address;
123 CreateUDPAddress("127.0.0.1", kPort, &server_address);
124 auto client = std::make_unique<UDPClientSocket>(DatagramSocket::DEFAULT_BIND,
125 nullptr, NetLogSource());
126 if (use_nonblocking_io)
127 client->UseNonBlockingIO();
128 rv = client->Connect(server_address);
129 EXPECT_THAT(rv, IsOk());
130
131 base::RunLoop run_loop;
132 base::OnceClosure done_callback = run_loop.QuitClosure();
133 base::ElapsedTimer write_elapsed_timer;
134 int packets = 100000;
135 client->SetSendBufferSize(1024);
136 WritePacketsToSocket(client.get(), packets, &done_callback);
137 run_loop.Run();
138
139 double write_elapsed = write_elapsed_timer.Elapsed().InSecondsF();
140 double total_elapsed = total_elapsed_timer.Elapsed().InMillisecondsF();
141 auto reporter =
142 SetUpUDPSocketReporter(use_nonblocking_io ? "nonblocking" : "blocking");
143 reporter.AddResult(kMetricElapsedTimeMs, total_elapsed);
144 reporter.AddResult(kMetricWriteSpeedBytesPerSecond,
145 packets * 1024 / write_elapsed);
146 }
147
TEST_F(UDPSocketPerfTest,Write)148 TEST_F(UDPSocketPerfTest, Write) {
149 WriteBenchmark(false);
150 }
151
TEST_F(UDPSocketPerfTest,WriteNonBlocking)152 TEST_F(UDPSocketPerfTest, WriteNonBlocking) {
153 WriteBenchmark(true);
154 }
155
156 } // namespace
157
158 } // namespace net
159