documentation.HELP! NVIDIA PhysX Documentation

NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h Source File

NVIDIA PhysX

previous page next page

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and 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.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2014 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 PSFOUNDATION_PSHASHINTERNALS_H
#define PSFOUNDATION_PSHASHINTERNALS_H

#include "PsBasicTemplates.h"
#include "PsArray.h"
#include "PsBitUtils.h"
#include "PsHash.h"
#include "foundation/PxIntrinsics.h"

#if PX_VC
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
namespace physx
{
namespace shdfnd
{
namespace internal
{
template <class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
class HashBase : private Allocator
{
        void init(uint32_t initialTableSize, float loadFactor)
        {
                mBuffer = NULL;
                mEntries = NULL;
                mEntriesNext = NULL;
                mHash = NULL;
                mEntriesCapacity = 0;
                mHashSize = 0;
                mLoadFactor = loadFactor;
                mFreeList = uint32_t(EOL);
                mTimestamp = 0;
                mEntriesCount = 0;

                if(initialTableSize)
                        reserveInternal(initialTableSize);
        }

  public:
        typedef Entry EntryType;

        HashBase(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : Allocator(PX_DEBUG_EXP("hashBase"))
        {
                init(initialTableSize, loadFactor);
        }

        HashBase(uint32_t initialTableSize, float loadFactor, const Allocator& alloc) : Allocator(alloc)
        {
                init(initialTableSize, loadFactor);
        }

        HashBase(const Allocator& alloc) : Allocator(alloc)
        {
                init(64, 0.75f);
        }

        ~HashBase()
        {
                destroy(); // No need to clear()

                if(mBuffer)
                        Allocator::deallocate(mBuffer);
        }

        static const uint32_t EOL = 0xffffffff;

        PX_INLINE Entry* create(const Key& k, bool& exists)
        {
                uint32_t h = 0;
                if(mHashSize)
                {
                        h = hash(k);
                        uint32_t index = mHash[h];
                        while(index != EOL && !HashFn().equal(GetKey()(mEntries[index]), k))
                                index = mEntriesNext[index];
                        exists = index != EOL;
                        if(exists)
                                return mEntries + index;
                }
                else
                        exists = false;

                if(freeListEmpty())
                {
                        grow();
                        h = hash(k);
                }

                uint32_t entryIndex = freeListGetNext();

                mEntriesNext[entryIndex] = mHash[h];
                mHash[h] = entryIndex;

                mEntriesCount++;
                mTimestamp++;

                return mEntries + entryIndex;
        }

        PX_INLINE const Entry* find(const Key& k) const
        {
                if(!mHashSize)
                        return NULL;

                const uint32_t h = hash(k);
                uint32_t index = mHash[h];
                while(index != EOL && !HashFn().equal(GetKey()(mEntries[index]), k))
                        index = mEntriesNext[index];
                return index != EOL ? mEntries + index : NULL;
        }

        PX_INLINE bool erase(const Key& k)
        {
                if(!mHashSize)
                        return false;

                const uint32_t h = hash(k);
                uint32_t* ptr = mHash + h;
                while(*ptr != EOL && !HashFn().equal(GetKey()(mEntries[*ptr]), k))
                        ptr = mEntriesNext + *ptr;

                if(*ptr == EOL)
                        return false;

                const uint32_t index = *ptr;
                *ptr = mEntriesNext[index];

                mEntries[index].~Entry();

                mEntriesCount--;
                mTimestamp++;

                if(compacting && index != mEntriesCount)
                        replaceWithLast(index);

                freeListAdd(index);

                return true;
        }

        PX_INLINE uint32_t size() const
        {
                return mEntriesCount;
        }

        PX_INLINE uint32_t capacity() const
        {
                return mHashSize;
        }

        void clear()
        {
                if(!mHashSize || mEntriesCount == 0)
                        return;

                destroy();

                intrinsics::memSet(mHash, EOL, mHashSize * sizeof(uint32_t));

                const uint32_t sizeMinus1 = mEntriesCapacity - 1;
                for(uint32_t i = 0; i < sizeMinus1; i++)
                {
                        prefetchLine(mEntriesNext + i, 128);
                        mEntriesNext[i] = i + 1;
                }
                mEntriesNext[mEntriesCapacity - 1] = uint32_t(EOL);
                mFreeList = 0;
                mEntriesCount = 0;
        }

        void reserve(uint32_t size)
        {
                if(size > mHashSize)
                        reserveInternal(size);
        }

        PX_INLINE const Entry* getEntries() const
        {
                return mEntries;
        }

        PX_INLINE Entry* insertUnique(const Key& k)
        {
                PX_ASSERT(find(k) == NULL);
                uint32_t h = hash(k);

                uint32_t entryIndex = freeListGetNext();

                mEntriesNext[entryIndex] = mHash[h];
                mHash[h] = entryIndex;

                mEntriesCount++;
                mTimestamp++;

                return mEntries + entryIndex;
        }

  private:
        void destroy()
        {
                for(uint32_t i = 0; i < mHashSize; i++)
                {
                        for(uint32_t j = mHash[i]; j != EOL; j = mEntriesNext[j])
                                mEntries[j].~Entry();
                }
        }

        template <typename HK, typename GK, class A, bool comp>
        PX_NOINLINE void copy(const HashBase<Entry, Key, HK, GK, A, comp>& other);

        // free list management - if we're coalescing, then we use mFreeList to hold
        // the top of the free list and it should always be equal to size(). Otherwise,
        // we build a free list in the next() pointers.

        PX_INLINE void freeListAdd(uint32_t index)
        {
                if(compacting)
                {
                        mFreeList--;
                        PX_ASSERT(mFreeList == mEntriesCount);
                }
                else
                {
                        mEntriesNext[index] = mFreeList;
                        mFreeList = index;
                }
        }

        PX_INLINE void freeListAdd(uint32_t start, uint32_t end)
        {
                if(!compacting)
                {
                        for(uint32_t i = start; i < end - 1; i++) // add the new entries to the free list
                                mEntriesNext[i] = i + 1;

                        // link in old free list
                        mEntriesNext[end - 1] = mFreeList;
                        PX_ASSERT(mFreeList != end - 1);
                        mFreeList = start;
                }
                else if(mFreeList == EOL) // don't reset the free ptr for the compacting hash unless it's empty
                        mFreeList = start;
        }

        PX_INLINE uint32_t freeListGetNext()
        {
                PX_ASSERT(!freeListEmpty());
                if(compacting)
                {
                        PX_ASSERT(mFreeList == mEntriesCount);
                        return mFreeList++;
                }
                else
                {
                        uint32_t entryIndex = mFreeList;
                        mFreeList = mEntriesNext[mFreeList];
                        return entryIndex;
                }
        }

        PX_INLINE bool freeListEmpty() const
        {
                if(compacting)
                        return mEntriesCount == mEntriesCapacity;
                else
                        return mFreeList == EOL;
        }

        PX_INLINE void replaceWithLast(uint32_t index)
        {
                PX_PLACEMENT_NEW(mEntries + index, Entry)(mEntries[mEntriesCount]);
                mEntries[mEntriesCount].~Entry();
                mEntriesNext[index] = mEntriesNext[mEntriesCount];

                uint32_t h = hash(GetKey()(mEntries[index]));
                uint32_t* ptr;
                for(ptr = mHash + h; *ptr != mEntriesCount; ptr = mEntriesNext + *ptr)
                        PX_ASSERT(*ptr != EOL);
                *ptr = index;
        }

        PX_INLINE uint32_t hash(const Key& k, uint32_t hashSize) const
        {
                return HashFn()(k) & (hashSize - 1);
        }

        PX_INLINE uint32_t hash(const Key& k) const
        {
                return hash(k, mHashSize);
        }

        void reserveInternal(uint32_t size)
        {
                if(!isPowerOfTwo(size))
                        size = nextPowerOfTwo(size);

                PX_ASSERT(!(size & (size - 1)));

                // decide whether iteration can be done on the entries directly
                bool resizeCompact = compacting || freeListEmpty();

                // define new table sizes
                uint32_t oldEntriesCapacity = mEntriesCapacity;
                uint32_t newEntriesCapacity = uint32_t(float(size) * mLoadFactor);
                uint32_t newHashSize = size;

                // allocate new common buffer and setup pointers to new tables
                uint8_t* newBuffer;
                uint32_t* newHash;
                uint32_t* newEntriesNext;
                Entry* newEntries;
                {
                        uint32_t newHashByteOffset = 0;
                        uint32_t newEntriesNextBytesOffset = newHashByteOffset + newHashSize * sizeof(uint32_t);
                        uint32_t newEntriesByteOffset = newEntriesNextBytesOffset + newEntriesCapacity * sizeof(uint32_t);
                        newEntriesByteOffset += (16 - (newEntriesByteOffset & 15)) & 15;
                        uint32_t newBufferByteSize = newEntriesByteOffset + newEntriesCapacity * sizeof(Entry);

                        newBuffer = reinterpret_cast<uint8_t*>(Allocator::allocate(newBufferByteSize, __FILE__, __LINE__));
                        PX_ASSERT(newBuffer);

                        newHash = reinterpret_cast<uint32_t*>(newBuffer + newHashByteOffset);
                        newEntriesNext = reinterpret_cast<uint32_t*>(newBuffer + newEntriesNextBytesOffset);
                        newEntries = reinterpret_cast<Entry*>(newBuffer + newEntriesByteOffset);
                }

                // initialize new hash table
                intrinsics::memSet(newHash, uint32_t(EOL), newHashSize * sizeof(uint32_t));

                // iterate over old entries, re-hash and create new entries
                if(resizeCompact)
                {
                        // check that old free list is empty - we don't need to copy the next entries
                        PX_ASSERT(compacting || mFreeList == EOL);

                        for(uint32_t index = 0; index < mEntriesCount; ++index)
                        {
                                uint32_t h = hash(GetKey()(mEntries[index]), newHashSize);
                                newEntriesNext[index] = newHash[h];
                                newHash[h] = index;

                                PX_PLACEMENT_NEW(newEntries + index, Entry)(mEntries[index]);
                                mEntries[index].~Entry();
                        }
                }
                else
                {
                        // copy old free list, only required for non compact resizing
                        intrinsics::memCopy(newEntriesNext, mEntriesNext, mEntriesCapacity * sizeof(uint32_t));

                        for(uint32_t bucket = 0; bucket < mHashSize; bucket++)
                        {
                                uint32_t index = mHash[bucket];
                                while(index != EOL)
                                {
                                        uint32_t h = hash(GetKey()(mEntries[index]), newHashSize);
                                        newEntriesNext[index] = newHash[h];
                                        PX_ASSERT(index != newHash[h]);

                                        newHash[h] = index;

                                        PX_PLACEMENT_NEW(newEntries + index, Entry)(mEntries[index]);
                                        mEntries[index].~Entry();

                                        index = mEntriesNext[index];
                                }
                        }
                }

                // swap buffer and pointers
                Allocator::deallocate(mBuffer);
                mBuffer = newBuffer;
                mHash = newHash;
                mHashSize = newHashSize;
                mEntriesNext = newEntriesNext;
                mEntries = newEntries;
                mEntriesCapacity = newEntriesCapacity;

                freeListAdd(oldEntriesCapacity, newEntriesCapacity);
        }

        void grow()
        {
                PX_ASSERT((mFreeList == EOL) || (compacting && (mEntriesCount == mEntriesCapacity)));

                uint32_t size = mHashSize == 0 ? 16 : mHashSize * 2;
                reserve(size);
        }

        uint8_t* mBuffer;
        Entry* mEntries;
        uint32_t* mEntriesNext; // same size as mEntries
        uint32_t* mHash;
        uint32_t mEntriesCapacity;
        uint32_t mHashSize;
        float mLoadFactor;
        uint32_t mFreeList;
        uint32_t mTimestamp;
        uint32_t mEntriesCount; // number of entries

  public:
        class Iter
        {
          public:
                PX_INLINE Iter(HashBase& b) : mBucket(0), mEntry(uint32_t(b.EOL)), mTimestamp(b.mTimestamp), mBase(b)
                {
                        if(mBase.mEntriesCapacity > 0)
                        {
                                mEntry = mBase.mHash[0];
                                skip();
                        }
                }

                PX_INLINE void check() const
                {
                        PX_ASSERT(mTimestamp == mBase.mTimestamp);
                }
                PX_INLINE Entry operator*() const
                {
                        check();
                        return mBase.mEntries[mEntry];
                }
                PX_INLINE Entry* operator->() const
                {
                        check();
                        return mBase.mEntries + mEntry;
                }
                PX_INLINE Iter operator++()
                {
                        check();
                        advance();
                        return *this;
                }
                PX_INLINE Iter operator++(int)
                {
                        check();
                        Iter i = *this;
                        advance();
                        return i;
                }
                PX_INLINE bool done() const
                {
                        check();
                        return mEntry == mBase.EOL;
                }

          private:
                PX_INLINE void advance()
                {
                        mEntry = mBase.mEntriesNext[mEntry];
                        skip();
                }
                PX_INLINE void skip()
                {
                        while(mEntry == mBase.EOL)
                        {
                                if(++mBucket == mBase.mHashSize)
                                        break;
                                mEntry = mBase.mHash[mBucket];
                        }
                }

                Iter& operator=(const Iter&);

                uint32_t mBucket;
                uint32_t mEntry;
                uint32_t mTimestamp;
                HashBase& mBase;
        };
};

template <class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
template <typename HK, typename GK, class A, bool comp>
PX_NOINLINE void
HashBase<Entry, Key, HashFn, GetKey, Allocator, compacting>::copy(const HashBase<Entry, Key, HK, GK, A, comp>& other)
{
        reserve(other.mEntriesCount);

        for(uint32_t i = 0; i < other.mEntriesCount; i++)
        {
                for(uint32_t j = other.mHash[i]; j != EOL; j = other.mEntriesNext[j])
                {
                        const Entry& otherEntry = other.mEntries[j];

                        bool exists;
                        Entry* newEntry = create(GK()(otherEntry), exists);
                        PX_ASSERT(!exists);

                        PX_PLACEMENT_NEW(newEntry, Entry)(otherEntry);
                }
        }
}

template <class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
class HashSetBase
{
        PX_NOCOPY(HashSetBase)
  public:
        struct GetKey
        {
                PX_INLINE const Key& operator()(const Key& e)
                {
                        return e;
                }
        };

