gpuperformance.h

Go to the documentation of this file.

#ifndef ION_ANALYTICS_GPUPERFORMANCE_H_
#define ION_ANALYTICS_GPUPERFORMANCE_H_

#if !ION_PRODUCTION

#include <functional>
#include <ostream>  // NOLINT
#include <utility>
#include <vector>

#include "base/integral_types.h"
#include "ion/analytics/benchmark.h"
#include "ion/external/gtest/gunit_prod.h"  // For FRIEND_TEST().
#include "ion/gfx/graphicsmanager.h"
#include "ion/gfx/node.h"
#include "ion/gfx/renderer.h"

namespace ion {
namespace analytics {

class ION_API GpuPerformanceTester {
 public:
  static const double kInvalidValue;


  enum Enables {
    kNoEnables       = 0x00,
    kConstants       = 0x01,
    kBaseline        = 0x02,
    kNoDraw          = 0x04,
    kMinimumViewport = 0x08,
    kResource        = 0x10,
    kGpuMemory       = 0x20,
    kGlTrace         = 0x40,
    kAllEnables      = 0x7F
  };

  struct Measurement {
    Measurement(double mean_value, double standard_deviation,
                double reciprocal_mean, double reciprocal_deviation,
                double minimum_value, double maximum_value)
      : mean(mean_value),
        deviation(standard_deviation),
        inverse_mean(reciprocal_mean),
        inverse_deviation(reciprocal_deviation),
        minimum(minimum_value), maximum(maximum_value) {}
    double mean;
    double deviation;
    double inverse_mean;
    double inverse_deviation;
    double minimum;
    double maximum;
  };


  enum ConstantIndices {
    kNodeCount,
    kShapeCount,
    kDrawCount,
    kVertexCount,
    kPrimitiveCount,
    kTriangleCount,
    kLineCount,
    kPointCount,
    kTrianglePercent,
    kLinePercent,
    kPointPercent,
    kVerticesPerShape,
    kPrimitivesPerShape,
    kTrialCount,
    kBindShaderCount,
    kBindTextureCount,
    kSetUniformCount,
    kBufferMemory,
    kFboMemory,
    kTextureMemory,
    kFrameBufferMemory,
    kTotalGpuMemory
  };


  enum VariableIndices {
    kFramesPerSecond,
    kNodesPerSecond,
    kShapesPerSecond,
    kDrawCallsPerSecond,
    kVerticesPerSecond,
    kPrimitivesPerSecond,
    kPixelsPerSecond,
    kRenderTime,
    kResourceCreation,
    kNoDrawCalls,
    kMinViewport,
    kTransformRate,
    kFillRate,
    kTraversalPercent,
    kTransformPercent,
    kFillPercent
  };

  GpuPerformanceTester(uint32 width, uint32 height);
  virtual ~GpuPerformanceTester();

  void SetEnables(Enables enables);
  Enables GetEnables() const { return enables_; }
  bool AreModesEnabled(Enables enables) const {
    return (enables_ & enables) == enables;
  }

  virtual const Benchmark RunAllMeasurements(
      const gfx::NodePtr& scene,
      const gfx::GraphicsManagerPtr& graphics_manager,
      const gfx::RendererPtr& renderer);

  virtual void AccumulateMeasurements(
      const gfx::NodePtr& scene,
      const gfx::GraphicsManagerPtr& graphics_manager,
      const gfx::RendererPtr& renderer);

  virtual const Benchmark GetResults();

  int GetTrialCount() const { return number_of_trials_; }
  void SetTrialCount(int number_of_trials) {
    number_of_trials_ = number_of_trials;
  }

 protected:
  virtual Measurement MeasurePerformance(
      const gfx::NodePtr& scene,
      const gfx::GraphicsManagerPtr& graphics_manager,
      const gfx::RendererPtr& renderer);

  virtual Measurement MeasureBaseline(
      const gfx::NodePtr& scene,
      const gfx::GraphicsManagerPtr& graphics_manager,
      const gfx::RendererPtr& renderer);

  virtual Measurement MeasureMinViewportSpeed(
      const gfx::NodePtr& scene,
      const gfx::GraphicsManagerPtr& graphics_manager,
      const gfx::RendererPtr& renderer);

  virtual Measurement MeasureStateChanges(
      const gfx::NodePtr& scene,
      const gfx::GraphicsManagerPtr& graphics_manager,
      const gfx::RendererPtr& renderer);

  virtual Measurement MeasureResourceCreation(
      const gfx::NodePtr& scene,
      const gfx::GraphicsManagerPtr& graphics_manager);

  static gfx::NodePtr InstanceCopy(const gfx::NodePtr& scene);

  uint32 number_of_trials_;
  uint32 width_;
  uint32 height_;

  Enables enables_;

  Benchmark benchmark_;

  int num_nodes_;
  int num_shapes_;
  int num_draws_;
  int num_vertices_;
  int num_triangles_;
  int num_lines_;
  int num_points_;
  size_t num_bind_shader_;
  size_t num_bind_texture_;
  size_t num_set_uniform_;
  size_t buffer_memory_;
  size_t fbo_memory_;
  size_t texture_memory_;
  size_t framebuffer_memory_;
  Benchmark::AccumulatedVariable baseline_;
  Benchmark::AccumulatedVariable baseline_inverse_;
  Benchmark::AccumulatedVariable resource_;
  Benchmark::AccumulatedVariable no_draw_calls_;
  Benchmark::AccumulatedVariable min_viewport_;
  Benchmark::AccumulatedVariable min_viewport_inverse_;

  FRIEND_TEST(GPUPerformanceTest, InstanceCopy);
};

inline GpuPerformanceTester::Enables operator|(
    GpuPerformanceTester::Enables left,
    GpuPerformanceTester::Enables right) {
  return static_cast<GpuPerformanceTester::Enables>(
        static_cast<int>(left) | static_cast<int>(right));
}

inline void GpuPerformanceTester::SetEnables(
    GpuPerformanceTester::Enables enables) {
  if ((enables & kResource) && (enables & kGpuMemory)) {
    enables = static_cast<GpuPerformanceTester::Enables>(
        static_cast<int>(enables) & ~static_cast<int>(kResource));
    LOG(WARNING) <<
        "GpuPerformanceTester: kResource and kGpuMemory are incompatible" <<
        std::endl << "Disabling kResource" << std::endl;
  }
  enables_ = enables;
}

}  // namespace analytics
}  // namespace ion

#endif  // ION_PRODUCTION

#endif  // ION_ANALYTICS_GPUPERFORMANCE_H_