UT_Tracing.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_Tracing header (C++)
 *
 * COMMENTS:    This class defines tracing macros that can be left
 *              in the source, as they pre-process to nothing if
 *              one of the tracing system macros is undefined.
 *
 */

#ifndef __UT_Tracing_h__
#define __UT_Tracing_h__

#include "UT_API.h"

#ifdef TRACY_ENABLE

#include "UT_NonCopyable.h"
#include "UT_NTUtil.h"  // for pid_t and getpid()
#include "UT_StringHolder.h"

// Tracy implementation.

// On-demand profiling.
#define TRACY_ON_DEMAND
// We manage profiler startup and shutdown.
#define TRACY_DELAYED_INIT
#define TRACY_MANUAL_LIFETIME

// Set up TRACY_API the same way we do for UT_API
#if !defined(MAKING_STATIC)
#ifdef UT_EXPORTS
#define TRACY_EXPORTS
#else
#define TRACY_IMPORTS
#endif
#endif

#include <tracy/tracy/Tracy.hpp>

class UT_API ut_TraceControl
{
public:
    // Flags for different types of traces.  To add a new type of trace,
    // add an enum here and a TRACYPARM call in the constructor.
    enum Flag
    {
        GENERIC,
        NODE_PATHS,
        CL_KERNELS,
        CL_MEMORY,
        NODE_COOKS,
        DOP_SOLVES,
        CL_FLUID,
        VIEWPORT,
        PYTHON_STATE,
        EVENT_QUEUE,
        HOUDINI_ENGINE,
        VK_COMMANDS,
    };

    ut_TraceControl();
    ~ut_TraceControl();

    UT_NON_COPYABLE(ut_TraceControl)

    static ut_TraceControl &get();

    bool flag(Flag f) const
    {
        return myFlags & (1u << f);
    }

    uint32_t setFlag(uint32_t idx, uint32_t val)
    {
        uint32_t bflag = (1u << idx);
        myFlags = val ? (myFlags | bflag) : (myFlags & ~bflag);
        return val;
    }

    void        shutdown();

private:

    uint32_t myFlags;
    pid_t    myPid;
};

// If the specific type of tracing is active.
#define utTraceFlag(F)                      ut_TraceControl::get().flag(ut_TraceControl::F)

// These macros match the Tracy suffix name:
// See the Tracy documentation for more: https://github.com/wolfpld/tracy
// N indicates a name
// S a stack trace to the specified depth
// C a specific color for the zone in the profiler UI

// Scoped zone tracing, supply a flag to specify the trace type.
#define utZoneScopedFlag(F)                 ZoneNamed( ___tracy_scoped_zone, utTraceFlag(F) )
#define utZoneScopedFlagN(F, name)          ZoneNamedN( ___tracy_scoped_zone, name, utTraceFlag(F) )
#define utZoneScopedFlagS(F, depth)         ZoneNamedS( ___tracy_scoped_zone,  depth, utTraceFlag(F) )
#define utZoneScopedFlagNS(F, name, depth)  ZoneNamedNS( ___tracy_scoped_zone, name, depth, utTraceFlag(F) )
#define utZoneScopedBool(b)                 ZoneNamed( ___tracy_scoped_zone, b )

// These zones show up for any trace type.
#define utZoneScoped                        utZoneScopedFlag(GENERIC)
#define utZoneScopedN(name)                 utZoneScopedFlagN(GENERIC, name)
// #define utZoneScopedC(color)                ZoneScopedC(color)
// #define utZoneScopedNC(name,color)          ZoneScopedNC(name,color)

#define utZoneScopedS(depth)                utZoneScopedFlagS(GENERIC, depth)
#define utZoneScopedNS(name,depth)          utZoneScopedFlagNS(GENERIC, name,depth)
//#define utZoneScopedCS(color,depth)         ZoneScopedCS(color,depth)
//#define utZoneScopedNCS(name,color,depth)   ZoneScopedNCS(name,color,depth)

// Attach user text, name, color, or user value to
// the current zone.
// SH takes a UT_StringHolder (anything that has c_str and length, really)
#define utZoneText(txt,size)                ZoneText(txt,size)
#define utZoneTextSH(sh)                    ZoneText((sh).c_str(),(sh).length())
#define utZoneName(name,size)               ZoneName(name,size)
#define utZoneNameSH(sh)                    ZoneName((sh).c_str(),(sh).length())
#define utZoneColor(color)                  ZoneColor(color)
#define utZoneValue(value)                  ZoneValue(value)
#define utZoneIsActive                      ZoneIsActive