        typedef HashBase<Key, Key, HashFn, GetKey, Allocator, Coalesced> BaseMap;
        typedef typename BaseMap::Iter Iterator;

        HashSetBase(uint32_t initialTableSize, float loadFactor, const Allocator& alloc)
        : mBase(initialTableSize, loadFactor, alloc)
        {
        }

        HashSetBase(const Allocator& alloc) : mBase(64, 0.75f, alloc)
        {
        }

        HashSetBase(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : mBase(initialTableSize, loadFactor)
        {
        }

        bool insert(const Key& k)
        {
                bool exists;
                Key* e = mBase.create(k, exists);
                if(!exists)
                        PX_PLACEMENT_NEW(e, Key)(k);
                return !exists;
        }

        PX_INLINE bool contains(const Key& k) const
        {
                return mBase.find(k) != 0;
        }
        PX_INLINE bool erase(const Key& k)
        {
                return mBase.erase(k);
        }
        PX_INLINE uint32_t size() const
        {
                return mBase.size();
        }
        PX_INLINE uint32_t capacity() const
        {
                return mBase.capacity();
        }
        PX_INLINE void reserve(uint32_t size)
        {
                mBase.reserve(size);
        }
        PX_INLINE void clear()
        {
                mBase.clear();
        }

  protected:
        BaseMap mBase;
};

template <class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
class HashMapBase
{
        PX_NOCOPY(HashMapBase)
  public:
        typedef Pair<const Key, Value> Entry;

