dalvik/tools/dmtracedump/CreateTestTrace.c

   1 /* //device/tools/dmtracedump/CreateTrace.c
   2 **
   3 ** Copyright 2006, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 /*
  19  * Create a test file in the format required by dmtrace.
  20  */
  21 #define NOT_VM
  22 #include "Profile.h"        // from VM header
  23
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <assert.h>
  30 #include <unistd.h>
  31 #include <sys/time.h>
  32 #include <time.h>
  33 #include <ctype.h>
  34
  35 /*
  36  * Values from the header of the data file.
  37  */
  38 typedef struct DataHeader {
  39     unsigned int magic;
  40     short version;
  41     short offsetToData;
  42     long long startWhen;
  43 } DataHeader;
  44
  45 #define VERSION 2
  46 int versionNumber = VERSION;
  47 int verbose = 0;
  48
  49 DataHeader header = { 0x574f4c53, VERSION, sizeof(DataHeader), 0LL };
  50
  51 char *versionHeader = "*version\n";
  52 char *clockDef = "clock=thread-cpu\n";
  53
  54 char *keyThreads =
  55 "*threads\n"
  56 "1      main\n"
  57 "2      foo\n"
  58 "3      bar\n"
  59 "4      blah\n";
  60
  61 char *keyEnd = "*end\n";
  62
  63 typedef struct dataRecord {
  64     unsigned int        time;
  65     int                 threadId;
  66     unsigned int        action;         /* 0=entry, 1=exit, 2=exception exit */
  67     char                *fullName;
  68     char                *className;
  69     char                *methodName;
  70     char                *signature;
  71     unsigned int        methodId;
  72 } dataRecord;
  73
  74 dataRecord *records;
  75
  76 #define BUF_SIZE 1024
  77 char buf[BUF_SIZE];
  78
  79 typedef struct stack {
  80     dataRecord  **frames;
  81     int         indentLevel;
  82 } stack;
  83
  84 /* Mac OS doesn't have strndup(), so implement it here.
  85  */
  86 char *strndup(const char *src, size_t len)
  87 {
  88     char *dest = (char *) malloc(len + 1);
  89     strncpy(dest, src, len);
  90     dest[len] = 0;
  91     return dest;
  92 }
  93
  94 /*
  95  * Parse the input file.  It looks something like this:
  96  * # This is a comment line
  97  * 4  1 A
  98  * 6  1  B
  99  * 8  1  B
 100  * 10 1 A
 101  *
 102  * where the first column is the time, the second column is the thread id,
 103  * and the third column is the method (actually just the class name).  The
 104  * number of spaces between the 2nd and 3rd columns is the indentation and
 105  * determines the call stack.  Each called method must be indented by one
 106  * more space.  In the example above, A is called at time 4, A calls B at
 107  * time 6, B returns at time 8, and A returns at time 10.  Thread 1 is the
 108  * only thread that is running.
 109  *
 110  * An alternative file format leaves out the first two columns:
 111  * A
 112  *  B
 113  *  B
 114  * A
 115  *
 116  * In this file format, the thread id is always 1, and the time starts at
 117  * 2 and increments by 2 for each line.
 118  */
 119 void parseInputFile(const char *inputFileName)
 120 {
 121     unsigned int time = 0, threadId;
 122     int len;
 123     int linenum = 0;
 124     int nextRecord = 0;
 125     int indentLevel = 0;
 126     stack *callStack;
 127
 128     FILE *inputFp = fopen(inputFileName, "r");
 129     if (inputFp == NULL) {
 130         perror(inputFileName);
 131         exit(1);
 132     }
 133
 134     /* Count the number of lines in the buffer */
 135     int numRecords = 0;
 136     int maxThreadId = 1;
 137     int maxFrames = 0;
 138     char *indentEnd;
 139     while (fgets(buf, BUF_SIZE, inputFp)) {
 140         char *cp = buf;
 141         if (*cp == '#')
 142             continue;
 143         numRecords += 1;
 144         if (isdigit(*cp)) {
 145             int time = strtoul(cp, &cp, 0);
 146             while (isspace(*cp))
 147                 cp += 1;
 148             int threadId = strtoul(cp, &cp, 0);
 149             if (maxThreadId < threadId)
 150                 maxThreadId = threadId;
 151         }
 152         indentEnd = cp;
 153         while (isspace(*indentEnd))
 154             indentEnd += 1;
 155         if (indentEnd - cp + 1 > maxFrames)
 156             maxFrames = indentEnd - cp + 1;
 157     }
 158     int numThreads = maxThreadId + 1;
 159
 160     /* Add space for a sentinel record at the end */
 161     numRecords += 1;
 162     records = (dataRecord *) malloc(sizeof(dataRecord) * numRecords);
 163     callStack = (stack *) malloc(sizeof(stack) * numThreads);
 164     int ii;
 165     for (ii = 0; ii < numThreads; ++ii) {
 166         callStack[ii].frames = NULL;
 167         callStack[ii].indentLevel = 0;
 168     }
 169
 170     rewind(inputFp);
 171     while (fgets(buf, BUF_SIZE, inputFp)) {
 172         int indent;
 173         int action;
 174         char *save_cp;
 175
 176         linenum += 1;
 177         char *cp = buf;
 178
 179         /* Skip lines that start with '#' */
 180         if (*cp == '#')
 181             continue;
 182
 183         /* Get time and thread id */
 184         if (!isdigit(*cp)) {
 185             /* If the line does not begin with a digit, then fill in
 186              * default values for the time and threadId.
 187              */
 188             time += 2;
 189             threadId = 1;
 190         } else {
 191             time = strtoul(cp, &cp, 0);
 192             while (isspace(*cp))
 193                 cp += 1;
 194             threadId = strtoul(cp, &cp, 0);
 195             cp += 1;
 196         }
 197
 198         // Allocate space for the thread stack, if necessary
 199         if (callStack[threadId].frames == NULL) {
 200             dataRecord **stk;
 201             stk = (dataRecord **) malloc(sizeof(dataRecord *) * maxFrames);
 202             callStack[threadId].frames = stk;
 203         }
 204         indentLevel = callStack[threadId].indentLevel;
 205
 206         save_cp = cp;
 207         while (isspace(*cp)) {
 208             cp += 1;
 209         }
 210         indent = cp - save_cp + 1;
 211         records[nextRecord].time = time;
 212         records[nextRecord].threadId = threadId;
 213
 214         save_cp = cp;
 215         while (*cp != '\n')
 216             cp += 1;
 217
 218         /* Remove trailing spaces */
 219         cp -= 1;
 220         while (isspace(*cp))
 221             cp -= 1;
 222         cp += 1;
 223         len = cp - save_cp;
 224         records[nextRecord].fullName = strndup(save_cp, len);
 225
 226         /* Parse the name to support "class.method signature" */
 227         records[nextRecord].className = NULL;
 228         records[nextRecord].methodName = NULL;
 229         records[nextRecord].signature = NULL;
 230         cp = strchr(save_cp, '.');
 231         if (cp) {
 232             len = cp - save_cp;
 233             if (len > 0)
 234                 records[nextRecord].className = strndup(save_cp, len);
 235             save_cp = cp + 1;
 236             cp = strchr(save_cp, ' ');
 237             if (cp == NULL)
 238                 cp = strchr(save_cp, '\n');
 239             if (cp && cp > save_cp) {
 240                 len = cp - save_cp;
 241                 records[nextRecord].methodName = strndup(save_cp, len);
 242                 save_cp = cp + 1;
 243                 cp = strchr(save_cp, ' ');
 244                 if (cp == NULL)
 245                     cp = strchr(save_cp, '\n');
 246                 if (cp && cp > save_cp) {
 247                     len = cp - save_cp;
 248                     records[nextRecord].signature = strndup(save_cp, len);
 249                 }
 250             }
 251         }
 252
 253         if (verbose) {
 254             printf("Indent: %d; IndentLevel: %d; Line: %s", indent, indentLevel, buf);
 255         }
 256
 257         action = 0;
 258         if (indent == indentLevel + 1) { // Entering a method
 259             if (verbose)
 260                 printf("  Entering %s\n", records[nextRecord].fullName);
 261             callStack[threadId].frames[indentLevel] = &records[nextRecord];
 262         } else if (indent == indentLevel) { // Exiting a method
 263             // Exiting method must be currently on top of stack (unless stack is empty)
 264             if (callStack[threadId].frames[indentLevel - 1] == NULL) {
 265                 if (verbose)
 266                     printf("  Exiting %s (past bottom of stack)\n", records[nextRecord].fullName);
 267                 callStack[threadId].frames[indentLevel - 1] = &records[nextRecord];
 268                 action = 1;
 269             } else {
 270                 if (indentLevel < 1) {
 271                     fprintf(stderr, "Error: line %d: %s", linenum, buf);
 272                     fprintf(stderr, "  expected positive (>0) indentation, found %d\n",
 273                             indent);
 274                     exit(1);
 275                 }
 276                 char *name = callStack[threadId].frames[indentLevel - 1]->fullName;
 277                 if (strcmp(name, records[nextRecord].fullName) == 0) {
 278                     if (verbose)
 279                         printf("  Exiting %s\n", name);
 280                     action = 1;
 281                 } else { // exiting method doesn't match stack's top method
 282                     fprintf(stderr, "Error: line %d: %s", linenum, buf);
 283                     fprintf(stderr, "  expected exit from %s\n",
 284                             callStack[threadId].frames[indentLevel - 1]->fullName);
 285                     exit(1);
 286                 }
 287             }
 288         } else {
 289             if (nextRecord != 0) {
 290                 fprintf(stderr, "Error: line %d: %s", linenum, buf);
 291                 fprintf(stderr, "  expected indentation %d [+1], found %d\n",
 292                         indentLevel, indent);
 293                 exit(1);
 294             }
 295
 296             if (verbose) {
 297                 printf("  Nonzero indent at first record\n");
 298                 printf("  Entering %s\n", records[nextRecord].fullName);
 299             }
 300
 301             // This is the first line of data, so we allow a larger
 302             // initial indent.  This allows us to test popping off more
 303             // frames than we entered.
 304             indentLevel = indent - 1;
 305             callStack[threadId].frames[indentLevel] = &records[nextRecord];
 306         }
 307
 308         if (action == 0)
 309             indentLevel += 1;
 310         else
 311             indentLevel -= 1;
 312         records[nextRecord].action = action;
 313         callStack[threadId].indentLevel = indentLevel;
 314
 315         nextRecord += 1;
 316     }
 317
 318     /* Mark the last record with a sentinel */
 319     memset(&records[nextRecord], 0, sizeof(dataRecord));
 320 }
 321
 322
 323 /*
 324  * Write values to the binary data file.
 325  */
 326 void write2LE(FILE* fp, unsigned short val)
 327 {
 328     putc(val & 0xff, fp);
 329     putc(val >> 8, fp);
 330 }
 331
 332 void write4LE(FILE* fp, unsigned int val)
 333 {
 334     putc(val & 0xff, fp);
 335     putc((val >> 8) & 0xff, fp);
 336     putc((val >> 16) & 0xff, fp);
 337     putc((val >> 24) & 0xff, fp);
 338 }
 339
 340 void write8LE(FILE* fp, unsigned long long val)
 341 {
 342     putc(val & 0xff, fp);
 343     putc((val >> 8) & 0xff, fp);
 344     putc((val >> 16) & 0xff, fp);
 345     putc((val >> 24) & 0xff, fp);
 346     putc((val >> 32) & 0xff, fp);
 347     putc((val >> 40) & 0xff, fp);
 348     putc((val >> 48) & 0xff, fp);
 349     putc((val >> 56) & 0xff, fp);
 350 }
 351
 352 void writeDataRecord(FILE *dataFp, int threadId, unsigned int methodVal,
 353                    unsigned int elapsedTime)
 354 {
 355     if (versionNumber == 1)
 356         putc(threadId, dataFp);
 357     else
 358         write2LE(dataFp, threadId);
 359     write4LE(dataFp, methodVal);
 360     write4LE(dataFp, elapsedTime);
 361 }
 362
 363 void writeDataHeader(FILE *dataFp)
 364 {
 365     struct timeval tv;
 366     struct timezone tz;
 367
 368     gettimeofday(&tv, &tz);
 369     unsigned long long startTime = tv.tv_sec;
 370     startTime = (startTime << 32) | tv.tv_usec;
 371     header.version = versionNumber;
 372     write4LE(dataFp, header.magic);
 373     write2LE(dataFp, header.version);
 374     write2LE(dataFp, header.offsetToData);
 375     write8LE(dataFp, startTime);
 376 }
 377
 378 void writeKeyMethods(FILE *keyFp)
 379 {
 380     dataRecord *pRecord, *pNext;
 381     char *methodStr = "*methods\n";
 382     fwrite(methodStr, strlen(methodStr), 1, keyFp);
 383
 384     /* Assign method ids in multiples of 4 */
 385     unsigned int methodId = 0;
 386     for (pRecord = records; pRecord->fullName; ++pRecord) {
 387         if (pRecord->methodId)
 388             continue;
 389         unsigned int id = ++methodId << 2;
 390         pRecord->methodId = id;
 391
 392         /* Assign this id to all the other records that have the
 393          * same name.
 394          */
 395         for (pNext = pRecord + 1; pNext->fullName; ++pNext) {
 396             if (pNext->methodId)
 397                 continue;
 398             if (strcmp(pRecord->fullName, pNext->fullName) == 0)
 399                 pNext->methodId = id;
 400         }
 401         if (pRecord->className == NULL || pRecord->methodName == NULL) {
 402             fprintf(keyFp, "0x%x        %s      m       ()\n",
 403                     pRecord->methodId, pRecord->fullName);
 404         } else if (pRecord->signature == NULL) {
 405             fprintf(keyFp, "0x%x        %s      %s      ()\n",
 406                     pRecord->methodId, pRecord->className,
 407                     pRecord->methodName);
 408         } else {
 409             fprintf(keyFp, "0x%x        %s      %s      %s\n",
 410                     pRecord->methodId, pRecord->className,
 411                     pRecord->methodName, pRecord->signature);
 412         }
 413     }
 414 }
 415
 416 void writeKeys(FILE *keyFp)
 417 {
 418     fprintf(keyFp, "%s%d\n%s", versionHeader, versionNumber, clockDef);
 419     fwrite(keyThreads, strlen(keyThreads), 1, keyFp);
 420     writeKeyMethods(keyFp);
 421     fwrite(keyEnd, strlen(keyEnd), 1, keyFp);
 422 }
 423
 424 void writeDataRecords(FILE *dataFp)
 425 {
 426     dataRecord *pRecord;
 427
 428     for (pRecord = records; pRecord->fullName; ++pRecord) {
 429         unsigned int val = METHOD_COMBINE(pRecord->methodId, pRecord->action);
 430         writeDataRecord(dataFp, pRecord->threadId, val, pRecord->time);
 431     }
 432 }
 433
 434 void writeTrace(const char* traceFileName)
 435 {
 436     FILE *fp = fopen(traceFileName, "w");
 437     if (fp == NULL) {
 438         perror(traceFileName);
 439         exit(1);
 440     }
 441     writeKeys(fp);
 442     writeDataHeader(fp);
 443     writeDataRecords(fp);
 444     fclose(fp);
 445 }
 446
 447 int parseOptions(int argc, char **argv)
 448 {
 449     int err = 0;
 450     while (1) {
 451         int opt = getopt(argc, argv, "v:d");
 452         if (opt == -1)
 453             break;
 454         switch (opt) {
 455             case 'v':
 456                 versionNumber = strtoul(optarg, NULL, 0);
 457                 if (versionNumber != 1 && versionNumber != 2) {
 458                     fprintf(stderr, "Error: version number (%d) must be 1 or 2\n",
 459                             versionNumber);
 460                     err = 1;
 461                 }
 462                 break;
 463             case 'd':
 464                 verbose = 1;
 465                 break;
 466             default:
 467                 err = 1;
 468                 break;
 469         }
 470     }
 471     return err;
 472 }
 473
 474 int main(int argc, char** argv)
 475 {
 476     char *inputFile;
 477     char *traceFileName = NULL;
 478     int len;
 479
 480     if (parseOptions(argc, argv) || argc - optind != 2) {
 481         fprintf(stderr, "Usage: %s [-v version] [-d] input_file trace_prefix\n",
 482                 argv[0]);
 483         exit(1);
 484     }
 485
 486     inputFile = argv[optind++];
 487     parseInputFile(inputFile);
 488     traceFileName = argv[optind++];
 489
 490     writeTrace(traceFileName);
 491
 492     return 0;
 493 }