X-Git-Url: https://pd.if.org/git/?p=nbds;a=blobdiff_plain;f=runtime%2Flwt.c;h=47bfcebb53f31760924139e51ccede621e604a01;hp=d7b9862d360284750df0a4d47518750958d1fc56;hb=HEAD;hpb=efd90a1b8a9d3bbb1bdd8e6ae41b3462e7193fb2 diff --git a/runtime/lwt.c b/runtime/lwt.c index d7b9862..47bfceb 100644 --- a/runtime/lwt.c +++ b/runtime/lwt.c @@ -5,91 +5,96 @@ * lightweight tracing */ #include - #include "common.h" -#include "tls.h" +#include "rlocal.h" #include "lwt.h" #include "mem.h" -DECLARE_THREAD_LOCAL(tb_, int); +#define LWT_BUFFER_SCALE 20 +#define LWT_BUFFER_SIZE (1ULL << LWT_BUFFER_SCALE) +#define LWT_BUFFER_MASK (LWT_BUFFER_SIZE - 1) -lwt_buffer_t *lwt_buf_[MAX_NUM_THREADS] = {}; -uint64_t flag_mask_ = 0; -static int buf_count_ = 0; -static const char *flags_ = ""; +volatile int halt_ = 0; -void lwt_init (void) -{ - INIT_THREAD_LOCAL(tb_, NULL); -} +typedef struct lwt_record { + uint64_t timestamp; + uint64_t format; + size_t value1; + size_t value2; +} lwt_record_t; + +typedef struct lwt_buffer { + uint32_t head; + lwt_record_t x[0]; +} lwt_buffer_t; -void lwt_thread_init (int thread_id) -{ - assert(thread_id < MAX_NUM_THREADS); - if (lwt_buf_[thread_id] == NULL) { - lwt_buf_[thread_id] = (lwt_buffer_t *)nbd_malloc(sizeof(lwt_buffer_t) + sizeof(lwt_record_t) * LWT_BUFFER_SIZE); - SYNC_ADD(&buf_count_, 1); - memset(lwt_buf_[thread_id], 0, sizeof(lwt_buffer_t)); - SET_THREAD_LOCAL(tb_, lwt_buf_[thread_id]); +lwt_buffer_t *TraceBuffer[MAX_NUM_THREADS] = {}; +char TraceLevel[256] = {}; +static const char *TraceSpec = ""; + +void lwt_thread_init (void) { + int thread_index = GET_THREAD_INDEX(); + + if (TraceBuffer[thread_index] == NULL) { + TraceBuffer[thread_index] = + (lwt_buffer_t *)nbd_malloc(sizeof(lwt_buffer_t) + sizeof(lwt_record_t) * LWT_BUFFER_SIZE); + memset(TraceBuffer[thread_index], 0, sizeof(lwt_buffer_t)); } } -void lwt_set_trace_level (const char *flags) -{ +void lwt_set_trace_level (const char *flags) { assert(strlen(flags) % 2 == 0); // a well formed should be an even number of characters long - flags_ = flags; - int i; - for (i = 0; flags[i]; i+=2) { - flag_mask_ |= 1 << (flags[i] - 'A'); + TraceSpec = flags; + memset(TraceLevel, 0, sizeof(TraceLevel)); + for (int i = 0; flags[i]; i+=2) { + TraceLevel[(unsigned)flags[i]] = flags[i+1]; } } -static inline void dump_record (FILE *file, int thread_id, lwt_record_t *r, uint64_t offset) -{ +static void dump_record (FILE *file, int thread_id, lwt_record_t *r, uint64_t offset) { // print the record if its trace category is enabled at a high enough level - int flag = (size_t)r->format >> 56; - int level = ((size_t)r->format >> 48) & 0xFF; - const char *f = strchr(flags_, flag); - if (f != NULL && level <= f[1]) { + int flag = r->format >> 56; + int level = (r->format >> 48) & 0xFF; + if (TraceLevel[(unsigned)flag] >= level) { char s[3] = {flag, level, '\0'}; - fprintf(file, "%09llu %d %s ", ((uint64_t)r->timestamp - offset) >> 6, thread_id, s); - const char *format = (const char *)(((uint64_t)r->format << 16) >> 16); // strip out the embedded flags + fprintf(file, "%09llu %d %s ", ((uint64_t)r->timestamp - offset) >> 5, thread_id, s); + const char *format = (const char *)(size_t)(r->format & MASK(48)); // strip out the embedded flags fprintf(file, format, r->value1, r->value2); fprintf(file, "\n"); } } -static void dump_buffer (FILE *file, int thread_id, uint64_t offset) -{ - assert(thread_id < buf_count_); - - lwt_buffer_t *tb = lwt_buf_[thread_id]; - int i; +static void dump_buffer (FILE *file, int thread_index, uint64_t offset) { + lwt_buffer_t *tb = TraceBuffer[thread_index]; + assert(tb); if (tb->head > LWT_BUFFER_SIZE) { - for (i = tb->head & LWT_BUFFER_MASK; i < LWT_BUFFER_SIZE; ++i) { - dump_record(file, thread_id, tb->x + i, offset); + for (int i = tb->head & LWT_BUFFER_MASK; i < LWT_BUFFER_SIZE; ++i) { + dump_record(file, thread_index + 1, tb->x + i, offset); } } - for (i = 0; i < (tb->head & LWT_BUFFER_MASK); ++i) { - dump_record(file, thread_id, tb->x + i, offset); + for (int i = 0; i < (tb->head & LWT_BUFFER_MASK); ++i) { + dump_record(file, thread_index + 1, tb->x + i, offset); } } -void lwt_dump (const char *file_name) -{ +void lwt_halt (void) { + halt_ = 1; +} + +void lwt_dump (const char *file_name) { + halt_ = 1; uint64_t offset = (uint64_t)-1; - int i; - for (i = 0; i < buf_count_; ++i) { - if (lwt_buf_[i] != NULL && lwt_buf_[i]->head != 0) { - uint64_t x = lwt_buf_[i]->x[0].timestamp; + for (int i = 0; i < MAX_NUM_THREADS; ++i) { + if (TraceBuffer[i] != NULL && TraceBuffer[i]->head != 0) { + uint64_t x = TraceBuffer[i]->x[0].timestamp; if (x < offset) { offset = x; } - if (lwt_buf_[i]->head > LWT_BUFFER_SIZE) + if (TraceBuffer[i]->head > LWT_BUFFER_SIZE) { - x = lwt_buf_[i]->x[lwt_buf_[i]->head & LWT_BUFFER_MASK].timestamp; + x = TraceBuffer[i]->x[TraceBuffer[i]->head & LWT_BUFFER_MASK].timestamp; if (x < offset) { offset = x; } @@ -100,8 +105,8 @@ void lwt_dump (const char *file_name) if (offset != (uint64_t)-1) { FILE *file = fopen(file_name, "w"); assert(file); - for (i = 0; i < buf_count_; ++i) { - if (lwt_buf_[i] != NULL) { + for (int i = 0; i < MAX_NUM_THREADS; ++i) { + if (TraceBuffer[i] != NULL) { dump_buffer(file, i, offset); } } @@ -109,3 +114,16 @@ void lwt_dump (const char *file_name) fclose(file); } } + +void lwt_trace_i (uint64_t format, size_t value1, size_t value2) { + while (halt_) {} + lwt_buffer_t *tb = TraceBuffer[GET_THREAD_INDEX()]; + if (tb != NULL) { + unsigned int u, l; + __asm__ __volatile__("rdtsc" : "=a" (l), "=d" (u)); + uint64_t timestamp = ((uint64_t)u << 32) | l; + lwt_record_t temp = { timestamp, format, value1, value2 }; + + tb->x[tb->head++ & LWT_BUFFER_MASK] = temp; + } +}