X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttv%2Flttv%2Fsync%2Fevent_analysis_eval.c;h=5dd1f6df16677e502b32d420cef594d45731d697;hb=e072e1abc02d780d84664fcb2c971eb5a317f664;hp=05a49acca39c9c1114245e53a9e2c6b6f87fd6cb;hpb=2bd4b3e43e525da7b4c9738915ec847f7fe4906a;p=lttv.git

diff --git a/lttv/lttv/sync/event_analysis_eval.c b/lttv/lttv/sync/event_analysis_eval.c
index 05a49acc..5dd1f6df 100644
--- a/lttv/lttv/sync/event_analysis_eval.c
+++ b/lttv/lttv/sync/event_analysis_eval.c
@@ -17,6 +17,7 @@
  */
 
 #define _GNU_SOURCE
+#define _ISOC99_SOURCE
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
@@ -24,12 +25,14 @@
 
 #include <arpa/inet.h>
 #include <errno.h>
+#include <math.h>
 #include <netinet/in.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/socket.h>
+#include <unistd.h>
 
 #include "lookup3.h"
 #include "sync_chain.h"
@@ -37,6 +40,13 @@
 #include "event_analysis_eval.h"
 
 
+struct WriteGraphInfo
+{
+	GHashTable* rttInfo;
+	FILE* graphsStream;
+};
+
+
 // Functions common to all analysis modules
 static void initAnalysisEval(SyncState* const syncState);
 static void destroyAnalysisEval(SyncState* const syncState);
@@ -59,6 +69,26 @@ static void gdnDestroyDouble(gpointer data);
 static void readRttInfo(GHashTable* rttInfo, FILE* rttFile);
 static void positionStream(FILE* stream);
 
