5 files changed, 119 insertions, 57 deletions

diff --git a/src/fragmentation/fragmentation.c b/src/fragmentation/fragmentation.c
index 4749f5378..19f7ff175 100644
--- a/src/fragmentation/fragmentation.c
+++ b/src/fragmentation/fragmentation.c
@@ -52,7 +52,12 @@ struct GNUNET_FRAGMENT_Context
   /**
    * Current expected delay for ACKs.
    */
-  struct GNUNET_TIME_Relative delay;
+  struct GNUNET_TIME_Relative ack_delay;
+
+  /**
+   * Current expected delay between messages.
+   */
+  struct GNUNET_TIME_Relative msg_delay;
 
   /**
    * Next allowed transmission time.
@@ -181,11 +186,11 @@ transmit_next (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;
   }
   fc->next_transmission = (fc->next_transmission + 1) % 64;
-  wrap |= (fc->next_transmission == 0);
+  wrap |= (0 == fc->next_transmission);
   while (0 == (fc->acks & (1LL << fc->next_transmission)))
   {
     fc->next_transmission = (fc->next_transmission + 1) % 64;
-    wrap |= (fc->next_transmission == 0);
+    wrap |= (0 == fc->next_transmission);
   }
 
   /* assemble fragmentation message */
@@ -217,16 +222,17 @@ transmit_next (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     delay = GNUNET_BANDWIDTH_tracker_get_delay (fc->tracker, fsize);
   else
     delay = GNUNET_TIME_UNIT_ZERO;
+  delay = GNUNET_TIME_relative_max (delay,
+                                    fc->msg_delay);
   if (wrap)
   {
     /* full round transmitted wait 2x delay for ACK before going again */
     fc->num_rounds++;
-    delay =
-        GNUNET_TIME_relative_max (GNUNET_TIME_relative_multiply (delay, 2),
-                                  GNUNET_TIME_relative_multiply (fc->delay,
-                                                                 fc->num_rounds));
+    delay = GNUNET_TIME_relative_multiply (delay, 2);
+    fc->msg_delay = GNUNET_TIME_relative_multiply (fc->msg_delay, 
+                                                   2 + (size / (fc->mtu - sizeof (struct FragmentHeader))));
     /* never use zero, need some time for ACK always */
-    delay = GNUNET_TIME_relative_max (MIN_ACK_DELAY, delay);
+    delay = GNUNET_TIME_relative_max (MIN_ACK_DELAY, delay);    
     fc->wack = GNUNET_YES;
     fc->last_round = GNUNET_TIME_absolute_get ();
     GNUNET_STATISTICS_update (fc->stats, _("# fragments wrap arounds"), 1,
@@ -250,7 +256,9 @@ transmit_next (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param stats statistics context
  * @param mtu the maximum message size for each fragment
  * @param tracker bandwidth tracker to use for flow control (can be NULL)
- * @param delay expected delay between fragment transmission
+ * @param msg_delay initial delay to insert between fragment transmissions
+ *              based on previous messages
+ * @param ack_delay expected delay between fragment transmission
  *              and ACK based on previous messages
  * @param msg the message to fragment
  * @param proc function to call for each fragment to transmit
@@ -261,7 +269,8 @@ struct GNUNET_FRAGMENT_Context *
 GNUNET_FRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats,
                                 uint16_t mtu,
                                 struct GNUNET_BANDWIDTH_Tracker *tracker,
-                                struct GNUNET_TIME_Relative delay,
+                                struct GNUNET_TIME_Relative msg_delay,
+                                struct GNUNET_TIME_Relative ack_delay,
                                 const struct GNUNET_MessageHeader *msg,
                                 GNUNET_FRAGMENT_MessageProcessor proc,
                                 void *proc_cls)
@@ -280,7 +289,8 @@ GNUNET_FRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats,
   fc->stats = stats;
   fc->mtu = mtu;
   fc->tracker = tracker;
-  fc->delay = delay;
+  fc->ack_delay = ack_delay;
+  fc->msg_delay = msg_delay;
   fc->msg = (const struct GNUNET_MessageHeader *) &fc[1];
   fc->proc = proc;
   fc->proc_cls = proc_cls;
@@ -339,7 +349,11 @@ GNUNET_FRAGMENT_process_ack (struct GNUNET_FRAGMENT_Context *fc,
   const struct FragmentAcknowledgement *fa;
   uint64_t abits;
   struct GNUNET_TIME_Relative ndelay;
+  unsigned int ack_cnt;
+  unsigned int snd_cnt;
+  unsigned int i;
 
+  fprintf (stderr, "Got ACK!\n");
   if (sizeof (struct FragmentAcknowledgement) != ntohs (msg->size))
   {
     GNUNET_break_op (0);
@@ -355,9 +369,40 @@ GNUNET_FRAGMENT_process_ack (struct GNUNET_FRAGMENT_Context *fc,
     /* normal ACK, can update running average of delay... */
     fc->wack = GNUNET_NO;
     ndelay = GNUNET_TIME_absolute_get_duration (fc->last_round);
-    fc->delay.rel_value =
-        (ndelay.rel_value / fc->num_transmissions + 3 * fc->delay.rel_value) / 4;
+    fc->ack_delay.rel_value =
+        (ndelay.rel_value / fc->num_transmissions + 3 * fc->ack_delay.rel_value) / 4;    
     fc->num_transmissions = 0;
+    /* calculate ratio msg sent vs. msg acked */
+    ack_cnt = 0;
+    snd_cnt = 0;
+    for (i=0;i<64;i++)
+    {
+      if (1 == (fc->acks_mask & (1 << i)))
+      {
+        snd_cnt++;
+        if (0 == (abits & (1 << i)))
+          ack_cnt++;
+      }
+    }
+    if (0 == ack_cnt)
+    {
+      /* complete loss */
+      fc->msg_delay = GNUNET_TIME_relative_multiply (fc->msg_delay, 
+                                                     snd_cnt);      
+    }
+    else if (snd_cnt > ack_cnt)
+    {
+      /* some loss, slow down proportionally */
+      fc->msg_delay.rel_value = ((fc->msg_delay.rel_value * ack_cnt) / snd_cnt);
+    }
+    else if (0 < fc->msg_delay.rel_value)
+    {
+      fc->msg_delay.rel_value--; /* try a bit faster */
+    }
+    fc->msg_delay = GNUNET_TIME_relative_max (fc->msg_delay,
+                                              GNUNET_TIME_UNIT_SECONDS);
+    fprintf (stderr, "New msg delay: %llu\n",
+             (unsigned long long )fc->msg_delay.rel_value);
   }
   GNUNET_STATISTICS_update (fc->stats,
                             _("# fragment acknowledgements received"), 1,
@@ -406,19 +451,23 @@ GNUNET_FRAGMENT_process_ack (struct GNUNET_FRAGMENT_Context *fc,
  * resources).
  *
  * @param fc fragmentation context
- * @return average delay between transmission and ACK for the
- *         last message, FOREVER if the message was not fully transmitted
+ * @param msg_delay where to store average delay between individual message transmissions the
+ *         last message (OUT only)
+ * @param ack_delay where to store average delay between transmission and ACK for the
+ *         last message, set to FOREVER if the message was not fully transmitted (OUT only)
  */
-struct GNUNET_TIME_Relative
-GNUNET_FRAGMENT_context_destroy (struct GNUNET_FRAGMENT_Context *fc)
+void
+GNUNET_FRAGMENT_context_destroy (struct GNUNET_FRAGMENT_Context *fc,
+                                 struct GNUNET_TIME_Relative *msg_delay,
+                                 struct GNUNET_TIME_Relative *ack_delay)
 {
-  struct GNUNET_TIME_Relative ret;
-
   if (fc->task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (fc->task);
-  ret = fc->delay;
+  if (NULL != ack_delay)
+    *ack_delay = fc->ack_delay;
+  if (NULL != msg_delay)
+    *msg_delay = fc->msg_delay;
   GNUNET_free (fc);
-  return ret;
 }
 
 
diff --git a/src/fragmentation/test_fragmentation.c b/src/fragmentation/test_fragmentation.c
index 0381a8dd0..ecbcdddab 100644
--- a/src/fragmentation/test_fragmentation.c
+++ b/src/fragmentation/test_fragmentation.c
@@ -77,7 +77,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   {
     if (frags[i] == NULL)
       continue;
-    GNUNET_FRAGMENT_context_destroy (frags[i]);
+    GNUNET_FRAGMENT_context_destroy (frags[i], NULL, NULL);
     frags[i] = NULL;
   }
 }
@@ -134,7 +134,7 @@ proc_acks (void *cls, uint32_t msg_id, const struct GNUNET_MessageHeader *hdr)
 #if DETAILS
       FPRINTF (stderr, "%s",  "@");    /* good ACK */
 #endif
-      GNUNET_FRAGMENT_context_destroy (frags[i]);
+      GNUNET_FRAGMENT_context_destroy (frags[i], NULL, NULL);
       frags[i] = NULL;
       acks++;
       return;
@@ -215,7 +215,9 @@ run (void *cls, char *const *args, const char *cfgfile,
         htons (sizeof (struct GNUNET_MessageHeader) + (17 * i) % (32 * 1024));
     frags[i] = GNUNET_FRAGMENT_context_create (NULL /* no stats */ ,
                                                MTU, &trackers[i],
-                                               GNUNET_TIME_UNIT_SECONDS, msg,
+                                               GNUNET_TIME_UNIT_MILLISECONDS, 
+                                               GNUNET_TIME_UNIT_SECONDS, 
+                                               msg,
                                                &proc_frac, &frags[i]);
   }
 }
diff --git a/src/include/gnunet_fragmentation_lib.h b/src/include/gnunet_fragmentation_lib.h
index a953bd2b1..b02201867 100644
--- a/src/include/gnunet_fragmentation_lib.h
+++ b/src/include/gnunet_fragmentation_lib.h
@@ -73,7 +73,9 @@ typedef void (*GNUNET_FRAGMENT_MessageProcessor) (void *cls,
  * @param stats statistics context
  * @param mtu the maximum message size for each fragment
  * @param tracker bandwidth tracker to use for flow control (can be NULL)
- * @param delay expected delay between fragment transmission
+ * @param msg_delay initial delay to insert between fragment transmissions
+ *              based on previous messages
+ * @param ack_delay expected delay between fragment transmission
  *              and ACK based on previous messages
  * @param msg the message to fragment
  * @param proc function to call for each fragment to transmit
@@ -84,7 +86,8 @@ struct GNUNET_FRAGMENT_Context *
 GNUNET_FRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats,
                                 uint16_t mtu,
                                 struct GNUNET_BANDWIDTH_Tracker *tracker,
-                                struct GNUNET_TIME_Relative delay,
+                                struct GNUNET_TIME_Relative msg_delay,
+                                struct GNUNET_TIME_Relative ack_delay,
                                 const struct GNUNET_MessageHeader *msg,
                                 GNUNET_FRAGMENT_MessageProcessor proc,
                                 void *proc_cls);
@@ -122,11 +125,15 @@ GNUNET_FRAGMENT_process_ack (struct GNUNET_FRAGMENT_Context *fc,
  * resources).
  *
  * @param fc fragmentation context
- * @return average delay between transmission and ACK for the
- *         last message, FOREVER if the message was not fully transmitted
+ * @param msg_delay where to store average delay between individual message transmissions the
+ *         last message (OUT only)
+ * @param ack_delay where to store average delay between transmission and ACK for the
+ *         last message, set to FOREVER if the message was not fully transmitted (OUT only)
  */
-struct GNUNET_TIME_Relative
-GNUNET_FRAGMENT_context_destroy (struct GNUNET_FRAGMENT_Context *fc);
+void
+GNUNET_FRAGMENT_context_destroy (struct GNUNET_FRAGMENT_Context *fc,
+                                 struct GNUNET_TIME_Relative *msg_delay,
+                                 struct GNUNET_TIME_Relative *ack_delay);
 
 
 /**
diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c
index b6b13eab2..18791c264 100644
--- a/src/transport/plugin_transport_udp.c
+++ b/src/transport/plugin_transport_udp.c
@@ -128,7 +128,12 @@ struct Session
   /**
    * expected delay for ACKs
    */
-  struct GNUNET_TIME_Relative last_expected_delay;
+  struct GNUNET_TIME_Relative last_expected_ack_delay;
+
+  /**
+   * desired delay between UDP messages
+   */
+  struct GNUNET_TIME_Relative last_expected_msg_delay;
 
   struct GNUNET_ATS_Information ats;
 
@@ -290,7 +295,7 @@ struct UDP_FragmentationContext
   size_t on_wire_size;
 
   unsigned int fragments_used;
-  struct GNUNET_TIME_Relative exp_delay;
+
 };
 
 
@@ -971,9 +976,9 @@ udp_plugin_check_address (void *cls, const void *addr, size_t addrlen)
 static void
 free_session (struct Session *s)
 {
-  if (s->frag_ctx != NULL)
+  if (NULL != s->frag_ctx)
   {
-    GNUNET_FRAGMENT_context_destroy(s->frag_ctx->frag);
+    GNUNET_FRAGMENT_context_destroy(s->frag_ctx->frag, NULL, NULL);
     GNUNET_free (s->frag_ctx);
     s->frag_ctx = NULL;
   }
@@ -1236,7 +1241,8 @@ create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *target,
   s->addrlen = len;
   s->target = *target;
   s->sock_addr = (const struct sockaddr *) &s[1];
-  s->last_expected_delay = GNUNET_TIME_UNIT_SECONDS;
+  s->last_expected_ack_delay = GNUNET_TIME_UNIT_SECONDS;
+  s->last_expected_msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
   s->flow_delay_from_other_peer = GNUNET_TIME_UNIT_ZERO_ABS;
   s->flow_delay_for_other_peer = GNUNET_TIME_UNIT_ZERO;
   start_session_timeout (s);
@@ -1561,17 +1567,17 @@ udp_plugin_send (void *cls,
     frag_ctx->timeout = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), to);
     frag_ctx->payload_size = msgbuf_size; /* unfragmented message size without UDP overhead */
     frag_ctx->on_wire_size = 0; /* bytes with UDP and fragmentation overhead */
+    fprintf (stderr, "New fc with msg delay: %llu and ack delay %llu\n",
+             (unsigned long long )s->last_expected_msg_delay.rel_value,
+             (unsigned long long )s->last_expected_ack_delay.rel_value);
     frag_ctx->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
-              UDP_MTU,
-              &plugin->tracker,
-              GNUNET_TIME_relative_max (s->last_expected_delay, GNUNET_TIME_UNIT_SECONDS),
-              &udp->header,
-              &enqueue_fragment,
-              frag_ctx);
-
-    frag_ctx->exp_delay = s->last_expected_delay;
-    s->frag_ctx = frag_ctx;
-
+                                                     UDP_MTU,
+                                                     &plugin->tracker,
+                                                     s->last_expected_msg_delay, 
+                                                     s->last_expected_ack_delay, 
+                                                     &udp->header,
+                                                     &enqueue_fragment,
+                                                     frag_ctx);    
     GNUNET_STATISTICS_update (plugin->env->stats,
                               "# UDP, fragmented msgs, messages, pending",
                               1, GNUNET_NO);
@@ -1964,7 +1970,9 @@ read_process_ack (struct Plugin *plugin,
        "Message full ACK'ed\n",
        (unsigned int) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
        GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
-  s->last_expected_delay = GNUNET_FRAGMENT_context_destroy (s->frag_ctx->frag);
+  GNUNET_FRAGMENT_context_destroy (s->frag_ctx->frag,
+                                   &s->last_expected_msg_delay,
+                                   &s->last_expected_ack_delay);
 
   if (s->addrlen == sizeof (struct sockaddr_in6))
   {
@@ -1994,15 +2002,6 @@ read_process_ack (struct Plugin *plugin,
       udpw = tmp;
     }
   }
-/*
-  LOG (GNUNET_ERROR_TYPE_ERROR,
-       "Fragmented message sent: fragments needed: %u , payload %u bytes, used on wire %u bytes, overhead: %f, expected delay: %llu\n",
-       s->frag_ctx->fragments_used,
-       s->frag_ctx->payload_size,
-       s->frag_ctx->on_wire_size,
-       ((float) s->frag_ctx->on_wire_size) / s->frag_ctx->payload_size,
-       s->frag_ctx->exp_delay.rel_value);
-*/
   dummy.msg_type = MSG_FRAGMENTED_COMPLETE;
   dummy.msg_buf = NULL;
   dummy.msg_size = s->frag_ctx->on_wire_size;
@@ -2190,7 +2189,9 @@ remove_timeout_messages_and_select (struct UDP_MessageWrapper *head,
           LOG (GNUNET_ERROR_TYPE_DEBUG,
                "Fragment for message for peer `%s' with size %u timed out\n",
                GNUNET_i2s(&udpw->session->target), udpw->frag_ctx->payload_size);
-          udpw->session->last_expected_delay = GNUNET_FRAGMENT_context_destroy (udpw->frag_ctx->frag);
+          GNUNET_FRAGMENT_context_destroy (udpw->frag_ctx->frag,
+                                           &udpw->session->last_expected_msg_delay,
+                                           &udpw->session->last_expected_ack_delay);
           GNUNET_free (udpw->frag_ctx);
           udpw->session->frag_ctx = NULL;
 
diff --git a/src/transport/plugin_transport_wlan.c b/src/transport/plugin_transport_wlan.c
index b73d444eb..ccf5d587c 100644
--- a/src/transport/plugin_transport_wlan.c
+++ b/src/transport/plugin_transport_wlan.c
@@ -790,7 +790,7 @@ free_fragment_message (struct FragmentMessage *fm)
     GNUNET_HELPER_send_cancel (fm->sh);
     fm->sh = NULL;
   }
-  GNUNET_FRAGMENT_context_destroy (fm->fragcontext);
+  GNUNET_FRAGMENT_context_destroy (fm->fragcontext, NULL, NULL);
   if (fm->timeout_task != GNUNET_SCHEDULER_NO_TASK)
   {
     GNUNET_SCHEDULER_cancel (fm->timeout_task);
@@ -857,10 +857,13 @@ send_with_fragmentation (struct MacEndpoint *endpoint,
   fm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   fm->cont = cont;
   fm->cont_cls = cont_cls;
+  /* 1 MBit/s typical data rate, 1430 byte fragments => ~100 ms per message */
   fm->fragcontext =
     GNUNET_FRAGMENT_context_create (plugin->env->stats, WLAN_MTU,
                                     &plugin->tracker,
                                     GNUNET_TIME_UNIT_SECONDS,
+                                    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+                                                                   100),
                                     msg,
                                     &transmit_fragment, fm);
   fm->timeout_task =