CE_VDBCreate.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: CE_VDBCreate.h ( CE Library, C++)
 *
 * COMMENTS: GPU NanoVDB Creation.
 */

#ifndef __CE_VDBCreate__
#define __CE_VDBCreate__

#include "CE_API.h"

#include <UT/UT_Debug.h>
#include <UT/UT_Error.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>

#include <CE/CE_Context.h>

#include <nanovdb/NanoVDB.h>
#include <nanovdb/util/GridHandle.h>
#include <nanovdb/util/HostBuffer.h>

#include <bitset>
#include <utility>

namespace nanovdb
{

//
// Pointer check utils
//

static inline void
ptrAssert(const void* ptr, const char* msg, const char* file, int line)
{
    if (ptr == nullptr)
    {
        UTdebugFormatCd(red, "NULL pointer error: {} {} {}\n", msg, file, line);
        UT_ASSERT(false);
    }
    else if (uint64_t(ptr) % NANOVDB_DATA_ALIGNMENT)
    {
        UTdebugFormatCd(red, "Pointer misalignment error: {} {} {}\n", msg, file, line);
        UT_ASSERT(false);
    }
}

static inline void
bufferAssert(const void* buf, const char* msg, const char* file, int line)
{
    if (buf == nullptr)
    {
        UTdebugFormatCd(red, "NULL buffer error: {} {} {}\n", msg, file, line);
        UT_ASSERT(false);
    }
}

#define CEcheckPtr(ptr, msg)                                                   \
    {                                                                          \
        ptrAssert((ptr).get(), (msg), __FILE__, __LINE__);                     \
    }

#define CEcheckBuffer(buf, msg)                                                \
    {                                                                          \
        bufferAssert((buf), (msg), __FILE__, __LINE__);                        \
    }

//
// OclDeviceBuffer
// TODO: should be moved to it's own header
//

class OclDeviceBuffer
{
    uint64_t mySize; // total number of bytes managed by this buffer (assumed to be identical for host and device)
    UT_UniquePtr<uint8_t[]> myCpuData; // raw pointers to the host buffer
    cl::Buffer myGpuData; // device buffer

public:
    /// @brief Static factory method that return an instance of this buffer
    /// @param size byte size of buffer to be initialized
    /// @param host If true buffer is initialized only on the host/CPU, else on the device/GPU
    /// @return An instance of this class using move semantics
    static OclDeviceBuffer create(uint64_t size, bool host = true);

    /// @brief Constructor
    /// @param size byte size of buffer to be initialized
    /// @param host If true buffer is initialized only on the host/CPU, else on the device/GPU
    OclDeviceBuffer(uint64_t size = 0, bool host = true)
        : mySize(0)
        , myCpuData(nullptr)
        , myGpuData(cl::Buffer())
    {
        if (size > 0) this->init(size, host);
    }

    /// @brief Disallow copy-construction
    OclDeviceBuffer(const OclDeviceBuffer&) = delete;

    /// @brief Move copy-constructor
    OclDeviceBuffer(OclDeviceBuffer&& other) noexcept
        : mySize(std::exchange(other.mySize, 0))
        , myCpuData(std::move(other.myCpuData))
        , myGpuData(std::exchange(other.myGpuData, cl::Buffer()))
    {
    }

    /// @brief Disallow copy assignment operation
    OclDeviceBuffer& operator=(const OclDeviceBuffer&) = delete;

    /// @brief Move copy assignment operation
    OclDeviceBuffer& operator=(OclDeviceBuffer&& other) noexcept
    {
        this->clear();
        mySize = std::exchange(other.mySize, 0);
        myCpuData = std::move(other.myCpuData);
        myGpuData = std::exchange(other.myGpuData, cl::Buffer());
        return *this;
    }

    /// @brief Destructor frees memory on both the host and device
    ~OclDeviceBuffer() { this->clear(); };

    /// @brief Initialize buffer
    /// @param size byte size of buffer to be initialized
    /// @param host If true buffer is initialized only on the host/CPU, else on the device/GPU
    /// @note All existing buffers are first cleared
    /// @warning size is expected to be non-zero. Use clear() clear buffer!
    void init(uint64_t size, bool host = true);

    /// @brief Retuns a raw pointer to the host/CPU buffer managed by this allocator.
    /// @warning Note that the pointer can be NULL!
    uint8_t* data() const { return myCpuData.get(); }

    /// @brief Retuns a cl::Buffer ref to the device/GPU buffer managed by this allocator.
    /// @warning Note that the pointer can be NULL!
    const cl::Buffer& deviceData() const { return myGpuData; }

    /// @brief  Upload this buffer from the host to the device, i.e. CPU -> GPU.
    /// @param stream optional stream (defaults to stream 0) (never used)
    /// @param sync if false the memory copy is asynchronous (never used)
    /// @note If the device/GPU buffer does not exist it is first allocated
    /// @warning Assumes that the host/CPU buffer already exists
    void deviceUpload(void* stream = nullptr, bool sync = true);

