fixed stat counters

reduced logging

6 files changed, 83 insertions, 57 deletions

diff --git a/src/experimentation/gnunet-daemon-experimentation.h b/src/experimentation/gnunet-daemon-experimentation.h
index 73499301a..838d06b69 100644
--- a/src/experimentation/gnunet-daemon-experimentation.h
+++ b/src/experimentation/gnunet-daemon-experimentation.h
@@ -271,7 +271,7 @@ int
 GED_nodes_rts (struct Node *n);
 
 int
-GED_nodes_request_start (struct Node *n, struct Experiment *e);
+GED_nodes_send_start (struct Node *n, struct Experiment *e);
 
 /**
  * Confirm a experiment START with a node
diff --git a/src/experimentation/gnunet-daemon-experimentation_capabilities.c b/src/experimentation/gnunet-daemon-experimentation_capabilities.c
index a92d2d4bc..a59f59969 100644
--- a/src/experimentation/gnunet-daemon-experimentation_capabilities.c
+++ b/src/experimentation/gnunet-daemon-experimentation_capabilities.c
@@ -154,7 +154,7 @@ GED_capabilities_start ()
                 index = index << c1;
                 if (GNUNET_YES == GED_capabilities_have (GSE_node_capabilities, index))
                 {
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "We have `%s'\n",
+                        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "We have `%s'\n",
                                         GED_capability_to_str(index));
                 }
   }
diff --git a/src/experimentation/gnunet-daemon-experimentation_experiments.c b/src/experimentation/gnunet-daemon-experimentation_experiments.c
index 28becc42d..343544ba8 100644
--- a/src/experimentation/gnunet-daemon-experimentation_experiments.c
+++ b/src/experimentation/gnunet-daemon-experimentation_experiments.c
@@ -306,7 +306,7 @@ void exp_file_iterator (void *cls,
         struct GNUNET_TIME_Relative frequency;
         struct GNUNET_TIME_Relative duration;
 
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Parsing section `%s'\n", name);
+        //GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Parsing section `%s'\n", name);
 
         /* Mandatory fields */
 
@@ -430,7 +430,7 @@ GED_experiments_start ()
                 }
                 else
                 {
-                                GNUNET_log (GNUNET_ERROR_TYPE_INFO, "`%s' is a valid issuer \n", GNUNET_i2s (&issuer_ID));
+                                GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' is a valid issuer \n", GNUNET_i2s (&issuer_ID));
                                 i = GNUNET_malloc (sizeof (struct Issuer));
                                 GNUNET_CONTAINER_multihashmap_put (valid_issuers, &issuer_ID.hashPubKey,
                                                 i, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
@@ -468,7 +468,7 @@ GED_experiments_start ()
         GSE_my_issuer_count = GNUNET_CONTAINER_multihashmap_size (valid_issuers);
         GSE_my_issuer = GNUNET_malloc (GSE_my_issuer_count * sizeof (struct Experimentation_Issuer));
         GNUNET_CONTAINER_multihashmap_iterate (valid_issuers, &create_issuer, GSE_my_issuer);
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Daemon has %u issuers\n"), GSE_my_issuer_count);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Daemon has %u issuers\n", GSE_my_issuer_count);
 
   experiments = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
   /* Load experiments from file */
diff --git a/src/experimentation/gnunet-daemon-experimentation_nodes.c b/src/experimentation/gnunet-daemon-experimentation_nodes.c
index 3d2868df7..0590a1dec 100644
--- a/src/experimentation/gnunet-daemon-experimentation_nodes.c
+++ b/src/experimentation/gnunet-daemon-experimentation_nodes.c
@@ -217,7 +217,7 @@ schedule_transmisson (struct NodeComCtx *e_ctx)
                         &e_ctx->n->id, e_ctx->size, transmit_read_wrapper, e_ctx);
         if (NULL == e_ctx->n->cth)
         {
-                GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Cannot send message to peer `%s' for experiment `%s'\n"),
+                GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Cannot send message to peer `%s' for experiment `%s'\n"),
                                 GNUNET_i2s(&e_ctx->n->id), e_ctx->e->name);
                 GNUNET_free (e_ctx);
         }
@@ -236,7 +236,7 @@ remove_request (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
         struct Node *n = cls;
 
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Removing request for peer %s due to timeout\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing request for peer %s due to timeout\n",
                         GNUNET_i2s (&n->id));
 
         if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (nodes_requested, &n->id.hashPubKey))
