CE_BufferHost.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.
 *
 */

#pragma once

#include "CE_API.h"
#include <UT/UT_Assert.h>
#include <SYS/SYS_Align.h>
#include <SYS/SYS_Types.h>
#include <string.h>

/// The traditional allocator will align to the size of the type, which in this
/// case is char - however, in order to maximize the chances of vectorized
/// instructions being generated, we'll align to the size of the cache line.
///
/// Note: We don't have a cross-platform method to determine the size of the
///       cache line, so we'll just assume 64 bytes.
///
/// T should be a POD as this is not initialized.
///
template <typename T>
class CE_BufferHost
{
public:
    explicit CE_BufferHost() = default;

    // Note this is NOT initialized.
    explicit CE_BufferHost(const exint size)
        : myData((T*)SYSamalloc(size*sizeof(T), ALIGNMENT))
        , myDataSize(size)
        , myStorageMode(StorageMode::STORE_ALIGNED)
    {
    }

    CE_BufferHost(const CE_BufferHost &other)
    {
        adoptFromAlignedMalloc(
            (T*)SYSamalloc(other.myDataSize*sizeof(T), ALIGNMENT), other.myDataSize*sizeof(T));
        memcpy(myData, other.myData, other.myDataSize*sizeof(T));
    }

    CE_BufferHost(CE_BufferHost &&other) noexcept
        : myData(other.myData)
        , myDataSize(other.myDataSize)
        , myStorageMode(other.myStorageMode)
    {
        other.myData        = nullptr;
        other.myDataSize    = 0;
        other.myStorageMode = StorageMode::STORE_UNDEFINED;
    }

    CE_BufferHost &operator=(const CE_BufferHost &other)
    {
        adoptFromAlignedMalloc(
            (T*)SYSamalloc(other.myDataSize*sizeof(T), ALIGNMENT), other.myDataSize*sizeof(T));
        memcpy(myData, other.myData, other.myDataSize*sizeof(T));
        return *this;
    }

    void adoptFromAlignedMalloc(void *data, const exint size)
    {
        freeData();

        myData        = (T*) data;
        myDataSize    = size;
        myStorageMode = StorageMode::STORE_ALIGNED;
    }

    void adoptFromMalloc(void *data, const exint size)
    {
        freeData();

        myData        = (T*) data;
        myDataSize    = size;
        myStorageMode = StorageMode::STORE_MALLOC;
    }

    void adoptFromNew(void *data, const exint size)
    {
        freeData();

        myData        = (T*) data;
        myDataSize    = size;
        myStorageMode = StorageMode::STORE_NEW;
    }

    ~CE_BufferHost()
    {
        freeData();
    }

    /// The buffer data. 
    T *data() const { return myData; }

    /// The size of the buffer data in elements.
    exint size() const { return myDataSize; }

    int64       getMemoryUsage() const
    {
        int64   total = sizeof(*this);
        total += myDataSize * sizeof(T);
        return total;
    }

    static constexpr int ALIGNMENT = 64;   // bytes

private:
    enum class StorageMode
    {
        STORE_UNDEFINED,
        STORE_NEW,
        STORE_MALLOC,
        STORE_ALIGNED
    };

    void freeData()
    {
        if (!myData)
            return;

        switch (myStorageMode)
        {
            case StorageMode::STORE_MALLOC:    free(myData);     break;
            case StorageMode::STORE_NEW:       delete[] myData;  break;
            case StorageMode::STORE_ALIGNED:   SYSafree(myData); break;
            case StorageMode::STORE_UNDEFINED: SYS_FALLTHROUGH;
            default: UT_ASSERT(0 && "Unknown storage mode");
        }

        myStorageMode = StorageMode::STORE_UNDEFINED;
        myData        = nullptr;
        myDataSize    = 0;
    }

    T           *myData        = nullptr;
    exint        myDataSize    = 0;   // T elements
    StorageMode  myStorageMode = StorageMode::STORE_UNDEFINED;
};

using CE_BufferHostByte = CE_BufferHost<uint8>;