[GNUnet-SVN] r23178 - gnunet/src/mesh

[gnunet]

Author: bartpolot
Date: 2012-08-09 17:46:50 +0200 (Thu, 09 Aug 2012)
New Revision: 23178

Modified:
   gnunet/src/mesh/test_mesh_local_traffic.c
Log:
- add 3 test in one to local traffic testcase source file

Modified: gnunet/src/mesh/test_mesh_local_traffic.c
===================================================================
--- gnunet/src/mesh/test_mesh_local_traffic.c   2012-08-09 12:36:42 UTC (rev 
23177)
+++ gnunet/src/mesh/test_mesh_local_traffic.c   2012-08-09 15:46:50 UTC (rev 
23178)
@@ -34,6 +34,14 @@
 
 #define TARGET 1000
 
+/**
+ * DIFFERENT TESTS TO RUN
+ */
+#define FWD 0
+#define BCK 1
+#define BOTH 2
+
+
 GNUNET_NETWORK_STRUCT_BEGIN
 
 struct test_traffic_message
@@ -44,6 +52,26 @@
 
 GNUNET_NETWORK_STRUCT_END
 
+
+/** Which test to run, based on executable name */
+static int test;
+
+static int started;
+
+/** How many packets to send from root to leaf */
+static unsigned int to_send_fwd;
+
+/** How many packets to send from leaf to root */
+static unsigned int to_send_bck;
+
+static unsigned int sent_fwd = 0;
+
+static unsigned int got_fwd = 0;
+
+static unsigned int sent_bck = 0;
+
+static unsigned int got_bck = 0;
+
 static struct GNUNET_MESH_Handle *mesh_peer_1;
 
 static struct GNUNET_MESH_Handle *mesh_peer_2;
@@ -56,10 +84,6 @@
 
 static int result = GNUNET_SYSERR;
 
-static unsigned int sent = 0;
-
-static unsigned int got = 0;
-
 static GNUNET_SCHEDULER_TaskIdentifier abort_task;
 
 static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
