1 files changed, 338 insertions, 340 deletions

diff --git a/src/ats-tests/perf_ats_logging.c b/src/ats-tests/perf_ats_logging.c
index 4b59515d3..e0f192ae4 100644
--- a/src/ats-tests/perf_ats_logging.c
+++ b/src/ats-tests/perf_ats_logging.c
@@ -1,19 +1,19 @@
 /*
- This file is part of GNUnet.
- Copyright (C) 2010-2013 GNUnet e.V.
+   This file is part of GNUnet.
+   Copyright (C) 2010-2013 GNUnet e.V.
 
- GNUnet is free software: you can redistribute it and/or modify it
- under the terms of the GNU Affero General Public License as published
- by the Free Software Foundation, either version 3 of the License,
- or (at your option) any later version.
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
 
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- Affero General Public License for more details.
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
 
- You should have received a copy of the GNU Affero General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
  */
@@ -28,25 +28,25 @@
 #include "perf_ats.h"
 
 #define THROUGHPUT_TEMPLATE "#!/usr/bin/gnuplot \n" \
-"set datafile separator ';' \n" \
-"set title \"Throughput between Master and Slaves\" \n" \
-"set xlabel \"Time in ms\" \n" \
-"set ylabel \"Bytes/s\" \n" \
-"set grid \n"
+  "set datafile separator ';' \n" \
+  "set title \"Throughput between Master and Slaves\" \n" \
+  "set xlabel \"Time in ms\" \n" \
+  "set ylabel \"Bytes/s\" \n" \
+  "set grid \n"
 
 #define RTT_TEMPLATE "#!/usr/bin/gnuplot \n" \
-"set datafile separator ';' \n" \
-"set title \"Application level roundtrip time between Master and Slaves\" \n" \
-"set xlabel \"Time in ms\" \n" \
-"set ylabel \"ms\" \n" \
-"set grid \n"
+  "set datafile separator ';' \n" \
+  "set title \"Application level roundtrip time between Master and Slaves\" \n" \
+  "set xlabel \"Time in ms\" \n" \
+  "set ylabel \"ms\" \n" \
+  "set grid \n"
 
 #define BW_TEMPLATE "#!/usr/bin/gnuplot \n" \
-"set datafile separator ';' \n" \
-"set title \"Bandwidth inbound and outbound between Master and Slaves\" \n" \
-"set xlabel \"Time in ms\" \n" \
-"set ylabel \"Bytes / s \" \n" \
-"set grid \n"
+  "set datafile separator ';' \n" \
+  "set title \"Bandwidth inbound and outbound between Master and Slaves\" \n" \
+  "set xlabel \"Time in ms\" \n" \
+  "set ylabel \"Bytes / s \" \n" \
+  "set grid \n"
 
 #define LOG_ITEMS_TIME 2
 #define LOG_ITEMS_PER_PEER 17
@@ -85,8 +85,7 @@ static struct GNUNET_TIME_Relative frequency;
 /**
  * A single logging time step for a partner
  */
