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
