/* This file is part of the Linux Trace Toolkit viewer
- * Copyright (C) 2009 Benjamin Poirier <benjamin.poirier@polymtl.ca>
+ * Copyright (C) 2009, 2010 Benjamin Poirier <benjamin.poirier@polymtl.ca>
*
- * 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 <http://www.gnu.org/licenses/>.
*/
#define _GNU_SOURCE
#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);
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);
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= {
.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",
};
/*
* 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);
}
static void initAnalysisEval(SyncState* const syncState)
{
AnalysisDataEval* analysisData;
- unsigned int i;
+ unsigned int i, j;
analysisData= malloc(sizeof(AnalysisDataEval));
syncState->analysisData= analysisData;
rttStream= fopen(optionEvalRttFile.arg, "r");
if (rttStream == NULL)
{
- g_error(strerror(errno));
+ g_error("%s", strerror(errno));
}
readRttInfo(analysisData->rttInfo, rttStream);
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*));
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);
}
}
* 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++)
{
{
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;
}
* 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);
}
* 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);
}
*
* 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);
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);
}
* 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];
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"
{
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");
+ }
}
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);
* 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)
{
.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);
}
}
* 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);
struct RttKey* rttKey;
double* rtt, * exchangeRtt;
- if (!syncState->stats)
- {
- return;
- }
-
g_assert(m1->inE->type == TCP);
// (T2 - T1) - (T3 - T4)
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);
}
}
* 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;
+
+ e0= g_queue_peek_head(broadcast->events);
+ e1= g_queue_peek_tail(broadcast->events);
+ if (e0->traceNum > e1->traceNum)
+ {
+ Event* tmp;
- g_queue_foreach(broadcast->events, &gfSum, &sum);
- g_queue_foreach(broadcast->events, &gfSumSquares, &squaresSum);
+ tmp= e0;
+ e0= e1;
+ e1= tmp;
+ }
+
+ dd= wallTimeSub(&e1->wallTime, &e0->wallTime);
- 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->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);
}
printf("Synchronization evaluation analysis stats:\n");
if (analysisData->stats->broadcastNb)
{
- printf("\tsum of broadcast differential delays: %g\n",
- analysisData->stats->broadcastDiffSum);
- printf("\taverage broadcast differential delays: %g\n",
- analysisData->stats->broadcastDiffSum /
+ 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"
&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);
}
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);
* 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;
if (retval == -1 && !feof(rttStream))
{
- g_error(strerror(errno));
+ g_error("%s", strerror(errno));
}
if (line[retval - 1] == '\n')
&tmp);
if (retval == EOF)
{
- g_error(strerror(errno));
+ g_error("%s", strerror(errno));
}
else if (retval != 3)
{
}
else
{
- g_error(strerror(errno));
+ g_error("%s", strerror(errno));
}
}
}
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);
+ }
+}
projects / lttv.git / blobdiff