Tracing.h

#pragma once
 
#ifndef CESIUM_OVERRIDE_TRACING
 
// If the build system doesn't enable the tracing support
// consider it disabled by default.
#ifndef CESIUM_TRACING_ENABLED
#define CESIUM_TRACING_ENABLED 0
#endif
 
#if !CESIUM_TRACING_ENABLED
 
#define CESIUM_TRACE_INIT(filename)
#define CESIUM_TRACE_SHUTDOWN()
#define CESIUM_TRACE(name)
#define CESIUM_TRACE_BEGIN(name)
#define CESIUM_TRACE_END(name)
#define CESIUM_TRACE_BEGIN_IN_TRACK(name)
#define CESIUM_TRACE_END_IN_TRACK(name)
#define CESIUM_TRACE_DECLARE_TRACK_SET(id, name)
#define CESIUM_TRACE_USE_TRACK_SET(id)
#define CESIUM_TRACE_LAMBDA_CAPTURE_TRACK() tracingTrack = false
#define CESIUM_TRACE_USE_CAPTURED_TRACK()
 
#else
 
#include <atomic>
#include <chrono>
#include <fstream>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
// helper macros to avoid shadowing variables
#define TRACE_NAME_AUX1(A, B) A##B
#define TRACE_NAME_AUX2(A, B) TRACE_NAME_AUX1(A, B)
 
#define CESIUM_TRACE_INIT(filename)                                            \
  CesiumUtility::CesiumImpl::Tracer::instance().startTracing(filename)
 
#define CESIUM_TRACE_SHUTDOWN()                                                \
  CesiumUtility::CesiumImpl::Tracer::instance().endTracing()
 
#define CESIUM_TRACE(name)                                                     \
  CesiumUtility::CesiumImpl::ScopedTrace TRACE_NAME_AUX2(                      \
      cesiumTrace,                                                             \
      __LINE__)(name)
 
#define CESIUM_TRACE_BEGIN(name)                                               \
  CesiumUtility::CesiumImpl::Tracer::instance().writeAsyncEventBegin(name)
 
#define CESIUM_TRACE_END(name)                                                 \
  CesiumUtility::CesiumImpl::Tracer::instance().writeAsyncEventEnd(name)
 
#define CESIUM_TRACE_BEGIN_IN_TRACK(name)                                      \
  if (CesiumUtility::CesiumImpl::TrackReference::current() != nullptr) {       \
    CESIUM_TRACE_BEGIN(name);                                                  \
  }
 
#define CESIUM_TRACE_END_IN_TRACK(name)                                        \
  if (CesiumUtility::CesiumImpl::TrackReference::current() != nullptr) {       \
    CESIUM_TRACE_END(name);                                                    \
  }
 
#define CESIUM_TRACE_DECLARE_TRACK_SET(id, name)                               \
  CesiumUtility::CesiumImpl::TrackSet id { name }
 
#define CESIUM_TRACE_USE_TRACK_SET(id)                                         \
  CesiumUtility::CesiumImpl::TrackReference TRACE_NAME_AUX2(                   \
      cesiumTraceEnlistTrack,                                                  \
      __LINE__)(id);
 
#define CESIUM_TRACE_LAMBDA_CAPTURE_TRACK()                                    \
  tracingTrack = CesiumUtility::CesiumImpl::LambdaCaptureTrack()
 
#define CESIUM_TRACE_USE_CAPTURED_TRACK()                                      \
  CESIUM_TRACE_USE_TRACK_SET(tracingTrack)
 
namespace CesiumUtility {
namespace CesiumImpl {
 
// The following are internal classes used by the tracing framework, do not use
// directly.
 
struct Trace {
  std::string name;
  int64_t start;
  int64_t duration;
  std::thread::id threadID;
};
 
class TrackReference;
 
class Tracer {
public:
  static Tracer& instance();
 
  ~Tracer();
 