+static void gfSum(gpointer data, gpointer userData);
+static void gfSumSquares(gpointer data, gpointer userData);
+static void ghfPrintExchangeRtt(gpointer key, gpointer value, gpointer user_data);
+
+static void hitBin(struct Bins* const bins, const double value);
+static unsigned int binNum(const double value) __attribute__((pure));
+static double binStart(const unsigned int binNum) __attribute__((pure));
+static double binEnd(const unsigned int binNum) __attribute__((pure));
+
+static AnalysisGraphEval* constructAnalysisGraphEval(const char* const
+	graphsDir, const struct RttKey* const rttKey);
+static void destroyAnalysisGraphEval(AnalysisGraphEval* const graph);
+static void gdnDestroyAnalysisGraphEval(gpointer data);
+static void ghfWriteGraph(gpointer key, gpointer value, gpointer user_data);
+static void dumpBinToFile(const struct Bins* const bins, FILE* const file);
+static void writeHistogram(FILE* graphsStream, const struct RttKey* rttKey,
+	double* minRtt);
+
+
+double binBase;
 
 static AnalysisModule analysisModuleEval= {
 	.name= "eval",
@@ -77,7 +107,7 @@ static ModuleOption optionEvalRttFile= {
 	.longName= "eval-rtt-file",
 	.hasArg= REQUIRED_ARG,
 	{.arg= NULL},
-	.optionHelp= "specify the file containing rtt information",
+	.optionHelp= "specify the file containing RTT information",
 	.argHelp= "FILE",
 };
 
@@ -133,17 +163,238 @@ static void initAnalysisEval(SyncState* const syncState)
 
 	if (syncState->stats)
 	{
-		analysisData->stats= malloc(sizeof(AnalysisStatsEval));
+		analysisData->stats= calloc(1, sizeof(AnalysisStatsEval));
 		analysisData->stats->broadcastDiffSum= 0.;
 
-		analysisData->stats->allStats= malloc(syncState->traceNb *
-			sizeof(TracePairStats*));
+		analysisData->stats->messageStats= malloc(syncState->traceNb *
+			sizeof(MessageStats*));
 		for (i= 0; i < syncState->traceNb; i++)
 		{
-			analysisData->stats->allStats[i]= calloc(syncState->traceNb,
-				sizeof(TracePairStats));
+			analysisData->stats->messageStats[i]= calloc(syncState->traceNb,
+				sizeof(MessageStats));
+		}
+
+		analysisData->stats->exchangeRtt=
+			g_hash_table_new_full(&ghfRttKeyHash, &gefRttKeyEqual,
+				&gdnDestroyRttKey, &gdnDestroyDouble);
+	}
+
+	if (syncState->graphsStream)
+	{
+		binBase= exp10(6. / (BIN_NB - 3));
+		analysisData->graphs= g_hash_table_new_full(&ghfRttKeyHash,
+			&gefRttKeyEqual, &gdnDestroyRttKey, &gdnDestroyAnalysisGraphEval);
+	}
+}
+
+
+/*
+ * Create and open files used to store histogram points to generate graphs.
+ * Create data structures to store histogram points during analysis.
+ *
+ * Args:
+ *   graphsDir:    folder where to write files
+ *   rttKey:       host pair, make sure saddr < daddr
+ */
+static AnalysisGraphEval* constructAnalysisGraphEval(const char* const
+	graphsDir, const struct RttKey* const rttKey)
+{
+	int retval;
+	unsigned int i;
+	char* cwd;
+	char name[60], saddr[16], daddr[16];
+	AnalysisGraphEval* graph= calloc(1, sizeof(*graph));
+	const struct {
+		size_t pointsOffset;
+		const char* fileName;
+		const char* host1, *host2;
+	} loopValues[]= {
+		{offsetof(AnalysisGraphEval, ttSendPoints), "analysis_eval_tt-%s_to_%s.data",
+			saddr, daddr},
+		{offsetof(AnalysisGraphEval, ttRecvPoints), "analysis_eval_tt-%s_to_%s.data",
+			daddr, saddr},
+		{offsetof(AnalysisGraphEval, hrttPoints), "analysis_eval_hrtt-%s_and_%s.data",
+			saddr, daddr},
+	};
+
+	graph->ttSendBins.max= BIN_NB - 1;
+	graph->ttRecvBins.max= BIN_NB - 1;
+	graph->hrttBins.max= BIN_NB - 1;
+
+	convertIP(saddr, rttKey->saddr);
+	convertIP(daddr, rttKey->daddr);
+
+	cwd= changeToGraphDir(graphsDir);
+
+	for (i= 0; i < sizeof(loopValues) / sizeof(*loopValues); i++)
+	{
+		retval= snprintf(name, sizeof(name), loopValues[i].fileName,
+			loopValues[i].host1, loopValues[i].host2);
+		if (retval > sizeof(name) - 1)
+		{
+			name[sizeof(name) - 1]= '\0';
+		}
+		if ((*(FILE**)((void*) graph + loopValues[i].pointsOffset)=
+				fopen(name, "w")) == NULL)
+		{
+			g_error(strerror(errno));
 		}
 	}
+
+	retval= chdir(cwd);
+	if (retval == -1)
+	{
+		g_error(strerror(errno));
+	}
+	free(cwd);
+
+	return graph;
+}
+
+
+/*
+ * Close files used to store histogram points to generate graphs.
+ *
+ * Args:
+ *   graphsDir:    folder where to write files
+ *   rttKey:       host pair, make sure saddr < daddr
+ */
+static void destroyAnalysisGraphEval(AnalysisGraphEval* const graph)
+{
+	unsigned int i;
+	int retval;
+	const struct {
+		size_t pointsOffset;
+	} loopValues[]= {
+		{offsetof(AnalysisGraphEval, ttSendPoints)},
+		{offsetof(AnalysisGraphEval, ttRecvPoints)},
+		{offsetof(AnalysisGraphEval, hrttPoints)},
+	};
+
+	for (i= 0; i < sizeof(loopValues) / sizeof(*loopValues); i++)
+	{
+		retval= fclose(*(FILE**)((void*) graph + loopValues[i].pointsOffset));
+		if (retval != 0)
+		{
+			g_error(strerror(errno));
+		}
+	}
+}
+
+
+/*
+ * A GDestroyNotify function for g_hash_table_new_full()
+ *
+ * Args:
+ *   data:         AnalysisGraphEval*
+ */
+static void gdnDestroyAnalysisGraphEval(gpointer data)
+{
+	destroyAnalysisGraphEval(data);
+}
+
+
+/*
+ * A GHFunc for g_hash_table_foreach()
+ *
+ * Args:
+ *   key:          RttKey* where saddr < daddr
+ *   value:        AnalysisGraphEval*
+ *   user_data     struct WriteGraphInfo*
+ */
+static void ghfWriteGraph(gpointer key, gpointer value, gpointer user_data)
+{
+	double* rtt1, * rtt2;
+	struct RttKey* rttKey= key;
+	struct RttKey oppositeRttKey= {.saddr= rttKey->daddr, .daddr=
+		rttKey->saddr};
+	AnalysisGraphEval* graph= value;
+	struct WriteGraphInfo* info= user_data;
+
+	rtt1= g_hash_table_lookup(info->rttInfo, rttKey);
+	rtt2= g_hash_table_lookup(info->rttInfo, &oppositeRttKey);
+
+	if (rtt1 == NULL)
+	{
+		rtt1= rtt2;
+	}
+	else if (rtt2 != NULL)
+	{
+		rtt1= MIN(rtt1, rtt2);
+	}
+
+	dumpBinToFile(&graph->ttSendBins, graph->ttSendPoints);
+	dumpBinToFile(&graph->ttRecvBins, graph->ttRecvPoints);
+	dumpBinToFile(&graph->hrttBins, graph->hrttPoints);
+	writeHistogram(info->graphsStream, rttKey, rtt1);
+}
+
+
+/*
+ * Write the content of one bin in a histogram point file
+ *
+ * Args:
+ *   bin:          array of values that make up a histogram
+ *   file:         FILE*, write to this file
+ */
+static void dumpBinToFile(const struct Bins* const bins, FILE* const file)
+{
+	unsigned int i;
+
+	// The first and last bins are skipped, see struct Bins
+	for (i= 1; i < BIN_NB - 1; i++)
+	{
+		if (bins->bin[i] > 0)
+		{
+			fprintf(file, "%20.9f %20.9f %20.9f\n", (binStart(i) + binEnd(i))
+				/ 2., (double) bins->bin[i] / ((binEnd(i) - binStart(i)) *
+					bins->total), binEnd(i) - binStart(i));
+		}
+	}
+}
+
+
+/*
+ * Write the analysis-specific plot in the gnuplot script.
+ *
+ * Args:
+ *   graphsStream: write to this file
+ *   rttKey:       must be sorted such that saddr < daddr
+ *   minRtt:       if available, else NULL
+ */
+static void writeHistogram(FILE* graphsStream, const struct RttKey* rttKey,
+	double* minRtt)
+{
+	char saddr[16], daddr[16];
+
+	convertIP(saddr, rttKey->saddr);
+	convertIP(daddr, rttKey->daddr);
+
+	fprintf(graphsStream,
+		"reset\n"
+		"set output \"histogram-%s-%s.eps\"\n"
+		"set title \"\"\n"
+		"set xlabel \"Message Latency (s)\"\n"
+		"set ylabel \"Proportion of messages per second\"\n", saddr, daddr);
+
+	if (minRtt != NULL)
+	{
+		fprintf(graphsStream,
+			"set arrow from %.9f, 0 rto 0, graph 1 "
+			"nohead linetype 3 linewidth 3 linecolor rgb \"black\"\n", *minRtt / 2);
+	}
+
+	fprintf(graphsStream,
+		"plot \\\n"
+		"\t\"analysis_eval_hrtt-%1$s_and_%2$s.data\" "
+			"title \"RTT/2\" with linespoints linetype 1 linewidth 2 "
+			"linecolor rgb \"black\" pointtype 6 pointsize 1,\\\n"
+		"\t\"analysis_eval_tt-%1$s_to_%2$s.data\" "
+			"title \"%1$s to %2$s\" with linespoints linetype 4 linewidth 2 "
+			"linecolor rgb \"gray60\" pointtype 6 pointsize 1,\\\n"
+		"\t\"analysis_eval_tt-%2$s_to_%1$s.data\" "
+			"title \"%2$s to %1$s\" with linespoints linetype 4 linewidth 2 "
+			"linecolor rgb \"gray30\" pointtype 6 pointsize 1\n", saddr, daddr);
 }
 
 
