- use window size client<->server, x4 faster

[oweals/gnunet.git] / src / mesh / mesh_api.c

diff --git a/src/mesh/mesh_api.c b/src/mesh/mesh_api.c
index 7b4987afdc06d9ab1dcc7c8cd77c36761bfa0c0d..46747a0d4c8649c2d39f19675aefbfa900124dd3 100644 (file)
--- a/src/mesh/mesh_api.c
+++ b/src/mesh/mesh_api.c
@@ -388,9 +388,17 @@ message_ready_size (struct GNUNET_MESH_Handle *h)
   for (th = h->th_head; NULL != th; th = th->next)
   {
     t = th->tunnel;
-    if (GNUNET_NO == th_is_payload (th) ||
-        GNUNET_NO == GMC_is_pid_bigger(t->next_send_pid, t->max_send_pid))
+    if (GNUNET_NO == th_is_payload (th))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "  message internal\n");
       return th->size;
+    }
+    if (GNUNET_NO == GMC_is_pid_bigger(t->next_send_pid, t->max_send_pid))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "  message payload ok (%u <= %u)\n",
+           t->next_send_pid, t->max_send_pid);
+      return th->size;
+    }
   }
   return 0;
 }
@@ -446,7 +454,8 @@ create_tunnel (struct GNUNET_MESH_Handle *h, MESH_TunnelNumber tid)
   {
     t->tid = tid;
   }
-  t->max_send_pid = 1;
+  t->max_send_pid = INITIAL_WINDOW_SIZE - 1;
+  t->last_recv_pid = (uint32_t) -1;
   return t;
 }
 
@@ -689,11 +698,11 @@ send_ack (struct GNUNET_MESH_Handle *h, struct GNUNET_MESH_Tunnel *t)
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending ACK on tunnel %X: %u\n",
-       t->tid, t->last_recv_pid + 1);
+       t->tid, t->last_recv_pid + INITIAL_WINDOW_SIZE);
   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK);
   msg.header.size = htons (sizeof (msg));
   msg.tunnel_id = htonl (t->tid);
-  msg.max_pid = t->last_recv_pid + 1;
+  msg.max_pid = htonl (t->last_recv_pid + INITIAL_WINDOW_SIZE);
 
   send_packet (h, &msg.header, t);
   return;
@@ -742,11 +751,16 @@ send_connect (struct GNUNET_MESH_Handle *h)
     for (napps = 0; napps < h->n_applications; napps++)
     {
       apps[napps] = htonl (h->applications[napps]);
-      LOG (GNUNET_ERROR_TYPE_DEBUG, " app %u\n", h->applications[napps]);
+      LOG (GNUNET_ERROR_TYPE_DEBUG, " app %u\n",
+           h->applications[napps]);
     }
     types = (uint16_t *) & apps[napps];
     for (ntypes = 0; ntypes < h->n_handlers; ntypes++)
+    {
       types[ntypes] = htons (h->message_handlers[ntypes].type);
+      LOG (GNUNET_ERROR_TYPE_DEBUG, " type %u\n",
+           h->message_handlers[ntypes].type);
+    }
     msg->applications = htons (napps);
     msg->types = htons (ntypes);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -822,6 +836,9 @@ do_reconnect (struct GNUNET_MESH_Handle *h)
        */
       continue;
     }
+    t->next_send_pid = 0;
+    t->max_send_pid = INITIAL_WINDOW_SIZE - 1;
+    t->last_recv_pid = (uint32_t) -1;
     tmsg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE);
     tmsg.header.size = htons (sizeof (struct GNUNET_MESH_TunnelMessage));
     tmsg.tunnel_id = htonl (t->tid);
@@ -1111,7 +1128,8 @@ process_incoming_data (struct GNUNET_MESH_Handle *h,
     LOG (GNUNET_ERROR_TYPE_DEBUG, "  ignored!\n");
     return GNUNET_YES;
   }
-  if (GMC_is_pid_bigger(pid, t->last_recv_pid + 1))
+    if (GNUNET_YES ==
+        GMC_is_pid_bigger(pid, t->last_recv_pid + INITIAL_WINDOW_SIZE))
   {
     GNUNET_break (0);
     LOG (GNUNET_ERROR_TYPE_WARNING, "  unauthorized message!\n");
@@ -1177,7 +1195,7 @@ process_ack (struct GNUNET_MESH_Handle *h,
   }
   ack = ntohl (msg->max_pid);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "  on tunnel %X, ack %u!\n", t->tid, ack);