  void startTracing(const std::string& filePath = "trace.json");
  void endTracing();
 
  void writeCompleteEvent(const Trace& trace);
  void writeAsyncEventBegin(const char* name, int64_t id);
  void writeAsyncEventBegin(const char* name);
  void writeAsyncEventEnd(const char* name, int64_t id);
  void writeAsyncEventEnd(const char* name);
 
  int64_t allocateTrackID();
 
private:
  Tracer();
 
  int64_t getCurrentThreadTrackID() const;
  void writeAsyncEvent(
      const char* category,
      const char* name,
      char type,
      int64_t id);
 
  std::ofstream _output;
  uint32_t _numTraces;
  std::mutex _lock;
  std::atomic<int64_t> _lastAllocatedID;
};
 
class ScopedTrace {
public:
  explicit ScopedTrace(const std::string& message);
  ~ScopedTrace();
 
  void reset();
 
  ScopedTrace(const ScopedTrace& rhs) = delete;
  ScopedTrace(ScopedTrace&& rhs) = delete;
  ScopedTrace& operator=(const ScopedTrace& rhs) = delete;
  ScopedTrace& operator=(ScopedTrace&& rhs) = delete;
 
private:
  std::string _name;
  std::chrono::steady_clock::time_point _startTime;
  std::thread::id _threadId;
  bool _reset;
};
 
class TrackSet {
public:
  explicit TrackSet(const char* name);
  ~TrackSet();
 
  size_t acquireTrack();
  void addReference(size_t trackIndex) noexcept;
  void releaseReference(size_t trackIndex) noexcept;
 
  int64_t getTracingID(size_t trackIndex) noexcept;
 
  TrackSet(TrackSet&& rhs) noexcept;
  TrackSet& operator=(TrackSet&& rhs) noexcept;
 
private:
  struct Track {
    Track(int64_t id_, bool inUse_)
        : id(id_), referenceCount(0), inUse(inUse_) {}
 
    int64_t id;
    int32_t referenceCount;
    bool inUse;
  };
 
  std::string name;
  std::vector<Track> tracks;
  std::mutex mutex;
};
 
class LambdaCaptureTrack {
public:
  LambdaCaptureTrack();
  LambdaCaptureTrack(LambdaCaptureTrack&& rhs) noexcept;
  LambdaCaptureTrack(const LambdaCaptureTrack& rhs) noexcept;
  ~LambdaCaptureTrack();
  LambdaCaptureTrack& operator=(const LambdaCaptureTrack& rhs) noexcept;
  LambdaCaptureTrack& operator=(LambdaCaptureTrack&& rhs) noexcept;
 
private:
  TrackSet* pSet;
  size_t index;
 
  friend class TrackReference;
};
 
// An RAII object to reference an async operation track.
// When the last instance associated with a particular track index is destroyed,
// the track is released back to the track set.
class TrackReference {
public:
  static TrackReference* current();
 
  TrackReference(TrackSet& set) noexcept;
  TrackReference(TrackSet& set, size_t index) noexcept;
  TrackReference(const LambdaCaptureTrack& lambdaCapture) noexcept;
  ~TrackReference() noexcept;
 
  operator bool() const noexcept;
  int64_t getTracingID() const noexcept;
 
  TrackReference(const TrackReference& rhs) = delete;
  TrackReference(TrackReference&& rhs) = delete;
  TrackReference& operator=(const TrackReference& rhs) = delete;
  TrackReference& operator=(TrackReference&& rhs) = delete;
 
private:
  void enlistCurrentThread();
  void dismissCurrentThread();
 
  TrackSet* pSet;
  size_t index;
 
  static thread_local std::vector<TrackReference*> _threadEnlistedTracks;
 
  friend class LambdaCaptureTrack;
};
 
} // namespace CesiumImpl
} // namespace CesiumUtility
 
#endif // CESIUM_TRACING_ENABLED
 
#endif