#endif
#include <errno.h>
+#include <inttypes.h>
#include <math.h>
#include <float.h>
#include <stdlib.h>
#include <stdio.h>
+#include <string.h>
#include <unistd.h>
#include "sync_chain.h"
#include "event_analysis_chull.h"
-#ifndef g_info
-#define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
-#endif
-
-
typedef enum
{
LOWER,
unsigned int i, const unsigned int j);
// Functions specific to this module
-static void registerAnalysisCHull() __attribute__((constructor (101)));
-
static void openGraphFiles(SyncState* const syncState);
static void closeGraphFiles(SyncState* const syncState);
static void writeGraphFiles(SyncState* const syncState);
const p3) __attribute__((pure));
static double crossProductK(const Point const* p1, const Point const* p2,
const Point const* p3, const Point const* p4) __attribute__((pure));
-static FactorsCHull** calculateAllFactors(SyncState* const syncState);
static Factors* calculateFactorsExact(GQueue* const cu, GQueue* const cl, const
LineType lineType) __attribute__((pure));
-static void calculateFactorsMiddle(FactorsCHull* factors);
static void calculateFactorsFallback(GQueue* const cr, GQueue* const cs,
FactorsCHull* const result);
static double slope(const Point* const p1, const Point* const p2)
__attribute__((pure));
static GArray* reduceFactors(SyncState* const syncState, FactorsCHull**
allFactors);
-static void freeAllFactors(const SyncState* const syncState, FactorsCHull**
- const allFactors);
static double verticalDistance(Point* p1, Point* p2, Point* const point)
__attribute__((pure));
static void floydWarshall(SyncState* const syncState, FactorsCHull** const
.finalizeAnalysis= &finalizeAnalysisCHull,
.printAnalysisStats= &printAnalysisStatsCHull,
.graphFunctions= {
- .writeTraceTracePlots= &writeAnalysisGraphsPlotsCHull,
+ .writeTraceTraceForePlots= &writeAnalysisGraphsPlotsCHull,
}
};
+const char* const approxNames[]= {
+ [EXACT]= "Exact",
+ [MIDDLE]= "Middle",
+ [FALLBACK]= "Fallback",
+ [INCOMPLETE]= "Incomplete",
+ [ABSENT]= "Absent",
+ [SCREWED]= "Screwed",
+};
+
/*
* Analysis module registering function
*/
-static void registerAnalysisCHull()
+void registerAnalysisCHull()
{
g_queue_push_tail(&analysisModules, &analysisModuleCHull);
}
analysisData= (AnalysisDataCHull*) syncState->analysisData;
- cwd= changeToGraphDir(syncState->graphsDir);
+ cwd= changeToGraphsDir(syncState->graphsDir);
analysisData->graphsData->hullPoints= malloc(syncState->traceNb *
sizeof(FILE**));
Point* point;
point= (Point*) data;
- fprintf((FILE*) userData, "%20llu %20llu\n", point->x, point->y);
+ fprintf((FILE*) userData, "%20" PRIu64 " %20" PRIu64 "\n", point->x, point->y);
}
for (j= 0; j < syncState->traceNb; j++)
{
g_queue_foreach(analysisData->hullArray[i][j], gfPointDestroy, NULL);
+ g_queue_free(analysisData->hullArray[i][j]);
}
free(analysisData->hullArray[i]);
}
{
if (analysisData->stats->allFactors != NULL)
{
- freeAllFactors(syncState, analysisData->stats->allFactors);
+ freeAllFactors(syncState->traceNb, analysisData->stats->allFactors);
}
free(analysisData->stats);
if (!syncState->stats && analysisData->graphsData->allFactors != NULL)
{
- freeAllFactors(syncState, analysisData->graphsData->allFactors);
+ freeAllFactors(syncState->traceNb, analysisData->graphsData->allFactors);
}
free(analysisData->graphsData);
newPoint->x= message->inE->cpuTime;
newPoint->y= message->outE->cpuTime;
hullType= UPPER;
- g_debug("Reception point hullArray[%lu][%lu] x= inE->time= %llu y= outE->time= %llu",
+ g_debug("Reception point hullArray[%lu][%lu] "
+ "x= inE->time= %" PRIu64 " y= outE->time= %" PRIu64,
message->inE->traceNum, message->outE->traceNum, newPoint->x,
newPoint->y);
}
newPoint->x= message->outE->cpuTime;
newPoint->y= message->inE->cpuTime;
hullType= LOWER;
- g_debug("Send point hullArray[%lu][%lu] x= inE->time= %llu y= outE->time= %llu",
+ g_debug("Send point hullArray[%lu][%lu] "
+ "x= inE->time= %" PRIu64 " y= outE->time= %" PRIu64,
message->inE->traceNum, message->outE->traceNum, newPoint->x,
newPoint->y);
}
}
else
{
- freeAllFactors(syncState, allFactors);
+ freeAllFactors(syncState->traceNb, allFactors);
}
return factors;
FactorsCHull* factorsCHull;
factorsCHull= &analysisData->stats->allFactors[j][i];
- printf("\t\t%3d - %-3d: ", i, j);
+ printf("\t\t%3d - %-3d: %s", i, j,
+ approxNames[factorsCHull->type]);
if (factorsCHull->type == EXACT)
{
- printf("Exact a0= % 7g a1= 1 %c %7g\n",
+ printf(" a0= % 7g a1= 1 %c %7g\n",
factorsCHull->approx->offset,
factorsCHull->approx->drift < 0. ? '-' : '+',
fabs(factorsCHull->approx->drift));
}
else if (factorsCHull->type == MIDDLE)
{
- printf("Middle a0= % 7g a1= 1 %c %7g accuracy %7g\n",
+ printf(" a0= % 7g a1= 1 %c %7g accuracy %7g\n",
factorsCHull->approx->offset, factorsCHull->approx->drift
- 1. < 0. ? '-' : '+', fabs(factorsCHull->approx->drift -
1.), factorsCHull->accuracy);
}
else if (factorsCHull->type == FALLBACK)
{
- printf("Fallback a0= % 7g a1= 1 %c %7g error= %7g\n",
+ printf(" a0= % 7g a1= 1 %c %7g error= %7g\n",
factorsCHull->approx->offset, factorsCHull->approx->drift
- 1. < 0. ? '-' : '+', fabs(factorsCHull->approx->drift -
1.), factorsCHull->accuracy);
}
else if (factorsCHull->type == INCOMPLETE)
{
- printf("Incomplete\n");
+ printf("\n");
if (factorsCHull->min->drift != -INFINITY)
{
}
else if (factorsCHull->type == SCREWED)
{
- printf("Screwed\n");
+ printf("\n");
if (factorsCHull->min != NULL && factorsCHull->min->drift != -INFINITY)
{
}
else if (factorsCHull->type == ABSENT)
{
- printf("Absent\n");
+ printf("\n");
}
else
{
const double fuzzFactor= 0.;
result= crossProductK(p1, p2, p1, p3);
- g_debug("crossProductK(p1= (%llu, %llu), p2= (%llu, %llu), p1= (%llu, %llu), p3= (%llu, %llu))= %g",
+ g_debug("crossProductK(p1= (%" PRIu64 ", %" PRIu64 "), "
+ "p2= (%" PRIu64 ", %" PRIu64 "), p1= (%" PRIu64 ", %" PRIu64 "), "
+ "p3= (%" PRIu64 ", %" PRIu64 "))= %g",
p1->x, p1->y, p2->x, p2->y, p1->x, p1->y, p3->x, p3->y, result);
if (result < fuzzFactor)
{
* Free a container of FactorsCHull
*
* Args:
- * syncState: container for synchronization data.
- * allFactors: container of Factors
+ * traceNb: number of traces
+ * allFactors: container of FactorsCHull
*/
-static void freeAllFactors(const SyncState* const syncState, FactorsCHull**
- const allFactors)
+void freeAllFactors(const unsigned int traceNb, FactorsCHull** const
+ allFactors)
{
unsigned int i, j;
- for (i= 0; i < syncState->traceNb; i++)
+ for (i= 0; i < traceNb; i++)
{
for (j= 0; j <= i; j++)
{
- FactorsCHull* factorsCHull;
-
- factorsCHull= &allFactors[i][j];
- if (factorsCHull->type == MIDDLE || factorsCHull->type ==
- INCOMPLETE || factorsCHull->type == ABSENT)
- {
- free(factorsCHull->min);
- free(factorsCHull->max);
- }
- else if (factorsCHull->type == SCREWED)
- {
- if (factorsCHull->min != NULL)
- {
- free(factorsCHull->min);
- }
- if (factorsCHull->max != NULL)
- {
- free(factorsCHull->max);
- }
- }
-
- if (factorsCHull->type == EXACT || factorsCHull->type == MIDDLE ||
- factorsCHull->type == FALLBACK)
- {
- free(factorsCHull->approx);
- }
+ destroyFactorsCHull(&allFactors[i][j]);
}
free(allFactors[i]);
}
}
+/*
+ * Free a FactorsCHull
+ *
+ * Args:
+ * factorsCHull: container of Factors
+ */
+void destroyFactorsCHull(FactorsCHull* factorsCHull)
+{
+ if (factorsCHull->type == MIDDLE || factorsCHull->type ==
+ INCOMPLETE || factorsCHull->type == ABSENT)
+ {
+ free(factorsCHull->min);
+ free(factorsCHull->max);
+ }
+ else if (factorsCHull->type == SCREWED)
+ {
+ if (factorsCHull->min != NULL)
+ {
+ free(factorsCHull->min);
+ }
+ if (factorsCHull->max != NULL)
+ {
+ free(factorsCHull->max);
+ }
+ }
+
+ if (factorsCHull->type == EXACT || factorsCHull->type == MIDDLE ||
+ factorsCHull->type == FALLBACK)
+ {
+ free(factorsCHull->approx);
+ }
+}
+
+
/*
* Analyze the convex hulls to determine the synchronization factors between
* each pair of trace.
* FactorsCHull*[TraceNum][TraceNum] array. See the documentation for the
* member allFactors of AnalysisStatsCHull.
*/
-static FactorsCHull** calculateAllFactors(SyncState* const syncState)
+FactorsCHull** calculateAllFactors(SyncState* const syncState)
{
unsigned int traceNumA, traceNumB;
FactorsCHull** allFactors;
* Args:
* factors: contains the min and max limits, used to store the result
*/
-static void calculateFactorsMiddle(FactorsCHull* factors)
+void calculateFactorsMiddle(FactorsCHull* const factors)
{
double amin, amax, bmin, bmax, bhat;
bmin= factors->min->drift;
bmax= factors->max->drift;
- g_assert_cmpfloat(bmax, >, bmin);
+ g_assert_cmpfloat(bmax, >=, bmin);
factors->approx= malloc(sizeof(Factors));
bhat= (bmax * bmin - 1. + sqrt(1. + pow(bmax, 2.) * pow(bmin, 2.) +
p1= g_queue_peek_nth(c1, i1);
p2= g_queue_peek_nth(c2, i2);
- g_debug("Resulting points are: c1[i1]: x= %llu y= %llu c2[i2]: x= %llu y= %llu",
- p1->x, p1->y, p2->x, p2->y);
+ g_debug("Resulting points are: c1[i1]: x= %" PRIu64 " y= %" PRIu64
+ " c2[i2]: x= %" PRIu64 " y= %" PRIu64 "", p1->x, p1->y, p2->x, p2->y);
result= malloc(sizeof(Factors));
result->drift= slope(p1, p2);
result->offset= intercept(p1, p2);
- g_debug("Resulting factors are: drift= %g offset= %g", result->drift, result->offset);
+ g_debug("Resulting factors are: drift= %g offset= %g", result->drift,
+ result->offset);
return result;
}
fprintf(syncState->graphsStream,
"\t%.2f + %.10f * x "
"title \"Middle conversion\" with lines "
- "linecolor rgb \"gray60\" linetype 1, \\\n",
+ "linecolor rgb \"black\" linetype 1, \\\n",
factorsCHull->approx->offset, factorsCHull->approx->drift);
}
else if (factorsCHull->type == FALLBACK)