stats.h

Go to the documentation of this file.

/*
 * Copyright 2011-2018 Blender Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __RENDER_STATS_H__
#define __RENDER_STATS_H__
 
#include "render/scene.h"
 
#include "util/util_stats.h"
#include "util/util_string.h"
#include "util/util_vector.h"
 
CCL_NAMESPACE_BEGIN
 
/* Named statistics entry, which corresponds to a size. There is no real
 * semantic around the units of size, it just should be the same for all
 * entries.
 *
 * This is a generic entry for all size-related statistics, which helps
 * avoiding duplicating code for things like sorting.
 */
class NamedSizeEntry {
 public:
  NamedSizeEntry();
  NamedSizeEntry(const string &name, size_t size);
 
  string name;
  size_t size;
};
 
class NamedTimeEntry {
 public:
  NamedTimeEntry();
  NamedTimeEntry(const string &name, double time);
 
  string name;
  double time;
};
 
/* Container of named size entries. Used, for example, to store per-mesh memory
 * usage statistics. But also keeps track of overall memory usage of the
 * container.
 */
class NamedSizeStats {
 public:
  NamedSizeStats();
 
  /* Add entry to the statistics. */
  void add_entry(const NamedSizeEntry &entry);
 
  /* Generate full human-readable report. */
  string full_report(int indent_level = 0);
 
  /* Total size of all entries. */
  size_t total_size;
 
  /* NOTE: Is fine to read directly, but for adding use add_entry(), which
   * makes sure all accumulating  values are properly updated.
   */
  vector<NamedSizeEntry> entries;
};
 
class NamedTimeStats {
 public:
  NamedTimeStats();
 
  /* Add entry to the statistics. */
  void add_entry(const NamedTimeEntry &entry)
  {
    total_time += entry.time;
    entries.push_back(entry);
  }
 
  /* Generate full human-readable report. */
  string full_report(int indent_level = 0);
 
  /* Total time of all entries. */
  double total_time;
 
  /* NOTE: Is fine to read directly, but for adding use add_entry(), which
   * makes sure all accumulating  values are properly updated.
   */
  vector<NamedTimeEntry> entries;
 
  void clear()
  {
    total_time = 0.0;
    entries.clear();
  }
};
 
class NamedNestedSampleStats {
 public:
  NamedNestedSampleStats();
  NamedNestedSampleStats(const string &name, uint64_t samples);
 
  NamedNestedSampleStats &add_entry(const string &name, uint64_t samples);
 
  /* Updates sum_samples recursively. */
  void update_sum();
 
  string full_report(int indent_level = 0, uint64_t total_samples = 0);
 
  string name;
 
  /* self_samples contains only the samples that this specific event got,
   * while sum_samples also includes the samples of all sub-entries. */
  uint64_t self_samples, sum_samples;
 
  vector<NamedNestedSampleStats> entries;
};
 
/* Named entry containing both a time-sample count for objects of a type and a
 * total count of processed items.
 * This allows to estimate the time spent per item. */
class NamedSampleCountPair {
 public:
  NamedSampleCountPair(const ustring &name, uint64_t samples, uint64_t hits);
 
  ustring name;
  uint64_t samples;
  uint64_t hits;
};
 
/* Contains statistics about pairs of samples and counts as described above. */
class NamedSampleCountStats {
 public:
  NamedSampleCountStats();
 
  string full_report(int indent_level = 0);
  void add(const ustring &name, uint64_t samples, uint64_t hits);
 
  typedef unordered_map<ustring, NamedSampleCountPair, ustringHash> entry_map;
  entry_map entries;
};
 
/* Statistics about mesh in the render database. */
class MeshStats {
 public:
  MeshStats();
 
  /* Generate full human-readable report. */
  string full_report(int indent_level = 0);
 
  /* Input geometry statistics, this is what is coming as an input to render
   * from. say, Blender. This does not include runtime or engine specific
   * memory like BVH.
   */
  NamedSizeStats geometry;
};
 
/* Statistics about images held in memory. */
class ImageStats {
 public:
  ImageStats();
 
  /* Generate full human-readable report. */
  string full_report(int indent_level = 0);
 
  NamedSizeStats textures;
};
 
/* Render process statistics. */
class RenderStats {
 public:
  RenderStats();
 
  /* Return full report as string. */
  string full_report();
 
  /* Collect kernel sampling information from Stats. */
  void collect_profiling(Scene *scene, Profiler &prof);
 
  bool has_profiling;
 
  MeshStats mesh;
  ImageStats image;
  NamedNestedSampleStats kernel;
  NamedSampleCountStats shaders;
  NamedSampleCountStats objects;
};
 
class UpdateTimeStats {
 public:
  /* Generate full human-readable report. */
  string full_report(int indent_level = 0);
 
  NamedTimeStats times;
};
 
class SceneUpdateStats {
 public:
  SceneUpdateStats();
 
  UpdateTimeStats geometry;
  UpdateTimeStats image;
  UpdateTimeStats light;
  UpdateTimeStats object;
  UpdateTimeStats background;
  UpdateTimeStats bake;
  UpdateTimeStats camera;
  UpdateTimeStats film;
  UpdateTimeStats integrator;
  UpdateTimeStats osl;
  UpdateTimeStats particles;
  UpdateTimeStats scene;
  UpdateTimeStats svm;
  UpdateTimeStats tables;
  UpdateTimeStats procedurals;
 
  string full_report();
 
  void clear();
};
 
CCL_NAMESPACE_END
 
#endif /* __RENDER_STATS_H__ */