-struct PartnerLoggingTimestep
-{
+struct PartnerLoggingTimestep {
   /**
    * Peer
    */
@@ -159,8 +158,7 @@ struct PartnerLoggingTimestep
 /**
  * A single logging time step for a peer
  */
-struct PeerLoggingTimestep
-{
+struct PeerLoggingTimestep {
   /**
    * Next in DLL
    */
@@ -215,8 +213,7 @@ struct PeerLoggingTimestep
 /**
  * Entry for a benchmark peer
  */
-struct LoggingPeer
-{
+struct LoggingPeer {
   /**
    * Peer
    */
@@ -245,7 +242,7 @@ static struct LoggingPeer *lp;
 
 
 static void
-write_throughput_gnuplot_script (char * fn, struct LoggingPeer *lp)
+write_throughput_gnuplot_script(char * fn, struct LoggingPeer *lp)
 {
   struct GNUNET_DISK_FileHandle *f;
   char * gfn;
@@ -253,57 +250,57 @@ write_throughput_gnuplot_script (char * fn, struct LoggingPeer *lp)
   int c_s;
   int peer_index;
 
-  GNUNET_asprintf (&gfn, "gnuplot_throughput_%s",fn);
-  f = GNUNET_DISK_file_open (gfn,
-      GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
-      GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+  GNUNET_asprintf(&gfn, "gnuplot_throughput_%s", fn);
+  f = GNUNET_DISK_file_open(gfn,
+                            GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
+                            GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == f)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", gfn);
-    GNUNET_free (gfn);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", gfn);
+      GNUNET_free(gfn);
+      return;
+    }
 
   /* Write header */
 
   if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, THROUGHPUT_TEMPLATE, strlen(THROUGHPUT_TEMPLATE)))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
 
   /* Write master data */
   peer_index = LOG_ITEMS_TIME;
-  GNUNET_asprintf (&data, "plot '%s' using 2:%u with lines title 'Master %u send total', \\\n" \
-                           "'%s' using 2:%u with lines title 'Master %u receive total', \\\n",
-                           fn, peer_index + LOG_ITEM_THROUGHPUT_SENT, lp->peer->no,
-                           fn, peer_index + LOG_ITEM_THROUGHPUT_RECV, lp->peer->no);
+  GNUNET_asprintf(&data, "plot '%s' using 2:%u with lines title 'Master %u send total', \\\n" \
+                  "'%s' using 2:%u with lines title 'Master %u receive total', \\\n",
+                  fn, peer_index + LOG_ITEM_THROUGHPUT_SENT, lp->peer->no,
+                  fn, peer_index + LOG_ITEM_THROUGHPUT_RECV, lp->peer->no);
   if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
-  GNUNET_free (data);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
+  GNUNET_free(data);
 
-  peer_index = LOG_ITEMS_TIME + LOG_ITEMS_PER_PEER ;
+  peer_index = LOG_ITEMS_TIME + LOG_ITEMS_PER_PEER;
   for (c_s = 0; c_s < lp->peer->num_partners; c_s++)
-  {
-    GNUNET_asprintf (&data, "'%s' using 2:%u with lines title 'Master %u - Slave %u send', \\\n" \
-                            "'%s' using 2:%u with lines title 'Master %u - Slave %u receive'%s\n",
-                            fn, peer_index + LOG_ITEM_THROUGHPUT_SENT, lp->peer->no, lp->peer->partners[c_s].dest->no,
-                            fn, peer_index + LOG_ITEM_THROUGHPUT_RECV, lp->peer->no, lp->peer->partners[c_s].dest->no,
-                            (c_s < lp->peer->num_partners -1) ? ", \\" : "\n pause -1");
-    if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
-    GNUNET_free (data);
-    peer_index += LOG_ITEMS_PER_PEER;
-  }
+    {
+      GNUNET_asprintf(&data, "'%s' using 2:%u with lines title 'Master %u - Slave %u send', \\\n" \
+                      "'%s' using 2:%u with lines title 'Master %u - Slave %u receive'%s\n",
+                      fn, peer_index + LOG_ITEM_THROUGHPUT_SENT, lp->peer->no, lp->peer->partners[c_s].dest->no,
+                      fn, peer_index + LOG_ITEM_THROUGHPUT_RECV, lp->peer->no, lp->peer->partners[c_s].dest->no,
+                      (c_s < lp->peer->num_partners - 1) ? ", \\" : "\n pause -1");
+      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
+      GNUNET_free(data);
+      peer_index += LOG_ITEMS_PER_PEER;
+    }
 
   if (GNUNET_SYSERR == GNUNET_DISK_file_close(f))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n", gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n", gfn);
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Data successfully written to plot file `%s'\n", gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Data successfully written to plot file `%s'\n", gfn);
 
-  GNUNET_free (gfn);
+  GNUNET_free(gfn);
 }
 
 
 static void
-write_rtt_gnuplot_script (char * fn, struct LoggingPeer *lp)
+write_rtt_gnuplot_script(char * fn, struct LoggingPeer *lp)
 {
   struct GNUNET_DISK_FileHandle *f;
   char * gfn;
@@ -311,44 +308,44 @@ write_rtt_gnuplot_script (char * fn, struct LoggingPeer *lp)
   int c_s;
   int index;
 
-  GNUNET_asprintf (&gfn, "gnuplot_rtt_%s",fn);
-  f = GNUNET_DISK_file_open (gfn,
-      GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
-      GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+  GNUNET_asprintf(&gfn, "gnuplot_rtt_%s", fn);
+  f = GNUNET_DISK_file_open(gfn,
+                            GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
+                            GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == f)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", gfn);
-    GNUNET_free (gfn);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", gfn);
+      GNUNET_free(gfn);
+      return;
+    }
 
   /* Write header */
 
   if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, RTT_TEMPLATE, strlen(RTT_TEMPLATE)))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
 
   index = LOG_ITEMS_TIME + LOG_ITEMS_PER_PEER;
   for (c_s = 0; c_s < lp->peer->num_partners; c_s++)
-  {
-    GNUNET_asprintf (&data, "%s'%s' using 2:%u with lines title 'Master %u - Slave %u '%s\n",
-        (0 == c_s) ? "plot " :"",
-        fn, index + LOG_ITEM_APP_RTT, lp->peer->no, lp->peer->partners[c_s].dest->no,
-        (c_s < lp->peer->num_partners -1) ? ", \\" : "\n pause -1");
-    if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
-    GNUNET_free (data);
-    index += LOG_ITEMS_PER_PEER;
-  }
+    {
+      GNUNET_asprintf(&data, "%s'%s' using 2:%u with lines title 'Master %u - Slave %u '%s\n",
+                      (0 == c_s) ? "plot " : "",
+                      fn, index + LOG_ITEM_APP_RTT, lp->peer->no, lp->peer->partners[c_s].dest->no,
+                      (c_s < lp->peer->num_partners - 1) ? ", \\" : "\n pause -1");
+      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
+      GNUNET_free(data);
+      index += LOG_ITEMS_PER_PEER;
+    }
 
   if (GNUNET_SYSERR == GNUNET_DISK_file_close(f))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n", gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n", gfn);
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Data successfully written to plot file `%s'\n", gfn);
-  GNUNET_free (gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Data successfully written to plot file `%s'\n", gfn);
+  GNUNET_free(gfn);
 }
 
 static void
