def expect(self):
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
createSwapchain = require(self.next_call_of("vkCreateSwapchainKHR"))
destroySwapchain = require(self.next_call_of("vkDestroySwapchainKHR"))
def get_swapchain_create_info_member(offset, size):
return little_endian_bytes_to_int(
require(
createSwapchain.get_read_data(
createSwapchain.hex_pCreateInfo + offset, size)))
swapchain_create_info = VulkanStruct(
architecture,
[
("sType", UINT32_T),
("pNext", POINTER),
("flags", UINT32_T),
("surface", HANDLE),
("minImageCount", UINT32_T),
("imageFormat", UINT32_T),
("imageColorSpace", UINT32_T),
("extent.width", UINT32_T),
("extent.height", UINT32_T),
("imageArrayLayers", UINT32_T),
("imageUsage", UINT32_T),
("imageSharingMode", UINT32_T),
("queueFamilyIndexCount", UINT32_T),
("queueFamilyIndices", POINTER),
("preTransform", UINT32_T),
("compositeAlpha", UINT32_T),
("presentMode", UINT32_T),
("clipped", UINT32_T),
("oldSwapchain", HANDLE) # oldSwapchain
],
get_swapchain_create_info_member)
require_equal(swapchain_create_info.sType,
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
require_equal(swapchain_create_info.oldSwapchain, 0)
require_equal(swapchain_create_info.clipped, 0)
require_equal(swapchain_create_info.imageArrayLayers, 1)
require_not_equal(0, destroySwapchain.int_swapchain)
require_equal(True,
(swapchain_create_info.queueFamilyIndexCount == 0
or swapchain_create_info.queueFamilyIndexCount == 2))
# Our second vkDestroySwapchain should have been called with
# VK_NULL_HANDLE.
if (self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200)
and self.not_android_version("7.1.1")):
destroySwapchain = require(
self.next_call_of("vkDestroySwapchainKHR"))
require_equal(0, destroySwapchain.int_swapchain)
def expect(self):
"""1. Expects a buffer view created with zero offset and VK_WHOLE_SIZE
range for a uniform texel buffer."""
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
create_buffer_view = require(self.nth_call_of("vkCreateBufferView", 1))
device = create_buffer_view.int_device
require_not_equal(0, device)
require_not_equal(0, create_buffer_view.hex_pCreateInfo)
require_equal(0, create_buffer_view.hex_pAllocator)
require_not_equal(0, create_buffer_view.hex_pView)
require_equal(VK_SUCCESS, int(create_buffer_view.return_val))
create_info = VulkanStruct(
architecture, BUFFER_VIEW_CREATE_INFO,
get_read_offset_function(create_buffer_view,
create_buffer_view.hex_pCreateInfo))
require_equal(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
create_info.sType)
require_equal(0, create_info.pNext)
require_equal(0, create_info.flags)
require_not_equal(0, create_info.buffer)
require_equal(VK_FORMAT_R8G8B8A8_UNORM, create_info.format)
require_equal(0, create_info.offset)
require_equal(VK_WHOLE_SIZE, create_info.range)
view = VulkanStruct(
architecture, BUFFER_VIEW,
get_write_offset_function(create_buffer_view,
create_buffer_view.hex_pView))
require_not_equal(0, view.handle)
destroy_buffer_view = require(self.next_call_of("vkDestroyBufferView"))
require_equal(device, destroy_buffer_view.int_device)
require_equal(view.handle, destroy_buffer_view.int_bufferView)
if self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200):
destroy_null_buffer_view = require(
self.next_call_of("vkDestroyBufferView"))
require_equal(device, destroy_buffer_view.int_device)
require_equal(0, destroy_null_buffer_view.int_bufferView)
def expect(self):
"""Check the arguments and the VkMappedMemoryRange structs used in
vkFlushMappedMemoryRanges(). The flushed memory starts at offset 768 and
has size 256"""
MAP_OFFSET = 512
FLUSH_OFFSET = MAP_OFFSET + 256
FLUSH_SIZE = 256
MEMORY_DATA = [("data", ARRAY, FLUSH_SIZE, CHAR)]
EXPECTED_MEMORY_DATA = [i for i in range(FLUSH_SIZE)]
architecture = self.architecture
# The first and second vkMapMemory() result is managed in
# VulkanApplication and is not used here, the third is the one we need
# here.
map_memory = require(self.nth_call_of("vkMapMemory", 3))
require_not_equal(0, map_memory.hex_ppData)
# The flushed data starts at mapped offset + 256
flushed_data_ptr = little_endian_bytes_to_int(require(
map_memory.get_write_data(map_memory.hex_ppData,
architecture.int_sizeSize))) + 256
# Check arguments
flush_mapped_memory_ranges = require(self.nth_call_of(
"vkFlushMappedMemoryRanges", 1))
require_equal(1, flush_mapped_memory_ranges.int_memoryRangeCount)
require_not_equal(0, flush_mapped_memory_ranges.hex_pMemoryRanges)
# Check the memory range struct content
mapped_memory_range = VulkanStruct(
architecture, MAPPED_MEMORY_RANGE, get_read_offset_function(
flush_mapped_memory_ranges,
flush_mapped_memory_ranges.hex_pMemoryRanges))
require_equal(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
mapped_memory_range.sType)
require_equal(0, mapped_memory_range.pNext)
require_not_equal(0, mapped_memory_range.memory)
require_equal(FLUSH_OFFSET, mapped_memory_range.offset)
require_equal(FLUSH_SIZE, mapped_memory_range.size)
# check the flushed memory data
memory_data = VulkanStruct(
architecture, MEMORY_DATA, get_read_offset_function(
flush_mapped_memory_ranges, flushed_data_ptr))
require_equal(EXPECTED_MEMORY_DATA, memory_data.data)
def expect(self):
"""2. Expects a query pool to be created with queryCount: 7 and
queryType: VK_QUERY_TYPE_TIMESTAMP."""
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
create_query_pool = require(self.nth_call_of("vkCreateQueryPool", 2))
device = create_query_pool.int_device
require_not_equal(0, device)
require_not_equal(0, create_query_pool.hex_pCreateInfo)
require_equal(0, create_query_pool.hex_pAllocator)
require_not_equal(0, create_query_pool.hex_pQueryPool)
require_equal(VK_SUCCESS, int(create_query_pool.return_val))
create_info = VulkanStruct(
architecture, QUERY_POOL_CREATE_INFO,
get_read_offset_function(create_query_pool,
create_query_pool.hex_pCreateInfo))
require_equal(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
create_info.sType)
require_equal(0, create_info.pNext)
require_equal(0, create_info.flags)
require_equal(VK_QUERY_TYPE_TIMESTAMP, create_info.queryType)
require_equal(7, create_info.queryCount)
require_equal(0, create_info.pipelineStatistics)
view = VulkanStruct(
architecture, QUERY_POOL,
get_write_offset_function(create_query_pool,
create_query_pool.hex_pQueryPool))
require_not_equal(0, view.handle)
destroy_query_pool = require(self.next_call_of("vkDestroyQueryPool"))
require_equal(device, destroy_query_pool.int_device)
require_equal(view.handle, destroy_query_pool.int_queryPool)
if self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200):
destroy_null_query_pool = require(
self.next_call_of("vkDestroyQueryPool"))
require_equal(device, destroy_query_pool.int_device)
require_equal(0, destroy_null_query_pool.int_queryPool)
def get_image_view_create_info(create_image_view, architecture):
"""Returns a VulkanStruct which is built to represent the image view create
info struct used in the given create image view command."""
def get_data(offset, size):
return little_endian_bytes_to_int(require(
create_image_view.get_read_data(create_image_view.hex_pCreateInfo +
offset, size)))
return VulkanStruct(architecture, IMAGE_VIEW_CREATE_INFO_ELEMENTS, get_data)
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):
"""2. Expects a command pool created with
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, then reseted with flag
of value 0, and finally destroyed"""
architecture = self.architecture
create_command_pool = require(
self.nth_call_of("vkCreateCommandPool", 2))
device = create_command_pool.int_device
require_not_equal(0, device)
require_not_equal(0, create_command_pool.hex_pCreateInfo)
require_equal(0, create_command_pool.hex_pAllocator)
require_not_equal(0, create_command_pool.hex_pCommandPool)
require_equal(VK_SUCCESS, int(create_command_pool.return_val))
create_info = VulkanStruct(
architecture, COMMAND_POOL_CREATE_INFO,
get_read_offset_function(create_command_pool,
create_command_pool.hex_pCreateInfo))
require_equal(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
create_info.sType)
require_equal(0, create_info.pNext)
require_equal(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
create_info.flags)
require_equal(0, create_info.queueFamilyIndex)
command_pool = VulkanStruct(
architecture, COMMAND_POOL,
get_write_offset_function(create_command_pool,
create_command_pool.hex_pCommandPool))
require_not_equal(0, command_pool.handle)
reset_pool = require(self.next_call_of("vkResetCommandPool"))
require_equal(device, reset_pool.int_device)
require_equal(command_pool.handle, reset_pool.int_commandPool)
require_equal(0, reset_pool.flags)
destroy_command_pool = require(
self.next_call_of("vkDestroyCommandPool"))
require_equal(device, destroy_command_pool.int_device)
require_equal(command_pool.handle,
destroy_command_pool.int_commandPool)
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):
architecture = self.architecture
create_render_pass = require(self.nth_call_of("vkCreateRenderPass", 1))
destroy_render_pass = require(self.next_call_of("vkDestroyRenderPass"))
render_pass_create_info = VulkanStruct(
architecture, RENDER_PASS_CREATE_INFO,
get_read_offset_function(create_render_pass,
create_render_pass.hex_pCreateInfo))
subpass_info = VulkanStruct(
architecture, SUBPASS_DESCRIPTION,
get_read_offset_function(create_render_pass,
render_pass_create_info.pSubpasses))
require_equal(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
render_pass_create_info.sType)
require_equal(0, render_pass_create_info.pNext)
require_equal(0, render_pass_create_info.flags)
require_equal(0, render_pass_create_info.attachmentCount)
require_equal(0, render_pass_create_info.pAttachments)
require_equal(1, render_pass_create_info.subpassCount)
require_not_equal(0, render_pass_create_info.pSubpasses)
require_equal(0, render_pass_create_info.dependencyCount)
require_equal(0, render_pass_create_info.pDependencies)
require_equal(0, subpass_info.flags)
require_equal(VK_PIPELINE_BIND_POINT_GRAPHICS,
subpass_info.pipelineBindPoint)
require_equal(0, subpass_info.inputAttachmentCount)
require_equal(0, subpass_info.pInputAttachments)
require_equal(0, subpass_info.colorAttachmentCount)
require_equal(0, subpass_info.pColorAttachments)
require_equal(0, subpass_info.pResolveAttachments)
require_equal(0, subpass_info.pDepthStencilAttachment)
require_equal(0, subpass_info.preserveAttachmentCount)
require_equal(0, subpass_info.pPreserveAttachments)
require_not_equal(0, destroy_render_pass.int_renderPass)
require_not_equal(0, destroy_render_pass.int_device)
def expect(self):
arch = self.architecture
get_layout = require(self.next_call_of("vkGetImageSubresourceLayout"))
require_not_equal(0, get_layout.int_image)
subresource = VulkanStruct(
arch, IMAGE_SUBRESOURCE_ELEMENTS,
get_read_offset_function(get_layout, get_layout.hex_pSubresource))
layout = VulkanStruct(
arch, SUBRESOURCE_LAYOUT_ELEMENTS,
get_write_offset_function(get_layout, get_layout.hex_pLayout))
require_equal(VK_IMAGE_ASPECT_COLOR_BIT, subresource.aspectMask)
require_equal(0, subresource.mipLevel)
require_equal(0, subresource.arrayLayer)
require_equal(0, layout.offset)
require_equal(4 * 32 * 32, layout.size)
require_equal(4 * 32, layout.rowPitch)
require_equal(4 * 32 * 32, layout.arrayPitch)
require_equal(4 * 32 * 32, layout.depthPitch)
def get_buffer_info(update_atom, architecture, base, count):
"""Returns |count| VulkanStructs representing the VkDescriptorBufferInfo
structs used in the VkWriteDescriptorSet parameter of the given
|update_atom| atom."""
infos = [
VulkanStruct(
architecture, DESCRIPTOR_BUFFER_INFO_ELEMENTS,
lambda offset, size: little_endian_bytes_to_int(
require(update_atom.get_read_data(base + offset, size))))
]
buffer_info_size = infos[-1].total_size
for i in range(1, count):
infos.append(
VulkanStruct(
architecture, DESCRIPTOR_BUFFER_INFO_ELEMENTS,
lambda offset, size: little_endian_bytes_to_int(
require(
update_atom.get_read_data(
base + i * buffer_info_size + offset, size)))))
return infos
def expect(self):
arch = self.architecture
physical_devices = GetPhysicalDevices(self, arch)
for pd in physical_devices:
for fmt in ALL_VK_FORMATS:
get_properties = require(self.next_call_of(
"vkGetPhysicalDeviceFormatProperties"))
require_equal(
True, get_properties.int_physicalDevice in physical_devices)
require_equal(fmt, get_properties.int_format)
require_not_equal(0, get_properties.hex_pFormatProperties)
VulkanStruct(arch, FORMAT_PROPERTIES, get_write_offset_function(
get_properties, get_properties.hex_pFormatProperties))
def get_write_descriptor_set(update_atom, architecture, count):
"""Returns |count| VulkanStructs representing the VkWriteDescriptorSet
structs used in the given |update_atom| atom."""
writes = [
VulkanStruct(
architecture, WRITE_DESCRIPTOR_SET_ELEMENTS,
lambda offset, size: little_endian_bytes_to_int(
require(
update_atom.get_read_data(
update_atom.hex_pDescriptorWrites + offset, size))))
]
struct_size = writes[-1].total_size
for i in range(1, count):
writes.append(
VulkanStruct(
architecture, WRITE_DESCRIPTOR_SET_ELEMENTS,
lambda offset, size: little_endian_bytes_to_int(
require(
update_atom.get_read_data(
(update_atom.hex_pDescriptorWrites + i *
struct_size + offset), size)))))
return writes
def expect(self):
architecture = self.architecture
get_granularity = require(
self.next_call_of("vkGetRenderAreaGranularity"))
require_not_equal(0, get_granularity.int_device)
require_not_equal(0, get_granularity.int_renderPass)
granularity = VulkanStruct(
architecture, EXTENT_2D,
get_write_offset_function(get_granularity,
get_granularity.hex_pGranularity))
require_not_equal(0, granularity.width)
require_not_equal(0, granularity.height)
def expect(self):
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
get_image_memory_requirements = require(
self.next_call_of("vkGetImageMemoryRequirements"))
memory_requirements = VulkanStruct(
architecture, MEMORY_REQUIREMENTS, get_write_offset_function(
get_image_memory_requirements,
get_image_memory_requirements.hex_pMemoryRequirements))
allocate_memory = require(self.next_call_of("vkAllocateMemory"))
require_not_equal(0, allocate_memory.int_device)
require_not_equal(0, allocate_memory.hex_pAllocateInfo)
require_equal(0, allocate_memory.hex_pAllocator)
require_not_equal(0, allocate_memory.hex_pMemory)
allocate_memory_info = VulkanStruct(
architecture, MEMORY_ALLOCATE_INFO,
get_read_offset_function(allocate_memory,
allocate_memory.hex_pAllocateInfo))
require_equal(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
allocate_memory_info.sType)
require_equal(0, allocate_memory_info.pNext)
require_equal(memory_requirements.size,
allocate_memory_info.allocationSize)
free_memory = require(self.next_call_of("vkFreeMemory"))
require_not_equal(0, free_memory.int_device)
require_not_equal(0, free_memory.int_memory)
require_equal(0, free_memory.hex_pAllocator)
if self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200):
free_memory = require(self.next_call_of("vkFreeMemory"))
require_not_equal(0, free_memory.int_device)
require_equal(0, free_memory.int_memory)
def expect(self):
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
get_cache_data_with_null_pdata = require(
self.nth_call_of("vkGetPipelineCacheData", 1))
write_data_size = VulkanStruct(
architecture, DATA_SIZE,
get_write_offset_function(
get_cache_data_with_null_pdata,
get_cache_data_with_null_pdata.hex_pDataSize))
# The pipeline cache data size must be at least as large as its header
# size
require_true(16 + VK_UUID_SIZE <= write_data_size.dataSize)
get_cache_data_with_not_null_pdata = require(
self.next_call_of("vkGetPipelineCacheData"))
# Check the header
cache_data_header = VulkanStruct(
architecture, DATA_HEADER,
get_write_offset_function(
get_cache_data_with_not_null_pdata,
get_cache_data_with_not_null_pdata.hex_pData))
require_equal(16 + VK_UUID_SIZE, cache_data_header.headerSize)
require_equal(1, cache_data_header.headerVersion)
require_not_equal(0, cache_data_header.venderID)
require_not_equal(0, cache_data_header.deviceID)
destroy_pipeline_cache = require(
self.next_call_of("vkDestroyPipelineCache"))
if self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200):
destroy_pipeline_cache = require(
self.next_call_of("vkDestroyPipelineCache"))
require_not_equal(0, destroy_pipeline_cache.int_device)
require_equal(0, destroy_pipeline_cache.int_pipelineCache)
def expect(self):
"""1. Expect vkEnumeratePhysicalDevices() to be called first, then
vkGetPhysicalDeviceFeatures() to be called num_phy_devices times and
return physical device features."""
arch = self.architecture
physical_devices = GetPhysicalDevices(self, arch)
for pd in physical_devices:
get_features = require(self.next_call_of(
"vkGetPhysicalDeviceFeatures"))
require_equal(pd, get_features.int_physicalDevice)
require_not_equal(0, get_features.hex_pFeatures)
VulkanStruct(arch, PHYSICAL_DEVICE_FEATURES,
get_write_offset_function(get_features,
get_features.hex_pFeatures))
def expect(self):
architecture = self.architecture
set_scissor = require(self.next_call_of("vkCmdSetScissor"))
require_not_equal(0, set_scissor.int_commandBuffer)
require_equal(0, set_scissor.int_firstScissor)
require_equal(1, set_scissor.int_scissorCount)
require_not_equal(0, set_scissor.hex_pScissors)
scissor = VulkanStruct(
architecture, RECT2D,
get_read_offset_function(set_scissor, set_scissor.hex_pScissors))
require_equal(0, scissor.offset_x)
require_equal(0, scissor.offset_x)
require_not_equal(0, scissor.extent_width)
require_not_equal(0, scissor.extent_width)
def GetCreatedEvent(architecture, create_event):
require_equal(VK_SUCCESS, int(create_event.return_val))
require_not_equal(0, create_event.int_device)
require_not_equal(0, create_event.hex_pCreateInfo)
require_not_equal(0, create_event.hex_pEvent)
create_info = VulkanStruct(architecture, EVENT_CREATE_INFO,
get_read_offset_function(
create_event, create_event.hex_pCreateInfo))
require_equal(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, create_info.sType)
require_equal(0, create_info.pNext)
require_equal(0, create_info.flags)
event = little_endian_bytes_to_int(require(create_event.get_write_data(
create_event.hex_pEvent, NON_DISPATCHABLE_HANDLE_SIZE)))
return event
def expect(self):
architecture = self.architecture
cmd_copy_buffer = require(self.next_call_of("vkCmdCopyBuffer"))
require_not_equal(0, cmd_copy_buffer.int_commandBuffer)
require_not_equal(0, cmd_copy_buffer.int_srcBuffer)
require_not_equal(0, cmd_copy_buffer.int_dstBuffer)
require_equal(1, cmd_copy_buffer.int_regionCount)
require_not_equal(0, cmd_copy_buffer.hex_pRegions)
copy = VulkanStruct(
architecture, BUFFER_COPY,
get_read_offset_function(cmd_copy_buffer,
cmd_copy_buffer.hex_pRegions))
require_equal(0, copy.srcOffset)
require_equal(0, copy.dstOffset)
require_equal(1024, copy.size)
def expect(self):
architecture = self.architecture
get_image_memory_requirements = require(
self.next_call_of("vkGetImageMemoryRequirements"))
require_not_equal(0, get_image_memory_requirements.int_device)
require_not_equal(0, get_image_memory_requirements.int_image)
require_not_equal(0,
get_image_memory_requirements.hex_pMemoryRequirements)
memory_requirements = VulkanStruct(
architecture, MEMORY_REQUIREMENTS, get_write_offset_function(
get_image_memory_requirements,
get_image_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)
def expect(self):
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
create_framebuffer = require(self.next_call_of("vkCreateFramebuffer"))
require_not_equal(0, create_framebuffer.int_device)
require_equal(0, create_framebuffer.hex_pAllocator)
framebuffer_create_info = VulkanStruct(
architecture, FRAMEBUFFER_CREATE_INFO,
get_read_offset_function(create_framebuffer,
create_framebuffer.hex_pCreateInfo))
require_equal(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
framebuffer_create_info.sType)
require_equal(0, framebuffer_create_info.pNext)
require_equal(0, framebuffer_create_info.flags)
require_not_equal(0, framebuffer_create_info.renderPass)
require_equal(1, framebuffer_create_info.attachmentCount)
require_not_equal(0, framebuffer_create_info.pAttachments)
require_not_equal(0, framebuffer_create_info.width)
require_not_equal(0, framebuffer_create_info.height)
require_equal(1, framebuffer_create_info.layers)
_ = require(
create_framebuffer.get_read_data(
framebuffer_create_info.pAttachments,
NON_DISPATCHABLE_HANDLE_SIZE))
_ = require(
create_framebuffer.get_write_data(
create_framebuffer.hex_pFramebuffer,
NON_DISPATCHABLE_HANDLE_SIZE))
destroy_framebuffer = require(
self.next_call_of("vkDestroyFramebuffer"))
require_not_equal(0, destroy_framebuffer.int_framebuffer)
require_not_equal(0, destroy_framebuffer.int_device)
require_equal(0, destroy_framebuffer.hex_pAllocator)
if self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200):
destroy_framebuffer = require(
self.next_call_of("vkDestroyFramebuffer"))
require_equal(0, destroy_framebuffer.int_framebuffer)
require_not_equal(0, destroy_framebuffer.int_device)
require_equal(0, destroy_framebuffer.hex_pAllocator)
def get_binding(create_descriptor_set_layout, architecture, create_info,
index):
"""Returns a VulkanStruct representing the |index|'th (starting from 0)
VkDescriptorSetLayoutBinding struct baked in |create_info| for the
|create_descriptor_set_layout| atom."""
binding_offset = create_info.pBindings + index * (
# Ok, this is a little bit tricky. We have 4 32-bit integers and a
# pointer in VkDescriptorSetLayoutBinding struct. On 32-bit
# architecture, pointer size is 4, so alignement should be fine.
# On 64-bit architecture, pointer size is 8, the struct totally
# occupies (4 * 4 + 8) bytes, so alignment should also be fine.
4 * 4 + int(architecture.int_pointerSize))
return VulkanStruct(
architecture, BINDING_ELEMENTS,
lambda offset, size: little_endian_bytes_to_int(
require(
create_descriptor_set_layout.get_read_data(
binding_offset + offset, size))))
def expect(self):
architecture = self.architecture
set_viewport = require(self.next_call_of("vkCmdSetViewport"))
require_not_equal(0, set_viewport.int_commandBuffer)
require_equal(0, set_viewport.int_firstViewport)
require_equal(1, set_viewport.int_viewportCount)
require_not_equal(0, set_viewport.hex_pViewports)
viewport = VulkanStruct(
architecture, VIEWPORT,
get_read_offset_function(set_viewport, set_viewport.hex_pViewports))
require_equal(0.0, viewport.x)
require_equal(0.0, viewport.y)
require_not_equal(0.0, viewport.width)
require_not_equal(0.0, viewport.height)
require_equal(0.0, viewport.minDepth)
require_equal(1.0, viewport.maxDepth)
def expect(self):
"""Check the arguments to vkCmdCopyImage"""
architecture = self.architecture
create_device = self.nth_call_of("vkCreateDevice", 2)
if create_device[0] is None:
raise GapidUnsupportedException(
"physical device feature: textureCompressionBC not supported")
copy_image = require(self.next_call_of("vkCmdCopyImage"))
require_not_equal(0, copy_image.int_commandBuffer)
require_not_equal(0, copy_image.int_srcImage)
require_equal(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
copy_image.int_srcImageLayout)
require_not_equal(0, copy_image.int_dstImage)
require_equal(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
copy_image.int_dstImageLayout)
require_equal(1, copy_image.int_regionCount)
image_copy = VulkanStruct(
architecture, IMAGE_COPY,
get_read_offset_function(copy_image, copy_image.hex_pRegions))
require_equal(VK_IMAGE_ASPECT_COLOR_BIT,
image_copy.srcSubresource_aspectMask)
require_equal(0, image_copy.srcSubresource_mipLevel)
require_equal(0, image_copy.srcSubresource_baseArrayLayer)
require_equal(1, image_copy.srcSubresource_layerCount)
require_equal(8, image_copy.srcOffset_x)
require_equal(12, image_copy.srcOffset_y)
require_equal(0, image_copy.srcOffset_z)
require_equal(VK_IMAGE_ASPECT_COLOR_BIT,
image_copy.dstSubresource_aspectMask)
require_equal(0, image_copy.dstSubresource_mipLevel)
require_equal(0, image_copy.dstSubresource_baseArrayLayer)
require_equal(1, image_copy.dstSubresource_layerCount)
require_equal(16, image_copy.dstOffset_x)
require_equal(16, image_copy.dstOffset_y)
require_equal(0, image_copy.dstOffset_z)
require_equal(16, image_copy.extent_x)
require_equal(12, image_copy.extent_y)
require_equal(1, image_copy.extent_z)
def expect(self):
architecture = self.architecture
create_pipeline = require(self.nth_call_of("vkCreatePipelineLayout",
2))
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(1, 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)
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)
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):
"""Check the arguments and data to vkCmdPushConstants"""
architecture = self.architecture
push_constants = require(self.nth_call_of("vkCmdPushConstants", 1))
require_not_equal(0, push_constants.int_commandBuffer)
require_not_equal(0, push_constants.int_layout)
require_equal(VK_SHADER_STAGE_VERTEX_BIT,
push_constants.int_stageFlags)
require_equal(0, push_constants.int_offset)
require_equal(100, push_constants.int_size)
require_not_equal(0, push_constants.hex_pValues)
CHAR_ARRAY_100 = [("values", ARRAY, 100, CHAR)]
data = VulkanStruct(
architecture, CHAR_ARRAY_100,
get_read_offset_function(push_constants,
push_constants.hex_pValues))
expected_data = [0xab for i in range(100)]
require_equal(expected_data, data.values)
def expect(self):
"""Check the arguments to vkCmdBlitImage"""
architecture = self.architecture
blit_image = require(self.nth_call_of("vkCmdBlitImage", 1))
require_not_equal(0, blit_image.int_commandBuffer)
require_not_equal(0, blit_image.int_srcImage)
require_equal(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
blit_image.int_srcImageLayout)
require_not_equal(0, blit_image.int_dstImage)
require_equal(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
blit_image.int_dstImageLayout)
require_equal(1, blit_image.int_regionCount)
require_equal(VK_FILTER_LINEAR, blit_image.int_filter)
image_blit = VulkanStruct(architecture, IMAGE_BLIT,
get_read_offset_function(
blit_image, blit_image.hex_pRegions))
require_equal(VK_IMAGE_ASPECT_COLOR_BIT,
image_blit.srcSubresource_aspectMask)
require_equal(0, image_blit.srcSubresource_mipLevel)
require_equal(0, image_blit.srcSubresource_baseArrayLayer)
require_equal(1, image_blit.srcSubresource_layerCount)
require_equal(0, image_blit.srcOffset_0_x)
require_equal(0, image_blit.srcOffset_0_y)
require_equal(0, image_blit.srcOffset_0_z)
require_equal(32, image_blit.srcOffset_1_x)
require_equal(32, image_blit.srcOffset_1_y)
require_equal(1, image_blit.srcOffset_1_z)
require_equal(VK_IMAGE_ASPECT_COLOR_BIT,
image_blit.dstSubresource_aspectMask)
require_equal(0, image_blit.dstSubresource_mipLevel)
require_equal(0, image_blit.dstSubresource_baseArrayLayer)
require_equal(1, image_blit.dstSubresource_layerCount)
require_equal(0, image_blit.dstOffset_0_x)
require_equal(0, image_blit.dstOffset_0_y)
require_equal(0, image_blit.dstOffset_0_z)
require_equal(32, image_blit.dstOffset_1_x)
require_equal(32, image_blit.dstOffset_1_y)
require_equal(1, image_blit.dstOffset_1_z)
def CheckAtom(atom,
architecture,
physical_device,
format=VK_FORMAT_R8G8B8A8_UNORM,
type=VK_IMAGE_TYPE_2D,
tiling=VK_IMAGE_TILING_OPTIMAL,
usage=VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
flags=0):
require_equal(True, IsExpectedReturnCode(int(int32(atom.return_val))))
require_equal(physical_device, atom.int_physicalDevice)
require_equal(format, atom.int_format)
require_equal(type, atom.int_type)
require_equal(tiling, atom.int_tiling)
require_equal(usage, atom.int_usage)
require_equal(flags, atom.int_flags)
require_not_equal(0, atom.hex_pImageFormatProperties)
if int(atom.return_val) == VK_SUCCESS:
VulkanStruct(
architecture, IMAGE_FORMAT_PROPERTIES,
get_write_offset_function(atom, atom.hex_pImageFormatProperties))
def expect(self):
num_queries = 4
result_width = 4
architecture = self.architecture
get_query_result = require(self.nth_call_of("vkGetQueryPoolResults", 1))
require_not_equal(0, get_query_result.int_device)
require_not_equal(0, get_query_result.int_queryPool)
require_equal(0, get_query_result.int_firstQuery)
require_equal(num_queries, get_query_result.int_queryCount)
require_equal(num_queries * result_width, get_query_result.int_dataSize)
require_not_equal(0, get_query_result.hex_pData)
require_equal(result_width, get_query_result.int_stride)
require_equal(0, get_query_result.int_flags)
require_equal(VK_SUCCESS, int(get_query_result.return_val))
result_data = VulkanStruct(
architecture, [("data", ARRAY, num_queries, UINT32_T)],
get_write_offset_function(get_query_result,
get_query_result.hex_pData))
require_equal([0 for i in range(num_queries)], result_data.data)