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.
1019 lines
46 KiB
1019 lines
46 KiB
#!/usr/bin/python3 -i
|
|
#
|
|
# 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: Mike Stroyan <stroyan@google.com>
|
|
# Author: Mark Lobodzinski <mark@lunarg.com>
|
|
|
|
import os,re,sys
|
|
from generator import *
|
|
from common_codegen import *
|
|
|
|
# ThreadGeneratorOptions - subclass of GeneratorOptions.
|
|
#
|
|
# Adds options used by ThreadOutputGenerator objects during threading
|
|
# layer generation.
|
|
#
|
|
# Additional members
|
|
# prefixText - list of strings to prefix generated header with
|
|
# (usually a copyright statement + calling convention macros).
|
|
# protectFile - True if multiple inclusion protection should be
|
|
# generated (based on the filename) around the entire header.
|
|
# protectFeature - True if #ifndef..#endif protection should be
|
|
# generated around a feature interface in the header file.
|
|
# genFuncPointers - True if function pointer typedefs should be
|
|
# generated
|
|
# protectProto - If conditional protection should be generated
|
|
# around prototype declarations, set to either '#ifdef'
|
|
# to require opt-in (#ifdef protectProtoStr) or '#ifndef'
|
|
# to require opt-out (#ifndef protectProtoStr). Otherwise
|
|
# set to None.
|
|
# protectProtoStr - #ifdef/#ifndef symbol to use around prototype
|
|
# declarations, if protectProto is set
|
|
# apicall - string to use for the function declaration prefix,
|
|
# such as APICALL on Windows.
|
|
# apientry - string to use for the calling convention macro,
|
|
# in typedefs, such as APIENTRY.
|
|
# apientryp - string to use for the calling convention macro
|
|
# in function pointer typedefs, such as APIENTRYP.
|
|
# indentFuncProto - True if prototype declarations should put each
|
|
# parameter on a separate line
|
|
# indentFuncPointer - True if typedefed function pointers should put each
|
|
# parameter on a separate line
|
|
# alignFuncParam - if nonzero and parameters are being put on a
|
|
# separate line, align parameter names at the specified column
|
|
class ThreadGeneratorOptions(GeneratorOptions):
|
|
def __init__(self,
|
|
conventions = None,
|
|
filename = None,
|
|
directory = '.',
|
|
apiname = None,
|
|
profile = None,
|
|
versions = '.*',
|
|
emitversions = '.*',
|
|
defaultExtensions = None,
|
|
addExtensions = None,
|
|
removeExtensions = None,
|
|
emitExtensions = None,
|
|
sortProcedure = regSortFeatures,
|
|
prefixText = "",
|
|
genFuncPointers = True,
|
|
protectFile = True,
|
|
protectFeature = True,
|
|
apicall = '',
|
|
apientry = '',
|
|
apientryp = '',
|
|
indentFuncProto = True,
|
|
indentFuncPointer = False,
|
|
alignFuncParam = 0,
|
|
expandEnumerants = True):
|
|
GeneratorOptions.__init__(self, conventions, filename, directory, apiname, profile,
|
|
versions, emitversions, defaultExtensions,
|
|
addExtensions, removeExtensions, emitExtensions, sortProcedure)
|
|
self.prefixText = prefixText
|
|
self.genFuncPointers = genFuncPointers
|
|
self.protectFile = protectFile
|
|
self.protectFeature = protectFeature
|
|
self.apicall = apicall
|
|
self.apientry = apientry
|
|
self.apientryp = apientryp
|
|
self.indentFuncProto = indentFuncProto
|
|
self.indentFuncPointer = indentFuncPointer
|
|
self.alignFuncParam = alignFuncParam
|
|
self.expandEnumerants = expandEnumerants
|
|
|
|
|
|
# ThreadOutputGenerator - subclass of OutputGenerator.
|
|
# Generates Thread checking framework
|
|
#
|
|
# ---- methods ----
|
|
# ThreadOutputGenerator(errFile, warnFile, diagFile) - args as for
|
|
# OutputGenerator. Defines additional internal state.
|
|
# ---- methods overriding base class ----
|
|
# beginFile(genOpts)
|
|
# endFile()
|
|
# beginFeature(interface, emit)
|
|
# endFeature()
|
|
# genType(typeinfo,name)
|
|
# genStruct(typeinfo,name)
|
|
# genGroup(groupinfo,name)
|
|
# genEnum(enuminfo, name)
|
|
# genCmd(cmdinfo)
|
|
class ThreadOutputGenerator(OutputGenerator):
|
|
"""Generate specified API interfaces in a specific style, such as a C header"""
|
|
|
|
inline_copyright_message = """
|
|
// 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>
|
|
*/"""
|
|
|
|
# Note that the inline_custom_header_preamble template below contains three embedded template expansion identifiers.
|
|
# These get replaced with generated code sections, and are labeled:
|
|
# o COUNTER_CLASS_DEFINITIONS_TEMPLATE
|
|
# o COUNTER_CLASS_INSTANCES_TEMPLATE
|
|
# o COUNTER_CLASS_BODIES_TEMPLATE
|
|
inline_custom_header_preamble = """
|
|
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <mutex>
|
|
#include <vector>
|
|
#include <unordered_set>
|
|
#include <string>
|
|
|
|
VK_DEFINE_NON_DISPATCHABLE_HANDLE(DISTINCT_NONDISPATCHABLE_PHONY_HANDLE)
|
|
// The following line must match the vulkan_core.h condition guarding VK_DEFINE_NON_DISPATCHABLE_HANDLE
|
|
#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
|
|
defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
|
|
// If pointers are 64-bit, then there can be separate counters for each
|
|
// NONDISPATCHABLE_HANDLE type. Otherwise they are all typedef uint64_t.
|
|
#define DISTINCT_NONDISPATCHABLE_HANDLES
|
|
// Make sure we catch any disagreement between us and the vulkan definition
|
|
static_assert(std::is_pointer<DISTINCT_NONDISPATCHABLE_PHONY_HANDLE>::value,
|
|
"Mismatched non-dispatchable handle handle, expected pointer type.");
|
|
#else
|
|
// Make sure we catch any disagreement between us and the vulkan definition
|
|
static_assert(std::is_same<uint64_t, DISTINCT_NONDISPATCHABLE_PHONY_HANDLE>::value,
|
|
"Mismatched non-dispatchable handle handle, expected uint64_t.");
|
|
#endif
|
|
|
|
// Suppress unused warning on Linux
|
|
#if defined(__GNUC__)
|
|
#define DECORATE_UNUSED __attribute__((unused))
|
|
#else
|
|
#define DECORATE_UNUSED
|
|
#endif
|
|
|
|
// clang-format off
|
|
static const char DECORATE_UNUSED *kVUID_Threading_Info = "UNASSIGNED-Threading-Info";
|
|
static const char DECORATE_UNUSED *kVUID_Threading_MultipleThreads = "UNASSIGNED-Threading-MultipleThreads";
|
|
static const char DECORATE_UNUSED *kVUID_Threading_SingleThreadReuse = "UNASSIGNED-Threading-SingleThreadReuse";
|
|
// clang-format on
|
|
|
|
#undef DECORATE_UNUSED
|
|
|
|
struct object_use_data {
|
|
loader_platform_thread_id thread;
|
|
int reader_count;
|
|
int writer_count;
|
|
};
|
|
|
|
// This is a wrapper around unordered_map that optimizes for the common case
|
|
// of only containing a single element. The "first" element's use is stored
|
|
// inline in the class and doesn't require hashing or memory (de)allocation.
|
|
// TODO: Consider generalizing this from one element to N elements (where N
|
|
// is a template parameter).
|
|
template <typename Key, typename T>
|
|
class small_unordered_map {
|
|
|
|
bool first_data_allocated;
|
|
Key first_data_key;
|
|
T first_data;
|
|
|
|
std::unordered_map<Key, T> uses;
|
|
|
|
public:
|
|
small_unordered_map() : first_data_allocated(false) {}
|
|
|
|
bool contains(const Key& object) const {
|
|
if (first_data_allocated && object == first_data_key) {
|
|
return true;
|
|
// check size() first to avoid hashing object unnecessarily.
|
|
} else if (uses.size() == 0) {
|
|
return false;
|
|
} else {
|
|
return uses.find(object) != uses.end();
|
|
}
|
|
}
|
|
|
|
T& operator[](const Key& object) {
|
|
if (first_data_allocated && first_data_key == object) {
|
|
return first_data;
|
|
} else if (!first_data_allocated && uses.size() == 0) {
|
|
first_data_allocated = true;
|
|
first_data_key = object;
|
|
return first_data;
|
|
} else {
|
|
return uses[object];
|
|
}
|
|
}
|
|
|
|
typename std::unordered_map<Key, T>::size_type erase(const Key& object) {
|
|
if (first_data_allocated && first_data_key == object) {
|
|
first_data_allocated = false;
|
|
return 1;
|
|
} else {
|
|
return uses.erase(object);
|
|
}
|
|
}
|
|
};
|
|
|
|
#define THREAD_SAFETY_BUCKETS_LOG2 6
|
|
#define THREAD_SAFETY_BUCKETS (1 << THREAD_SAFETY_BUCKETS_LOG2)
|
|
|
|
template <typename T> inline uint32_t ThreadSafetyHashObject(T object)
|
|
{
|
|
uint64_t u64 = (uint64_t)(uintptr_t)object;
|
|
uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
|
|
hash ^= (hash >> THREAD_SAFETY_BUCKETS_LOG2) ^ (hash >> (2*THREAD_SAFETY_BUCKETS_LOG2));
|
|
hash &= (THREAD_SAFETY_BUCKETS-1);
|
|
return hash;
|
|
}
|
|
|
|
template <typename T>
|
|
class counter {
|
|
public:
|
|
const char *typeName;
|
|
VkDebugReportObjectTypeEXT objectType;
|
|
debug_report_data **report_data;
|
|
|
|
// Per-bucket locking, to reduce contention.
|
|
struct CounterBucket {
|
|
small_unordered_map<T, object_use_data> uses;
|
|
std::mutex counter_lock;
|
|
};
|
|
|
|
CounterBucket buckets[THREAD_SAFETY_BUCKETS];
|
|
CounterBucket &GetBucket(T object)
|
|
{
|
|
return buckets[ThreadSafetyHashObject(object)];
|
|
}
|
|
|
|
void StartWrite(T object) {
|
|
if (object == VK_NULL_HANDLE) {
|
|
return;
|
|
}
|
|
auto &bucket = GetBucket(object);
|
|
bool skip = false;
|
|
loader_platform_thread_id tid = loader_platform_get_thread_id();
|
|
std::unique_lock<std::mutex> lock(bucket.counter_lock);
|
|
if (!bucket.uses.contains(object)) {
|
|
// There is no current use of the object. Record writer thread.
|
|
struct object_use_data *use_data = &bucket.uses[object];
|
|
use_data->reader_count = 0;
|
|
use_data->writer_count = 1;
|
|
use_data->thread = tid;
|
|
} else {
|
|
struct object_use_data *use_data = &bucket.uses[object];
|
|
if (use_data->reader_count == 0) {
|
|
// There are no readers. Two writers just collided.
|
|
if (use_data->thread != tid) {
|
|
skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
|
|
kVUID_Threading_MultipleThreads,
|
|
"THREADING ERROR : object of type %s is simultaneously used in "
|
|
"thread 0x%" PRIx64 " and thread 0x%" PRIx64,
|
|
typeName, (uint64_t)use_data->thread, (uint64_t)tid);
|
|
if (skip) {
|
|
WaitForObjectIdle(bucket, object, lock);
|
|
// There is now no current use of the object. Record writer thread.
|
|
struct object_use_data *new_use_data = &bucket.uses[object];
|
|
new_use_data->thread = tid;
|
|
new_use_data->reader_count = 0;
|
|
new_use_data->writer_count = 1;
|
|
} else {
|
|
// Continue with an unsafe use of the object.
|
|
use_data->thread = tid;
|
|
use_data->writer_count += 1;
|
|
}
|
|
} else {
|
|
// This is either safe multiple use in one call, or recursive use.
|
|
// There is no way to make recursion safe. Just forge ahead.
|
|
use_data->writer_count += 1;
|
|
}
|
|
} else {
|
|
// There are readers. This writer collided with them.
|
|
if (use_data->thread != tid) {
|
|
skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
|
|
kVUID_Threading_MultipleThreads,
|
|
"THREADING ERROR : object of type %s is simultaneously used in "
|
|
"thread 0x%" PRIx64 " and thread 0x%" PRIx64,
|
|
typeName, (uint64_t)use_data->thread, (uint64_t)tid);
|
|
if (skip) {
|
|
WaitForObjectIdle(bucket, object, lock);
|
|
// There is now no current use of the object. Record writer thread.
|
|
struct object_use_data *new_use_data = &bucket.uses[object];
|
|
new_use_data->thread = tid;
|
|
new_use_data->reader_count = 0;
|
|
new_use_data->writer_count = 1;
|
|
} else {
|
|
// Continue with an unsafe use of the object.
|
|
use_data->thread = tid;
|
|
use_data->writer_count += 1;
|
|
}
|
|
} else {
|
|
// This is either safe multiple use in one call, or recursive use.
|
|
// There is no way to make recursion safe. Just forge ahead.
|
|
use_data->writer_count += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FinishWrite(T object) {
|
|
if (object == VK_NULL_HANDLE) {
|
|
return;
|
|
}
|
|
auto &bucket = GetBucket(object);
|
|
// Object is no longer in use
|
|
std::unique_lock<std::mutex> lock(bucket.counter_lock);
|
|
struct object_use_data *use_data = &bucket.uses[object];
|
|
use_data->writer_count -= 1;
|
|
if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
|
|
bucket.uses.erase(object);
|
|
}
|
|
}
|
|
|
|
void StartRead(T object) {
|
|
if (object == VK_NULL_HANDLE) {
|
|
return;
|
|
}
|
|
auto &bucket = GetBucket(object);
|
|
bool skip = false;
|
|
loader_platform_thread_id tid = loader_platform_get_thread_id();
|
|
std::unique_lock<std::mutex> lock(bucket.counter_lock);
|
|
if (!bucket.uses.contains(object)) {
|
|
// There is no current use of the object. Record reader count
|
|
struct object_use_data *use_data = &bucket.uses[object];
|
|
use_data->reader_count = 1;
|
|
use_data->writer_count = 0;
|
|
use_data->thread = tid;
|
|
} else if (bucket.uses[object].writer_count > 0 && bucket.uses[object].thread != tid) {
|
|
// There is a writer of the object.
|
|
skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
|
|
kVUID_Threading_MultipleThreads,
|
|
"THREADING ERROR : object of type %s is simultaneously used in "
|
|
"thread 0x%" PRIx64 " and thread 0x%" PRIx64,
|
|
typeName, (uint64_t)bucket.uses[object].thread, (uint64_t)tid);
|
|
if (skip) {
|
|
WaitForObjectIdle(bucket, object, lock);
|
|
// There is no current use of the object. Record reader count
|
|
struct object_use_data *use_data = &bucket.uses[object];
|
|
use_data->reader_count = 1;
|
|
use_data->writer_count = 0;
|
|
use_data->thread = tid;
|
|
} else {
|
|
bucket.uses[object].reader_count += 1;
|
|
}
|
|
} else {
|
|
// There are other readers of the object. Increase reader count
|
|
bucket.uses[object].reader_count += 1;
|
|
}
|
|
}
|
|
void FinishRead(T object) {
|
|
if (object == VK_NULL_HANDLE) {
|
|
return;
|
|
}
|
|
auto &bucket = GetBucket(object);
|
|
std::unique_lock<std::mutex> lock(bucket.counter_lock);
|
|
struct object_use_data *use_data = &bucket.uses[object];
|
|
use_data->reader_count -= 1;
|
|
if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
|
|
bucket.uses.erase(object);
|
|
}
|
|
}
|
|
counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, debug_report_data **rep_data = nullptr) {
|
|
typeName = name;
|
|
objectType = type;
|
|
report_data = rep_data;
|
|
}
|
|
|
|
private:
|
|
void WaitForObjectIdle(CounterBucket &bucket, T object, std::unique_lock<std::mutex> &lock) {
|
|
// Wait for thread-safe access to object instead of skipping call.
|
|
// Don't use condition_variable to wait because it should be extremely
|
|
// rare to have collisions, but signaling would be very frequent.
|
|
while (bucket.uses.contains(object)) {
|
|
lock.unlock();
|
|
std::this_thread::sleep_for(std::chrono::microseconds(1));
|
|
lock.lock();
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
class ThreadSafety : public ValidationObject {
|
|
public:
|
|
|
|
// Override chassis read/write locks for this validation object
|
|
// This override takes a deferred lock. i.e. it is not acquired.
|
|
std::unique_lock<std::mutex> write_lock() {
|
|
return std::unique_lock<std::mutex>(validation_object_mutex, std::defer_lock);
|
|
}
|
|
|
|
// Per-bucket locking, to reduce contention.
|
|
struct CommandBufferBucket {
|
|
std::mutex command_pool_lock;
|
|
small_unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;
|
|
};
|
|
|
|
CommandBufferBucket buckets[THREAD_SAFETY_BUCKETS];
|
|
CommandBufferBucket &GetBucket(VkCommandBuffer object)
|
|
{
|
|
return buckets[ThreadSafetyHashObject(object)];
|
|
}
|
|
|
|
counter<VkCommandBuffer> c_VkCommandBuffer;
|
|
counter<VkDevice> c_VkDevice;
|
|
counter<VkInstance> c_VkInstance;
|
|
counter<VkQueue> c_VkQueue;
|
|
#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
|
|
|
|
// Special entry to allow tracking of command pool Reset and Destroy
|
|
counter<VkCommandPool> c_VkCommandPoolContents;
|
|
COUNTER_CLASS_DEFINITIONS_TEMPLATE
|
|
|
|
#else // DISTINCT_NONDISPATCHABLE_HANDLES
|
|
// Special entry to allow tracking of command pool Reset and Destroy
|
|
counter<uint64_t> c_VkCommandPoolContents;
|
|
|
|
counter<uint64_t> c_uint64_t;
|
|
#endif // DISTINCT_NONDISPATCHABLE_HANDLES
|
|
|
|
ThreadSafety()
|
|
: c_VkCommandBuffer("VkCommandBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, &report_data),
|
|
c_VkDevice("VkDevice", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, &report_data),
|
|
c_VkInstance("VkInstance", VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, &report_data),
|
|
c_VkQueue("VkQueue", VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, &report_data),
|
|
c_VkCommandPoolContents("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, &report_data),
|
|
|
|
#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
|
|
COUNTER_CLASS_INSTANCES_TEMPLATE
|
|
|
|
|
|
#else // DISTINCT_NONDISPATCHABLE_HANDLES
|
|
c_uint64_t("NON_DISPATCHABLE_HANDLE", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data)
|
|
#endif // DISTINCT_NONDISPATCHABLE_HANDLES
|
|
{};
|
|
|
|
#define WRAPPER(type) \
|
|
void StartWriteObject(type object) { \
|
|
c_##type.StartWrite(object); \
|
|
} \
|
|
void FinishWriteObject(type object) { \
|
|
c_##type.FinishWrite(object); \
|
|
} \
|
|
void StartReadObject(type object) { \
|
|
c_##type.StartRead(object); \
|
|
} \
|
|
void FinishReadObject(type object) { \
|
|
c_##type.FinishRead(object); \
|
|
}
|
|
|
|
WRAPPER(VkDevice)
|
|
WRAPPER(VkInstance)
|
|
WRAPPER(VkQueue)
|
|
#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
|
|
COUNTER_CLASS_BODIES_TEMPLATE
|
|
|
|
#else // DISTINCT_NONDISPATCHABLE_HANDLES
|
|
WRAPPER(uint64_t)
|
|
#endif // DISTINCT_NONDISPATCHABLE_HANDLES
|
|
|
|
// VkCommandBuffer needs check for implicit use of command pool
|
|
void StartWriteObject(VkCommandBuffer object, bool lockPool = true) {
|
|
if (lockPool) {
|
|
auto &bucket = GetBucket(object);
|
|
std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
|
|
VkCommandPool pool = bucket.command_pool_map[object];
|
|
lock.unlock();
|
|
StartWriteObject(pool);
|
|
}
|
|
c_VkCommandBuffer.StartWrite(object);
|
|
}
|
|
void FinishWriteObject(VkCommandBuffer object, bool lockPool = true) {
|
|
c_VkCommandBuffer.FinishWrite(object);
|
|
if (lockPool) {
|
|
auto &bucket = GetBucket(object);
|
|
std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
|
|
VkCommandPool pool = bucket.command_pool_map[object];
|
|
lock.unlock();
|
|
FinishWriteObject(pool);
|
|
}
|
|
}
|
|
void StartReadObject(VkCommandBuffer object) {
|
|
auto &bucket = GetBucket(object);
|
|
std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
|
|
VkCommandPool pool = bucket.command_pool_map[object];
|
|
lock.unlock();
|
|
// We set up a read guard against the "Contents" counter to catch conflict vs. vkResetCommandPool and vkDestroyCommandPool
|
|
// while *not* establishing a read guard against the command pool counter itself to avoid false postives for
|
|
// non-externally sync'd command buffers
|
|
c_VkCommandPoolContents.StartRead(pool);
|
|
c_VkCommandBuffer.StartRead(object);
|
|
}
|
|
void FinishReadObject(VkCommandBuffer object) {
|
|
auto &bucket = GetBucket(object);
|
|
c_VkCommandBuffer.FinishRead(object);
|
|
std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
|
|
VkCommandPool pool = bucket.command_pool_map[object];
|
|
lock.unlock();
|
|
c_VkCommandPoolContents.FinishRead(pool);
|
|
} """
|
|
|
|
|
|
inline_custom_source_preamble = """
|
|
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);
|
|
}
|
|
|
|
"""
|
|
|
|
|
|
# This is an ordered list of sections in the header file.
|
|
ALL_SECTIONS = ['command']
|
|
def __init__(self,
|
|
errFile = sys.stderr,
|
|
warnFile = sys.stderr,
|
|
diagFile = sys.stdout):
|
|
OutputGenerator.__init__(self, errFile, warnFile, diagFile)
|
|
# Internal state - accumulators for different inner block text
|
|
self.sections = dict([(section, []) for section in self.ALL_SECTIONS])
|
|
self.non_dispatchable_types = set()
|
|
self.object_to_debug_report_type = {
|
|
'VkInstance' : 'VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT',
|
|
'VkPhysicalDevice' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT',
|
|
'VkDevice' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT',
|
|
'VkQueue' : 'VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT',
|
|
'VkSemaphore' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT',
|
|
'VkCommandBuffer' : 'VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT',
|
|
'VkFence' : 'VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT',
|
|
'VkDeviceMemory' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT',
|
|
'VkBuffer' : 'VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT',
|
|
'VkImage' : 'VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT',
|
|
'VkEvent' : 'VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT',
|
|
'VkQueryPool' : 'VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT',
|
|
'VkBufferView' : 'VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT',
|
|
'VkImageView' : 'VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT',
|
|
'VkShaderModule' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT',
|
|
'VkPipelineCache' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT',
|
|
'VkPipelineLayout' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT',
|
|
'VkRenderPass' : 'VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT',
|
|
'VkPipeline' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT',
|
|
'VkDescriptorSetLayout' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT',
|
|
'VkSampler' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT',
|
|
'VkDescriptorPool' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT',
|
|
'VkDescriptorSet' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT',
|
|
'VkFramebuffer' : 'VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT',
|
|
'VkCommandPool' : 'VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT',
|
|
'VkSurfaceKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT',
|
|
'VkSwapchainKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT',
|
|
'VkDisplayKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT',
|
|
'VkDisplayModeKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT',
|
|
'VkObjectTableNVX' : 'VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT',
|
|
'VkIndirectCommandsLayoutNVX' : 'VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT',
|
|
'VkSamplerYcbcrConversion' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT',
|
|
'VkDescriptorUpdateTemplate' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT',
|
|
'VkAccelerationStructureNV' : 'VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT',
|
|
'VkDebugReportCallbackEXT' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT',
|
|
'VkValidationCacheEXT' : 'VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT' }
|
|
|
|
# Check if the parameter passed in is a pointer to an array
|
|
def paramIsArray(self, param):
|
|
return param.attrib.get('len') is not None
|
|
|
|
# Check if the parameter passed in is a pointer
|
|
def paramIsPointer(self, param):
|
|
ispointer = False
|
|
for elem in param:
|
|
if elem.tag == 'type' and elem.tail is not None and '*' in elem.tail:
|
|
ispointer = True
|
|
return ispointer
|
|
|
|
def makeThreadUseBlock(self, cmd, functionprefix):
|
|
"""Generate C function pointer typedef for <command> Element"""
|
|
paramdecl = ''
|
|
# Find and add any parameters that are thread unsafe
|
|
params = cmd.findall('param')
|
|
for param in params:
|
|
paramname = param.find('name')
|
|
if False: # self.paramIsPointer(param):
|
|
paramdecl += ' // not watching use of pointer ' + paramname.text + '\n'
|
|
else:
|
|
externsync = param.attrib.get('externsync')
|
|
if externsync == 'true':
|
|
if self.paramIsArray(param):
|
|
paramdecl += 'if (' + paramname.text + ') {\n'
|
|
paramdecl += ' for (uint32_t index=0; index < ' + param.attrib.get('len') + '; index++) {\n'
|
|
paramdecl += ' ' + functionprefix + 'WriteObject(' + paramname.text + '[index]);\n'
|
|
paramdecl += ' }\n'
|
|
paramdecl += '}\n'
|
|
else:
|
|
paramdecl += functionprefix + 'WriteObject(' + paramname.text + ');\n'
|
|
elif (param.attrib.get('externsync')):
|
|
if self.paramIsArray(param):
|
|
# Externsync can list pointers to arrays of members to synchronize
|
|
paramdecl += 'if (' + paramname.text + ') {\n'
|
|
paramdecl += ' for (uint32_t index=0; index < ' + param.attrib.get('len') + '; index++) {\n'
|
|
second_indent = ' '
|
|
for member in externsync.split(","):
|
|
# Replace first empty [] in member name with index
|
|
element = member.replace('[]','[index]',1)
|
|
if '[]' in element:
|
|
# TODO: These null checks can be removed if threading ends up behind parameter
|
|
# validation in layer order
|
|
element_ptr = element.split('[]')[0]
|
|
paramdecl += ' if (' + element_ptr + ') {\n'
|
|
# Replace any second empty [] in element name with inner array index based on mapping array
|
|
# names like "pSomeThings[]" to "someThingCount" array size. This could be more robust by
|
|
# mapping a param member name to a struct type and "len" attribute.
|
|
limit = element[0:element.find('s[]')] + 'Count'
|
|
dotp = limit.rfind('.p')
|
|
limit = limit[0:dotp+1] + limit[dotp+2:dotp+3].lower() + limit[dotp+3:]
|
|
paramdecl += ' for (uint32_t index2=0; index2 < '+limit+'; index2++) {\n'
|
|
element = element.replace('[]','[index2]')
|
|
second_indent = ' '
|
|
paramdecl += ' ' + second_indent + functionprefix + 'WriteObject(' + element + ');\n'
|
|
paramdecl += ' }\n'
|
|
paramdecl += ' }\n'
|
|
else:
|
|
paramdecl += ' ' + second_indent + functionprefix + 'WriteObject(' + element + ');\n'
|
|
paramdecl += ' }\n'
|
|
paramdecl += '}\n'
|
|
else:
|
|
# externsync can list members to synchronize
|
|
for member in externsync.split(","):
|
|
member = str(member).replace("::", "->")
|
|
member = str(member).replace(".", "->")
|
|
paramdecl += ' ' + functionprefix + 'WriteObject(' + member + ');\n'
|
|
else:
|
|
paramtype = param.find('type')
|
|
if paramtype is not None:
|
|
paramtype = paramtype.text
|
|
else:
|
|
paramtype = 'None'
|
|
if paramtype in self.handle_types and paramtype != 'VkPhysicalDevice':
|
|
if self.paramIsArray(param) and ('pPipelines' != paramname.text):
|
|
# Add pointer dereference for array counts that are pointer values
|
|
dereference = ''
|
|
for candidate in params:
|
|
if param.attrib.get('len') == candidate.find('name').text:
|
|
if self.paramIsPointer(candidate):
|
|
dereference = '*'
|
|
param_len = str(param.attrib.get('len')).replace("::", "->")
|
|
paramdecl += 'if (' + paramname.text + ') {\n'
|
|
paramdecl += ' for (uint32_t index = 0; index < ' + dereference + param_len + '; index++) {\n'
|
|
paramdecl += ' ' + functionprefix + 'ReadObject(' + paramname.text + '[index]);\n'
|
|
paramdecl += ' }\n'
|
|
paramdecl += '}\n'
|
|
elif not self.paramIsPointer(param):
|
|
# Pointer params are often being created.
|
|
# They are not being read from.
|
|
paramdecl += functionprefix + 'ReadObject(' + paramname.text + ');\n'
|
|
explicitexternsyncparams = cmd.findall("param[@externsync]")
|
|
if (explicitexternsyncparams is not None):
|
|
for param in explicitexternsyncparams:
|
|
externsyncattrib = param.attrib.get('externsync')
|
|
paramname = param.find('name')
|
|
paramdecl += '// Host access to '
|
|
if externsyncattrib == 'true':
|
|
if self.paramIsArray(param):
|
|
paramdecl += 'each member of ' + paramname.text
|
|
elif self.paramIsPointer(param):
|
|
paramdecl += 'the object referenced by ' + paramname.text
|
|
else:
|
|
paramdecl += paramname.text
|
|
else:
|
|
paramdecl += externsyncattrib
|
|
paramdecl += ' must be externally synchronized\n'
|
|
|
|
# Find and add any "implicit" parameters that are thread unsafe
|
|
implicitexternsyncparams = cmd.find('implicitexternsyncparams')
|
|
if (implicitexternsyncparams is not None):
|
|
for elem in implicitexternsyncparams:
|
|
paramdecl += '// '
|
|
paramdecl += elem.text
|
|
paramdecl += ' must be externally synchronized between host accesses\n'
|
|
|
|
if (paramdecl == ''):
|
|
return None
|
|
else:
|
|
return paramdecl
|
|
def beginFile(self, genOpts):
|
|
OutputGenerator.beginFile(self, genOpts)
|
|
|
|
# Initialize members that require the tree
|
|
self.handle_types = GetHandleTypes(self.registry.tree)
|
|
|
|
# TODO: LUGMAL -- remove this and add our copyright
|
|
# User-supplied prefix text, if any (list of strings)
|
|
write(self.inline_copyright_message, file=self.outFile)
|
|
|
|
self.header_file = (genOpts.filename == 'thread_safety.h')
|
|
self.source_file = (genOpts.filename == 'thread_safety.cpp')
|
|
|
|
if not self.header_file and not self.source_file:
|
|
print("Error: Output Filenames have changed, update generator source.\n")
|
|
sys.exit(1)
|
|
|
|
if self.source_file:
|
|
write('#include "chassis.h"', file=self.outFile)
|
|
write('#include "thread_safety.h"', file=self.outFile)
|
|
self.newline()
|
|
write(self.inline_custom_source_preamble, file=self.outFile)
|
|
|
|
|
|
def endFile(self):
|
|
|
|
# Create class definitions
|
|
counter_class_defs = ''
|
|
counter_class_instances = ''
|
|
counter_class_bodies = ''
|
|
|
|
for obj in sorted(self.non_dispatchable_types):
|
|
counter_class_defs += ' counter<%s> c_%s;\n' % (obj, obj)
|
|
if obj in self.object_to_debug_report_type:
|
|
obj_type = self.object_to_debug_report_type[obj]
|
|
else:
|
|
obj_type = 'VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT'
|
|
counter_class_instances += ' c_%s("%s", %s, &report_data),\n' % (obj, obj, obj_type)
|
|
counter_class_bodies += 'WRAPPER(%s)\n' % obj
|
|
if self.header_file:
|
|
class_def = self.inline_custom_header_preamble.replace('COUNTER_CLASS_DEFINITIONS_TEMPLATE', counter_class_defs)
|
|
class_def = class_def.replace('COUNTER_CLASS_INSTANCES_TEMPLATE', counter_class_instances[:-2]) # Kill last comma
|
|
class_def = class_def.replace('COUNTER_CLASS_BODIES_TEMPLATE', counter_class_bodies)
|
|
write(class_def, file=self.outFile)
|
|
write('\n'.join(self.sections['command']), file=self.outFile)
|
|
if self.header_file:
|
|
write('};', file=self.outFile)
|
|
|
|
# Finish processing in superclass
|
|
OutputGenerator.endFile(self)
|
|
|
|
def beginFeature(self, interface, emit):
|
|
#write('// starting beginFeature', file=self.outFile)
|
|
# Start processing in superclass
|
|
OutputGenerator.beginFeature(self, interface, emit)
|
|
# C-specific
|
|
# Accumulate includes, defines, types, enums, function pointer typedefs,
|
|
# end function prototypes separately for this feature. They're only
|
|
# printed in endFeature().
|
|
self.featureExtraProtect = GetFeatureProtect(interface)
|
|
if (self.featureExtraProtect is not None):
|
|
self.appendSection('command', '\n#ifdef %s' % self.featureExtraProtect)
|
|
|
|
#write('// ending beginFeature', file=self.outFile)
|
|
def endFeature(self):
|
|
# C-specific
|
|
if (self.emit):
|
|
if (self.featureExtraProtect is not None):
|
|
self.appendSection('command', '#endif // %s' % self.featureExtraProtect)
|
|
# Finish processing in superclass
|
|
OutputGenerator.endFeature(self)
|
|
#
|
|
# Append a definition to the specified section
|
|
def appendSection(self, section, text):
|
|
self.sections[section].append(text)
|
|
#
|
|
# Type generation
|
|
def genType(self, typeinfo, name, alias):
|
|
OutputGenerator.genType(self, typeinfo, name, alias)
|
|
if self.handle_types.IsNonDispatchable(name):
|
|
self.non_dispatchable_types.add(name)
|
|
#
|
|
# Struct (e.g. C "struct" type) generation.
|
|
# This is a special case of the <type> tag where the contents are
|
|
# interpreted as a set of <member> tags instead of freeform C
|
|
# C type declarations. The <member> tags are just like <param>
|
|
# tags - they are a declaration of a struct or union member.
|
|
# Only simple member declarations are supported (no nested
|
|
# structs etc.)
|
|
def genStruct(self, typeinfo, typeName, alias):
|
|
OutputGenerator.genStruct(self, typeinfo, typeName, alias)
|
|
body = 'typedef ' + typeinfo.elem.get('category') + ' ' + typeName + ' {\n'
|
|
# paramdecl = self.makeCParamDecl(typeinfo.elem, self.genOpts.alignFuncParam)
|
|
for member in typeinfo.elem.findall('.//member'):
|
|
body += self.makeCParamDecl(member, self.genOpts.alignFuncParam)
|
|
body += ';\n'
|
|
body += '} ' + typeName + ';\n'
|
|
self.appendSection('struct', body)
|
|
#
|
|
# Group (e.g. C "enum" type) generation.
|
|
# These are concatenated together with other types.
|
|
def genGroup(self, groupinfo, groupName, alias):
|
|
pass
|
|
# Enumerant generation
|
|
# <enum> tags may specify their values in several ways, but are usually
|
|
# just integers.
|
|
def genEnum(self, enuminfo, name, alias):
|
|
pass
|
|
#
|
|
# Command generation
|
|
def genCmd(self, cmdinfo, name, alias):
|
|
# Commands shadowed by interface functions and are not implemented
|
|
special_functions = [
|
|
'vkCreateDevice',
|
|
'vkCreateInstance',
|
|
'vkAllocateCommandBuffers',
|
|
'vkFreeCommandBuffers',
|
|
'vkResetCommandPool',
|
|
'vkDestroyCommandPool',
|
|
'vkAllocateDescriptorSets',
|
|
'vkQueuePresentKHR',
|
|
'vkGetSwapchainImagesKHR',
|
|
]
|
|
if name == 'vkQueuePresentKHR' or (name in special_functions and self.source_file):
|
|
return
|
|
|
|
if (("DebugMarker" in name or "DebugUtilsObject" in name) and "EXT" in name):
|
|
self.appendSection('command', '// TODO - not wrapping EXT function ' + name)
|
|
return
|
|
|
|
# Determine first if this function needs to be intercepted
|
|
startthreadsafety = self.makeThreadUseBlock(cmdinfo.elem, 'Start')
|
|
if startthreadsafety is None:
|
|
return
|
|
finishthreadsafety = self.makeThreadUseBlock(cmdinfo.elem, 'Finish')
|
|
|
|
OutputGenerator.genCmd(self, cmdinfo, name, alias)
|
|
|
|
# setup common to call wrappers
|
|
# first parameter is always dispatchable
|
|
dispatchable_type = cmdinfo.elem.find('param/type').text
|
|
dispatchable_name = cmdinfo.elem.find('param/name').text
|
|
|
|
decls = self.makeCDecls(cmdinfo.elem)
|
|
|
|
result_type = cmdinfo.elem.find('proto/type')
|
|
|
|
if self.source_file:
|
|
pre_decl = decls[0][:-1]
|
|
pre_decl = pre_decl.split("VKAPI_CALL ")[1]
|
|
pre_decl = 'void ThreadSafety::PreCallRecord' + pre_decl + ' {'
|
|
|
|
# PreCallRecord
|
|
self.appendSection('command', '')
|
|
self.appendSection('command', pre_decl)
|
|
self.appendSection('command', " " + "\n ".join(str(startthreadsafety).rstrip().split("\n")))
|
|
self.appendSection('command', '}')
|
|
|
|
# PostCallRecord
|
|
post_decl = pre_decl.replace('PreCallRecord', 'PostCallRecord')
|
|
if result_type.text == 'VkResult':
|
|
post_decl = post_decl.replace(')', ',\n VkResult result)')
|
|
self.appendSection('command', '')
|
|
self.appendSection('command', post_decl)
|
|
self.appendSection('command', " " + "\n ".join(str(finishthreadsafety).rstrip().split("\n")))
|
|
self.appendSection('command', '}')
|
|
|
|
if self.header_file:
|
|
pre_decl = decls[0][:-1]
|
|
pre_decl = pre_decl.split("VKAPI_CALL ")[1]
|
|
pre_decl = 'void PreCallRecord' + pre_decl + ';'
|
|
|
|
# PreCallRecord
|
|
self.appendSection('command', '')
|
|
self.appendSection('command', pre_decl)
|
|
|
|
# PostCallRecord
|
|
post_decl = pre_decl.replace('PreCallRecord', 'PostCallRecord')
|
|
if result_type.text == 'VkResult':
|
|
post_decl = post_decl.replace(')', ',\n VkResult result)')
|
|
self.appendSection('command', '')
|
|
self.appendSection('command', post_decl)
|
|
|
|
#
|
|
# override makeProtoName to drop the "vk" prefix
|
|
def makeProtoName(self, name, tail):
|
|
return self.genOpts.apientry + name[2:] + tail
|