BRAY_Stats.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:        BRAY_Stats.h (BRAY Library, C++)
 *
 * COMMENTS:
 */

#ifndef __BRAY_Stats__
#define __BRAY_Stats__

#include "BRAY_API.h"
#include "BRAY_Types.h"
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Rect.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_JSONValue.h>

class BRAY_StatsImpl;
class BRAY_Renderer;

namespace BRAY
{

class BRAY_API Stats
    : UT_NonCopyable
{
public:
     Stats(const BRAY_Renderer &renderer);
    ~Stats();

    enum Key
    {
        // System information
        USERNAME,               // User name
        HOSTNAME,               // Host name
        KARMA_VERSION,          // Karma version
        SYSTEM_THREADS,         // Thread count
        SYSTEM_CPU_BRAND,       // CPU brand
        SYSTEM_CPU_ARCHITECTURE,// CPU architecture
        SYSTEM_MEMORY,          // Current system memory usage
        SYSTEM_TIME,            // Current system times
        SYSTEM_RESOURCE_USAGE,  // Current system resource usage

        // Global render state
        ENGINE,                 // Rendering engine (cpu or xpu)
        XPU_DEVICE_COUNT,       // XPU device count

        RENDER_SETTINGS,        // JSON string of all global render settings

        RENDER_CAMERA,          // Path to render camera
        DICING_CAMERA,          // Path to dicing camera
        RESOLUTION,             // Image resoution

        WORLD_TO_CAMERA,        // World to camera transform
        WORLD_TO_SCREEN,        // World to screen transform
        WORLD_TO_NDC,           // World to NDC transform
        WORLD_TO_RASTER,        // World to raster space transform

        CAMERA_NEAR_FAR,        // Camera near/far clipping planes

        AOV_BUFFERS,            // AOV Buffer dictionary
        AOV_RASTER_MEMORY,      // Current/Peak memory used by rasters
        DEEP_IMAGE_MEMORY,      // Current/peak deep memory

        // Texture information
        UNIFIED_CACHE,          // Unified cache information
        TEXTURE_ERROR_FILES,    // List of bad texture paths
        TEXTURE_CONVERSIONS,    // Textures converted interanally

        RAT_STATS,              // Number of .rat textures
        RAT_DISK_CACHE,         // RAT file disk cache performance
        RAT_DISK_CACHE_ERRORS,  // RAT file disk cache conversions

        OIIO_STATS,             // OIIO texture stats
        OIIO_STATS_STRING,      // OIIO stats string (direct from OIIO)

        PTEX_STATS,             // Ptex texture stats

        // USD information
        OBJECT_COUNTS,          // Object counts in the scene
        GEOMETRY_COUNTS,        // Geometry prim counts in the scene
        LIGHT_TYPES,            // Counts for different light types
        PRIMVAR_CACHE,          // Information about primvar cache

        // Rendering state information
        PERCENT_COMPLETE,       // Percent complete (0-1)
        RENDER_STAGE,           // Stage of rendering (inactive, loading, etc.)
        RENDER_STAGE_LABEL,     // Stage of rendering (inactive, loading, etc.)
        LOAD_TIME,              // Time to load scene
        LOAD_MEMORY,            // Memory after load
        TTFP,                   // Time to first pixel
        FILTER_ERRORS,          // Errors in pixel/image filters (denoisers)

        // Karma CPU
        SHADER_CALLS,           // Number of shader calls
        SHADER_NODES,           // Number of shader graph nodes
        RAY_COUNTS,             // Primary, indirect, occlusion, etc.
        TIMINGS,                // Breakdown of time

        // Karma XPU
        XPU_COMPILES,           // XPU compile information
        XPU_TIMINGS,            // XPU-specific timings

        STOCHASTIC_DEPTH,       // Depth of stochastic transparency
        RAY_DEPTHS,             // Distribution of ray-depths
        RAY_DEPTHS_PERCENTAGE,  // Distribution of ray-depths
        RAY_BATCH_EFFICIENCY,   // Batch efficiency

        // Checkpointing
        CHECKPOINT_STATS,       // Checkpoint stats

        // Render progress
        ACTIVE_BUCKETS,         // Active buckets list

        // Annoatations (backward compatibility)
        PROGRESS_ANNOTATION,    // Progress
        STATS_ANNOTATION,       // XPU Stats

        MAX_KEYS                // Sentinal
    };

    enum DeviceKey
    {
        DEVICE_LABEL,           // Label for the device
        DEVICE_TYPE,            // Type of device (gpu, embree)
        DEVICE_STATUS,          // Device status
        DEVICE_ERROR,           // Device error message
        DEVICE_MEMORY,          // Breakdown of memory
        DEVICE_SAMPLES,         // Number of samples processed by device
        DEVICE_CONTRIB,         // Contribution of device

        DEVICE_MAX_KEYS         // Sentinal
    };

    struct BRAY_API Value
        : public UT_NonCopyable
    {
         Value(BRAY_StatsImpl &stats, Key key);
         Value(BRAY_StatsImpl &stats, DeviceKey key, int device);
        ~Value();

        SYS_SAFE_BOOL    operator bool() const
        {
            return myValue.getType() != UT_JSONValue::JSON_NULL;
        }

        const UT_JSONValue      &get() const { return myValue; }
        const UT_JSONValue      &operator->() const { return myValue; }
        const UT_JSONValue      &operator*() const { return myValue; }

        const UT_StringHolder   &key() const;
        UT_StringHolder          asString() const;
    private:
        const UT_JSONValue      &myValue;
        BRAY_StatsImpl          &myStats;
        int                      myDevice;
        Key                      myKey;
        DeviceKey                myDeviceKey;
    };

    static const UT_StringHolder        &keyName(Key key);
    static const UT_StringHolder        &deviceKeyName(DeviceKey key);

    /// Lightweight method to get the render stage
    BRAY_RenderStage    renderStage() const;
    /// Lightweight method to get the percent complete (between 0 and 100)
    fpreal              percentComplete() const;

    /// Get the value of the stat
    Value       get(Key key) const
                    { return Value(*myImpl, key); }

    /// Get the value of the device stat
    Value       get(DeviceKey key, int device) const
                    { return Value(*myImpl, key, device); }

    /// After XPU devices are initialized, call this method to configure the
    /// stats.
    void        initDevices();

    /// Clear for next render
    void        clear();

    /// @{
    /// @private - methods used by the renderer to update stats during rendering
    BRAY_RenderStage    setStage(BRAY_RenderStage s);
    void        setPercentDone(fpreal v);
    void        setTTFP(fpreal v);
    void        setProgressAnnotation(const UT_StringHolder &s);
    void        setStatsAnnotation(const UT_StringHolder &s);
    void        setAnnotations(const UT_StringHolder &progress_annotation,
                                const UT_StringHolder &stats_annotation);
    void        startBucket(const UT_DimRect &bounds, int pass);
    void        endBucket();

    struct AutoBucket
    {
        AutoBucket(Stats &stats, const UT_DimRect &bounds, int pass)
            : myStats(stats)
        {
            myStats.startBucket(bounds, pass);
        }
        ~AutoBucket()
        {
            myStats.endBucket();
        }
        Stats   &myStats;
    };
    /// @}

private:
    UT_UniquePtr<BRAY_StatsImpl>        myImpl;
};

} // End namespace

#endif