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