@@ -127,6 +151,54 @@
 
 
 /**
+ * Transmit ready callback.
+ * 
+ * @param cls Closure (peer number of peer sending the data).
+ * @param size Buffer size.
+ * @param buf Buffer.
+ */
+static size_t
+tmt_rdy (void *cls, size_t size, void *buf)
+{
+  unsigned int peer_number = *(unsigned int *) cls;
+  struct GNUNET_MessageHeader *m = buf;
+  struct test_traffic_message *msg = buf;
+  size_t msize = sizeof (struct test_traffic_message);
+  unsigned int *sent;
+  unsigned int target;
+
+  if (0 == size || NULL == buf)
+    return 0;
+
+  if (1 == peer_number)
+  {
+    sent = &sent_fwd;
+    target = to_send_fwd;
+  }
+  else if (2 == peer_number)
+  {
+    sent = &sent_bck;
+    target = to_send_bck;
+  }
+  else
+    GNUNET_abort();
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending data packet # %u\n",
+              *sent);
+  GNUNET_assert (size >= msize);
+  (*sent)++;
+  if (target > *sent)
+    GNUNET_MESH_notify_transmit_ready (t, GNUNET_NO,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       &peer_id, msize, &tmt_rdy, cls);
+  m->size = htons (msize);
+  m->type = htons (1);
+  msg->data = htonl (*sent - 1);
+  return msize;
+}
+
+
+/**
  * Function is called whenever a message is received.
  *
  * @param cls closure (set from GNUNET_MESH_connect)
@@ -145,16 +217,43 @@
                const struct GNUNET_ATS_Information *atsi)
 {
   struct test_traffic_message *msg;
+  unsigned int *peer_number = cls;
+  unsigned int *got;
+  unsigned int target;
 
+  if (GNUNET_NO == started)
+  {
+    GNUNET_break (2 == *peer_number);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got initial data packet\n");
+    started = GNUNET_YES;
+    return GNUNET_OK;
+  }
+
+  if (*peer_number == 1)
+  {
+    got = &got_bck;
+    target = to_send_bck;
+  }
+  else if (*peer_number == 2)
+  {
+    got = &got_fwd;
+    target = to_send_fwd;
+  }
+  else
+  {
+    GNUNET_abort();
+  }
   msg = (struct test_traffic_message *) message;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got data packet # %u [%u]\n",
               ntohl (msg->data), got + 1);
-  got++;
-  if (TARGET == got)
+  (*got)++;
+  if (target == *got)
   {
-    end_time = GNUNET_TIME_absolute_get();
-    result = GNUNET_OK;
-    finish();
+    if (to_send_bck == sent_bck && to_send_fwd == sent_fwd) {
+      end_time = GNUNET_TIME_absolute_get();
+      result = GNUNET_OK;
+      finish();
+    }
     return GNUNET_OK;
   }
   if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
@@ -184,12 +283,25 @@
   unsigned int id = *(unsigned int *) cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "received incoming tunnel\n");
-  if (id != 1)
+  if (id != 2)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "received incoming tunnel on peer 2\n");
+                "received incoming tunnel on peer 1\n");
     result = GNUNET_SYSERR;
   }
+  start_time = GNUNET_TIME_absolute_get();
+  if (FWD != test) // Send leaf -> root
+    GNUNET_MESH_notify_transmit_ready (tunnel, GNUNET_NO,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       NULL,
+                                       sizeof (struct test_traffic_message),
+                                       &tmt_rdy, &two);
+  if (BCK != test) // Send root -> leaf
+    GNUNET_MESH_notify_transmit_ready (t, GNUNET_NO,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       &peer_id,
+                                       sizeof (struct test_traffic_message),
+                                       &tmt_rdy, &one);
   return NULL;
 }
 
@@ -220,37 +332,6 @@
 
 
 /**
- * Transmit ready callback.
- * 
- * @param cls Closure.
- * @param size Buffer size.
- * @param buf Buffer.
- */
-static size_t
-tmt_rdy (void *cls, size_t size, void *buf)
-{
-  struct GNUNET_MessageHeader *m = buf;
-  struct test_traffic_message *msg = buf;
-  size_t msize = sizeof (struct test_traffic_message);
-
-  if (0 == size || NULL == buf)
-    return 0;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending data packet # %u\n",
-              sent);
-  GNUNET_assert (size >= msize);
-  sent++;
-  if (TARGET > sent)
-    GNUNET_MESH_notify_transmit_ready (t, GNUNET_NO,
-                                       GNUNET_TIME_UNIT_FOREVER_REL,
-                                       &peer_id, msize, &tmt_rdy, NULL);
-  m->size = htons (msize);
-  m->type = htons (1);
-  msg->data = htonl (sent - 1);
-  return msize;
-}
-
-
-/**
  * Method called whenever a peer has connected to the tunnel.
  *
  * @param cls Closure.
@@ -262,10 +343,10 @@
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer connected\n");
   peer_id = *peer;
-  start_time = GNUNET_TIME_absolute_get();
+  /* Force an inbound tunnel notification on peer 2 */
   GNUNET_MESH_notify_transmit_ready (t, GNUNET_NO, 
GNUNET_TIME_UNIT_FOREVER_REL,
                                      peer, sizeof (struct 
test_traffic_message),
-                                     &tmt_rdy, NULL);
+                                     &tmt_rdy, &one);
 }
 
 
@@ -286,8 +367,8 @@
 /**
  * Handler array for traffic received on peer1
  */
