Home | History | Annotate | Download | only in qtools 
      1 #include <stdio.h>
      2 #include <stdlib.h>
      3 #include <string.h>
      4 #include <inttypes.h>
      5 #include "trace_reader.h"
      6 
      7 typedef struct MyStaticRec {
      8   StaticRec bb;
      9   uint32_t  *insns;
     10 } MyStaticRec;
     11 
     12 const int kNumPids = 32768;
     13 char usedPids[kNumPids];
     14 
     15 int main(int argc, char **argv) {
     16   uint32_t insns[kMaxInsnPerBB];
     17 
     18   if (argc != 2) {
     19     fprintf(stderr, "Usage: %s trace_file\n", argv[0]);
     20     exit(1);
     21   }
     22 
     23   char *trace_filename = argv[1];
     24   TraceReaderBase *trace = new TraceReaderBase;
     25   trace->SetPostProcessing(true);
     26   trace->Open(trace_filename);
     27 
     28   // Count the number of static basic blocks and instructions.
     29   uint64_t num_static_bb = 0;
     30   uint64_t num_static_insn = 0;
     31   while (1) {
     32     StaticRec static_rec;
     33 
     34     if (trace->ReadStatic(&static_rec))
     35       break;
     36     if (static_rec.bb_num != num_static_bb) {
     37       fprintf(stderr,
     38               "Error: basic block numbers out of order; expected %lld, got %lld\n",
     39               num_static_bb, static_rec.bb_num);
     40       exit(1);
     41     }
     42     num_static_bb += 1;
     43     num_static_insn += static_rec.num_insns;
     44     trace->ReadStaticInsns(static_rec.num_insns, insns);
     45   }
     46   trace->Close();
     47 
     48   // Allocate space for all of the static blocks
     49   MyStaticRec *blocks = new MyStaticRec[num_static_bb];
     50 
     51   // Read the static blocks again and save pointers to them
     52   trace->Open(trace_filename);
     53   for (uint32_t ii = 0; ii < num_static_bb; ++ii) {
     54     trace->ReadStatic(&blocks[ii].bb);
     55     uint32_t num_insns = blocks[ii].bb.num_insns;
     56     if (num_insns > 0) {
     57       blocks[ii].insns = new uint32_t[num_insns];
     58       trace->ReadStaticInsns(num_insns, blocks[ii].insns);
     59     }
     60   }
     61 
     62   // Check the last basic block.  If it contains a special undefined
     63   // instruction, then truncate the basic block at that point.
     64   uint32_t num_insns = blocks[num_static_bb - 1].bb.num_insns;
     65   uint32_t *insn_ptr = blocks[num_static_bb - 1].insns;
     66   for (uint32_t ii = 0; ii < num_insns; ++ii, ++insn_ptr) {
     67     if (*insn_ptr == 0xe6c00110) {
     68       uint32_t actual_num_insns = ii + 1;
     69       blocks[num_static_bb - 1].bb.num_insns = actual_num_insns;
     70       num_static_insn -= (num_insns - actual_num_insns);
     71 
     72       // Write the changes back to the trace file
     73       trace->TruncateLastBlock(actual_num_insns);
     74       break;
     75     }
     76   }
     77   TraceHeader *header = trace->GetHeader();
     78   strcpy(header->ident, TRACE_IDENT);
     79   header->num_static_bb = num_static_bb;
     80   header->num_dynamic_bb = 0;
     81   header->num_static_insn = num_static_insn;
     82   header->num_dynamic_insn = 0;
     83   trace->WriteHeader(header);
     84 
     85   // Reopen the trace file in order to force the trace manager to reread
     86   // the static blocks now that we have written that information to the
     87   // header.
     88   trace->Close();
     89   trace->Open(trace_filename);
     90 
     91   // Count the number of dynamic executions of basic blocks and instructions.
     92   // Also keep track of which process ids are used.
     93   uint64_t num_dynamic_bb = 0;
     94   uint64_t num_dynamic_insn = 0;
     95   while (1) {
     96     BBEvent event;
     97 
     98     if (trace->ReadBB(&event))
     99       break;
    100     if (event.bb_num >= num_static_bb) {
    101       fprintf(stderr,
    102               "Error: basic block number (%lld) too large (num blocks: %lld)\n",
    103               event.bb_num, num_static_bb);
    104       exit(1);
    105     }
    106     usedPids[event.pid] = 1;
    107     num_dynamic_bb += 1;
    108     num_dynamic_insn += event.num_insns;
    109   }
    110 
    111   // Count the number of process ids that are used and remember the first
    112   // unused pid.
    113   int numUsedPids = 0;
    114   int unusedPid = -1;
    115   for (int pid = 0; pid < kNumPids; pid++) {
    116       if (usedPids[pid] == 1) {
    117           numUsedPids += 1;
    118       } else if (unusedPid == -1) {
    119           unusedPid = pid;
    120       }
    121   }
    122 
    123   // Rewrite the header with the dynamic counts
    124   header->num_dynamic_bb = num_dynamic_bb;
    125   header->num_dynamic_insn = num_dynamic_insn;
    126   header->num_used_pids = numUsedPids;
    127   header->first_unused_pid = unusedPid;
    128   trace->WriteHeader(header);
    129   trace->Close();
    130 
    131   printf("Static basic blocks: %llu, Dynamic basic blocks: %llu\n",
    132          num_static_bb, num_dynamic_bb);
    133   printf("Static instructions: %llu, Dynamic instructions: %llu\n",
    134          num_static_insn, num_dynamic_insn);
    135 
    136   double elapsed_secs = header->elapsed_usecs / 1000000.0;
    137   double insn_per_sec = 0;
    138   if (elapsed_secs != 0)
    139     insn_per_sec = num_dynamic_insn / elapsed_secs;
    140   const char *suffix = "";
    141   if (insn_per_sec >= 1000000) {
    142     insn_per_sec /= 1000000.0;
    143     suffix = "M";
    144   } else if (insn_per_sec > 1000) {
    145     insn_per_sec /= 1000.0;
    146     suffix = "K";
    147   }
    148   printf("Elapsed seconds: %.2f, simulated instructions/sec: %.1f%s\n",
    149          elapsed_secs, insn_per_sec, suffix);
    150   return 0;
    151 }
    152