-write_bw_gnuplot_script (char * fn, struct LoggingPeer *lp)
+write_bw_gnuplot_script(char * fn, struct LoggingPeer *lp)
 {
   struct GNUNET_DISK_FileHandle *f;
   char * gfn;
@@ -356,49 +353,49 @@ write_bw_gnuplot_script (char * fn, struct LoggingPeer *lp)
   int c_s;
   int index;
 
-  GNUNET_asprintf (&gfn, "gnuplot_bw_%s",fn);
-  f = GNUNET_DISK_file_open (gfn,
-      GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
-      GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+  GNUNET_asprintf(&gfn, "gnuplot_bw_%s", fn);
+  f = GNUNET_DISK_file_open(gfn,
+                            GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
+                            GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == f)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", gfn);
-    GNUNET_free (gfn);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", gfn);
+      GNUNET_free(gfn);
+      return;
+    }
 
   /* Write header */
 
   if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, BW_TEMPLATE, strlen(BW_TEMPLATE)))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
 
   index = LOG_ITEMS_TIME + LOG_ITEMS_PER_PEER;
   for (c_s = 0; c_s < lp->peer->num_partners; c_s++)
-  {
-    GNUNET_asprintf (&data, "%s"\
-        "'%s' using 2:%u with lines title 'BW out master %u - Slave %u ', \\\n" \
-        "'%s' using 2:%u with lines title 'BW in master %u - Slave %u '"\
-        "%s\n",
-        (0 == c_s) ? "plot " :"",
-        fn, index + LOG_ITEM_ATS_BW_OUT, lp->peer->no, lp->peer->partners[c_s].dest->no,
-        fn, index + LOG_ITEM_ATS_BW_IN, lp->peer->no, lp->peer->partners[c_s].dest->no,
-        (c_s < lp->peer->num_partners -1) ? ", \\" : "\n pause -1");
-    if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
-    GNUNET_free (data);
-    index += LOG_ITEMS_PER_PEER;
-  }
+    {
+      GNUNET_asprintf(&data, "%s" \
+                      "'%s' using 2:%u with lines title 'BW out master %u - Slave %u ', \\\n" \
+                      "'%s' using 2:%u with lines title 'BW in master %u - Slave %u '" \
+                      "%s\n",
+                      (0 == c_s) ? "plot " : "",
+                      fn, index + LOG_ITEM_ATS_BW_OUT, lp->peer->no, lp->peer->partners[c_s].dest->no,
+                      fn, index + LOG_ITEM_ATS_BW_IN, lp->peer->no, lp->peer->partners[c_s].dest->no,
+                      (c_s < lp->peer->num_partners - 1) ? ", \\" : "\n pause -1");
+      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn);
+      GNUNET_free(data);
+      index += LOG_ITEMS_PER_PEER;
+    }
 
   if (GNUNET_SYSERR == GNUNET_DISK_file_close(f))
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n", gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n", gfn);
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Data successfully written to plot file `%s'\n", gfn);
-  GNUNET_free (gfn);
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Data successfully written to plot file `%s'\n", gfn);
+  GNUNET_free(gfn);
 }
 
 
 static void