@@ -174,12 +425,20 @@ static void destroyAnalysisEval(SyncState* const syncState)
 	{
 		for (i= 0; i < syncState->traceNb; i++)
 		{
-			free(analysisData->stats->allStats[i]);
+			free(analysisData->stats->messageStats[i]);
 		}
-		free(analysisData->stats->allStats);
+		free(analysisData->stats->messageStats);
+
+		g_hash_table_destroy(analysisData->stats->exchangeRtt);
+
 		free(analysisData->stats);
 	}
 
+	if (syncState->graphsStream && analysisData->graphs)
+	{
+		g_hash_table_destroy(analysisData->graphs);
+	}
+
 	free(syncState->analysisData);
 	syncState->analysisData= NULL;
 }
@@ -188,36 +447,165 @@ static void destroyAnalysisEval(SyncState* const syncState)
 /*
  * Perform analysis on an event pair.
  *
+ * Check if there is message inversion or messages that are too fast.
+ *
  * Args:
  *   syncState     container for synchronization data
  *   message       structure containing the events
  */
 static void analyzeMessageEval(SyncState* const syncState, Message* const message)
 {
-	AnalysisDataEval* analysisData;
+	AnalysisDataEval* analysisData= syncState->analysisData;
+	MessageStats* messageStats=
+		&analysisData->stats->messageStats[message->outE->traceNum][message->inE->traceNum];;
+	double* rtt;
+	double tt;
+	struct RttKey rttKey;
 
-	analysisData= (AnalysisDataEval*) syncState->analysisData;
+	if (!syncState->stats)
+	{
+		return;
+	}
+
+	g_assert(message->inE->type == TCP);
+
+	messageStats->total++;
+
+	tt= wallTimeSub(&message->inE->wallTime, &message->outE->wallTime);
+	if (tt <= 0)
+	{
+		messageStats->inversionNb++;
+	}
+	else if (syncState->graphsStream)
+	{
+		struct RttKey rttKey= {
+			.saddr=MIN(message->inE->event.tcpEvent->segmentKey->connectionKey.saddr,
+				message->inE->event.tcpEvent->segmentKey->connectionKey.daddr),
+			.daddr=MAX(message->inE->event.tcpEvent->segmentKey->connectionKey.saddr,
+				message->inE->event.tcpEvent->segmentKey->connectionKey.daddr),
+		};
+		AnalysisGraphEval* graph= g_hash_table_lookup(analysisData->graphs,
+			&rttKey);
+
+		if (graph == NULL)
+		{
+			struct RttKey* tableKey= malloc(sizeof(*tableKey));
+
+			graph= constructAnalysisGraphEval(syncState->graphsDir, &rttKey);
+			memcpy(tableKey, &rttKey, sizeof(*tableKey));
+			g_hash_table_insert(analysisData->graphs, tableKey, graph);
+		}
+
+		if (message->inE->event.udpEvent->datagramKey->saddr <
+			message->inE->event.udpEvent->datagramKey->daddr)
+		{
+			hitBin(&graph->ttSendBins, tt);
+		}
+		else
+		{
+			hitBin(&graph->ttRecvBins, tt);
+		}
+	}
+
+	rttKey.saddr=
+		message->inE->event.tcpEvent->segmentKey->connectionKey.saddr;
+	rttKey.daddr=
+		message->inE->event.tcpEvent->segmentKey->connectionKey.daddr;
+	rtt= g_hash_table_lookup(analysisData->rttInfo, &rttKey);
+	g_debug("rttInfo, looking up (%u, %u)->(%f)", rttKey.saddr,
+		rttKey.daddr, rtt ? *rtt : NAN);
+
+	if (rtt)
+	{
+		g_debug("rttInfo, tt: %f rtt / 2: %f", tt, *rtt / 2.);
+		if (tt < *rtt / 2.)
+		{
+			messageStats->tooFastNb++;
+		}
+	}
+	else
+	{
+		messageStats->noRTTInfoNb++;
+	}
 }
 
 
 /*
  * Perform analysis on multiple messages
  *
+ * Measure the RTT
+ *
  * Args:
  *   syncState     container for synchronization data
  *   exchange      structure containing the messages
  */
 static void analyzeExchangeEval(SyncState* const syncState, Exchange* const exchange)
 {
-	AnalysisDataEval* analysisData;
+	AnalysisDataEval* analysisData= syncState->analysisData;
+	Message* m1= g_queue_peek_tail(exchange->acks);
+	Message* m2= exchange->message;
+	struct RttKey* rttKey;
+	double* rtt, * exchangeRtt;
 
-	analysisData= (AnalysisDataEval*) syncState->analysisData;
+	if (!syncState->stats)
+	{
+		return;
+	}
+
+	g_assert(m1->inE->type == TCP);
+
+	// (T2 - T1) - (T3 - T4)
+	rtt= malloc(sizeof(double));
+	*rtt= wallTimeSub(&m1->inE->wallTime, &m1->outE->wallTime) -
+		wallTimeSub(&m2->outE->wallTime, &m2->inE->wallTime);
+
+	rttKey= malloc(sizeof(struct RttKey));
+	rttKey->saddr=
+		MIN(m1->inE->event.tcpEvent->segmentKey->connectionKey.saddr,
+			m1->inE->event.tcpEvent->segmentKey->connectionKey.daddr);
+	rttKey->daddr=
+		MAX(m1->inE->event.tcpEvent->segmentKey->connectionKey.saddr,
+			m1->inE->event.tcpEvent->segmentKey->connectionKey.daddr);
+
+	if (syncState->graphsStream)
+	{
+		AnalysisGraphEval* graph= g_hash_table_lookup(analysisData->graphs,
+			rttKey);
+
+		if (graph == NULL)
+		{
+			struct RttKey* tableKey= malloc(sizeof(*tableKey));
+
+			graph= constructAnalysisGraphEval(syncState->graphsDir, rttKey);
+			memcpy(tableKey, rttKey, sizeof(*tableKey));
+			g_hash_table_insert(analysisData->graphs, tableKey, graph);
+		}
+
+		hitBin(&graph->hrttBins, *rtt / 2);
+	}
+
+	exchangeRtt= g_hash_table_lookup(analysisData->stats->exchangeRtt,
+		rttKey);
+
+	if (exchangeRtt)
+	{
+		if (*rtt < *exchangeRtt)
+		{
+			g_hash_table_replace(analysisData->stats->exchangeRtt, rttKey, rtt);
+		}
+	}
+	else
+	{
+		g_hash_table_insert(analysisData->stats->exchangeRtt, rttKey, rtt);
+	}
 }
 
 
 /*
  * Perform analysis on muliple events
  *
+ * Sum the broadcast differential delays
+ *
  * Args:
  *   syncState     container for synchronization data
  *   broadcast     structure containing the events
@@ -225,8 +613,27 @@ static void analyzeExchangeEval(SyncState* const syncState, Exchange* const exch
 static void analyzeBroadcastEval(SyncState* const syncState, Broadcast* const broadcast)
 {
 	AnalysisDataEval* analysisData;
+	double sum= 0, squaresSum= 0;
+	double y;
+
+	if (!syncState->stats)
+	{
+		return;
+	}
 
 	analysisData= (AnalysisDataEval*) syncState->analysisData;
+
+	g_queue_foreach(broadcast->events, &gfSum, &sum);
+	g_queue_foreach(broadcast->events, &gfSumSquares, &squaresSum);
+
+	analysisData->stats->broadcastNb++;
+	// Because of numerical errors, this can at times be < 0
+	y= squaresSum / g_queue_get_length(broadcast->events) - pow(sum /
+		g_queue_get_length(broadcast->events), 2.);
+	if (y > 0)
+	{
+		analysisData->stats->broadcastDiffSum+= sqrt(y);
+	}
 }
 
 
@@ -240,12 +647,22 @@ static void analyzeBroadcastEval(SyncState* const syncState, Broadcast* const br
  *   syncState     container for synchronization data.
  *
  * Returns:
- *   Factors[traceNb] synchronization factors for each trace
+ *   Factors[traceNb] identity factors for each trace
  */
 static GArray* finalizeAnalysisEval(SyncState* const syncState)
 {
 	GArray* factors;
 	unsigned int i;
+	AnalysisDataEval* analysisData= syncState->analysisData;
+
+	if (syncState->graphsStream && analysisData->graphs)
+	{
+		g_hash_table_foreach(analysisData->graphs, &ghfWriteGraph, &(struct
+				WriteGraphInfo) {.rttInfo= analysisData->rttInfo,
+			.graphsStream= syncState->graphsStream});
+		g_hash_table_destroy(analysisData->graphs);
+		analysisData->graphs= NULL;
+	}
 
 	factors= g_array_sized_new(FALSE, FALSE, sizeof(Factors),
 		syncState->traceNb);
@@ -285,28 +702,83 @@ static void printAnalysisStatsEval(SyncState* const syncState)
 	printf("Synchronization evaluation analysis stats:\n");
 	printf("\tsum of broadcast differential delays: %g\n",
 		analysisData->stats->broadcastDiffSum);
+	printf("\taverage broadcast differential delays: %g\n",
+		analysisData->stats->broadcastDiffSum /
+		analysisData->stats->broadcastNb);
 
 	printf("\tIndividual evaluation:\n"
-		"\t\tTrace pair  Inversions  Too fast    (No RTT info)\n");
+		"\t\tTrace pair  Inversions Too fast   (No RTT info) Total\n");
 
 	for (i= 0; i < syncState->traceNb; i++)
 	{
 		for (j= i + 1; j < syncState->traceNb; j++)
 		{
-			TracePairStats* tpStats;
-			const char* format= "\t\t%3d - %-3d   %-10u  %-10u  %u\n";
+			MessageStats* messageStats;
+			const char* format= "\t\t%3d - %-3d   %-10u %-10u %-10u    %u\n";
+
+			messageStats= &analysisData->stats->messageStats[i][j];
+
+			printf(format, i, j, messageStats->inversionNb, messageStats->tooFastNb,
+				messageStats->noRTTInfoNb, messageStats->total);
+
+			messageStats= &analysisData->stats->messageStats[j][i];
+
+			printf(format, j, i, messageStats->inversionNb, messageStats->tooFastNb,
+				messageStats->noRTTInfoNb, messageStats->total);
+		}
+	}
 
