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
   9 #include "common.h"
  10 #include "tls.h"
  11 #include "lwt.h"
  12 #include "mem.h"
  13
  14 #define LWT_BUFFER_SCALE 16
  15 #define LWT_BUFFER_SIZE (1 << LWT_BUFFER_SCALE)
  16 #define LWT_BUFFER_MASK (LWT_BUFFER_SIZE - 1)
  17
  18 typedef struct lwt_record {
  19     uint64_t timestamp;
  20     const char *format;
  21     size_t value1;
  22     size_t value2;
  23 } lwt_record_t;
  24
  25 typedef struct lwt_buffer {
  26     uint32_t head;
  27     lwt_record_t x[0];
  28 } lwt_buffer_t;
  29
  30 DECLARE_THREAD_LOCAL(tb_, int);
  31
  32 lwt_buffer_t *lwt_buf_[MAX_NUM_THREADS] = {};
  33 uint64_t flag_mask_ = 0;
  34 static int buf_count_ = 0;
  35 static const char *flags_ = "";
  36
  37 void lwt_init (void)
  38 {
  39     INIT_THREAD_LOCAL(tb_, NULL);
  40 }
  41
  42 void lwt_thread_init (int thread_id)
  43 {
  44     assert(thread_id < MAX_NUM_THREADS);
  45     if (lwt_buf_[thread_id] == NULL) {
  46         lwt_buf_[thread_id] = (lwt_buffer_t *)nbd_malloc(sizeof(lwt_buffer_t) + sizeof(lwt_record_t) * LWT_BUFFER_SIZE);
  47         SYNC_ADD(&buf_count_, 1);
  48         memset(lwt_buf_[thread_id], 0, sizeof(lwt_buffer_t));
  49         SET_THREAD_LOCAL(tb_, lwt_buf_[thread_id]);
  50     }
  51 }
  52
  53 void lwt_set_trace_level (const char *flags)
  54 {
  55     assert(strlen(flags) % 2 == 0); // a well formed <flags> should be an even number of characters long
  56     flags_ = flags;
  57     int i;
  58     for (i = 0; flags[i]; i+=2) {
  59         flag_mask_ |= 1 << (flags[i] - 'A');
  60     }
  61 }
  62
  63 static inline void dump_record (FILE *file, int thread_id, lwt_record_t *r, uint64_t offset)
  64 {
  65     // print the record if its trace category is enabled at a high enough level
  66     int flag  =  (size_t)r->format >> 56;
  67     int level = ((size_t)r->format >> 48) & 0xFF;
  68     const char *f = strchr(flags_, flag);
  69     if (f != NULL && level <= f[1]) {
  70         char s[3] = {flag, level, '\0'};
  71         fprintf(file, "%09llu %d %s ", ((uint64_t)r->timestamp - offset) >> 6, thread_id, s);
  72         const char *format = (const char *)(((uint64_t)r->format << 16) >> 16); // strip out the embedded flags
  73         fprintf(file, format, r->value1, r->value2);
  74         fprintf(file, "\n");
  75     }
  76 }
  77
  78 static void dump_buffer (FILE *file, int thread_id, uint64_t offset)
  79 {
  80     assert(thread_id < buf_count_);
  81
  82     lwt_buffer_t *tb = lwt_buf_[thread_id];
  83     int i;
  84     if (tb->head > LWT_BUFFER_SIZE) {
  85         for (i = tb->head & LWT_BUFFER_MASK; i < LWT_BUFFER_SIZE; ++i) {
  86             dump_record(file, thread_id, tb->x + i, offset);
  87         }
  88     }
  89
  90     for (i = 0; i < (tb->head & LWT_BUFFER_MASK); ++i) {
  91         dump_record(file, thread_id, tb->x + i, offset);
  92     }
  93 }
  94
  95 void lwt_dump (const char *file_name)
  96 {
  97     uint64_t offset = (uint64_t)-1;
  98     int i;
  99
 100     for (i = 0; i < buf_count_; ++i) {
 101         if (lwt_buf_[i] != NULL && lwt_buf_[i]->head != 0) {
 102             uint64_t x = lwt_buf_[i]->x[0].timestamp;
 103             if (x < offset) {
 104                 offset = x;
 105             }
 106             if (lwt_buf_[i]->head > LWT_BUFFER_SIZE)
 107             {
 108                 x = lwt_buf_[i]->x[lwt_buf_[i]->head & LWT_BUFFER_MASK].timestamp;
 109                 if (x < offset) {
 110                     offset = x;
 111                 }
 112             }
 113         }
 114     }
 115
 116     if (offset != (uint64_t)-1) {
 117         FILE *file = fopen(file_name, "w");
 118         assert(file);
 119         for (i = 0; i < buf_count_; ++i) {
 120             if (lwt_buf_[i] != NULL) {
 121                 dump_buffer(file, i, offset);
 122             }
 123         }
 124         fflush(file);
 125         fclose(file);
 126     }
 127 }
 128
 129 void lwt_trace_i (const char *format, size_t value1, size_t value2) {
 130     LOCALIZE_THREAD_LOCAL(tb_, lwt_buffer_t *);
 131     if (tb_) {
 132         unsigned int u, l;
 133         __asm__ __volatile__("rdtsc" : "=a" (l), "=d" (u));
 134         uint64_t timestamp = ((uint64_t)u << 32) | l;
 135         lwt_record_t temp = { timestamp, format, value1, value2 };
 136         tb_->x[tb_->head++ & LWT_BUFFER_MASK] = temp;
 137     }
 138 }