pd.if.org Git - nbds/blob - runtime/lwt.c

   1 /*
   2  * Written by Josh Dybnis and released to the public domain, as explained at
   3  * http://creativecommons.org/licenses/publicdomain
   4  *
   5  * lightweight tracing
   6  */
   7 #include <stdio.h>
   8 #include "common.h"
   9 #include "rlocal.h"
  10 #include "lwt.h"
  11 #include "mem.h"
  12
  13 #define LWT_BUFFER_SCALE 20
  14 #define LWT_BUFFER_SIZE (1ULL << LWT_BUFFER_SCALE)
  15 #define LWT_BUFFER_MASK (LWT_BUFFER_SIZE - 1)
  16
  17 volatile int halt_ = 0;
  18
  19 typedef struct lwt_record {
  20     uint64_t timestamp;
  21     uint64_t format;
  22     size_t value1;
  23     size_t value2;
  24 } lwt_record_t;
  25
  26 typedef struct lwt_buffer {
  27     uint32_t head;
  28     lwt_record_t x[0];
  29 } lwt_buffer_t;
  30
  31 lwt_buffer_t *TraceBuffer[MAX_NUM_THREADS] = {};
  32 char TraceLevel[256] = {};
  33 static const char *TraceSpec = "";
  34
  35 void lwt_thread_init (void) {
  36     int thread_index = GET_THREAD_INDEX();
  37
  38     if (TraceBuffer[thread_index] == NULL) {
  39         TraceBuffer[thread_index] =
  40             (lwt_buffer_t *)nbd_malloc(sizeof(lwt_buffer_t) + sizeof(lwt_record_t) * LWT_BUFFER_SIZE);
  41         memset(TraceBuffer[thread_index], 0, sizeof(lwt_buffer_t));
  42     }
  43 }
  44
  45 void lwt_set_trace_level (const char *flags) {
  46     assert(strlen(flags) % 2 == 0); // a well formed <flags> should be an even number of characters long
  47     TraceSpec = flags;
  48     memset(TraceLevel, 0, sizeof(TraceLevel));
  49     for (int i = 0; flags[i]; i+=2) {
  50         TraceLevel[(unsigned)flags[i]] = flags[i+1];
  51     }
  52 }
  53
  54 static void dump_record (FILE *file, int thread_id, lwt_record_t *r, uint64_t offset) {
  55     // print the record if its trace category is enabled at a high enough level
  56     int flag  =  r->format >> 56;
  57     int level = (r->format >> 48) & 0xFF;
  58     if (TraceLevel[(unsigned)flag] >= level) {
  59         char s[3] = {flag, level, '\0'};
  60         fprintf(file, "%09llu %d %s ", ((uint64_t)r->timestamp - offset) >> 5, thread_id, s);
  61         const char *format = (const char *)(size_t)(r->format & MASK(48)); // strip out the embedded flags
  62         fprintf(file, format, r->value1, r->value2);
  63         fprintf(file, "\n");
  64     }
  65 }
  66
  67 static void dump_buffer (FILE *file, int thread_index, uint64_t offset) {
  68     lwt_buffer_t *tb = TraceBuffer[thread_index];
  69     assert(tb);
  70     if (tb->head > LWT_BUFFER_SIZE) {
  71         for (int i = tb->head & LWT_BUFFER_MASK; i < LWT_BUFFER_SIZE; ++i) {
  72             dump_record(file, thread_index + 1, tb->x + i, offset);
  73         }
  74     }
  75
  76     for (int i = 0; i < (tb->head & LWT_BUFFER_MASK); ++i) {
  77         dump_record(file, thread_index + 1, tb->x + i, offset);
  78     }
  79 }
  80
  81 void lwt_halt (void) {
  82     halt_ = 1;
  83 }
  84
  85 void lwt_dump (const char *file_name) {
  86     halt_ = 1;
  87     uint64_t offset = (uint64_t)-1;
  88
  89     for (int i = 0; i < MAX_NUM_THREADS; ++i) {
  90         if (TraceBuffer[i] != NULL && TraceBuffer[i]->head != 0) {
  91             uint64_t x = TraceBuffer[i]->x[0].timestamp;
  92             if (x < offset) {
  93                 offset = x;
  94             }
  95             if (TraceBuffer[i]->head > LWT_BUFFER_SIZE)
  96             {
  97                 x = TraceBuffer[i]->x[TraceBuffer[i]->head & LWT_BUFFER_MASK].timestamp;
  98                 if (x < offset) {
  99                     offset = x;
 100                 }
 101             }
 102         }
 103     }
 104
 105     if (offset != (uint64_t)-1) {
 106         FILE *file = fopen(file_name, "w");
 107         assert(file);
 108         for (int i = 0; i < MAX_NUM_THREADS; ++i) {
 109             if (TraceBuffer[i] != NULL) {
 110                 dump_buffer(file, i, offset);
 111             }
 112         }
 113         fflush(file);
 114         fclose(file);
 115     }
 116 }
 117
 118 void lwt_trace_i (uint64_t format, size_t value1, size_t value2) {
 119     while (halt_) {}
 120     lwt_buffer_t *tb = TraceBuffer[GET_THREAD_INDEX()];
 121     if (tb != NULL) {
 122         unsigned int u, l;
 123         __asm__ __volatile__("rdtsc" : "=a" (l), "=d" (u));
 124         uint64_t timestamp = ((uint64_t)u << 32) | l;
 125         lwt_record_t temp = { timestamp, format, value1, value2 };
 126
 127         tb->x[tb->head++ & LWT_BUFFER_MASK] = temp;
 128     }
 129 }