-			tpStats= &analysisData->stats->allStats[i][j];
+	printf("\tRound-trip times:\n"
+		"\t\tHost pair                          RTT from exchanges  RTTs from file (ms)\n");
+	g_hash_table_foreach(analysisData->stats->exchangeRtt,
+		&ghfPrintExchangeRtt, analysisData->rttInfo);
+}
+
+
+/*
+ * A GHFunc for g_hash_table_foreach()
+ *
+ * Args:
+ *   key:          RttKey* where saddr < daddr
+ *   value:        double*, RTT estimated from exchanges
+ *   user_data     GHashTable* rttInfo
+ */
+static void ghfPrintExchangeRtt(gpointer key, gpointer value, gpointer user_data)
+{
+	char addr1[16], addr2[16];
+	struct RttKey* rttKey1= key;
+	struct RttKey rttKey2= {rttKey1->daddr, rttKey1->saddr};
+	double* fileRtt1, *fileRtt2;
+	GHashTable* rttInfo= user_data;
 
-			printf(format, i, j, tpStats->inversionNb, tpStats->tooFastNb,
-				tpStats->noRTTInfoNb);
+	convertIP(addr1, rttKey1->saddr);
+	convertIP(addr2, rttKey1->daddr);
 
-			tpStats= &analysisData->stats->allStats[j][i];
+	fileRtt1= g_hash_table_lookup(rttInfo, rttKey1);
+	fileRtt2= g_hash_table_lookup(rttInfo, &rttKey2);
 
-			printf(format, j, i, tpStats->inversionNb, tpStats->tooFastNb,
-				tpStats->noRTTInfoNb);
+	printf("\t\t(%15s, %-15s) %-18.3f  ", addr1, addr2, *(double*) value * 1e3);
+
+	if (fileRtt1 || fileRtt2)
+	{
+		if (fileRtt1)
+		{
+			printf("%.3f", *fileRtt1 * 1e3);
+		}
+		if (fileRtt1 && fileRtt2)
+		{
+			printf(", ");
+		}
+		if (fileRtt2)
+		{
+			printf("%.3f", *fileRtt2 * 1e3);
 		}
 	}
+	else
+	{
+		printf("-");
+	}
+	printf("\n");
 }
 
 
