Initial commit
[nbds] / util / 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 DECLARE_THREAD_LOCAL(tb_, int);
15
16 lwt_buffer_t *lwt_buf_[MAX_NUM_THREADS] = {};
17 uint64_t flag_mask_ = 0;
18 static int buf_count_ = 0;
19 static const char *flags_ = "";
20
21 void lwt_init (void)
22 {
23     INIT_THREAD_LOCAL(tb_, NULL);
24 }
25
26 void lwt_thread_init (int thread_id)
27 {
28     assert(thread_id < MAX_NUM_THREADS);
29     if (lwt_buf_[thread_id] == NULL) {
30         lwt_buf_[thread_id] = (lwt_buffer_t *)nbd_malloc(sizeof(lwt_buffer_t) + sizeof(lwt_record_t) * LWT_BUFFER_SIZE);
31         SYNC_ADD(&buf_count_, 1);
32         memset(lwt_buf_[thread_id], 0, sizeof(lwt_buffer_t));
33         SET_THREAD_LOCAL(tb_, lwt_buf_[thread_id]);
34     }
35 }
36
37 void lwt_set_trace_level (const char *flags)
38 {
39     assert(strlen(flags) % 2 == 0); // a well formed <flags> should be an even number of characters long
40     flags_ = flags;
41     int i;
42     for (i = 0; flags[i]; i+=2) {
43         flag_mask_ |= 1 << (flags[i] - 'A');
44     }
45 }
46
47 static inline void dump_record (FILE *file, int thread_id, lwt_record_t *r, uint64_t offset)
48 {
49     // print the record if its trace category is enabled at a high enough level
50     int flag  =  (size_t)r->format >> 56;
51     int level = ((size_t)r->format >> 48) & 0xFF;
52     const char *f = strchr(flags_, flag);
53     if (f != NULL && level <= f[1]) {
54         char s[3] = {flag, level, '\0'};
55         fprintf(file, "%09llu %d %s ", ((uint64_t)r->timestamp - offset) >> 6, thread_id, s);
56         const char *format = (const char *)(((uint64_t)r->format << 16) >> 16); // strip out the embedded flags
57         fprintf(file, format, r->value1, r->value2);
58         fprintf(file, "\n");
59     }
60 }
61
62 static void dump_buffer (FILE *file, int thread_id, uint64_t offset)
63 {
64     assert(thread_id < buf_count_);
65
66     lwt_buffer_t *tb = lwt_buf_[thread_id]; 
67     int i;
68     if (tb->head > LWT_BUFFER_SIZE) {
69         for (i = tb->head & LWT_BUFFER_MASK; i < LWT_BUFFER_SIZE; ++i) {
70             dump_record(file, thread_id, tb->x + i, offset);
71         }
72     }
73
74     for (i = 0; i < (tb->head & LWT_BUFFER_MASK); ++i) {
75         dump_record(file, thread_id, tb->x + i, offset);
76     }
77 }
78
79 void lwt_dump (const char *file_name)
80 {
81     uint64_t offset = (uint64_t)-1;
82     int i;
83
84     for (i = 0; i < buf_count_; ++i) {
85         if (lwt_buf_[i] != NULL && lwt_buf_[i]->head != 0) {
86             uint64_t x = lwt_buf_[i]->x[0].timestamp;
87             if (x < offset) {
88                 offset = x;
89             }
90             if (lwt_buf_[i]->head > LWT_BUFFER_SIZE)
91             {
92                 x = lwt_buf_[i]->x[lwt_buf_[i]->head & LWT_BUFFER_MASK].timestamp;
93                 if (x < offset) {
94                     offset = x;
95                 }
96             }
97         }
98     }
99
100     if (offset != (uint64_t)-1) {
101         FILE *file = fopen(file_name, "w");
102         assert(file);
103         for (i = 0; i < buf_count_; ++i) {
104             if (lwt_buf_[i] != NULL) {
105                 dump_buffer(file, i, offset);
106             }
107         }
108         fflush(file);
109         fclose(file);
110     }
111 }