PxCudaMemoryManager.h

Go to the documentation of this file.

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.

#ifndef PXCUDACONTEXTMANAGER_PXCUDAMEMORYMANAGER_H
#define PXCUDACONTEXTMANAGER_PXCUDAMEMORYMANAGER_H

#include "foundation/PxPreprocessor.h"

#if PX_SUPPORT_GPU_PHYSX

#include "task/PxTaskDefine.h"

// some macros to keep the source code more readable
#define PX_ALLOC_INFO(name, ID) __FILE__, __LINE__, name, physx::PxAllocId::ID
#define PX_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 PX_ALLOC_INFO_PARAMS_DEF()  const char* file, int line, const char* allocName, physx::PxAllocId::Enum allocId
#define PX_ALLOC_INFO_PARAMS_INPUT()  file, line, allocName, allocId
#define PX_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

namespace physx
{

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, PX_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, PX_ALLOC_INFO_PARAMS_DECL(NULL, 0, NULL, UNASSIGNED)) = 0;

    virtual PxCudaBufferPtr             alloc(PxCudaBufferMemorySpace::Enum memorySpace, size_t size, PX_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, PX_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


} // end physx namespace

#endif // PX_SUPPORT_GPU_PHYSX
#endif // PXCUDACONTEXTMANAGER_PXCUDAMEMORYMANAGER_H