@@ -451,6 +923,9 @@ static void readRttInfo(GHashTable* rttInfo, FILE* rttStream)
 				addr.s_addr;
 		}
 
+		*rtt/= 1e3;
+		g_debug("rttInfo, Inserting (%u, %u)->(%f)", rttKey->saddr,
+			rttKey->daddr, *rtt);
 		g_hash_table_insert(rttInfo, rttKey, rtt);
 
 		positionStream(rttStream);
@@ -520,3 +995,162 @@ outEof:
 		free(line);
 	}
 }
+
+
+/*
+ * A GFunc for g_queue_foreach()
+ *
+ * Args:
+ *   data          Event*, a UDP broadcast event
+ *   user_data     double*, the running sum
+ *
+ * Returns:
+ *   Adds the time of the event to the sum
+ */
+static void gfSum(gpointer data, gpointer userData)
+{
+	Event* event= (Event*) data;
+
+	*(double*) userData+= event->wallTime.seconds + event->wallTime.nanosec /
+		1e9;
+}
+
+
+/*
+ * A GFunc for g_queue_foreach()
+ *
+ * Args:
+ *   data          Event*, a UDP broadcast event
+ *   user_data     double*, the running sum
+ *
+ * Returns:
+ *   Adds the square of the time of the event to the sum
+ */
+static void gfSumSquares(gpointer data, gpointer userData)
+{
+	Event* event= (Event*) data;
+
+	*(double*) userData+= pow(event->wallTime.seconds + event->wallTime.nanosec
+		/ 1e9, 2.);
+}
+
+
+/*
+ * Update a struct Bins according to a new value
+ *
+ * Args:
+ *   bins:         the structure containing bins to build a histrogram
+ *   value:        the new value
+ */
+static void hitBin(struct Bins* const bins, const double value)
+{
+	unsigned int binN= binNum(value);
+
+	if (binN < bins->min)
+	{
+		bins->min= binN;
+	}
+	else if (binN > bins->max)
+	{
+		bins->max= binN;
+	}
+
+	bins->total++;
+
+	bins->bin[binN]++;
+}
+
+
+/*
+ * Figure out the bin in a histogram to which a value belongs.
+ *
+ * This uses exponentially sized bins that go from 0 to infinity.
+ *
+ * Args:
+ *   value:        in the range -INFINITY to INFINITY
+ *
+ * Returns:
+ *   The number of the bin in a struct Bins.bin
+ */
+static unsigned int binNum(const double value)
+{
+	if (value <= 0)
+	{
+		return 0;
+	}
+	else if (value < binEnd(1))
+	{
+		return 1;
+	}
+	else if (value >= binStart(BIN_NB - 1))
+	{
+		return BIN_NB - 1;
+	}
+	else
+	{
+		return floor(log(value) / log(binBase)) + BIN_NB + 1;
+	}
+}
+
+
+/*
+ * Figure out the start of the interval of a bin in a histogram. See struct
+ * Bins.
+ *
+ * This uses exponentially sized bins that go from 0 to infinity.
+ *
+ * Args:
+ *   binNum:       bin number
+ *
+ * Return:
+ *   The start of the interval, this value is included in the interval (except
+ *   for -INFINITY, naturally)
+ */
+static double binStart(const unsigned int binNum)
+{
+	g_assert_cmpuint(binNum, <, BIN_NB);
+
+	if (binNum == 0)
+	{
+		return -INFINITY;
+	}
+	else if (binNum == 1)
+	{
+		return 0.;
+	}
+	else
+	{
+		return pow(binBase, (double) binNum - BIN_NB + 1);
+	}
+}
+
+
+/*
+ * Figure out the end of the interval of a bin in a histogram. See struct
+ * Bins.
+ *
+ * This uses exponentially sized bins that go from 0 to infinity.
+ *
+ * Args:
+ *   binNum:       bin number
+ *
+ * Return:
+ *   The end of the interval, this value is not included in the interval
+ */
+static double binEnd(const unsigned int binNum)
+{
+	g_assert_cmpuint(binNum, <, BIN_NB);
+
+	if (binNum == 0)
+	{
+		return 0.;
+	}
+	else if (binNum < BIN_NB - 1)
+	{
+		return pow(binBase, (double) binNum - BIN_NB + 2);
+	}
+	else
+	{
+		return INFINITY;
+	}
+}