vkmm Namespace Reference

interface More...

Classes
struct	Allocation_T
struct	AllocationCreateInfo
struct	AllocationInfo
struct	Allocator_T
struct	AllocatorCreateInfo
struct	BufferAllocation
struct	DefragmentationInfo
struct	DefragmentationStats
struct	DeviceMemoryCallbacks
struct	MemoryVk
struct	PointerLess
struct	PoolCreateInfo
struct	PoolStats
struct	StatInfo
struct	Stats
	General statistics from current state of Allocator. More...
class	StlAllocator
struct	VkMAInfo

Typedefs
typedef void(VKAPI_PTR *	PFN_AllocateDeviceMemoryFunction) (Allocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
	VK_DEFINE_HANDLE(Allocator) More...
typedef void(VKAPI_PTR *	PFN_FreeDeviceMemoryFunction) (Allocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
	Callback function called before vkFreeMemory. More...
typedef struct vkmm::DeviceMemoryCallbacks	DeviceMemoryCallbacks
typedef enum vkmm::AllocatorCreateFlagBits	AllocatorCreateFlagBits
typedef VkFlags	AllocatorCreateFlags
typedef struct vkmm::AllocatorCreateInfo	AllocatorCreateInfo
typedef struct vkmm::StatInfo	StatInfo
typedef struct vkmm::Stats	Stats
	General statistics from current state of Allocator. More...
typedef enum vkmm::MemoryUsage	MemoryUsage
typedef enum vkmm::AllocationCreateFlagBits	AllocationCreateFlagBits
typedef VkFlags	AllocationCreateFlags
typedef struct vkmm::AllocationCreateInfo	AllocationCreateInfo
typedef enum vkmm::PoolCreateFlagBits	PoolCreateFlagBits
typedef VkFlags	PoolCreateFlags
typedef struct vkmm::PoolCreateInfo	PoolCreateInfo
typedef struct vkmm::PoolStats	PoolStats
typedef struct vkmm::AllocationInfo	AllocationInfo
typedef struct vkmm::DefragmentationInfo	DefragmentationInfo
typedef struct vkmm::DefragmentationStats	DefragmentationStats
typedef struct Allocator_T *	Allocator

Enumerations
enum	AllocatorCreateFlagBits { ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001 , ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002 , ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF }
enum	MemoryUsage {   MEMORY_USAGE_UNKNOWN = 0 , MEMORY_USAGE_GPU =1 , MEMORY_USAGE_GPU_ONLY = 2 , MEMORY_USAGE_CPU_ONLY = 3 ,   MEMORY_USAGE_CPU_TO_GPU = 4 , MEMORY_USAGE_GPU_TO_CPU = 5 , MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF }
enum	AllocationCreateFlagBits {   ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001 , ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002 , ALLOCATION_CREATE_MAPPED_BIT = 0x00000004 , ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008 ,   ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010 , ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020 , ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040 , ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF }
enum	PoolCreateFlagBits { POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002 , POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004 , POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF }
enum	SuballocationType {   SUBALLOCATION_TYPE_FREE = 0 , SUBALLOCATION_TYPE_UNKNOWN = 1 , SUBALLOCATION_TYPE_BUFFER = 2 , SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3 ,   SUBALLOCATION_TYPE_IMAGE_LINEAR = 4 , SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5 , SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF }
enum	CACHE_OPERATION { CACHE_FLUSH , CACHE_INVALIDATE }

Functions
VkResult	CreateAllocator (const AllocatorCreateInfo *pCreateInfo, Allocator *pAllocator)
VkResult	MapMemory (Allocator allocator, Allocation allocation, void **ppData)
void	UnmapMemory (Allocator allocator, Allocation allocation)
template<typename CmpLess , typename VectorT >
bool	VectorRemoveSorted (VectorT &v, typename VectorT::value_type &value)
template<typename CmpLess , typename VectorT >
size_t	VectorInsertSorted (VectorT &vector, const typename VectorT::value_type &value)
template<typename P , typename T >
void	append_pNext (P &parent, T &child)
template<typename T >
void	_printbits (T number, unsigned int num_bits_to_print)
template<typename T >
void	printbits (T number)
VkResult	FindMemoryTypeIndex (Allocator allocator, uint32_t memoryTypeBits, AllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
VkResult	CreateBuffer (Allocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, AllocationCreateInfo &pAllocationCreateInfo, VkBuffer *pBuffer, Allocation *pAllocation, AllocationInfo *pAllocationInfo)
void	DestroyBuffer (Allocator allocator, VkBuffer buffer, Allocation allocation)
void *	Malloc (Allocator hAllocator, size_t size, size_t alignment)
void	Free (Allocator hAllocator, void *ptr)
template<typename T >
T	RoundDiv (T x, T y)

Detailed Description

interface

block

allocate

vulkan

utils

vector

Typedef Documentation

AllocationCreateFlagBits

typedef enum vkmm::AllocationCreateFlagBits vkmm::AllocationCreateFlagBits

AllocationCreateFlags

typedef VkFlags vkmm::AllocationCreateFlags

Definition at line 625 of file AllocatorVk.h.

AllocationCreateInfo

typedef struct vkmm::AllocationCreateInfo vkmm::AllocationCreateInfo

AllocationInfo

typedef struct vkmm::AllocationInfo vkmm::AllocationInfo

Allocator

typedef struct Allocator_T* vkmm::Allocator

Definition at line 68 of file vthreepy_types.h.

AllocatorCreateFlagBits

typedef enum vkmm::AllocatorCreateFlagBits vkmm::AllocatorCreateFlagBits

Description of a Allocator to be created. /// Flags for created #VmaAllocator.

AllocatorCreateFlags

typedef VkFlags vkmm::AllocatorCreateFlags

Definition at line 550 of file AllocatorVk.h.

AllocatorCreateInfo

typedef struct vkmm::AllocatorCreateInfo vkmm::AllocatorCreateInfo

DefragmentationInfo

typedef struct vkmm::DefragmentationInfo vkmm::DefragmentationInfo

DefragmentationStats

typedef struct vkmm::DefragmentationStats vkmm::DefragmentationStats

DeviceMemoryCallbacks

typedef struct vkmm::DeviceMemoryCallbacks vkmm::DeviceMemoryCallbacks

MemoryUsage

typedef enum vkmm::MemoryUsage vkmm::MemoryUsage

PFN_AllocateDeviceMemoryFunction

typedef void(VKAPI_PTR * vkmm::PFN_AllocateDeviceMemoryFunction) (Allocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)

VK_DEFINE_HANDLE(Allocator)

Definition at line 522 of file AllocatorVk.h.

PFN_FreeDeviceMemoryFunction

typedef void(VKAPI_PTR * vkmm::PFN_FreeDeviceMemoryFunction) (Allocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)

Callback function called before vkFreeMemory.

Definition at line 528 of file AllocatorVk.h.

PoolCreateFlagBits

typedef enum vkmm::PoolCreateFlagBits vkmm::PoolCreateFlagBits

PoolCreateFlags

typedef VkFlags vkmm::PoolCreateFlags

Definition at line 654 of file AllocatorVk.h.

PoolCreateInfo

typedef struct vkmm::PoolCreateInfo vkmm::PoolCreateInfo

PoolStats

typedef struct vkmm::PoolStats vkmm::PoolStats

StatInfo

typedef struct vkmm::StatInfo vkmm::StatInfo

Stats

typedef struct vkmm::Stats vkmm::Stats

General statistics from current state of Allocator.

Enumeration Type Documentation

AllocationCreateFlagBits

enum vkmm::AllocationCreateFlagBits

Enumerator
ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
ALLOCATION_CREATE_NEVER_ALLOCATE_BIT
ALLOCATION_CREATE_MAPPED_BIT
ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
ALLOCATION_CREATE_UPPER_ADDRESS_BIT
ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM

Definition at line 607 of file AllocatorVk.h.

                                              {
  
        ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
 
        ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
 
        ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
 
        ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
 
        ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
 
        ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
 
        ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
 
        ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    } AllocationCreateFlagBits;

AllocatorCreateFlagBits

enum vkmm::AllocatorCreateFlagBits

Description of a Allocator to be created. /// Flags for created #VmaAllocator.

Enumerator
ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM

Definition at line 542 of file AllocatorVk.h.

                                         {
        ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
 
        ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
 
        ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    } AllocatorCreateFlagBits;

CACHE_OPERATION

enum vkmm::CACHE_OPERATION

Enumerator
CACHE_FLUSH
CACHE_INVALIDATE

Definition at line 903 of file AllocatorVk.h.

{ CACHE_FLUSH, CACHE_INVALIDATE };

MemoryUsage

enum vkmm::MemoryUsage

Enumerator
MEMORY_USAGE_UNKNOWN
MEMORY_USAGE_GPU
MEMORY_USAGE_GPU_ONLY
MEMORY_USAGE_CPU_ONLY
MEMORY_USAGE_CPU_TO_GPU
MEMORY_USAGE_GPU_TO_CPU
MEMORY_USAGE_MAX_ENUM

Definition at line 596 of file AllocatorVk.h.

    {
 
        MEMORY_USAGE_UNKNOWN = 0,
        MEMORY_USAGE_GPU          =1,
        MEMORY_USAGE_GPU_ONLY = 2,
       MEMORY_USAGE_CPU_ONLY = 3,
        MEMORY_USAGE_CPU_TO_GPU = 4,
        MEMORY_USAGE_GPU_TO_CPU = 5,
        MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
    } MemoryUsage;

PoolCreateFlagBits

enum vkmm::PoolCreateFlagBits

Enumerator
POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT
POOL_CREATE_LINEAR_ALGORITHM_BIT
POOL_CREATE_FLAG_BITS_MAX_ENUM

Definition at line 646 of file AllocatorVk.h.

                                    {
 
        POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
 
        POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
 
       POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    } PoolCreateFlagBits;

SuballocationType

enum vkmm::SuballocationType

Enumerator
SUBALLOCATION_TYPE_FREE
SUBALLOCATION_TYPE_UNKNOWN
SUBALLOCATION_TYPE_BUFFER
SUBALLOCATION_TYPE_IMAGE_UNKNOWN
SUBALLOCATION_TYPE_IMAGE_LINEAR
SUBALLOCATION_TYPE_IMAGE_OPTIMAL
SUBALLOCATION_TYPE_MAX_ENUM

Definition at line 738 of file AllocatorVk.h.

    {
        SUBALLOCATION_TYPE_FREE = 0,
        SUBALLOCATION_TYPE_UNKNOWN = 1,
        SUBALLOCATION_TYPE_BUFFER = 2,
        SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
        SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
        SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
        SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
    };

Function Documentation

_printbits()

template<typename T >

void vkmm::_printbits	(	T	number,
		unsigned int	num_bits_to_print
	)

Definition at line 391 of file AllocatorVk.cpp.

    {
        if (number || num_bits_to_print > 0) {
            _printbits(number >> (T)1, num_bits_to_print - 1);
            printf("%d", ((int)number) & 1);
        }
    }

append_pNext()

template<typename P , typename T >

void vkmm::append_pNext	(	P &	parent,
		T &	child
	)

Definition at line 375 of file AllocatorVk.cpp.

    {
 
        struct ExtensionHeader 
        {
            VkStructureType sType;
            void* pNext;
        };
 
        auto last = (ExtensionHeader*)&parent;
        while (last->pNext != nullptr)last = (ExtensionHeader*)last->pNext;
        last->pNext = &child;
 
    }

CreateAllocator()

VkResult vkmm::CreateAllocator	(	const AllocatorCreateInfo *	pCreateInfo,
		Allocator *	pAllocator
	)

Definition at line 228 of file AllocatorVk.cpp.

    {
        assert(pCreateInfo && pAllocator);
        *pAllocator = vkmm_new(pCreateInfo->pAllocationCallbacks, Allocator_T)(pCreateInfo);
        return (*pAllocator)->Init(pCreateInfo);
    }

CreateBuffer()

VkResult vkmm::CreateBuffer	(	Allocator	allocator,
		const VkBufferCreateInfo *	pBufferCreateInfo,
		AllocationCreateInfo &	pAllocationCreateInfo,
		VkBuffer *	pBuffer,
		Allocation *	pAllocation,
		AllocationInfo *	pAllocationInfo
	)

VMA_DEBUG_GLOBAL_MUTEX_LOCK

Definition at line 934 of file AllocatorVk.cpp.

    {
        assert(allocator && pBufferCreateInfo && &pAllocationCreateInfo && pBuffer && pAllocation);
 
        *pBuffer = VK_NULL_HANDLE;
        *pAllocation = VK_NULL_HANDLE;
        VkResult res = vkCreateBuffer(
            allocator->m_hDevice,
            pBufferCreateInfo,
            allocator->GetAllocationCallbacks(),
            pBuffer);
        if (res >= 0)
        {
 
            VkMemoryRequirements vkMemReq = {};
            bool requiresDedicatedAllocation = false;
            bool prefersDedicatedAllocation = false;
            allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
                requiresDedicatedAllocation, prefersDedicatedAllocation);
 
            if ((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
            {
                assert(vkMemReq.alignment %
                    allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
            }
            if ((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
            {
                assert(vkMemReq.alignment %
                    allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
            }
            if ((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
            {
                assert(vkMemReq.alignment %
                    allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
            }
 
            
            if ((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0) {
                VkMemoryAllocateFlagsInfo* info = nullptr;
                pAllocationCreateInfo.info.append(info);
                info->deviceMask = 0;
                info->flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT | VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
            }
            
 
           
 
            res = allocator->AllocateMemory(
                vkMemReq,
                requiresDedicatedAllocation,
                prefersDedicatedAllocation,
                *pBuffer,
                VK_NULL_HANDLE,
                pAllocationCreateInfo,
                SUBALLOCATION_TYPE_BUFFER,
                pAllocation);
 
            if (res >= 0)
            {
 
                res = allocator->BindBufferMemory(*pAllocation, *pBuffer);
                if (res >= 0)
                {
 
#if VMA_STATS_STRING_ENABLED
                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
#endif
                    if (pAllocationInfo != nullptr)
                    {
                        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
                    }
 
                    return VK_SUCCESS;
                }
 
                allocator->FreeMemory(*pAllocation);
                *pAllocation = VK_NULL_HANDLE;
                vkDestroyBuffer(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
                *pBuffer = VK_NULL_HANDLE;
                return res;
            }
 
            vkDestroyBuffer(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
            *pBuffer = VK_NULL_HANDLE;
            return res;
        }
        return res;
    }

DestroyBuffer()

void vkmm::DestroyBuffer	(	Allocator	allocator,
		VkBuffer	buffer,
		Allocation	allocation
	)

VKMM_DEBUG_GLOBAL_MUTEX_LOCK

Definition at line 1030 of file AllocatorVk.cpp.

    {
 
        assert(allocator);
        if (buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        {
            return;
        }
 
        VKMM_DEBUG_LOG("DestroyBuffer");
 
 
        if (buffer != VK_NULL_HANDLE)
        {
            vkDestroyBuffer(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
        }
 
        if (allocation != VK_NULL_HANDLE)
        {
            allocator->FreeMemory(allocation);
        }
    }

FindMemoryTypeIndex()

VkResult vkmm::FindMemoryTypeIndex	(	Allocator	allocator,
		uint32_t	memoryTypeBits,
		AllocationCreateInfo *	pAllocationCreateInfo,
		uint32_t *	pMemoryTypeIndex
	)

Definition at line 425 of file AllocatorVk.cpp.

    {
        assert(allocator != VK_NULL_HANDLE);
        assert(pAllocationCreateInfo != nullptr);
        assert(pMemoryTypeIndex != nullptr);
 
        if (pAllocationCreateInfo->memoryTypeBits != 0)
        {
            memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
        }
 
        uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
        uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
 
        const bool mapped = (pAllocationCreateInfo->flags & ALLOCATION_CREATE_MAPPED_BIT) != 0;
        if (mapped)
        {
            preferredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        }
 
        // Convert usage to requiredFlags and preferredFlags.
        switch (pAllocationCreateInfo->usage)
        {
        case MEMORY_USAGE_UNKNOWN:
            break;
        case MEMORY_USAGE_GPU_ONLY:
            if (!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
            {
                requiredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
            }
            break;
 
        case MEMORY_USAGE_GPU:
            if (!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
            {
                preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
            }
            break;
        case MEMORY_USAGE_CPU_ONLY:
            requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
            break;
        case MEMORY_USAGE_CPU_TO_GPU:
            requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
            if ( (pAllocationCreateInfo->flags & ALLOCATION_CREATE_MAPPED_BIT) == 0) {
                pAllocationCreateInfo->flags |= ALLOCATION_CREATE_MAPPED_BIT;
            }
            if (!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
            {
                preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
            }
            break;
        case MEMORY_USAGE_GPU_TO_CPU:
            requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
            preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
            break;
        default:
            break;
        }
 
        /*
        printf("memTypeBit Request  ");
        printbits(memoryTypeBits);
 
        printf("memTypeBit Require  ");
        printbits(requiredFlags);
 
        printf("memTypeBit Prefered  ");
        printbits(preferredFlags);
 
        for (uint32_t memTypeIndex = 0, memTypeBit = 1;
            memTypeIndex < allocator->GetMemoryTypeCount();
            ++memTypeIndex, memTypeBit <<= 1)
        {
            // This memory type is acceptable according to memoryTypeBits bitmask.
            printf("memTypeBit[%d]     ", memTypeIndex);
            printbits(memTypeBit);
            printf(" propFlags .ex{Cache | Coherent | Visible|  DeviceLocal ,None}  [%d]   ", memTypeIndex);
            printbits(allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags);
 
        }
        */
        *pMemoryTypeIndex = UINT32_MAX;
        uint32_t minCost = UINT32_MAX;
        for (uint32_t memTypeIndex = 0, memTypeBit = 1;
            memTypeIndex < allocator->GetMemoryTypeCount();
            ++memTypeIndex, memTypeBit <<= 1)
        {
 
            if ((memTypeBit & memoryTypeBits) != 0)
            {
                const VkMemoryPropertyFlags currFlags =
                    allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
                // This memory type contains requiredFlags.
                if ((requiredFlags & ~currFlags) == 0)
                {
                    // Calculate cost as number of bits from preferredFlags not present in this memory type.
                    uint32_t currCost = CountBitsSet(preferredFlags & ~currFlags);
                    // Remember memory type with lowest cost.
                    if (currCost < minCost)
                    {
                        *pMemoryTypeIndex = memTypeIndex;
                        if (currCost == 0)
                        {
                            return VK_SUCCESS;
                        }
                        minCost = currCost;
                    }
                }
            }
        }
        return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
    }

Free()

void vkmm::Free	(	Allocator	hAllocator,
		void *	ptr
	)

Definition at line 1184 of file AllocatorVk.cpp.

    {
        Free(&hAllocator->m_AllocationCallbacks, ptr);
    }

Malloc()

void * vkmm::Malloc	(	Allocator	hAllocator,
		size_t	size,
		size_t	alignment
	)

Definition at line 1179 of file AllocatorVk.cpp.

    {
        return Malloc(&hAllocator->m_AllocationCallbacks, size, alignment);
    }

MapMemory()

VkResult vkmm::MapMemory	(	Allocator	allocator,
		Allocation	allocation,
		void **	ppData
	)

Definition at line 238 of file AllocatorVk.cpp.

    {
        assert(allocator && allocation && ppData);
 
        //VMA_DEBUG_GLOBAL_MUTEX_LOCK
 
        VkResult res = allocator->Map(allocation, ppData);
 
        return res;
    }

printbits()

template<typename T >

void vkmm::printbits

(

T

number

)

Definition at line 399 of file AllocatorVk.cpp.

    {
        if (number < 0) {
            printf(" Negative Binary : You should use unsigned type.\n");
            return;
        };
 
        printf("0B");
        _printbits(number, 8 * sizeof(T));
        printf("\n");
 
    }

RoundDiv()

template<typename T >

T vkmm::RoundDiv ( T  x, T  y  )

inline

Definition at line 1403 of file AllocatorVk.h.

    {
        return (x + (y / (T)2)) / y;
    }

UnmapMemory()

void vkmm::UnmapMemory	(	Allocator	allocator,
		Allocation	allocation
	)

Definition at line 252 of file AllocatorVk.cpp.

    {
        assert(allocator && allocation);
        //VMA_DEBUG_GLOBAL_MUTEX_LOCK
        allocator->Unmap(allocation);
 
    }

VectorInsertSorted()

template<typename CmpLess , typename VectorT >

size_t vkmm::VectorInsertSorted	(	VectorT &	vector,
		const typename VectorT::value_type &	value
	)

Definition at line 341 of file AllocatorVk.cpp.

    {
        
        const size_t indexToInsert = BinaryFindFirstNotLess(
            vector.data(),
            vector.data() + vector.size(),
            value,
            CmpLess()) - vector.data();
        
        VectorInsert(vector, indexToInsert, value);
        return indexToInsert;
    }

VectorRemoveSorted()

template<typename CmpLess , typename VectorT >

bool vkmm::VectorRemoveSorted	(	VectorT &	v,
		typename VectorT::value_type &	value
	)

Definition at line 278 of file AllocatorVk.cpp.

    {
        CmpLess comparator;
            auto it = find(v.begin(), v.end(), value);
            if (it != v.end())
            {
#ifdef USE_HIREDIS
                rlog.hpush(__FILE__, __LINE__, LOG_TRACE, value.__rep__(true));
#endif
              // v.erase(it);
                return true;
            }
         
            /*
        typename VectorT::iterator it = BinaryFindFirstNotLess(
            vector.begin(),
            vector.end(),
            value,
            comparator);
  
        if ((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
        {
#ifdef USE_HIREDIS
            rlog.hpush(__FILE__, __LINE__, LOG_TRACE,value->__rep__(true));
#endif
            size_t indexToRemove = it - vector.begin();
            VectorRemove(vector, indexToRemove);
            return true;
        }
                  */
        return false;
    }