tracerecorder.h

Go to the documentation of this file.

#ifndef ION_PROFILE_TRACERECORDER_H_
#define ION_PROFILE_TRACERECORDER_H_

#include <memory>
#include <string>
#include <unordered_map>

#include "base/integral_types.h"
#include "ion/base/allocatable.h"
#include "ion/base/circularbuffer.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/port/threadutils.h"
#include "ion/profile/timelineevent.h"
#include "ion/profile/timelinenode.h"
#include "third_party/jsoncpp/include/json/json.h"

namespace ion {
namespace profile {

class CallTraceManager;

class TraceRecorder : public ion::base::Allocatable {
 public:
  struct TraceHeader {
    TraceHeader(uint32 id, uint32 time_micros)
        : id(id), time_micros(time_micros) {}
    uint32 id;  // Event id
    uint32 time_micros;  // in microseconds since the timebase
  };

  typedef base::CircularBuffer<uint32> TraceBuffer;
  typedef std::unordered_map<uint32, std::string> IndexToStringMap;

  explicit TraceRecorder(CallTraceManager* manager);

  TraceRecorder(CallTraceManager* manager, size_t buffer_size);

  static size_t GetDefaultBufferSize() { return s_default_buffer_size_; }
  static void SetDefaultBufferSize(size_t s) { s_default_buffer_size_ = s; }

  static bool GetReserveBuffer() { return s_reserve_buffer_; }
  static void SetReserveBuffer(bool reserve) { s_reserve_buffer_ = reserve; }

  void EnterScope(int event_id);

  void AnnotateCurrentScope(const std::string& name, const std::string& value);

  void LeaveScope();

  void EnterScopeAtTime(uint32 timestamp, int event_id);

  void AnnotateCurrentScopeAtTime(uint32 timestamp,
                                  const std::string& name,
                                  const std::string& value);

  void LeaveScopeAtTime(uint32 timestamp);

  void EnterFrame(uint32 frame_number);

  void LeaveFrame();

  void EnterTimeRange(uint32 unique_id, const char* name, const char* value);

  uint32 EnterTimeRange(const char* name, const char* value);

  void LeaveTimeRange(uint32 id);

  void CreateTimeStamp(const char* name, const char* value);

  void CreateTimeStampAtTime(
      uint32 timestamp, const char* name, const char* value);

  size_t GetNumTraces() const;

  const ion::port::ThreadId& GetThreadId() const { return thread_id_; }

  void SetThreadName(const std::string& name) { thread_name_ = name; }

  std::string GetThreadName() const { return thread_name_; }

  void DumpStrings(std::vector<std::string>* table) const;

  void DumpTrace(std::string* output, uint32 string_index_offset) const;

  void AddTraceToTimelineNode(TimelineNode* root) const;

  uint32 GetCurrentFrameNumber() const;

  bool IsInFrameScope() const { return frame_level_ > 0; }

 private:
  static size_t s_default_buffer_size_;
  static bool s_reserve_buffer_;

  uint32 GetStringIndex(const std::string& str);

  std::string GetStringArg(size_t index, int arg_index,
                           const IndexToStringMap& inverse_string_buffer) const;

  std::unique_ptr<TimelineEvent> GetTimelineEvent(
      size_t index, const IndexToStringMap& inverse_string_buffer) const;

  CallTraceManager* manager_;

  TraceBuffer trace_buffer_;

  std::unordered_map<std::string, uint32> string_buffer_;

  int scope_level_;

  ion::port::ThreadId thread_id_;

  std::string thread_name_;

  int frame_level_;
  uint32 current_frame_number_;
};

}  // namespace profile
}  // namespace ion

#endif  // ION_PROFILE_TRACERECORDER_H_