@@ -287,7 +287,7 @@ size_t send_experimentation_request_cb (void *cls, size_t bufsize, void *buf)
         memcpy (buf, &msg, msg_size);
         memcpy (&((char *) buf)[msg_size], GSE_my_issuer, ri_size);
 
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending request to peer %s\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending experimentation request to peer %s\n"),
                         GNUNET_i2s (&n->id));
         return total_size;
 }
@@ -361,7 +361,7 @@ size_t send_response_cb (void *cls, size_t bufsize, void *buf)
         memcpy (buf, &msg, msg_size);
         memcpy (&((char *) buf)[msg_size], GSE_my_issuer, ri_size);
 
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending response to peer %s\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending response to peer %s\n",
                         GNUNET_i2s (&n->id));
         return total_size;
 }
@@ -372,15 +372,7 @@ get_experiments_cb (struct Node *n, struct Experiment *e)
 {
         static int counter = 0;
         if (NULL == e)
-        {
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Added %u experiments for peer %s\n"),
-                                        counter, GNUNET_i2s (&n->id));
-                        return;
-        }
-
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Starting experiment `%s' with peer %s\n"),
-                        e->name,
-                        GNUNET_i2s (&n->id));
+                        return; /* Done */
 
         /* Tell the scheduler to add a node with an experiment */
         GED_scheduler_add (n, e, GNUNET_YES);
@@ -509,7 +501,7 @@ static void handle_request (const struct GNUNET_PeerIdentity *peer,
                 if (GNUNET_YES == GED_experiments_issuer_accepted(&rmi[c1].issuer_id))
                         ic_accepted ++;
         }
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Request from peer `%s' with %u issuers, we accepted %u issuer \n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Request from peer `%s' with %u issuers, we accepted %u issuer \n",
                         GNUNET_i2s (peer), ic, ic_accepted);
         GNUNET_free_non_null (n->issuer_id);
         n->issuer_id = GNUNET_malloc (ic_accepted * sizeof (struct GNUNET_PeerIdentity));
@@ -573,12 +565,12 @@ static void handle_response (const struct GNUNET_PeerIdentity *peer,
         make_active = GNUNET_NO;
         if (NULL != (n = GNUNET_CONTAINER_multihashmap_get (nodes_active, &peer->hashPubKey)))
         {
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Received %s from %s peer `%s'\n"),
+                        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s from %s peer `%s'\n",
                                         "RESPONSE", "active", GNUNET_i2s (peer));
         }
         else if (NULL != (n = GNUNET_CONTAINER_multihashmap_get (nodes_requested, &peer->hashPubKey)))
         {
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Received %s from %s peer `%s'\n"),
+                        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s from %s peer `%s'\n",
                                         "RESPONSE", "requested", GNUNET_i2s (peer));
                         GNUNET_CONTAINER_multihashmap_remove (nodes_requested, &peer->hashPubKey, n);
                         if (GNUNET_SCHEDULER_NO_TASK != n->timeout_task)
@@ -591,7 +583,7 @@ static void handle_response (const struct GNUNET_PeerIdentity *peer,
         }
         else if (NULL != (n = GNUNET_CONTAINER_multihashmap_get (nodes_inactive, &peer->hashPubKey)))
         {
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Received %s from peer `%s'\n"),
+                        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s from peer `%s'\n",
                                         "RESPONSE", "inactive", GNUNET_i2s (peer));
                         GNUNET_CONTAINER_multihashmap_remove (nodes_inactive, &peer->hashPubKey, n);
                         update_stats (nodes_inactive);
@@ -599,7 +591,7 @@ static void handle_response (const struct GNUNET_PeerIdentity *peer,
         }
         else
         {
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Received %s from %s peer `%s'\n"),
+                        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s from %s peer `%s'\n",
                                         "RESPONSE", "unknown", GNUNET_i2s (peer));
                         return;
         }
@@ -614,7 +606,7 @@ static void handle_response (const struct GNUNET_PeerIdentity *peer,
                 if (GNUNET_YES == GED_experiments_issuer_accepted(&rmi[c1].issuer_id))
                         ic_accepted ++;
         }
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Response from peer `%s' with %u issuers, we accepted %u issuer \n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Response from peer `%s' with %u issuers, we accepted %u issuer \n",
                         GNUNET_i2s (peer), ic, ic_accepted);
         GNUNET_free_non_null (n->issuer_id);
         n->issuer_id = GNUNET_malloc (ic_accepted * sizeof (struct GNUNET_PeerIdentity));
