PxCudaMemoryManager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */

#ifndef PX_CUDA_MEMORY_MANAGER_H
#define PX_CUDA_MEMORY_MANAGER_H

#include "foundation/PxSimpleTypes.h"

// some macros to keep the source code more readable
#define NV_ALLOC_INFO(name, ID) __FILE__, __LINE__, name, physx::PxAllocId::ID
#define NV_ALLOC_INFO_PARAMS_DECL(p0, p1, p2, p3)  const char* file = p0, int line = p1, const char* allocName = p2, physx::PxAllocId::Enum allocId = physx::PxAllocId::p3
#define NV_ALLOC_INFO_PARAMS_DEF()  const char* file, int line, const char* allocName, physx::PxAllocId::Enum allocId
#define NV_ALLOC_INFO_PARAMS_INPUT()  file, line, allocName, allocId
#define NV_ALLOC_INFO_PARAMS_INPUT_INFO(info) info.getFileName(), info.getLine(), info.getAllocName(), info.getAllocId()

#ifndef NULL // don't want to include <string.h>
#define NULL 0
#endif

#ifndef PX_DOXYGEN
namespace physx
{
#endif

PX_PUSH_PACK_DEFAULT

struct PxAllocId
{
    enum Enum
    {
        UNASSIGNED,     
        APEX,           
        PARTICLES,      
        GPU_UTIL,       
        CLOTH,          
        NUM_IDS         
    };
};

struct PxCudaBufferMemorySpace
{
    enum Enum
    {
        T_GPU,
        T_PINNED_HOST,
        T_WRITE_COMBINED,
        T_HOST,
        COUNT
    };
};

class PxAllocInfo
{
public:
    PxAllocInfo() {}

    PxAllocInfo(const char* file, int line, const char* allocName, PxAllocId::Enum allocId)
        : mFileName(file)
        , mLine(line)
        , mAllocName(allocName)
        , mAllocId(allocId)
    {}

    inline  const char*         getFileName() const
    {
        return mFileName;
    }

    inline  int                 getLine() const
    {
        return mLine;
    }

    inline  const char*         getAllocName() const
    {
        return mAllocName;
    }

    inline  PxAllocId::Enum     getAllocId() const
    {
        return mAllocId;
    }

private:
    const char*         mFileName;
    int                 mLine;
    const char*         mAllocName;
    PxAllocId::Enum     mAllocId;
};

struct PxAllocIdStats
{
    size_t size;        
    size_t maxSize;     
    size_t elements;    
    size_t maxElements; 
};

class PxCudaMemoryManager;
typedef size_t PxCudaBufferPtr;

struct PxCudaBufferFlags
{
    enum Enum
    {
        F_READ          = (1 << 0),
        F_WRITE         = (1 << 1),
        F_READ_WRITE    = F_READ | F_WRITE
    };
};


struct PxCudaMemoryManagerStats
{

    size_t          heapSize;       
    size_t          totalAllocated; 
    size_t          maxAllocated;   
    PxAllocIdStats  allocIdStats[PxAllocId::NUM_IDS]; 
};


struct PxCudaBufferType
{
    PX_INLINE PxCudaBufferType(const PxCudaBufferType& t)
        : memorySpace(t.memorySpace)
        , flags(t.flags)
    {}
    
    PX_INLINE PxCudaBufferType(PxCudaBufferMemorySpace::Enum _memSpace, PxCudaBufferFlags::Enum _flags)
        : memorySpace(_memSpace)
        , flags(_flags)
    {}

    PxCudaBufferMemorySpace::Enum   memorySpace;    
    PxCudaBufferFlags::Enum         flags;          
};


class PxCudaBuffer
{
public:
    virtual PxCudaMemoryManager*            getCudaMemoryManager() const = 0;

    virtual bool                        free() = 0;

    virtual bool                        realloc(size_t size, NV_ALLOC_INFO_PARAMS_DECL(NULL, 0, NULL, UNASSIGNED)) = 0;

    virtual const PxCudaBufferType&     getType() const = 0;

    virtual PxCudaBufferPtr             getPtr() const = 0;

    virtual size_t                      getSize() const = 0;

protected:
    virtual ~PxCudaBuffer() {}
};


class PxCudaMemoryManager
{
public:
    virtual PxCudaBuffer*               alloc(const PxCudaBufferType& type, size_t size, NV_ALLOC_INFO_PARAMS_DECL(NULL, 0, NULL, UNASSIGNED)) = 0;

    virtual PxCudaBufferPtr             alloc(PxCudaBufferMemorySpace::Enum memorySpace, size_t size, NV_ALLOC_INFO_PARAMS_DECL(NULL, 0, NULL, UNASSIGNED)) = 0;

    virtual bool                        free(PxCudaBufferMemorySpace::Enum memorySpace, PxCudaBufferPtr addr) = 0;

    virtual bool                        realloc(PxCudaBufferMemorySpace::Enum memorySpace, PxCudaBufferPtr addr, size_t size, NV_ALLOC_INFO_PARAMS_DECL(NULL, 0, NULL, UNASSIGNED)) = 0;

    virtual void                        getStats(const PxCudaBufferType& type, PxCudaMemoryManagerStats& outStats) = 0;

    virtual bool                        reserve(const PxCudaBufferType& type, size_t size) = 0;

    virtual bool                        setPageSize(const PxCudaBufferType& type, size_t size) = 0;

    virtual bool                        setMaxMemorySize(const PxCudaBufferType& type, size_t size) = 0;

    virtual size_t                      getBaseSize(const PxCudaBufferType& type) = 0;

    virtual size_t                      getPageSize(const PxCudaBufferType& type) = 0;

    virtual size_t                      getMaxMemorySize(const PxCudaBufferType& type) = 0;

    virtual PxCudaBufferPtr             getMappedPinnedPtr(PxCudaBufferPtr hostPtr) = 0;

protected:
    virtual ~PxCudaMemoryManager() {}
};

PX_POP_PACK

#ifndef PX_DOXYGEN
} // end physx namespace
#endif

#endif