include/foundation/PxPinnedArray.h

File members: include/foundation/PxPinnedArray.h

// 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-2024 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.

#ifndef PX_PINNED_ARRAY_H
#define PX_PINNED_ARRAY_H

#include "foundation/PxArray.h"
#include "foundation/PxAllocator.h"
#include "foundation/PxBounds3.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

    // PT: the default pinned-memory arrays are defined as PxPinnedArray = PxArray<T, PxVirtualAllocator>.
    // The PxVirtualAllocator ultimately uses cuMemHostAlloc via PxgCudaHostMemoryAllocatorCallback / PxgPinnedMemoryAllocate.
    // We use the CU_MEMHOSTALLOC_DEVICEMAP flag there so cuMemHostGetDevicePointer() can later be used on returned ptr.
    //
    // The new pinned-memory arrays are defined as PxPinnedArraySafe = PxArray<T, PxPinnedAllocator<T> >. This uses a new
    // allocator that allocates either from cuMemHostAlloc, *or* fallbacks to regular allocs when we run out of pinned memory.
    // The issue is that in the second case cuMemHostGetDevicePointer() will fail, so we cannot use this everywhere.
    //
    // I think this exposes issues in PxArray itself, for example in the swap function (we don't swap the allocator data there,
    // so when using a PxVirtualAllocator with PxArray the PxVirtualAllocator members are not swapped).

    // PT: this class uses the fact that PxArray inherits from the allocator to add new members to the array class. In particular
    // PxPinnedAllocator::mPinned describes where PxArray::mData has been allocated. The class is mostly designed to be used in
    // conjunction with PxArray, not as a standalone allocator.
    template<class T>
    class PxPinnedAllocator
    {
        public:
        PxPinnedAllocator(PxVirtualAllocatorCallback* callback = NULL, int group = 0) : mCallback(callback), mGroup(group), mPinned(0)  {}

        PX_INLINE   void* allocate(size_t size, const char* file, int line, uint32_t* cookie=NULL)
        {
            PX_ASSERT(mCallback);
            // PT: returns *previous* pinned value. It will be passed back to the deallocate function.
            if(cookie)
                *cookie = mPinned;

            if(!size)
            {
                mPinned = 0xffffffff;
                return NULL;
            }

            // PT: first, try with the pinned-memory allocator
            void* ptr = mCallback->allocate(size, mGroup, file, line);
            if(ptr)
            {
                mPinned = 1;
                return ptr;
            }

            // PT: if it fails, fallback to regular allocator
            mPinned = 0;
            return PxReflectionAllocator<T>::allocate(size, file, line);
        }

        PX_INLINE   void deallocate(void* ptr, uint32_t* cookie=NULL)
        {
            PX_ASSERT(mCallback);
            if(ptr)
            {
                // PT: by default use the internal value, except if we're given an explicit cookie
                const uint32_t pinned = cookie ? *cookie : mPinned;
                if(pinned==1)
                    mCallback->deallocate(ptr);
                else
                    PxReflectionAllocator<T>::deallocate(ptr);
            }
        }

        PX_FORCE_INLINE void setCallback(PxVirtualAllocatorCallback* callback)
        {
            mCallback = callback;
        }

        PX_FORCE_INLINE PxVirtualAllocatorCallback* getCallback()
        {
            return mCallback;
        }

        private:
        PxVirtualAllocatorCallback* mCallback;
        const int mGroup;
        uint32_t mPinned;
        PxPinnedAllocator& operator=(const PxPinnedAllocator&);
    };

    struct PxsCachedTransform;

    // PT: default versions:
    template<class T>
    using PxPinnedArray = PxArray<T, PxVirtualAllocator>;

    typedef PxArray<PxsCachedTransform, PxVirtualAllocator> PxCachedTransformArrayPinned;
    typedef PxArray<PxBounds3, PxVirtualAllocator>          PxBoundsArrayPinned;
    typedef PxArray<PxReal, PxVirtualAllocator>             PxFloatArrayPinned;
    typedef PxArray<PxU32, PxVirtualAllocator>              PxInt32ArrayPinned;
    typedef PxArray<PxU16, PxVirtualAllocator>              PxInt16ArrayPinned;
    typedef PxArray<PxU8, PxVirtualAllocator>               PxInt8ArrayPinned;

    // PT: new versions
    template<class T>
    using PxPinnedArraySafe = PxArray<T, PxPinnedAllocator<T> >;

    typedef PxArray<PxsCachedTransform, PxPinnedAllocator<PxsCachedTransform> > PxCachedTransformArrayPinnedSafe;
    typedef PxArray<PxBounds3, PxPinnedAllocator<PxBounds3> >                   PxBoundsArrayPinnedSafe;
    typedef PxArray<PxReal, PxPinnedAllocator<PxReal> >                         PxFloatArrayPinnedSafe;
    typedef PxArray<PxU32, PxPinnedAllocator<PxU32> >                           PxInt32ArrayPinnedSafe;
    typedef PxArray<PxU16, PxPinnedAllocator<PxU16> >                           PxInt16ArrayPinnedSafe;
    typedef PxArray<PxU8, PxPinnedAllocator<PxU8> >                             PxInt8ArrayPinnedSafe;

#if !PX_DOXYGEN
} // namespace physx
#endif

#endif