def expect(self):
"""4. Expects an image with linear tiling and can be used as the source
and destination of a transfer command."""
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
create_image, device, image = check_create_image(self, 4)
info = get_image_create_info(create_image, architecture)
check_destroy_image(self, device, image, device_properties)
require_equal(info.sType, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
require_equal(info.pNext, 0)
require_equal(info.flags, 0)
require_equal(info.imageType, VK_IMAGE_TYPE_2D)
require_equal(info.format, VK_FORMAT_R8G8B8A8_UNORM)
require_equal(info.extent_width, 32)
require_equal(info.extent_height, 32)
require_equal(info.extent_depth, 1)
require_equal(info.mipLevels, 1)
require_equal(info.arrayLayers, 1)
require_equal(info.samples, VK_SAMPLE_COUNT_1_BIT)
require_equal(info.tiling, VK_IMAGE_TILING_LINEAR)
require_equal(
info.usage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT
| VK_IMAGE_USAGE_TRANSFER_DST_BIT)
require_equal(info.sharingMode, VK_SHARING_MODE_EXCLUSIVE)
require_equal(info.queueFamilyIndexCount, 0)
require_equal(info.pQueueFamilyIndices, 0)
require_equal(info.initialLayout, VK_IMAGE_LAYOUT_UNDEFINED)
def expect(self):
"""Check the arguments to vkCmdCopyBufferToImage"""
architecture = self.architecture
copy_buffer_to_image = require(
self.nth_call_of("vkCmdCopyBufferToImage", 1))
require_not_equal(0, copy_buffer_to_image.int_commandBuffer)
require_not_equal(0, copy_buffer_to_image.int_srcBuffer)
require_not_equal(0, copy_buffer_to_image.int_dstImage)
require_equal(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
copy_buffer_to_image.int_dstImageLayout)
require_equal(1, copy_buffer_to_image.int_regionCount)
require_not_equal(0, copy_buffer_to_image.hex_pRegions)
buffer_image_copy = VulkanStruct(
architecture, BUFFER_IMAGE_COPY,
get_read_offset_function(copy_buffer_to_image,
copy_buffer_to_image.hex_pRegions))
require_equal(0, buffer_image_copy.bufferOffset)
require_equal(0, buffer_image_copy.bufferRowLength)
require_equal(0, buffer_image_copy.bufferImageHeight)
require_equal(VK_IMAGE_ASPECT_COLOR_BIT,
buffer_image_copy.imageSubresource_aspectMask)
require_equal(0, buffer_image_copy.imageSubresource_mipLevel)
require_equal(0, buffer_image_copy.imageSubresource_baseArrayLayer)
require_equal(1, buffer_image_copy.imageSubresource_layerCount)
require_equal(0, buffer_image_copy.imageOffset_x)
require_equal(0, buffer_image_copy.imageOffset_y)
require_equal(0, buffer_image_copy.imageOffset_z)
require_equal(32, buffer_image_copy.imageExtent_width)
require_equal(32, buffer_image_copy.imageExtent_height)
require_equal(1, buffer_image_copy.imageExtent_depth)
def check_destroy_sampler(test, device, sampler):
"""Checks that the next vkDestroySampler command call atom has the
passed-in |device| and |sampler| handle value.
"""
destroy_sampler = require(test.next_call_of("vkDestroySampler"))
require_equal(device, destroy_sampler.int_device)
require_equal(sampler, destroy_sampler.int_sampler)
def expect(self):
"""1. Expects a sampler with normalized coordinates."""
architecture = self.architecture
device_properties = require(
self.nth_call_of("vkGetPhysicalDeviceProperties", 1))
create_sampler, device, sampler = check_create_sampler(self)
info = get_sampler_create_info(create_sampler, architecture)
require_equal(info.sType, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
require_equal(info.pNext, 0)
require_equal(info.flags, 0)
require_equal(info.magFilter, VK_FILTER_NEAREST)
require_equal(info.minFilter, VK_FILTER_LINEAR)
require_equal(info.mipmapMode, VK_SAMPLER_MIPMAP_MODE_LINEAR)
require_equal(info.addressModeU, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
require_equal(info.addressModeV, VK_SAMPLER_ADDRESS_MODE_REPEAT)
require_equal(info.addressModeW,
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)
require_equal(info.mipLodBias, -1.)
require_false(info.anisotropyEnable)
require_equal(info.maxAnisotropy, 1.)
require_false(info.compareEnable)
require_equal(info.compareOp, VK_COMPARE_OP_ALWAYS)
require_equal(info.minLod, 1.)
require_equal(info.maxLod, 2.)
require_equal(info.borderColor, VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK)
require_false(info.unnormalizedCoordinates)
check_destroy_sampler(self, device, sampler)
def expect(self):
"""The first call to vkCmdSetLineWidth should have line width value: 1.0
"""
set_line_width = require(self.nth_call_of("vkCmdSetLineWidth", 1))
require_not_equal(0, set_line_width.int_commandBuffer)
require_equal(1.0, set_line_width.float_lineWidth)
def check_destroy_image(test, device, image, device_properties):
"""Checks the |index|'th vkDestroyImage command call atom, including the
device handler value and the image handler value.
"""
destroy_image = require(test.next_call_of("vkDestroyImage"))
require_equal(device, destroy_image.int_device)
require_equal(image, destroy_image.int_image)
def expect(self):
"""1. Expects a normal 2D color attachement image."""
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
create_image, device, image = check_create_image(self, 1)
info = get_image_create_info(create_image, architecture)
check_destroy_image(self, device, image, device_properties)
require_equal(info.sType, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
require_equal(info.pNext, 0)
require_equal(info.flags, 0)
require_equal(info.imageType, VK_IMAGE_TYPE_2D)
require_equal(info.format, VK_FORMAT_R8G8B8A8_UNORM)
require_equal(info.extent_width, 32)
require_equal(info.extent_height, 32)
require_equal(info.extent_depth, 1)
require_equal(info.mipLevels, 1)
require_equal(info.arrayLayers, 1)
require_equal(info.samples, VK_SAMPLE_COUNT_1_BIT)
require_equal(info.tiling, VK_IMAGE_TILING_OPTIMAL)
require_equal(info.usage, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
require_equal(info.sharingMode, VK_SHARING_MODE_EXCLUSIVE)
require_equal(info.queueFamilyIndexCount, 0)
require_equal(info.pQueueFamilyIndices, 0)
require_equal(info.initialLayout, VK_IMAGE_LAYOUT_UNDEFINED)
def expect(self):
set_blend_constants = require(
self.next_call_of("vkCmdSetBlendConstants"))
require_not_equal(0, set_blend_constants.int_commandBuffer)
require_equal([1.25, 2.5, 5.0, 10.0],
set_blend_constants.float_blendConstants)
def expect(self):
num_queries = 8
get_result_num_queries = 4
result_width = 8
architecture = self.architecture
get_query_result = require(self.nth_call_of("vkGetQueryPoolResults", 2))
require_not_equal(0, get_query_result.int_device)
require_not_equal(0, get_query_result.int_queryPool)
require_equal(num_queries - get_result_num_queries,
get_query_result.int_firstQuery)
require_equal(get_result_num_queries, get_query_result.int_queryCount)
require_equal(result_width * get_result_num_queries,
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(VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT,
get_query_result.int_flags)
require_equal(VK_SUCCESS, int(get_query_result.return_val))
result_data = VulkanStruct(
architecture, [("data", ARRAY, get_result_num_queries, UINT64_T)],
get_write_offset_function(get_query_result,
get_query_result.hex_pData))
require_equal([0 for i in range(get_result_num_queries)],
result_data.data)
def expect(self):
num_queries = 4
stride = 12
architecture = self.architecture
get_query_result = require(self.nth_call_of("vkGetQueryPoolResults", 3))
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 * stride, get_query_result.int_dataSize)
require_not_equal(0, get_query_result.hex_pData)
require_equal(stride, get_query_result.int_stride)
require_equal(VK_QUERY_RESULT_PARTIAL_BIT
| VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
get_query_result.int_flags)
require_equal(VK_SUCCESS, int(get_query_result.return_val))
result_data = VulkanStruct(
architecture, [("data", ARRAY, num_queries * stride / 4, UINT32_T)],
get_write_offset_function(get_query_result,
get_query_result.hex_pData))
expected_data = [0, 1, 0xFFFFFFFF, 0, 1, 0xFFFFFFFF, 0, 1, 0xFFFFFFFF,
0, 1, 0xFFFFFFFF]
require_equal(expected_data, result_data.data)
def expect(self):
"""3. Free null descriptor sets."""
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
if (self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200)):
free_descriptor_set = require(
self.nth_call_of("vkFreeDescriptorSets", 3))
p_sets = free_descriptor_set.hex_pDescriptorSets
for i in range(2):
actual_set = little_endian_bytes_to_int(
require(
free_descriptor_set.get_read_data(
p_sets + NON_DISPATCHABLE_HANDLE_SIZE * i,
NON_DISPATCHABLE_HANDLE_SIZE)))
require_equal(0, actual_set)
def expect(self):
dispatch = require(self.next_call_of("vkCmdDispatch"))
require_not_equal(0, dispatch.int_commandBuffer)
require_equal(512, dispatch.int_groupCountX)
require_equal(1, dispatch.int_groupCountY)
require_equal(1, dispatch.int_groupCountZ)
def expect(self):
"""Check the arguments to vkCmdExecuteCommands"""
execute_commands = require(self.nth_call_of("vkCmdExecuteCommands", 1))
require_not_equal(0, execute_commands.int_commandBuffer)
require_equal(2, execute_commands.int_commandBufferCount)
require_not_equal(0, execute_commands.hex_pCommandBuffers)
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_integerSize))) + 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):
"""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 check_free_descriptor_set(test, device, pool, sets):
"""Checks that the next vkFreeDescriptorSets command call atom is used to
free the given descriptor |sets| from the given descriptor |pool| on the
given |device|.
"""
free_descriptor_set = require(
test.next_call_of("vkFreeDescriptorSets"))
require_equal(device, free_descriptor_set.int_device)
require_equal(pool, free_descriptor_set.int_descriptorPool)
require_equal(len(sets), free_descriptor_set.int_descriptorSetCount)
p_sets = free_descriptor_set.hex_pDescriptorSets
for i, expected_set in enumerate(sets):
actual_set = little_endian_bytes_to_int(
require(free_descriptor_set.get_read_data(
p_sets + NON_DISPATCHABLE_HANDLE_SIZE * i,
NON_DISPATCHABLE_HANDLE_SIZE)))
require_equal(expected_set, actual_set)
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 expect(self):
architecture = self.architecture
bind_pipeline = require(self.next_call_of("vkCmdBindPipeline"))
require_not_equal(0, bind_pipeline.int_commandBuffer)
require_equal(VK_PIPELINE_BIND_POINT_GRAPHICS,
bind_pipeline.int_pipelineBindPoint)
require_not_equal(0, bind_pipeline.int_pipeline)
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 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))
def expect(self):
draw = require(self.next_call_of("vkCmdDraw"))
require_not_equal(0, draw.int_commandBuffer)
require_equal(3, draw.int_vertexCount)
require_equal(1, draw.int_instanceCount)
require_equal(0, draw.int_firstVertex)
require_equal(0, draw.int_firstInstance)
def expect(self):
draw = require(self.next_call_of("vkCmdDrawIndexedIndirect"))
require_not_equal(0, draw.int_commandBuffer)
require_not_equal(0, draw.int_buffer)
require_equal(0, draw.int_offset)
require_equal(1, draw.int_drawCount)
require_equal(0, draw.int_stride)
def check_destroy_descriptor_pool(test, device, descriptor_pool):
"""Checks that the next vkDestroyDescriptorPool command call atom has the
passed-in |device| and |descriptor_pool| handle value.
"""
destroy_descriptor_pool = require(
test.next_call_of("vkDestroyDescriptorPool"))
require_equal(device, destroy_descriptor_pool.int_device)
require_equal(descriptor_pool, destroy_descriptor_pool.int_descriptorPool)
def expect(self):
"""2. Expects vkCmdResetQueryPool() is called with firstQuery: 1,
queryCount: 5."""
reset_query_pool = require(self.nth_call_of("vkCmdResetQueryPool", 2))
require_not_equal(0, reset_query_pool.int_commandBuffer)
require_not_equal(0, reset_query_pool.int_queryPool)
require_equal(1, reset_query_pool.int_firstQuery)
require_equal(5, reset_query_pool.int_queryCount)
def GetMappedLocation(test):
require(test.nth_call_of("vkDestroyBuffer", 3))
map_coherent_memory = require(test.next_call_of("vkMapMemory"))
require_equal(VK_SUCCESS, int(map_coherent_memory.return_val))
require_not_equal(0, map_coherent_memory.int_device)
require_not_equal(0, map_coherent_memory.int_memory)
# All vkMapMemory called in this test has offset 0.
require_equal(0, map_coherent_memory.int_offset)
require_true(map_coherent_memory.int_size >= BUFFER_SIZE)
require_equal(0, map_coherent_memory.int_flags)
require_not_equal(0, map_coherent_memory.hex_ppData)
pData = little_endian_bytes_to_int(
require(
map_coherent_memory.get_write_data(
map_coherent_memory.hex_ppData,
test.architecture.int_pointerSize)))
return pData
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 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):
"""2. Expects a buffer view created with non-zero offset and
non-VK_WHOLE_SIZE range for a storage texel buffer."""
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
create_buffer_view = require(self.nth_call_of("vkCreateBufferView", 2))
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(MIN_TEXEL_BUFFER_OFFSET_ALIGNMENT * 1,
create_info.offset)
require_equal(MIN_TEXEL_BUFFER_OFFSET_ALIGNMENT * 3, 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):
"""3. Expects a command pool created with
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, then reset with flag of value
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, and finally destroyed"""
architecture = self.architecture
create_command_pool = require(
self.nth_call_of("vkCreateCommandPool", 3))
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
| VK_COMMAND_POOL_CREATE_TRANSIENT_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(VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT,
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 expect(self):
"""3. Expects a query pool to be created with queryCount: 4 and
queryType: VK_QUERY_TYPE_PIPELINE_STATISTICS and pipelineStatistics:
VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT."""
architecture = self.architecture
device_properties = require(
self.next_call_of("vkGetPhysicalDeviceProperties"))
create_device = self.nth_call_of("vkCreateDevice", 1)
if create_device[0] is None:
raise GapidUnsupportedException(
"physical device feature: pipelineStatistics not supported")
create_query_pool = require(self.next_call_of("vkCreateQueryPool"))
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_PIPELINE_STATISTICS, create_info.queryType)
require_equal(4, create_info.queryCount)
require_equal(
VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
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)
