gpuprofiler.h

Go to the documentation of this file.

#ifndef ION_GFXPROFILE_GPUPROFILER_H_
#define ION_GFXPROFILE_GPUPROFILER_H_


#include <deque>
#include <stack>
#include <vector>

#include "base/integral_types.h"
#include "ion/base/staticsafedeclare.h"
#include "ion/gfx/graphicsmanager.h"
#include "ion/profile/calltracemanager.h"
#include "ion/profile/profiling.h"
#include "ion/profile/tracerecorder.h"

namespace ion {
namespace profile {
class CallTraceTest;
}  // namespace profile
namespace gfxprofile {

class GpuProfiler {
 public:
  static GpuProfiler* Get();

  GpuProfiler();
  ~GpuProfiler();

  bool IsGpuProfilingSupported(const ion::gfx::GraphicsManagerPtr& gfx_mgr)
      const;

  void SetGraphicsManager(const gfx::GraphicsManagerPtr& gfx_mgr);

  void SetEnableGpuTracing(bool enabled) {
    enable_gpu_tracing_ = enabled;
  }

  gfx::GraphicsManager* GetGraphicsManagerOrNull() const {
    if (enable_gpu_tracing_) {
      return graphics_manager_.Get();
    } else {
      return NULL;
    }
  }

  void PollGlTimerQueries();

  void EnterGlScope(uint32 id);

  void LeaveGlScope();

 private:
  struct GpuTimerQuery {
    enum QueryType {
      kQueryBeginFrame,
      kQueryBeginScope,
      kQueryEndScope,
    };

    GpuTimerQuery(uint64 timestamp_ns,
                  int scope_id,
                  GLuint query_id,
                  QueryType type)
        : cpu_timestamp_ns(timestamp_ns),
          scope_event_id(scope_id),
          gl_query_id(query_id),
          query_type(type) {}

    uint64 cpu_timestamp_ns;
    int scope_event_id;
    GLuint gl_query_id;
    QueryType query_type;
  };

  explicit GpuProfiler(ion::profile::CallTraceManager* manager);

  void SyncGlTimebase();

  GLuint TryAllocateGlQueryId();

  ion::profile::CallTraceManager* manager_;

  base::Setting<bool> enable_gpu_tracing_;

  int64 gl_timer_offset_ns_;

  gfx::GraphicsManagerPtr graphics_manager_;

  std::deque<GpuTimerQuery> pending_gpu_queries_;

  std::stack<GLuint, std::vector<GLuint> > gl_timer_query_id_pool_;

  friend class ion::profile::CallTraceTest;
};

class ScopedGlTracer {
 public:
  ScopedGlTracer(GpuProfiler* profiler, int id) : profiler_(profiler) {
    profiler_->EnterGlScope(id);
  }

  ~ScopedGlTracer() {
    profiler_->LeaveGlScope();
  }

 private:
  GpuProfiler* profiler_;
};

}  // namespace gfxprofile
}  // namespace ion

#if ION_PRODUCTION
#define ION_PROFILE_GPU(group_name)
#else
#define ION_PROFILE_GPU(group_name)                                            \
    /* Force compilation to fail if group_name is not a literal string */      \
    (void) group_name " must be a literal string.";                            \
    ION_PROFILE_FUNCTION(group_name);                                          \
    ION_DECLARE_SAFE_STATIC_POINTER_WITH_CONSTRUCTOR(                          \
        int, ION_PROFILING_PASTE3(gpu_scope_event_id_),                        \
        new int(::ion::profile::GetCallTraceManager()->                        \
            GetScopeEnterEvent("GPU_" group_name)));                           \
    ::ion::gfxprofile::ScopedGlTracer ION_PROFILING_PASTE3(gpu_scope_tracer_)( \
        ::ion::gfxprofile::GpuProfiler::Get(),                                 \
        *ION_PROFILING_PASTE3(gpu_scope_event_id_))
#endif  // ION_PRODUCTION

#endif  // ION_GFXPROFILE_GPUPROFILER_H_