#include <AllocatorVk.h>

Public Types
typedef tbb::concurrent_unordered_map< int, vkmm::Allocation, std::hash< int >, std::equal_to< int >, front::tbbTAllocator >	AllocMapTy
	COM VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];. More...

typedef tbb::concurrent_unordered_map< int, AllocMapTy, std::hash< int >, std::equal_to< int >, front::tbbTAllocator >	AllocMapMapTy

Public Member Functions
	Allocator_T ()

	Allocator_T (const AllocatorCreateInfo *pCreateInfo)

VkResult	Init (const AllocatorCreateInfo *pCreateInfo)

	~Allocator_T ()

const VkAllocationCallbacks *	GetAllocationCallbacks () const

VkDeviceSize	GetBufferImageGranularity () const

uint32_t	GetMemoryHeapCount () const

uint32_t	GetMemoryTypeCount () const

uint32_t	MemoryTypeIndexToHeapIndex (uint32_t memTypeIndex) const

bool	IsMemoryTypeNonCoherent (uint32_t memTypeIndex) const

VkDeviceSize	GetMemoryTypeMinAlignment (uint32_t memTypeIndex) const

bool	IsIntegratedGpu () const

void	GetBufferMemoryRequirements (VkBuffer hBuffer, VkMemoryRequirements &memReq, bool &requiresDedicatedAllocation, bool &prefersDedicatedAllocation) const

void	GetImageMemoryRequirements (VkImage hImage, VkMemoryRequirements &memReq, bool &requiresDedicatedAllocation, bool &prefersDedicatedAllocation) const

VkResult	AllocateMemory (const VkMemoryRequirements &vkMemReq, bool requiresDedicatedAllocation, bool prefersDedicatedAllocation, VkBuffer dedicatedBuffer, VkImage dedicatedImage, AllocationCreateInfo &createInfo, SuballocationType suballocType, Allocation *pAllocation)

void	FreeMemory (const Allocation allocation)

void	CalculateStats (Stats *pStats)

VkResult	Defragment (Allocation pAllocations, size_t allocationCount, VkBool32 pAllocationsChanged, const DefragmentationInfo pDefragmentationInfo, DefragmentationStats pDefragmentationStats)

void	GetAllocationInfo (Allocation hAllocation, AllocationInfo *pAllocationInfo)

bool	TouchAllocation (Allocation hAllocation)

VkResult	CreatePool (const PoolCreateInfo pCreateInfo, Pool pPool)

void	DestroyPool (Pool pool)

void	GetPoolStats (Pool pool, PoolStats *pPoolStats)

void	SetCurrentFrameIndex (uint32_t frameIndex)

uint32_t	GetCurrentFrameIndex () const

void	MakePoolAllocationsLost (Pool hPool, size_t *pLostAllocationCount)

VkResult	CheckPoolCorruption (Pool hPool)

VkResult	CheckCorruption (uint32_t memoryTypeBits)

void	CreateLostAllocation (Allocation *pAllocation)

VkResult	AllocateVulkanMemory (VkMemoryAllocateInfo pAllocateInfo, VkDeviceMemory pMemory)

void	FreeVulkanMemory (uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)

VkResult	Map (Allocation hAllocation, void **ppData)

void	Unmap (Allocation hAllocation)

VkResult	BindBufferMemory (Allocation hAllocation, VkBuffer hBuffer)

VkResult	BindImageMemory (Allocation hAllocation, VkImage hImage)

void	FlushOrInvalidateAllocation (Allocation hAllocation, VkDeviceSize offset, VkDeviceSize size, CACHE_OPERATION op)

void	FillAllocation (const Allocation hAllocation, uint8_t pattern)

VkDeviceSize	CalcPreferredBlockSize (uint32_t memTypeIndex)
	COM VmaVulkanFunctions m_VulkanFunctions;. More...

VkResult	AllocateMemoryOfType (VkDeviceSize size, VkDeviceSize alignment, bool dedicatedAllocation, VkBuffer dedicatedBuffer, VkImage dedicatedImage, AllocationCreateInfo &createInfo, uint32_t memTypeIndex, SuballocationType suballocType, Allocation *pAllocation)

VkResult	AllocateDedicatedMemory (VkDeviceSize size, SuballocationType suballocType, uint32_t memTypeIndex, bool map, bool isUserDataString, AllocationCreateInfo &createInfo, VkBuffer dedicatedBuffer, VkImage dedicatedImage, Allocation *pAllocation)

void	FreeDedicatedMemory (Allocation allocation)

Public Attributes
SRWLOCK	slim

bool	m_UseMutex

bool	m_UseKhrDedicatedAllocation

VkDevice	m_hDevice

bool	m_AllocationCallbacksSpecified

VkAllocationCallbacks	m_AllocationCallbacks

DeviceMemoryCallbacks	m_DeviceMemoryCallbacks

VkDeviceSize	m_HeapSizeLimit [VK_MAX_MEMORY_HEAPS_MIN]

VkPhysicalDeviceProperties	m_PhysicalDeviceProperties
	COM VMA_MUTEX m_HeapSizeLimitMutex;. More...

VkPhysicalDeviceMemoryProperties	m_MemProps

AllocMapMapTy	m_pDedicatedAllocations

VkDeviceSize	m_PreferredLargeHeapBlockSize
	private: More...

VkPhysicalDevice	m_PhysicalDevice

