RV_VKQuery.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:        RV_VKQuery.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Class to handle Vulkan Queries
 */

#ifndef RV_VKQuery_h
#define RV_VKQuery_h

#include "RV_API.h"

#include <SYS/SYS_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_Span.h>
#include <UT/UT_UniquePtr.h>

#include <VE/VE_VK.h>

#include "RV_VKCommandBuffer.h"

class RV_Instance;
class RV_Render;
class RV_VKBuffer;

class RV_VKQuery
{
public:
    enum QueryType
    {
        RV_QUERY_SIMPLE_OCCLUSION,
        RV_QUERY_PRECISE_OCCLUSION,
        RV_QUERY_TIMESTAMP,
        RV_QUERY_ACCEL_STRUCT_COMPACT_SIZE
    };

    static UT_UniquePtr<RV_VKQuery> createQuery(
            RV_Instance* inst,
            int count,
            QueryType type,
            bool gpu_exclusive);

    QueryType getType() const { return myType; }
    bool isGPUExclusive() const { return myIsGPUOnly; }
    int getSize() const { return myQueryFlags.size(); }

    // Recording Actions ---------
    bool begin(RV_VKCommandBuffer* cb, int idx = 0);
    void end(RV_VKCommandBuffer* cb, int idx = 0);
    void reset(RV_VKCommandBuffer* cb, int idx = 0);
    void softReset(int idx = 0);

    // timestamp only valid for timestamp queries
    void writeTimestamp(RV_VKCommandBuffer* cb,
          VkPipelineStageFlagBits stage = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
          int idx = 0);
    
    // acceleratrion structure compact size queries
    void writeAccelStructCompactSize(
        RV_VKCommandBuffer* cb,
        const VkAccelerationStructureKHR* accel_struct,
        int idx = 0);

    // Results ---------
    bool isResultAvailable(RV_Instance* inst, int idx = 0);

    int32 getResult(RV_Instance* inst, int idx = 0);
    int64 getLongResult(RV_Instance* inst, int idx = 0);

    // When called with RV_Render it can flush the CB if needed
    int32 getResult(RV_Render* r, int idx = 0);
    int64 getLongResult(RV_Render* inst, int idx = 0);

    // Write the results and the result status into the buffer `buf`
    void writeResult(
            RV_VKCommandBuffer* cb,
            RV_VKBuffer* buf,
            bool wait,
            int idx = 0);
    int64 writeLongResult(
            RV_VKCommandBuffer* cb,
            RV_VKBuffer* buf,
            bool wait,
            int idx = 0);

    // Lifecycle Queries ---------
    
    // IsReset means the Query is completely blank:
    //  it is not active and it will not be modified by the GPU
    bool isReset(int idx = 0)
    {
        auto& flags = myQueryFlags(idx);
        return !flags.myIsActiveRecording && !flags.myIsFinishedRecording
            && !flags.myIsSubmitted && !flags.myIsAvailable;
    }
    
    bool isDoneRecording(int idx = 0)
    {
        auto& flags = myQueryFlags(idx);
        return !flags.myIsActiveRecording && flags.myIsFinishedRecording;
    }

    bool isSubmitted(int idx = 0)
    {
        auto& flags = myQueryFlags(idx);
        return flags.myIsFinishedRecording && flags.myIsSubmitted;
    }

    bool isWaiting(int idx = 0)
    {
        auto& flags = myQueryFlags(idx);
        return flags.myIsFinishedRecording && !flags.myIsAvailable;
    }

    ~RV_VKQuery();

private:
    struct PassKey {};
public:
    RV_VKQuery(
            RV_Instance* inst,
            int count,
            VkQueryPool pool,
            QueryType type,
            bool gpu_exclusive,
            const PassKey&);

protected:
    void markSubmitted(int idx);

    friend class RV_FinishQueryTask;

private:
    bool privGetCPUResult(
            RV_Instance* inst,
            int idx,
            VkQueryResultFlags flags,
            const UT_Span<uint8>& out_data);
    
    bool privWait(RV_Instance* inst, int idx);
    bool privWait(RV_Render r, int idx); // version with RV_Render can flush

    RV_Instance* myInst;
    VkQueryPool myVkQuery;

    // Create Info
    QueryType   myType;
    int         myCount;
    bool        myIsGPUOnly;

    // TODO: move lifecycle flags to RV_Query or make array
    // stages:  (RECORDING)UNAVAILABLE  // after reset
    //          (RECORDING)ACTIVE       // after begin
    //          (RECORDING)AVAILABLE    // after end
    //              -> Waiting for submission (not available on CPU until submission + wait)
    //          (EXECUTING)ACTIVE       // after begin
    //          (EXECUTING)AVAILABLE    // after end
    //          (EXECUTING)UNAVAILABLE  // after reset
    // NOTE: GPU-only queries will only care about the RECORDING
    //       stages -- sync can be done of the GPU-timeline
   
    // Lifecycle flags
    // TODO: atomic ? they're local to CB: should only be used on one thread
    struct QueryFlags
    {
        bool myIsResetRecorded = false;
        bool myIsActiveRecording = false;
        bool myIsFinishedRecording = false;

        // flags only used for CPU-access tracking
        bool myIsSubmitted = false;
        bool myIsAvailable = false;
    };
    UT_Array<QueryFlags> myQueryFlags;
};

#if 0
class RV_TimeStampQuery 
{
public:
    enum RV_OcclusionResult
    {
        BOOLEAN,
        NUM_SAMPLES
    };
    RV_TimerQuery();
    init(RV_Render* r);

    void timestamp(RV_VKCommandBuffer* cb);
    int64 getTimestampNS();

    void writeResult(RV_VKCommandBuffer* cb, RV_VKBuffer* buf);
private:
    RV_VKQuery myQuery;
    bool myIsBoolean;
}

class RV_TimerQuery 
{
public:
    RV_TimerQuery();
    init(RV_Render* r);

    void init(RV_Render* inst);
    bool begin(RV_VKCommandBuffer *cb);
    void end(RV_VKCommandBuffer* cb);

    int64 getTimeNS();

    void writeResult(RV_VKCommandBuffer* cb, RV_VKBuffer* buf);
private:
    RV_VKQuery myQuery;
    bool myIsBoolean;
}

#endif

class RV_FinishQueryTask
{
public:
    RV_VKQuery* myQuery;
    int myQueryIdx;

    void operator()(RV_Instance*)
    {
        myQuery->markSubmitted(myQueryIdx);
    }

    RV_FinishQueryTask(RV_VKQuery* query, int idx)
    : myQuery(query)
    , myQueryIdx(idx)
    {}
};

RV_VKCommandBuffer::Callback RVmakeFinishQueryTask(
    RV_VKQuery* query,
    int idx);

#endif