-write_to_file ()
+write_to_file()
 {
   struct GNUNET_DISK_FileHandle *f;
 
@@ -412,88 +409,88 @@ write_to_file ()
   int c_s;
 
   for (c_m = 0; c_m < num_peers; c_m++)
-  {
-    GNUNET_asprintf (&filename, "%llu_master_%u_%s_%s.data", GNUNET_TIME_absolute_get().abs_value_us,
-        lp[c_m].peer->no, GNUNET_i2s(&lp[c_m].peer->id), name);
-
-    f = GNUNET_DISK_file_open (filename,
-        GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
-        GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
-    if (NULL == f)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open log file `%s'\n", filename);
-      GNUNET_free (filename);
-      return;
+      GNUNET_asprintf(&filename, "%llu_master_%u_%s_%s.data", GNUNET_TIME_absolute_get().abs_value_us,
+                      lp[c_m].peer->no, GNUNET_i2s(&lp[c_m].peer->id), name);
+
+      f = GNUNET_DISK_file_open(filename,
+                                GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
+                                GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+      if (NULL == f)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot open log file `%s'\n", filename);
+          GNUNET_free(filename);
+          return;
+        }
+
+      for (cur_lt = lp[c_m].head; NULL != cur_lt; cur_lt = cur_lt->next)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                     "Master [%u]: timestamp %llu %llu ; %u %u %u ; %u %u %u\n", lp[c_m].peer->no,
+                     cur_lt->timestamp, GNUNET_TIME_absolute_get_difference(lp[c_m].start, cur_lt->timestamp).rel_value_us / 1000,
+                     cur_lt->total_messages_sent, cur_lt->total_bytes_sent, cur_lt->total_throughput_send,
+                     cur_lt->total_messages_received, cur_lt->total_bytes_received, cur_lt->total_throughput_recv);
+
+          slave_string = GNUNET_strdup(";");
+          for (c_s = 0; c_s < lp[c_m].peer->num_partners; c_s++)
+            {
+              plt = &cur_lt->slaves_log[c_s];
+              /* Log partners */
+
+              /* Assembling slave string */
+              GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+                         "\t Slave [%u]: %u %u %u ; %u %u %u rtt %u delay %u bw_in %u bw_out %u \n", plt->slave->no,
+                         plt->total_messages_sent, plt->total_bytes_sent, plt->throughput_sent,
+                         plt->total_messages_received, plt->total_bytes_received, plt->throughput_recv,
+                         plt->app_rtt, plt->ats_delay,
+                         plt->bandwidth_in, plt->bandwidth_out);
+
+              GNUNET_asprintf(&slave_string_tmp, "%s%u;%u;%u;%u;%u;%u;%.3f;%u;%u;%u;%u;%u;%u;%u;%u;%u;%u;", slave_string,
+                              plt->total_messages_sent, plt->total_bytes_sent, plt->throughput_sent,
+                              plt->total_messages_received, plt->total_bytes_received, plt->throughput_sent,
+                              (double)plt->app_rtt / 1000,
+                              plt->bandwidth_in, plt->bandwidth_out,
+                              plt->ats_cost_lan, plt->ats_cost_wan, plt->ats_cost_wlan,
+                              plt->ats_delay, plt->ats_distance, plt->ats_network_type,
+                              plt->ats_utilization_up, plt->ats_utilization_down);
+              GNUNET_free(slave_string);
+              slave_string = slave_string_tmp;
+            }
+          /* Assembling master string */
+
+
+
+          GNUNET_asprintf(&data, "%llu;%llu;%u;%u;%u;%u;%u;%u;;;;;;;;;;;%s\n",
+                          cur_lt->timestamp,
+                          GNUNET_TIME_absolute_get_difference(lp[c_m].start, cur_lt->timestamp).rel_value_us / 1000,
+                          cur_lt->total_messages_sent, cur_lt->total_bytes_sent, cur_lt->total_throughput_send,
+                          cur_lt->total_messages_received, cur_lt->total_bytes_received, cur_lt->total_throughput_recv,
+                          slave_string);
+          GNUNET_free(slave_string);
+
+          if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
+            GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot write data to log file `%s'\n", filename);
+          GNUNET_free(data);
+        }
+      if (GNUNET_SYSERR == GNUNET_DISK_file_close(f))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot close log file `%s'\n", filename);
+          GNUNET_free(filename);
+          return;
+        }
+
+      write_throughput_gnuplot_script(filename, lp);
+      write_rtt_gnuplot_script(filename, lp);
+      write_bw_gnuplot_script(filename, lp);
+
+      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Data file successfully written to log file `%s'\n", filename);
+      GNUNET_free(filename);
     }
-
-    for (cur_lt = lp[c_m].head; NULL != cur_lt; cur_lt = cur_lt->next)
-    {
-       GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-          "Master [%u]: timestamp %llu %llu ; %u %u %u ; %u %u %u\n", lp[c_m].peer->no,
-          cur_lt->timestamp, GNUNET_TIME_absolute_get_difference(lp[c_m].start,cur_lt->timestamp).rel_value_us / 1000,
-          cur_lt->total_messages_sent, cur_lt->total_bytes_sent, cur_lt->total_throughput_send,
-          cur_lt->total_messages_received, cur_lt->total_bytes_received, cur_lt->total_throughput_recv);
-
-      slave_string = GNUNET_strdup (";");
-      for (c_s = 0; c_s < lp[c_m].peer->num_partners; c_s++)
-      {
-        plt = &cur_lt->slaves_log[c_s];
-        /* Log partners */
-
-        /* Assembling slave string */
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-            "\t Slave [%u]: %u %u %u ; %u %u %u rtt %u delay %u bw_in %u bw_out %u \n", plt->slave->no,
-            plt->total_messages_sent, plt->total_bytes_sent, plt->throughput_sent,
-            plt->total_messages_received, plt->total_bytes_received, plt->throughput_recv,
-            plt->app_rtt, plt->ats_delay,
-            plt->bandwidth_in, plt->bandwidth_out);
-
-        GNUNET_asprintf(&slave_string_tmp, "%s%u;%u;%u;%u;%u;%u;%.3f;%u;%u;%u;%u;%u;%u;%u;%u;%u;%u;",slave_string,
-            plt->total_messages_sent, plt->total_bytes_sent,  plt->throughput_sent,
-            plt->total_messages_received, plt->total_bytes_received,  plt->throughput_sent,
-            (double) plt->app_rtt / 1000,
-            plt->bandwidth_in,plt->bandwidth_out,
-            plt->ats_cost_lan, plt->ats_cost_wan, plt->ats_cost_wlan,
-            plt->ats_delay, plt->ats_distance, plt->ats_network_type,
-            plt->ats_utilization_up, plt->ats_utilization_down);
-        GNUNET_free (slave_string);
-        slave_string = slave_string_tmp;
-      }
-      /* Assembling master string */
-
-
-
-      GNUNET_asprintf (&data, "%llu;%llu;%u;%u;%u;%u;%u;%u;;;;;;;;;;;%s\n",
-          cur_lt->timestamp,
-          GNUNET_TIME_absolute_get_difference(lp[c_m].start,cur_lt->timestamp).rel_value_us / 1000,
-          cur_lt->total_messages_sent, cur_lt->total_bytes_sent,  cur_lt->total_throughput_send,
-          cur_lt->total_messages_received, cur_lt->total_bytes_received, cur_lt->total_throughput_recv,
-          slave_string);
-      GNUNET_free (slave_string);
-
-      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to log file `%s'\n", filename);
-      GNUNET_free (data);
-    }
-    if (GNUNET_SYSERR == GNUNET_DISK_file_close(f))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close log file `%s'\n", filename);
-      GNUNET_free (filename);
-      return;
-    }
-
-    write_throughput_gnuplot_script (filename, lp);
-    write_rtt_gnuplot_script (filename, lp);
-    write_bw_gnuplot_script (filename, lp);
-
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Data file successfully written to log file `%s'\n", filename);
-    GNUNET_free (filename);
-  }
 }
 
 
 void
