def expect(self): architecture = self.architecture create_pipeline = require(self.nth_call_of("vkCreatePipelineLayout", 3)) require_not_equal(0, create_pipeline.int_device) require_not_equal(0, create_pipeline.hex_pCreateInfo) require_equal(0, create_pipeline.hex_pAllocator) require_not_equal(0, create_pipeline.hex_pPipelineLayout) created_pipeline = little_endian_bytes_to_int( require( create_pipeline.get_write_data( create_pipeline.hex_pPipelineLayout, NON_DISPATCHABLE_HANDLE_SIZE))) pipeline_layout_create_info = VulkanStruct( architecture, PIPELINE_LAYOUT_CREATE_INFO, get_read_offset_function(create_pipeline, create_pipeline.hex_pCreateInfo)) require_equal(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, pipeline_layout_create_info.sType) require_equal(0, pipeline_layout_create_info.pNext) require_equal(0, pipeline_layout_create_info.flags) require_equal(2, pipeline_layout_create_info.setLayoutCount) require_not_equal(0, pipeline_layout_create_info.pSetLayouts) require_equal(0, pipeline_layout_create_info.pushConstantRangeCount) require_equal(0, pipeline_layout_create_info.pPushConstantRanges) _ = require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts, NON_DISPATCHABLE_HANDLE_SIZE)) _ = require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts + NON_DISPATCHABLE_HANDLE_SIZE, NON_DISPATCHABLE_HANDLE_SIZE)) set_layout = little_endian_bytes_to_int( require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(VK_NULL_HANDLE, set_layout) set_layout2 = little_endian_bytes_to_int( require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts + NON_DISPATCHABLE_HANDLE_SIZE, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(VK_NULL_HANDLE, set_layout2) destroy_pipeline = require( self.next_call_of("vkDestroyPipelineLayout")) require_equal(created_pipeline, destroy_pipeline.int_pipelineLayout) require_equal(create_pipeline.int_device, destroy_pipeline.int_device) require_equal(0, destroy_pipeline.hex_pAllocator)
def expect(self): """1. One descriptor set.""" arch = self.architecture # Get the VkDescriptorPool handle returned from the driver. # This will also locate us to the proper position in the stream # so we can call next_call_of() for querying the other atoms. pool = get_descriptor_pool(self, 1) # Get the VkDescriptorSetLayout handle returned from the driver. set_layout = get_descriptor_set_layout(self) alloc_descriptor_set, device, p_sets = \ check_alloc_descriptor_set(self, arch) info = get_descriptor_set_alloc_info(alloc_descriptor_set, arch) require_equal(info.sType, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO) require_equal(0, info.pNext) require_equal(pool, info.descriptorPool) require_equal(1, info.descriptorSetCount) # Read the VkDescriptorSetLayout conveyed in the alloc info. layout = little_endian_bytes_to_int( require(alloc_descriptor_set.get_read_data( info.pSetLayouts, NON_DISPATCHABLE_HANDLE_SIZE))) require_equal(set_layout, layout) # Get the real VkDescriptorSet returned form the driver. actual_set = little_endian_bytes_to_int( require(alloc_descriptor_set.get_write_data( alloc_descriptor_set.hex_pDescriptorSets, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, actual_set) check_free_descriptor_set(self, device, pool, [actual_set])
def expect(self): """Expect that the applicationInfoPointer is not null for the second vkCreateInstance, and that it contains some of the expected data.""" architecture = self.architecture create_instance = require(self.nth_call_of("vkCreateInstance", 1)) require_not_equal(create_instance.hex_pCreateInfo, 0) create_info_memory = require( create_instance.get_read_data(create_instance.hex_pCreateInfo, architecture.int_integerSize)) require_equal(little_endian_bytes_to_int(create_info_memory), VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) applicationInfoPointer = require( create_instance.get_read_data( create_instance.hex_pCreateInfo + architecture.int_pointerSize * 3, architecture.int_pointerSize)) require_not_equal(little_endian_bytes_to_int(applicationInfoPointer), 0) # The 2nd pointer(3rd element) in VkApplicationInfo should be the string # Application application_info_application_name_ptr = require( create_instance.get_read_data( little_endian_bytes_to_int(applicationInfoPointer) + 2 * architecture.int_pointerSize, architecture.int_pointerSize)) application_name = require( create_instance.get_read_string( little_endian_bytes_to_int( application_info_application_name_ptr))) require_equal(application_name, "Application")
def expect(self): """Expect that the pInheritanceInfo is null for the first vkBeginCommandBuffer""" architecture = self.architecture begin_command_buffer = require( self.next_call_of("vkBeginCommandBuffer")) command_buffer_value = begin_command_buffer.int_commandBuffer require_not_equal(command_buffer_value, 0) # The command buffer begin info struct should start with correct # sType value. begin_info_stype_memory = require( begin_command_buffer.get_read_data( begin_command_buffer.hex_pBeginInfo, architecture.int_integerSize)) require_equal(little_endian_bytes_to_int(begin_info_stype_memory), VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) # The inheritance info pointer should be a nullptr. inheritance_info_pointer_memory = require( begin_command_buffer.get_read_data( begin_command_buffer.hex_pBeginInfo + architecture.int_pointerSize * 3, architecture.int_pointerSize)) require_equal( little_endian_bytes_to_int(inheritance_info_pointer_memory), 0) # vkEndCommandBuffer() returns correctly end_command_buffer = require(self.next_call_of("vkEndCommandBuffer")) require_equal(end_command_buffer.int_commandBuffer, command_buffer_value) require_equal(VK_SUCCESS, int(end_command_buffer.return_val))
def expect(self): require(self.nth_call_of("vkCreateInstance", 2)) pData = GetMappedLocation(self) require(self.next_call_of("vkAllocateCommandBuffers")) require(self.next_call_of("vkCreateBuffer")) require(self.next_call_of("vkCreateBuffer")) require(self.next_call_of("vkCreateEvent")) require(self.next_call_of("vkCreateEvent")) # submit -> update -> set -> wait idle require(self.next_call_of("vkCmdWaitEvents")) require(self.next_call_of("vkCmdCopyBuffer")) require(self.next_call_of("vkQueueSubmit")) set_event = require(self.next_call_of("vkSetEvent")) require(self.next_call_of("vkQueueWaitIdle")) require(self.next_call_of("vkResetEvent")) require_equal( 0x11111111, little_endian_bytes_to_int( require(set_event.get_read_data(pData, BUFFER_SIZE)))) # update -> set -> submit -> wait idle require(self.next_call_of("vkSetEvent")) require(self.next_call_of("vkCmdWaitEvents")) submit = require(self.next_call_of("vkQueueSubmit")) require(self.next_call_of("vkQueueWaitIdle")) require(self.next_call_of("vkResetEvent")) require_equal( 0x22222222, little_endian_bytes_to_int( require(submit.get_read_data(pData, BUFFER_SIZE)))) # submit [cmdSetEvent (multiple), ... cmdWaitEvents] require(self.next_call_of("vkCmdSetEvent")) require(self.next_call_of("vkCmdSetEvent")) require(self.next_call_of("vkCmdWaitEvents")) require(self.next_call_of("vkCmdCopyBuffer")) submit = require(self.next_call_of("vkQueueSubmit")) require(self.next_call_of("vkQueueWaitIdle")) require(self.next_call_of("vkResetEvent")) require(self.next_call_of("vkResetEvent")) require_equal( 0x33333333, little_endian_bytes_to_int( require(submit.get_read_data(pData, BUFFER_SIZE)))) # submit [cmdSetEvent] -> submit [cmdWaitEvents] require(self.next_call_of("vkCmdSetEvent")) require(self.next_call_of("vkQueueSubmit")) require(self.next_call_of("vkCmdWaitEvents")) require(self.next_call_of("vkCmdCopyBuffer")) submit = require(self.next_call_of("vkQueueSubmit")) require(self.next_call_of("vkQueueWaitIdle")) require(self.next_call_of("vkResetEvent")) require_equal( 0x44444444, little_endian_bytes_to_int( require(submit.get_read_data(pData, BUFFER_SIZE))))
def expect(self): """Expect that the applicationInfoPointer is null for the first vkCreateInstance""" if self.device.Configuration.OS.Kind != ANDROID: return architecture = self.architecture create_surface = require( self.next_call_of("vkCreateAndroidSurfaceKHR")) # Make sure the parameters are valid require_not_equal(create_surface.int_instance, 0) require_not_equal(create_surface.hex_pCreateInfo, 0) require_equal(create_surface.hex_pAllocator, 0) require_not_equal(create_surface.hex_pSurface, 0) create_surface_structure_type_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo, architecture.int_integerSize)) create_surface_pNext_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo + architecture.int_pointerSize, architecture.int_pointerSize)) create_surface_flags_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo + 2 * architecture.int_pointerSize, architecture.int_integerSize)) create_surface_native_window_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo + 3 * architecture.int_pointerSize, architecture.int_pointerSize)) # The struct should look like # {VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, 0, 0, window} require_equal( little_endian_bytes_to_int(create_surface_structure_type_memory), VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR) require_equal( little_endian_bytes_to_int(create_surface_pNext_memory), 0) require_equal( little_endian_bytes_to_int(create_surface_flags_memory), 0) require_not_equal( little_endian_bytes_to_int(create_surface_native_window_memory), 0) # pSemaphore is filled in by the call, should be a write observation surface = require( create_surface.get_write_data(create_surface.hex_pSurface, NON_DISPATCHABLE_HANDLE_SIZE)) # We should have called destroy_semaphore with the same one destroy_surface = require(self.next_call_of("vkDestroySurfaceKHR")) require_equal( little_endian_bytes_to_int(surface), destroy_surface.int_surface) destroy_surface_2 = require(self.next_call_of("vkDestroySurfaceKHR")) require_equal(0, destroy_surface_2.int_surface)
def expect(self): """Expect that the pInheritanceInfo is not null for the second vkBeginCommandBuffer, and that it contains some of the expected data.""" architecture = self.architecture begin_command_buffer = require( self.nth_call_of("vkBeginCommandBuffer", 2)) command_buffer_value = begin_command_buffer.int_commandBuffer require_not_equal(command_buffer_value, 0) # The command buffer begin info struct should start with correct sType # value. begin_info_stype_memory = require( begin_command_buffer.get_read_data( begin_command_buffer.hex_pBeginInfo, architecture.int_integerSize)) require_equal(little_endian_bytes_to_int(begin_info_stype_memory), VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) # The inheritance info pointer should not be a nullptr. inheritance_info_pointer_memory = require( begin_command_buffer.get_read_data( begin_command_buffer.hex_pBeginInfo + architecture.int_pointerSize * 3, architecture.int_pointerSize)) inheritance_info_addr = little_endian_bytes_to_int( inheritance_info_pointer_memory) require_not_equal(inheritance_info_addr, 0) # The inheritance info struct should start with correct sType value. inheritance_info_stype_memory = require( begin_command_buffer.get_read_data(inheritance_info_addr, architecture.int_integerSize)) require_equal( little_endian_bytes_to_int(inheritance_info_stype_memory), VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO) # The last field of inheritance info struct: pipelineStatistics should # have value 0. # TODO(qining): Add tests for other fields. inheritance_info_pipeline_statistics_memory = require( begin_command_buffer.get_read_data( inheritance_info_addr + architecture.int_pointerSize * 2 + NON_DISPATCHABLE_HANDLE_SIZE * 3 + architecture.int_integerSize * 2, architecture.int_integerSize)) require_equal( little_endian_bytes_to_int( inheritance_info_pipeline_statistics_memory), 0) # vkEndCommandBuffer() returns correctly end_command_buffer = require(self.next_call_of("vkEndCommandBuffer")) require_equal(end_command_buffer.int_commandBuffer, command_buffer_value) require_equal(VK_SUCCESS, int(end_command_buffer.return_val))
def expect(self): architecture = self.architecture create_fence = require(self.nth_call_of("vkCreateFence", 1)) wait_for_fences = require(self.next_call_of("vkWaitForFences")) reset_fences = require(self.next_call_of("vkResetFences")) destroy_fence = require(self.next_call_of("vkDestroyFence")) require_not_equal(0, create_fence.int_device) require_not_equal(0, create_fence.hex_pCreateInfo) require_equal(0, create_fence.hex_pAllocator) require_not_equal(0, create_fence.hex_pFence) create_info = VulkanStruct( architecture, FENCE_CREATE_INFO, get_read_offset_function(create_fence, create_fence.hex_pCreateInfo)) require_equal(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, create_info.sType) require_equal(0, create_info.pNext) require_equal(0, create_info.flags) returned_fence = little_endian_bytes_to_int( require( create_fence.get_write_data(create_fence.hex_pFence, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, returned_fence) require_equal(create_fence.int_device, wait_for_fences.int_device) require_equal(1, wait_for_fences.int_fenceCount) require_not_equal(1, wait_for_fences.hex_pFences) require_equal(0, wait_for_fences.int_waitAll) require_equal(100000000, wait_for_fences.int_timeout) waited_for_fence = little_endian_bytes_to_int( require( wait_for_fences.get_read_data(wait_for_fences.hex_pFences, NON_DISPATCHABLE_HANDLE_SIZE))) require_equal(waited_for_fence, returned_fence) require_equal(create_fence.int_device, reset_fences.int_device) require_equal(1, reset_fences.int_fenceCount) require_equal(create_fence.int_device, reset_fences.int_device) reset_fence = little_endian_bytes_to_int( require( reset_fences.get_read_data(wait_for_fences.hex_pFences, NON_DISPATCHABLE_HANDLE_SIZE))) require_equal(returned_fence, reset_fence) require_equal(create_fence.int_device, destroy_fence.int_device) require_equal(returned_fence, destroy_fence.int_fence) require_equal(0, destroy_fence.hex_pAllocator)
def expect(self): architecture = self.architecture device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) create_semaphore = require(self.next_call_of("vkCreateSemaphore")) # Make sure the parameters are valid require_not_equal(create_semaphore.hex_pCreateInfo, 0) require_not_equal(create_semaphore.int_device, 0) require_not_equal(create_semaphore.hex_pSemaphore, 0) require_equal(create_semaphore.hex_pAllocator, 0) create_info_structure_type_memory = require( create_semaphore.get_read_data(create_semaphore.hex_pCreateInfo, architecture.int_integerSize)) create_info_pNext_memory = require( create_semaphore.get_read_data( create_semaphore.hex_pCreateInfo + architecture.int_pointerSize, architecture.int_pointerSize)) create_info_flags_memory = require( create_semaphore.get_read_data( create_semaphore.hex_pCreateInfo + 2 * architecture.int_pointerSize, architecture.int_integerSize)) # The struct should look like # {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, 0, 0} require_equal( little_endian_bytes_to_int(create_info_structure_type_memory), VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO) require_equal(little_endian_bytes_to_int(create_info_pNext_memory), 0) require_equal(little_endian_bytes_to_int(create_info_flags_memory), 0) # pSemaphore is filled in by the call, should be a write observation returned_semaphore = require( create_semaphore.get_write_data(create_semaphore.hex_pSemaphore, 8)) # We should have called destroy_semaphore with the same one destroy_semaphore = require(self.next_call_of("vkDestroySemaphore")) require_equal(little_endian_bytes_to_int(returned_semaphore), destroy_semaphore.int_semaphore) # Our second destroy_semaphore should have been called with # VK_NULL_HANDLE if self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200): destroy_semaphore_null = require( self.next_call_of("vkDestroySemaphore")) require_equal(0, destroy_semaphore_null.int_semaphore)
def expect(self): architecture = self.architecture device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) create_buffer = require(self.next_call_of("vkCreateBuffer")) buffer_create_info = VulkanStruct( architecture, BUFFER_CREATE_INFO, get_read_offset_function(create_buffer, create_buffer.hex_pCreateInfo)) written_buffer = little_endian_bytes_to_int( require( create_buffer.get_write_data(create_buffer.hex_pBuffer, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, written_buffer) require_equal(buffer_create_info.sType, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO) require_equal(buffer_create_info.pNext, 0) require_equal(buffer_create_info.createFlags, 0) require_equal(buffer_create_info.size, 1024) require_equal(buffer_create_info.usage, VK_BUFFER_USAGE_TRANSFER_SRC_BIT) require_equal(buffer_create_info.sharingMode, VK_SHARING_MODE_EXCLUSIVE) require_equal(buffer_create_info.queueFamilyIndexCount, 0) require_equal(buffer_create_info.pQueueFamilyIndices, 0) get_buffer_memory_requirements = require( self.next_call_of("vkGetBufferMemoryRequirements")) require_not_equal(0, get_buffer_memory_requirements.int_device) require_equal(written_buffer, get_buffer_memory_requirements.int_buffer) require_not_equal( 0, get_buffer_memory_requirements.hex_pMemoryRequirements) memory_requirements = VulkanStruct( architecture, MEMORY_REQUIREMENTS, get_write_offset_function( get_buffer_memory_requirements, get_buffer_memory_requirements.hex_pMemoryRequirements)) require_equal(True, memory_requirements.size >= 1) require_not_equal(0, memory_requirements.alignment) require_not_equal(0, memory_requirements.memoryTypeBits) destroy_buffer = require(self.next_call_of("vkDestroyBuffer")) require_equal(destroy_buffer.int_device, get_buffer_memory_requirements.int_device) require_equal(written_buffer, destroy_buffer.int_buffer) # Our second vkDestroySwapchain should have been called with # VK_NULL_HANDLE if (self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200)): destroy_buffer = require(self.next_call_of("vkDestroyBuffer")) require_not_equal(0, destroy_buffer.int_device) require_equal(0, destroy_buffer.int_buffer)
def expect(self): architecture = self.architecture device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) create_pipeline_cache = require( self.nth_call_of("vkCreatePipelineCache", 1)) destroy_pipeline_cache = require( self.next_call_of("vkDestroyPipelineCache")) require_equal(VK_SUCCESS, int(create_pipeline_cache.return_val)) require_not_equal(0, create_pipeline_cache.int_device) require_not_equal(0, create_pipeline_cache.hex_pCreateInfo) require_not_equal(0, create_pipeline_cache.hex_pPipelineCache) cache = little_endian_bytes_to_int( require( create_pipeline_cache.get_write_data( create_pipeline_cache.hex_pPipelineCache, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, cache) pipeline_cache_create_info = VulkanStruct( architecture, PIPELINE_CACHE_CREATE_INFO, get_read_offset_function(create_pipeline_cache, create_pipeline_cache.hex_pCreateInfo)) require_equal(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, pipeline_cache_create_info.sType) require_equal(0, pipeline_cache_create_info.pNext) require_equal(0, pipeline_cache_create_info.flags) require_equal(0, pipeline_cache_create_info.initialDataSize) require_equal(0, pipeline_cache_create_info.pInitialData) require_not_equal(0, destroy_pipeline_cache.int_device) require_not_equal(0, destroy_pipeline_cache.int_pipelineCache)
def GetPhysicalDevices(test, architecture): # first call to enumerate physical devices first_enumerate_physical_devices = require( test.next_call_of("vkEnumeratePhysicalDevices")) require_equal(VK_SUCCESS, int(first_enumerate_physical_devices.return_val)) require_not_equal(0, first_enumerate_physical_devices.int_instance) require_not_equal( 0, first_enumerate_physical_devices.hex_pPhysicalDeviceCount) require_equal(0, first_enumerate_physical_devices.hex_pPhysicalDevices) num_phy_devices = little_endian_bytes_to_int( require( first_enumerate_physical_devices.get_write_data( first_enumerate_physical_devices.hex_pPhysicalDeviceCount, architecture.int_integerSize))) # second call to enumerate physical devices second_enumerate_physical_devices = require( test.next_call_of("vkEnumeratePhysicalDevices")) require_equal(VK_SUCCESS, int(second_enumerate_physical_devices.return_val)) require_not_equal(0, second_enumerate_physical_devices.int_instance) require_not_equal( 0, second_enumerate_physical_devices.hex_pPhysicalDeviceCount) require_not_equal(0, second_enumerate_physical_devices.hex_pPhysicalDevices) require_not_equal(0, num_phy_devices) PHYSICAL_DEVICES = [("physicalDevices", ARRAY, num_phy_devices, POINTER)] returned_physical_devices = VulkanStruct( architecture, PHYSICAL_DEVICES, get_write_offset_function( second_enumerate_physical_devices, second_enumerate_physical_devices.hex_pPhysicalDevices)) return returned_physical_devices.physicalDevices
def expect(self): architecture = self.architecture first_call = require( self.next_call_of("vkGetImageSparseMemoryRequirements")) require_not_equal(0, first_call.int_device) require_not_equal(0, first_call.int_image) require_not_equal(0, first_call.hex_pSparseMemoryRequirementCount) require_equal(0, first_call.hex_pSparseMemoryRequirements) count = little_endian_bytes_to_int( require( first_call.get_write_data( first_call.hex_pSparseMemoryRequirementCount, architecture.int_integerSize))) second_call = require( self.next_call_of("vkGetImageSparseMemoryRequirements")) require_not_equal(0, second_call.int_device) require_not_equal(0, second_call.int_image) require_not_equal(0, second_call.hex_pSparseMemoryRequirementCount) require_not_equal(0, second_call.hex_pSparseMemoryRequirements) offset = 0 for i in range(count): memory_requirements = VulkanStruct( architecture, SPRASE_IMAGE_MEMORY_REQUIREMENTS, get_write_offset_function( second_call, second_call.hex_pSparseMemoryRequirements + offset)) offset += memory_requirements.total_size
def expect(self): architecture = self.architecture bind_buffer_memory = require(self.next_call_of("vkBindBufferMemory")) map_memory = require(self.next_call_of("vkMapMemory")) unmap_memory = require(self.next_call_of("vkUnmapMemory")) require_not_equal(0, bind_buffer_memory.int_device) require_not_equal(0, bind_buffer_memory.int_buffer) require_not_equal(0, bind_buffer_memory.int_memory) require_equal(0, bind_buffer_memory.int_memoryOffset) require_equal(bind_buffer_memory.int_device, map_memory.int_device) require_equal(bind_buffer_memory.int_memory, map_memory.int_memory) require_equal(0, map_memory.int_offset) require_equal(VK_WHOLE_SIZE, map_memory.int_size) require_equal(0, map_memory.int_flags) require_not_equal(0, map_memory.hex_ppData) written_pointer = little_endian_bytes_to_int( require( map_memory.get_write_data(map_memory.hex_ppData, architecture.int_pointerSize))) require_not_equal(0, written_pointer) require_equal(bind_buffer_memory.int_device, unmap_memory.int_device) require_equal(bind_buffer_memory.int_memory, unmap_memory.int_memory)
def get_image_info(update_atom, architecture, base): """Returns a VulkanStruct representing the VkDescriptorImageInfo struct used in the VkWriteDescriptorSet parameter of the given |update_atom| atom.""" return VulkanStruct( architecture, DESCRIPTOR_IMAGE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int( require(update_atom.get_read_data(base + offset, size))))
def get_descriptor_set_alloc_info(alloc_descriptor_set, architecture): """Returns a VulkanStruct representing the VkDescriptorSetAllocateInfo struct used in the given |alloc_descriptor_set| command.""" return VulkanStruct( architecture, DESCRIPTOR_SET_ALLOCATE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int(require( alloc_descriptor_set.get_read_data( alloc_descriptor_set.hex_pAllocateInfo + offset, size))))
def get_descriptor_pool_create_info(create_descriptor_pool, architecture): """Returns a VulkanStruct representing the VkDescriptorPoolCreateInfo struct used in the given create_descriptor_pool command.""" return VulkanStruct( architecture, DESCRIPTOR_POOL_CREATE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int(require( create_descriptor_pool.get_read_data( create_descriptor_pool.hex_pCreateInfo + offset, size))))
def GetCreatedImage(create_image): require_equal(VK_SUCCESS, int(create_image.return_val)) require_not_equal(0, create_image.int_device) require_not_equal(0, create_image.hex_pCreateInfo) require_not_equal(0, create_image.hex_pImage) img = little_endian_bytes_to_int(require(create_image.get_write_data( create_image.hex_pImage, NON_DISPATCHABLE_HANDLE_SIZE))) return img
def get_sampler_create_info(create_sampler, architecture): """Returns a VulkanStruct representing the VkSamplerCreateInfo struct used in the given create_sampler command.""" return VulkanStruct( architecture, SAMPLER_CREATE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int( require( create_sampler.get_read_data( create_sampler.hex_pCreateInfo + offset, size))))
def GetCreatedBuffer(create_buffer): require_equal(VK_SUCCESS, int(create_buffer.return_val)) require_not_equal(0, create_buffer.int_device) require_not_equal(0, create_buffer.hex_pCreateInfo) require_not_equal(0, create_buffer.hex_pBuffer) buf = little_endian_bytes_to_int(require(create_buffer.get_write_data( create_buffer.hex_pBuffer, NON_DISPATCHABLE_HANDLE_SIZE))) return buf
def get_bound_sampler(create_descriptor_set_layout, architecture, binding_info, index): """Returns the |index|'th sampler contained in the |binding_info| VkDescriptorSetLayoutBinding struct's pImmutableSamplers field.""" offset = (binding_info.pImmutableSamplers + index * NON_DISPATCHABLE_HANDLE_SIZE) return little_endian_bytes_to_int( require( create_descriptor_set_layout.get_read_data( offset, NON_DISPATCHABLE_HANDLE_SIZE)))
def get_descriptor_set_layout(test): """Returns the handle of the next descriptor set layout created from vkCreateDescriptorSetLayout.""" create = require(test.next_call_of("vkCreateDescriptorSetLayout")) require_equal(VK_SUCCESS, int(create.return_val)) layout = little_endian_bytes_to_int( require(create.get_write_data( create.hex_pSetLayout, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, layout) return layout
def get_descriptor_pool(test, index): """Returns the handle of the |index|th (starting from 1) descriptor pool created from vkCreateDescriptorPool.""" create = require(test.nth_call_of("vkCreateDescriptorPool", index)) require_equal(VK_SUCCESS, int(create.return_val)) pool = little_endian_bytes_to_int( require(create.get_write_data( create.hex_pDescriptorPool, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, pool) return pool
def get_pool_size(create_descriptor_pool, architecture, create_info, index): """Returns a VulkanStruct representing the VkDescriptorPoolSize struct.""" pool_size_offset = (create_info.pPoolSizes + # (4 + 4) is the size of a VkDescriptorPoolSize struct. index * (4 + 4)) return VulkanStruct( architecture, DESCRIPTOR_POOL_SIZE_ELEMENTS, lambda offset, size: little_endian_bytes_to_int(require( create_descriptor_pool.get_read_data( pool_size_offset + offset, size))))
def expect(self): first_create_cache = require( self.nth_call_of("vkCreatePipelineCache", 2)) second_create_cache = require( self.next_call_of("vkCreatePipelineCache", )) third_create_cache = require( self.next_call_of("vkCreatePipelineCache", )) first_cache = little_endian_bytes_to_int( require( first_create_cache.get_write_data( first_create_cache.hex_pPipelineCache, NON_DISPATCHABLE_HANDLE_SIZE))) second_cache = little_endian_bytes_to_int( require( second_create_cache.get_write_data( second_create_cache.hex_pPipelineCache, NON_DISPATCHABLE_HANDLE_SIZE))) third_cache = little_endian_bytes_to_int( require( third_create_cache.get_write_data( third_create_cache.hex_pPipelineCache, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, first_cache) require_not_equal(0, second_cache) require_not_equal(0, third_cache) merge = require(self.next_call_of("vkMergePipelineCaches")) require_equal(VK_SUCCESS, int(merge.return_val)) require_equal(first_cache, merge.int_dstCache) require_equal(2, merge.int_srcCacheCount) first_src = little_endian_bytes_to_int( require( merge.get_read_data(merge.hex_pSrcCaches, NON_DISPATCHABLE_HANDLE_SIZE))) second_src = little_endian_bytes_to_int( require( merge.get_read_data( merge.hex_pSrcCaches + NON_DISPATCHABLE_HANDLE_SIZE, NON_DISPATCHABLE_HANDLE_SIZE))) require_equal(second_cache, first_src) require_equal(third_cache, second_src)
def get_buffer(test): """Returns the next buffer handle created by vkCreateBuffer.""" create = require(test.next_call_of("vkCreateBuffer")) require_equal(VK_SUCCESS, int(create.return_val)) buf = little_endian_bytes_to_int( require( create.get_write_data(create.hex_pBuffer, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, buf) return buf
def expect(self): arch = self.architecture create_device = require(self.next_call_of("vkCreateDevice")) device = little_endian_bytes_to_int(require( create_device.get_write_data(create_device.hex_pDevice, arch.int_pointerSize))) require_equal(VK_SUCCESS, int(create_device.return_val)) require_not_equal(0, device) get_queue = require(self.next_call_of("vkGetDeviceQueue")) require_equal(device, get_queue.int_device) require_equal(0, get_queue.int_queueFamilyIndex) require_equal(0, get_queue.int_queueIndex) require_not_equal(0, get_queue.hex_pQueue) queue = little_endian_bytes_to_int(require(get_queue.get_write_data( get_queue.hex_pQueue, arch.int_pointerSize))) require_not_equal(0, queue)
def get_descriptor_set_layout_create_info(create_descriptor_set_layout, architecture): """Returns a VulkanStruct representing the VkDescriptorSetLayoutCreateInfo struct used in the given |create_descriptor_set_layout| command.""" return VulkanStruct( architecture, DESCRIPTOR_SET_LAYOUT_CREATE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int( require( create_descriptor_set_layout.get_read_data( create_descriptor_set_layout.hex_pCreateInfo + offset, size ))))
def expect(self): """Expect that the applicationInfoPointer is null for the first vkCreateInstance""" architecture = self.architecture create_instance = require(self.next_call_of("vkCreateInstance")) require_not_equal(create_instance.hex_pCreateInfo, 0) create_info_memory = require( create_instance.get_read_data(create_instance.hex_pCreateInfo, architecture.int_integerSize)) require_equal(little_endian_bytes_to_int(create_info_memory), VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) applicationInfoPointer = require( create_instance.get_read_data( create_instance.hex_pCreateInfo + architecture.int_pointerSize * 3, architecture.int_pointerSize)) require_equal(little_endian_bytes_to_int(applicationInfoPointer), 0)
def get_descriptor_set(test, index): """Returns the descriptor set handle created by the |index|th (starting from 1) vkAllocateDescriptorSet.""" allocate = require(test.nth_call_of("vkAllocateDescriptorSets", index)) require_equal(VK_SUCCESS, int(allocate.return_val)) d_set = little_endian_bytes_to_int( require( allocate.get_write_data(allocate.hex_pDescriptorSets, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(0, d_set) return d_set