Home | History | Annotate | Download | only in trace_event 
      1 // Copyright (c) 2012 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 
      6 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
      7 #define BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
      8 
      9 #include <stdint.h>
     10 
     11 #include <stack>
     12 #include <string>
     13 #include <vector>
     14 
     15 #include "base/atomicops.h"
     16 #include "base/base_export.h"
     17 #include "base/callback.h"
     18 #include "base/containers/hash_tables.h"
     19 #include "base/macros.h"
     20 #include "base/memory/ref_counted_memory.h"
     21 #include "base/observer_list.h"
     22 #include "base/single_thread_task_runner.h"
     23 #include "base/strings/string_util.h"
     24 #include "base/synchronization/condition_variable.h"
     25 #include "base/synchronization/lock.h"
     26 #include "base/threading/thread.h"
     27 #include "base/threading/thread_local.h"
     28 #include "base/trace_event/trace_event_memory_overhead.h"
     29 #include "build/build_config.h"
     30 
     31 namespace base {
     32 
     33 class WaitableEvent;
     34 class MessageLoop;
     35 
     36 namespace trace_event {
     37 
     38 typedef base::Callback<bool(const char* arg_name)> ArgumentNameFilterPredicate;
     39 
     40 typedef base::Callback<bool(const char* category_group_name,
     41                             const char* event_name,
     42                             ArgumentNameFilterPredicate*)>
     43     ArgumentFilterPredicate;
     44 
     45 // For any argument of type TRACE_VALUE_TYPE_CONVERTABLE the provided
     46 // class must implement this interface.
     47 class BASE_EXPORT ConvertableToTraceFormat
     48     : public RefCounted<ConvertableToTraceFormat> {
     49  public:
     50   // Append the class info to the provided |out| string. The appended
     51   // data must be a valid JSON object. Strings must be properly quoted, and
     52   // escaped. There is no processing applied to the content after it is
     53   // appended.
     54   virtual void AppendAsTraceFormat(std::string* out) const = 0;
     55 
     56   virtual void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
     57 
     58   std::string ToString() const {
     59     std::string result;
     60     AppendAsTraceFormat(&result);
     61     return result;
     62   }
     63 
     64  protected:
     65   virtual ~ConvertableToTraceFormat() {}
     66 
     67  private:
     68   friend class RefCounted<ConvertableToTraceFormat>;
     69 };
     70 
     71 const int kTraceMaxNumArgs = 2;
     72 
     73 struct TraceEventHandle {
     74   uint32_t chunk_seq;
     75   // These numbers of bits must be kept consistent with
     76   // TraceBufferChunk::kMaxTrunkIndex and
     77   // TraceBufferChunk::kTraceBufferChunkSize (in trace_buffer.h).
     78   unsigned chunk_index : 26;
     79   unsigned event_index : 6;
     80 };
     81 
     82 class BASE_EXPORT TraceEvent {
     83  public:
     84   union TraceValue {
     85     bool as_bool;
     86     unsigned long long as_uint;
     87     long long as_int;
     88     double as_double;
     89     const void* as_pointer;
     90     const char* as_string;
     91   };
     92 
     93   TraceEvent();
     94   ~TraceEvent();
     95 
     96   // We don't need to copy TraceEvent except when TraceEventBuffer is cloned.
     97   // Use explicit copy method to avoid accidentally misuse of copy.
     98   void CopyFrom(const TraceEvent& other);
     99 
    100   void Initialize(
    101       int thread_id,
    102       TimeTicks timestamp,
    103       ThreadTicks thread_timestamp,
    104       char phase,
    105       const unsigned char* category_group_enabled,
    106       const char* name,
    107       unsigned long long id,
    108       unsigned long long bind_id,
    109       int num_args,
    110       const char** arg_names,
    111       const unsigned char* arg_types,
    112       const unsigned long long* arg_values,
    113       const scoped_refptr<ConvertableToTraceFormat>* convertable_values,
    114       unsigned int flags);
    115 
    116   void Reset();
    117 
    118   void UpdateDuration(const TimeTicks& now, const ThreadTicks& thread_now);
    119 
    120   void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
    121 
    122   // Serialize event data to JSON
    123   void AppendAsJSON(
    124       std::string* out,
    125       const ArgumentFilterPredicate& argument_filter_predicate) const;
    126   void AppendPrettyPrinted(std::ostringstream* out) const;
    127 
    128   static void AppendValueAsJSON(unsigned char type,
    129                                 TraceValue value,
    130                                 std::string* out);
    131 
    132   TimeTicks timestamp() const { return timestamp_; }
    133   ThreadTicks thread_timestamp() const { return thread_timestamp_; }
    134   char phase() const { return phase_; }
    135   int thread_id() const { return thread_id_; }
    136   TimeDelta duration() const { return duration_; }
    137   TimeDelta thread_duration() const { return thread_duration_; }
    138   unsigned long long id() const { return id_; }
    139   unsigned int flags() const { return flags_; }
    140 
    141   // Exposed for unittesting:
    142 
    143   const base::RefCountedString* parameter_copy_storage() const {
    144     return parameter_copy_storage_.get();
    145   }
    146 
    147   const unsigned char* category_group_enabled() const {
    148     return category_group_enabled_;
    149   }
    150 
    151   const char* name() const { return name_; }
    152 
    153 #if defined(OS_ANDROID)
    154   void SendToATrace();
    155 #endif
    156 
    157  private:
    158   // Note: these are ordered by size (largest first) for optimal packing.
    159   TimeTicks timestamp_;
    160   ThreadTicks thread_timestamp_;
    161   TimeDelta duration_;
    162   TimeDelta thread_duration_;
    163   // id_ can be used to store phase-specific data.
    164   unsigned long long id_;
    165   TraceValue arg_values_[kTraceMaxNumArgs];
    166   const char* arg_names_[kTraceMaxNumArgs];
    167   scoped_refptr<ConvertableToTraceFormat> convertable_values_[kTraceMaxNumArgs];
    168   const unsigned char* category_group_enabled_;
    169   const char* name_;
    170   scoped_refptr<base::RefCountedString> parameter_copy_storage_;
    171   // Depending on TRACE_EVENT_FLAG_HAS_PROCESS_ID the event will have either:
    172   //  tid: thread_id_, pid: current_process_id (default case).
    173   //  tid: -1, pid: process_id_ (when flags_ & TRACE_EVENT_FLAG_HAS_PROCESS_ID).
    174   union {
    175     int thread_id_;
    176     int process_id_;
    177   };
    178   unsigned int flags_;
    179   unsigned long long bind_id_;
    180   unsigned char arg_types_[kTraceMaxNumArgs];
    181   char phase_;
    182 
    183   DISALLOW_COPY_AND_ASSIGN(TraceEvent);
    184 };
    185 
    186 }  // namespace trace_event
    187 }  // namespace base
    188 
    189 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
    190