X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttv%2Flttv%2Fsync%2Fevent_analysis_eval.c;h=8dbf5bb60ec3439fa26b53e37c7502a609a1f23a;hb=df64b31664467d7217fa08fcdee423577856b38a;hp=b8f3b85882d82f6e1b9917f019aa6648d1c6ed8e;hpb=f109919bd6649a6e21a0719a174b5efabd989225;p=lttv.git diff --git a/lttv/lttv/sync/event_analysis_eval.c b/lttv/lttv/sync/event_analysis_eval.c index b8f3b858..8dbf5bb6 100644 --- a/lttv/lttv/sync/event_analysis_eval.c +++ b/lttv/lttv/sync/event_analysis_eval.c @@ -1,19 +1,18 @@ /* This file is part of the Linux Trace Toolkit viewer - * Copyright (C) 2009 Benjamin Poirier + * Copyright (C) 2009, 2010 Benjamin Poirier * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License Version 2 as - * published by the Free Software Foundation; + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 2.1 of the License, or (at + * your option) any later version. * - * This program 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 General Public License for more details. + * This program 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 Lesser General Public + * License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . */ #define _GNU_SOURCE @@ -40,13 +39,12 @@ #include "event_analysis_eval.h" -struct WriteGraphInfo +struct WriteHistogramInfo { GHashTable* rttInfo; FILE* graphsStream; }; - // Functions common to all analysis modules static void initAnalysisEval(SyncState* const syncState); static void destroyAnalysisEval(SyncState* const syncState); @@ -57,11 +55,14 @@ static void analyzeExchangeEval(SyncState* const syncState, Exchange* const exchange); static void analyzeBroadcastEval(SyncState* const syncState, Broadcast* const broadcast); -static GArray* finalizeAnalysisEval(SyncState* const syncState); +static AllFactors* finalizeAnalysisEval(SyncState* const syncState); static void printAnalysisStatsEval(SyncState* const syncState); +static void writeAnalysisTraceTimeBackPlotsEval(SyncState* const syncState, + const unsigned int i, const unsigned int j); +static void writeAnalysisTraceTimeForePlotsEval(SyncState* const syncState, + const unsigned int i, const unsigned int j); // Functions specific to this module -static void registerAnalysisEval() __attribute__((constructor (102))); static guint ghfRttKeyHash(gconstpointer key); static gboolean gefRttKeyEqual(gconstpointer a, gconstpointer b); static void gdnDestroyRttKey(gpointer data); @@ -71,23 +72,31 @@ 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 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 uint32_t normalTotal(struct Bins* const bins) __attribute__((const)); -static AnalysisGraphEval* constructAnalysisGraphEval(const char* const +static AnalysisHistogramEval* constructAnalysisHistogramEval(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 destroyAnalysisHistogramEval(AnalysisHistogramEval* const + histogram); +static void gdnDestroyAnalysisHistogramEval(gpointer data); +static void ghfWriteHistogram(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* minRtt, AnalysisHistogramEval* const histogram); + +static void updateBounds(Bounds** const bounds, Event* const e1, Event* const + e2); +// initialized in registerAnalysisEval() double binBase; static AnalysisModule analysisModuleEval= { @@ -99,14 +108,15 @@ static AnalysisModule analysisModuleEval= { .analyzeBroadcast= &analyzeBroadcastEval, .finalizeAnalysis= &finalizeAnalysisEval, .printAnalysisStats= &printAnalysisStatsEval, - .writeAnalysisGraphsPlots= NULL, - .writeAnalysisGraphsOptions= NULL, + .graphFunctions= { + .writeTraceTimeBackPlots= &writeAnalysisTraceTimeBackPlotsEval, + .writeTraceTimeForePlots= &writeAnalysisTraceTimeForePlotsEval, + } }; static ModuleOption optionEvalRttFile= { .longName= "eval-rtt-file", .hasArg= REQUIRED_ARG, - {.arg= NULL}, .optionHelp= "specify the file containing RTT information", .argHelp= "FILE", }; @@ -115,8 +125,10 @@ static ModuleOption optionEvalRttFile= { /* * Analysis module registering function */ -static void registerAnalysisEval() +void registerAnalysisEval() { + binBase= exp10(6. / (BIN_NB - 3)); + g_queue_push_tail(&analysisModules, &analysisModuleEval); g_queue_push_tail(&moduleOptions, &optionEvalRttFile); } @@ -134,7 +146,7 @@ static void registerAnalysisEval() static void initAnalysisEval(SyncState* const syncState) { AnalysisDataEval* analysisData; - unsigned int i; + unsigned int i, j; analysisData= malloc(sizeof(AnalysisDataEval)); syncState->analysisData= analysisData; @@ -149,7 +161,7 @@ static void initAnalysisEval(SyncState* const syncState) rttStream= fopen(optionEvalRttFile.arg, "r"); if (rttStream == NULL) { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } readRttInfo(analysisData->rttInfo, rttStream); @@ -157,14 +169,15 @@ static void initAnalysisEval(SyncState* const syncState) retval= fclose(rttStream); if (retval == EOF) { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } } if (syncState->stats) { analysisData->stats= calloc(1, sizeof(AnalysisStatsEval)); - analysisData->stats->broadcastDiffSum= 0.; + analysisData->stats->broadcastRangeMin= INFINITY; + analysisData->stats->broadcastRangeMax= -INFINITY; analysisData->stats->messageStats= malloc(syncState->traceNb * sizeof(MessageStats*)); @@ -181,9 +194,33 @@ static void initAnalysisEval(SyncState* const syncState) if (syncState->graphsStream) { - binBase= exp10(6. / (BIN_NB - 3)); - analysisData->graphs= g_hash_table_new_full(&ghfRttKeyHash, - &gefRttKeyEqual, &gdnDestroyRttKey, &gdnDestroyAnalysisGraphEval); + AnalysisGraphsEval* graphs= malloc(sizeof(AnalysisGraphsEval)); + GList* result; + + analysisData->graphs= graphs; + + graphs->histograms= g_hash_table_new_full(&ghfRttKeyHash, + &gefRttKeyEqual, &gdnDestroyRttKey, + &gdnDestroyAnalysisHistogramEval); + + graphs->bounds= malloc(syncState->traceNb * sizeof(Bounds*)); + for (i= 0; i < syncState->traceNb; i++) + { + graphs->bounds[i]= malloc(i * sizeof(Bounds)); + for (j= 0; j < i; j++) + { + graphs->bounds[i][j].min= UINT64_MAX; + graphs->bounds[i][j].max= 0; + } + } + + graphs->chullSS= (SyncState*) malloc(sizeof(SyncState)); + memcpy(graphs->chullSS, syncState, sizeof(SyncState)); + graphs->chullSS->analysisData= NULL; + result= g_queue_find_custom(&analysisModules, "chull", &gcfCompareAnalysis); + g_assert(result != NULL); + graphs->chullSS->analysisModule= (AnalysisModule*) result->data; + graphs->chullSS->analysisModule->initAnalysis(graphs->chullSS); } } @@ -196,35 +233,35 @@ static void initAnalysisEval(SyncState* const syncState) * graphsDir: folder where to write files * rttKey: host pair, make sure saddr < daddr */ -static AnalysisGraphEval* constructAnalysisGraphEval(const char* const +static AnalysisHistogramEval* constructAnalysisHistogramEval(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)); + AnalysisHistogramEval* histogram= calloc(1, sizeof(*histogram)); 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}, + {offsetof(AnalysisHistogramEval, ttSendPoints), + "analysis_eval_tt-%s_to_%s.data", saddr, daddr}, + {offsetof(AnalysisHistogramEval, ttRecvPoints), + "analysis_eval_tt-%s_to_%s.data", daddr, saddr}, + {offsetof(AnalysisHistogramEval, 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; + histogram->ttSendBins.min= BIN_NB - 1; + histogram->ttRecvBins.min= BIN_NB - 1; + histogram->hrttBins.min= BIN_NB - 1; convertIP(saddr, rttKey->saddr); convertIP(daddr, rttKey->daddr); - cwd= changeToGraphDir(graphsDir); + cwd= changeToGraphsDir(graphsDir); for (i= 0; i < sizeof(loopValues) / sizeof(*loopValues); i++) { @@ -234,21 +271,21 @@ static AnalysisGraphEval* constructAnalysisGraphEval(const char* const { name[sizeof(name) - 1]= '\0'; } - if ((*(FILE**)((void*) graph + loopValues[i].pointsOffset)= + if ((*(FILE**)((void*) histogram + loopValues[i].pointsOffset)= fopen(name, "w")) == NULL) { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } } retval= chdir(cwd); if (retval == -1) { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } free(cwd); - return graph; + return histogram; } @@ -259,26 +296,29 @@ static AnalysisGraphEval* constructAnalysisGraphEval(const char* const * graphsDir: folder where to write files * rttKey: host pair, make sure saddr < daddr */ -static void destroyAnalysisGraphEval(AnalysisGraphEval* const graph) +static void destroyAnalysisHistogramEval(AnalysisHistogramEval* const + histogram) { unsigned int i; int retval; const struct { size_t pointsOffset; } loopValues[]= { - {offsetof(AnalysisGraphEval, ttSendPoints)}, - {offsetof(AnalysisGraphEval, ttRecvPoints)}, - {offsetof(AnalysisGraphEval, hrttPoints)}, + {offsetof(AnalysisHistogramEval, ttSendPoints)}, + {offsetof(AnalysisHistogramEval, ttRecvPoints)}, + {offsetof(AnalysisHistogramEval, hrttPoints)}, }; for (i= 0; i < sizeof(loopValues) / sizeof(*loopValues); i++) { - retval= fclose(*(FILE**)((void*) graph + loopValues[i].pointsOffset)); + retval= fclose(*(FILE**)((void*) histogram + loopValues[i].pointsOffset)); if (retval != 0) { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } } + + free(histogram); } @@ -286,11 +326,11 @@ static void destroyAnalysisGraphEval(AnalysisGraphEval* const graph) * A GDestroyNotify function for g_hash_table_new_full() * * Args: - * data: AnalysisGraphEval* + * data: AnalysisHistogramEval* */ -static void gdnDestroyAnalysisGraphEval(gpointer data) +static void gdnDestroyAnalysisHistogramEval(gpointer data) { - destroyAnalysisGraphEval(data); + destroyAnalysisHistogramEval(data); } @@ -299,17 +339,17 @@ static void gdnDestroyAnalysisGraphEval(gpointer data) * * Args: * key: RttKey* where saddr < daddr - * value: AnalysisGraphEval* - * user_data struct WriteGraphInfo* + * value: AnalysisHistogramEval* + * user_data struct WriteHistogramInfo* */ -static void ghfWriteGraph(gpointer key, gpointer value, gpointer user_data) +static void ghfWriteHistogram(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; + AnalysisHistogramEval* histogram= value; + struct WriteHistogramInfo* info= user_data; rtt1= g_hash_table_lookup(info->rttInfo, rttKey); rtt2= g_hash_table_lookup(info->rttInfo, &oppositeRttKey); @@ -323,10 +363,10 @@ static void ghfWriteGraph(gpointer key, gpointer value, gpointer user_data) rtt1= MIN(rtt1, rtt2); } - dumpBinToFile(&graph->ttSendBins, graph->ttSendPoints); - dumpBinToFile(&graph->ttRecvBins, graph->ttRecvPoints); - dumpBinToFile(&graph->hrttBins, graph->hrttPoints); - writeHistogram(info->graphsStream, rttKey, rtt1); + dumpBinToFile(&histogram->ttSendBins, histogram->ttSendPoints); + dumpBinToFile(&histogram->ttRecvBins, histogram->ttRecvPoints); + dumpBinToFile(&histogram->hrttBins, histogram->hrttPoints); + writeHistogram(info->graphsStream, rttKey, rtt1, histogram); } @@ -361,9 +401,11 @@ static void dumpBinToFile(const struct Bins* const bins, FILE* const file) * graphsStream: write to this file * rttKey: must be sorted such that saddr < daddr * minRtt: if available, else NULL + * histogram: struct that contains the bins for the pair of traces + * identified by rttKey */ static void writeHistogram(FILE* graphsStream, const struct RttKey* rttKey, - double* minRtt) + double* minRtt, AnalysisHistogramEval* const histogram) { char saddr[16], daddr[16]; @@ -371,7 +413,7 @@ static void writeHistogram(FILE* graphsStream, const struct RttKey* rttKey, convertIP(daddr, rttKey->daddr); fprintf(graphsStream, - "reset\n" + "\nreset\n" "set output \"histogram-%s-%s.eps\"\n" "set title \"\"\n" "set xlabel \"Message Latency (s)\"\n" @@ -381,20 +423,54 @@ static void writeHistogram(FILE* graphsStream, const struct RttKey* rttKey, { fprintf(graphsStream, "set arrow from %.9f, 0 rto 0, graph 1 " - "nohead linetype 3 linewidth 3 linecolor rgb \"black\"\n", *minRtt / 2); + "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); + if (normalTotal(&histogram->ttSendBins) || + normalTotal(&histogram->ttRecvBins) || + normalTotal(&histogram->hrttBins)) + { + fprintf(graphsStream, "plot \\\n"); + + if (normalTotal(&histogram->hrttBins)) + { + fprintf(graphsStream, + "\t\"analysis_eval_hrtt-%s_and_%s.data\" " + "title \"RTT/2\" with linespoints linetype 1 linewidth 2 " + "linecolor rgb \"black\" pointtype 6 pointsize 1,\\\n", + saddr, daddr); + } + + if (normalTotal(&histogram->ttSendBins)) + { + fprintf(graphsStream, + "\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", + saddr, daddr); + } + + if (normalTotal(&histogram->ttRecvBins)) + { + fprintf(graphsStream, + "\t\"analysis_eval_tt-%1$s_to_%2$s.data\" " + "title \"%1$s to %2$s\" with linespoints linetype 4 linewidth 2 " + "linecolor rgb \"gray30\" pointtype 6 pointsize 1,\\\n", + daddr, saddr); + } + + // Remove the ",\\\n" from the last graph plot line + if (ftruncate(fileno(graphsStream), ftell(graphsStream) - 3) == -1) + { + g_error("%s", strerror(errno)); + } + if (fseek(graphsStream, 0, SEEK_END) == -1) + { + g_error("%s", strerror(errno)); + } + fprintf(graphsStream, "\n"); + } } @@ -413,30 +489,47 @@ static void destroyAnalysisEval(SyncState* const syncState) analysisData= (AnalysisDataEval*) syncState->analysisData; - if (analysisData == NULL || analysisData->rttInfo == NULL) + if (analysisData == NULL) { return; } g_hash_table_destroy(analysisData->rttInfo); - analysisData->rttInfo= NULL; if (syncState->stats) { + AnalysisStatsEval* stats= analysisData->stats; + for (i= 0; i < syncState->traceNb; i++) { - free(analysisData->stats->messageStats[i]); + free(stats->messageStats[i]); } - free(analysisData->stats->messageStats); + free(stats->messageStats); - g_hash_table_destroy(analysisData->stats->exchangeRtt); + g_hash_table_destroy(stats->exchangeRtt); - free(analysisData->stats); + free(stats); } - if (syncState->graphsStream && analysisData->graphs) + if (syncState->graphsStream) { - g_hash_table_destroy(analysisData->graphs); + AnalysisGraphsEval* graphs= analysisData->graphs; + + if (graphs->histograms) + { + g_hash_table_destroy(graphs->histograms); + } + + for (i= 0; i < syncState->traceNb; i++) + { + free(graphs->bounds[i]); + } + free(graphs->bounds); + + graphs->chullSS->analysisModule->destroyAnalysis(graphs->chullSS); + free(graphs->chullSS); + + free(graphs); } free(syncState->analysisData); @@ -453,28 +546,31 @@ static void destroyAnalysisEval(SyncState* const syncState) * syncState container for synchronization data * message structure containing the events */ -static void analyzeMessageEval(SyncState* const syncState, Message* const message) +static void analyzeMessageEval(SyncState* const syncState, Message* const + message) { AnalysisDataEval* analysisData= syncState->analysisData; - MessageStats* messageStats= - &analysisData->stats->messageStats[message->outE->traceNum][message->inE->traceNum];; + MessageStats* messageStats = NULL; /* for gcc */ double* rtt; double tt; struct RttKey rttKey; - if (!syncState->stats) - { - return; - } - g_assert(message->inE->type == TCP); - messageStats->total++; + if (syncState->stats) + { + messageStats= + &analysisData->stats->messageStats[message->outE->traceNum][message->inE->traceNum]; + messageStats->total++; + } tt= wallTimeSub(&message->inE->wallTime, &message->outE->wallTime); if (tt <= 0) { - messageStats->inversionNb++; + if (syncState->stats) + { + messageStats->inversionNb++; + } } else if (syncState->graphsStream) { @@ -484,48 +580,60 @@ static void analyzeMessageEval(SyncState* const syncState, Message* const messag .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); + AnalysisHistogramEval* histogram= + g_hash_table_lookup(analysisData->graphs->histograms, &rttKey); - if (graph == NULL) + if (histogram == NULL) { struct RttKey* tableKey= malloc(sizeof(*tableKey)); - graph= constructAnalysisGraphEval(syncState->graphsDir, &rttKey); + histogram= constructAnalysisHistogramEval(syncState->graphsDir, &rttKey); memcpy(tableKey, &rttKey, sizeof(*tableKey)); - g_hash_table_insert(analysisData->graphs, tableKey, graph); + g_hash_table_insert(analysisData->graphs->histograms, tableKey, histogram); } if (message->inE->event.udpEvent->datagramKey->saddr < message->inE->event.udpEvent->datagramKey->daddr) { - hitBin(&graph->ttSendBins, tt); + hitBin(&histogram->ttSendBins, tt); } else { - hitBin(&graph->ttRecvBins, tt); + hitBin(&histogram->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) + if (syncState->stats) { - g_debug("rttInfo, tt: %f rtt / 2: %f", tt, *rtt / 2.); - if (tt < *rtt / 2.) + 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) { - messageStats->tooFastNb++; + g_debug("rttInfo, tt: %f rtt / 2: %f", tt, *rtt / 2.); + if (tt < *rtt / 2.) + { + messageStats->tooFastNb++; + } + } + else + { + messageStats->noRTTInfoNb++; } } - else + + if (syncState->graphsStream) { - messageStats->noRTTInfoNb++; + updateBounds(analysisData->graphs->bounds, message->inE, + message->outE); + + analysisData->graphs->chullSS->analysisModule->analyzeMessage(analysisData->graphs->chullSS, + message); } } @@ -539,7 +647,8 @@ static void analyzeMessageEval(SyncState* const syncState, Message* const messag * syncState container for synchronization data * exchange structure containing the messages */ -static void analyzeExchangeEval(SyncState* const syncState, Exchange* const exchange) +static void analyzeExchangeEval(SyncState* const syncState, Exchange* const + exchange) { AnalysisDataEval* analysisData= syncState->analysisData; Message* m1= g_queue_peek_tail(exchange->acks); @@ -547,11 +656,6 @@ static void analyzeExchangeEval(SyncState* const syncState, Exchange* const exch struct RttKey* rttKey; double* rtt, * exchangeRtt; - if (!syncState->stats) - { - return; - } - g_assert(m1->inE->type == TCP); // (T2 - T1) - (T3 - T4) @@ -569,34 +673,49 @@ static void analyzeExchangeEval(SyncState* const syncState, Exchange* const exch if (syncState->graphsStream) { - AnalysisGraphEval* graph= g_hash_table_lookup(analysisData->graphs, - rttKey); + AnalysisHistogramEval* histogram= + g_hash_table_lookup(analysisData->graphs->histograms, rttKey); - if (graph == NULL) + if (histogram == NULL) { struct RttKey* tableKey= malloc(sizeof(*tableKey)); - graph= constructAnalysisGraphEval(syncState->graphsDir, rttKey); + histogram= constructAnalysisHistogramEval(syncState->graphsDir, + rttKey); memcpy(tableKey, rttKey, sizeof(*tableKey)); - g_hash_table_insert(analysisData->graphs, tableKey, graph); + g_hash_table_insert(analysisData->graphs->histograms, tableKey, + histogram); } - hitBin(&graph->hrttBins, *rtt / 2); + hitBin(&histogram->hrttBins, *rtt / 2); } - exchangeRtt= g_hash_table_lookup(analysisData->stats->exchangeRtt, - rttKey); - - if (exchangeRtt) + if (syncState->stats) { - if (*rtt < *exchangeRtt) + exchangeRtt= g_hash_table_lookup(analysisData->stats->exchangeRtt, + rttKey); + + if (exchangeRtt) + { + if (*rtt < *exchangeRtt) + { + g_hash_table_replace(analysisData->stats->exchangeRtt, rttKey, rtt); + } + else + { + free(rttKey); + free(rtt); + } + } + else { - g_hash_table_replace(analysisData->stats->exchangeRtt, rttKey, rtt); + g_hash_table_insert(analysisData->stats->exchangeRtt, rttKey, rtt); } } else { - g_hash_table_insert(analysisData->stats->exchangeRtt, rttKey, rtt); + free(rttKey); + free(rtt); } } @@ -610,73 +729,126 @@ static void analyzeExchangeEval(SyncState* const syncState, Exchange* const exch * syncState container for synchronization data * broadcast structure containing the events */ -static void analyzeBroadcastEval(SyncState* const syncState, Broadcast* const broadcast) +static void analyzeBroadcastEval(SyncState* const syncState, Broadcast* const + broadcast) { - AnalysisDataEval* analysisData; - double sum= 0, squaresSum= 0; - double y; + AnalysisDataEval* analysisData= syncState->analysisData; - if (!syncState->stats) + if (syncState->stats) { - return; - } + double sum= 0, squaresSum= 0; + double y; - 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->broadcastStdevSum+= sqrt(y); + } + + if (syncState->traceNb == 2 && g_queue_get_length(broadcast->events) + == 2) + { + Event* e0, * e1; + double dd; - g_queue_foreach(broadcast->events, &gfSum, &sum); - g_queue_foreach(broadcast->events, &gfSumSquares, &squaresSum); + e0= g_queue_peek_head(broadcast->events); + e1= g_queue_peek_tail(broadcast->events); + if (e0->traceNum > e1->traceNum) + { + Event* tmp; + + tmp= e0; + e0= e1; + e1= tmp; + } - 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) + dd= wallTimeSub(&e1->wallTime, &e0->wallTime); + + analysisData->stats->broadcastPairNb++; + if (dd < analysisData->stats->broadcastRangeMin) + { + analysisData->stats->broadcastRangeMin= dd; + } + if (dd > analysisData->stats->broadcastRangeMax) + { + analysisData->stats->broadcastRangeMax= dd; + } + + analysisData->stats->broadcastSum+= dd; + analysisData->stats->broadcastSumSquares+= pow(dd, 2); + } + } + + if (syncState->graphsStream) { - analysisData->stats->broadcastDiffSum+= sqrt(y); + unsigned int i, j; + GArray* events; + unsigned int eventNb= broadcast->events->length; + + events= g_array_sized_new(FALSE, FALSE, sizeof(Event*), eventNb); + g_queue_foreach(broadcast->events, &gfAddEventToArray, events); + + for (i= 0; i < eventNb; i++) + { + for (j= 0; j < eventNb; j++) + { + Event* eventI= g_array_index(events, Event*, i), * eventJ= + g_array_index(events, Event*, j); + + if (eventI->traceNum < eventJ->traceNum) + { + updateBounds(analysisData->graphs->bounds, eventI, eventJ); + } + } + } + + g_array_free(events, TRUE); } } /* - * Finalize the factor calculations - * - * Since this module does not really calculate factors, identity factors are - * returned. + * Finalize the factor calculations. Since this module does not really + * calculate factors, absent factors are returned. Instead, histograms are + * written out and histogram structures are freed. * * Args: * syncState container for synchronization data. * * Returns: - * Factors[traceNb] identity factors for each trace + * AllFactors* synchronization factors for each trace pair */ -static GArray* finalizeAnalysisEval(SyncState* const syncState) +static AllFactors* finalizeAnalysisEval(SyncState* const syncState) { - GArray* factors; - unsigned int i; AnalysisDataEval* analysisData= syncState->analysisData; - if (syncState->graphsStream && analysisData->graphs) + /* This function may be run twice because of matching_distributor. This + * check is there to make sure the next block is run only once. + */ + if (syncState->graphsStream && analysisData->graphs->histograms) { - g_hash_table_foreach(analysisData->graphs, &ghfWriteGraph, &(struct - WriteGraphInfo) {.rttInfo= analysisData->rttInfo, - .graphsStream= syncState->graphsStream}); - g_hash_table_destroy(analysisData->graphs); - analysisData->graphs= NULL; - } + g_hash_table_foreach(analysisData->graphs->histograms, + &ghfWriteHistogram, &(struct WriteHistogramInfo) {.rttInfo= + analysisData->rttInfo, .graphsStream= syncState->graphsStream}); + g_hash_table_destroy(analysisData->graphs->histograms); + analysisData->graphs->histograms= NULL; - factors= g_array_sized_new(FALSE, FALSE, sizeof(Factors), - syncState->traceNb); - g_array_set_size(factors, syncState->traceNb); - for (i= 0; i < syncState->traceNb; i++) - { - Factors* e; + if (syncState->graphsStream) + { + SyncState* chullSS= analysisData->graphs->chullSS; - e= &g_array_index(factors, Factors, i); - e->drift= 1.; - e->offset= 0.; + freeAllFactors(chullSS->analysisModule->finalizeAnalysis(chullSS), + chullSS->traceNb); + } } - return factors; + return createAllFactors(syncState->traceNb); } @@ -702,11 +874,30 @@ static void printAnalysisStatsEval(SyncState* const syncState) analysisData= (AnalysisDataEval*) syncState->analysisData; 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); + if (analysisData->stats->broadcastNb) + { + printf("\tBroadcast differential delay:\n"); + printf("\t\tsum of standard deviations: %g\n", + analysisData->stats->broadcastStdevSum); + printf("\t\taverage standard deviation: %g\n", + analysisData->stats->broadcastStdevSum / + analysisData->stats->broadcastNb); + + if (syncState->traceNb == 2) + { + printf("\t\tdifferential delay range: [ %g .. %g ]\n", + analysisData->stats->broadcastRangeMin, + analysisData->stats->broadcastRangeMax); + printf("\t\tdifferential delay average: %g\n", + analysisData->stats->broadcastSum / + analysisData->stats->broadcastPairNb); + printf("\t\tdifferential delay standard deviation: %g\n", + sqrt(analysisData->stats->broadcastSumSquares / + analysisData->stats->broadcastPairNb - + pow(analysisData->stats->broadcastSum / + analysisData->stats->broadcastPairNb, 2))); + } + } printf("\tIndividual evaluation:\n" "\t\tTrace pair Inversions Too fast No RTT info Total\n"); @@ -729,13 +920,13 @@ static void printAnalysisStatsEval(SyncState* const syncState) &analysisData->stats->messageStats[loopValues[k].t1][loopValues[k].t2]; printf("\t\t%3d - %-3d ", loopValues[k].t1, loopValues[k].t2); - printf("%u (%u%%)%n", messageStats->inversionNb, (unsigned - int) ceil((double) messageStats->inversionNb / - messageStats->total * 100), &charNb); + printf("%u (%.2f%%)%n", messageStats->inversionNb, (double) + messageStats->inversionNb / messageStats->total * 100, + &charNb); printf("%*s", 17 - charNb > 0 ? 17 - charNb + 1: 1, " "); - printf("%u (%u%%)%n", messageStats->tooFastNb, (unsigned int) - ceil((double) messageStats->tooFastNb / - messageStats->total * 100), &charNb); + printf("%u (%.2f%%)%n", messageStats->tooFastNb, (double) + messageStats->tooFastNb / messageStats->total * 100, + &charNb); printf("%*s%-10u %u\n", 17 - charNb > 0 ? 17 - charNb + 1: 1, " ", messageStats->noRTTInfoNb, messageStats->total); @@ -748,11 +939,11 @@ static void printAnalysisStatsEval(SyncState* const syncState) } printf("\t\t total "); - printf("%u (%u%%)%n", totInversion, (unsigned int) ceil((double) - totInversion / totTotal * 100), &charNb); + printf("%u (%.2f%%)%n", totInversion, (double) totInversion / totTotal * + 100, &charNb); printf("%*s", 17 - charNb > 0 ? 17 - charNb + 1: 1, " "); - printf("%u (%u%%)%n", totTooFast, (unsigned int) ceil((double) totTooFast - / totTotal * 100), &charNb); + printf("%u (%.2f%%)%n", totTooFast, (double) totTooFast / totTotal * 100, + &charNb); printf("%*s%-10u %u\n", 17 - charNb > 0 ? 17 - charNb + 1: 1, " ", totNoInfo, totTotal); @@ -771,7 +962,8 @@ static void printAnalysisStatsEval(SyncState* const syncState) * value: double*, RTT estimated from exchanges * user_data GHashTable* rttInfo */ -static void ghfPrintExchangeRtt(gpointer key, gpointer value, gpointer user_data) +static void ghfPrintExchangeRtt(gpointer key, gpointer value, gpointer + user_data) { char addr1[16], addr2[16]; struct RttKey* rttKey1= key; @@ -919,7 +1111,7 @@ static void readRttInfo(GHashTable* rttInfo, FILE* rttStream) if (retval == -1 && !feof(rttStream)) { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } if (line[retval - 1] == '\n') @@ -932,7 +1124,7 @@ static void readRttInfo(GHashTable* rttInfo, FILE* rttStream) &tmp); if (retval == EOF) { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } else if (retval != 3) { @@ -995,7 +1187,7 @@ static void positionStream(FILE* stream) } else { - g_error(strerror(errno)); + g_error("%s", strerror(errno)); } } } @@ -1182,3 +1374,100 @@ static double binEnd(const unsigned int binNum) return INFINITY; } } + + +/* + * Return the total number of elements in the "normal" bins (not underflow or + * overflow) + * + * Args: + * bins: the structure containing bins to build a histrogram + */ +static uint32_t normalTotal(struct Bins* const bins) +{ + return bins->total - bins->bin[0] - bins->bin[BIN_NB - 1]; +} + + +/* Update the bounds between two traces + * + * Args: + * bounds: the array containing all the trace-pair bounds + * e1, e2: the two related events + */ +static void updateBounds(Bounds** const bounds, Event* const e1, Event* const + e2) +{ + unsigned int traceI, traceJ; + uint64_t messageTime; + Bounds* tpBounds; + + if (e1->traceNum < e2->traceNum) + { + traceI= e2->traceNum; + traceJ= e1->traceNum; + messageTime= e1->cpuTime; + } + else + { + traceI= e1->traceNum; + traceJ= e2->traceNum; + messageTime= e2->cpuTime; + } + tpBounds= &bounds[traceI][traceJ]; + + if (messageTime < tpBounds->min) + { + tpBounds->min= messageTime; + } + if (messageTime > tpBounds->max) + { + tpBounds->max= messageTime; + } +} + + +/* + * Write the analysis-specific graph lines in the gnuplot script. + * + * Args: + * syncState: container for synchronization data + * i: first trace number + * j: second trace number, garanteed to be larger than i + */ +static void writeAnalysisTraceTimeBackPlotsEval(SyncState* const syncState, + const unsigned int i, const unsigned int j) +{ + SyncState* chullSS= ((AnalysisDataEval*) + syncState->analysisData)->graphs->chullSS; + const GraphFunctions* graphFunctions= + &chullSS->analysisModule->graphFunctions; + + if (graphFunctions->writeTraceTimeBackPlots != NULL) + { + graphFunctions->writeTraceTimeBackPlots(chullSS, i, j); + } +} + + +/* + * Write the analysis-specific graph lines in the gnuplot script. + * + * Args: + * syncState: container for synchronization data + * i: first trace number + * j: second trace number, garanteed to be larger than i + */ +static void writeAnalysisTraceTimeForePlotsEval(SyncState* const syncState, + const unsigned int i, const unsigned int j) +{ + SyncState* chullSS= ((AnalysisDataEval*) + syncState->analysisData)->graphs->chullSS; + const GraphFunctions* graphFunctions= + &chullSS->analysisModule->graphFunctions; + + if (graphFunctions->writeTraceTimeForePlots != NULL) + { + graphFunctions->writeTraceTimeForePlots(chullSS, i, j); + } +}