lttv/modules/text/sync_chain_batch.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2009 Benjamin Poirier
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <glib.h>
  26 #include <inttypes.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/resource.h>
  31 #include <sys/time.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <unistd.h>
  35
  36 #include <lttv/attribute.h>
  37 #include <lttv/filter.h>
  38 #include <lttv/hook.h>
  39 #include <lttv/iattribute.h>
  40 #include <lttv/lttv.h>
  41 #include <lttv/module.h>
  42 #include <lttv/option.h>
  43 #include <lttv/print.h>
  44 #include <lttv/sync/sync_chain.h>
  45 #include <ltt/ltt.h>
  46 #include <ltt/event.h>
  47 #include <ltt/trace.h>
  48
  49
  50 struct TracesetChainState {
  51         // uint64_t* eventNbs[LttvTraceContext*]
  52         GHashTable* eventNbs;
  53
  54         SyncState* syncState;
  55         struct timeval startTime;
  56         struct rusage startUsage;
  57 };
  58
  59 static LttvHooks* before_traceset, * before_trace, * event_hook, * after_traceset;
  60
  61
  62 static void init();
  63 static void destroy();
  64
  65 static gboolean tracesetStart(void *hook_data, void *call_data);
  66 static gboolean traceStart(void *hook_data, void *call_data);
  67 static int processEveryEvent(void *hook_data, void *call_data);
  68 static gboolean tracesetEnd(void *hook_data, void *call_data);
  69
  70 static void setupSyncChain(LttvTracesetContext* const traceSetContext);
  71 static void teardownSyncChain(LttvTracesetContext* const traceSetContext);
  72
  73 void ghfPrintEventCount(gpointer key, gpointer value, gpointer user_data);
  74 void gdnDestroyUint64(gpointer data);
  75
  76 // struct TracesetChainState* tracesetChainStates[LttvTracesetContext*]
  77 static GHashTable* tracesetChainStates;
  78
  79 static LttvHooks* before_traceset, * before_trace, * event_hook, * after_traceset;
  80 static const struct {
  81         const char const *path;
  82         LttvHooks **hook;
  83         LttvHook function;
  84 } batchAnalysisHooks[] = {
  85         {"hooks/traceset/before", &before_traceset, &tracesetStart},
  86         {"hooks/trace/before", &before_trace, &traceStart},
  87         {"hooks/event", &event_hook, &processEveryEvent},
  88         {"hooks/traceset/after", &after_traceset, &tracesetEnd},
  89 };
  90
  91 static gboolean optionEvalGraphs;
  92 static char* optionEvalGraphsDir;
  93 static char graphsDir[20];
  94
  95
  96 /*
  97  * Module init function
  98  */
  99 static void init()
 100 {
 101         gboolean result;
 102         unsigned int i;
 103         LttvAttributeValue value;
 104         int retval;
 105         LttvIAttribute* attributes= LTTV_IATTRIBUTE(lttv_global_attributes());
 106
 107         tracesetChainStates= g_hash_table_new(NULL, NULL);
 108
 109         for (i= 0; i < sizeof(batchAnalysisHooks) / sizeof(*batchAnalysisHooks);
 110                 i++)
 111         {
 112                 result= lttv_iattribute_find_by_path(attributes,
 113                         batchAnalysisHooks[i].path, LTTV_POINTER, &value);
 114                 g_assert(result);
 115                 *batchAnalysisHooks[i].hook= *(value.v_pointer);
 116                 g_assert(*batchAnalysisHooks[i].hook);
 117                 lttv_hooks_add(*batchAnalysisHooks[i].hook,
 118                         batchAnalysisHooks[i].function, NULL, LTTV_PRIO_DEFAULT);
 119         }
 120
 121         optionEvalGraphs= FALSE;
 122         lttv_option_add("eval-graphs", '\0', "output gnuplot graph showing "
 123                 "synchronization points", "none", LTTV_OPT_NONE, &optionEvalGraphs,
 124                 NULL, NULL);
 125
 126         retval= snprintf(graphsDir, sizeof(graphsDir), "eval-graphs-%d", getpid());
 127         if (retval > sizeof(graphsDir) - 1)
 128         {
 129                 graphsDir[sizeof(graphsDir) - 1]= '\0';
 130         }
 131         optionEvalGraphsDir= graphsDir;
 132         lttv_option_add("eval-graphs-dir", '\0', "specify the directory where to"
 133                 " store the graphs", graphsDir, LTTV_OPT_STRING, &optionEvalGraphsDir,
 134                 NULL, NULL);
 135 }
 136
 137
 138 /*
 139  * Module destroy function
 140  */
 141 static void destroy()
 142 {
 143         unsigned int i;
 144
 145         g_assert_cmpuint(g_hash_table_size(tracesetChainStates), ==, 0);
 146         g_hash_table_destroy(tracesetChainStates);
 147
 148         for (i= 0; i < sizeof(batchAnalysisHooks) / sizeof(*batchAnalysisHooks);
 149                 i++)
 150         {
 151                 lttv_hooks_remove_data(*batchAnalysisHooks[i].hook,
 152                         batchAnalysisHooks[i].function, NULL);
 153         }
 154
 155         lttv_option_remove("eval-graphs");
 156         lttv_option_remove("eval-graphs-dir");
 157 }
 158
 159
 160 /*
 161  * Lttv hook function that will be called before a traceset is processed
 162  *
 163  * Args:
 164  *   hookData:     NULL
 165  *   callData:     LttvTracesetContext* at that moment
 166  *
 167  * Returns:
 168  *   FALSE         Always returns FALSE, meaning to keep processing hooks
 169  */
 170 static gboolean tracesetStart(void *hook_data, void *call_data)
 171 {
 172         struct TracesetChainState* tracesetChainState;
 173         LttvTracesetContext *tsc= (LttvTracesetContext *) call_data;
 174
 175         tracesetChainState= malloc(sizeof(struct TracesetChainState));
 176         g_hash_table_insert(tracesetChainStates, tsc, tracesetChainState);
 177         tracesetChainState->eventNbs= g_hash_table_new_full(&g_direct_hash,
 178                 &g_direct_equal, NULL, &gdnDestroyUint64);
 179
 180         gettimeofday(&tracesetChainState->startTime, 0);
 181         getrusage(RUSAGE_SELF, &tracesetChainState->startUsage);
 182
 183         setupSyncChain(tsc);
 184
 185         return FALSE;
 186 }
 187
 188
 189 /*
 190  * Lttv hook function that will be called before a trace is processed
 191  *
 192  * Args:
 193  *   hookData:     NULL
 194  *   callData:     LttvTraceContext* at that moment
 195  *
 196  * Returns:
 197  *   FALSE         Always returns FALSE, meaning to keep processing hooks
 198  */
 199 static gboolean traceStart(void *hook_data, void *call_data)
 200 {
 201         struct TracesetChainState* tracesetChainState;
 202         uint64_t* eventNb;
 203         LttvTraceContext* tc= (LttvTraceContext*) call_data;
 204         LttvTracesetContext* tsc= tc->ts_context;
 205
 206         tracesetChainState= g_hash_table_lookup(tracesetChainStates, tsc);
 207         eventNb= malloc(sizeof(uint64_t));
 208         *eventNb= 0;
 209         g_hash_table_insert(tracesetChainState->eventNbs, tc, eventNb);
 210
 211         return FALSE;
 212 }
 213
 214
 215 /*
 216  * Lttv hook function that is called for every event
 217  *
 218  * Args:
 219  *   hookData:     NULL
 220  *   callData:     LttvTracefileContext* at the moment of the event
 221  *
 222  * Returns:
 223  *   FALSE         Always returns FALSE, meaning to keep processing hooks for
 224  *                 this event
 225  */
 226 static int processEveryEvent(void *hook_data, void *call_data)
 227 {
 228         LttvTracefileContext* tfc= (LttvTracefileContext*) call_data;
 229         LttvTraceContext* tc= tfc->t_context;
 230         LttvTracesetContext* tsc= tc->ts_context;
 231         struct TracesetChainState* tracesetChainState;
 232         uint64_t* eventNb;
 233
 234         tracesetChainState= g_hash_table_lookup(tracesetChainStates, tsc);
 235         eventNb= g_hash_table_lookup(tracesetChainState->eventNbs, tc);
 236
 237         (*eventNb)++;
 238
 239         return FALSE;
 240 }
 241
 242
 243 /*
 244  * Lttv hook function that is called after a traceset has been processed
 245  *
 246  * Args:
 247  *   hookData:     NULL
 248  *   callData:     LttvTracefileContext* at that moment
 249  *
 250  * Returns:
 251  *   FALSE         Always returns FALSE, meaning to keep processing hooks
 252  */
 253 static gboolean tracesetEnd(void *hook_data, void *call_data)
 254 {
 255         struct TracesetChainState* tracesetChainState;
 256         LttvTracesetContext* tsc= (LttvTracesetContext*) call_data;
 257         uint64_t sum= 0;
 258
 259         tracesetChainState= g_hash_table_lookup(tracesetChainStates, tsc);
 260         printf("Event count (%u traces):\n",
 261                 g_hash_table_size(tracesetChainState->eventNbs));
 262         g_hash_table_foreach(tracesetChainState->eventNbs, &ghfPrintEventCount,
 263                 &sum);
 264         printf("\ttotal events: %" PRIu64 "\n", sum);
 265         g_hash_table_destroy(tracesetChainState->eventNbs);
 266
 267         teardownSyncChain(tsc);
 268
 269         g_hash_table_remove(tracesetChainStates, tsc);
 270
 271         return FALSE;
 272 }
 273
 274
 275 /*
 276  * Initialize modules in a sync chain. Use modules that will check
 277  * the precision of time synchronization between a group of traces.
 278  *
 279  * Args:
 280  *   traceSetContext: traceset
 281  */
 282 void setupSyncChain(LttvTracesetContext* const traceSetContext)
 283 {
 284         struct TracesetChainState* tracesetChainState;
 285         SyncState* syncState;
 286         GList* result;
 287         int retval;
 288
 289         tracesetChainState= g_hash_table_lookup(tracesetChainStates, traceSetContext);
 290         syncState= malloc(sizeof(SyncState));
 291         tracesetChainState->syncState= syncState;
 292         syncState->traceNb= lttv_traceset_number(traceSetContext->ts);
 293
 294         syncState->stats= true;
 295
 296         if (optionEvalGraphs)
 297         {
 298                 char* cwd;
 299                 int graphsFp;
 300
 301                 // Create the graph directory right away in case the module initialization
 302                 // functions have something to write in it.
 303                 syncState->graphsDir= optionEvalGraphsDir;
 304                 cwd= changeToGraphDir(optionEvalGraphsDir);
 305
 306                 if ((graphsFp= open("graphs.gnu", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR |
 307                                 S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH
 308                                 | S_IWOTH | S_IXOTH)) == -1)
 309                 {
 310                         g_error(strerror(errno));
 311                 }
 312                 if ((syncState->graphsStream= fdopen(graphsFp, "w")) == NULL)
 313                 {
 314                         g_error(strerror(errno));
 315                 }
 316
 317                 retval= chdir(cwd);
 318                 if (retval == -1)
 319                 {
 320                         g_error(strerror(errno));
 321                 }
 322                 free(cwd);
 323         }
 324         else
 325         {
 326                 syncState->graphsStream= NULL;
 327                 syncState->graphsDir= NULL;
 328         }
 329
 330         syncState->analysisData= NULL;
 331         result= g_queue_find_custom(&analysisModules, "eval",
 332                 &gcfCompareAnalysis);
 333         syncState->analysisModule= (AnalysisModule*) result->data;
 334         syncState->analysisModule->initAnalysis(syncState);
 335
 336         syncState->matchingData= NULL;
 337         result= g_queue_find_custom(&matchingModules, "distributor",
 338                 &gcfCompareMatching);
 339         syncState->matchingModule= (MatchingModule*) result->data;
 340         syncState->matchingModule->initMatching(syncState);
 341
 342         syncState->processingData= NULL;
 343         result= g_queue_find_custom(&processingModules, "LTTV-standard",
 344                 &gcfCompareProcessing);
 345         syncState->processingModule= (ProcessingModule*) result->data;
 346         syncState->processingModule->initProcessing(syncState, traceSetContext);
 347 }
 348
 349
 350 /*
 351  * Destroy modules in a sync chain
 352  *
 353  * Args:
 354  *   traceSetContext: traceset
 355  */
 356 void teardownSyncChain(LttvTracesetContext* const traceSetContext)
 357 {
 358         struct TracesetChainState* tracesetChainState;
 359         SyncState* syncState;
 360         struct timeval endTime;
 361         struct rusage endUsage;
 362         unsigned int i, j;
 363         int retval;
 364
 365         tracesetChainState= g_hash_table_lookup(tracesetChainStates, traceSetContext);
 366         syncState= tracesetChainState->syncState;
 367
 368         syncState->processingModule->finalizeProcessing(syncState);
 369
 370         // Write graphs file
 371         if (optionEvalGraphs)
 372         {
 373                 fprintf(syncState->graphsStream,
 374                         "#!/usr/bin/gnuplot\n\n"
 375                         "set terminal postscript eps color size 8in,6in\n");
 376
 377                 // Cover the upper triangular matrix, i is the reference node.
 378                 for (i= 0; i < syncState->traceNb; i++)
 379                 {
 380                         for (j= i + 1; j < syncState->traceNb; j++)
 381                         {
 382                                 long pos1, pos2, trunc;
 383
 384                                 fprintf(syncState->graphsStream,
 385                                         "\nset output \"%03d-%03d.eps\"\n"
 386                                         "plot \\\n", i, j);
 387                                 pos1= ftell(syncState->graphsStream);
 388
 389                                 if (syncState->analysisModule->writeAnalysisGraphsPlots)
 390                                 {
 391                                         syncState->analysisModule->writeAnalysisGraphsPlots(syncState,
 392                                                 i, j);
 393                                 }
 394
 395                                 fflush(syncState->graphsStream);
 396                                 pos2= ftell(syncState->graphsStream);
 397                                 if (pos1 != pos2)
 398                                 {
 399                                         // Remove the ", \\\n" from the last graph plot line
 400                                         trunc= pos2 - 4;
 401                                 }
 402                                 else
 403                                 {
 404                                         // Remove the "plot \\\n" line to avoid creating an invalid
 405                                         // gnuplot script
 406                                         trunc= pos2 - 7;
 407                                 }
 408
 409                                 if (ftruncate(fileno(syncState->graphsStream), trunc) == -1)
 410                                 {
 411                                         g_error(strerror(errno));
 412                                 }
 413                                 if (fseek(syncState->graphsStream, 0, SEEK_END) == -1)
 414                                 {
 415                                         g_error(strerror(errno));
 416                                 }
 417
 418                                 fprintf(syncState->graphsStream,
 419                                         "\nset output \"%1$03d-%2$03d.eps\"\n"
 420                                         "set title \"\"\n", i, j);
 421
 422                                 if (syncState->analysisModule->writeAnalysisGraphsOptions)
 423                                 {
 424                                         syncState->analysisModule->writeAnalysisGraphsOptions(syncState,
 425                                                 i, j);
 426                                 }
 427
 428                                 if (pos1 != pos2)
 429                                 {
 430                                         fprintf(syncState->graphsStream, "replot\n");
 431                                 }
 432                         }
 433                 }
 434
 435                 if (fclose(syncState->graphsStream) != 0)
 436                 {
 437                         g_error(strerror(errno));
 438                 }
 439         }
 440
 441         if (syncState->processingModule->printProcessingStats != NULL)
 442         {
 443                 syncState->processingModule->printProcessingStats(syncState);
 444         }
 445         if (syncState->matchingModule->printMatchingStats != NULL)
 446         {
 447                 syncState->matchingModule->printMatchingStats(syncState);
 448         }
 449         if (syncState->analysisModule->printAnalysisStats != NULL)
 450         {
 451                 syncState->analysisModule->printAnalysisStats(syncState);
 452         }
 453
 454         printf("Resulting synchronization factors:\n");
 455     for (i= 0; i < syncState->traceNb; i++)
 456     {
 457         LttTrace* t;
 458
 459         t= traceSetContext->traces[i]->t;
 460
 461         printf("\ttrace %u drift= %g offset= %g (%f) start time= %ld.%09ld\n",
 462             i, t->drift, t->offset, (double) tsc_to_uint64(t->freq_scale,
 463                 t->start_freq, t->offset) / NANOSECONDS_PER_SECOND,
 464             t->start_time_from_tsc.tv_sec, t->start_time_from_tsc.tv_nsec);
 465     }
 466
 467         syncState->processingModule->destroyProcessing(syncState);
 468         if (syncState->matchingModule != NULL)
 469         {
 470                 syncState->matchingModule->destroyMatching(syncState);
 471         }
 472         if (syncState->analysisModule != NULL)
 473         {
 474                 syncState->analysisModule->destroyAnalysis(syncState);
 475         }
 476
 477         free(syncState);
 478
 479         gettimeofday(&endTime, 0);
 480         retval= getrusage(RUSAGE_SELF, &endUsage);
 481
 482         timeDiff(&endTime, &tracesetChainState->startTime);
 483         timeDiff(&endUsage.ru_utime, &tracesetChainState->startUsage.ru_utime);
 484         timeDiff(&endUsage.ru_stime, &tracesetChainState->startUsage.ru_stime);
 485
 486         printf("Evaluation time:\n");
 487         printf("\treal time: %ld.%06ld\n", endTime.tv_sec, endTime.tv_usec);
 488         printf("\tuser time: %ld.%06ld\n", endUsage.ru_utime.tv_sec,
 489                 endUsage.ru_utime.tv_usec);
 490         printf("\tsystem time: %ld.%06ld\n", endUsage.ru_stime.tv_sec,
 491                 endUsage.ru_stime.tv_usec);
 492
 493         g_hash_table_remove(tracesetChainStates, traceSetContext);
 494         free(tracesetChainState);
 495 }
 496
 497
 498
 499 /*
 500  * A GHFunc function for g_hash_table_foreach()
 501  *
 502  * Args:
 503  *   key:          LttvTraceContext *
 504  *   value:        uint64_t *, event count for this trace
 505  *   user_data:    uint64_t *, sum of the event counts
 506  *
 507  * Returns:
 508  *   Updates the sum in user_data
 509  */
 510 void ghfPrintEventCount(gpointer key, gpointer value, gpointer user_data)
 511 {
 512         LttvTraceContext *tc = (LttvTraceContext *) key;
 513         uint64_t *eventNb = (uint64_t *)value;
 514         uint64_t *sum = (uint64_t *)user_data;
 515
 516         printf("\t%s: %" PRIu64 "\n", g_quark_to_string(ltt_trace_name(tc->t)),
 517                 *eventNb);
 518         *sum += *eventNb;
 519 }
 520
 521
 522 /*
 523  * A GDestroyNotify function for g_hash_table_new_full()
 524  *
 525  * Args:
 526  *   data:         TsetStats *
 527  */
 528 void gdnDestroyUint64(gpointer data)
 529 {
 530         free((uint64_t *) data);
 531 }
 532
 533
 534 LTTV_MODULE("sync_chain_batch", "Execute synchronization modules in a "\
 535         "post-processing step.", "This can be used to quantify the precision "\
 536         "with which a group of trace is synchronized.", init, destroy,\
 537         "batchAnalysis", "option", "sync")