tools/dmtracedump/createtesttrace.cc - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright 2015, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /*
  * Create a test file in the format required by dmtrace.
  */
 #include "profile.h"  // from VM header

 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <memory>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>

 /*
  * Values from the header of the data file.
  */
 typedef struct DataHeader {
   uint32_t magic;
   int16_t version;
   int16_t offsetToData;
   int64_t startWhen;
 } DataHeader;

 #define VERSION 2
 int32_t versionNumber = VERSION;
 int32_t verbose = 0;

 DataHeader header = {0x574f4c53, VERSION, sizeof(DataHeader), 0LL};

 const char* versionHeader = "*version\n";
 const char* clockDef = "clock=thread-cpu\n";

 const char* keyThreads =
     "*threads\n"
     "1      main\n"
     "2      foo\n"
     "3      bar\n"
     "4      blah\n";

 const char* keyEnd = "*end\n";

 typedef struct dataRecord {
   uint32_t time;
   int32_t threadId;
   uint32_t action; /* 0=entry, 1=exit, 2=exception exit */
   char* fullName;
   char* className;
   char* methodName;
   char* signature;
   uint32_t methodId;
 } dataRecord;

 dataRecord* records;

 #define BUF_SIZE 1024
 char buf[BUF_SIZE];

 typedef struct stack {
   dataRecord** frames;
   int32_t indentLevel;
 } stack;

 /* Mac OS doesn't have strndup(), so implement it here.
  */
 char* strndup(const char* src, size_t len) {
   char* dest = new char[len + 1];
   strncpy(dest, src, len);
   dest[len] = 0;
   return dest;
 }

 /*
  * Parse the input file.  It looks something like this:
  * # This is a comment line
  * 4  1 A
  * 6  1  B
  * 8  1  B
  * 10 1 A
  *
  * where the first column is the time, the second column is the thread id,
  * and the third column is the method (actually just the class name).  The
  * number of spaces between the 2nd and 3rd columns is the indentation and
  * determines the call stack.  Each called method must be indented by one
  * more space.  In the example above, A is called at time 4, A calls B at
  * time 6, B returns at time 8, and A returns at time 10.  Thread 1 is the
  * only thread that is running.
  *
  * An alternative file format leaves out the first two columns:
  * A
  *  B
  *  B
  * A
  *
  * In this file format, the thread id is always 1, and the time starts at
  * 2 and increments by 2 for each line.
  */
 void parseInputFile(const char* inputFileName) {
   FILE* inputFp = fopen(inputFileName, "re");
   if (inputFp == nullptr) {
     perror(inputFileName);
     exit(1);
   }

   /* Count the number of lines in the buffer */
   int32_t numRecords = 0;
   int32_t maxThreadId = 1;
   int32_t maxFrames = 0;
   char* indentEnd;
   while (fgets(buf, BUF_SIZE, inputFp)) {
     char* cp = buf;
     if (*cp == '#') continue;
     numRecords += 1;
     if (isdigit(*cp)) {
       while (isspace(*cp)) cp += 1;
       int32_t threadId = strtoul(cp, &cp, 0);
       if (maxThreadId < threadId) maxThreadId = threadId;
     }
     indentEnd = cp;
     while (isspace(*indentEnd)) indentEnd += 1;
     if (indentEnd - cp + 1 > maxFrames) maxFrames = indentEnd - cp + 1;
   }
   int32_t numThreads = maxThreadId + 1;

   /* Add space for a sentinel record at the end */
   numRecords += 1;
   records = new dataRecord[numRecords];
   std::unique_ptr<stack[]> callStack(new stack[numThreads]);
   for (int32_t ii = 0; ii < numThreads; ++ii) {
     callStack[ii].frames = nullptr;
     callStack[ii].indentLevel = 0;
   }

   rewind(inputFp);

   uint32_t time = 0;
   int32_t linenum = 0;
   int32_t nextRecord = 0;
   int32_t indentLevel = 0;
   while (fgets(buf, BUF_SIZE, inputFp)) {
     uint32_t threadId;
     int32_t len;
     int32_t indent;
     int32_t action;
     char* save_cp;

     linenum += 1;
     char* cp = buf;

     /* Skip lines that start with '#' */
     if (*cp == '#') continue;

     /* Get time and thread id */
     if (!isdigit(*cp)) {
       /* If the line does not begin with a digit, then fill in
        * default values for the time and threadId.
        */
       time += 2;
       threadId = 1;
     } else {
       time = strtoul(cp, &cp, 0);
       while (isspace(*cp)) cp += 1;
       threadId = strtoul(cp, &cp, 0);
       cp += 1;
     }

     // Allocate space for the thread stack, if necessary
     if (callStack[threadId].frames == nullptr) {
       dataRecord** stk = new dataRecord*[maxFrames];
       callStack[threadId].frames = stk;
     }
     indentLevel = callStack[threadId].indentLevel;

     save_cp = cp;
     while (isspace(*cp)) {
       cp += 1;
     }
     indent = cp - save_cp + 1;
     records[nextRecord].time = time;
     records[nextRecord].threadId = threadId;

     save_cp = cp;
     while (*cp != '\n') cp += 1;

     /* Remove trailing spaces */
     cp -= 1;
     while (isspace(*cp)) cp -= 1;
     cp += 1;
     len = cp - save_cp;
     records[nextRecord].fullName = strndup(save_cp, len);

     /* Parse the name to support "class.method signature" */
     records[nextRecord].className = nullptr;
     records[nextRecord].methodName = nullptr;
     records[nextRecord].signature = nullptr;
     cp = strchr(save_cp, '.');
     if (cp) {
       len = cp - save_cp;
       if (len > 0) records[nextRecord].className = strndup(save_cp, len);
       save_cp = cp + 1;
       cp = strchr(save_cp, ' ');
       if (cp == nullptr) cp = strchr(save_cp, '\n');
       if (cp && cp > save_cp) {
         len = cp - save_cp;
         records[nextRecord].methodName = strndup(save_cp, len);
         save_cp = cp + 1;
         cp = strchr(save_cp, ' ');
         if (cp == nullptr) cp = strchr(save_cp, '\n');
         if (cp && cp > save_cp) {
           len = cp - save_cp;
           records[nextRecord].signature = strndup(save_cp, len);
         }
       }
     }

     if (verbose) {
       printf("Indent: %d; IndentLevel: %d; Line: %s", indent, indentLevel, buf);
     }

     action = 0;
     if (indent == indentLevel + 1) {  // Entering a method
       if (verbose) printf("  Entering %s\n", records[nextRecord].fullName);
       callStack[threadId].frames[indentLevel] = &records[nextRecord];
     } else if (indent == indentLevel) {  // Exiting a method
       // Exiting method must be currently on top of stack (unless stack is
       // empty)
       if (callStack[threadId].frames[indentLevel - 1] == nullptr) {
         if (verbose)
           printf("  Exiting %s (past bottom of stack)\n",
                  records[nextRecord].fullName);
         callStack[threadId].frames[indentLevel - 1] = &records[nextRecord];
         action = 1;
       } else {
         if (indentLevel < 1) {
           fprintf(stderr, "Error: line %d: %s", linenum, buf);
           fprintf(stderr, "  expected positive (>0) indentation, found %d\n",
                   indent);
           exit(1);
         }
         char* name = callStack[threadId].frames[indentLevel - 1]->fullName;
         if (strcmp(name, records[nextRecord].fullName) == 0) {
           if (verbose) printf("  Exiting %s\n", name);
           action = 1;
         } else {  // exiting method doesn't match stack's top method
           fprintf(stderr, "Error: line %d: %s", linenum, buf);
           fprintf(stderr, "  expected exit from %s\n",
                   callStack[threadId].frames[indentLevel - 1]->fullName);
           exit(1);
         }
       }
     } else {
       if (nextRecord != 0) {
         fprintf(stderr, "Error: line %d: %s", linenum, buf);
         fprintf(stderr, "  expected indentation %d [+1], found %d\n",
                 indentLevel, indent);
         exit(1);
       }

       if (verbose) {
         printf("  Nonzero indent at first record\n");
         printf("  Entering %s\n", records[nextRecord].fullName);
       }

       // This is the first line of data, so we allow a larger
       // initial indent.  This allows us to test popping off more
       // frames than we entered.
       indentLevel = indent - 1;
       callStack[threadId].frames[indentLevel] = &records[nextRecord];
     }

     if (action == 0)
       indentLevel += 1;
     else
       indentLevel -= 1;
     records[nextRecord].action = action;
     callStack[threadId].indentLevel = indentLevel;

     nextRecord += 1;
   }

   /* Mark the last record with a sentinel */
   memset(&records[nextRecord], 0, sizeof(dataRecord));
 }

 /*
  * Write values to the binary data file.
  */
 void write2LE(FILE* fp, uint16_t val) {
   putc(val & 0xff, fp);
   putc(val >> 8, fp);
 }

 void write4LE(FILE* fp, uint32_t val) {
   putc(val & 0xff, fp);
   putc((val >> 8) & 0xff, fp);
   putc((val >> 16) & 0xff, fp);
   putc((val >> 24) & 0xff, fp);
 }

 void write8LE(FILE* fp, uint64_t val) {
   putc(val & 0xff, fp);
   putc((val >> 8) & 0xff, fp);
   putc((val >> 16) & 0xff, fp);
   putc((val >> 24) & 0xff, fp);
   putc((val >> 32) & 0xff, fp);
   putc((val >> 40) & 0xff, fp);
   putc((val >> 48) & 0xff, fp);
   putc((val >> 56) & 0xff, fp);
 }

 void writeDataRecord(FILE* dataFp, int32_t threadId, uint32_t methodVal, uint32_t elapsedTime) {
   if (versionNumber == 1)
     putc(threadId, dataFp);
   else
     write2LE(dataFp, threadId);
   write4LE(dataFp, methodVal);
   write4LE(dataFp, elapsedTime);
 }

 void writeDataHeader(FILE* dataFp) {
   struct timeval tv;
   struct timezone tz;

   gettimeofday(&tv, &tz);
   uint64_t startTime = tv.tv_sec;
   startTime = (startTime << 32) | tv.tv_usec;
   header.version = versionNumber;
   write4LE(dataFp, header.magic);
   write2LE(dataFp, header.version);
   write2LE(dataFp, header.offsetToData);
   write8LE(dataFp, startTime);
 }

 void writeKeyMethods(FILE* keyFp) {
   const char* methodStr = "*methods\n";
   fwrite(methodStr, strlen(methodStr), 1, keyFp);

   /* Assign method ids in multiples of 4 */
   uint32_t methodId = 0;
   for (dataRecord* pRecord = records; pRecord->fullName; ++pRecord) {
     if (pRecord->methodId) continue;
     uint32_t id = ++methodId << 2;
     pRecord->methodId = id;

     /* Assign this id to all the other records that have the
      * same name.
      */
     for (dataRecord* pNext = pRecord + 1; pNext->fullName; ++pNext) {
       if (pNext->methodId) continue;
       if (strcmp(pRecord->fullName, pNext->fullName) == 0) pNext->methodId = id;
     }
     if (pRecord->className == nullptr || pRecord->methodName == nullptr) {
       fprintf(keyFp, "%#x        %s      m       ()\n", pRecord->methodId,
               pRecord->fullName);
     } else if (pRecord->signature == nullptr) {
       fprintf(keyFp, "%#x        %s      %s      ()\n", pRecord->methodId,
               pRecord->className, pRecord->methodName);
     } else {
       fprintf(keyFp, "%#x        %s      %s      %s\n", pRecord->methodId,
               pRecord->className, pRecord->methodName, pRecord->signature);
     }
   }
 }

 void writeKeys(FILE* keyFp) {
   fprintf(keyFp, "%s%d\n%s", versionHeader, versionNumber, clockDef);
   fwrite(keyThreads, strlen(keyThreads), 1, keyFp);
   writeKeyMethods(keyFp);
   fwrite(keyEnd, strlen(keyEnd), 1, keyFp);
 }

 void writeDataRecords(FILE* dataFp) {
   for (dataRecord* pRecord = records; pRecord->fullName; ++pRecord) {
     uint32_t val = METHOD_COMBINE(pRecord->methodId, pRecord->action);
     writeDataRecord(dataFp, pRecord->threadId, val, pRecord->time);
   }
 }

 void writeTrace(const char* traceFileName) {
   FILE* fp = fopen(traceFileName, "we");
   if (fp == nullptr) {
     perror(traceFileName);
     exit(1);
   }
   writeKeys(fp);
   writeDataHeader(fp);
   writeDataRecords(fp);
   fclose(fp);
 }

 int32_t parseOptions(int32_t argc, char** argv) {
   int32_t err = 0;
   while (1) {
     int32_t opt = getopt(argc, argv, "v:d");
     if (opt == -1) break;
     switch (opt) {
       case 'v':
         versionNumber = strtoul(optarg, nullptr, 0);
         if (versionNumber != 1 && versionNumber != 2) {
           fprintf(stderr, "Error: version number (%d) must be 1 or 2\n", versionNumber);
           err = 1;
         }
         break;
       case 'd':
         verbose = 1;
         break;
       default:
         err = 1;
         break;
     }
   }
   return err;
 }

 int32_t main(int32_t argc, char** argv) {
   char* inputFile;
   char* traceFileName = nullptr;

   if (parseOptions(argc, argv) || argc - optind != 2) {
     fprintf(stderr, "Usage: %s [-v version] [-d] input_file trace_prefix\n", argv[0]);
     exit(1);
   }

   inputFile = argv[optind++];
   parseInputFile(inputFile);
   traceFileName = argv[optind++];

   writeTrace(traceFileName);

   return 0;
 }
	/*
	* Copyright 2015, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/*
	* Create a test file in the format required by dmtrace.
	*/
	#include "profile.h" // from VM header

	#include <assert.h>
	#include <ctype.h>
	#include <errno.h>
	#include <memory>
	#include <stdint.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/time.h>
	#include <time.h>
	#include <unistd.h>

	/*
	* Values from the header of the data file.
	*/
	typedef struct DataHeader {
	uint32_t magic;
	int16_t version;
	int16_t offsetToData;
	int64_t startWhen;
	} DataHeader;

	#define VERSION 2
	int32_t versionNumber = VERSION;
	int32_t verbose = 0;

	DataHeader header = {0x574f4c53, VERSION, sizeof(DataHeader), 0LL};

	const char* versionHeader = "*version\n";
	const char* clockDef = "clock=thread-cpu\n";

	const char* keyThreads =
	"*threads\n"
	"1 main\n"
	"2 foo\n"
	"3 bar\n"
	"4 blah\n";

	const char* keyEnd = "*end\n";

	typedef struct dataRecord {
	uint32_t time;
	int32_t threadId;
	uint32_t action; /* 0=entry, 1=exit, 2=exception exit */
	char* fullName;
	char* className;
	char* methodName;
	char* signature;
	uint32_t methodId;
	} dataRecord;

	dataRecord* records;

	#define BUF_SIZE 1024
	char buf[BUF_SIZE];

	typedef struct stack {
	dataRecord** frames;
	int32_t indentLevel;
	} stack;

	/* Mac OS doesn't have strndup(), so implement it here.
	*/
	char* strndup(const char* src, size_t len) {
	char* dest = new char[len + 1];
	strncpy(dest, src, len);
	dest[len] = 0;
	return dest;
	}

	/*
	* Parse the input file. It looks something like this:
	* # This is a comment line
	* 4 1 A
	* 6 1 B
	* 8 1 B
	* 10 1 A
	*
	* where the first column is the time, the second column is the thread id,
	* and the third column is the method (actually just the class name). The
	* number of spaces between the 2nd and 3rd columns is the indentation and
	* determines the call stack. Each called method must be indented by one
	* more space. In the example above, A is called at time 4, A calls B at
	* time 6, B returns at time 8, and A returns at time 10. Thread 1 is the
	* only thread that is running.
	*
	* An alternative file format leaves out the first two columns:
	* A
	* B
	* B
	* A
	*
	* In this file format, the thread id is always 1, and the time starts at
	* 2 and increments by 2 for each line.
	*/
	void parseInputFile(const char* inputFileName) {
	FILE* inputFp = fopen(inputFileName, "re");
	if (inputFp == nullptr) {
	perror(inputFileName);
	exit(1);
	}

	/* Count the number of lines in the buffer */
	int32_t numRecords = 0;
	int32_t maxThreadId = 1;
	int32_t maxFrames = 0;
	char* indentEnd;
	while (fgets(buf, BUF_SIZE, inputFp)) {
	char* cp = buf;
	if (*cp == '#') continue;
	numRecords += 1;
	if (isdigit(*cp)) {
	while (isspace(*cp)) cp += 1;
	int32_t threadId = strtoul(cp, &cp, 0);
	if (maxThreadId < threadId) maxThreadId = threadId;
	}
	indentEnd = cp;
	while (isspace(*indentEnd)) indentEnd += 1;
	if (indentEnd - cp + 1 > maxFrames) maxFrames = indentEnd - cp + 1;
	}
	int32_t numThreads = maxThreadId + 1;

	/* Add space for a sentinel record at the end */
	numRecords += 1;
	records = new dataRecord[numRecords];
	std::unique_ptr<stack[]> callStack(new stack[numThreads]);
	for (int32_t ii = 0; ii < numThreads; ++ii) {
	callStack[ii].frames = nullptr;
	callStack[ii].indentLevel = 0;
	}

	rewind(inputFp);

	uint32_t time = 0;
	int32_t linenum = 0;
	int32_t nextRecord = 0;
	int32_t indentLevel = 0;
	while (fgets(buf, BUF_SIZE, inputFp)) {
	uint32_t threadId;
	int32_t len;
	int32_t indent;
	int32_t action;
	char* save_cp;

	linenum += 1;
	char* cp = buf;

	/* Skip lines that start with '#' */
	if (*cp == '#') continue;

	/* Get time and thread id */
	if (!isdigit(*cp)) {
	/* If the line does not begin with a digit, then fill in
	* default values for the time and threadId.
	*/
	time += 2;
	threadId = 1;
	} else {
	time = strtoul(cp, &cp, 0);
	while (isspace(*cp)) cp += 1;
	threadId = strtoul(cp, &cp, 0);
	cp += 1;
	}

	// Allocate space for the thread stack, if necessary
	if (callStack[threadId].frames == nullptr) {
	dataRecord** stk = new dataRecord*[maxFrames];
	callStack[threadId].frames = stk;
	}
	indentLevel = callStack[threadId].indentLevel;

	save_cp = cp;
	while (isspace(*cp)) {
	cp += 1;
	}
	indent = cp - save_cp + 1;
	records[nextRecord].time = time;
	records[nextRecord].threadId = threadId;

	save_cp = cp;
	while (*cp != '\n') cp += 1;

	/* Remove trailing spaces */
	cp -= 1;
	while (isspace(*cp)) cp -= 1;
	cp += 1;
	len = cp - save_cp;
	records[nextRecord].fullName = strndup(save_cp, len);

	/* Parse the name to support "class.method signature" */
	records[nextRecord].className = nullptr;
	records[nextRecord].methodName = nullptr;
	records[nextRecord].signature = nullptr;
	cp = strchr(save_cp, '.');
	if (cp) {
	len = cp - save_cp;
	if (len > 0) records[nextRecord].className = strndup(save_cp, len);
	save_cp = cp + 1;
	cp = strchr(save_cp, ' ');
	if (cp == nullptr) cp = strchr(save_cp, '\n');
	if (cp && cp > save_cp) {
	len = cp - save_cp;
	records[nextRecord].methodName = strndup(save_cp, len);
	save_cp = cp + 1;
	cp = strchr(save_cp, ' ');
	if (cp == nullptr) cp = strchr(save_cp, '\n');
	if (cp && cp > save_cp) {
	len = cp - save_cp;
	records[nextRecord].signature = strndup(save_cp, len);
	}
	}
	}

	if (verbose) {
	printf("Indent: %d; IndentLevel: %d; Line: %s", indent, indentLevel, buf);
	}

	action = 0;
	if (indent == indentLevel + 1) { // Entering a method
	if (verbose) printf(" Entering %s\n", records[nextRecord].fullName);
	callStack[threadId].frames[indentLevel] = &records[nextRecord];
	} else if (indent == indentLevel) { // Exiting a method
	// Exiting method must be currently on top of stack (unless stack is
	// empty)
	if (callStack[threadId].frames[indentLevel - 1] == nullptr) {
	if (verbose)
	printf(" Exiting %s (past bottom of stack)\n",
	records[nextRecord].fullName);
	callStack[threadId].frames[indentLevel - 1] = &records[nextRecord];
	action = 1;
	} else {
	if (indentLevel < 1) {
	fprintf(stderr, "Error: line %d: %s", linenum, buf);
	fprintf(stderr, " expected positive (>0) indentation, found %d\n",
	indent);
	exit(1);
	}
	char* name = callStack[threadId].frames[indentLevel - 1]->fullName;
	if (strcmp(name, records[nextRecord].fullName) == 0) {
	if (verbose) printf(" Exiting %s\n", name);
	action = 1;
	} else { // exiting method doesn't match stack's top method
	fprintf(stderr, "Error: line %d: %s", linenum, buf);
	fprintf(stderr, " expected exit from %s\n",
	callStack[threadId].frames[indentLevel - 1]->fullName);
	exit(1);
	}
	}
	} else {
	if (nextRecord != 0) {
	fprintf(stderr, "Error: line %d: %s", linenum, buf);
	fprintf(stderr, " expected indentation %d [+1], found %d\n",
	indentLevel, indent);
	exit(1);
	}

	if (verbose) {
	printf(" Nonzero indent at first record\n");
	printf(" Entering %s\n", records[nextRecord].fullName);
	}

	// This is the first line of data, so we allow a larger
	// initial indent. This allows us to test popping off more
	// frames than we entered.
	indentLevel = indent - 1;
	callStack[threadId].frames[indentLevel] = &records[nextRecord];
	}

	if (action == 0)
	indentLevel += 1;
	else
	indentLevel -= 1;
	records[nextRecord].action = action;
	callStack[threadId].indentLevel = indentLevel;

	nextRecord += 1;
	}

	/* Mark the last record with a sentinel */
	memset(&records[nextRecord], 0, sizeof(dataRecord));
	}

	/*
	* Write values to the binary data file.
	*/
	void write2LE(FILE* fp, uint16_t val) {
	putc(val & 0xff, fp);
	putc(val >> 8, fp);
	}

	void write4LE(FILE* fp, uint32_t val) {
	putc(val & 0xff, fp);
	putc((val >> 8) & 0xff, fp);
	putc((val >> 16) & 0xff, fp);
	putc((val >> 24) & 0xff, fp);
	}

	void write8LE(FILE* fp, uint64_t val) {
	putc(val & 0xff, fp);
	putc((val >> 8) & 0xff, fp);
	putc((val >> 16) & 0xff, fp);
	putc((val >> 24) & 0xff, fp);
	putc((val >> 32) & 0xff, fp);
	putc((val >> 40) & 0xff, fp);
	putc((val >> 48) & 0xff, fp);
	putc((val >> 56) & 0xff, fp);
	}

	void writeDataRecord(FILE* dataFp, int32_t threadId, uint32_t methodVal, uint32_t elapsedTime) {
	if (versionNumber == 1)
	putc(threadId, dataFp);
	else
	write2LE(dataFp, threadId);
	write4LE(dataFp, methodVal);
	write4LE(dataFp, elapsedTime);
	}

	void writeDataHeader(FILE* dataFp) {
	struct timeval tv;
	struct timezone tz;

	gettimeofday(&tv, &tz);
	uint64_t startTime = tv.tv_sec;
	startTime = (startTime << 32) \| tv.tv_usec;
	header.version = versionNumber;
	write4LE(dataFp, header.magic);
	write2LE(dataFp, header.version);
	write2LE(dataFp, header.offsetToData);
	write8LE(dataFp, startTime);
	}

	void writeKeyMethods(FILE* keyFp) {
	const char* methodStr = "*methods\n";
	fwrite(methodStr, strlen(methodStr), 1, keyFp);

	/* Assign method ids in multiples of 4 */
	uint32_t methodId = 0;
	for (dataRecord* pRecord = records; pRecord->fullName; ++pRecord) {
	if (pRecord->methodId) continue;
	uint32_t id = ++methodId << 2;
	pRecord->methodId = id;

	/* Assign this id to all the other records that have the
	* same name.
	*/
	for (dataRecord* pNext = pRecord + 1; pNext->fullName; ++pNext) {
	if (pNext->methodId) continue;
	if (strcmp(pRecord->fullName, pNext->fullName) == 0) pNext->methodId = id;
	}
	if (pRecord->className == nullptr \|\| pRecord->methodName == nullptr) {
	fprintf(keyFp, "%#x %s m ()\n", pRecord->methodId,
	pRecord->fullName);
	} else if (pRecord->signature == nullptr) {
	fprintf(keyFp, "%#x %s %s ()\n", pRecord->methodId,
	pRecord->className, pRecord->methodName);
	} else {
	fprintf(keyFp, "%#x %s %s %s\n", pRecord->methodId,
	pRecord->className, pRecord->methodName, pRecord->signature);
	}
	}
	}

	void writeKeys(FILE* keyFp) {
	fprintf(keyFp, "%s%d\n%s", versionHeader, versionNumber, clockDef);
	fwrite(keyThreads, strlen(keyThreads), 1, keyFp);
	writeKeyMethods(keyFp);
	fwrite(keyEnd, strlen(keyEnd), 1, keyFp);
	}

	void writeDataRecords(FILE* dataFp) {
	for (dataRecord* pRecord = records; pRecord->fullName; ++pRecord) {
	uint32_t val = METHOD_COMBINE(pRecord->methodId, pRecord->action);
	writeDataRecord(dataFp, pRecord->threadId, val, pRecord->time);
	}
	}

	void writeTrace(const char* traceFileName) {
	FILE* fp = fopen(traceFileName, "we");
	if (fp == nullptr) {
	perror(traceFileName);
	exit(1);
	}
	writeKeys(fp);
	writeDataHeader(fp);
	writeDataRecords(fp);
	fclose(fp);
	}

	int32_t parseOptions(int32_t argc, char** argv) {
	int32_t err = 0;
	while (1) {
	int32_t opt = getopt(argc, argv, "v:d");
	if (opt == -1) break;
	switch (opt) {
	case 'v':
	versionNumber = strtoul(optarg, nullptr, 0);
	if (versionNumber != 1 && versionNumber != 2) {
	fprintf(stderr, "Error: version number (%d) must be 1 or 2\n", versionNumber);
	err = 1;
	}
	break;
	case 'd':
	verbose = 1;
	break;
	default:
	err = 1;
	break;
	}
	}
	return err;
	}

	int32_t main(int32_t argc, char** argv) {
	char* inputFile;
	char* traceFileName = nullptr;

	if (parseOptions(argc, argv) \|\| argc - optind != 2) {
	fprintf(stderr, "Usage: %s [-v version] [-d] input_file trace_prefix\n", argv[0]);
	exit(1);
	}

	inputFile = argv[optind++];
	parseInputFile(inputFile);
	traceFileName = argv[optind++];

	writeTrace(traceFileName);

	return 0;
	}