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 <bitset>

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

#include <CE/CE_Context.h>

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

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 checkPtr(ptr, msg)                                                     \
    {                                                                          \
        ptrAssert((ptr), (msg), __FILE__, __LINE__);                           \
    }

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

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

class OclDeviceBuffer
{
    uint64_t mSize; // total number of bytes managed by this buffer (assumed to be identical for host and device)
    uint8_t *mCpuData; // raw pointers to the host buffer
    cl::Buffer mGpuData; // 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)
        : mSize(0)
        , mCpuData(nullptr)
        , mGpuData(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
        : mSize(other.mSize)
        , mCpuData(other.mCpuData)
        , mGpuData(other.mGpuData)
    {
        other.mSize = 0;
        other.mCpuData = nullptr;
        other.mGpuData = cl::Buffer();
    }

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

    /// @brief Move copy assignment operation
    OclDeviceBuffer& operator=(OclDeviceBuffer&& other) noexcept
    {
        this->clear();
        mSize = other.mSize;
        mCpuData = other.mCpuData;
        mGpuData = other.mGpuData;
        other.mSize = 0;
        other.mCpuData = nullptr;
        other.mGpuData = 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 mCpuData; }

    /// @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 mGpuData; }

    /// @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 mSize; }

    //@{
    /// @brief Returns true if this allocator is empty, i.e. has no allocated memory
    bool empty() const { return mSize == 0; }
    bool isEmpty() const { return mSize == 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 (mSize > 0)
        this->clear();
    UT_ASSERT(size > 0);
    if (host)
    {
        mCpuData = new uint8_t[size];
        checkPtr(mCpuData, "OclDeviceBuffer::init: failed to allocate host buffer");
    }
    else
    {
        CE_Context* context = CE_Context::getContext();
        mGpuData = context->allocBuffer(size); // un-managed memory on the device, always 32B aligned!
        checkBuffer(mGpuData(), "OclDeviceBuffer::init: failed to allocate device buffer");
    }
    mSize = size;
}

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

    checkPtr(mCpuData, "uninitialized cpu data");
    if (mGpuData() == nullptr) {
        mGpuData = context->allocBuffer(mSize); // un-managed memory on the device, always 32B aligned!
    }
    checkBuffer(mGpuData(), "uninitialized gpu data");

    context->writeBuffer(mGpuData, mSize, mCpuData);
}

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

    checkBuffer(mGpuData(), "uninitialized gpu data");
    if (mCpuData == nullptr) {
        mCpuData = new uint8_t[mSize];
    }
    checkPtr(mCpuData, "uninitialized cpu data");

    context->readBuffer(mGpuData, mSize, mCpuData);
}

inline void OclDeviceBuffer::clear()
{
    CE_Context *context = CE_Context::getContext();
    if (mGpuData() != nullptr) context->releaseBuffer(std::move(mGpuData));
    if (mCpuData != nullptr) delete[] mCpuData;
    mCpuData = nullptr;
    mGpuData = cl::Buffer();
    mSize = 0;
}

} // 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);

    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,
            void** datacacheptr);

    template <typename BuildT>
    static void deleteDataCache(void* datacacheptr);
};

#endif