@@ -1003,7 +995,8 @@ GED_nodes_send_start_ack (struct Node *n, struct Experiment *e)
 {
         struct NodeComCtx *e_ctx;
 
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending %s for experiment request to peer `%s' for experiment `%s'\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Sending %s for experiment request to peer `%s' for experiment `%s'\n",
                         "START_ACK" ,GNUNET_i2s(&n->id), e->name);
 
         e_ctx = GNUNET_malloc (sizeof (struct NodeComCtx));
@@ -1025,11 +1018,12 @@ GED_nodes_send_start_ack (struct Node *n, struct Experiment *e)
  * @return GNUNET_NO if core was busy with sending, GNUNET_OK otherwise
  */
 int
-GED_nodes_request_start (struct Node *n, struct Experiment *e)
+GED_nodes_send_start (struct Node *n, struct Experiment *e)
 {
         struct NodeComCtx *e_ctx;
 
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending %s for experiment request to peer `%s' for experiment `%s'\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Sending %s for experiment request to peer `%s' for experiment `%s'\n",
                         "START", GNUNET_i2s(&n->id), e->name);
 
         e_ctx = GNUNET_malloc (sizeof (struct NodeComCtx));
diff --git a/src/experimentation/gnunet-daemon-experimentation_scheduler.c b/src/experimentation/gnunet-daemon-experimentation_scheduler.c
index c1a948efe..784baa4d4 100644
--- a/src/experimentation/gnunet-daemon-experimentation_scheduler.c
+++ b/src/experimentation/gnunet-daemon-experimentation_scheduler.c
@@ -82,7 +82,8 @@ struct ScheduledExperiment *running_out_tail;
 
 
 static unsigned int experiments_scheduled;
-static unsigned int experiments_running;
+static unsigned int experiments_outbound_running;
+static unsigned int experiments_inbound_running;
 static unsigned int experiments_requested;
 
 
@@ -105,7 +106,7 @@ request_timeout (void *cls,const struct GNUNET_SCHEDULER_TaskContext* tc)
         struct ScheduledExperiment *se = cls;
         se->task = GNUNET_SCHEDULER_NO_TASK;
 
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peer `%s' did not respond to request for experiment `%s'\n",
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Peer `%s' did not respond to request for experiment `%s'\n"),
                         GNUNET_i2s (&se->n->id), se->e->name);
 
         GNUNET_CONTAINER_DLL_remove (waiting_out_head, waiting_out_tail, se);
@@ -138,8 +139,14 @@ static void run_experiment_inbound (void *cls,const struct GNUNET_SCHEDULER_Task
                                         se->task = GNUNET_SCHEDULER_add_delayed (start, &run_experiment_inbound, se);
                         break;
                 case REQUESTED:
-                case STARTED:
+                        experiments_inbound_running ++;
+                        GNUNET_STATISTICS_set (GED_stats, "# experiments inbound running", experiments_inbound_running, GNUNET_NO);
+                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Starting inbound experiment `%s' with peer `%s'\n"),
+                                        se->e->name, GNUNET_i2s (&se->n->id));
                         se->state = STARTED;
+                        se->task = GNUNET_SCHEDULER_add_now (&run_experiment_inbound, se);
+                        break;
+                case STARTED:
                         /* Experiment is running */
                         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running %s experiment `%s' peer for `%s'\n",
                                         "inbound", GNUNET_i2s (&se->n->id), se->e->name);
