Skip to content

Commit

Permalink
build: Update to header 1.3.266
Browse files Browse the repository at this point in the history 
- Update known-good
- Generate source
  • Loading branch information
@mikes-lunarg
mikes-lunarg committed Sep 29, 2023
1 parent 47c40a4 commit cdde97c
Show file tree
Hide file tree
Showing 30 changed files with 2,317 additions and 285 deletions.
2 changes: 1 addition & 1 deletion layers/VkLayer_khronos_validation.json.in
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@
"name": "VK_LAYER_KHRONOS_validation",
"type": "GLOBAL",
"library_path": "@JSON_LIBRARY_PATH@",
"api_version": "1.3.265",
"api_version": "1.3.266",
"implementation_version": "1",
"description": "Khronos Validation Layer",
"introduction": "The main, comprehensive Khronos validation layer.\n\nVulkan is an Explicit API, enabling direct control over how GPUs actually work. By design, minimal error checking is done inside a Vulkan driver. Applications have full control and responsibility for correct operation. Any errors in how Vulkan is used can result in a crash. \n\nThe Khronos Valiation Layer can be enabled to assist development by enabling developers to verify their applications correctly use the Vulkan API.",
Expand Down
18 changes: 18 additions & 0 deletions layers/vulkan/generated/best_practices.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2865,6 +2865,24 @@ void BestPractices::PostCallRecordGetFramebufferTilePropertiesQCOM(VkDevice devi
}
}

void BestPractices::PostCallRecordSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain,
VkLatencySleepModeInfoNV* pSleepModeInfo, const RecordObject& record_obj) {
ValidationStateTracker::PostCallRecordSetLatencySleepModeNV(device, swapchain, pSleepModeInfo, record_obj);

if (record_obj.result < VK_SUCCESS) {
LogErrorCode(record_obj);
}
}

void BestPractices::PostCallRecordLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo,
const RecordObject& record_obj) {
ValidationStateTracker::PostCallRecordLatencySleepNV(device, swapchain, pSleepInfo, record_obj);

if (record_obj.result < VK_SUCCESS) {
LogErrorCode(record_obj);
}
}

#ifdef VK_USE_PLATFORM_SCREEN_QNX
void BestPractices::PostCallRecordGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer,
VkScreenBufferPropertiesQNX* pProperties,
Expand Down
7 changes: 7 additions & 0 deletions layers/vulkan/generated/best_practices.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -994,6 +994,12 @@ void PostCallRecordGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, s
void PostCallRecordGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount,
VkTilePropertiesQCOM* pProperties, const RecordObject& record_obj) override;

void PostCallRecordSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepModeInfoNV* pSleepModeInfo,
const RecordObject& record_obj) override;

void PostCallRecordLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo,
const RecordObject& record_obj) override;

#ifdef VK_USE_PLATFORM_SCREEN_QNX
void PostCallRecordGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer,
VkScreenBufferPropertiesQNX* pProperties, const RecordObject& record_obj) override;
Expand Down Expand Up @@ -1163,6 +1169,7 @@ const vvl::unordered_map<std::string, std::string> special_use_extensions = {
{"VK_EXT_non_seamless_cube_map", "d3demulation, glemulation"},
{"VK_GOOGLE_surfaceless_query", "glemulation"},
{"VK_EXT_legacy_dithering", "glemulation"},
{"VK_ANDROID_external_format_resolve", "glemulation"},
{"VK_EXT_mutable_descriptor_type", "d3demulation"},
};

Expand Down
115 changes: 115 additions & 0 deletions layers/vulkan/generated/chassis.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15561,6 +15561,116 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM(VkDevice de
return result;
}

VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain,
VkLatencySleepModeInfoNV* pSleepModeInfo) {
auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
ErrorObject error_obj(vvl::Func::vkSetLatencySleepModeNV, VulkanTypedHandle(device, kVulkanObjectTypeDevice));
for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateSetLatencySleepModeNV]) {
auto lock = intercept->ReadLock();
skip |= intercept->PreCallValidateSetLatencySleepModeNV(device, swapchain, pSleepModeInfo, error_obj);
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
}
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordSetLatencySleepModeNV]) {
auto lock = intercept->WriteLock();
intercept->PreCallRecordSetLatencySleepModeNV(device, swapchain, pSleepModeInfo);
}
VkResult result = DispatchSetLatencySleepModeNV(device, swapchain, pSleepModeInfo);
RecordObject record_obj(vvl::Func::vkSetLatencySleepModeNV, result);
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordSetLatencySleepModeNV]) {
auto lock = intercept->WriteLock();
intercept->PostCallRecordSetLatencySleepModeNV(device, swapchain, pSleepModeInfo, record_obj);
}
return result;
}

VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo) {
auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
ErrorObject error_obj(vvl::Func::vkLatencySleepNV, VulkanTypedHandle(device, kVulkanObjectTypeDevice));
for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateLatencySleepNV]) {
auto lock = intercept->ReadLock();
skip |= intercept->PreCallValidateLatencySleepNV(device, swapchain, pSleepInfo, error_obj);
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
}
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordLatencySleepNV]) {
auto lock = intercept->WriteLock();
intercept->PreCallRecordLatencySleepNV(device, swapchain, pSleepInfo);
}
VkResult result = DispatchLatencySleepNV(device, swapchain, pSleepInfo);
RecordObject record_obj(vvl::Func::vkLatencySleepNV, result);
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordLatencySleepNV]) {
auto lock = intercept->WriteLock();
intercept->PostCallRecordLatencySleepNV(device, swapchain, pSleepInfo, record_obj);
}
return result;
}

VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain,
VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
ErrorObject error_obj(vvl::Func::vkSetLatencyMarkerNV, VulkanTypedHandle(device, kVulkanObjectTypeDevice));
for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateSetLatencyMarkerNV]) {
auto lock = intercept->ReadLock();
skip |= intercept->PreCallValidateSetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo, error_obj);
if (skip) return;
}
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordSetLatencyMarkerNV]) {
auto lock = intercept->WriteLock();
intercept->PreCallRecordSetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo);
}
DispatchSetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo);
RecordObject record_obj(vvl::Func::vkSetLatencyMarkerNV);
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordSetLatencyMarkerNV]) {
auto lock = intercept->WriteLock();
intercept->PostCallRecordSetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo, record_obj);
}
}

VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount,
VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
ErrorObject error_obj(vvl::Func::vkGetLatencyTimingsNV, VulkanTypedHandle(device, kVulkanObjectTypeDevice));
for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateGetLatencyTimingsNV]) {
auto lock = intercept->ReadLock();
skip |= intercept->PreCallValidateGetLatencyTimingsNV(device, swapchain, pTimingCount, pLatencyMarkerInfo, error_obj);
if (skip) return;
}
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordGetLatencyTimingsNV]) {
auto lock = intercept->WriteLock();
intercept->PreCallRecordGetLatencyTimingsNV(device, swapchain, pTimingCount, pLatencyMarkerInfo);
}
DispatchGetLatencyTimingsNV(device, swapchain, pTimingCount, pLatencyMarkerInfo);
RecordObject record_obj(vvl::Func::vkGetLatencyTimingsNV);
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordGetLatencyTimingsNV]) {
auto lock = intercept->WriteLock();
intercept->PostCallRecordGetLatencyTimingsNV(device, swapchain, pTimingCount, pLatencyMarkerInfo, record_obj);
}
}

VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV(VkQueue queue, VkOutOfBandQueueTypeInfoNV pQueueTypeInfo) {
auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
bool skip = false;
ErrorObject error_obj(vvl::Func::vkQueueNotifyOutOfBandNV, VulkanTypedHandle(queue, kVulkanObjectTypeQueue));
for (const ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallValidateQueueNotifyOutOfBandNV]) {
auto lock = intercept->ReadLock();
skip |= intercept->PreCallValidateQueueNotifyOutOfBandNV(queue, pQueueTypeInfo, error_obj);
if (skip) return;
}
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPreCallRecordQueueNotifyOutOfBandNV]) {
auto lock = intercept->WriteLock();
intercept->PreCallRecordQueueNotifyOutOfBandNV(queue, pQueueTypeInfo);
}
DispatchQueueNotifyOutOfBandNV(queue, pQueueTypeInfo);
RecordObject record_obj(vvl::Func::vkQueueNotifyOutOfBandNV);
for (ValidationObject* intercept : layer_data->intercept_vectors[InterceptIdPostCallRecordQueueNotifyOutOfBandNV]) {
auto lock = intercept->WriteLock();
intercept->PostCallRecordQueueNotifyOutOfBandNV(queue, pQueueTypeInfo, record_obj);
}
}

VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) {
auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
bool skip = false;
Expand Down Expand Up @@ -17022,6 +17132,11 @@ const vvl::unordered_map<std::string, function_data> name_to_funcptr_map = {
{"vkCmdBindShadersEXT", {kFuncTypeDev, (void*)CmdBindShadersEXT}},
{"vkGetFramebufferTilePropertiesQCOM", {kFuncTypeDev, (void*)GetFramebufferTilePropertiesQCOM}},
{"vkGetDynamicRenderingTilePropertiesQCOM", {kFuncTypeDev, (void*)GetDynamicRenderingTilePropertiesQCOM}},
{"vkSetLatencySleepModeNV", {kFuncTypeDev, (void*)SetLatencySleepModeNV}},
{"vkLatencySleepNV", {kFuncTypeDev, (void*)LatencySleepNV}},
{"vkSetLatencyMarkerNV", {kFuncTypeDev, (void*)SetLatencyMarkerNV}},
{"vkGetLatencyTimingsNV", {kFuncTypeDev, (void*)GetLatencyTimingsNV}},
{"vkQueueNotifyOutOfBandNV", {kFuncTypeDev, (void*)QueueNotifyOutOfBandNV}},
{"vkCmdSetAttachmentFeedbackLoopEnableEXT", {kFuncTypeDev, (void*)CmdSetAttachmentFeedbackLoopEnableEXT}},
#ifdef VK_USE_PLATFORM_SCREEN_QNX
{"vkGetScreenBufferPropertiesQNX", {kFuncTypeDev, (void*)GetScreenBufferPropertiesQNX}},
Expand Down
28 changes: 28 additions & 0 deletions layers/vulkan/generated/chassis.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2038,6 +2038,19 @@ VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM(VkDevice device,
VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo,
VkTilePropertiesQCOM* pProperties);

VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain,
VkLatencySleepModeInfoNV* pSleepModeInfo);

VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo);

VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain,
VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo);

VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount,
VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo);

VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV(VkQueue queue, VkOutOfBandQueueTypeInfoNV pQueueTypeInfo);

VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask);

