vtkRenderTimerLog.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkRenderTimerLog.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/

#ifndef vtkRenderTimerLog_h
#define vtkRenderTimerLog_h

#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkType.h" // For vtkTypeUint64, etc
#include <sstream> // for std::ostringstream
#include <string> // for std::string
#include <vector> // for std::vector

#define VTK_SCOPED_RENDER_EVENT(eventName, timer) \
  VTK_SCOPED_RENDER_EVENT2(eventName, timer, _event)

#define VTK_SCOPED_RENDER_EVENT2(eventName, timer, identifier) \
  vtkRenderTimerLog::ScopedEventLogger identifier; \
  do \
  { \
    std::ostringstream _eventNameStream; \
    _eventNameStream << eventName; \
    identifier = timer->StartScopedEvent(_eventNameStream.str()); \
    (void)identifier; /* Prevent set-but-not-used var warnings */ \
  } while (false) /* Do-while loop prevents duplicate semicolon warnings */

class VTKRENDERINGCORE_EXPORT vtkRenderTimerLog : public vtkObject
{
public:
  struct Frame;

  struct VTKRENDERINGCORE_EXPORT Event
  {
    std::string Name;

    vtkTypeUInt64 StartTime;
    vtkTypeUInt64 EndTime;
    float ElapsedTimeSeconds() const
      { return this->ElapsedTimeNanoseconds() * 1e-9f; }
    float ElapsedTimeMilliseconds() const
    { return this->ElapsedTimeNanoseconds() * 1e-6f; }
    vtkTypeUInt64 ElapsedTimeNanoseconds() const
      { return this->EndTime - this->StartTime; }

    std::vector<Event> Events;

    void Print(std::ostream &os, float threshMs = 0.f,
               vtkIndent indent = vtkIndent())
    {
      this->Print(os, 0.f, threshMs, indent);
    }

    friend struct vtkRenderTimerLog::Frame;

  protected:
    void Print(std::ostream &os, float parentTime, float threshMs,
               vtkIndent indent);
  };

  struct VTKRENDERINGCORE_EXPORT Frame
  {
    std::vector<Event> Events;

    void Print(std::ostream &os, float threshMs = 0.f);
  };

  struct VTKRENDERINGCORE_EXPORT ScopedEventLogger
  {
    ScopedEventLogger() : Log(nullptr) {}
    ScopedEventLogger(ScopedEventLogger &&other);
    ScopedEventLogger& operator=(ScopedEventLogger &&other);
    ~ScopedEventLogger() { this->Stop(); }
    void Stop();
    friend class vtkRenderTimerLog;
  protected:
    ScopedEventLogger(vtkRenderTimerLog *log) : Log(log) {}
  private:
    void operator=(const ScopedEventLogger&) = delete;
    ScopedEventLogger(const ScopedEventLogger &other) = delete;
    vtkRenderTimerLog *Log;
  };

  static vtkRenderTimerLog* New();
  vtkTypeMacro(vtkRenderTimerLog, vtkObject)
  void PrintSelf(ostream &os, vtkIndent indent) override;

  virtual bool IsSupported();

  virtual void MarkFrame();

  ScopedEventLogger StartScopedEvent(const std::string &name);

  virtual void MarkStartEvent(const std::string &name);
  virtual void MarkEndEvent();
  virtual bool FrameReady();

  virtual Frame PopFirstReadyFrame();

  vtkSetMacro(LoggingEnabled, bool)
  vtkGetMacro(LoggingEnabled, bool)
  vtkBooleanMacro(LoggingEnabled, bool)
  vtkSetMacro(FrameLimit, unsigned int)
  vtkGetMacro(FrameLimit, unsigned int)
  virtual void ReleaseGraphicsResources();

protected:
  vtkRenderTimerLog();
  ~vtkRenderTimerLog() override;

  bool LoggingEnabled;
  unsigned int FrameLimit;

private:
  vtkRenderTimerLog(const vtkRenderTimerLog&) = delete;
  void operator=(const vtkRenderTimerLog&) = delete;
};

#endif // vtkRenderTimerLog_h