-collect_log_now (void)
+collect_log_now(void)
 {
   struct LoggingPeer *bp;
   struct PeerLoggingTimestep *mlt;
@@ -511,143 +508,143 @@ collect_log_now (void)
     return;
 
   for (c_m = 0; c_m < num_peers; c_m++)
-  {
-    bp = &lp[c_m];
-    mlt = GNUNET_new (struct PeerLoggingTimestep);
-    GNUNET_CONTAINER_DLL_insert_tail(bp->head, bp->tail, mlt);
-    prev_log_mlt = mlt->prev;
-
-    /* Collect data */
-
-    /* Current master state */
-    mlt->timestamp = GNUNET_TIME_absolute_get();
-    mlt->total_bytes_sent = bp->peer->total_bytes_sent;
-    mlt->total_messages_sent = bp->peer->total_messages_sent;
-    mlt->total_bytes_received = bp->peer->total_bytes_received;
-    mlt->total_messages_received = bp->peer->total_messages_received;
-
-    /* Throughput */
-    if (NULL == prev_log_mlt)
-     {
-       /* Get difference to start */
-       delta = GNUNET_TIME_absolute_get_difference (lp[c_m].start, mlt->timestamp);
-     }
-     else
-     {
-       /* Get difference to last timestep */
-       delta = GNUNET_TIME_absolute_get_difference (mlt->prev->timestamp, mlt->timestamp);
-     }
-
-     /* Multiplication factor for throughput calculation */
-     mult = (1.0 * 1000 * 1000) / (delta.rel_value_us);
-
-     /* Total throughput */
-     if (NULL != prev_log_mlt)
-     {
-       if (mlt->total_bytes_sent - mlt->prev->total_bytes_sent > 0)
-         mlt->total_throughput_send = mult * (mlt->total_bytes_sent - mlt->prev->total_bytes_sent);
-       else
-         mlt->total_throughput_send = prev_log_mlt->total_throughput_send; /* no msgs send */
-
-       if (mlt->total_bytes_received - mlt->prev->total_bytes_received > 0)
-         mlt->total_throughput_recv = mult * (mlt->total_bytes_received - mlt->prev->total_bytes_received);
-       else
-         mlt->total_throughput_recv = prev_log_mlt->total_throughput_recv; /* no msgs received */
-     }
-     else
-     {
-       mlt->total_throughput_send = mult * mlt->total_bytes_sent;
-       mlt->total_throughput_send = mult * mlt->total_bytes_received;
-     }
-
-    mlt->slaves_log = GNUNET_malloc (bp->peer->num_partners *
-        sizeof (struct PartnerLoggingTimestep));
-
-    for (c_s = 0; c_s < bp->peer->num_partners; c_s++)
     {
-      p = &bp->peer->partners[c_s];
-      slt = &mlt->slaves_log[c_s];
-
-      slt->slave = p->dest;
-      /* Bytes sent from master to this slave */
-      slt->total_bytes_sent = p->bytes_sent;
-      /* Messages sent from master to this slave */
-      slt->total_messages_sent = p->messages_sent;
-      /* Bytes master received from this slave */
-      slt->total_bytes_received = p->bytes_received;
-      /* Messages master received from this slave */
-      slt->total_messages_received = p->messages_received;
-      slt->total_app_rtt = p->total_app_rtt;
-      /* ats performance information */
-      slt->ats_cost_lan = p->ats_cost_lan;
-      slt->ats_cost_wan = p->ats_cost_wan;
-      slt->ats_cost_wlan = p->ats_cost_wlan;
-      slt->ats_delay = p->ats_delay;
-      slt->ats_distance = p->ats_distance;
-      slt->ats_network_type = p->ats_network_type;
-      slt->ats_utilization_down = p->ats_utilization_down;
-      slt->ats_utilization_up = p->ats_utilization_up;
-      slt->bandwidth_in = p->bandwidth_in;
-      slt->bandwidth_out = p->bandwidth_out;
-
-      /* Total application level rtt  */
+      bp = &lp[c_m];
+      mlt = GNUNET_new(struct PeerLoggingTimestep);
+      GNUNET_CONTAINER_DLL_insert_tail(bp->head, bp->tail, mlt);
+      prev_log_mlt = mlt->prev;
+
+      /* Collect data */
+
+      /* Current master state */
+      mlt->timestamp = GNUNET_TIME_absolute_get();
+      mlt->total_bytes_sent = bp->peer->total_bytes_sent;
+      mlt->total_messages_sent = bp->peer->total_messages_sent;
+      mlt->total_bytes_received = bp->peer->total_bytes_received;
+      mlt->total_messages_received = bp->peer->total_messages_received;
+
+      /* Throughput */
       if (NULL == prev_log_mlt)
-      {
-        if (0 != slt->total_messages_sent)
-          app_rtt = slt->total_app_rtt / slt->total_messages_sent;
-        else
-          app_rtt = 0;
-      }
+        {
+          /* Get difference to start */
+          delta = GNUNET_TIME_absolute_get_difference(lp[c_m].start, mlt->timestamp);
+        }
       else
-      {
-        prev_log_slt =  &prev_log_mlt->slaves_log[c_s];
-        if ((slt->total_messages_sent - prev_log_slt->total_messages_sent) > 0)
-          app_rtt = (slt->total_app_rtt - prev_log_slt->total_app_rtt) /
-                  (slt->total_messages_sent - prev_log_slt->total_messages_sent);
-        else
-          app_rtt = prev_log_slt->app_rtt; /* No messages were */
-      }
-      slt->app_rtt = app_rtt;
-
-      /* Partner throughput */
+        {
+          /* Get difference to last timestep */
+          delta = GNUNET_TIME_absolute_get_difference(mlt->prev->timestamp, mlt->timestamp);
+        }
+
+      /* Multiplication factor for throughput calculation */
+      mult = (1.0 * 1000 * 1000) / (delta.rel_value_us);
+
+      /* Total throughput */
       if (NULL != prev_log_mlt)
-      {
-        prev_log_slt =  &prev_log_mlt->slaves_log[c_s];
-        if (slt->total_bytes_sent - prev_log_slt->total_bytes_sent > 0)
-          slt->throughput_sent = mult * (slt->total_bytes_sent - prev_log_slt->total_bytes_sent);
-        else
-          slt->throughput_sent = prev_log_slt->throughput_sent; /* no msgs send */
-
-        if (slt->total_bytes_received - prev_log_slt->total_bytes_received > 0)
-          slt->throughput_recv = mult * (slt->total_bytes_received - prev_log_slt->total_bytes_received);
-        else
-          slt->throughput_recv = prev_log_slt->throughput_recv; /* no msgs received */
-      }
+        {
+          if (mlt->total_bytes_sent - mlt->prev->total_bytes_sent > 0)
+            mlt->total_throughput_send = mult * (mlt->total_bytes_sent - mlt->prev->total_bytes_sent);
+          else
+            mlt->total_throughput_send = prev_log_mlt->total_throughput_send; /* no msgs send */
+
+          if (mlt->total_bytes_received - mlt->prev->total_bytes_received > 0)
+            mlt->total_throughput_recv = mult * (mlt->total_bytes_received - mlt->prev->total_bytes_received);
+          else
+            mlt->total_throughput_recv = prev_log_mlt->total_throughput_recv; /* no msgs received */
+        }
       else
-      {
-        slt->throughput_sent = mult * slt->total_bytes_sent;
-        slt->throughput_sent = mult * slt->total_bytes_received;
-      }
-
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Master [%u]: slave [%u]\n",
-          bp->peer->no, p->dest->no);
+        {
+          mlt->total_throughput_send = mult * mlt->total_bytes_sent;
+          mlt->total_throughput_send = mult * mlt->total_bytes_received;
+        }
+
+      mlt->slaves_log = GNUNET_malloc(bp->peer->num_partners *
+                                      sizeof(struct PartnerLoggingTimestep));
+
+      for (c_s = 0; c_s < bp->peer->num_partners; c_s++)
+        {
+          p = &bp->peer->partners[c_s];
+          slt = &mlt->slaves_log[c_s];
+
+          slt->slave = p->dest;
+          /* Bytes sent from master to this slave */
+          slt->total_bytes_sent = p->bytes_sent;
+          /* Messages sent from master to this slave */
+          slt->total_messages_sent = p->messages_sent;
+          /* Bytes master received from this slave */
+          slt->total_bytes_received = p->bytes_received;
+          /* Messages master received from this slave */
+          slt->total_messages_received = p->messages_received;
+          slt->total_app_rtt = p->total_app_rtt;
+          /* ats performance information */
+          slt->ats_cost_lan = p->ats_cost_lan;
+          slt->ats_cost_wan = p->ats_cost_wan;
+          slt->ats_cost_wlan = p->ats_cost_wlan;
+          slt->ats_delay = p->ats_delay;
+          slt->ats_distance = p->ats_distance;
+          slt->ats_network_type = p->ats_network_type;
+          slt->ats_utilization_down = p->ats_utilization_down;
+          slt->ats_utilization_up = p->ats_utilization_up;
+          slt->bandwidth_in = p->bandwidth_in;
+          slt->bandwidth_out = p->bandwidth_out;
+
+          /* Total application level rtt  */
+          if (NULL == prev_log_mlt)
+            {
+              if (0 != slt->total_messages_sent)
+                app_rtt = slt->total_app_rtt / slt->total_messages_sent;
+              else
+                app_rtt = 0;
+            }
+          else
+            {
+              prev_log_slt = &prev_log_mlt->slaves_log[c_s];
+              if ((slt->total_messages_sent - prev_log_slt->total_messages_sent) > 0)
+                app_rtt = (slt->total_app_rtt - prev_log_slt->total_app_rtt) /
+                          (slt->total_messages_sent - prev_log_slt->total_messages_sent);
+              else
+                app_rtt = prev_log_slt->app_rtt; /* No messages were */
+            }
+          slt->app_rtt = app_rtt;
+
+          /* Partner throughput */
+          if (NULL != prev_log_mlt)
+            {
+              prev_log_slt = &prev_log_mlt->slaves_log[c_s];
+              if (slt->total_bytes_sent - prev_log_slt->total_bytes_sent > 0)
+                slt->throughput_sent = mult * (slt->total_bytes_sent - prev_log_slt->total_bytes_sent);
+              else
+                slt->throughput_sent = prev_log_slt->throughput_sent; /* no msgs send */
+
+              if (slt->total_bytes_received - prev_log_slt->total_bytes_received > 0)
+                slt->throughput_recv = mult * (slt->total_bytes_received - prev_log_slt->total_bytes_received);
+              else
+                slt->throughput_recv = prev_log_slt->throughput_recv; /* no msgs received */
+            }
+          else
+            {
+              slt->throughput_sent = mult * slt->total_bytes_sent;
+              slt->throughput_sent = mult * slt->total_bytes_received;
+            }
+
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     "Master [%u]: slave [%u]\n",
+                     bp->peer->no, p->dest->no);
+        }
     }