    /// @brief Upload this buffer from the device to the host, i.e. GPU -> CPU.
    /// @param stream optional stream (defaults to stream 0)  (never used)
    /// @param sync if false the memory copy is asynchronous  (never used)
    /// @note If the host/CPU buffer does not exist it is first allocated
    /// @warning Assumes that the device/GPU buffer already exists
    void deviceDownload(void* stream = nullptr, bool sync = true);

    /// @brief Returns the size in bytes of the raw memory buffer managed by this allocator.
    uint64_t size() const { return mySize; }

    //@{
    /// @brief Returns true if this allocator is empty, i.e. has no allocated memory
    bool empty() const { return mySize == 0; }
    bool isEmpty() const { return mySize == 0; }
    //@}

    /// @brief De-allocate all memory managed by this allocator and set all pointers to NULL
    void clear();

};

template<>
struct BufferTraits<OclDeviceBuffer>
{
    static constexpr bool hasDeviceDual = true;
};

// --------------------------> Implementations below <--------------------------

inline OclDeviceBuffer
OclDeviceBuffer::create(uint64_t size, bool host)
{
    return OclDeviceBuffer(size, host);
}

inline void
OclDeviceBuffer::init(uint64_t size, bool host)
{
    if (mySize > 0)
        this->clear();
    UT_ASSERT(size > 0);
    if (host)
    {
        myCpuData = UTmakeUniqueForOverwrite<uint8_t[]>(size);
        CEcheckPtr(myCpuData, "OclDeviceBuffer::init: failed to allocate host buffer");
    }
    else
    {
        CE_Context* context = CE_Context::getContext();
        myGpuData = context->allocBuffer(size); // un-managed memory on the device, always 32B aligned!
        CEcheckBuffer(myGpuData(), "OclDeviceBuffer::init: failed to allocate device buffer");
    }
    mySize = size;
}

inline void
OclDeviceBuffer::deviceUpload(void* stream, bool sync)
{
    CE_Context *context = CE_Context::getContext();

    CEcheckPtr(myCpuData, "uninitialized cpu data");
    if (myGpuData() == nullptr)
        myGpuData = context->allocBuffer(mySize); // un-managed memory on the device, always 32B aligned!
    CEcheckBuffer(myGpuData(), "uninitialized gpu data");

    context->writeBuffer(myGpuData, mySize, myCpuData.get());
}

inline void
OclDeviceBuffer::deviceDownload(void* stream, bool sync)
{
    CE_Context *context = CE_Context::getContext();

    CEcheckBuffer(myGpuData(), "uninitialized gpu data");
    if (myCpuData == nullptr)
        myCpuData = UTmakeUniqueForOverwrite<uint8_t[]>(mySize);
    CEcheckPtr(myCpuData, "uninitialized cpu data");

    context->readBuffer(myGpuData, mySize, myCpuData.get());
}

inline void
OclDeviceBuffer::clear()
{
    CE_Context *context = CE_Context::getContext();
    if (myGpuData() != nullptr)
        context->releaseBuffer(std::move(myGpuData));
    myCpuData.reset();
    myGpuData = cl::Buffer();
    mySize = 0;
}

struct OclPointsData; // opaque

} // nanovdb namespace

class CE_API CE_VDBCreate
{
public:
    CE_VDBCreate() {}

    static uint32_t
    runLengthEncoding(
            uint32_t in_count,
            const cl::Buffer& input,
            cl::Buffer& values,
            cl::Buffer& counts,
            uint32_t bit_shift_right = 0);

    static void
    radixSortPairs(
            uint32_t in_count,
            cl::Buffer& in_key,
            cl::Buffer& in_val,
            uint32_t lsb = -1,
            uint32_t msb = -1,
            uint32_t offset = 0, // offset in elems of the in_* arrays
            uint32_t buffer_nelem = -1);

    class CE_API DataCache
    {
    public:
        DataCache();
        ~DataCache();
        UT_NON_COPYABLE(DataCache)

        bool hasData() const
        {
            return myDataPtr != nullptr;
        }

        // WARNING: throws cl::Error exceptions
        void clear();

    private:
        UT_UniquePtr<nanovdb::OclPointsData> myDataPtr;
        friend class CE_VDBCreate;
    };

    template <
            typename BuildT,
            typename PtrT,
            typename BufferT = nanovdb::OclDeviceBuffer>
    static nanovdb::GridHandle<BufferT> oclPointsToGrid(
            const PtrT d_ijk,
            uint32_t voxelcount,
            double voxelsize,
            const bool activateleaves,
            const uint32_t leafdilation,
            const UT_StringHolder& gridname,
            const nanovdb::GridClass gridclass,
            const BuildT& bgvalue,
            cl::Buffer& tilestart,
            exint& leafcount,
            exint& lowercount,
            exint& uppercount,
            DataCache* datacacheptr);
};

#undef CEcheckPtr
#undef CEcheckBuffer

#endif