-static struct GNUNET_MESH_MessageHandler handlers1[] = {
-  {&data_callback, 1, 0},
+static struct GNUNET_MESH_MessageHandler handlers[] = {
+  {&data_callback, 1, sizeof (struct test_traffic_message)},
   {NULL, 0, 0}
 };
 
@@ -295,7 +376,7 @@
 /**
  * Handler array for traffic received on peer2 (none expected)
  */
-static struct GNUNET_MESH_MessageHandler handlers2[] = { {NULL, 0, 0} };
+static struct GNUNET_MESH_MessageHandler handlers_null[] = { {NULL, 0, 0} };
 
 
 /**
@@ -306,8 +387,8 @@
      const struct GNUNET_CONFIGURATION_Handle *cfg,
      struct GNUNET_TESTING_Peer *peer)
 {
-  static const GNUNET_MESH_ApplicationType app1[] = { 1, 0 };
-  static const GNUNET_MESH_ApplicationType app2[] = { 0 };
+  static const GNUNET_MESH_ApplicationType app1[] = { 0 };
+  static const GNUNET_MESH_ApplicationType app2[] = { 1, 0 };
 
   abort_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
@@ -315,16 +396,17 @@
                                     NULL);
   mesh_peer_1 = GNUNET_MESH_connect (cfg,       /* configuration */
                                      (void *) &one,     /* cls */
-                                     &inbound_tunnel,   /* inbound new hndlr */
-                                     &inbound_end,      /* inbound end hndlr */
-                                     handlers1, /* traffic handlers */
+                                     NULL,      /* inbound new hndlr */
+                                     NULL,      /* inbound end hndlr */
+                                     /* traffic handlers */
+                                     test == FWD ? handlers_null : handlers,
                                      app1);     /* apps offered */
 
   mesh_peer_2 = GNUNET_MESH_connect (cfg,       /* configuration */
                                      (void *) &two,     /* cls */
-                                     NULL,   /* inbound new hndlr */
-                                     NULL,      /* inbound end hndlr */
-                                     handlers2, /* traffic handlers */
+                                     &inbound_tunnel,   /* inbound new hndlr */
+                                     &inbound_end,      /* inbound end hndlr */
+                                     handlers,          /* traffic handlers */
                                      app2);     /* apps offered */
   if (NULL == mesh_peer_1 || NULL == mesh_peer_2)
   {
@@ -336,7 +418,7 @@
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected to mesh\n");
   }
-  t = GNUNET_MESH_tunnel_create (mesh_peer_2, NULL, &peer_connected,
+  t = GNUNET_MESH_tunnel_create (mesh_peer_1, NULL, &peer_connected,
                                  &peer_disconnected, (void *) &two);
   GNUNET_MESH_peer_request_connect_by_type (t, 1);
 }
@@ -348,6 +430,29 @@
 int
 main (int argc, char *argv[])
 {
+  if (strstr (argv[0], "test_mesh_local_traffic_fwd") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FWD\n");
+    test = FWD;
+    to_send_fwd = TARGET;
+  }
+  else if (strstr (argv[0], "test_mesh_local_traffic_bck") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "BCK\n");
+    test = BCK;
+    to_send_bck = TARGET;
+  }
+  else if (strstr (argv[0], "test_mesh_local_traffic_both") != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "BOTH\n");
+    test = BOTH;
+    to_send_bck = to_send_fwd = TARGET;
+  }
+  else
+  {
+    return 1;
+  }
+
   if (0 != GNUNET_TESTING_peer_run ("test-mesh-local-traffic",
                                    "test_mesh.conf",
                                    &run, NULL))
@@ -355,22 +460,45 @@
   if (result != GNUNET_OK)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed. Sent: %u, Got: %u\n",
-                sent, got);
+                "Failed.\nFWD expected: %u, Sent: %u, Got: %u\n",
+                to_send_fwd, sent_fwd, got_fwd);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "BCK expected: %u, Sent: %u, Got: %u\n",
+                to_send_bck, sent_bck, got_bck);
     return 1;
   }
   else
   {
     struct GNUNET_TIME_Relative total_time;
+    unsigned int total_traffic;
+    char *name;
 
+    total_traffic = BOTH == test ? 2 * TARGET : TARGET;
+    switch (test)
+    {
+      case FWD:
+        name = "Local traffic Root to Leaf";
+        break;
+      case BCK:
+        name = "Local traffic Leaf to Root";
+        break;
+      case BOTH:
+        name = "Local traffic bidirectional";
+        break;
+      default:
+        GNUNET_assert (0);
+    }
+
     total_time = GNUNET_TIME_absolute_get_difference(start_time, end_time);
     FPRINTF (stderr, "\nTest time %llu ms\n",
              (unsigned long long) total_time.rel_value);
     FPRINTF (stderr, "Test payload bandwidth: %f kb/s\n",
              4 * 1000.0 / total_time.rel_value); // 4bytes * ms
     FPRINTF (stderr, "Test throughput: %f packets/s\n\n",
-             TARGET * 1000.0 / total_time.rel_value); // 1000 packets * ms
-    GAUGER ("MESH", "Local traffic default", TARGET * 1000.0 / 
total_time.rel_value,
+             total_traffic * 1000.0 / total_time.rel_value); // 1000 packets * 
ms
+    GAUGER ("MESH",
+            name,
+            total_traffic * 1000.0 / total_time.rel_value,
             "packets/s");
   }
   return 0;