// Mark a frame, possibly with a type of frame.
#define utFrameMark                         FrameMark
#define utFrameMarkNamed(x)                 FrameMarkNamed(x)

#define utTracePlot(name,val)               TracyPlot(name,val)
// Confifgure plot as num, memory, or percent.
#define utTracePlotConfigNum(name)          TracyPlotConfig(name,tracy::PlotFormatType::Number)
#define utTracePlotConfigMem(name)          TracyPlotConfig(name,tracy::PlotFormatType::Memory)
#define utTracePlotConfigPct(name)          TracyPlotConfig(name,tracy::PlotFormatType::Percentage)

// Add a trace message to the profiler, will attach
// to the current zone.
// L is literal, else you need to supply a size.
#define utTraceMessage(txt,size)            TracyMessage(txt,size)
#define utTraceMessageSH(sh)                TracyMessage((sh).c_str(),(sh).length())
#define utTraceMessageL(txt)                TracyMessageL(txt)
#define utTraceMessageC(txt,size,color)     TracyMessageC(txt,size,color)
#define utTraceMessageSHC(sh,color)         TracyMessageC((sh).c_str(),(sh).length(),color)
#define utTraceMessageLC(txt,color)         TracyMessageLC(txt,color)

#define utTraceMessageS(txt,size,depth)     TracyMessageS(txt,size,depth)
#define utTraceMessageSHS(sh,depth)         TracyMessageS((sh).c_str(),(sh).length(),depth)
#define utTraceMessageLS(txt,depth)         TracyMessageLS(txt,depth)
#define utTraceMessageCS(txt,size,color,d)  TracyMessageCS(txt,size,color,d)
#define utTraceMessageSHCS(sh,color,d)      TracyMessageCS((sh).c_str(),(sh).length(),color,d)
#define utTraceMessageLCS(txt,color,depth)  TracyMessageLCS(txt,color,depth)

#define utTraceMessageFlag(F,txt,size)         if(utTraceFlag(F)) TracyMessage(txt,size)
#define utTraceMessageFlagSH(F,sh)             if(utTraceFlag(F)) TracyMessage((sh).c_str(),(sh).length())
#define utTraceMessageFlagL(F,txt)             if(utTraceFlag(F)) TracyMessageL(txt)
#define utTraceMessageFlagLC(F,txt,color)      if(utTraceFlag(F)) TracyMessageLC(txt,color)
#define utTraceMessageFlagC(F,txt,size,color)  if(utTraceFlag(F)) TracyMessageC(txt,size,color)
#define utTraceMessageFlagSHC(F,sh,color)      if(utTraceFlag(F)) TracyMessageC((sh).c_str(),(sh).length(),color)

#define utTraceMessageFlagS(F,txt,size,depth)     if(utTraceFlag(F)) TracyMessageS(txt,size,depth)
#define utTraceMessageFlagSHS(F,sh,depth)         if(utTraceFlag(F)) TracyMessageS((sh).c_str(),(sh).length(),depth)
#define utTraceMessageFlagLS(F,txt,depth)         if(utTraceFlag(F)) TracyMessageLS(txt,depth)
#define utTraceMessageFlagLCS(F,txt,color,depth)  if(utTraceFlag(F)) TracyMessageLCS(txt,color,depth)
#define utTraceMessageFlagCS(F,txt,size,color,d)  if(utTraceFlag(F)) TracyMessageCS(txt,size,color,d)
#define utTraceMessageFlagSHCS(F,sh,color,d)      if(utTraceFlag(F)) TracyMessageCS((sh).c_str(),(sh).length(),color,d)

// Memory tracing.
#define utTraceAlloc(ptr,size)              TracyAlloc(ptr,size)
#define utTraceFree(ptr)                    TracyFree(ptr)
#define utTraceAllocN(ptr,size,name)        TracyAllocN(ptr,size,name)
#define utTraceFreeN(ptr,name)              TracyFreeN(ptr,name)

#define utTraceAllocS(ptr,size,depth)       TracyAllocS(ptr, size, depth)
#define utTraceFreeS(ptr,depth)             TracyFreeS(ptr, depth)
#define utTraceAllocNS(ptr,size,depth,name) TracyAllocNS(ptr, size, depth, name)
#define utTraceFreeNS(ptr,depth,name)       TracyFreeNS(ptr, depth, name)

// Query if the profiler is connected.
#define utTraceIsConnected                  TracyIsConnected

