calltracemanager.h

Go to the documentation of this file.

#ifndef ION_PROFILE_CALLTRACEMANAGER_H_
#define ION_PROFILE_CALLTRACEMANAGER_H_

#include <chrono>  // NOLINT
#include <memory>
#include <vector>

#include "ion/analytics/benchmark.h"
#include "ion/base/lockguards.h"
#include "ion/base/setting.h"
#include "ion/base/stlalloc/allocunorderedmap.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/base/threadlocalobject.h"
#include "ion/port/mutex.h"
#include "ion/port/timer.h"
#include "ion/profile/timeline.h"
#include "ion/profile/timelinemetric.h"

namespace ion {
namespace profile {

class TraceRecorder;

class CallTraceManager : public base::Allocatable {
 public:
  enum EventArgType {
    kArgNone,
    kArgNumeric,
    kArgString,
  };

  enum BuiltinEventType {
    kDefineEvent = 1,

    kCreateZoneEvent = 3,
    kDeleteZoneEvent = 4,
    kSetZoneEvent = 5,

    kScopeLeaveEvent = 8,

    kScopeAppendDataEvent = 9,

    kMarkEvent = 10,

    kTimeStampEvent = 11,

    kTimeRangeStartEvent = 12,
    kTimeRangeEndEvent = 13,

    kFrameStartEvent = 14,
    kFrameEndEvent = 15,

    kCustomScopeEvent = 100,
  };

  enum NamedTraceRecorderType {
    kRecorderGpu = 0,
    kRecorderVSync,
    kNumNamedTraceRecorders,
  };

  typedef base::AllocUnorderedMap<const void*, uint32> ScopeEventMap;

  typedef base::AllocUnorderedMap<uint32, const char*> ReverseScopeEventMap;

  typedef base::AllocVector<TraceRecorder*> TraceList;

  CallTraceManager();

  explicit CallTraceManager(size_t buffer_size);

  ~CallTraceManager() override;

  TraceRecorder* GetTraceRecorder();

  TraceRecorder* GetNamedTraceRecorder(NamedTraceRecorderType name);

  const TraceList& GetAllTraceRecorders() const { return recorder_list_; }

  int GetScopeEnterEvent(const char* string_id);

  const char* GetScopeEnterEventName(uint32 event_id) const;

  static int GetNumArgsForEvent(uint32 event_id);

  static EventArgType GetArgType(uint32 event_id, int arg_index);

  size_t GetNumScopeEvents() const { return scope_event_map_.size(); }

  std::string SnapshotCallTraces() const;

  virtual uint32 GetTimeInUs() const {
    return static_cast<uint32>(
        std::chrono::duration_cast<std::chrono::microseconds>(timer_.Get())
            .count());
  }

  uint64 GetTimeInNs() const {
    return static_cast<uint64>(
        std::chrono::duration_cast<std::chrono::nanoseconds>(timer_.Get())
            .count());
  }

  void WriteFile(const std::string& filename) const;

  Timeline BuildTimeline() const;

  void RegisterTimelineMetric(std::unique_ptr<TimelineMetric> metric) {
    timeline_metrics_.push_back(std::move(metric));
  }

  analytics::Benchmark RunTimelineMetrics() const;

 private:
  struct NamedTraceRecorderArray {
    NamedTraceRecorderArray() {
      for (int i = 0; i < kNumNamedTraceRecorders; ++i) {
        recorders[i] = NULL;
      }
    }

    TraceRecorder* recorders[kNumNamedTraceRecorders];
  };

  TraceRecorder* AllocateTraceRecorder();

  port::Mutex mutex_;

  base::ThreadLocalObject<TraceRecorder*> trace_recorder_;

  base::ThreadLocalObject<NamedTraceRecorderArray> named_trace_recorders_;

  TraceList recorder_list_;

  size_t buffer_size_;

  port::Timer timer_;

  ScopeEventMap scope_event_map_;

  ReverseScopeEventMap reverse_scope_event_map_;

  std::vector<std::unique_ptr<TimelineMetric>> timeline_metrics_;
};

class ScopedTracer {
 public:
  ScopedTracer(TraceRecorder* recorder, int id);
  ~ScopedTracer();

 private:
  TraceRecorder* recorder_;
};

class ScopedFrameTracer {
 public:
  ScopedFrameTracer(TraceRecorder* recorder, uint32 id);
  ~ScopedFrameTracer();

 private:
  TraceRecorder* recorder_;
};

}  // namespace profile
}  // namespace ion

#endif  // ION_PROFILE_CALLTRACEMANAGER_H_