@@ -175,7 +182,7 @@ static void run_experiment_outbound (void *cls,const struct GNUNET_SCHEDULER_Tas
         switch (se->state) {
                 case NOT_RUNNING:
                         /* Send START message */
-                        GED_nodes_request_start (se->n, se->e);
+                        GED_nodes_send_start (se->n, se->e);
                         se->state = REQUESTED;
                         se->task = GNUNET_SCHEDULER_add_delayed (EXP_RESPONSE_TIMEOUT, &request_timeout, se);
                         experiments_requested ++;
@@ -225,13 +232,11 @@ GED_scheduler_handle_start (struct Node *n, struct Experiment *e)
         if ((NULL != (se = find_experiment (waiting_in_head, waiting_in_tail, n, e, GNUNET_NO))) ||
                  (NULL != (se = find_experiment (running_in_head, running_in_tail, n, e, GNUNET_NO))))
         {
-                GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received duplicate %s message from peer %s for experiment `%s'\n"),
-                                "START", GNUNET_i2s (&n->id), e->name);
                 GNUNET_break_op (0);
                 return;
         }
 
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received %s message from peer %s for experiment `%s'\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s message from peer %s for experiment `%s'\n",
                         "START", GNUNET_i2s (&n->id), e->name);
 
         GED_scheduler_add (n, e, GNUNET_NO);
@@ -254,7 +259,7 @@ GED_scheduler_handle_start_ack (struct Node *n, struct Experiment *e)
                 return;
         }
 
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received %s message from peer %s for requested experiment `%s'\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s message from peer %s for requested experiment `%s'\n",
                         "START_ACK", GNUNET_i2s (&n->id), e->name);
 
         if (GNUNET_SCHEDULER_NO_TASK != se->task)
@@ -268,6 +273,10 @@ GED_scheduler_handle_start_ack (struct Node *n, struct Experiment *e)
         GNUNET_CONTAINER_DLL_insert (running_out_head, running_out_tail, se);
 
         /* Change state and schedule to run */
+        experiments_outbound_running ++;
+        GNUNET_STATISTICS_set (GED_stats, "# experiments outbound running", experiments_outbound_running, GNUNET_NO);
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Starting outbound experiment `%s' with peer `%s'\n"),
+                        e->name, GNUNET_i2s (&n->id));
         se->state = STARTED;
         se->task = GNUNET_SCHEDULER_add_now (&run_experiment_outbound, se);
 }
@@ -284,18 +293,18 @@ GED_scheduler_handle_stop (struct Node *n, struct Experiment *e)
 {
         struct ScheduledExperiment *se;
 
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received %s message from peer %s for experiment `%s'\n"),
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Received %s message from peer %s for experiment `%s'\n"),
                         "STOP", GNUNET_i2s (&n->id), e->name);
 
         if (NULL != (se = find_experiment (waiting_in_head, waiting_in_tail, n, e, GNUNET_NO)))
         {
-                GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received %s message from peer %s for waiting experiment `%s'\n"),
+                GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s message from peer %s for waiting experiment `%s'\n",
                                 "STOP", GNUNET_i2s (&n->id), e->name);
         }
 
         if (NULL != (se = find_experiment (running_in_head, running_in_tail, n, e, GNUNET_NO)))
         {
-                GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received %s message from peer %s for running experiment `%s'\n"),
+                GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received %s message from peer %s for running experiment `%s'\n",
                                 "STOP", GNUNET_i2s (&n->id), e->name);
         }
 
@@ -346,7 +355,7 @@ GED_scheduler_add (struct Node *n, struct Experiment *e, int outbound)
                 GNUNET_CONTAINER_DLL_insert (waiting_in_head, waiting_in_tail, se);
         }
 
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Added %s experiment `%s' for node to be scheduled\n",
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added %s experiment `%s' for node to be scheduled\n",
                         (GNUNET_YES == outbound) ? "outbound" : "inbound", e->name, GNUNET_i2s(&se->n->id));
         experiments_scheduled ++;
         GNUNET_STATISTICS_set (GED_stats, "# experiments scheduled", experiments_scheduled, GNUNET_NO);
@@ -400,9 +409,9 @@ GED_scheduler_stop ()
                                         cur->task = GNUNET_SCHEDULER_NO_TASK;
                         }
                         GNUNET_free (cur);
-                        GNUNET_assert (experiments_running > 0);
-                        experiments_running --;
-                        GNUNET_STATISTICS_set (GED_stats, "# experiments running", experiments_running, GNUNET_NO);
+                        GNUNET_assert (experiments_outbound_running > 0);
+                        experiments_inbound_running --;
+                        GNUNET_STATISTICS_set (GED_stats, "# experiments inbound running", experiments_inbound_running, GNUNET_NO);
         }
 
         next = waiting_out_head;
@@ -432,9 +441,9 @@ GED_scheduler_stop ()
                                         cur->task = GNUNET_SCHEDULER_NO_TASK;
                         }
                         GNUNET_free (cur);