-  }
 }
 
 static void
-collect_log_task (void *cls)
+collect_log_task(void *cls)
 {
   log_task = NULL;
-  collect_log_now ();
-  log_task = GNUNET_SCHEDULER_add_delayed (frequency,
-                                           &collect_log_task, NULL);
+  collect_log_now();
+  log_task = GNUNET_SCHEDULER_add_delayed(frequency,
+                                          &collect_log_task, NULL);
 }
 
 
 void
-perf_logging_stop ()
+perf_logging_stop()
 {
   int c_m;
   struct PeerLoggingTimestep *cur;
@@ -656,53 +653,54 @@ perf_logging_stop ()
     return;
 
   if (NULL != log_task)
-  {
-    GNUNET_SCHEDULER_cancel (log_task);
-    log_task = NULL;
-  }
-  collect_log_task (NULL);
+    {
+      GNUNET_SCHEDULER_cancel(log_task);
+      log_task = NULL;
+    }
+  collect_log_task(NULL);
 
   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-      _("Stop logging\n"));
+             _("Stop logging\n"));
 
-  write_to_file ();
+  write_to_file();
 
   for (c_m = 0; c_m < num_peers; c_m++)
-  {
-    while (NULL != (cur = lp[c_m].head))
     {
-      GNUNET_CONTAINER_DLL_remove (lp[c_m].head, lp[c_m].tail, cur);
-      GNUNET_free (cur->slaves_log);
-      GNUNET_free (cur);
+      while (NULL != (cur = lp[c_m].head))
+        {
+          GNUNET_CONTAINER_DLL_remove(lp[c_m].head, lp[c_m].tail, cur);
+          GNUNET_free(cur->slaves_log);
+          GNUNET_free(cur);
+        }
     }
-  }
 
