net/disk_cache/blockfile/trace.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/disk_cache/blockfile/trace.h"
   6
   7 #include <stdarg.h>
   8 #include <stdio.h>
   9 #if defined(OS_WIN)
  10 #include <windows.h>
  11 #endif
  12
  13 #include "base/lazy_instance.h"
  14 #include "base/logging.h"
  15 #include "base/synchronization/lock.h"
  16 #include "net/disk_cache/blockfile/stress_support.h"
  17
  18 // Change this value to 1 to enable tracing on a release build. By default,
  19 // tracing is enabled only on debug builds.
  20 #define ENABLE_TRACING 0
  21
  22 #ifndef NDEBUG
  23 #undef ENABLE_TRACING
  24 #define ENABLE_TRACING 1
  25 #endif
  26
  27 namespace {
  28
  29 const int kEntrySize = 12 * sizeof(size_t);
  30 #if defined(NET_BUILD_STRESS_CACHE)
  31 const int kNumberOfEntries = 500000;
  32 #else
  33 const int kNumberOfEntries = 5000;  // 240 KB on 32bit, 480 KB on 64bit
  34 #endif
  35
  36 bool s_trace_enabled = false;
  37 base::LazyInstance<base::Lock>::Leaky s_lock = LAZY_INSTANCE_INITIALIZER;
  38
  39 struct TraceBuffer {
  40   int num_traces;
  41   int current;
  42   char buffer[kNumberOfEntries][kEntrySize];
  43 };
  44
  45 #if ENABLE_TRACING
  46 void DebugOutput(const char* msg) {
  47 #if defined(OS_WIN)
  48   OutputDebugStringA(msg);
  49 #else
  50   NOTIMPLEMENTED();
  51 #endif
  52 }
  53 #endif  // ENABLE_TRACING
  54
  55 }  // namespace
  56
  57 namespace disk_cache {
  58
  59 // s_trace_buffer and s_trace_object are not singletons because I want the
  60 // buffer to be destroyed and re-created when the last user goes away, and it
  61 // must be straightforward to access the buffer from the debugger.
  62 static TraceObject* s_trace_object = NULL;
  63
  64 // Static.
  65 TraceObject* TraceObject::GetTraceObject() {
  66   base::AutoLock lock(s_lock.Get());
  67
  68   if (s_trace_object)
  69     return s_trace_object;
  70
  71   s_trace_object = new TraceObject();
  72   return s_trace_object;
  73 }
  74
  75 TraceObject::TraceObject() {
  76   InitTrace();
  77 }
  78
  79 TraceObject::~TraceObject() {
  80   DestroyTrace();
  81 }
  82
  83 void TraceObject::EnableTracing(bool enable) {
  84   base::AutoLock lock(s_lock.Get());
  85   s_trace_enabled = enable;
  86 }
  87
  88 #if ENABLE_TRACING
  89
  90 static TraceBuffer* s_trace_buffer = NULL;
  91
  92 void InitTrace(void) {
  93   s_trace_enabled = true;
  94   if (s_trace_buffer)
  95     return;
  96
  97   s_trace_buffer = new TraceBuffer;
  98   memset(s_trace_buffer, 0, sizeof(*s_trace_buffer));
  99 }
 100
 101 void DestroyTrace(void) {
 102   base::AutoLock lock(s_lock.Get());
 103
 104   delete s_trace_buffer;
 105   s_trace_buffer = NULL;
 106   s_trace_object = NULL;
 107 }
 108
 109 void Trace(const char* format, ...) {
 110   if (!s_trace_buffer || !s_trace_enabled)
 111     return;
 112
 113   va_list ap;
 114   va_start(ap, format);
 115   char line[kEntrySize + 2];
 116
 117 #if defined(OS_WIN)
 118   vsprintf_s(line, format, ap);
 119 #else
 120   vsnprintf(line, kEntrySize, format, ap);
 121 #endif
 122
 123 #if defined(DISK_CACHE_TRACE_TO_LOG)
 124   line[kEntrySize] = '\0';
 125   LOG(INFO) << line;
 126 #endif
 127
 128   va_end(ap);
 129
 130   {
 131     base::AutoLock lock(s_lock.Get());
 132     if (!s_trace_buffer || !s_trace_enabled)
 133       return;
 134
 135     memcpy(s_trace_buffer->buffer[s_trace_buffer->current], line, kEntrySize);
 136
 137     s_trace_buffer->num_traces++;
 138     s_trace_buffer->current++;
 139     if (s_trace_buffer->current == kNumberOfEntries)
 140       s_trace_buffer->current = 0;
 141   }
 142 }
 143
 144 // Writes the last num_traces to the debugger output.
 145 void DumpTrace(int num_traces) {
 146   DCHECK(s_trace_buffer);
 147   DebugOutput("Last traces:\n");
 148
 149   if (num_traces > kNumberOfEntries || num_traces < 0)
 150     num_traces = kNumberOfEntries;
 151
 152   if (s_trace_buffer->num_traces) {
 153     char line[kEntrySize + 2];
 154
 155     int current = s_trace_buffer->current - num_traces;
 156     if (current < 0)
 157       current += kNumberOfEntries;
 158
 159     for (int i = 0; i < num_traces; i++) {
 160       memcpy(line, s_trace_buffer->buffer[current], kEntrySize);
 161       line[kEntrySize] = '\0';
 162       size_t length = strlen(line);
 163       if (length) {
 164         line[length] = '\n';
 165         line[length + 1] = '\0';
 166         DebugOutput(line);
 167       }
 168
 169       current++;
 170       if (current ==  kNumberOfEntries)
 171         current = 0;
 172     }
 173   }
 174
 175   DebugOutput("End of Traces\n");
 176 }
 177
 178 #else  // ENABLE_TRACING
 179
 180 void InitTrace(void) {
 181   return;
 182 }
 183
 184 void DestroyTrace(void) {
 185   s_trace_object = NULL;
 186 }
 187
 188 void Trace(const char* format, ...) {
 189 }
 190
 191 #endif  // ENABLE_TRACING
 192
 193 }  // namespace disk_cache