king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd5f7aa4152'
${ noResults }
v811_spc009/external/vulkan-validation-layers/layers/generated/thread_safety.cpp

5850 lines
244 KiB
Raw Blame History

// This file is ***GENERATED***. Do Not Edit.
// See thread_safety_generator.py for modifications.
/* Copyright (c) 2015-2019 The Khronos Group Inc.
* Copyright (c) 2015-2019 Valve Corporation
* Copyright (c) 2015-2019 LunarG, Inc.
* Copyright (c) 2015-2019 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Author: Mark Lobodzinski <mark@lunarg.com>
*/
#include "chassis.h"
#include "thread_safety.h"
void ThreadSafety::PreCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
VkCommandBuffer *pCommandBuffers) {
StartReadObject(device);
StartWriteObject(pAllocateInfo->commandPool);
}
void ThreadSafety::PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
VkCommandBuffer *pCommandBuffers, VkResult result) {
FinishReadObject(device);
FinishWriteObject(pAllocateInfo->commandPool);
// Record mapping from command buffer to command pool
if(pCommandBuffers) {
for (uint32_t index = 0; index < pAllocateInfo->commandBufferCount; index++) {
auto &bucket = GetBucket(pCommandBuffers[index]);
std::lock_guard<std::mutex> lock(bucket.command_pool_lock);
bucket.command_pool_map[pCommandBuffers[index]] = pAllocateInfo->commandPool;
}
}
}
void ThreadSafety::PreCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets) {
StartReadObject(device);
StartWriteObject(pAllocateInfo->descriptorPool);
// Host access to pAllocateInfo::descriptorPool must be externally synchronized
}
void ThreadSafety::PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets, VkResult result) {
FinishReadObject(device);
FinishWriteObject(pAllocateInfo->descriptorPool);
// Host access to pAllocateInfo::descriptorPool must be externally synchronized
}
void ThreadSafety::PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
const bool lockCommandPool = false; // pool is already directly locked
StartReadObject(device);
StartWriteObject(commandPool);
if(pCommandBuffers) {
// Even though we're immediately "finishing" below, we still are testing for concurrency with any call in process
// so this isn't a no-op
for (uint32_t index = 0; index < commandBufferCount; index++) {
StartWriteObject(pCommandBuffers[index], lockCommandPool);
}
// The driver may immediately reuse command buffers in another thread.
// These updates need to be done before calling down to the driver.
for (uint32_t index = 0; index < commandBufferCount; index++) {
FinishWriteObject(pCommandBuffers[index], lockCommandPool);
}
// Holding the lock for the shortest time while we update the map
for (uint32_t index = 0; index < commandBufferCount; index++) {
auto &bucket = GetBucket(pCommandBuffers[index]);
std::lock_guard<std::mutex> lock(bucket.command_pool_lock);
bucket.command_pool_map.erase(pCommandBuffers[index]);
}
}
}
void ThreadSafety::PostCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
FinishReadObject(device);
FinishWriteObject(commandPool);
}
void ThreadSafety::PreCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
StartReadObject(device);
StartWriteObject(commandPool);
// Check for any uses of non-externally sync'd command buffers (for example from vkCmdExecuteCommands)
c_VkCommandPoolContents.StartWrite(commandPool);
// Host access to commandPool must be externally synchronized
}
void ThreadSafety::PostCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, VkResult result) {
FinishReadObject(device);
FinishWriteObject(commandPool);
c_VkCommandPoolContents.FinishWrite(commandPool);
// Host access to commandPool must be externally synchronized
}
void ThreadSafety::PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
StartReadObject(device);
StartWriteObject(commandPool);
// Check for any uses of non-externally sync'd command buffers (for example from vkCmdExecuteCommands)
c_VkCommandPoolContents.StartWrite(commandPool);
// Host access to commandPool must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
FinishReadObject(device);
FinishWriteObject(commandPool);
c_VkCommandPoolContents.FinishWrite(commandPool);
}
// GetSwapchainImages can return a non-zero count with a NULL pSwapchainImages pointer. Let's avoid crashes by ignoring
// pSwapchainImages.
void ThreadSafety::PreCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
VkImage *pSwapchainImages) {
StartReadObject(device);
StartReadObject(swapchain);
}
void ThreadSafety::PostCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
VkImage *pSwapchainImages, VkResult result) {
FinishReadObject(device);
FinishReadObject(swapchain);
}
void ThreadSafety::PreCallRecordDestroyInstance(
VkInstance instance,
const VkAllocationCallbacks* pAllocator) {
StartWriteObject(instance);
// Host access to instance must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyInstance(
VkInstance instance,
const VkAllocationCallbacks* pAllocator) {
FinishWriteObject(instance);
// Host access to instance must be externally synchronized
}
void ThreadSafety::PreCallRecordEnumeratePhysicalDevices(
VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordEnumeratePhysicalDevices(
VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices,
VkResult result) {
FinishReadObject(instance);
}
void ThreadSafety::PreCallRecordGetInstanceProcAddr(
VkInstance instance,
const char* pName) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordGetInstanceProcAddr(
VkInstance instance,
const char* pName) {
FinishReadObject(instance);
}
void ThreadSafety::PreCallRecordGetDeviceProcAddr(
VkDevice device,
const char* pName) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDeviceProcAddr(
VkDevice device,
const char* pName) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyDevice(
VkDevice device,
const VkAllocationCallbacks* pAllocator) {
StartWriteObject(device);
// Host access to device must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyDevice(
VkDevice device,
const VkAllocationCallbacks* pAllocator) {
FinishWriteObject(device);
// Host access to device must be externally synchronized
}
void ThreadSafety::PreCallRecordGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
VkQueue* pQueue) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
VkQueue* pQueue) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordQueueSubmit(
VkQueue queue,
uint32_t submitCount,
const VkSubmitInfo* pSubmits,
VkFence fence) {
StartWriteObject(queue);
StartWriteObject(fence);
// Host access to queue must be externally synchronized
// Host access to fence must be externally synchronized
}
void ThreadSafety::PostCallRecordQueueSubmit(
VkQueue queue,
uint32_t submitCount,
const VkSubmitInfo* pSubmits,
VkFence fence,
VkResult result) {
FinishWriteObject(queue);
FinishWriteObject(fence);
// Host access to queue must be externally synchronized
// Host access to fence must be externally synchronized
}
void ThreadSafety::PreCallRecordQueueWaitIdle(
VkQueue queue) {
StartWriteObject(queue);
// Host access to queue must be externally synchronized
}
void ThreadSafety::PostCallRecordQueueWaitIdle(
VkQueue queue,
VkResult result) {
FinishWriteObject(queue);
// Host access to queue must be externally synchronized
}
void ThreadSafety::PreCallRecordDeviceWaitIdle(
VkDevice device) {
StartReadObject(device);
// all sname:VkQueue objects created from pname:device must be externally synchronized between host accesses
}
void ThreadSafety::PostCallRecordDeviceWaitIdle(
VkDevice device,
VkResult result) {
FinishReadObject(device);
// all sname:VkQueue objects created from pname:device must be externally synchronized between host accesses
}
void ThreadSafety::PreCallRecordAllocateMemory(
VkDevice device,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordAllocateMemory(
VkDevice device,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordFreeMemory(
VkDevice device,
VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(memory);
// Host access to memory must be externally synchronized
}
void ThreadSafety::PostCallRecordFreeMemory(
VkDevice device,
VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(memory);
// Host access to memory must be externally synchronized
}
void ThreadSafety::PreCallRecordMapMemory(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData) {
StartReadObject(device);
StartWriteObject(memory);
// Host access to memory must be externally synchronized
}
void ThreadSafety::PostCallRecordMapMemory(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(memory);
// Host access to memory must be externally synchronized
}
void ThreadSafety::PreCallRecordUnmapMemory(
VkDevice device,
VkDeviceMemory memory) {
StartReadObject(device);
StartWriteObject(memory);
// Host access to memory must be externally synchronized
}
void ThreadSafety::PostCallRecordUnmapMemory(
VkDevice device,
VkDeviceMemory memory) {
FinishReadObject(device);
FinishWriteObject(memory);
// Host access to memory must be externally synchronized
}
void ThreadSafety::PreCallRecordFlushMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordFlushMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordInvalidateMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordInvalidateMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes) {
StartReadObject(device);
StartReadObject(memory);
}
void ThreadSafety::PostCallRecordGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes) {
FinishReadObject(device);
FinishReadObject(memory);
}
void ThreadSafety::PreCallRecordBindBufferMemory(
VkDevice device,
VkBuffer buffer,
VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
StartReadObject(device);
StartWriteObject(buffer);
StartReadObject(memory);
// Host access to buffer must be externally synchronized
}
void ThreadSafety::PostCallRecordBindBufferMemory(
VkDevice device,
VkBuffer buffer,
VkDeviceMemory memory,
VkDeviceSize memoryOffset,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(buffer);
FinishReadObject(memory);
// Host access to buffer must be externally synchronized
}
void ThreadSafety::PreCallRecordBindImageMemory(
VkDevice device,
VkImage image,
VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
StartReadObject(device);
StartWriteObject(image);
StartReadObject(memory);
// Host access to image must be externally synchronized
}
void ThreadSafety::PostCallRecordBindImageMemory(
VkDevice device,
VkImage image,
VkDeviceMemory memory,
VkDeviceSize memoryOffset,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(image);
FinishReadObject(memory);
// Host access to image must be externally synchronized
}
void ThreadSafety::PreCallRecordGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements) {
StartReadObject(device);
StartReadObject(buffer);
}
void ThreadSafety::PostCallRecordGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements) {
FinishReadObject(device);
FinishReadObject(buffer);
}
void ThreadSafety::PreCallRecordGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements) {
StartReadObject(device);
StartReadObject(image);
}
void ThreadSafety::PostCallRecordGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements) {
FinishReadObject(device);
FinishReadObject(image);
}
void ThreadSafety::PreCallRecordGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
StartReadObject(device);
StartReadObject(image);
}
void ThreadSafety::PostCallRecordGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
FinishReadObject(device);
FinishReadObject(image);
}
void ThreadSafety::PreCallRecordQueueBindSparse(
VkQueue queue,
uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo,
VkFence fence) {
StartWriteObject(queue);
if (pBindInfo) {
for (uint32_t index=0; index < bindInfoCount; index++) {
if (pBindInfo[index].pBufferBinds) {
for (uint32_t index2=0; index2 < pBindInfo[index].bufferBindCount; index2++) {
StartWriteObject(pBindInfo[index].pBufferBinds[index2].buffer);
}
}
if (pBindInfo[index].pImageOpaqueBinds) {
for (uint32_t index2=0; index2 < pBindInfo[index].imageOpaqueBindCount; index2++) {
StartWriteObject(pBindInfo[index].pImageOpaqueBinds[index2].image);
}
}
if (pBindInfo[index].pImageBinds) {
for (uint32_t index2=0; index2 < pBindInfo[index].imageBindCount; index2++) {
StartWriteObject(pBindInfo[index].pImageBinds[index2].image);
}
}
}
}
StartWriteObject(fence);
// Host access to queue must be externally synchronized
// Host access to pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image must be externally synchronized
// Host access to fence must be externally synchronized
}
void ThreadSafety::PostCallRecordQueueBindSparse(
VkQueue queue,
uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo,
VkFence fence,
VkResult result) {
FinishWriteObject(queue);
if (pBindInfo) {
for (uint32_t index=0; index < bindInfoCount; index++) {
if (pBindInfo[index].pBufferBinds) {
for (uint32_t index2=0; index2 < pBindInfo[index].bufferBindCount; index2++) {
FinishWriteObject(pBindInfo[index].pBufferBinds[index2].buffer);
}
}
if (pBindInfo[index].pImageOpaqueBinds) {
for (uint32_t index2=0; index2 < pBindInfo[index].imageOpaqueBindCount; index2++) {
FinishWriteObject(pBindInfo[index].pImageOpaqueBinds[index2].image);
}
}
if (pBindInfo[index].pImageBinds) {
for (uint32_t index2=0; index2 < pBindInfo[index].imageBindCount; index2++) {
FinishWriteObject(pBindInfo[index].pImageBinds[index2].image);
}
}
}
}
FinishWriteObject(fence);
// Host access to queue must be externally synchronized
// Host access to pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image must be externally synchronized
// Host access to fence must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyFence(
VkDevice device,
VkFence fence,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(fence);
// Host access to fence must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyFence(
VkDevice device,
VkFence fence,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(fence);
// Host access to fence must be externally synchronized
}
void ThreadSafety::PreCallRecordResetFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences) {
StartReadObject(device);
if (pFences) {
for (uint32_t index=0; index < fenceCount; index++) {
StartWriteObject(pFences[index]);
}
}
// Host access to each member of pFences must be externally synchronized
}
void ThreadSafety::PostCallRecordResetFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences,
VkResult result) {
FinishReadObject(device);
if (pFences) {
for (uint32_t index=0; index < fenceCount; index++) {
FinishWriteObject(pFences[index]);
}
}
// Host access to each member of pFences must be externally synchronized
}
void ThreadSafety::PreCallRecordGetFenceStatus(
VkDevice device,
VkFence fence) {
StartReadObject(device);
StartReadObject(fence);
}
void ThreadSafety::PostCallRecordGetFenceStatus(
VkDevice device,
VkFence fence,
VkResult result) {
FinishReadObject(device);
FinishReadObject(fence);
}
void ThreadSafety::PreCallRecordWaitForFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences,
VkBool32 waitAll,
uint64_t timeout) {
StartReadObject(device);
if (pFences) {
for (uint32_t index = 0; index < fenceCount; index++) {
StartReadObject(pFences[index]);
}
}
}
void ThreadSafety::PostCallRecordWaitForFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences,
VkBool32 waitAll,
uint64_t timeout,
VkResult result) {
FinishReadObject(device);
if (pFences) {
for (uint32_t index = 0; index < fenceCount; index++) {
FinishReadObject(pFences[index]);
}
}
}
void ThreadSafety::PreCallRecordCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroySemaphore(
VkDevice device,
VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(semaphore);
// Host access to semaphore must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroySemaphore(
VkDevice device,
VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(semaphore);
// Host access to semaphore must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyEvent(
VkDevice device,
VkEvent event,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(event);
// Host access to event must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyEvent(
VkDevice device,
VkEvent event,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(event);
// Host access to event must be externally synchronized
}
void ThreadSafety::PreCallRecordGetEventStatus(
VkDevice device,
VkEvent event) {
StartReadObject(device);
StartReadObject(event);
}
void ThreadSafety::PostCallRecordGetEventStatus(
VkDevice device,
VkEvent event,
VkResult result) {
FinishReadObject(device);
FinishReadObject(event);
}
void ThreadSafety::PreCallRecordSetEvent(
VkDevice device,
VkEvent event) {
StartReadObject(device);
StartWriteObject(event);
// Host access to event must be externally synchronized
}
void ThreadSafety::PostCallRecordSetEvent(
VkDevice device,
VkEvent event,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(event);
// Host access to event must be externally synchronized
}
void ThreadSafety::PreCallRecordResetEvent(
VkDevice device,
VkEvent event) {
StartReadObject(device);
StartWriteObject(event);
// Host access to event must be externally synchronized
}
void ThreadSafety::PostCallRecordResetEvent(
VkDevice device,
VkEvent event,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(event);
// Host access to event must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(queryPool);
// Host access to queryPool must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(queryPool);
// Host access to queryPool must be externally synchronized
}
void ThreadSafety::PreCallRecordGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
size_t dataSize,
void* pData,
VkDeviceSize stride,
VkQueryResultFlags flags) {
StartReadObject(device);
StartReadObject(queryPool);
}
void ThreadSafety::PostCallRecordGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
size_t dataSize,
void* pData,
VkDeviceSize stride,
VkQueryResultFlags flags,
VkResult result) {
FinishReadObject(device);
FinishReadObject(queryPool);
}
void ThreadSafety::PreCallRecordCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyBuffer(
VkDevice device,
VkBuffer buffer,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(buffer);
// Host access to buffer must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyBuffer(
VkDevice device,
VkBuffer buffer,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(buffer);
// Host access to buffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBufferView* pView) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBufferView* pView,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(bufferView);
// Host access to bufferView must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(bufferView);
// Host access to bufferView must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImage* pImage) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImage* pImage,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyImage(
VkDevice device,
VkImage image,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(image);
// Host access to image must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyImage(
VkDevice device,
VkImage image,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(image);
// Host access to image must be externally synchronized
}
void ThreadSafety::PreCallRecordGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout) {
StartReadObject(device);
StartReadObject(image);
}
void ThreadSafety::PostCallRecordGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout) {
FinishReadObject(device);
FinishReadObject(image);
}
void ThreadSafety::PreCallRecordCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImageView* pView) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImageView* pView,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyImageView(
VkDevice device,
VkImageView imageView,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(imageView);
// Host access to imageView must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyImageView(
VkDevice device,
VkImageView imageView,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(imageView);
// Host access to imageView must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(shaderModule);
// Host access to shaderModule must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(shaderModule);
// Host access to shaderModule must be externally synchronized
}
void ThreadSafety::PreCallRecordCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(pipelineCache);
// Host access to pipelineCache must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(pipelineCache);
// Host access to pipelineCache must be externally synchronized
}
void ThreadSafety::PreCallRecordGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
size_t* pDataSize,
void* pData) {
StartReadObject(device);
StartReadObject(pipelineCache);
}
void ThreadSafety::PostCallRecordGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
size_t* pDataSize,
void* pData,
VkResult result) {
FinishReadObject(device);
FinishReadObject(pipelineCache);
}
void ThreadSafety::PreCallRecordMergePipelineCaches(
VkDevice device,
VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches) {
StartReadObject(device);
StartWriteObject(dstCache);
if (pSrcCaches) {
for (uint32_t index = 0; index < srcCacheCount; index++) {
StartReadObject(pSrcCaches[index]);
}
}
// Host access to dstCache must be externally synchronized
}
void ThreadSafety::PostCallRecordMergePipelineCaches(
VkDevice device,
VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(dstCache);
if (pSrcCaches) {
for (uint32_t index = 0; index < srcCacheCount; index++) {
FinishReadObject(pSrcCaches[index]);
}
}
// Host access to dstCache must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateGraphicsPipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
StartReadObject(device);
StartReadObject(pipelineCache);
}
void ThreadSafety::PostCallRecordCreateGraphicsPipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines,
VkResult result) {
FinishReadObject(device);
FinishReadObject(pipelineCache);
}
void ThreadSafety::PreCallRecordCreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
StartReadObject(device);
StartReadObject(pipelineCache);
}
void ThreadSafety::PostCallRecordCreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines,
VkResult result) {
FinishReadObject(device);
FinishReadObject(pipelineCache);
}
void ThreadSafety::PreCallRecordDestroyPipeline(
VkDevice device,
VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(pipeline);
// Host access to pipeline must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyPipeline(
VkDevice device,
VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(pipeline);
// Host access to pipeline must be externally synchronized
}
void ThreadSafety::PreCallRecordCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(pipelineLayout);
// Host access to pipelineLayout must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(pipelineLayout);
// Host access to pipelineLayout must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroySampler(
VkDevice device,
VkSampler sampler,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(sampler);
// Host access to sampler must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroySampler(
VkDevice device,
VkSampler sampler,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(sampler);
// Host access to sampler must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(descriptorSetLayout);
// Host access to descriptorSetLayout must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(descriptorSetLayout);
// Host access to descriptorSetLayout must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(descriptorPool);
// Host access to descriptorPool must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(descriptorPool);
// Host access to descriptorPool must be externally synchronized
}
void ThreadSafety::PreCallRecordResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags) {
StartReadObject(device);
StartWriteObject(descriptorPool);
// Host access to descriptorPool must be externally synchronized
// any sname:VkDescriptorSet objects allocated from pname:descriptorPool must be externally synchronized between host accesses
}
void ThreadSafety::PostCallRecordResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(descriptorPool);
// Host access to descriptorPool must be externally synchronized
// any sname:VkDescriptorSet objects allocated from pname:descriptorPool must be externally synchronized between host accesses
}
void ThreadSafety::PreCallRecordFreeDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets) {
StartReadObject(device);
StartWriteObject(descriptorPool);
if (pDescriptorSets) {
for (uint32_t index=0; index < descriptorSetCount; index++) {
StartWriteObject(pDescriptorSets[index]);
}
}
// Host access to descriptorPool must be externally synchronized
// Host access to each member of pDescriptorSets must be externally synchronized
}
void ThreadSafety::PostCallRecordFreeDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(descriptorPool);
if (pDescriptorSets) {
for (uint32_t index=0; index < descriptorSetCount; index++) {
FinishWriteObject(pDescriptorSets[index]);
}
}
// Host access to descriptorPool must be externally synchronized
// Host access to each member of pDescriptorSets must be externally synchronized
}
void ThreadSafety::PreCallRecordUpdateDescriptorSets(
VkDevice device,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies) {
StartReadObject(device);
if (pDescriptorWrites) {
for (uint32_t index=0; index < descriptorWriteCount; index++) {
StartWriteObject(pDescriptorWrites[index].dstSet);
}
}
if (pDescriptorCopies) {
for (uint32_t index=0; index < descriptorCopyCount; index++) {
StartWriteObject(pDescriptorCopies[index].dstSet);
}
}
// Host access to pDescriptorWrites[].dstSet must be externally synchronized
// Host access to pDescriptorCopies[].dstSet must be externally synchronized
}
void ThreadSafety::PostCallRecordUpdateDescriptorSets(
VkDevice device,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies) {
FinishReadObject(device);
if (pDescriptorWrites) {
for (uint32_t index=0; index < descriptorWriteCount; index++) {
FinishWriteObject(pDescriptorWrites[index].dstSet);
}
}
if (pDescriptorCopies) {
for (uint32_t index=0; index < descriptorCopyCount; index++) {
FinishWriteObject(pDescriptorCopies[index].dstSet);
}
}
// Host access to pDescriptorWrites[].dstSet must be externally synchronized
// Host access to pDescriptorCopies[].dstSet must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(framebuffer);
// Host access to framebuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(framebuffer);
// Host access to framebuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(renderPass);
// Host access to renderPass must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(renderPass);
// Host access to renderPass must be externally synchronized
}
void ThreadSafety::PreCallRecordGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity) {
StartReadObject(device);
StartReadObject(renderPass);
}
void ThreadSafety::PostCallRecordGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity) {
FinishReadObject(device);
FinishReadObject(renderPass);
}
void ThreadSafety::PreCallRecordCreateCommandPool(
VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateCommandPool(
VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordBeginCommandBuffer(
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
// the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
}
void ThreadSafety::PostCallRecordBeginCommandBuffer(
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo,
VkResult result) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
// the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
}
void ThreadSafety::PreCallRecordEndCommandBuffer(
VkCommandBuffer commandBuffer) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
// the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
}
void ThreadSafety::PostCallRecordEndCommandBuffer(
VkCommandBuffer commandBuffer,
VkResult result) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
// the sname:VkCommandPool that pname:commandBuffer was allocated from must be externally synchronized between host accesses
}
void ThreadSafety::PreCallRecordResetCommandBuffer(
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordResetCommandBuffer(
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags,
VkResult result) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBindPipeline(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline) {
StartWriteObject(commandBuffer);
StartReadObject(pipeline);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBindPipeline(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline) {
FinishWriteObject(commandBuffer);
FinishReadObject(pipeline);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetViewport(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewport* pViewports) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetViewport(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewport* pViewports) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetScissor(
VkCommandBuffer commandBuffer,
uint32_t firstScissor,
uint32_t scissorCount,
const VkRect2D* pScissors) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetScissor(
VkCommandBuffer commandBuffer,
uint32_t firstScissor,
uint32_t scissorCount,
const VkRect2D* pScissors) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetLineWidth(
VkCommandBuffer commandBuffer,
float lineWidth) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetLineWidth(
VkCommandBuffer commandBuffer,
float lineWidth) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetDepthBias(
VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetDepthBias(
VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetBlendConstants(
VkCommandBuffer commandBuffer,
const float blendConstants[4]) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetBlendConstants(
VkCommandBuffer commandBuffer,
const float blendConstants[4]) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetDepthBounds(
VkCommandBuffer commandBuffer,
float minDepthBounds,
float maxDepthBounds) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetDepthBounds(
VkCommandBuffer commandBuffer,
float minDepthBounds,
float maxDepthBounds) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetStencilCompareMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t compareMask) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetStencilCompareMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t compareMask) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetStencilWriteMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t writeMask) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetStencilWriteMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t writeMask) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t reference) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t reference) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBindDescriptorSets(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets) {
StartWriteObject(commandBuffer);
StartReadObject(layout);
if (pDescriptorSets) {
for (uint32_t index = 0; index < descriptorSetCount; index++) {
StartReadObject(pDescriptorSets[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBindDescriptorSets(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets) {
FinishWriteObject(commandBuffer);
FinishReadObject(layout);
if (pDescriptorSets) {
for (uint32_t index = 0; index < descriptorSetCount; index++) {
FinishReadObject(pDescriptorSets[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBindIndexBuffer(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBindIndexBuffer(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBindVertexBuffers(
VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets) {
StartWriteObject(commandBuffer);
if (pBuffers) {
for (uint32_t index = 0; index < bindingCount; index++) {
StartReadObject(pBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBindVertexBuffers(
VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets) {
FinishWriteObject(commandBuffer);
if (pBuffers) {
for (uint32_t index = 0; index < bindingCount; index++) {
FinishReadObject(pBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDraw(
VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDraw(
VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawIndexed(
VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
int32_t vertexOffset,
uint32_t firstInstance) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndexed(
VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
int32_t vertexOffset,
uint32_t firstInstance) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawIndexedIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndexedIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDispatch(
VkCommandBuffer commandBuffer,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDispatch(
VkCommandBuffer commandBuffer,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDispatchIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDispatchIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdCopyBuffer(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions) {
StartWriteObject(commandBuffer);
StartReadObject(srcBuffer);
StartReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdCopyBuffer(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions) {
FinishWriteObject(commandBuffer);
FinishReadObject(srcBuffer);
FinishReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdCopyImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy* pRegions) {
StartWriteObject(commandBuffer);
StartReadObject(srcImage);
StartReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdCopyImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy* pRegions) {
FinishWriteObject(commandBuffer);
FinishReadObject(srcImage);
FinishReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBlitImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit* pRegions,
VkFilter filter) {
StartWriteObject(commandBuffer);
StartReadObject(srcImage);
StartReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBlitImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit* pRegions,
VkFilter filter) {
FinishWriteObject(commandBuffer);
FinishReadObject(srcImage);
FinishReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions) {
StartWriteObject(commandBuffer);
StartReadObject(srcBuffer);
StartReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions) {
FinishWriteObject(commandBuffer);
FinishReadObject(srcBuffer);
FinishReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions) {
StartWriteObject(commandBuffer);
StartReadObject(srcImage);
StartReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions) {
FinishWriteObject(commandBuffer);
FinishReadObject(srcImage);
FinishReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdUpdateBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void* pData) {
StartWriteObject(commandBuffer);
StartReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdUpdateBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void* pData) {
FinishWriteObject(commandBuffer);
FinishReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdFillBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data) {
StartWriteObject(commandBuffer);
StartReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdFillBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data) {
FinishWriteObject(commandBuffer);
FinishReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdClearColorImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges) {
StartWriteObject(commandBuffer);
StartReadObject(image);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdClearColorImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges) {
FinishWriteObject(commandBuffer);
FinishReadObject(image);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdClearDepthStencilImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges) {
StartWriteObject(commandBuffer);
StartReadObject(image);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdClearDepthStencilImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges) {
FinishWriteObject(commandBuffer);
FinishReadObject(image);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdClearAttachments(
VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdClearAttachments(
VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdResolveImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve* pRegions) {
StartWriteObject(commandBuffer);
StartReadObject(srcImage);
StartReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdResolveImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve* pRegions) {
FinishWriteObject(commandBuffer);
FinishReadObject(srcImage);
FinishReadObject(dstImage);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
StartWriteObject(commandBuffer);
StartReadObject(event);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
FinishWriteObject(commandBuffer);
FinishReadObject(event);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdResetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
StartWriteObject(commandBuffer);
StartReadObject(event);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdResetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
FinishWriteObject(commandBuffer);
FinishReadObject(event);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdWaitEvents(
VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
StartWriteObject(commandBuffer);
if (pEvents) {
for (uint32_t index = 0; index < eventCount; index++) {
StartReadObject(pEvents[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdWaitEvents(
VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
FinishWriteObject(commandBuffer);
if (pEvents) {
for (uint32_t index = 0; index < eventCount; index++) {
FinishReadObject(pEvents[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
VkQueryControlFlags flags) {
StartWriteObject(commandBuffer);
StartReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
VkQueryControlFlags flags) {
FinishWriteObject(commandBuffer);
FinishReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query) {
StartWriteObject(commandBuffer);
StartReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query) {
FinishWriteObject(commandBuffer);
FinishReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount) {
StartWriteObject(commandBuffer);
StartReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount) {
FinishWriteObject(commandBuffer);
FinishReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdWriteTimestamp(
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query) {
StartWriteObject(commandBuffer);
StartReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdWriteTimestamp(
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query) {
FinishWriteObject(commandBuffer);
FinishReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags) {
StartWriteObject(commandBuffer);
StartReadObject(queryPool);
StartReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags) {
FinishWriteObject(commandBuffer);
FinishReadObject(queryPool);
FinishReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdPushConstants(
VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
uint32_t size,
const void* pValues) {
StartWriteObject(commandBuffer);
StartReadObject(layout);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdPushConstants(
VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
uint32_t size,
const void* pValues) {
FinishWriteObject(commandBuffer);
FinishReadObject(layout);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdNextSubpass(
VkCommandBuffer commandBuffer,
VkSubpassContents contents) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdNextSubpass(
VkCommandBuffer commandBuffer,
VkSubpassContents contents) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdEndRenderPass(
VkCommandBuffer commandBuffer) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdEndRenderPass(
VkCommandBuffer commandBuffer) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdExecuteCommands(
VkCommandBuffer commandBuffer,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
StartWriteObject(commandBuffer);
if (pCommandBuffers) {
for (uint32_t index = 0; index < commandBufferCount; index++) {
StartReadObject(pCommandBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdExecuteCommands(
VkCommandBuffer commandBuffer,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
FinishWriteObject(commandBuffer);
if (pCommandBuffers) {
for (uint32_t index = 0; index < commandBufferCount; index++) {
FinishReadObject(pCommandBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordBindBufferMemory2(
VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordBindBufferMemory2(
VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordBindImageMemory2(
VkDevice device,
uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordBindImageMemory2(
VkDevice device,
uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetDeviceGroupPeerMemoryFeatures(
VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDeviceGroupPeerMemoryFeatures(
VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdSetDeviceMask(
VkCommandBuffer commandBuffer,
uint32_t deviceMask) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetDeviceMask(
VkCommandBuffer commandBuffer,
uint32_t deviceMask) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDispatchBase(
VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDispatchBase(
VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordEnumeratePhysicalDeviceGroups(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordEnumeratePhysicalDeviceGroups(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
VkResult result) {
FinishReadObject(instance);
}
void ThreadSafety::PreCallRecordGetImageMemoryRequirements2(
VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetImageMemoryRequirements2(
VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetBufferMemoryRequirements2(
VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetBufferMemoryRequirements2(
VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetImageSparseMemoryRequirements2(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetImageSparseMemoryRequirements2(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordTrimCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags) {
StartReadObject(device);
StartWriteObject(commandPool);
// Host access to commandPool must be externally synchronized
}
void ThreadSafety::PostCallRecordTrimCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags) {
FinishReadObject(device);
FinishWriteObject(commandPool);
// Host access to commandPool must be externally synchronized
}
void ThreadSafety::PreCallRecordGetDeviceQueue2(
VkDevice device,
const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDeviceQueue2(
VkDevice device,
const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCreateSamplerYcbcrConversion(
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateSamplerYcbcrConversion(
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroySamplerYcbcrConversion(
VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(ycbcrConversion);
// Host access to ycbcrConversion must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroySamplerYcbcrConversion(
VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(ycbcrConversion);
// Host access to ycbcrConversion must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateDescriptorUpdateTemplate(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateDescriptorUpdateTemplate(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyDescriptorUpdateTemplate(
VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(descriptorUpdateTemplate);
// Host access to descriptorUpdateTemplate must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyDescriptorUpdateTemplate(
VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(descriptorUpdateTemplate);
// Host access to descriptorUpdateTemplate must be externally synchronized
}
void ThreadSafety::PreCallRecordUpdateDescriptorSetWithTemplate(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData) {
StartReadObject(device);
StartWriteObject(descriptorSet);
StartReadObject(descriptorUpdateTemplate);
// Host access to descriptorSet must be externally synchronized
}
void ThreadSafety::PostCallRecordUpdateDescriptorSetWithTemplate(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData) {
FinishReadObject(device);
FinishWriteObject(descriptorSet);
FinishReadObject(descriptorUpdateTemplate);
// Host access to descriptorSet must be externally synchronized
}
void ThreadSafety::PreCallRecordGetDescriptorSetLayoutSupport(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDescriptorSetLayoutSupport(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroySurfaceKHR(
VkInstance instance,
VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(instance);
StartWriteObject(surface);
// Host access to surface must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroySurfaceKHR(
VkInstance instance,
VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(instance);
FinishWriteObject(surface);
// Host access to surface must be externally synchronized
}
void ThreadSafety::PreCallRecordGetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
VkBool32* pSupported) {
StartReadObject(surface);
}
void ThreadSafety::PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
VkBool32* pSupported,
VkResult result) {
FinishReadObject(surface);
}
void ThreadSafety::PreCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
StartReadObject(surface);
}
void ThreadSafety::PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities,
VkResult result) {
FinishReadObject(surface);
}
void ThreadSafety::PreCallRecordGetPhysicalDeviceSurfaceFormatsKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats) {
StartReadObject(surface);
}
void ThreadSafety::PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats,
VkResult result) {
FinishReadObject(surface);
}
void ThreadSafety::PreCallRecordGetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes) {
StartReadObject(surface);
}
void ThreadSafety::PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes,
VkResult result) {
FinishReadObject(surface);
}
void ThreadSafety::PreCallRecordCreateSwapchainKHR(
VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain) {
StartReadObject(device);
StartWriteObject(pCreateInfo->surface);
StartWriteObject(pCreateInfo->oldSwapchain);
// Host access to pCreateInfo.surface,pCreateInfo.oldSwapchain must be externally synchronized
}
void ThreadSafety::PostCallRecordCreateSwapchainKHR(
VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(pCreateInfo->surface);
FinishWriteObject(pCreateInfo->oldSwapchain);
// Host access to pCreateInfo.surface,pCreateInfo.oldSwapchain must be externally synchronized
}
void ThreadSafety::PreCallRecordDestroySwapchainKHR(
VkDevice device,
VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroySwapchainKHR(
VkDevice device,
VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
void ThreadSafety::PreCallRecordAcquireNextImageKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint64_t timeout,
VkSemaphore semaphore,
VkFence fence,
uint32_t* pImageIndex) {
StartReadObject(device);
StartWriteObject(swapchain);
StartWriteObject(semaphore);
StartWriteObject(fence);
// Host access to swapchain must be externally synchronized
// Host access to semaphore must be externally synchronized
// Host access to fence must be externally synchronized
}
void ThreadSafety::PostCallRecordAcquireNextImageKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint64_t timeout,
VkSemaphore semaphore,
VkFence fence,
uint32_t* pImageIndex,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(swapchain);
FinishWriteObject(semaphore);
FinishWriteObject(fence);
// Host access to swapchain must be externally synchronized
// Host access to semaphore must be externally synchronized
// Host access to fence must be externally synchronized
}
void ThreadSafety::PreCallRecordGetDeviceGroupPresentCapabilitiesKHR(
VkDevice device,
VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDeviceGroupPresentCapabilitiesKHR(
VkDevice device,
VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetDeviceGroupSurfacePresentModesKHR(
VkDevice device,
VkSurfaceKHR surface,
VkDeviceGroupPresentModeFlagsKHR* pModes) {
StartReadObject(device);
StartWriteObject(surface);
// Host access to surface must be externally synchronized
}
void ThreadSafety::PostCallRecordGetDeviceGroupSurfacePresentModesKHR(
VkDevice device,
VkSurfaceKHR surface,
VkDeviceGroupPresentModeFlagsKHR* pModes,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(surface);
// Host access to surface must be externally synchronized
}
void ThreadSafety::PreCallRecordGetPhysicalDevicePresentRectanglesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pRectCount,
VkRect2D* pRects) {
StartWriteObject(surface);
// Host access to surface must be externally synchronized
}
void ThreadSafety::PostCallRecordGetPhysicalDevicePresentRectanglesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pRectCount,
VkRect2D* pRects,
VkResult result) {
FinishWriteObject(surface);
// Host access to surface must be externally synchronized
}
void ThreadSafety::PreCallRecordAcquireNextImage2KHR(
VkDevice device,
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordAcquireNextImage2KHR(
VkDevice device,
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays) {
if (pDisplays) {
for (uint32_t index = 0; index < *pDisplayCount; index++) {
StartReadObject(pDisplays[index]);
}
}
}
void ThreadSafety::PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays,
VkResult result) {
if (pDisplays) {
for (uint32_t index = 0; index < *pDisplayCount; index++) {
FinishReadObject(pDisplays[index]);
}
}
}
void ThreadSafety::PreCallRecordGetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties) {
StartReadObject(display);
}
void ThreadSafety::PostCallRecordGetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties,
VkResult result) {
FinishReadObject(display);
}
void ThreadSafety::PreCallRecordCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDisplayModeKHR* pMode) {
StartWriteObject(display);
// Host access to display must be externally synchronized
}
void ThreadSafety::PostCallRecordCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDisplayModeKHR* pMode,
VkResult result) {
FinishWriteObject(display);
// Host access to display must be externally synchronized
}
void ThreadSafety::PreCallRecordGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
StartWriteObject(mode);
// Host access to mode must be externally synchronized
}
void ThreadSafety::PostCallRecordGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities,
VkResult result) {
FinishWriteObject(mode);
// Host access to mode must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateDisplayPlaneSurfaceKHR(
VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateDisplayPlaneSurfaceKHR(
VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
void ThreadSafety::PreCallRecordCreateSharedSwapchainsKHR(
VkDevice device,
uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchains) {
StartReadObject(device);
if (pCreateInfos) {
for (uint32_t index=0; index < swapchainCount; index++) {
StartWriteObject(pCreateInfos[index].surface);
StartWriteObject(pCreateInfos[index].oldSwapchain);
}
}
if (pSwapchains) {
for (uint32_t index = 0; index < swapchainCount; index++) {
StartReadObject(pSwapchains[index]);
}
}
// Host access to pCreateInfos[].surface,pCreateInfos[].oldSwapchain must be externally synchronized
}
void ThreadSafety::PostCallRecordCreateSharedSwapchainsKHR(
VkDevice device,
uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchains,
VkResult result) {
FinishReadObject(device);
if (pCreateInfos) {
for (uint32_t index=0; index < swapchainCount; index++) {
FinishWriteObject(pCreateInfos[index].surface);
FinishWriteObject(pCreateInfos[index].oldSwapchain);
}
}
if (pSwapchains) {
for (uint32_t index = 0; index < swapchainCount; index++) {
FinishReadObject(pSwapchains[index]);
}
}
// Host access to pCreateInfos[].surface,pCreateInfos[].oldSwapchain must be externally synchronized
}
#ifdef VK_USE_PLATFORM_XLIB_KHR
void ThreadSafety::PreCallRecordCreateXlibSurfaceKHR(
VkInstance instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateXlibSurfaceKHR(
VkInstance instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#ifdef VK_USE_PLATFORM_XCB_KHR
void ThreadSafety::PreCallRecordCreateXcbSurfaceKHR(
VkInstance instance,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateXcbSurfaceKHR(
VkInstance instance,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_XCB_KHR
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
void ThreadSafety::PreCallRecordCreateWaylandSurfaceKHR(
VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateWaylandSurfaceKHR(
VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR
void ThreadSafety::PreCallRecordCreateAndroidSurfaceKHR(
VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateAndroidSurfaceKHR(
VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordCreateWin32SurfaceKHR(
VkInstance instance,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateWin32SurfaceKHR(
VkInstance instance,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(
VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(
VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdSetDeviceMaskKHR(
VkCommandBuffer commandBuffer,
uint32_t deviceMask) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetDeviceMaskKHR(
VkCommandBuffer commandBuffer,
uint32_t deviceMask) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDispatchBaseKHR(
VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDispatchBaseKHR(
VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordTrimCommandPoolKHR(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags) {
StartReadObject(device);
StartWriteObject(commandPool);
// Host access to commandPool must be externally synchronized
}
void ThreadSafety::PostCallRecordTrimCommandPoolKHR(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags) {
FinishReadObject(device);
FinishWriteObject(commandPool);
// Host access to commandPool must be externally synchronized
}
void ThreadSafety::PreCallRecordEnumeratePhysicalDeviceGroupsKHR(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordEnumeratePhysicalDeviceGroupsKHR(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
VkResult result) {
FinishReadObject(instance);
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordGetMemoryWin32HandleKHR(
VkDevice device,
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetMemoryWin32HandleKHR(
VkDevice device,
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetMemoryWin32HandlePropertiesKHR(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
HANDLE handle,
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetMemoryWin32HandlePropertiesKHR(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
HANDLE handle,
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties,
VkResult result) {
FinishReadObject(device);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordGetMemoryFdKHR(
VkDevice device,
const VkMemoryGetFdInfoKHR* pGetFdInfo,
int* pFd) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetMemoryFdKHR(
VkDevice device,
const VkMemoryGetFdInfoKHR* pGetFdInfo,
int* pFd,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetMemoryFdPropertiesKHR(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
int fd,
VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetMemoryFdPropertiesKHR(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
int fd,
VkMemoryFdPropertiesKHR* pMemoryFdProperties,
VkResult result) {
FinishReadObject(device);
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordImportSemaphoreWin32HandleKHR(
VkDevice device,
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordImportSemaphoreWin32HandleKHR(
VkDevice device,
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetSemaphoreWin32HandleKHR(
VkDevice device,
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetSemaphoreWin32HandleKHR(
VkDevice device,
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle,
VkResult result) {
FinishReadObject(device);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordImportSemaphoreFdKHR(
VkDevice device,
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordImportSemaphoreFdKHR(
VkDevice device,
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetSemaphoreFdKHR(
VkDevice device,
const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
int* pFd) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetSemaphoreFdKHR(
VkDevice device,
const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
int* pFd,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdPushDescriptorSetKHR(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t set,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites) {
StartWriteObject(commandBuffer);
StartReadObject(layout);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdPushDescriptorSetKHR(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t set,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites) {
FinishWriteObject(commandBuffer);
FinishReadObject(layout);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdPushDescriptorSetWithTemplateKHR(
VkCommandBuffer commandBuffer,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
VkPipelineLayout layout,
uint32_t set,
const void* pData) {
StartWriteObject(commandBuffer);
StartReadObject(descriptorUpdateTemplate);
StartReadObject(layout);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdPushDescriptorSetWithTemplateKHR(
VkCommandBuffer commandBuffer,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
VkPipelineLayout layout,
uint32_t set,
const void* pData) {
FinishWriteObject(commandBuffer);
FinishReadObject(descriptorUpdateTemplate);
FinishReadObject(layout);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateDescriptorUpdateTemplateKHR(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateDescriptorUpdateTemplateKHR(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyDescriptorUpdateTemplateKHR(
VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(descriptorUpdateTemplate);
// Host access to descriptorUpdateTemplate must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyDescriptorUpdateTemplateKHR(
VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(descriptorUpdateTemplate);
// Host access to descriptorUpdateTemplate must be externally synchronized
}
void ThreadSafety::PreCallRecordUpdateDescriptorSetWithTemplateKHR(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData) {
StartReadObject(device);
StartWriteObject(descriptorSet);
StartReadObject(descriptorUpdateTemplate);
// Host access to descriptorSet must be externally synchronized
}
void ThreadSafety::PostCallRecordUpdateDescriptorSetWithTemplateKHR(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData) {
FinishReadObject(device);
FinishWriteObject(descriptorSet);
FinishReadObject(descriptorUpdateTemplate);
// Host access to descriptorSet must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateRenderPass2KHR(
VkDevice device,
const VkRenderPassCreateInfo2KHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateRenderPass2KHR(
VkDevice device,
const VkRenderPassCreateInfo2KHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdBeginRenderPass2KHR(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBeginRenderPass2KHR(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdNextSubpass2KHR(
VkCommandBuffer commandBuffer,
const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
const VkSubpassEndInfoKHR* pSubpassEndInfo) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdNextSubpass2KHR(
VkCommandBuffer commandBuffer,
const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
const VkSubpassEndInfoKHR* pSubpassEndInfo) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdEndRenderPass2KHR(
VkCommandBuffer commandBuffer,
const VkSubpassEndInfoKHR* pSubpassEndInfo) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdEndRenderPass2KHR(
VkCommandBuffer commandBuffer,
const VkSubpassEndInfoKHR* pSubpassEndInfo) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordGetSwapchainStatusKHR(
VkDevice device,
VkSwapchainKHR swapchain) {
StartReadObject(device);
StartWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
void ThreadSafety::PostCallRecordGetSwapchainStatusKHR(
VkDevice device,
VkSwapchainKHR swapchain,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordImportFenceWin32HandleKHR(
VkDevice device,
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordImportFenceWin32HandleKHR(
VkDevice device,
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetFenceWin32HandleKHR(
VkDevice device,
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetFenceWin32HandleKHR(
VkDevice device,
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle,
VkResult result) {
FinishReadObject(device);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordImportFenceFdKHR(
VkDevice device,
const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordImportFenceFdKHR(
VkDevice device,
const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetFenceFdKHR(
VkDevice device,
const VkFenceGetFdInfoKHR* pGetFdInfo,
int* pFd) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetFenceFdKHR(
VkDevice device,
const VkFenceGetFdInfoKHR* pGetFdInfo,
int* pFd,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetDisplayModeProperties2KHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModeProperties2KHR* pProperties) {
StartReadObject(display);
}
void ThreadSafety::PostCallRecordGetDisplayModeProperties2KHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModeProperties2KHR* pProperties,
VkResult result) {
FinishReadObject(display);
}
void ThreadSafety::PreCallRecordGetImageMemoryRequirements2KHR(
VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetImageMemoryRequirements2KHR(
VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetBufferMemoryRequirements2KHR(
VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetBufferMemoryRequirements2KHR(
VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetImageSparseMemoryRequirements2KHR(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetImageSparseMemoryRequirements2KHR(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCreateSamplerYcbcrConversionKHR(
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateSamplerYcbcrConversionKHR(
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroySamplerYcbcrConversionKHR(
VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(ycbcrConversion);
// Host access to ycbcrConversion must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroySamplerYcbcrConversionKHR(
VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(ycbcrConversion);
// Host access to ycbcrConversion must be externally synchronized
}
void ThreadSafety::PreCallRecordBindBufferMemory2KHR(
VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordBindBufferMemory2KHR(
VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordBindImageMemory2KHR(
VkDevice device,
uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordBindImageMemory2KHR(
VkDevice device,
uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetDescriptorSetLayoutSupportKHR(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDescriptorSetLayoutSupportKHR(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdDrawIndirectCountKHR(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
StartReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndirectCountKHR(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
FinishReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawIndexedIndirectCountKHR(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
StartReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndexedIndirectCountKHR(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
FinishReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordGetPipelineExecutablePropertiesKHR(
VkDevice device,
const VkPipelineInfoKHR* pPipelineInfo,
uint32_t* pExecutableCount,
VkPipelineExecutablePropertiesKHR* pProperties) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetPipelineExecutablePropertiesKHR(
VkDevice device,
const VkPipelineInfoKHR* pPipelineInfo,
uint32_t* pExecutableCount,
VkPipelineExecutablePropertiesKHR* pProperties,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetPipelineExecutableStatisticsKHR(
VkDevice device,
const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pStatisticCount,
VkPipelineExecutableStatisticKHR* pStatistics) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetPipelineExecutableStatisticsKHR(
VkDevice device,
const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pStatisticCount,
VkPipelineExecutableStatisticKHR* pStatistics,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetPipelineExecutableInternalRepresentationsKHR(
VkDevice device,
const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(
VkDevice device,
const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCreateDebugReportCallbackEXT(
VkInstance instance,
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDebugReportCallbackEXT* pCallback) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateDebugReportCallbackEXT(
VkInstance instance,
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDebugReportCallbackEXT* pCallback,
VkResult result) {
FinishReadObject(instance);
}
void ThreadSafety::PreCallRecordDestroyDebugReportCallbackEXT(
VkInstance instance,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(instance);
StartWriteObject(callback);
// Host access to callback must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyDebugReportCallbackEXT(
VkInstance instance,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(instance);
FinishWriteObject(callback);
// Host access to callback must be externally synchronized
}
void ThreadSafety::PreCallRecordDebugReportMessageEXT(
VkInstance instance,
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char* pLayerPrefix,
const char* pMessage) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordDebugReportMessageEXT(
VkInstance instance,
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char* pLayerPrefix,
const char* pMessage) {
FinishReadObject(instance);
}
// TODO - not wrapping EXT function vkDebugMarkerSetObjectTagEXT
// TODO - not wrapping EXT function vkDebugMarkerSetObjectNameEXT
// TODO - not wrapping EXT function vkCmdDebugMarkerBeginEXT
// TODO - not wrapping EXT function vkCmdDebugMarkerEndEXT
// TODO - not wrapping EXT function vkCmdDebugMarkerInsertEXT
void ThreadSafety::PreCallRecordCmdBindTransformFeedbackBuffersEXT(
VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets,
const VkDeviceSize* pSizes) {
StartWriteObject(commandBuffer);
if (pBuffers) {
for (uint32_t index = 0; index < bindingCount; index++) {
StartReadObject(pBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBindTransformFeedbackBuffersEXT(
VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets,
const VkDeviceSize* pSizes) {
FinishWriteObject(commandBuffer);
if (pBuffers) {
for (uint32_t index = 0; index < bindingCount; index++) {
FinishReadObject(pBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBeginTransformFeedbackEXT(
VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers,
const VkDeviceSize* pCounterBufferOffsets) {
StartWriteObject(commandBuffer);
if (pCounterBuffers) {
for (uint32_t index = 0; index < counterBufferCount; index++) {
StartReadObject(pCounterBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBeginTransformFeedbackEXT(
VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers,
const VkDeviceSize* pCounterBufferOffsets) {
FinishWriteObject(commandBuffer);
if (pCounterBuffers) {
for (uint32_t index = 0; index < counterBufferCount; index++) {
FinishReadObject(pCounterBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdEndTransformFeedbackEXT(
VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers,
const VkDeviceSize* pCounterBufferOffsets) {
StartWriteObject(commandBuffer);
if (pCounterBuffers) {
for (uint32_t index = 0; index < counterBufferCount; index++) {
StartReadObject(pCounterBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdEndTransformFeedbackEXT(
VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers,
const VkDeviceSize* pCounterBufferOffsets) {
FinishWriteObject(commandBuffer);
if (pCounterBuffers) {
for (uint32_t index = 0; index < counterBufferCount; index++) {
FinishReadObject(pCounterBuffers[index]);
}
}
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdBeginQueryIndexedEXT(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
VkQueryControlFlags flags,
uint32_t index) {
StartWriteObject(commandBuffer);
StartReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBeginQueryIndexedEXT(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
VkQueryControlFlags flags,
uint32_t index) {
FinishWriteObject(commandBuffer);
FinishReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdEndQueryIndexedEXT(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
uint32_t index) {
StartWriteObject(commandBuffer);
StartReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdEndQueryIndexedEXT(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query,
uint32_t index) {
FinishWriteObject(commandBuffer);
FinishReadObject(queryPool);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawIndirectByteCountEXT(
VkCommandBuffer commandBuffer,
uint32_t instanceCount,
uint32_t firstInstance,
VkBuffer counterBuffer,
VkDeviceSize counterBufferOffset,
uint32_t counterOffset,
uint32_t vertexStride) {
StartWriteObject(commandBuffer);
StartReadObject(counterBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndirectByteCountEXT(
VkCommandBuffer commandBuffer,
uint32_t instanceCount,
uint32_t firstInstance,
VkBuffer counterBuffer,
VkDeviceSize counterBufferOffset,
uint32_t counterOffset,
uint32_t vertexStride) {
FinishWriteObject(commandBuffer);
FinishReadObject(counterBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordGetImageViewHandleNVX(
VkDevice device,
const VkImageViewHandleInfoNVX* pInfo) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetImageViewHandleNVX(
VkDevice device,
const VkImageViewHandleInfoNVX* pInfo) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdDrawIndirectCountAMD(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
StartReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndirectCountAMD(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
FinishReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawIndexedIndirectCountAMD(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
StartReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawIndexedIndirectCountAMD(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
FinishReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordGetShaderInfoAMD(
VkDevice device,
VkPipeline pipeline,
VkShaderStageFlagBits shaderStage,
VkShaderInfoTypeAMD infoType,
size_t* pInfoSize,
void* pInfo) {
StartReadObject(device);
StartReadObject(pipeline);
}
void ThreadSafety::PostCallRecordGetShaderInfoAMD(
VkDevice device,
VkPipeline pipeline,
VkShaderStageFlagBits shaderStage,
VkShaderInfoTypeAMD infoType,
size_t* pInfoSize,
void* pInfo,
VkResult result) {
FinishReadObject(device);
FinishReadObject(pipeline);
}
#ifdef VK_USE_PLATFORM_GGP
void ThreadSafety::PreCallRecordCreateStreamDescriptorSurfaceGGP(
VkInstance instance,
const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateStreamDescriptorSurfaceGGP(
VkInstance instance,
const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_GGP
#ifdef VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordGetMemoryWin32HandleNV(
VkDevice device,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagsNV handleType,
HANDLE* pHandle) {
StartReadObject(device);
StartReadObject(memory);
}
void ThreadSafety::PostCallRecordGetMemoryWin32HandleNV(
VkDevice device,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagsNV handleType,
HANDLE* pHandle,
VkResult result) {
FinishReadObject(device);
FinishReadObject(memory);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_VI_NN
void ThreadSafety::PreCallRecordCreateViSurfaceNN(
VkInstance instance,
const VkViSurfaceCreateInfoNN* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateViSurfaceNN(
VkInstance instance,
const VkViSurfaceCreateInfoNN* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_VI_NN
void ThreadSafety::PreCallRecordCmdBeginConditionalRenderingEXT(
VkCommandBuffer commandBuffer,
const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBeginConditionalRenderingEXT(
VkCommandBuffer commandBuffer,
const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdEndConditionalRenderingEXT(
VkCommandBuffer commandBuffer) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdEndConditionalRenderingEXT(
VkCommandBuffer commandBuffer) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdProcessCommandsNVX(
VkCommandBuffer commandBuffer,
const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdProcessCommandsNVX(
VkCommandBuffer commandBuffer,
const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdReserveSpaceForCommandsNVX(
VkCommandBuffer commandBuffer,
const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdReserveSpaceForCommandsNVX(
VkCommandBuffer commandBuffer,
const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateIndirectCommandsLayoutNVX(
VkDevice device,
const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateIndirectCommandsLayoutNVX(
VkDevice device,
const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyIndirectCommandsLayoutNVX(
VkDevice device,
VkIndirectCommandsLayoutNVX indirectCommandsLayout,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartReadObject(indirectCommandsLayout);
}
void ThreadSafety::PostCallRecordDestroyIndirectCommandsLayoutNVX(
VkDevice device,
VkIndirectCommandsLayoutNVX indirectCommandsLayout,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishReadObject(indirectCommandsLayout);
}
void ThreadSafety::PreCallRecordCreateObjectTableNVX(
VkDevice device,
const VkObjectTableCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkObjectTableNVX* pObjectTable) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateObjectTableNVX(
VkDevice device,
const VkObjectTableCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkObjectTableNVX* pObjectTable,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyObjectTableNVX(
VkDevice device,
VkObjectTableNVX objectTable,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(objectTable);
// Host access to objectTable must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyObjectTableNVX(
VkDevice device,
VkObjectTableNVX objectTable,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(objectTable);
// Host access to objectTable must be externally synchronized
}
void ThreadSafety::PreCallRecordRegisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectTableEntryNVX* const* ppObjectTableEntries,
const uint32_t* pObjectIndices) {
StartReadObject(device);
StartWriteObject(objectTable);
// Host access to objectTable must be externally synchronized
}
void ThreadSafety::PostCallRecordRegisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectTableEntryNVX* const* ppObjectTableEntries,
const uint32_t* pObjectIndices,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(objectTable);
// Host access to objectTable must be externally synchronized
}
void ThreadSafety::PreCallRecordUnregisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectEntryTypeNVX* pObjectEntryTypes,
const uint32_t* pObjectIndices) {
StartReadObject(device);
StartWriteObject(objectTable);
// Host access to objectTable must be externally synchronized
}
void ThreadSafety::PostCallRecordUnregisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectEntryTypeNVX* pObjectEntryTypes,
const uint32_t* pObjectIndices,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(objectTable);
// Host access to objectTable must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetViewportWScalingNV(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewportWScalingNV* pViewportWScalings) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetViewportWScalingNV(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewportWScalingNV* pViewportWScalings) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordReleaseDisplayEXT(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display) {
StartReadObject(display);
}
void ThreadSafety::PostCallRecordReleaseDisplayEXT(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
VkResult result) {
FinishReadObject(display);
}
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
void ThreadSafety::PreCallRecordAcquireXlibDisplayEXT(
VkPhysicalDevice physicalDevice,
Display* dpy,
VkDisplayKHR display) {
StartReadObject(display);
}
void ThreadSafety::PostCallRecordAcquireXlibDisplayEXT(
VkPhysicalDevice physicalDevice,
Display* dpy,
VkDisplayKHR display,
VkResult result) {
FinishReadObject(display);
}
#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
void ThreadSafety::PreCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
StartReadObject(surface);
}
void ThreadSafety::PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilities2EXT* pSurfaceCapabilities,
VkResult result) {
FinishReadObject(surface);
}
void ThreadSafety::PreCallRecordDisplayPowerControlEXT(
VkDevice device,
VkDisplayKHR display,
const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
StartReadObject(device);
StartReadObject(display);
}
void ThreadSafety::PostCallRecordDisplayPowerControlEXT(
VkDevice device,
VkDisplayKHR display,
const VkDisplayPowerInfoEXT* pDisplayPowerInfo,
VkResult result) {
FinishReadObject(device);
FinishReadObject(display);
}
void ThreadSafety::PreCallRecordRegisterDeviceEventEXT(
VkDevice device,
const VkDeviceEventInfoEXT* pDeviceEventInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordRegisterDeviceEventEXT(
VkDevice device,
const VkDeviceEventInfoEXT* pDeviceEventInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordRegisterDisplayEventEXT(
VkDevice device,
VkDisplayKHR display,
const VkDisplayEventInfoEXT* pDisplayEventInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence) {
StartReadObject(device);
StartReadObject(display);
}
void ThreadSafety::PostCallRecordRegisterDisplayEventEXT(
VkDevice device,
VkDisplayKHR display,
const VkDisplayEventInfoEXT* pDisplayEventInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence,
VkResult result) {
FinishReadObject(device);
FinishReadObject(display);
}
void ThreadSafety::PreCallRecordGetSwapchainCounterEXT(
VkDevice device,
VkSwapchainKHR swapchain,
VkSurfaceCounterFlagBitsEXT counter,
uint64_t* pCounterValue) {
StartReadObject(device);
StartReadObject(swapchain);
}
void ThreadSafety::PostCallRecordGetSwapchainCounterEXT(
VkDevice device,
VkSwapchainKHR swapchain,
VkSurfaceCounterFlagBitsEXT counter,
uint64_t* pCounterValue,
VkResult result) {
FinishReadObject(device);
FinishReadObject(swapchain);
}
void ThreadSafety::PreCallRecordGetRefreshCycleDurationGOOGLE(
VkDevice device,
VkSwapchainKHR swapchain,
VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
StartReadObject(device);
StartWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
void ThreadSafety::PostCallRecordGetRefreshCycleDurationGOOGLE(
VkDevice device,
VkSwapchainKHR swapchain,
VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
void ThreadSafety::PreCallRecordGetPastPresentationTimingGOOGLE(
VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pPresentationTimingCount,
VkPastPresentationTimingGOOGLE* pPresentationTimings) {
StartReadObject(device);
StartWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
void ThreadSafety::PostCallRecordGetPastPresentationTimingGOOGLE(
VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pPresentationTimingCount,
VkPastPresentationTimingGOOGLE* pPresentationTimings,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(swapchain);
// Host access to swapchain must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetDiscardRectangleEXT(
VkCommandBuffer commandBuffer,
uint32_t firstDiscardRectangle,
uint32_t discardRectangleCount,
const VkRect2D* pDiscardRectangles) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetDiscardRectangleEXT(
VkCommandBuffer commandBuffer,
uint32_t firstDiscardRectangle,
uint32_t discardRectangleCount,
const VkRect2D* pDiscardRectangles) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordSetHdrMetadataEXT(
VkDevice device,
uint32_t swapchainCount,
const VkSwapchainKHR* pSwapchains,
const VkHdrMetadataEXT* pMetadata) {
StartReadObject(device);
if (pSwapchains) {
for (uint32_t index = 0; index < swapchainCount; index++) {
StartReadObject(pSwapchains[index]);
}
}
}
void ThreadSafety::PostCallRecordSetHdrMetadataEXT(
VkDevice device,
uint32_t swapchainCount,
const VkSwapchainKHR* pSwapchains,
const VkHdrMetadataEXT* pMetadata) {
FinishReadObject(device);
if (pSwapchains) {
for (uint32_t index = 0; index < swapchainCount; index++) {
FinishReadObject(pSwapchains[index]);
}
}
}
#ifdef VK_USE_PLATFORM_IOS_MVK
void ThreadSafety::PreCallRecordCreateIOSSurfaceMVK(
VkInstance instance,
const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateIOSSurfaceMVK(
VkInstance instance,
const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_IOS_MVK
#ifdef VK_USE_PLATFORM_MACOS_MVK
void ThreadSafety::PreCallRecordCreateMacOSSurfaceMVK(
VkInstance instance,
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateMacOSSurfaceMVK(
VkInstance instance,
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_MACOS_MVK
// TODO - not wrapping EXT function vkSetDebugUtilsObjectNameEXT
// TODO - not wrapping EXT function vkSetDebugUtilsObjectTagEXT
void ThreadSafety::PreCallRecordQueueBeginDebugUtilsLabelEXT(
VkQueue queue,
const VkDebugUtilsLabelEXT* pLabelInfo) {
StartReadObject(queue);
}
void ThreadSafety::PostCallRecordQueueBeginDebugUtilsLabelEXT(
VkQueue queue,
const VkDebugUtilsLabelEXT* pLabelInfo) {
FinishReadObject(queue);
}
void ThreadSafety::PreCallRecordQueueEndDebugUtilsLabelEXT(
VkQueue queue) {
StartReadObject(queue);
}
void ThreadSafety::PostCallRecordQueueEndDebugUtilsLabelEXT(
VkQueue queue) {
FinishReadObject(queue);
}
void ThreadSafety::PreCallRecordQueueInsertDebugUtilsLabelEXT(
VkQueue queue,
const VkDebugUtilsLabelEXT* pLabelInfo) {
StartReadObject(queue);
}
void ThreadSafety::PostCallRecordQueueInsertDebugUtilsLabelEXT(
VkQueue queue,
const VkDebugUtilsLabelEXT* pLabelInfo) {
FinishReadObject(queue);
}
void ThreadSafety::PreCallRecordCmdBeginDebugUtilsLabelEXT(
VkCommandBuffer commandBuffer,
const VkDebugUtilsLabelEXT* pLabelInfo) {
StartReadObject(commandBuffer);
}
void ThreadSafety::PostCallRecordCmdBeginDebugUtilsLabelEXT(
VkCommandBuffer commandBuffer,
const VkDebugUtilsLabelEXT* pLabelInfo) {
FinishReadObject(commandBuffer);
}
void ThreadSafety::PreCallRecordCmdEndDebugUtilsLabelEXT(
VkCommandBuffer commandBuffer) {
StartReadObject(commandBuffer);
}
void ThreadSafety::PostCallRecordCmdEndDebugUtilsLabelEXT(
VkCommandBuffer commandBuffer) {
FinishReadObject(commandBuffer);
}
void ThreadSafety::PreCallRecordCmdInsertDebugUtilsLabelEXT(
VkCommandBuffer commandBuffer,
const VkDebugUtilsLabelEXT* pLabelInfo) {
StartReadObject(commandBuffer);
}
void ThreadSafety::PostCallRecordCmdInsertDebugUtilsLabelEXT(
VkCommandBuffer commandBuffer,
const VkDebugUtilsLabelEXT* pLabelInfo) {
FinishReadObject(commandBuffer);
}
void ThreadSafety::PreCallRecordCreateDebugUtilsMessengerEXT(
VkInstance instance,
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDebugUtilsMessengerEXT* pMessenger) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateDebugUtilsMessengerEXT(
VkInstance instance,
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDebugUtilsMessengerEXT* pMessenger,
VkResult result) {
FinishReadObject(instance);
}
void ThreadSafety::PreCallRecordDestroyDebugUtilsMessengerEXT(
VkInstance instance,
VkDebugUtilsMessengerEXT messenger,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(instance);
StartWriteObject(messenger);
// Host access to messenger must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyDebugUtilsMessengerEXT(
VkInstance instance,
VkDebugUtilsMessengerEXT messenger,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(instance);
FinishWriteObject(messenger);
// Host access to messenger must be externally synchronized
}
void ThreadSafety::PreCallRecordSubmitDebugUtilsMessageEXT(
VkInstance instance,
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordSubmitDebugUtilsMessageEXT(
VkInstance instance,
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
FinishReadObject(instance);
}
#ifdef VK_USE_PLATFORM_ANDROID_KHR
void ThreadSafety::PreCallRecordGetAndroidHardwareBufferPropertiesANDROID(
VkDevice device,
const struct AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetAndroidHardwareBufferPropertiesANDROID(
VkDevice device,
const struct AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordGetMemoryAndroidHardwareBufferANDROID(
VkDevice device,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
struct AHardwareBuffer** pBuffer) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetMemoryAndroidHardwareBufferANDROID(
VkDevice device,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
struct AHardwareBuffer** pBuffer,
VkResult result) {
FinishReadObject(device);
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
void ThreadSafety::PreCallRecordCmdSetSampleLocationsEXT(
VkCommandBuffer commandBuffer,
const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetSampleLocationsEXT(
VkCommandBuffer commandBuffer,
const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordGetImageDrmFormatModifierPropertiesEXT(
VkDevice device,
VkImage image,
VkImageDrmFormatModifierPropertiesEXT* pProperties) {
StartReadObject(device);
StartReadObject(image);
}
void ThreadSafety::PostCallRecordGetImageDrmFormatModifierPropertiesEXT(
VkDevice device,
VkImage image,
VkImageDrmFormatModifierPropertiesEXT* pProperties,
VkResult result) {
FinishReadObject(device);
FinishReadObject(image);
}
void ThreadSafety::PreCallRecordCreateValidationCacheEXT(
VkDevice device,
const VkValidationCacheCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkValidationCacheEXT* pValidationCache) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateValidationCacheEXT(
VkDevice device,
const VkValidationCacheCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkValidationCacheEXT* pValidationCache,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyValidationCacheEXT(
VkDevice device,
VkValidationCacheEXT validationCache,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartWriteObject(validationCache);
// Host access to validationCache must be externally synchronized
}
void ThreadSafety::PostCallRecordDestroyValidationCacheEXT(
VkDevice device,
VkValidationCacheEXT validationCache,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishWriteObject(validationCache);
// Host access to validationCache must be externally synchronized
}
void ThreadSafety::PreCallRecordMergeValidationCachesEXT(
VkDevice device,
VkValidationCacheEXT dstCache,
uint32_t srcCacheCount,
const VkValidationCacheEXT* pSrcCaches) {
StartReadObject(device);
StartWriteObject(dstCache);
if (pSrcCaches) {
for (uint32_t index = 0; index < srcCacheCount; index++) {
StartReadObject(pSrcCaches[index]);
}
}
// Host access to dstCache must be externally synchronized
}
void ThreadSafety::PostCallRecordMergeValidationCachesEXT(
VkDevice device,
VkValidationCacheEXT dstCache,
uint32_t srcCacheCount,
const VkValidationCacheEXT* pSrcCaches,
VkResult result) {
FinishReadObject(device);
FinishWriteObject(dstCache);
if (pSrcCaches) {
for (uint32_t index = 0; index < srcCacheCount; index++) {
FinishReadObject(pSrcCaches[index]);
}
}
// Host access to dstCache must be externally synchronized
}
void ThreadSafety::PreCallRecordGetValidationCacheDataEXT(
VkDevice device,
VkValidationCacheEXT validationCache,
size_t* pDataSize,
void* pData) {
StartReadObject(device);
StartReadObject(validationCache);
}
void ThreadSafety::PostCallRecordGetValidationCacheDataEXT(
VkDevice device,
VkValidationCacheEXT validationCache,
size_t* pDataSize,
void* pData,
VkResult result) {
FinishReadObject(device);
FinishReadObject(validationCache);
}
void ThreadSafety::PreCallRecordCmdBindShadingRateImageNV(
VkCommandBuffer commandBuffer,
VkImageView imageView,
VkImageLayout imageLayout) {
StartWriteObject(commandBuffer);
StartReadObject(imageView);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdBindShadingRateImageNV(
VkCommandBuffer commandBuffer,
VkImageView imageView,
VkImageLayout imageLayout) {
FinishWriteObject(commandBuffer);
FinishReadObject(imageView);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetViewportShadingRatePaletteNV(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkShadingRatePaletteNV* pShadingRatePalettes) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetViewportShadingRatePaletteNV(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkShadingRatePaletteNV* pShadingRatePalettes) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetCoarseSampleOrderNV(
VkCommandBuffer commandBuffer,
VkCoarseSampleOrderTypeNV sampleOrderType,
uint32_t customSampleOrderCount,
const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetCoarseSampleOrderNV(
VkCommandBuffer commandBuffer,
VkCoarseSampleOrderTypeNV sampleOrderType,
uint32_t customSampleOrderCount,
const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCreateAccelerationStructureNV(
VkDevice device,
const VkAccelerationStructureCreateInfoNV* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkAccelerationStructureNV* pAccelerationStructure) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordCreateAccelerationStructureNV(
VkDevice device,
const VkAccelerationStructureCreateInfoNV* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkAccelerationStructureNV* pAccelerationStructure,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordDestroyAccelerationStructureNV(
VkDevice device,
VkAccelerationStructureNV accelerationStructure,
const VkAllocationCallbacks* pAllocator) {
StartReadObject(device);
StartReadObject(accelerationStructure);
}
void ThreadSafety::PostCallRecordDestroyAccelerationStructureNV(
VkDevice device,
VkAccelerationStructureNV accelerationStructure,
const VkAllocationCallbacks* pAllocator) {
FinishReadObject(device);
FinishReadObject(accelerationStructure);
}
void ThreadSafety::PreCallRecordGetAccelerationStructureMemoryRequirementsNV(
VkDevice device,
const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
VkMemoryRequirements2KHR* pMemoryRequirements) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetAccelerationStructureMemoryRequirementsNV(
VkDevice device,
const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
VkMemoryRequirements2KHR* pMemoryRequirements) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordBindAccelerationStructureMemoryNV(
VkDevice device,
uint32_t bindInfoCount,
const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordBindAccelerationStructureMemoryNV(
VkDevice device,
uint32_t bindInfoCount,
const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdBuildAccelerationStructureNV(
VkCommandBuffer commandBuffer,
const VkAccelerationStructureInfoNV* pInfo,
VkBuffer instanceData,
VkDeviceSize instanceOffset,
VkBool32 update,
VkAccelerationStructureNV dst,
VkAccelerationStructureNV src,
VkBuffer scratch,
VkDeviceSize scratchOffset) {
StartReadObject(commandBuffer);
StartReadObject(instanceData);
StartReadObject(dst);
StartReadObject(src);
StartReadObject(scratch);
}
void ThreadSafety::PostCallRecordCmdBuildAccelerationStructureNV(
VkCommandBuffer commandBuffer,
const VkAccelerationStructureInfoNV* pInfo,
VkBuffer instanceData,
VkDeviceSize instanceOffset,
VkBool32 update,
VkAccelerationStructureNV dst,
VkAccelerationStructureNV src,
VkBuffer scratch,
VkDeviceSize scratchOffset) {
FinishReadObject(commandBuffer);
FinishReadObject(instanceData);
FinishReadObject(dst);
FinishReadObject(src);
FinishReadObject(scratch);
}
void ThreadSafety::PreCallRecordCmdCopyAccelerationStructureNV(
VkCommandBuffer commandBuffer,
VkAccelerationStructureNV dst,
VkAccelerationStructureNV src,
VkCopyAccelerationStructureModeNV mode) {
StartReadObject(commandBuffer);
StartReadObject(dst);
StartReadObject(src);
}
void ThreadSafety::PostCallRecordCmdCopyAccelerationStructureNV(
VkCommandBuffer commandBuffer,
VkAccelerationStructureNV dst,
VkAccelerationStructureNV src,
VkCopyAccelerationStructureModeNV mode) {
FinishReadObject(commandBuffer);
FinishReadObject(dst);
FinishReadObject(src);
}
void ThreadSafety::PreCallRecordCmdTraceRaysNV(
VkCommandBuffer commandBuffer,
VkBuffer raygenShaderBindingTableBuffer,
VkDeviceSize raygenShaderBindingOffset,
VkBuffer missShaderBindingTableBuffer,
VkDeviceSize missShaderBindingOffset,
VkDeviceSize missShaderBindingStride,
VkBuffer hitShaderBindingTableBuffer,
VkDeviceSize hitShaderBindingOffset,
VkDeviceSize hitShaderBindingStride,
VkBuffer callableShaderBindingTableBuffer,
VkDeviceSize callableShaderBindingOffset,
VkDeviceSize callableShaderBindingStride,
uint32_t width,
uint32_t height,
uint32_t depth) {
StartReadObject(commandBuffer);
StartReadObject(raygenShaderBindingTableBuffer);
StartReadObject(missShaderBindingTableBuffer);
StartReadObject(hitShaderBindingTableBuffer);
StartReadObject(callableShaderBindingTableBuffer);
}
void ThreadSafety::PostCallRecordCmdTraceRaysNV(
VkCommandBuffer commandBuffer,
VkBuffer raygenShaderBindingTableBuffer,
VkDeviceSize raygenShaderBindingOffset,
VkBuffer missShaderBindingTableBuffer,
VkDeviceSize missShaderBindingOffset,
VkDeviceSize missShaderBindingStride,
VkBuffer hitShaderBindingTableBuffer,
VkDeviceSize hitShaderBindingOffset,
VkDeviceSize hitShaderBindingStride,
VkBuffer callableShaderBindingTableBuffer,
VkDeviceSize callableShaderBindingOffset,
VkDeviceSize callableShaderBindingStride,
uint32_t width,
uint32_t height,
uint32_t depth) {
FinishReadObject(commandBuffer);
FinishReadObject(raygenShaderBindingTableBuffer);
FinishReadObject(missShaderBindingTableBuffer);
FinishReadObject(hitShaderBindingTableBuffer);
FinishReadObject(callableShaderBindingTableBuffer);
}
void ThreadSafety::PreCallRecordCreateRayTracingPipelinesNV(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
StartReadObject(device);
StartReadObject(pipelineCache);
}
void ThreadSafety::PostCallRecordCreateRayTracingPipelinesNV(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines,
VkResult result) {
FinishReadObject(device);
FinishReadObject(pipelineCache);
}
void ThreadSafety::PreCallRecordGetRayTracingShaderGroupHandlesNV(
VkDevice device,
VkPipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
void* pData) {
StartReadObject(device);
StartReadObject(pipeline);
}
void ThreadSafety::PostCallRecordGetRayTracingShaderGroupHandlesNV(
VkDevice device,
VkPipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
void* pData,
VkResult result) {
FinishReadObject(device);
FinishReadObject(pipeline);
}
void ThreadSafety::PreCallRecordGetAccelerationStructureHandleNV(
VkDevice device,
VkAccelerationStructureNV accelerationStructure,
size_t dataSize,
void* pData) {
StartReadObject(device);
StartReadObject(accelerationStructure);
}
void ThreadSafety::PostCallRecordGetAccelerationStructureHandleNV(
VkDevice device,
VkAccelerationStructureNV accelerationStructure,
size_t dataSize,
void* pData,
VkResult result) {
FinishReadObject(device);
FinishReadObject(accelerationStructure);
}
void ThreadSafety::PreCallRecordCmdWriteAccelerationStructuresPropertiesNV(
VkCommandBuffer commandBuffer,
uint32_t accelerationStructureCount,
const VkAccelerationStructureNV* pAccelerationStructures,
VkQueryType queryType,
VkQueryPool queryPool,
uint32_t firstQuery) {
StartReadObject(commandBuffer);
if (pAccelerationStructures) {
for (uint32_t index = 0; index < accelerationStructureCount; index++) {
StartReadObject(pAccelerationStructures[index]);
}
}
StartReadObject(queryPool);
}
void ThreadSafety::PostCallRecordCmdWriteAccelerationStructuresPropertiesNV(
VkCommandBuffer commandBuffer,
uint32_t accelerationStructureCount,
const VkAccelerationStructureNV* pAccelerationStructures,
VkQueryType queryType,
VkQueryPool queryPool,
uint32_t firstQuery) {
FinishReadObject(commandBuffer);
if (pAccelerationStructures) {
for (uint32_t index = 0; index < accelerationStructureCount; index++) {
FinishReadObject(pAccelerationStructures[index]);
}
}
FinishReadObject(queryPool);
}
void ThreadSafety::PreCallRecordCompileDeferredNV(
VkDevice device,
VkPipeline pipeline,
uint32_t shader) {
StartReadObject(device);
StartReadObject(pipeline);
}
void ThreadSafety::PostCallRecordCompileDeferredNV(
VkDevice device,
VkPipeline pipeline,
uint32_t shader,
VkResult result) {
FinishReadObject(device);
FinishReadObject(pipeline);
}
void ThreadSafety::PreCallRecordGetMemoryHostPointerPropertiesEXT(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
const void* pHostPointer,
VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetMemoryHostPointerPropertiesEXT(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
const void* pHostPointer,
VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdWriteBufferMarkerAMD(
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
uint32_t marker) {
StartWriteObject(commandBuffer);
StartReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdWriteBufferMarkerAMD(
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
uint32_t marker) {
FinishWriteObject(commandBuffer);
FinishReadObject(dstBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordGetCalibratedTimestampsEXT(
VkDevice device,
uint32_t timestampCount,
const VkCalibratedTimestampInfoEXT* pTimestampInfos,
uint64_t* pTimestamps,
uint64_t* pMaxDeviation) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetCalibratedTimestampsEXT(
VkDevice device,
uint32_t timestampCount,
const VkCalibratedTimestampInfoEXT* pTimestampInfos,
uint64_t* pTimestamps,
uint64_t* pMaxDeviation,
VkResult result) {
FinishReadObject(device);
}
#ifdef VK_USE_PLATFORM_GGP
#endif // VK_USE_PLATFORM_GGP
void ThreadSafety::PreCallRecordCmdDrawMeshTasksNV(
VkCommandBuffer commandBuffer,
uint32_t taskCount,
uint32_t firstTask) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawMeshTasksNV(
VkCommandBuffer commandBuffer,
uint32_t taskCount,
uint32_t firstTask) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawMeshTasksIndirectNV(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawMeshTasksIndirectNV(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdDrawMeshTasksIndirectCountNV(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
StartWriteObject(commandBuffer);
StartReadObject(buffer);
StartReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdDrawMeshTasksIndirectCountNV(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride) {
FinishWriteObject(commandBuffer);
FinishReadObject(buffer);
FinishReadObject(countBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetExclusiveScissorNV(
VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VkRect2D* pExclusiveScissors) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetExclusiveScissorNV(
VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VkRect2D* pExclusiveScissors) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordCmdSetCheckpointNV(
VkCommandBuffer commandBuffer,
const void* pCheckpointMarker) {
StartReadObject(commandBuffer);
}
void ThreadSafety::PostCallRecordCmdSetCheckpointNV(
VkCommandBuffer commandBuffer,
const void* pCheckpointMarker) {
FinishReadObject(commandBuffer);
}
void ThreadSafety::PreCallRecordGetQueueCheckpointDataNV(
VkQueue queue,
uint32_t* pCheckpointDataCount,
VkCheckpointDataNV* pCheckpointData) {
StartReadObject(queue);
}
void ThreadSafety::PostCallRecordGetQueueCheckpointDataNV(
VkQueue queue,
uint32_t* pCheckpointDataCount,
VkCheckpointDataNV* pCheckpointData) {
FinishReadObject(queue);
}
void ThreadSafety::PreCallRecordInitializePerformanceApiINTEL(
VkDevice device,
const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordInitializePerformanceApiINTEL(
VkDevice device,
const VkInitializePerformanceApiInfoINTEL* pInitializeInfo,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordUninitializePerformanceApiINTEL(
VkDevice device) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordUninitializePerformanceApiINTEL(
VkDevice device) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordCmdSetPerformanceMarkerINTEL(
VkCommandBuffer commandBuffer,
const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
StartReadObject(commandBuffer);
}
void ThreadSafety::PostCallRecordCmdSetPerformanceMarkerINTEL(
VkCommandBuffer commandBuffer,
const VkPerformanceMarkerInfoINTEL* pMarkerInfo,
VkResult result) {
FinishReadObject(commandBuffer);
}
void ThreadSafety::PreCallRecordCmdSetPerformanceStreamMarkerINTEL(
VkCommandBuffer commandBuffer,
const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
StartReadObject(commandBuffer);
}
void ThreadSafety::PostCallRecordCmdSetPerformanceStreamMarkerINTEL(
VkCommandBuffer commandBuffer,
const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo,
VkResult result) {
FinishReadObject(commandBuffer);
}
void ThreadSafety::PreCallRecordCmdSetPerformanceOverrideINTEL(
VkCommandBuffer commandBuffer,
const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
StartReadObject(commandBuffer);
}
void ThreadSafety::PostCallRecordCmdSetPerformanceOverrideINTEL(
VkCommandBuffer commandBuffer,
const VkPerformanceOverrideInfoINTEL* pOverrideInfo,
VkResult result) {
FinishReadObject(commandBuffer);
}
void ThreadSafety::PreCallRecordAcquirePerformanceConfigurationINTEL(
VkDevice device,
const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
VkPerformanceConfigurationINTEL* pConfiguration) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordAcquirePerformanceConfigurationINTEL(
VkDevice device,
const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
VkPerformanceConfigurationINTEL* pConfiguration,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordReleasePerformanceConfigurationINTEL(
VkDevice device,
VkPerformanceConfigurationINTEL configuration) {
StartReadObject(device);
StartReadObject(configuration);
}
void ThreadSafety::PostCallRecordReleasePerformanceConfigurationINTEL(
VkDevice device,
VkPerformanceConfigurationINTEL configuration,
VkResult result) {
FinishReadObject(device);
FinishReadObject(configuration);
}
void ThreadSafety::PreCallRecordQueueSetPerformanceConfigurationINTEL(
VkQueue queue,
VkPerformanceConfigurationINTEL configuration) {
StartReadObject(queue);
StartReadObject(configuration);
}
void ThreadSafety::PostCallRecordQueueSetPerformanceConfigurationINTEL(
VkQueue queue,
VkPerformanceConfigurationINTEL configuration,
VkResult result) {
FinishReadObject(queue);
FinishReadObject(configuration);
}
void ThreadSafety::PreCallRecordGetPerformanceParameterINTEL(
VkDevice device,
VkPerformanceParameterTypeINTEL parameter,
VkPerformanceValueINTEL* pValue) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetPerformanceParameterINTEL(
VkDevice device,
VkPerformanceParameterTypeINTEL parameter,
VkPerformanceValueINTEL* pValue,
VkResult result) {
FinishReadObject(device);
}
void ThreadSafety::PreCallRecordSetLocalDimmingAMD(
VkDevice device,
VkSwapchainKHR swapChain,
VkBool32 localDimmingEnable) {
StartReadObject(device);
StartReadObject(swapChain);
}
void ThreadSafety::PostCallRecordSetLocalDimmingAMD(
VkDevice device,
VkSwapchainKHR swapChain,
VkBool32 localDimmingEnable) {
FinishReadObject(device);
FinishReadObject(swapChain);
}
#ifdef VK_USE_PLATFORM_FUCHSIA
void ThreadSafety::PreCallRecordCreateImagePipeSurfaceFUCHSIA(
VkInstance instance,
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateImagePipeSurfaceFUCHSIA(
VkInstance instance,
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_FUCHSIA
#ifdef VK_USE_PLATFORM_METAL_EXT
void ThreadSafety::PreCallRecordCreateMetalSurfaceEXT(
VkInstance instance,
const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateMetalSurfaceEXT(
VkInstance instance,
const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
#endif // VK_USE_PLATFORM_METAL_EXT
void ThreadSafety::PreCallRecordGetBufferDeviceAddressEXT(
VkDevice device,
const VkBufferDeviceAddressInfoEXT* pInfo) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetBufferDeviceAddressEXT(
VkDevice device,
const VkBufferDeviceAddressInfoEXT* pInfo) {
FinishReadObject(device);
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordAcquireFullScreenExclusiveModeEXT(
VkDevice device,
VkSwapchainKHR swapchain) {
StartReadObject(device);
StartReadObject(swapchain);
}
void ThreadSafety::PostCallRecordAcquireFullScreenExclusiveModeEXT(
VkDevice device,
VkSwapchainKHR swapchain,
VkResult result) {
FinishReadObject(device);
FinishReadObject(swapchain);
}
void ThreadSafety::PreCallRecordReleaseFullScreenExclusiveModeEXT(
VkDevice device,
VkSwapchainKHR swapchain) {
StartReadObject(device);
StartReadObject(swapchain);
}
void ThreadSafety::PostCallRecordReleaseFullScreenExclusiveModeEXT(
VkDevice device,
VkSwapchainKHR swapchain,
VkResult result) {
FinishReadObject(device);
FinishReadObject(swapchain);
}
void ThreadSafety::PreCallRecordGetDeviceGroupSurfacePresentModes2EXT(
VkDevice device,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
VkDeviceGroupPresentModeFlagsKHR* pModes) {
StartReadObject(device);
}
void ThreadSafety::PostCallRecordGetDeviceGroupSurfacePresentModes2EXT(
VkDevice device,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
VkDeviceGroupPresentModeFlagsKHR* pModes,
VkResult result) {
FinishReadObject(device);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void ThreadSafety::PreCallRecordCreateHeadlessSurfaceEXT(
VkInstance instance,
const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
StartReadObject(instance);
}
void ThreadSafety::PostCallRecordCreateHeadlessSurfaceEXT(
VkInstance instance,
const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface,
VkResult result) {
FinishReadObject(instance);
}
void ThreadSafety::PreCallRecordCmdSetLineStippleEXT(
VkCommandBuffer commandBuffer,
uint32_t lineStippleFactor,
uint16_t lineStipplePattern) {
StartWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PostCallRecordCmdSetLineStippleEXT(
VkCommandBuffer commandBuffer,
uint32_t lineStippleFactor,
uint16_t lineStipplePattern) {
FinishWriteObject(commandBuffer);
// Host access to commandBuffer must be externally synchronized
}
void ThreadSafety::PreCallRecordResetQueryPoolEXT(
VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount) {
StartReadObject(device);
StartReadObject(queryPool);
}
void ThreadSafety::PostCallRecordResetQueryPoolEXT(
VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount) {
FinishReadObject(device);
FinishReadObject(queryPool);
}
Reference in new issue View Git Blame Copy Permalink