        struct GetKey
        {
                PX_INLINE const Key& operator()(const Entry& e)
                {
                        return e.first;
                }
        };

        typedef HashBase<Entry, Key, HashFn, GetKey, Allocator, true> BaseMap;
        typedef typename BaseMap::Iter Iterator;

        HashMapBase(uint32_t initialTableSize, float loadFactor, const Allocator& alloc)
        : mBase(initialTableSize, loadFactor, alloc)
        {
        }

        HashMapBase(const Allocator& alloc) : mBase(64, 0.75f, alloc)
        {
        }

        HashMapBase(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : mBase(initialTableSize, loadFactor)
        {
        }

        bool insert(const Key /*&*/ k, const Value /*&*/ v)
        {
                bool exists;
                Entry* e = mBase.create(k, exists);
                if(!exists)
                        PX_PLACEMENT_NEW(e, Entry)(k, v);
                return !exists;
        }

        Value& operator[](const Key& k)
        {
                bool exists;
                Entry* e = mBase.create(k, exists);
                if(!exists)
                        PX_PLACEMENT_NEW(e, Entry)(k, Value());

                return e->second;
        }

        PX_INLINE const Entry* find(const Key& k) const
        {
                return mBase.find(k);
        }
        PX_INLINE bool erase(const Key& k)
        {
                return mBase.erase(k);
        }
        PX_INLINE uint32_t size() const
        {
                return mBase.size();
        }
        PX_INLINE uint32_t capacity() const
        {
                return mBase.capacity();
        }
        PX_INLINE Iterator getIterator()
        {
                return Iterator(mBase);
        }
        PX_INLINE void reserve(uint32_t size)
        {
                mBase.reserve(size);
        }
        PX_INLINE void clear()
        {
                mBase.clear();
        }

  protected:
        BaseMap mBase;
};
}

} // namespace shdfnd
} // namespace physx

#if PX_VC
#pragma warning(pop)
#endif
#endif // #ifndef PSFOUNDATION_PSHASHINTERNALS_H

---

previous page start next page

Menu

• Homepage

Table of contents

• Modules
  • Foundation
    • Defines
      • PX_FOUNDATION_VERSION
      • PX_FOUNDATION_VERSION_BUGFIX
      • PX_FOUNDATION_VERSION_MAJOR
      • PX_FOUNDATION_VERSION_MINOR
      • PX_SORT_PARANOIA
    • Functions
      • empty
      • grow
      • partition
      • pop
      • push
      • smallSort
      • sort
      • sort
      • Stack
      • ~Stack
    • Namespaces
      • physx
    • Classes
      • physx::shdfnd::internal::Stack< Allocator >
• Class List
  • physx::shdfnd::AlignedAllocator< N, BaseAllocator >
  • Alloc
  • Allocator
  • physx::shdfnd::AllocatorTraits< T >
  • physx::shdfnd::Array< T, Alloc >
  • physx::shdfnd::AtomicLock
  • physx::shdfnd::AtomicLockCopy
  • physx::shdfnd::AtomicRwLock
  • physx::shdfnd::BufferedSocketImpl
  • physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
  • physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • physx::shdfnd::CounterFrequencyToTensOfNanos
  • physx::shdfnd::Cpu
  • physx::shdfnd::EnableIfPod< T, X >
  • physx::shdfnd::Equal< A >
  • physx::shdfnd::FPUGuard
  • physx::shdfnd::Greater< A >
  • physx::shdfnd::Hash< Key >
  • physx::shdfnd::Hash< const char * >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey
  • physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey
  • physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • physx::shdfnd::InlineArray< T, N, Alloc >
  • physx::shdfnd::Less< A >
  • physx::shdfnd::LogTwo< A >
  • physx::shdfnd::LogTwo< 1 >
  • physx::shdfnd::MutexImpl
  • physx::shdfnd::MutexT< Alloc >
  • physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • physx::shdfnd::NonTrackingAllocator
  • physx::shdfnd::Pair< F, S >
  • physx::shdfnd::Pool< T, Alloc >
  • physx::shdfnd::Pool2< T, slabSize, Alloc >
  • physx::shdfnd::PoolBase< T, Alloc >
  • physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList
  • physx::shdfnd::RawAllocator
  • physx::shdfnd::ReadWriteLock
  • physx::shdfnd::ReadWriteLockImpl
  • physx::shdfnd::ReflectionAllocator< T >
  • physx::shdfnd::Runnable
  • physx::shdfnd::ScopedAtomicLock
  • physx::shdfnd::ScopedPointer< T, Alloc >
  • physx::shdfnd::ScopedReadLock
  • physx::shdfnd::ScopedWriteLock
  • physx::shdfnd::SIMDGuard
  • physx::shdfnd::SListImpl
  • physx::shdfnd::SListT< Alloc >
  • physx::shdfnd::Socket
  • physx::shdfnd::SocketImpl
  • physx::shdfnd::internal::Stack< Allocator >
  • physx::shdfnd::SyncImpl
  • physx::shdfnd::SyncT< Alloc >
  • physx::shdfnd::TempAllocator
  • physx::shdfnd::TempAllocatorChunk
  • physx::shdfnd::ThreadImpl
  • physx::shdfnd::ThreadPriority
  • physx::shdfnd::ThreadT< Alloc >
  • physx::shdfnd::Time
  • physx::shdfnd::UnConst< T >
  • physx::shdfnd::UnConst< const T >
  • physx::shdfnd::UserAllocated
• Class Hierarchy
  • physx::shdfnd::AlignedAllocator< N, BaseAllocator >
  • Alloc
    • physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc >
      • physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > >
        • physx::shdfnd::InlineArray< T, N, Alloc >
    • physx::shdfnd::InlineAllocator< N *sizeof(void *), Alloc >
      • physx::shdfnd::Array< void *, InlineAllocator< N *sizeof(void *), Alloc > >
        • physx::shdfnd::InlineArray< void *, 64, Alloc >
    • physx::shdfnd::Array< T, Alloc >
    • physx::shdfnd::MutexT< Alloc >
    • physx::shdfnd::PoolBase< T, Alloc >
    • physx::shdfnd::ScopedPointer< T, Alloc >
    • physx::shdfnd::SListT< Alloc >
    • physx::shdfnd::SyncT< Alloc >
    • physx::shdfnd::ThreadT< Alloc >
    • physx::shdfnd::PoolBase< T, Alloc >
      • physx::shdfnd::Pool< T, Alloc >
      • physx::shdfnd::Pool2< T, slabSize, Alloc >
  • Allocator
    • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, true >
    • physx::shdfnd::internal::HashBase< Key, Key, HashFn, GetKey, Allocator, Coalesced >
  • physx::shdfnd::AllocatorTraits< T >
  • physx::shdfnd::AtomicLock
  • physx::shdfnd::AtomicLockCopy
  • physx::shdfnd::AtomicRwLock
  • physx::shdfnd::CounterFrequencyToTensOfNanos
  • physx::shdfnd::Cpu
  • physx::shdfnd::EnableIfPod< T, X >
  • physx::shdfnd::Equal< A >
  • physx::shdfnd::FPUGuard
  • physx::shdfnd::Greater< A >
  • physx::shdfnd::Hash< Key >
  • physx::shdfnd::Hash< const char * >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
    • physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
    • physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false >
    • physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true >
    • physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • physx::shdfnd::Less< A >
  • physx::shdfnd::LogTwo< A >
  • physx::shdfnd::LogTwo< 1 >
  • physx::shdfnd::MutexImpl
  • physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • physx::shdfnd::NonTrackingAllocator
  • physx::shdfnd::Pair< F, S >
  • physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList
  • physx::shdfnd::RawAllocator
  • physx::shdfnd::ReadWriteLock
  • physx::shdfnd::ReadWriteLockImpl
  • physx::shdfnd::ReflectionAllocator< T >
  • physx::shdfnd::Runnable
    • physx::shdfnd::ThreadT< Alloc >
  • physx::shdfnd::ScopedAtomicLock
  • physx::shdfnd::ScopedReadLock
  • physx::shdfnd::ScopedWriteLock
  • physx::shdfnd::SIMDGuard
  • physx::shdfnd::SListImpl
  • physx::shdfnd::SocketImpl
    • physx::shdfnd::BufferedSocketImpl
  • physx::shdfnd::internal::Stack< Allocator >
  • physx::shdfnd::SyncImpl
  • physx::shdfnd::TempAllocator
  • physx::shdfnd::TempAllocatorChunk
  • physx::shdfnd::ThreadImpl
  • physx::shdfnd::ThreadPriority
  • physx::shdfnd::Time
  • physx::shdfnd::UnConst< T >
  • physx::shdfnd::UnConst< const T >
  • physx::shdfnd::UserAllocated
    • physx::shdfnd::PoolBase< T, Alloc >
    • physx::shdfnd::Socket
    • physx::shdfnd::ThreadT< Alloc >
    • physx::shdfnd::PoolBase< T, Alloc >
  • Key
• Class Members
• Namespace List
  • physx
  • physx::shdfnd
  • physx::shdfnd::internal
• Namespace Members
• File List
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/Ps.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlignedMalloc.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlloca.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsArray.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAtomic.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBitUtils.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsCpu.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsFPU.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsGlobals.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHash.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashMap.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashSet.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineAllocator.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineArray.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsIntrinsics.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSList.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSocket.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSort.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSortInternals.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsString.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSync.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTempAllocator.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTime.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsUserAllocated.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsVersionNumber.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsFPU.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsInclude.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsIntrinsics.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAllocator.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAssert.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsGlobals.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsHeaderTest.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsString.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsTempAllocator.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsAtomic.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsCpu.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsFPU.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsMutex.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsPrintString.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSList.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSocket.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSync.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsThread.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsTime.cpp
• File Members

Get in touch

Submit feedback about this site to:

• [email protected]

© documentation.help. Design: rehmann.co.