-                        GNUNET_assert (experiments_running > 0);
-                        experiments_running --;
-                        GNUNET_STATISTICS_set (GED_stats, "# experiments running", experiments_running, GNUNET_NO);
+                        GNUNET_assert (experiments_outbound_running > 0);
+                        experiments_outbound_running --;
+                        GNUNET_STATISTICS_set (GED_stats, "# experiments outbound running", experiments_outbound_running, GNUNET_NO);
         }
 }
 
diff --git a/src/experimentation/test_experimentation_clique_run.c b/src/experimentation/test_experimentation_clique_run.c
index bc325c5c9..b6329bb8e 100644
--- a/src/experimentation/test_experimentation_clique_run.c
+++ b/src/experimentation/test_experimentation_clique_run.c
@@ -91,7 +91,8 @@ struct ExperimentationPeer
   unsigned int inactive_nodes;
   unsigned int issuer;
   unsigned int experiments_active;
-  unsigned int experiments_running;
+  unsigned int experiments_outbound_running;
+  unsigned int experiments_inbound_running;
 };
 
 
@@ -162,21 +163,31 @@ controller_event_cb (void *cls,
 static void
 check_end ()
 {
-
-        static int last_experiments_value = 0;
+        static int last_in_experiments_value = 0;
+        static int last_out_experiments_value = 0;
   unsigned int peer;
-  unsigned int t_running_experiments = 0;
+  unsigned int t_running_outbound_experiments = 0;
+  unsigned int t_running_inbound_experiments = 0;
 
         for (peer = 0; peer < NUM_PEERS; peer++)
         {
-                t_running_experiments += ph[peer].experiments_running;
+                t_running_outbound_experiments += ph[peer].experiments_outbound_running;
+                t_running_inbound_experiments += ph[peer].experiments_inbound_running;
+
         }
 
-        if (last_experiments_value < t_running_experiments)
+        //fprintf (stderr, "%u %u \n", t_running_outbound_experiments, t_running_inbound_experiments);
+        if (last_in_experiments_value < t_running_inbound_experiments)
                 fprintf (stderr, ".");
-        last_experiments_value = t_running_experiments;
+        last_in_experiments_value = t_running_inbound_experiments;
+        if (last_out_experiments_value < t_running_outbound_experiments)
+                fprintf (stderr, ".");
+        last_out_experiments_value = t_running_outbound_experiments;
+
 
-        if (t_running_experiments == (NUM_PEERS * NUM_EXPERIMENTS))
+
+        if ((t_running_inbound_experiments == (NUM_PEERS * NUM_EXPERIMENTS)) &&
+                        (t_running_outbound_experiments == (NUM_PEERS * NUM_EXPERIMENTS)))
         {
                         fprintf (stderr, "\n");
                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "All %u peers are running experiments\n", NUM_PEERS);
@@ -207,11 +218,17 @@ stat_iterator (void *cls, const char *subsystem, const char *name,
                         peer->experiments_active = value;
         }
 
-        if (0 == strcmp (name, "# experiments running"))
+        if (0 == strcmp (name, "# experiments outbound running"))
         {
-                        peer->experiments_running = value;
+                        peer->experiments_outbound_running = value;
         }
 
+        if (0 == strcmp (name, "# experiments inbound running"))
+        {
+                        peer->experiments_inbound_running = value;
+        }
+
+
         check_end ();
 
         return GNUNET_OK;
@@ -244,7 +261,10 @@ stat_comp_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
                 (peer->sh, "experimentation", "# experiments active",
                  stat_iterator, peer));
   GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
-                (peer->sh, "experimentation", "# experiments running",
+                (peer->sh, "experimentation", "# experiments outbound running",
+                 stat_iterator, peer));
+  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
+                (peer->sh, "experimentation", "# experiments inbound running",
                  stat_iterator, peer));
 }
 
@@ -283,7 +303,10 @@ stat_disconnect_adapter (void *cls, void *op_result)
                 (peer->sh, "experimentation", "# experiments active",
                  stat_iterator, peer));
   GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
-                (peer->sh, "experimentation", "# experiments running",
+                (peer->sh, "experimentation", "# experiments outbound running",
+                 stat_iterator, peer));
+  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
+                (peer->sh, "experimentation", "# experiments inbound running",
                  stat_iterator, peer));
   GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
   peer->sh = NULL;