// Tests if the profiler
// has been started at all via tracy::StartupProfiler()
// in the static ut_TraceControl constructor.
// If a zone might be called during static construction
// it should be guarded with
// if (utIsStarted)
// otherwise its call to tracy::getProfiler might crash
// if ut_TraceControl hasn't been constructed yet.
#define utTraceIsStarted                    TracyIsStarted

// Set the zone name to the node name
#define utZoneScopedNodeFlag(F, node)       ZoneNamed( ___tracy_scoped_zone, utTraceFlag(F) ); \
                                            if (node) utZoneNameSH(node->getName());
// Set the zone name to the node name, optionally setting the zone text to the full path.
// Only do if the zone is active (flag true and isconnected) since getFullPath is expensive.
#define utZoneScopedNodeFlagP(F, node)      utZoneScopedNodeFlag(F, node) \
                                            if (utZoneIsActive && node && utTraceFlag(NODE_PATHS)) { \
                                            UT_StringHolder ___zonetext = node->getFullPath(); \
                                            utZoneTextSH(___zonetext);}

#define utTraceViewportDrawEvent(viewport, event) utZoneScopedFlag(VIEWPORT);                                  \
                                                    if (utZoneIsActive) {                                      \
                                                        utZoneNameSH(UT_StringHolder(viewport));               \
                                                        utZoneTextSH(UT_StringHolder(event)); }


#else

#define utTraceFlag(F)                      false

#define utZoneScopedFlag(F)
#define utZoneScopedFlagN(F, name)
#define utZoneScopedFlagS(F, depth)
#define utZoneScopedFlagNS(F, name, depth)
#define utZoneScopedBool(b)

#define utZoneScoped
#define utZoneScopedN(name)
#define utZoneScopedC(color)
#define utZoneScopedNC(name,color)

#define utZoneScopedS(depth)
#define utZoneScopedNS(name,depth)
#define utZoneScopedCS(color,depth)
#define utZoneScopedNCS(name,color,depth)

#define utZoneText(txt,size)
#define utZoneTextSH(sh)
#define utZoneName(name,size)
#define utZoneNameSH(sh)
#define utZoneColor(color)
#define utZoneValue(value)
#define utZoneIsActive false

#define utFrameMark
#define utFrameMarkNamed(x)

#define utTracePlot(name,val)
#define utTracePlotConfigNum(name)
#define utTracePlotConfigMem(name)
#define utTracePlotConfigPct(name)

#define utTraceMessage(txt,size)
#define utTraceMessageSH(sh)
#define utTraceMessageL(txt)
#define utTraceMessageC(txt,size,color)
#define utTraceMessageSHC(sh,color)
#define utTraceMessageLC(txt,color)

#define utTraceMessageS(txt,size,depth)
#define utTraceMessageSHS(sh,depth)
#define utTraceMessageLS(txt,depth)
#define utTraceMessageCS(txt,size,color,d)
#define utTraceMessageSHCS(sh,color,d)
#define utTraceMessageLCS(txt,color,depth)

#define utTraceMessageFlag(F,txt,size)
#define utTraceMessageFlagSH(F,sh)
#define utTraceMessageFlagL(F,txt)
#define utTraceMessageFlagLC(F,txt,color)
#define utTraceMessageFlagC(F,txt,size,color)
#define utTraceMessageFlagSHC(F,sh,color)

#define utTraceMessageFlagS(F,txt,size,depth)
#define utTraceMessageFlagSHS(F,sh,depth)
#define utTraceMessageFlagLS(F,txt,depth)
#define utTraceMessageFlagLCS(F,txt,color,depth)
#define utTraceMessageFlagCS(F,txt,size,color,d)
#define utTraceMessageFlagSHCS(F,sh,color,d)

#define utTraceAlloc(ptr,size)
#define utTraceFree(ptr)
#define utTraceAllocN(ptr,size,name)
#define utTraceFreeN(ptr,name)

#define utTraceAllocS(ptr,size,depth)
#define utTraceFreeS(ptr,depth)
#define utTraceAllocNS(ptr,size,depth,name)
#define utTraceFreeNS(ptr,depth,name)

#define utTraceIsConnected                  false
#define utTraceIsStarted                    false

#define utZoneScopedNodeFlag(F, node)
#define utZoneScopedNodeFlagP(F, node)

#define utTraceViewportDrawEvent(viewport, event)

#endif

#endif // UT_ASSERT_H_INCLUDED