Added queued SendTo/RecvFrom calls.

ppapi/tests/test_udp_socket_private.cc

Index: ppapi/tests/test_udp_socket_private.cc
diff --git a/ppapi/tests/test_udp_socket_private.cc b/ppapi/tests/test_udp_socket_private.cc
index 4680ff2a1390ff4cb091d6271262217cf6da383d..d5684ee15daf41ab4656cac44ce2a60e54cb46f4 100644
--- a/ppapi/tests/test_udp_socket_private.cc
+++ b/ppapi/tests/test_udp_socket_private.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <cstdio>
 #include <cstring>
 #include <vector>
 
@@ -58,6 +59,8 @@ void TestUDPSocketPrivate::RunTests(const std::string& filter) {
   RUN_TEST_FORCEASYNC_AND_NOT(ConnectFailure, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(Broadcast, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(SetSocketFeatureErrors, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(QueuedRequests, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(SequentialRequests, filter);
 }
 
 std::string TestUDPSocketPrivate::GetLocalAddress(
@@ -182,6 +185,135 @@ std::string TestUDPSocketPrivate::PassMessage(pp::UDPSocketPrivate* target,
   PASS();
 }
 
+std::string TestUDPSocketPrivate::BenchmarkQueuedRequests(size_t num_messages,
+                                                          size_t message_size,
+                                                          timeval* elapsed) {
+  pp::UDPSocketPrivate server_socket(instance_), client_socket(instance_);
+  PP_NetAddress_Private server_address, client_address;
+
+  ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&server_socket,
+                                                    &server_address));
+  ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&client_socket,
+                                                    &client_address));
+
+  std::vector<std::string> messages(num_messages);
+  for (size_t i = 0; i < num_messages; ++i)
+    messages[i].resize(message_size, 'a');
+
+  struct timeval tv_start;
+  gettimeofday(&tv_start, NULL);
+
+  std::vector<TestCompletionCallback*> sendto_callbacks(num_messages);
+  std::vector<int32_t> sendto_rv(num_messages);
+
+  std::vector<std::vector<char> > buffers(num_messages);
+  std::vector<TestCompletionCallback*> recvfrom_callbacks(num_messages);
+  std::vector<int32_t> recvfrom_rv(num_messages);
+
+  for (size_t i = 0; i < num_messages; ++i) {
+    sendto_callbacks[i] = new TestCompletionCallback(instance_->pp_instance(),
+                                                     force_async_);
+    sendto_rv[i] = client_socket.SendTo(messages[i].c_str(), messages[i].size(),
+                                        &server_address, *sendto_callbacks[i]);
+    if (force_async_ && sendto_rv[i] != PP_OK_COMPLETIONPENDING) {
+      return ReportError("PPB_UDPSocket_Private::SendTo force_async",
+                         sendto_rv[i]);
+    }
+
+    buffers[i].resize(messages[i].size());
+    recvfrom_callbacks[i] = new TestCompletionCallback(instance_->pp_instance(),
+                                                       force_async_);
+    recvfrom_rv[i] = server_socket.RecvFrom(&buffers[i][0], messages[i].size(),
+                                            *recvfrom_callbacks[i]);
+    if (force_async_ && recvfrom_rv[i] != PP_OK_COMPLETIONPENDING) {
+      return ReportError("PPB_UDPSocket_Private::RecvFrom force_async",
+                         recvfrom_rv[i]);
+    }
+  }
+
+  for (size_t i = 0; i < num_messages; ++i) {
+    if (recvfrom_rv[i] == PP_OK_COMPLETIONPENDING)
+      recvfrom_rv[i] = recvfrom_callbacks[i]->WaitForResult();
+    if (recvfrom_rv[i] < 0 ||
+        messages[i].size() != static_cast<size_t>(recvfrom_rv[i])) {
+      return ReportError("PPB_UDPSocket_Private::RecvFrom", recvfrom_rv[i]);
+    }
+
+    if (sendto_rv[i] == PP_OK_COMPLETIONPENDING)
+      sendto_rv[i] = sendto_callbacks[i]->WaitForResult();
+    if (sendto_rv[i] < 0 ||
+        messages[i].size() != static_cast<size_t>(sendto_rv[i])) {
+      return ReportError("PPB_UDPSocket_Private::SendTo", sendto_rv[i]);
+    }
+
+    ASSERT_EQ(messages[i], std::string(buffers[i].begin(), buffers[i].end()));
+  }
+
+  struct timeval tv_end;
+  gettimeofday(&tv_end, NULL);
+
+  long sec = tv_end.tv_sec - tv_start.tv_sec;
+  long usec = tv_end.tv_usec - tv_start.tv_usec;
+  if (usec < 0) {
+    --sec;
+    usec += 1000000;
+  }
+
+  elapsed->tv_sec = sec;
+  elapsed->tv_usec = usec;
+
+  for (size_t i = 0; i < num_messages; ++i) {
+    delete sendto_callbacks[i];
+    delete recvfrom_callbacks[i];
+  }
+
+  server_socket.Close();
+  client_socket.Close();
+  PASS();
+}
+
+std::string TestUDPSocketPrivate::BenchmarkSequentialRequests(
+    size_t num_messages,
+    size_t message_size,
+    timeval* elapsed) {
+  pp::UDPSocketPrivate server_socket(instance_), client_socket(instance_);
+  PP_NetAddress_Private server_address, client_address;
+
+  ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&server_socket,
+                                                    &server_address));
+  ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&client_socket,
+                                                    &client_address));
+  std::vector<std::string> messages(num_messages);
+  for (size_t i = 0; i < num_messages; ++i)
+    messages[i].resize(message_size, 'a');
+
+  struct timeval tv_start;
+  gettimeofday(&tv_start, NULL);
+
+  for (size_t i = 0; i < num_messages; ++i) {
+    ASSERT_SUBTEST_SUCCESS(PassMessage(&server_socket,
+                                       &client_socket,
+                                       &server_address,
+                                       messages[i]));
+  }
+
+  struct timeval tv_end;
+  gettimeofday(&tv_end, NULL);
+
+  long sec = tv_end.tv_sec - tv_start.tv_sec;
+  long usec = tv_end.tv_usec - tv_start.tv_usec;
+  if (usec < 0) {
+    --sec;
+    usec += 1000000;
+  }
+  elapsed->tv_sec = sec;
+  elapsed->tv_usec = usec;
+
+  server_socket.Close();
+  client_socket.Close();
+  PASS();
+}
+
 std::string TestUDPSocketPrivate::TestConnect() {
   pp::UDPSocketPrivate server_socket(instance_), client_socket(instance_);
   PP_NetAddress_Private server_address, client_address;
@@ -274,3 +406,39 @@ std::string TestUDPSocketPrivate::TestSetSocketFeatureErrors() {
   ASSERT_EQ(PP_ERROR_BADARGUMENT, rv);
   PASS();
 }
+
+std::string TestUDPSocketPrivate::TestSequentialRequests() {
+  fprintf(stderr, "TestSequentialRequests:\n");
+  const size_t kMessageSize = 1 << 12;
+  const size_t kMaxNumMessages = 1 << 14;
+  for (size_t num_messages = 256;
+       num_messages <= kMaxNumMessages; num_messages <<= 1) {
+    struct timeval elapsed;
+    ASSERT_SUBTEST_SUCCESS(BenchmarkSequentialRequests(num_messages,
+                                                       kMessageSize,
+                                                       &elapsed));
+    fprintf(stderr, "num messages: %zu, message size: %zu, force_async_: %d\n",
+            num_messages, kMessageSize, (int) force_async_);
+    fprintf(stderr, "time elapsed: %ld.%06ld\n",
+            (long) elapsed.tv_sec, (long) elapsed.tv_usec);
+  }
+  PASS();
+}
+
+std::string TestUDPSocketPrivate::TestQueuedRequests() {
+  fprintf(stderr, "TestQueuedRequests:\n");
+  const size_t kMessageSize = 1 << 12;
+  const size_t kMaxNumMessages = 1 << 14;
+  for (size_t num_messages = 256;
+       num_messages <= kMaxNumMessages; num_messages <<= 1) {
+    struct timeval elapsed;
+    ASSERT_SUBTEST_SUCCESS(BenchmarkQueuedRequests(num_messages,
+                                                   kMessageSize,
+                                                   &elapsed));
+    fprintf(stderr, "num messages: %zu, message size: %zu, force_async_: %d\n",
+            num_messages, kMessageSize, (int) force_async_);
+    fprintf(stderr, "time elapsed: %ld.%06ld\n",
+            (long) elapsed.tv_sec, (long) elapsed.tv_usec);
+  }
+  PASS();
+}