Home | History | Annotate | Download | only in vulkan 
      1 #ifndef _VKMEMUTIL_HPP
      2 #define _VKMEMUTIL_HPP
      3 /*-------------------------------------------------------------------------
      4  * Vulkan CTS Framework
      5  * --------------------
      6  *
      7  * Copyright (c) 2015 Google Inc.
      8  *
      9  * Licensed under the Apache License, Version 2.0 (the "License");
     10  * you may not use this file except in compliance with the License.
     11  * You may obtain a copy of the License at
     12  *
     13  *      http://www.apache.org/licenses/LICENSE-2.0
     14  *
     15  * Unless required by applicable law or agreed to in writing, software
     16  * distributed under the License is distributed on an "AS IS" BASIS,
     17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     18  * See the License for the specific language governing permissions and
     19  * limitations under the License.
     20  *
     21  *//*!
     22  * \file
     23  * \brief Memory management utilities.
     24  *//*--------------------------------------------------------------------*/
     25 
     26 #include "vkDefs.hpp"
     27 #include "deUniquePtr.hpp"
     28 
     29 namespace vk
     30 {
     31 
     32 /*--------------------------------------------------------------------*//*!
     33  * \brief Memory allocation interface
     34  *
     35  * Allocation represents block of device memory and is allocated by
     36  * Allocator implementation. Test code should use Allocator for allocating
     37  * memory, unless there is a reason not to (for example testing vkAllocMemory).
     38  *
     39  * Allocation doesn't necessarily correspond to a whole VkDeviceMemory, but
     40  * instead it may represent sub-allocation. Thus whenever VkDeviceMemory
     41  * (getMemory()) managed by Allocation is passed to Vulkan API calls,
     42  * offset given by getOffset() must be used.
     43  *
     44  * If host-visible memory was requested, host pointer to the memory can
     45  * be queried with getHostPtr(). No offset is needed when accessing host
     46  * pointer, i.e. the pointer is already adjusted in case of sub-allocation.
     47  *
     48  * Memory mappings are managed solely by Allocation, i.e. unmapping or
     49  * re-mapping VkDeviceMemory owned by Allocation is not allowed.
     50  *//*--------------------------------------------------------------------*/
     51 class Allocation
     52 {
     53 public:
     54 	virtual					~Allocation		(void);
     55 
     56 	//! Get VkDeviceMemory backing this allocation
     57 	VkDeviceMemory			getMemory		(void) const { return m_memory;							}
     58 
     59 	//! Get offset in VkDeviceMemory for this allocation
     60 	VkDeviceSize			getOffset		(void) const { return m_offset;							}
     61 
     62 	//! Get host pointer for this allocation. Only available for host-visible allocations
     63 	void*					getHostPtr		(void) const { DE_ASSERT(m_hostPtr); return m_hostPtr;	}
     64 
     65 protected:
     66 							Allocation		(VkDeviceMemory memory, VkDeviceSize offset, void* hostPtr);
     67 
     68 private:
     69 	const VkDeviceMemory	m_memory;
     70 	const VkDeviceSize		m_offset;
     71 	void* const				m_hostPtr;
     72 };
     73 
     74 //! Memory allocation requirements
     75 class MemoryRequirement
     76 {
     77 public:
     78 	static const MemoryRequirement	Any;
     79 	static const MemoryRequirement	HostVisible;
     80 	static const MemoryRequirement	Coherent;
     81 	static const MemoryRequirement	LazilyAllocated;
     82 
     83 	inline MemoryRequirement		operator|			(MemoryRequirement requirement) const
     84 	{
     85 		return MemoryRequirement(m_flags | requirement.m_flags);
     86 	}
     87 
     88 	inline MemoryRequirement		operator&			(MemoryRequirement requirement) const
     89 	{
     90 		return MemoryRequirement(m_flags & requirement.m_flags);
     91 	}
     92 
     93 	bool							matchesHeap			(VkMemoryPropertyFlags heapFlags) const;
     94 
     95 	inline operator					bool				(void) const { return m_flags != 0u; }
     96 
     97 private:
     98 	explicit						MemoryRequirement	(deUint32 flags);
     99 
    100 	const deUint32					m_flags;
    101 
    102 	enum Flags
    103 	{
    104 		FLAG_HOST_VISIBLE		= 1u << 0u,
    105 		FLAG_COHERENT			= 1u << 1u,
    106 		FLAG_LAZY_ALLOCATION	= 1u << 2u,
    107 	};
    108 };
    109 
    110 //! Memory allocator interface
    111 class Allocator
    112 {
    113 public:
    114 									Allocator	(void) {}
    115 	virtual							~Allocator	(void) {}
    116 
    117 	virtual de::MovePtr<Allocation>	allocate	(const VkMemoryAllocateInfo& allocInfo, VkDeviceSize alignment) = 0;
    118 	virtual de::MovePtr<Allocation>	allocate	(const VkMemoryRequirements& memRequirements, MemoryRequirement requirement) = 0;
    119 };
    120 
    121 //! Allocator that backs every allocation with its own VkDeviceMemory
    122 class SimpleAllocator : public Allocator
    123 {
    124 public:
    125 											SimpleAllocator	(const DeviceInterface& vk, VkDevice device, const VkPhysicalDeviceMemoryProperties& deviceMemProps);
    126 
    127 	de::MovePtr<Allocation>					allocate		(const VkMemoryAllocateInfo& allocInfo, VkDeviceSize alignment);
    128 	de::MovePtr<Allocation>					allocate		(const VkMemoryRequirements& memRequirements, MemoryRequirement requirement);
    129 
    130 private:
    131 	const DeviceInterface&					m_vk;
    132 	const VkDevice							m_device;
    133 	const VkPhysicalDeviceMemoryProperties	m_memProps;
    134 };
    135 
    136 de::MovePtr<Allocation>	allocateDedicated			(const InstanceInterface& vki, const DeviceInterface& vkd, const VkPhysicalDevice& physDevice, const VkDevice device, const VkBuffer buffer, MemoryRequirement requirement);
    137 de::MovePtr<Allocation>	allocateDedicated			(const InstanceInterface& vki, const DeviceInterface& vkd, const VkPhysicalDevice& physDevice, const VkDevice device, const VkImage image, MemoryRequirement requirement);
    138 
    139 void*					mapMemory					(const DeviceInterface& vkd, VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags);
    140 void					flushMappedMemoryRange		(const DeviceInterface& vkd, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size);
    141 void					invalidateMappedMemoryRange	(const DeviceInterface& vkd, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size);
    142 deUint32				getCompatibleMemoryTypes	(const VkPhysicalDeviceMemoryProperties& deviceMemProps, MemoryRequirement requirement);
    143 void					bindImagePlaneMemory		(const DeviceInterface&	vkd, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkImageAspectFlagBits planeAspect);
    144 
    145 } // vk
    146 
    147 #endif // _VKMEMUTIL_HPP
    148