lttv/lttv/sync/event_processing_text.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2009 Benjamin Poirier <benjamin.poirier@polymtl.ca>
   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 #define NANOSECONDS_PER_SECOND 1000000000
  20 #define CPU_FREQ 1e9
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <math.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "sync_chain.h"
  33
  34 #include "event_processing_text.h"
  35
  36
  37 // Functions common to all processing modules
  38 static void initProcessingText(SyncState* const syncState, ...);
  39 static void destroyProcessingText(SyncState* const syncState);
  40 static void finalizeProcessingText(SyncState* const syncState);
  41 static void printProcessingStatsText(SyncState* const syncState);
  42 static void writeProcessingTraceTimeOptionsText(SyncState* const syncState,
  43         const unsigned int i, const unsigned int j);
  44 static void writeProcessingTraceTraceOptionsText(SyncState* const syncState,
  45         const unsigned int i, const unsigned int j);
  46 static void writeProcessingGraphVariablesText(SyncState* const syncState,
  47         const unsigned int i);
  48
  49 // Functions specific to this module
  50 static void registerProcessingText() __attribute__((constructor (102)));
  51
  52 static unsigned int readTraceNb(FILE* testCase);
  53 static void skipCommentLines(FILE* testCase);
  54
  55
  56 static ProcessingModule processingModuleText = {
  57         .name= "text",
  58         .initProcessing= &initProcessingText,
  59         .destroyProcessing= &destroyProcessingText,
  60         .finalizeProcessing= &finalizeProcessingText,
  61         .printProcessingStats= &printProcessingStatsText,
  62         .graphFunctions= {
  63                 .writeVariables= &writeProcessingGraphVariablesText,
  64                 .writeTraceTraceOptions= &writeProcessingTraceTraceOptionsText,
  65                 .writeTraceTimeOptions= &writeProcessingTraceTimeOptionsText,
  66         },
  67 };
  68
  69
  70 /*
  71  * Processing Module registering function
  72  */
  73 static void registerProcessingText()
  74 {
  75         g_queue_push_tail(&processingModules, &processingModuleText);
  76 }
  77
  78
  79 /*
  80  * Allocate and initialize data structures for synchronizing a traceset.
  81  * Open test case file.
  82  *
  83  * Args:
  84  *   syncState:    container for synchronization data.
  85  *   testCaseName: const char*, test case file name
  86  */
  87 static void initProcessingText(SyncState* const syncState, ...)
  88 {
  89         ProcessingDataText* processingData;
  90         const char* testCaseName;
  91         va_list ap;
  92
  93         processingData= malloc(sizeof(ProcessingDataText));
  94         syncState->processingData= processingData;
  95         va_start(ap, syncState);
  96         testCaseName= va_arg(ap, const char*);
  97         va_end(ap);
  98
  99         processingData->testCase= fopen(testCaseName, "r");
 100         if (processingData->testCase == NULL)
 101         {
 102                 g_error(strerror(errno));
 103         }
 104         syncState->traceNb= readTraceNb(processingData->testCase);
 105
 106         if (syncState->stats)
 107         {
 108                 processingData->factors= NULL;
 109         }
 110 }
 111
 112
 113 static void destroyProcessingText(SyncState* const syncState)
 114 {
 115         ProcessingDataText* processingData= (ProcessingDataText*)
 116                 syncState->processingData;
 117
 118         if (processingData == NULL)
 119         {
 120                 return;
 121         }
 122
 123         if (syncState->stats && processingData->factors)
 124         {
 125                 g_array_free(processingData->factors, TRUE);
 126         }
 127
 128         free(syncState->processingData);
 129         syncState->processingData= NULL;
 130 }
 131
 132
 133 /*
 134  * Read the test case file and make up events. Dispatch those events to the
 135  * matching module.
 136  *
 137  * Args:
 138  *   syncState:    container for synchronization data.
 139  */
 140 static void finalizeProcessingText(SyncState* const syncState)
 141 {
 142         size_t len;
 143         int retval;
 144         unsigned int* seq;
 145         GArray* factors;
 146         ProcessingDataText* processingData= (ProcessingDataText*)
 147                 syncState->processingData;
 148         FILE* testCase= processingData->testCase;
 149         char* line= NULL;
 150
 151         seq= calloc(syncState->traceNb, sizeof(unsigned int));
 152
 153         skipCommentLines(testCase);
 154         retval= getline(&line, &len, testCase);
 155         while(!feof(testCase))
 156         {
 157                 unsigned int sender, receiver;
 158                 double sendTime, recvTime;
 159                 char tmp;
 160                 unsigned int i;
 161
 162                 if (retval == -1 && !feof(testCase))
 163                 {
 164                         g_error(strerror(errno));
 165                 }
 166
 167                 if (line[len - 1] == '\n')
 168                 {
 169                         line[len - 1]= '\0';
 170                 }
 171
 172                 retval= sscanf(line, " %u %u %lf %lf %c", &sender, &receiver,
 173                         &sendTime, &recvTime, &tmp);
 174                 if (retval == EOF)
 175                 {
 176                         g_error(strerror(errno));
 177                 }
 178                 else if (retval != 4)
 179                 {
 180                         g_error("Error parsing test file while looking for data point, line was '%s'", line);
 181                 }
 182
 183                 if (sender + 1 > syncState->traceNb)
 184                 {
 185                         g_error("Error parsing test file, sender is out of range, line was '%s'", line);
 186                 }
 187
 188                 if (receiver + 1 > syncState->traceNb)
 189                 {
 190                         g_error("Error parsing test file, receiver is out of range, line was '%s'", line);
 191                 }
 192
 193                 if (sendTime < 0)
 194                 {
 195                         g_error("Error parsing test file, send time is negative, line was '%s'", line);
 196                 }
 197
 198                 if (recvTime < 0)
 199                 {
 200                         g_error("Error parsing test file, receive time is negative, line was '%s'", line);
 201                 }
 202
 203                 // Generate ouput and input events
 204                 {
 205                         unsigned int addressOffset;
 206                         struct {
 207                                 unsigned int traceNum;
 208                                 double time;
 209                                 enum Direction direction;
 210                         } loopValues[]= {
 211                                 {sender, sendTime, OUT},
 212                                 {receiver, recvTime, IN},
 213                         };
 214
 215                         /* addressOffset is added to a traceNum to convert it to an address so
 216                          * that the address is not plainly the same as the traceNb. */
 217                         if (syncState->traceNb > 1)
 218                         {
 219                                 addressOffset= pow(10, floor(log(syncState->traceNb - 1) /
 220                                                 log(10)) + 1);
 221                         }
 222                         else
 223                         {
 224                                 addressOffset= 0;
 225                         }
 226
 227                         for (i= 0; i < sizeof(loopValues) / sizeof(*loopValues); i++)
 228                         {
 229                                 Event* event;
 230
 231                                 event= malloc(sizeof(Event));
 232                                 event->traceNum= loopValues[i].traceNum;
 233                                 event->wallTime.seconds= floor(loopValues[i].time);
 234                                 event->wallTime.nanosec= floor((loopValues[i].time -
 235                                                 floor(loopValues[i].time)) * NANOSECONDS_PER_SECOND);
 236                                 event->cpuTime= round(loopValues[i].time * CPU_FREQ);
 237                                 event->type= TCP;
 238                                 event->destroy= &destroyTCPEvent;
 239                                 event->event.tcpEvent= malloc(sizeof(TCPEvent));
 240                                 event->event.tcpEvent->direction= loopValues[i].direction;
 241                                 event->event.tcpEvent->segmentKey= malloc(sizeof(SegmentKey));
 242                                 event->event.tcpEvent->segmentKey->ihl= 5;
 243                                 event->event.tcpEvent->segmentKey->tot_len= 40;
 244                                 event->event.tcpEvent->segmentKey->connectionKey.saddr= sender +
 245                                         addressOffset;
 246                                 event->event.tcpEvent->segmentKey->connectionKey.daddr= receiver +
 247                                         addressOffset;
 248                                 event->event.tcpEvent->segmentKey->connectionKey.source= 57645;
 249                                 event->event.tcpEvent->segmentKey->connectionKey.dest= 80;
 250                                 event->event.tcpEvent->segmentKey->seq= seq[sender];
 251                                 event->event.tcpEvent->segmentKey->ack_seq= 0;
 252                                 event->event.tcpEvent->segmentKey->doff= 5;
 253                                 event->event.tcpEvent->segmentKey->ack= 0;
 254                                 event->event.tcpEvent->segmentKey->rst= 0;
 255                                 event->event.tcpEvent->segmentKey->syn= 1;
 256                                 event->event.tcpEvent->segmentKey->fin= 0;
 257
 258                                 syncState->matchingModule->matchEvent(syncState, event);
 259                         }
 260                 }
 261
 262                 seq[sender]++;
 263
 264                 skipCommentLines(testCase);
 265                 retval= getline(&line, &len, testCase);
 266         }
 267
 268         free(seq);
 269
 270         if (line)
 271         {
 272                 free(line);
 273         }
 274
 275         factors= syncState->matchingModule->finalizeMatching(syncState);
 276         if (syncState->stats)
 277         {
 278                 processingData->factors= factors;
 279         }
 280         else
 281         {
 282                 g_array_free(factors, TRUE);
 283         }
 284 }
 285
 286
 287 /*
 288  * Print statistics related to processing. Must be called after
 289  * finalizeProcessing.
 290  *
 291  * Args:
 292  *   syncState     container for synchronization data.
 293  */
 294 static void printProcessingStatsText(SyncState* const syncState)
 295 {
 296         unsigned int i;
 297
 298         printf("Resulting synchronization factors:\n");
 299         for (i= 0; i < syncState->traceNb; i++)
 300         {
 301                 Factors* factors= &g_array_index(((ProcessingDataText*)
 302                                 syncState->processingData)->factors, Factors, i);
 303
 304                 printf("\ttrace %u drift= %g offset= %g (%f)\n", i, factors->drift,
 305                         factors->offset, factors->offset / CPU_FREQ);
 306         }
 307 }
 308
 309
 310 /*
 311  * Read trace number from the test case stream. The trace number should be the
 312  * first non-comment line and should be an unsigned int by itself on a line.
 313  *
 314  * Args:
 315  *   testCase:     test case stream
 316  *
 317  * Returns:
 318  *   The trace number
 319  */
 320 static unsigned int readTraceNb(FILE* testCase)
 321 {
 322         unsigned int result;
 323         int retval;
 324         char* line= NULL;
 325         size_t len;
 326         char tmp;
 327
 328         skipCommentLines(testCase);
 329         retval= getline(&line, &len, testCase);
 330         if (retval == -1)
 331         {
 332                 if (feof(testCase))
 333                 {
 334                         g_error("Unexpected end of file while looking for number of traces");
 335                 }
 336                 else
 337                 {
 338                         g_error(strerror(errno));
 339                 }
 340         }
 341         if (line[retval - 1] == '\n')
 342         {
 343                 line[retval - 1]= '\0';
 344         }
 345
 346         retval= sscanf(line, " %u %c", &result, &tmp);
 347         if (retval == EOF || retval != 1)
 348         {
 349                 g_error("Error parsing test file while looking for number of traces, line was '%s'", line);
 350
 351                 // Not really needed but avoids warning from gcc
 352                 abort();
 353         }
 354
 355         return result;
 356 }
 357
 358
 359 /*
 360  * Advance testCase stream over empty space, empty lines and lines that begin
 361  * with '#'
 362  *
 363  * Args:
 364  *   testCase:     test case stream
 365  */
 366 static void skipCommentLines(FILE* testCase)
 367 {
 368         int firstChar;
 369         ssize_t retval;
 370         char* line= NULL;
 371         size_t len;
 372
 373         do
 374         {
 375                 firstChar= fgetc(testCase);
 376                 if (firstChar == (int) '#')
 377                 {
 378                         retval= getline(&line, &len, testCase);
 379                         if (retval == -1)
 380                         {
 381                                 if (feof(testCase))
 382                                 {
 383                                         goto outEof;
 384                                 }
 385                                 else
 386                                 {
 387                                         g_error(strerror(errno));
 388                                 }
 389                         }
 390                 }
 391                 else if (firstChar == (int) '\n' || firstChar == (int) ' ')
 392                 {}
 393                 else if (firstChar == EOF)
 394                 {
 395                         goto outEof;
 396                 }
 397                 else
 398                 {
 399                         break;
 400                 }
 401         } while (true);
 402         retval= ungetc(firstChar, testCase);
 403         if (retval == EOF)
 404         {
 405                 g_error("Error: ungetc()");
 406         }
 407
 408 outEof:
 409         if (line)
 410         {
 411                 free(line);
 412         }
 413 }
 414
 415
 416 /*
 417  * Write the processing-specific variables in the gnuplot script.
 418  *
 419  * Args:
 420  *   syncState:    container for synchronization data
 421  *   i:            trace number
 422  */
 423 static void writeProcessingGraphVariablesText(SyncState* const syncState,
 424         const unsigned int i)
 425 {
 426         fprintf(syncState->graphsStream, "clock_freq_%u= %.3f\n", i, CPU_FREQ);
 427 }
 428
 429
 430 /*
 431  * Write the processing-specific options in the gnuplot script.
 432  *
 433  * Args:
 434  *   syncState:    container for synchronization data
 435  *   i:            first trace number
 436  *   j:            second trace number, garanteed to be larger than i
 437  */
 438 static void writeProcessingTraceTraceOptionsText(SyncState* const syncState,
 439         const unsigned int i, const unsigned int j)
 440 {
 441         fprintf(syncState->graphsStream,
 442         "set key inside right bottom\n"
 443         "set xlabel \"Clock %1$u\"\n"
 444         "set xtics nomirror\n"
 445         "set ylabel \"Clock %2$u\"\n"
 446         "set ytics nomirror\n"
 447                 "set x2label \"Clock %1$d (s)\"\n"
 448                 "set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
 449                 "set x2tics\n"
 450                 "set y2label \"Clock %2$d (s)\"\n"
 451                 "set y2range [GPVAL_Y_MIN / clock_freq_%2$u : GPVAL_Y_MAX / clock_freq_%2$u]\n"
 452                 "set y2tics\n", i, j);
 453 }
 454
 455
 456 /*
 457  * Write the processing-specific options in the gnuplot script.
 458  *
 459  * Args:
 460  *   syncState:    container for synchronization data
 461  *   i:            first trace number
 462  *   j:            second trace number, garanteed to be larger than i
 463  */
 464 static void writeProcessingTraceTimeOptionsText(SyncState* const syncState,
 465         const unsigned int i, const unsigned int j)
 466 {
 467         fprintf(syncState->graphsStream,
 468         "set key inside right bottom\n"
 469         "set xlabel \"Clock %1$u\"\n"
 470         "set xtics nomirror\n"
 471         "set ylabel \"time (s)\"\n"
 472         "set ytics nomirror\n"
 473                 "set x2label \"Clock %1$d (s)\"\n"
 474                 "set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
 475                 "set x2tics\n", i);
 476 }