std::atomic< UINT >	m_CurrentFrameIndex

VkmmVector< Pool, StlAllocator< Pool > >	m_Pools
	COM VMA_MUTEX m_PoolsMutex;. More...

uint32_t	m_NextPoolId

Detailed Description

Definition at line 907 of file AllocatorVk.h.

Member Typedef Documentation

◆ AllocMapMapTy

typedef tbb::concurrent_unordered_map<int, AllocMapTy, std::hash<int>, std::equal_to<int>, front::tbbTAllocator> vkmm::Allocator_T::AllocMapMapTy

Definition at line 934 of file AllocatorVk.h.

◆ AllocMapTy

typedef tbb::concurrent_unordered_map<int, vkmm::Allocation, std::hash<int>, std::equal_to<int>, front::tbbTAllocator> vkmm::Allocator_T::AllocMapTy

COM VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];.

Definition at line 933 of file AllocatorVk.h.

Constructor & Destructor Documentation

◆ Allocator_T() [1/2]

vkmm::Allocator_T::Allocator_T ( )

inline

Definition at line 939 of file AllocatorVk.h.

939{};

◆ Allocator_T() [2/2]

vkmm::Allocator_T::Allocator_T ( const AllocatorCreateInfo * pCreateInfo )

COM ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);

Definition at line 1189 of file AllocatorVk.cpp.

                                                                   :
        m_UseMutex((pCreateInfo->flags& ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
        m_UseKhrDedicatedAllocation((pCreateInfo->flags& ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
        m_hDevice($device),
        m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != nullptr),
        m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
            *pCreateInfo->pAllocationCallbacks : EmptyAllocationCallbacks),
        m_PreferredLargeHeapBlockSize(0),
        m_PhysicalDevice($physicaldevice),
        m_CurrentFrameIndex(0),
        m_Pools(StlAllocator<Pool>(GetAllocationCallbacks())),
        m_NextPoolId(0)
    {
        m_UseKhrDedicatedAllocation = false;
        InitializeSRWLock(&slim);
 
#ifdef USE_HIREDIS
        rlog.SetUp();
        rlog.FlushDB(15);
#endif
 
        if (_DEBUG_DETECT_CORRUPTION)
        {
            // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
            assert(_DEBUG_MARGIN % sizeof(uint32_t) == 0);
        }
 
        assert($physicaldevice && $device);
 
#if !(DEDICATED_ALLOCATION)
        if ((pCreateInfo->flags & ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
        {
            assert(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
        }
#endif
 
        memset(&m_DeviceMemoryCallbacks, 0, sizeof(m_DeviceMemoryCallbacks));
        memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
        memset(&m_MemProps, 0, sizeof(m_MemProps));
 
        // memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
       // memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
 
        for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS_MIN; ++i)
        {
            m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
        }
 
        if (pCreateInfo->pDeviceMemoryCallbacks != nullptr)
        {
            m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
            m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
        }
 
        m_PhysicalDeviceProperties = $properties;
        m_MemProps = $memoryProperties;
 
        m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
            pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
 
        if (pCreateInfo->pHeapSizeLimit != nullptr)
        {
            for (uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
            {
                const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
                if (limit != VK_WHOLE_SIZE)
                {
                    m_HeapSizeLimit[heapIndex] = limit;
                    if (limit < m_MemProps.memoryHeaps[heapIndex].size)
                    {
                        m_MemProps.memoryHeaps[heapIndex].size = limit;
                    }
                }
            }
        }
 
 
 
        for (uint32_t memTypeIndex = 0; memTypeIndex < VK_MAX_MEMORY_TYPES_MIN; ++memTypeIndex)
        {
            /*
            const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
            m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
                this,
                memTypeIndex,
                preferredBlockSize,
                0,
                SIZE_MAX,
                GetBufferImageGranularity(),
                pCreateInfo->frameInUseCount,
                false, // isCustomPool
                false, // explicitBlockSize
                false); // linearAlgorithm
            */
            // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
            // becase minBlockCount is 0.
            m_pDedicatedAllocations[memTypeIndex] = AllocMapTy();
        }
    }

◆ ~Allocator_T()

vkmm::Allocator_T::~Allocator_T ( )

COM assert(m_Pools.empty());

COM Delete(this, m_pBlockVectors[i]);

Definition at line 1297 of file AllocatorVk.cpp.

    {
 
#ifdef USE_HIREDIS
        rlog.TearDown();
#endif
        for (size_t i = GetMemoryTypeCount(); i--; )
        {
            m_pDedicatedAllocations[i].clear();
        }
       m_pDedicatedAllocations.clear();
    }

Member Function Documentation

◆ AllocateDedicatedMemory()

VkResult vkmm::Allocator_T::AllocateDedicatedMemory	(	VkDeviceSize	size,
		SuballocationType	suballocType,
		uint32_t	memTypeIndex,
		bool	map,
		bool	isUserDataString,
		AllocationCreateInfo &	createInfo,
		VkBuffer	dedicatedBuffer,
		VkImage	dedicatedImage,
		Allocation *	pAllocation
	)

Definition at line 1315 of file AllocatorVk.cpp.

    {
 
        assert(pAllocation);
        createInfo.info.memoryTypeIndex = memTypeIndex;
        bool dedicated = true;
        if (memTypeIndex == 2 || memTypeIndex == 3 || memTypeIndex == 0) {
            if (HOST_VISIBLE_SINGLE_ALLO_MAX < size) {
                log_bad("memory out of range \n");
            }
        }
 
        if(dedicated) {
                createInfo.info.allocationSize = size;
#if DEDICATED_ALLOCATION
                VkMemoryDedicatedAllocateInfo* dedicatedAllocInfo = nullptr;
                if (m_UseKhrDedicatedAllocation)
                {
                    createInfo.info.append(dedicatedAllocInfo);
                    if (dedicatedBuffer != VK_NULL_HANDLE)
                    {
                        assert(dedicatedImage == VK_NULL_HANDLE);
                        dedicatedAllocInfo->buffer = dedicatedBuffer;
                    }
                    else if (dedicatedImage != VK_NULL_HANDLE)
                    {
                        dedicatedAllocInfo->image = dedicatedImage;
                    }
                }
#endif // #if VMA_DEDICATED_ALLOCATION
                // Allocate VkDeviceMemory.
                VkDeviceMemory hMemory = VK_NULL_HANDLE;
                VkResult res = AllocateVulkanMemory((VkMemoryAllocateInfo*)&createInfo.info, &hMemory);
                if (res < 0)
                {
                    VKMM_DEBUG_LOG("    vkAllocateMemory FAILED");
                    return res;
                }
 
                void* pMappedData = nullptr;
                if (map)
                {
                    res = vkMapMemory(
                        m_hDevice,
                        hMemory,
                        0,
                        VK_WHOLE_SIZE,
                        0,
                        &pMappedData);
                    if (res < 0)
                    {
                        VKMM_DEBUG_LOG("    vkMapMemory FAILED");
                        FreeVulkanMemory(memTypeIndex, size, hMemory);
                        return res;
                    }
                }
 
                *pAllocation = vkmm_new(this, Allocation_T)(m_CurrentFrameIndex.load(), isUserDataString);
                (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
        }
 
 
        strcpy((*pAllocation)->name, createInfo.name);
 
        if (_DEBUG_INITIALIZE_ALLOCATIONS)
        {
            FillAllocation(*pAllocation, ALLOCATION_FILL_PATTERN_CREATED);
        }
 
        {
 
            GetCTX($ctx)
                $ctx->deb.setObjectName(dedicatedBuffer, createInfo.name);
 
            AllocMapTy  pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
            pDedicatedAllocations[(*pAllocation)->ID] = (*pAllocation);
        }
 
        VKMM_DEBUG_LOG("    Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);
 
        return VK_SUCCESS;
    }

◆ AllocateMemory()

VkResult vkmm::Allocator_T::AllocateMemory	(	const VkMemoryRequirements &	vkMemReq,
		bool	requiresDedicatedAllocation,
		bool	prefersDedicatedAllocation,
		VkBuffer	dedicatedBuffer,
		VkImage	dedicatedImage,
		AllocationCreateInfo &	createInfo,
		SuballocationType	suballocType,
		Allocation *	pAllocation
	)

Definition at line 1525 of file AllocatorVk.cpp.

    {
        if ((createInfo.flags & ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
            (createInfo.flags & ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        {
            assert(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        }
        if ((createInfo.flags & ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
            (createInfo.flags & ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
        {
            assert(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        }
 
        if (requiresDedicatedAllocation)
        {
            if ((createInfo.flags & ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
            {
                assert(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
            }
            if (createInfo.pool != VK_NULL_HANDLE)
            {
                assert(0 && "Pool specified while dedicated allocation is required.");
                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
            }
        }
 
        if ((createInfo.pool != VK_NULL_HANDLE) &&
            ((createInfo.flags & (ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
        {
            assert(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        }
 
        if (createInfo.pool != VK_NULL_HANDLE)
        {
            /*/// COM
            const VkDeviceSize alignmentForPool = __max(
                vkMemReq.alignment,
                GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
            return createInfo.pool->m_BlockVector.Allocate(
                createInfo.pool,
                m_CurrentFrameIndex.load(),
                vkMemReq.size,
                alignmentForPool,
                createInfo,
                suballocType,
                pAllocation);
            */
        }
        else
        {
            // Bit mask of memory Vulkan types acceptable for this allocation.
            uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
            uint32_t memTypeIndex = UINT32_MAX;
            VkResult res = FindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
            
            if (res == VK_SUCCESS)
            {
                VkDeviceSize alignmentForMemType = __max(
                    vkMemReq.alignment,
                    GetMemoryTypeMinAlignment(memTypeIndex));
 
                res = AllocateMemoryOfType(
                    vkMemReq.size,
                    alignmentForMemType,
                    requiresDedicatedAllocation || prefersDedicatedAllocation,
                    dedicatedBuffer,
                    dedicatedImage,
                    createInfo,
                    memTypeIndex,
                    suballocType,
                    pAllocation);
                // Succeeded on first try.
                if (res == VK_SUCCESS)
                {
                    return res;
                }
                // Allocation from this memory type failed. Try other compatible memory types.
                else
                {
                    for (;;)
                    {
                        // Remove old memTypeIndex from list of possibilities.
                        memoryTypeBits &= ~(1u << memTypeIndex);
                        // Find alternative memTypeIndex.
                        res = FindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
                        if (res == VK_SUCCESS)
                        {
                            alignmentForMemType = __max(
                                vkMemReq.alignment,
                                GetMemoryTypeMinAlignment(memTypeIndex));
 
                            res = AllocateMemoryOfType(
                                vkMemReq.size,
                                alignmentForMemType,
                                requiresDedicatedAllocation || prefersDedicatedAllocation,
                                dedicatedBuffer,
                                dedicatedImage,
                                createInfo,
                                memTypeIndex,
                                suballocType,
                                pAllocation);
                            // Allocation from this alternative memory type succeeded.
                            if (res == VK_SUCCESS)
                            {
                                return res;
                            }
                            // else: Allocation from this memory type failed. Try next one - next loop iteration.
                        }
                        // No other matching memory type index could be found.
                        else
                        {
                            // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
                            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
                        }
                    }
                }
            }
            // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
            else
                return res;
        }
        assert(0);
        return (VkResult)0;
    }

◆ AllocateMemoryOfType()

VkResult vkmm::Allocator_T::AllocateMemoryOfType	(	VkDeviceSize	size,
		VkDeviceSize	alignment,
		bool	dedicatedAllocation,
		VkBuffer	dedicatedBuffer,
		VkImage	dedicatedImage,
		AllocationCreateInfo &	createInfo,
		uint32_t	memTypeIndex,
		SuballocationType	suballocType,
		Allocation *	pAllocation
	)

Definition at line 1407 of file AllocatorVk.cpp.

    {
        assert(pAllocation != nullptr);
 
        AllocationCreateInfo& finalCreateInfo = createInfo;
 
        // If memory type is not HOST_VISIBLE, disable MAPPED.
        if ((finalCreateInfo.flags & ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
            (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        {
            finalCreateInfo.flags &= ~ALLOCATION_CREATE_MAPPED_BIT;
        }
 
        /*COM
        VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
        assert(blockVector);
                const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
        */
 
        const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
 
        bool preferDedicatedMemory =
            _DEBUG_ALWAYS_DEDICATED_MEMORY ||
            dedicatedAllocation ||
            // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
            size > preferredBlockSize / 2;
 
        if (preferDedicatedMemory &&
            (finalCreateInfo.flags & ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
            finalCreateInfo.pool == VK_NULL_HANDLE)
        {
            finalCreateInfo.flags |= ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        }
 
        if ((finalCreateInfo.flags & ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
        {
            if ((finalCreateInfo.flags & ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
            {
                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
            }
            else
            {
                return AllocateDedicatedMemory(
                    size,
                    suballocType,
                    memTypeIndex,
                    (finalCreateInfo.flags & ALLOCATION_CREATE_MAPPED_BIT) != 0,
                    (finalCreateInfo.flags & ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
                    finalCreateInfo,
                    dedicatedBuffer,
                    dedicatedImage,
                    pAllocation);
            }
        }
        else
        {
            /*COM
            VkResult res = blockVector->Allocate(
                VK_NULL_HANDLE, // hCurrentPool
                m_CurrentFrameIndex.load(),
                size,
                alignment,
                finalCreateInfo,
                suballocType,
                pAllocation);
            if (res == VK_SUCCESS)
            {
                return res;
            }
 
            // 5. Try dedicated memory.
            if ((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
            {
                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
            }
            else
            {
                res = AllocateDedicatedMemory(
                    size,
                    suballocType,
                    memTypeIndex,
                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
                    finalCreateInfo.pUserData,
                    dedicatedBuffer,
                    dedicatedImage,
                    pAllocation);
                if (res == VK_SUCCESS)
                {
                    // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
                    VMA_DEBUG_LOG("    Allocated as DedicatedMemory");
                    return VK_SUCCESS;
                }
                else
                {
                    // Everything failed: Return error code.
                    VMA_DEBUG_LOG("    vkAllocateMemory FAILED");
                    return res;
                }
            }
            */
        }
 
        assert(0);
        return (VkResult)0;
 
    }

◆ AllocateVulkanMemory()

VkResult vkmm::Allocator_T::AllocateVulkanMemory	(	VkMemoryAllocateInfo *	pAllocateInfo,
		VkDeviceMemory *	pMemory
	)

VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);

Definition at line 1074 of file AllocatorVk.cpp.

    {
        const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
 
        VkResult res;
        if (m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        {
            if (m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
            {
                    res = vkAllocateMemory(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
                    if (res == VK_SUCCESS)
                    {
                        m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
 
                    }
            }
            else
            {
                res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
            }
        }
        else
        {
            res = vkAllocateMemory(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        }
 
        if (res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != nullptr)
        {
            (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
        }
 
        return res;
    }

◆ BindBufferMemory()

VkResult vkmm::Allocator_T::BindBufferMemory	(	Allocation	hAllocation,
		VkBuffer	hBuffer
	)

Definition at line 854 of file AllocatorVk.cpp.

    {
        VkResult res = VK_SUCCESS;
        switch (hAllocation->GetType())
        {
        case Allocation_T::ALLOCATION_TYPE_DEDICATED:
            res = vkBindBufferMemory(
                m_hDevice,
                hBuffer,
                hAllocation->GetMemory(),
                0); //memoryOffset
            break;
 
        case Allocation_T::ALLOCATION_TYPE_BLOCK:
        {
            /*
            VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
            VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
            res = pBlock->BindBufferMemory(this, hAllocation, hBuffer);
            */
            break;
        }
        default:
            assert(0);
        }
        return res;
    }

◆ BindImageMemory()

VkResult vkmm::Allocator_T::BindImageMemory	(	Allocation	hAllocation,
		VkImage	hImage
	)

◆ CalcPreferredBlockSize()

VkDeviceSize vkmm::Allocator_T::CalcPreferredBlockSize ( uint32_t memTypeIndex )

COM VmaVulkanFunctions m_VulkanFunctions;.

COM void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);

Definition at line 1774 of file AllocatorVk.cpp.

    {
        const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        const bool isSmallHeap = heapSize <= _SMALL_HEAP_MAX_SIZE;  //1GB
        return isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;
    }

◆ CalculateStats()

void vkmm::Allocator_T::CalculateStats ( Stats * pStats )

◆ CheckCorruption()

VkResult vkmm::Allocator_T::CheckCorruption ( uint32_t memoryTypeBits )

◆ CheckPoolCorruption()

VkResult vkmm::Allocator_T::CheckPoolCorruption ( Pool hPool )

◆ CreateLostAllocation()

void vkmm::Allocator_T::CreateLostAllocation ( Allocation * pAllocation )

◆ CreatePool()

VkResult vkmm::Allocator_T::CreatePool	(	const PoolCreateInfo *	pCreateInfo,
		Pool *	pPool
	)

◆ Defragment()

VkResult vkmm::Allocator_T::Defragment	(	Allocation *	pAllocations,
		size_t	allocationCount,
		VkBool32 *	pAllocationsChanged,
		const DefragmentationInfo *	pDefragmentationInfo,
		DefragmentationStats *	pDefragmentationStats
	)

◆ DestroyPool()

void vkmm::Allocator_T::DestroyPool ( Pool pool )

◆ FillAllocation()

void vkmm::Allocator_T::FillAllocation	(	const Allocation	hAllocation,
		uint8_t	pattern
	)

Definition at line 628 of file AllocatorVk.cpp.

    {
        if (_DEBUG_INITIALIZE_ALLOCATIONS &&
            !hAllocation->CanBecomeLost() &&
            (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        {
            void* pData = nullptr;
            VkResult res = Map(hAllocation, &pData);
            if (res == VK_SUCCESS)
            {
                memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
                FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, CACHE_FLUSH);
                Unmap(hAllocation);
            }
            else
            {
                assert(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
            }
        }
    }

◆ FlushOrInvalidateAllocation()

void vkmm::Allocator_T::FlushOrInvalidateAllocation	(	Allocation	hAllocation,
		VkDeviceSize	offset,
		VkDeviceSize	size,
		CACHE_OPERATION	op
	)

Definition at line 682 of file AllocatorVk.cpp.

    {
        const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
        if (size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
        {
            const VkDeviceSize allocationSize = hAllocation->GetSize();
            assert(offset <= allocationSize);
 
            const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
 
            VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
            memRange.memory = hAllocation->GetMemory();
 
            switch (hAllocation->GetType())
            {
            case Allocation_T::ALLOCATION_TYPE_DEDICATED:
                memRange.offset = AlignDown(offset, nonCoherentAtomSize);
                if (size == VK_WHOLE_SIZE)
                {
                    memRange.size = allocationSize - memRange.offset;
                }
                else
                {
                    assert(offset + size <= allocationSize);
                    memRange.size = __min(
                        AlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
                        allocationSize - memRange.offset);
                }
                break;
 
            case Allocation_T::ALLOCATION_TYPE_BLOCK:
            {
                /* COM
                // 1. Still within this allocation.
                memRange.offset = AlignDown(offset, nonCoherentAtomSize);
                if (size == VK_WHOLE_SIZE)
                {
                    size = allocationSize - offset;
                }
                else
                {
                    assert(offset + size <= allocationSize);
                }
                memRange.size = AlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
 
                // 2. Adjust to whole block.
                const VkDeviceSize allocationOffset = hAllocation->GetOffset();
                assert(allocationOffset % nonCoherentAtomSize == 0);
                const VkDeviceSize blockSize = hAllocation->GetBlock()->m_pMetadata->GetSize();
                memRange.offset += allocationOffset;
                memRange.size = __min(memRange.size, blockSize - memRange.offset);
 
                break;
                */
            }
 
            default:
                assert(0);
            }
 
            switch (op)
            {
            case CACHE_FLUSH:
                vkFlushMappedMemoryRanges(m_hDevice, 1, &memRange);
                break;
            case CACHE_INVALIDATE:
                vkInvalidateMappedMemoryRanges(m_hDevice, 1, &memRange);
                break;
            default:
                assert(0);
            }
        }
        // else: Just ignore this call.
    }

◆ FreeDedicatedMemory()

void vkmm::Allocator_T::FreeDedicatedMemory ( Allocation allocation )

Definition at line 1144 of file AllocatorVk.cpp.

    {
 
        assert(allocation && allocation->GetType() == Allocation_T::ALLOCATION_TYPE_DEDICATED);
 
        const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        {
            AllocMapTy  pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
            const  int id = allocation->ID;
            AcquireSRWLockExclusive(&slim);
            pDedicatedAllocations.unsafe_erase(id);
            ReleaseSRWLockExclusive(&slim);
        }
 
        VkDeviceMemory hMemory = allocation->GetMemory();
 
        if (allocation->GetMappedData() != nullptr)
        {
            vkUnmapMemory(m_hDevice, hMemory);
        }
 
        FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
 
        VKMM_DEBUG_LOG("    Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
    }

◆ FreeMemory()

void vkmm::Allocator_T::FreeMemory ( const Allocation allocation )

Definition at line 1663 of file AllocatorVk.cpp.

    {
        assert(allocation);
 
        if (TouchAllocation(allocation))
        {
            if (_DEBUG_INITIALIZE_ALLOCATIONS)
            {
                FillAllocation(allocation, ALLOCATION_FILL_PATTERN_DESTROYED);
            }
 
            switch (allocation->GetType())
            {
            case Allocation_T::ALLOCATION_TYPE_BLOCK:
            {
                /*COM
                BlockVector* pBlockVector = VMA_NULL;
                Pool hPool = allocation->GetPool();
                if (hPool != VK_NULL_HANDLE)
                {
                    pBlockVector = &hPool->m_BlockVector;
                }
                else
                {
                    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
                    pBlockVector = m_pBlockVectors[memTypeIndex];
                }
                pBlockVector->Free(allocation);
                */
            }
            break;
            case Allocation_T::ALLOCATION_TYPE_DEDICATED:
                FreeDedicatedMemory(allocation);
                break;
            default:
                assert(0);
            }
        }
 
        vkmm::Delete(this, allocation);
        
 
    }

◆ FreeVulkanMemory()

void vkmm::Allocator_T::FreeVulkanMemory	(	uint32_t	memoryType,
		VkDeviceSize	size,
		VkDeviceMemory	hMemory
	)

Definition at line 1057 of file AllocatorVk.cpp.

    {
        if (m_DeviceMemoryCallbacks.pfnFree != nullptr)
        {
            (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
        }
 
        vkFreeMemory(m_hDevice, hMemory, GetAllocationCallbacks());
 
        const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
        if (m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        {
            //VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
            m_HeapSizeLimit[heapIndex] += size;
        }
    }

◆ GetAllocationCallbacks()

const VkAllocationCallbacks * vkmm::Allocator_T::GetAllocationCallbacks ( ) const

inline

Definition at line 944 of file AllocatorVk.h.

        {
            return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
        }

◆ GetAllocationInfo()

void vkmm::Allocator_T::GetAllocationInfo	(	Allocation	hAllocation,
		AllocationInfo *	pAllocationInfo
	)

Definition at line 575 of file AllocatorVk.cpp.

    {
        if (hAllocation->CanBecomeLost())
        {
            /*
            Warning: This is a carefully designed algorithm.
            Do not modify unless you really know what you're doing :)
            */
            const uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
            uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
            for (;;)
            {
                if (localLastUseFrameIndex == FRAME_INDEX_LOST)
                {
                    pAllocationInfo->memoryType = UINT32_MAX;
                    pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
                    pAllocationInfo->offset = 0;
                    pAllocationInfo->size = hAllocation->GetSize();
                    pAllocationInfo->pMappedData = nullptr;
                    pAllocationInfo->pUserData = hAllocation->GetUserData();
                    return;
                }
                else if (localLastUseFrameIndex == localCurrFrameIndex)
                {
                    pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
                    pAllocationInfo->deviceMemory = hAllocation->GetMemory();
                    pAllocationInfo->offset = hAllocation->GetOffset();
                    pAllocationInfo->size = hAllocation->GetSize();
                    pAllocationInfo->pMappedData = nullptr;
                    pAllocationInfo->pUserData = hAllocation->GetUserData();
                    return;
                }
                else // Last use time earlier than current time.
                {
                    if (hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
                    {
                        localLastUseFrameIndex = localCurrFrameIndex;
                    }
                }
            }
        }
        else
        {
 
 
            pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
            pAllocationInfo->deviceMemory = hAllocation->GetMemory();
            pAllocationInfo->offset = hAllocation->GetOffset();
            pAllocationInfo->size = hAllocation->GetSize();
            pAllocationInfo->pMappedData = hAllocation->GetMappedData();
            pAllocationInfo->pUserData = hAllocation->GetUserData();
        }
    }

◆ GetBufferImageGranularity()

VkDeviceSize vkmm::Allocator_T::GetBufferImageGranularity ( ) const

inline

Definition at line 950 of file AllocatorVk.h.

        {
            return __max(
                static_cast<VkDeviceSize>(_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
                m_PhysicalDeviceProperties.limits.bufferImageGranularity);
        }

◆ GetBufferMemoryRequirements()

void vkmm::Allocator_T::GetBufferMemoryRequirements	(	VkBuffer	hBuffer,
		VkMemoryRequirements &	memReq,
		bool &	requiresDedicatedAllocation,
		bool &	prefersDedicatedAllocation
	)		const

Definition at line 1110 of file AllocatorVk.cpp.

    {
 
#if DEDICATED_ALLOCATION
        if (m_UseKhrDedicatedAllocation)
        {
            VkBufferMemoryRequirementsInfo2 memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 };
            memReqInfo.buffer = hBuffer;
 
            VkMemoryDedicatedRequirements memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS };
 
            VkMemoryRequirements2 memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 };
            memReq2.pNext = &memDedicatedReq;
 
            vkGetBufferMemoryRequirements2(m_hDevice, &memReqInfo, &memReq2);
 
            memReq = memReq2.memoryRequirements;
            requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
            prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
 
        }
        else
#endif // #if VMA_DEDICATED_ALLOCATION
        {
            vkGetBufferMemoryRequirements(m_hDevice, hBuffer, &memReq);
            requiresDedicatedAllocation = false;
            prefersDedicatedAllocation = false;
        }
    }

◆ GetCurrentFrameIndex()

uint32_t vkmm::Allocator_T::GetCurrentFrameIndex ( ) const

inline

Definition at line 1034 of file AllocatorVk.h.

1034{ return m_CurrentFrameIndex.load(); }

◆ GetImageMemoryRequirements()

void vkmm::Allocator_T::GetImageMemoryRequirements	(	VkImage	hImage,
		VkMemoryRequirements &	memReq,
		bool &	requiresDedicatedAllocation,
		bool &	prefersDedicatedAllocation
	)		const

◆ GetMemoryHeapCount()

uint32_t vkmm::Allocator_T::GetMemoryHeapCount ( ) const

inline

Definition at line 957 of file AllocatorVk.h.

957{ return m_MemProps.memoryHeapCount; }

◆ GetMemoryTypeCount()

uint32_t vkmm::Allocator_T::GetMemoryTypeCount ( ) const

inline

Definition at line 958 of file AllocatorVk.h.

958{ return m_MemProps.memoryTypeCount; }

◆ GetMemoryTypeMinAlignment()

VkDeviceSize vkmm::Allocator_T::GetMemoryTypeMinAlignment ( uint32_t memTypeIndex ) const

inline

Definition at line 972 of file AllocatorVk.h.

        {
            return IsMemoryTypeNonCoherent(memTypeIndex) ?
                __max((VkDeviceSize)_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
                (VkDeviceSize)_DEBUG_ALIGNMENT;
        }

◆ GetPoolStats()

void vkmm::Allocator_T::GetPoolStats	(	Pool	pool,
		PoolStats *	pPoolStats
	)

◆ Init()

VkResult vkmm::Allocator_T::Init ( const AllocatorCreateInfo * pCreateInfo )

Definition at line 1290 of file AllocatorVk.cpp.

    {
        VkResult res = VK_SUCCESS;
 
        return res;
    }

◆ IsIntegratedGpu()

bool vkmm::Allocator_T::IsIntegratedGpu ( ) const

inline

Definition at line 979 of file AllocatorVk.h.

        {
            return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
        }

◆ IsMemoryTypeNonCoherent()

bool vkmm::Allocator_T::IsMemoryTypeNonCoherent ( uint32_t memTypeIndex ) const

inline

Definition at line 966 of file AllocatorVk.h.

        {
            return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        }

◆ MakePoolAllocationsLost()

void vkmm::Allocator_T::MakePoolAllocationsLost	(	Pool	hPool,
		size_t *	pLostAllocationCount
	)

◆ Map()

VkResult vkmm::Allocator_T::Map	(	Allocation	hAllocation,
		void **	ppData
	)

Definition at line 882 of file AllocatorVk.cpp.

    {
        if (hAllocation->CanBecomeLost())
        {
            return VK_ERROR_MEMORY_MAP_FAILED;
        }
 
        switch (hAllocation->GetType())
        {
        case Allocation_T::ALLOCATION_TYPE_BLOCK:
        {
            /*COM
            DeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
            char* pBytes = VMA_NULL;
            VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
            if (res == VK_SUCCESS)
            {
                *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
                hAllocation->BlockAllocMap();
            }
            return res;
            */
        }
        case Allocation_T::ALLOCATION_TYPE_DEDICATED:
            return hAllocation->DedicatedAllocMap(this, ppData);
        default:
            assert(0);
            return VK_ERROR_MEMORY_MAP_FAILED;
        }
    }

◆ MemoryTypeIndexToHeapIndex()

uint32_t vkmm::Allocator_T::MemoryTypeIndexToHeapIndex ( uint32_t memTypeIndex ) const

inline

Definition at line 960 of file AllocatorVk.h.

        {
            assert(memTypeIndex < m_MemProps.memoryTypeCount);
            return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        }

◆ SetCurrentFrameIndex()

void vkmm::Allocator_T::SetCurrentFrameIndex ( uint32_t frameIndex )

◆ TouchAllocation()

bool vkmm::Allocator_T::TouchAllocation ( Allocation hAllocation )

Definition at line 648 of file AllocatorVk.cpp.

    {
        // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
        if (hAllocation->CanBecomeLost())
        {
            uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
            uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
            for (;;)
            {
                if (localLastUseFrameIndex == FRAME_INDEX_LOST)
                {
                    return false;
                }
                else if (localLastUseFrameIndex == localCurrFrameIndex)
                {
                    return true;
                }
                else // Last use time earlier than current time.
                {
                    if (hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
                    {
                        localLastUseFrameIndex = localCurrFrameIndex;
                    }
                }
            }
        }
        else
        {
 
 
            return true;
        }
    }

◆ Unmap()

void vkmm::Allocator_T::Unmap ( Allocation hAllocation )

Definition at line 913 of file AllocatorVk.cpp.

    {
        switch (hAllocation->GetType())
        {
        case Allocation_T::ALLOCATION_TYPE_BLOCK:
        {
            /*
            VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
            hAllocation->BlockAllocUnmap();
            pBlock->Unmap(this, 1);
            */
        }
        break;
        case Allocation_T::ALLOCATION_TYPE_DEDICATED:
            hAllocation->DedicatedAllocUnmap(this);
            break;
        default:
            assert(0);
        }
    }

Member Data Documentation

◆ m_AllocationCallbacks

VkAllocationCallbacks vkmm::Allocator_T::m_AllocationCallbacks

Definition at line 918 of file AllocatorVk.h.

◆ m_AllocationCallbacksSpecified

bool vkmm::Allocator_T::m_AllocationCallbacksSpecified

Definition at line 917 of file AllocatorVk.h.

◆ m_CurrentFrameIndex

std::atomic<UINT> vkmm::Allocator_T::m_CurrentFrameIndex

Definition at line 1064 of file AllocatorVk.h.

◆ m_DeviceMemoryCallbacks

DeviceMemoryCallbacks vkmm::Allocator_T::m_DeviceMemoryCallbacks

Definition at line 919 of file AllocatorVk.h.

◆ m_hDevice

VkDevice vkmm::Allocator_T::m_hDevice

Definition at line 916 of file AllocatorVk.h.

◆ m_HeapSizeLimit

VkDeviceSize vkmm::Allocator_T::m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS_MIN]

Definition at line 922 of file AllocatorVk.h.

◆ m_MemProps

VkPhysicalDeviceMemoryProperties vkmm::Allocator_T::m_MemProps

Definition at line 926 of file AllocatorVk.h.

◆ m_NextPoolId

uint32_t vkmm::Allocator_T::m_NextPoolId

Definition at line 1069 of file AllocatorVk.h.

◆ m_pDedicatedAllocations

AllocMapMapTy vkmm::Allocator_T::m_pDedicatedAllocations

Definition at line 936 of file AllocatorVk.h.

◆ m_PhysicalDevice

VkPhysicalDevice vkmm::Allocator_T::m_PhysicalDevice

Definition at line 1063 of file AllocatorVk.h.

◆ m_PhysicalDeviceProperties

VkPhysicalDeviceProperties vkmm::Allocator_T::m_PhysicalDeviceProperties

COM VMA_MUTEX m_HeapSizeLimitMutex;.

Definition at line 925 of file AllocatorVk.h.

◆ m_Pools

VkmmVector<Pool, StlAllocator<Pool> > vkmm::Allocator_T::m_Pools

COM VMA_MUTEX m_PoolsMutex;.

Definition at line 1068 of file AllocatorVk.h.

◆ m_PreferredLargeHeapBlockSize

VkDeviceSize vkmm::Allocator_T::m_PreferredLargeHeapBlockSize

private:

Definition at line 1061 of file AllocatorVk.h.

◆ m_UseKhrDedicatedAllocation

bool vkmm::Allocator_T::m_UseKhrDedicatedAllocation

Definition at line 915 of file AllocatorVk.h.

◆ m_UseMutex

bool vkmm::Allocator_T::m_UseMutex

Definition at line 914 of file AllocatorVk.h.

◆ slim

SRWLOCK vkmm::Allocator_T::slim

Definition at line 912 of file AllocatorVk.h.

The documentation for this struct was generated from the following files:

Public Types

Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ AllocMapMapTy

◆ AllocMapTy

Constructor & Destructor Documentation

◆ Allocator_T() [1/2]

◆ Allocator_T() [2/2]

◆ ~Allocator_T()

Member Function Documentation

◆ AllocateDedicatedMemory()

◆ AllocateMemory()

◆ AllocateMemoryOfType()

◆ AllocateVulkanMemory()

◆ BindBufferMemory()

◆ BindImageMemory()

◆ CalcPreferredBlockSize()

◆ CalculateStats()

◆ CheckCorruption()

◆ CheckPoolCorruption()

◆ CreateLostAllocation()

◆ CreatePool()

◆ Defragment()

◆ DestroyPool()

◆ FillAllocation()

◆ FlushOrInvalidateAllocation()

◆ FreeDedicatedMemory()

◆ FreeMemory()

◆ FreeVulkanMemory()

◆ GetAllocationCallbacks()

◆ GetAllocationInfo()

◆ GetBufferImageGranularity()

◆ GetBufferMemoryRequirements()

◆ GetCurrentFrameIndex()

◆ GetImageMemoryRequirements()

◆ GetMemoryHeapCount()

◆ GetMemoryTypeCount()

◆ GetMemoryTypeMinAlignment()

◆ GetPoolStats()

◆ Init()

◆ IsIntegratedGpu()

◆ IsMemoryTypeNonCoherent()

◆ MakePoolAllocationsLost()

◆ Map()

◆ MemoryTypeIndexToHeapIndex()

◆ SetCurrentFrameIndex()

◆ TouchAllocation()

◆ Unmap()

Member Data Documentation

◆ m_AllocationCallbacks

◆ m_AllocationCallbacksSpecified

◆ m_CurrentFrameIndex

◆ m_DeviceMemoryCallbacks

◆ m_hDevice

◆ m_HeapSizeLimit

◆ m_MemProps

◆ m_NextPoolId

◆ m_pDedicatedAllocations

◆ m_PhysicalDevice

◆ m_PhysicalDeviceProperties

◆ m_Pools

◆ m_PreferredLargeHeapBlockSize

◆ m_UseKhrDedicatedAllocation

◆ m_UseMutex

◆ slim