-  GNUNET_free (lp);
+  GNUNET_free(lp);
 }
 
 
 void
-perf_logging_start (struct GNUNET_TIME_Relative log_frequency,
-    char * testname, struct BenchmarkPeer *masters, int num_masters)
+perf_logging_start(struct GNUNET_TIME_Relative log_frequency,
+                   char * testname, struct BenchmarkPeer *masters, int num_masters)
 {
   int c_m;
+
   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-      _("Start logging `%s'\n"), testname);
+             _("Start logging `%s'\n"), testname);
 
   num_peers = num_masters;
   name = testname;
   frequency = log_frequency;
 
-  lp = GNUNET_malloc (num_masters * sizeof (struct LoggingPeer));
+  lp = GNUNET_malloc(num_masters * sizeof(struct LoggingPeer));
 
-  for (c_m = 0; c_m < num_masters; c_m ++)
-  {
-    lp[c_m].peer = &masters[c_m];
-    lp[c_m].start = GNUNET_TIME_absolute_get();
-  }
+  for (c_m = 0; c_m < num_masters; c_m++)
+    {
+      lp[c_m].peer = &masters[c_m];
+      lp[c_m].start = GNUNET_TIME_absolute_get();
+    }
 
   /* Schedule logging task */
-  log_task = GNUNET_SCHEDULER_add_now (&collect_log_task, NULL);
+  log_task = GNUNET_SCHEDULER_add_now(&collect_log_task, NULL);
   running = GNUNET_YES;
 }
 /* end of file perf_ats_logging.c */