#ifdef VK_USE_PLATFORM_SCREEN_QNX
Expand Down Expand Up @@ -4449,6 +4462,21 @@ class ValidationObject {
virtual bool PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, const ErrorObject& error_obj) const { return false; };
virtual void PreCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) {};
virtual void PostCallRecordGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, const RecordObject& record_obj) {};
virtual bool PreCallValidateSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepModeInfoNV* pSleepModeInfo, const ErrorObject& error_obj) const { return false; };
virtual void PreCallRecordSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepModeInfoNV* pSleepModeInfo) {};
virtual void PostCallRecordSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepModeInfoNV* pSleepModeInfo, const RecordObject& record_obj) {};
virtual bool PreCallValidateLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo, const ErrorObject& error_obj) const { return false; };
virtual void PreCallRecordLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo) {};
virtual void PostCallRecordLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, VkLatencySleepInfoNV* pSleepInfo, const RecordObject& record_obj) {};
virtual bool PreCallValidateSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo, const ErrorObject& error_obj) const { return false; };
virtual void PreCallRecordSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) {};
virtual void PostCallRecordSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo, const RecordObject& record_obj) {};
virtual bool PreCallValidateGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo, const ErrorObject& error_obj) const { return false; };
virtual void PreCallRecordGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) {};
virtual void PostCallRecordGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo, const RecordObject& record_obj) {};
virtual bool PreCallValidateQueueNotifyOutOfBandNV(VkQueue queue, VkOutOfBandQueueTypeInfoNV pQueueTypeInfo, const ErrorObject& error_obj) const { return false; };
virtual void PreCallRecordQueueNotifyOutOfBandNV(VkQueue queue, VkOutOfBandQueueTypeInfoNV pQueueTypeInfo) {};
virtual void PostCallRecordQueueNotifyOutOfBandNV(VkQueue queue, VkOutOfBandQueueTypeInfoNV pQueueTypeInfo, const RecordObject& record_obj) {};
virtual bool PreCallValidateCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask, const ErrorObject& error_obj) const { return false; };
virtual void PreCallRecordCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) {};
virtual void PostCallRecordCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask, const RecordObject& record_obj) {};
Expand Down
30 changes: 30 additions & 0 deletions layers/vulkan/generated/chassis_dispatch_helper.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1560,6 +1560,21 @@ typedef enum InterceptId {
InterceptIdPreCallValidateGetDynamicRenderingTilePropertiesQCOM,
InterceptIdPreCallRecordGetDynamicRenderingTilePropertiesQCOM,
InterceptIdPostCallRecordGetDynamicRenderingTilePropertiesQCOM,
InterceptIdPreCallValidateSetLatencySleepModeNV,
InterceptIdPreCallRecordSetLatencySleepModeNV,
InterceptIdPostCallRecordSetLatencySleepModeNV,
InterceptIdPreCallValidateLatencySleepNV,
InterceptIdPreCallRecordLatencySleepNV,
InterceptIdPostCallRecordLatencySleepNV,
InterceptIdPreCallValidateSetLatencyMarkerNV,
InterceptIdPreCallRecordSetLatencyMarkerNV,
InterceptIdPostCallRecordSetLatencyMarkerNV,
InterceptIdPreCallValidateGetLatencyTimingsNV,
InterceptIdPreCallRecordGetLatencyTimingsNV,
InterceptIdPostCallRecordGetLatencyTimingsNV,
InterceptIdPreCallValidateQueueNotifyOutOfBandNV,
InterceptIdPreCallRecordQueueNotifyOutOfBandNV,
InterceptIdPostCallRecordQueueNotifyOutOfBandNV,
InterceptIdPreCallValidateCmdSetAttachmentFeedbackLoopEnableEXT,
InterceptIdPreCallRecordCmdSetAttachmentFeedbackLoopEnableEXT,
InterceptIdPostCallRecordCmdSetAttachmentFeedbackLoopEnableEXT,
Expand Down Expand Up @@ -3294,6 +3309,21 @@ void ValidationObject::InitObjectDispatchVectors() {
BUILD_DISPATCH_VECTOR(PreCallValidateGetDynamicRenderingTilePropertiesQCOM);
BUILD_DISPATCH_VECTOR(PreCallRecordGetDynamicRenderingTilePropertiesQCOM);
BUILD_DISPATCH_VECTOR(PostCallRecordGetDynamicRenderingTilePropertiesQCOM);
BUILD_DISPATCH_VECTOR(PreCallValidateSetLatencySleepModeNV);
BUILD_DISPATCH_VECTOR(PreCallRecordSetLatencySleepModeNV);
BUILD_DISPATCH_VECTOR(PostCallRecordSetLatencySleepModeNV);
BUILD_DISPATCH_VECTOR(PreCallValidateLatencySleepNV);
BUILD_DISPATCH_VECTOR(PreCallRecordLatencySleepNV);
BUILD_DISPATCH_VECTOR(PostCallRecordLatencySleepNV);
BUILD_DISPATCH_VECTOR(PreCallValidateSetLatencyMarkerNV);
BUILD_DISPATCH_VECTOR(PreCallRecordSetLatencyMarkerNV);
BUILD_DISPATCH_VECTOR(PostCallRecordSetLatencyMarkerNV);
BUILD_DISPATCH_VECTOR(PreCallValidateGetLatencyTimingsNV);
BUILD_DISPATCH_VECTOR(PreCallRecordGetLatencyTimingsNV);
BUILD_DISPATCH_VECTOR(PostCallRecordGetLatencyTimingsNV);
BUILD_DISPATCH_VECTOR(PreCallValidateQueueNotifyOutOfBandNV);
BUILD_DISPATCH_VECTOR(PreCallRecordQueueNotifyOutOfBandNV);
BUILD_DISPATCH_VECTOR(PostCallRecordQueueNotifyOutOfBandNV);
BUILD_DISPATCH_VECTOR(PreCallValidateCmdSetAttachmentFeedbackLoopEnableEXT);
BUILD_DISPATCH_VECTOR(PreCallRecordCmdSetAttachmentFeedbackLoopEnableEXT);
BUILD_DISPATCH_VECTOR(PostCallRecordCmdSetAttachmentFeedbackLoopEnableEXT);
Expand Down
Loading

0 comments on commit cdde97c

Please sign in to comment.