-  if (ack > t->max_send_pid || PID_OVERFLOW (t->max_send_pid, ack))
+  if (GNUNET_YES == GMC_is_pid_bigger(ack, t->max_send_pid))
     t->max_send_pid = ack;
   else
     return;
@@ -1282,6 +1300,7 @@ send_callback (void *cls, size_t size, void *buf)
   char *cbuf = buf;
   size_t tsize;
   size_t psize;
+  size_t nsize;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Send packet() Buffer %u\n", size);
@@ -1294,13 +1313,14 @@ send_callback (void *cls, size_t size, void *buf)
   }
   tsize = 0;
   next = h->th_head;
-  while ((NULL != (th = next)) && (size >= th->size))
+  nsize = message_ready_size (h);
+  while ((NULL != (th = next)) && (0 < nsize) && (size >= nsize))
   {
     t = th->tunnel;
     if (GNUNET_YES == th_is_payload (th))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG, " payload\n");
-      if (t->max_send_pid < t->next_send_pid && GNUNET_NO == PID_OVERFLOW (t->next_send_pid, t->max_send_pid))
+      if (GNUNET_YES == GMC_is_pid_bigger(t->next_send_pid, t->max_send_pid))
       {
         /* This tunnel is not ready to transmit yet, try next message */
         next = th->next;
@@ -1386,7 +1406,7 @@ send_callback (void *cls, size_t size, void *buf)
       struct GNUNET_MessageHeader *mh = (struct GNUNET_MessageHeader *) &th[1];
 
       LOG (GNUNET_ERROR_TYPE_DEBUG, "  mesh traffic, type %s\n",
-             GNUNET_MESH_DEBUG_M2S (ntohs (mh->type)));
+           GNUNET_MESH_DEBUG_M2S (ntohs (mh->type)));
       memcpy (cbuf, &th[1], th->size);
       psize = th->size;
     }
@@ -1395,6 +1415,7 @@ send_callback (void *cls, size_t size, void *buf)
     GNUNET_CONTAINER_DLL_remove (h->th_head, h->th_tail, th);
     GNUNET_free (th);
     next = h->th_head;
+    nsize = message_ready_size (h);
     cbuf += psize;
     size -= psize;
     tsize += psize;
@@ -1412,7 +1433,10 @@ send_callback (void *cls, size_t size, void *buf)
   }
   else
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  nothing left to transmit\n");
+    if (NULL != h->th_head)
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "  can't transmit any more\n");
+    else
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "  nothing left to transmit\n");
   }
   if (GNUNET_NO == h->in_receive)
   {
@@ -1443,6 +1467,8 @@ send_packet (struct GNUNET_MESH_Handle *h,
   struct GNUNET_MESH_TransmitHandle *th;
   size_t msize;
 
+  LOG (GNUNET_ERROR_TYPE_DEBUG, " Sending message to service: %s\n",
+       GNUNET_MESH_DEBUG_M2S(ntohs(msg->type)));
   msize = ntohs (msg->size);
   th = GNUNET_malloc (sizeof (struct GNUNET_MESH_TransmitHandle) + msize);
   th->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
@@ -1450,8 +1476,10 @@ send_packet (struct GNUNET_MESH_Handle *h,
   th->tunnel = tunnel;
   memcpy (&th[1], msg, msize);
   add_to_queue (h, th);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "  queued\n");
   if (NULL != h->th)
     return;
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "  calling ntfy tmt rdy for %u bytes\n", msize);
   h->th =
       GNUNET_CLIENT_notify_transmit_ready (h->client, msize,
                                            GNUNET_TIME_UNIT_FOREVER_REL,
@@ -2028,8 +2056,7 @@ GNUNET_MESH_notify_transmit_ready (struct GNUNET_MESH_Tunnel *tunnel, int cork,
   add_to_queue (tunnel->mesh, th);
   if (NULL != tunnel->mesh->th)
     return th;
-  if (GNUNET_NO == PID_OVERFLOW(tunnel->next_send_pid, tunnel->max_send_pid) &&
-      tunnel->max_send_pid <= tunnel->next_send_pid)
+  if (GMC_is_pid_bigger(tunnel->next_send_pid, tunnel->max_send_pid))
     return th;
   LOG (GNUNET_ERROR_TYPE_DEBUG, "    call notify tmt rdy\n");
   tunnel->mesh->th =