OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

venus: adopt venus protocol release

Browse Source 
Signed-off-by: Yiwei Zhang <zzyiwei@chromium.org>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/22547>
This commit is contained in:
Yiwei Zhang
2023-04-07 23:53:09 -07:00
committed by Marge Bot
parent 234ae64c92
commit e9c26e6920
10 changed files with 185 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/virtio/venus-protocol/vn_protocol_driver.h
View File

@@ -1,4 +1,4 @@
/* This file is generated by venus-protocol git-fbda104b. */
/* This file is generated by venus-protocol git-36572e74. */
/*
* Copyright 2020 Google LLC

34
src/virtio/venus-protocol/vn_protocol_driver_defines.h
View File

@@ -18,8 +18,8 @@
#define VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA ((VkStructureType)1000384000)
#define VK_STRUCTURE_TYPE_MEMORY_RESOURCE_PROPERTIES_MESA ((VkStructureType)1000384001)
#define VK_STRUCTURE_TYPE_IMPORT_MEMORY_RESOURCE_INFO_MESA ((VkStructureType)1000384002)
#define VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA ((VkStructureType)1000384003)
#define VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_100000_MESA ((VkStructureType)1000384004)
#define VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA ((VkStructureType)1000384003)
#define VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_MESA ((VkStructureType)1000384004)
#define VK_STRUCTURE_TYPE_DEVICE_QUEUE_TIMELINE_INFO_MESA ((VkStructureType)1000384005)
#define VK_STRUCTURE_TYPE_RING_MONITOR_INFO_MESA ((VkStructureType)1000384006)
@@ -350,13 +350,12 @@ typedef enum VkCommandTypeEXT {
VK_COMMAND_TYPE_vkNotifyRingMESA_EXT = 190,
VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT = 191,
VK_COMMAND_TYPE_vkGetMemoryResourcePropertiesMESA_EXT = 192,
VK_COMMAND_TYPE_vkResetFenceResource100000MESA_EXT = 244,
VK_COMMAND_TYPE_vkWaitSemaphoreResource100000MESA_EXT = 245,
VK_COMMAND_TYPE_vkImportSemaphoreResource100000MESA_EXT = 246,
VK_COMMAND_TYPE_vkSubmitVirtqueueSeqno100000MESA_EXT = 251,
VK_COMMAND_TYPE_vkWaitVirtqueueSeqno100000MESA_EXT = 252,
VK_COMMAND_TYPE_vkWaitRingSeqno100000MESA_EXT = 253,
VK_COMMAND_TYPE_vkGetVenusExperimentalFeatureData100000MESA_EXT = 195,
VK_COMMAND_TYPE_vkResetFenceResourceMESA_EXT = 244,
VK_COMMAND_TYPE_vkWaitSemaphoreResourceMESA_EXT = 245,
VK_COMMAND_TYPE_vkImportSemaphoreResourceMESA_EXT = 246,
VK_COMMAND_TYPE_vkSubmitVirtqueueSeqnoMESA_EXT = 251,
VK_COMMAND_TYPE_vkWaitVirtqueueSeqnoMESA_EXT = 252,
VK_COMMAND_TYPE_vkWaitRingSeqnoMESA_EXT = 253,
} VkCommandTypeEXT;
typedef enum VkCommandFlagBitsEXT {
@@ -426,27 +425,18 @@ typedef struct VkImportMemoryResourceInfoMESA {
uint32_t resourceId;
} VkImportMemoryResourceInfoMESA;
typedef struct VkVenusExperimentalFeatures100000MESA {
VkBool32 memoryResourceAllocationSize;
VkBool32 globalFencing;
VkBool32 largeRing;
VkBool32 syncFdFencing;
VkBool32 asyncRoundtrip;
VkBool32 ringMonitoring;
} VkVenusExperimentalFeatures100000MESA;
typedef struct VkMemoryResourceAllocationSizeProperties100000MESA {
typedef struct VkMemoryResourceAllocationSizePropertiesMESA {
VkStructureType sType;
void* pNext;
uint64_t allocationSize;
} VkMemoryResourceAllocationSizeProperties100000MESA;
} VkMemoryResourceAllocationSizePropertiesMESA;
typedef struct VkImportSemaphoreResourceInfo100000MESA {
typedef struct VkImportSemaphoreResourceInfoMESA {
VkStructureType sType;
const void* pNext;
VkSemaphore semaphore;
uint32_t resourceId;
} VkImportSemaphoreResourceInfo100000MESA;
} VkImportSemaphoreResourceInfoMESA;
typedef struct VkDeviceQueueTimelineInfoMESA {
VkStructureType sType;

64
src/virtio/venus-protocol/vn_protocol_driver_device_memory.h
View File

@@ -537,17 +537,17 @@ vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_encoder *enc, cons
vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(enc, val);
}
/* struct VkMemoryResourceAllocationSizeProperties100000MESA chain */
/* struct VkMemoryResourceAllocationSizePropertiesMESA chain */
static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_pnext(const void *val)
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self(const VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self(const VkMemoryResourceAllocationSizePropertiesMESA *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
@@ -556,19 +556,19 @@ vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self(const VkMemory
}
static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA(const VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA(const VkMemoryResourceAllocationSizePropertiesMESA *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_pnext(val->pNext);
size += vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self(val);
size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext(val->pNext);
size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self(val);
return size;
}
static inline void
vn_decode_VkMemoryResourceAllocationSizeProperties100000MESA_pnext(struct vn_cs_decoder *dec, const void *val)
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
@@ -576,33 +576,33 @@ vn_decode_VkMemoryResourceAllocationSizeProperties100000MESA_pnext(struct vn_cs_
}
static inline void
vn_decode_VkMemoryResourceAllocationSizeProperties100000MESA_self(struct vn_cs_decoder *dec, VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_self(struct vn_cs_decoder *dec, VkMemoryResourceAllocationSizePropertiesMESA *val)
{
/* skip val->{sType,pNext} */
vn_decode_uint64_t(dec, &val->allocationSize);
}
static inline void
vn_decode_VkMemoryResourceAllocationSizeProperties100000MESA(struct vn_cs_decoder *dec, VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA(struct vn_cs_decoder *dec, VkMemoryResourceAllocationSizePropertiesMESA *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA);
assert(stype == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA);
assert(val->sType == stype);
vn_decode_VkMemoryResourceAllocationSizeProperties100000MESA_pnext(dec, val->pNext);
vn_decode_VkMemoryResourceAllocationSizeProperties100000MESA_self(dec, val);
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_pnext(dec, val->pNext);
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_self(dec, val);
}
static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_pnext_partial(const void *val)
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self_partial(const VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(const VkMemoryResourceAllocationSizePropertiesMESA *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
@@ -611,38 +611,38 @@ vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self_partial(const
}
static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_partial(const VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_partial(const VkMemoryResourceAllocationSizePropertiesMESA *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_pnext_partial(val->pNext);
size += vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self_partial(val);
size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(val->pNext);
size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(val);
return size;
}
static inline void
vn_encode_VkMemoryResourceAllocationSizeProperties100000MESA_pnext_partial(struct vn_cs_encoder *enc, const void *val)
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkMemoryResourceAllocationSizeProperties100000MESA_self_partial(struct vn_cs_encoder *enc, const VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(struct vn_cs_encoder *enc, const VkMemoryResourceAllocationSizePropertiesMESA *val)
{
/* skip val->{sType,pNext} */
/* skip val->allocationSize */
}
static inline void
vn_encode_VkMemoryResourceAllocationSizeProperties100000MESA_partial(struct vn_cs_encoder *enc, const VkMemoryResourceAllocationSizeProperties100000MESA *val)
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_partial(struct vn_cs_encoder *enc, const VkMemoryResourceAllocationSizePropertiesMESA *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA });
vn_encode_VkMemoryResourceAllocationSizeProperties100000MESA_pnext_partial(enc, val->pNext);
vn_encode_VkMemoryResourceAllocationSizeProperties100000MESA_self_partial(enc, val);
assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA });
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(enc, val->pNext);
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(enc, val);
}
/* struct VkMemoryResourcePropertiesMESA chain */
@@ -655,11 +655,11 @@ vn_sizeof_VkMemoryResourcePropertiesMESA_pnext(const void *val)
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA:
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkMemoryResourcePropertiesMESA_pnext(pnext->pNext);
size += vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self((const VkMemoryResourceAllocationSizeProperties100000MESA *)pnext);
size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self((const VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
@@ -711,9 +711,9 @@ vn_decode_VkMemoryResourcePropertiesMESA_pnext(struct vn_cs_decoder *dec, const
}
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA:
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
vn_decode_VkMemoryResourcePropertiesMESA_pnext(dec, pnext->pNext);
vn_decode_VkMemoryResourceAllocationSizeProperties100000MESA_self(dec, (VkMemoryResourceAllocationSizeProperties100000MESA *)pnext);
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_self(dec, (VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
break;
default:
assert(false);
@@ -748,11 +748,11 @@ vn_sizeof_VkMemoryResourcePropertiesMESA_pnext_partial(const void *val)
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA:
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkMemoryResourcePropertiesMESA_pnext_partial(pnext->pNext);
size += vn_sizeof_VkMemoryResourceAllocationSizeProperties100000MESA_self_partial((const VkMemoryResourceAllocationSizeProperties100000MESA *)pnext);
size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self_partial((const VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
@@ -792,11 +792,11 @@ vn_encode_VkMemoryResourcePropertiesMESA_pnext_partial(struct vn_cs_encoder *enc
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA:
case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkMemoryResourcePropertiesMESA_pnext_partial(enc, pnext->pNext);
vn_encode_VkMemoryResourceAllocationSizeProperties100000MESA_self_partial(enc, (const VkMemoryResourceAllocationSizeProperties100000MESA *)pnext);
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(enc, (const VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
return;
default:
/* ignore unknown/unsupported struct */

34
src/virtio/venus-protocol/vn_protocol_driver_fence.h
View File

@@ -471,9 +471,9 @@ static inline VkResult vn_decode_vkWaitForFences_reply(struct vn_cs_decoder *dec
return ret;
}
static inline size_t vn_sizeof_vkResetFenceResource100000MESA(VkDevice device, VkFence fence)
static inline size_t vn_sizeof_vkResetFenceResourceMESA(VkDevice device, VkFence fence)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFenceResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFenceResourceMESA_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
@@ -483,9 +483,9 @@ static inline size_t vn_sizeof_vkResetFenceResource100000MESA(VkDevice device, V
return cmd_size;
}
static inline void vn_encode_vkResetFenceResource100000MESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence)
static inline void vn_encode_vkResetFenceResourceMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFenceResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFenceResourceMESA_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
@@ -494,9 +494,9 @@ static inline void vn_encode_vkResetFenceResource100000MESA(struct vn_cs_encoder
vn_encode_VkFence(enc, &fence);
}
static inline size_t vn_sizeof_vkResetFenceResource100000MESA_reply(VkDevice device, VkFence fence)
static inline size_t vn_sizeof_vkResetFenceResourceMESA_reply(VkDevice device, VkFence fence)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFenceResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFenceResourceMESA_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
@@ -505,11 +505,11 @@ static inline size_t vn_sizeof_vkResetFenceResource100000MESA_reply(VkDevice dev
return cmd_size;
}
static inline void vn_decode_vkResetFenceResource100000MESA_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence)
static inline void vn_decode_vkResetFenceResourceMESA_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkResetFenceResource100000MESA_EXT);
assert(command_type == VK_COMMAND_TYPE_vkResetFenceResourceMESA_EXT);
/* skip device */
/* skip fence */
@@ -620,21 +620,21 @@ static inline void vn_submit_vkWaitForFences(struct vn_instance *vn_instance, Vk
}
}
static inline void vn_submit_vkResetFenceResource100000MESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, struct vn_instance_submit_command *submit)
static inline void vn_submit_vkResetFenceResourceMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkResetFenceResource100000MESA(device, fence);
size_t cmd_size = vn_sizeof_vkResetFenceResourceMESA(device, fence);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFenceResource100000MESA_reply(device, fence) : 0;
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFenceResourceMESA_reply(device, fence) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkResetFenceResource100000MESA(enc, cmd_flags, device, fence);
vn_encode_vkResetFenceResourceMESA(enc, cmd_flags, device, fence);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
@@ -748,23 +748,23 @@ static inline void vn_async_vkWaitForFences(struct vn_instance *vn_instance, VkD
vn_submit_vkWaitForFences(vn_instance, 0, device, fenceCount, pFences, waitAll, timeout, &submit);
}
static inline void vn_call_vkResetFenceResource100000MESA(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
static inline void vn_call_vkResetFenceResourceMESA(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkResetFenceResource100000MESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, &submit);
vn_submit_vkResetFenceResourceMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkResetFenceResource100000MESA_reply(dec, device, fence);
vn_decode_vkResetFenceResourceMESA_reply(dec, device, fence);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkResetFenceResource100000MESA(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
static inline void vn_async_vkResetFenceResourceMESA(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
{
struct vn_instance_submit_command submit;
vn_submit_vkResetFenceResource100000MESA(vn_instance, 0, device, fence, &submit);
vn_submit_vkResetFenceResourceMESA(vn_instance, 0, device, fence, &submit);
}
#endif /* VN_PROTOCOL_DRIVER_FENCE_H */

6
src/virtio/venus-protocol/vn_protocol_driver_info.h
View File

@@ -23,7 +23,7 @@ static const uint32_t _vn_info_extension_count = 102;
static const struct vn_info_extension _vn_info_extensions[102] = {
{ "VK_EXT_4444_formats", 341, 1 },
{ "VK_EXT_calibrated_timestamps", 185, 2 },
{ "VK_EXT_command_serialization", 384, 0 },
{ "VK_EXT_command_serialization", 384, 1 },
{ "VK_EXT_conditional_rendering", 82, 2 },
{ "VK_EXT_conservative_rasterization", 102, 1 },
{ "VK_EXT_custom_border_color", 288, 12 },
@@ -121,14 +121,14 @@ static const struct vn_info_extension _vn_info_extensions[102] = {
{ "VK_KHR_variable_pointers", 121, 1 },
{ "VK_KHR_vulkan_memory_model", 212, 3 },
{ "VK_KHR_zero_initialize_workgroup_memory", 326, 1 },
{ "VK_MESA_venus_protocol", 385, 100000 },
{ "VK_MESA_venus_protocol", 385, 1 },
{ "VK_VALVE_mutable_descriptor_type", 352, 1 },
};
static inline uint32_t
vn_info_wire_format_version(void)
{
return 0;
return 1;
}
static inline uint32_t

98
src/virtio/venus-protocol/vn_protocol_driver_semaphore.h
View File

@@ -305,17 +305,17 @@ vn_encode_VkSemaphoreSignalInfo(struct vn_cs_encoder *enc, const VkSemaphoreSign
vn_encode_VkSemaphoreSignalInfo_self(enc, val);
}
/* struct VkImportSemaphoreResourceInfo100000MESA chain */
/* struct VkImportSemaphoreResourceInfoMESA chain */
static inline size_t
vn_sizeof_VkImportSemaphoreResourceInfo100000MESA_pnext(const void *val)
vn_sizeof_VkImportSemaphoreResourceInfoMESA_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkImportSemaphoreResourceInfo100000MESA_self(const VkImportSemaphoreResourceInfo100000MESA *val)
vn_sizeof_VkImportSemaphoreResourceInfoMESA_self(const VkImportSemaphoreResourceInfoMESA *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
@@ -325,26 +325,26 @@ vn_sizeof_VkImportSemaphoreResourceInfo100000MESA_self(const VkImportSemaphoreRe
}
static inline size_t
vn_sizeof_VkImportSemaphoreResourceInfo100000MESA(const VkImportSemaphoreResourceInfo100000MESA *val)
vn_sizeof_VkImportSemaphoreResourceInfoMESA(const VkImportSemaphoreResourceInfoMESA *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkImportSemaphoreResourceInfo100000MESA_pnext(val->pNext);
size += vn_sizeof_VkImportSemaphoreResourceInfo100000MESA_self(val);
size += vn_sizeof_VkImportSemaphoreResourceInfoMESA_pnext(val->pNext);
size += vn_sizeof_VkImportSemaphoreResourceInfoMESA_self(val);
return size;
}
static inline void
vn_encode_VkImportSemaphoreResourceInfo100000MESA_pnext(struct vn_cs_encoder *enc, const void *val)
vn_encode_VkImportSemaphoreResourceInfoMESA_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkImportSemaphoreResourceInfo100000MESA_self(struct vn_cs_encoder *enc, const VkImportSemaphoreResourceInfo100000MESA *val)
vn_encode_VkImportSemaphoreResourceInfoMESA_self(struct vn_cs_encoder *enc, const VkImportSemaphoreResourceInfoMESA *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkSemaphore(enc, &val->semaphore);
@@ -352,12 +352,12 @@ vn_encode_VkImportSemaphoreResourceInfo100000MESA_self(struct vn_cs_encoder *enc
}
static inline void
vn_encode_VkImportSemaphoreResourceInfo100000MESA(struct vn_cs_encoder *enc, const VkImportSemaphoreResourceInfo100000MESA *val)
vn_encode_VkImportSemaphoreResourceInfoMESA(struct vn_cs_encoder *enc, const VkImportSemaphoreResourceInfoMESA *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_100000_MESA);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_100000_MESA });
vn_encode_VkImportSemaphoreResourceInfo100000MESA_pnext(enc, val->pNext);
vn_encode_VkImportSemaphoreResourceInfo100000MESA_self(enc, val);
assert(val->sType == VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_MESA);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_MESA });
vn_encode_VkImportSemaphoreResourceInfoMESA_pnext(enc, val->pNext);
vn_encode_VkImportSemaphoreResourceInfoMESA_self(enc, val);
}
static inline size_t vn_sizeof_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
@@ -654,9 +654,9 @@ static inline VkResult vn_decode_vkSignalSemaphore_reply(struct vn_cs_decoder *d
return ret;
}
static inline size_t vn_sizeof_vkWaitSemaphoreResource100000MESA(VkDevice device, VkSemaphore semaphore)
static inline size_t vn_sizeof_vkWaitSemaphoreResourceMESA(VkDevice device, VkSemaphore semaphore)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphoreResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphoreResourceMESA_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
@@ -666,9 +666,9 @@ static inline size_t vn_sizeof_vkWaitSemaphoreResource100000MESA(VkDevice device
return cmd_size;
}
static inline void vn_encode_vkWaitSemaphoreResource100000MESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore)
static inline void vn_encode_vkWaitSemaphoreResourceMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphoreResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphoreResourceMESA_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
@@ -677,9 +677,9 @@ static inline void vn_encode_vkWaitSemaphoreResource100000MESA(struct vn_cs_enco
vn_encode_VkSemaphore(enc, &semaphore);
}
static inline size_t vn_sizeof_vkWaitSemaphoreResource100000MESA_reply(VkDevice device, VkSemaphore semaphore)
static inline size_t vn_sizeof_vkWaitSemaphoreResourceMESA_reply(VkDevice device, VkSemaphore semaphore)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphoreResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphoreResourceMESA_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
@@ -688,45 +688,45 @@ static inline size_t vn_sizeof_vkWaitSemaphoreResource100000MESA_reply(VkDevice
return cmd_size;
}
static inline void vn_decode_vkWaitSemaphoreResource100000MESA_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore)
static inline void vn_decode_vkWaitSemaphoreResourceMESA_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkWaitSemaphoreResource100000MESA_EXT);
assert(command_type == VK_COMMAND_TYPE_vkWaitSemaphoreResourceMESA_EXT);
/* skip device */
/* skip semaphore */
}
static inline size_t vn_sizeof_vkImportSemaphoreResource100000MESA(VkDevice device, const VkImportSemaphoreResourceInfo100000MESA* pImportSemaphoreResourceInfo)
static inline size_t vn_sizeof_vkImportSemaphoreResourceMESA(VkDevice device, const VkImportSemaphoreResourceInfoMESA* pImportSemaphoreResourceInfo)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkImportSemaphoreResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkImportSemaphoreResourceMESA_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_simple_pointer(pImportSemaphoreResourceInfo);
if (pImportSemaphoreResourceInfo)
cmd_size += vn_sizeof_VkImportSemaphoreResourceInfo100000MESA(pImportSemaphoreResourceInfo);
cmd_size += vn_sizeof_VkImportSemaphoreResourceInfoMESA(pImportSemaphoreResourceInfo);
return cmd_size;
}
static inline void vn_encode_vkImportSemaphoreResource100000MESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImportSemaphoreResourceInfo100000MESA* pImportSemaphoreResourceInfo)
static inline void vn_encode_vkImportSemaphoreResourceMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImportSemaphoreResourceInfoMESA* pImportSemaphoreResourceInfo)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkImportSemaphoreResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkImportSemaphoreResourceMESA_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
if (vn_encode_simple_pointer(enc, pImportSemaphoreResourceInfo))
vn_encode_VkImportSemaphoreResourceInfo100000MESA(enc, pImportSemaphoreResourceInfo);
vn_encode_VkImportSemaphoreResourceInfoMESA(enc, pImportSemaphoreResourceInfo);
}
static inline size_t vn_sizeof_vkImportSemaphoreResource100000MESA_reply(VkDevice device, const VkImportSemaphoreResourceInfo100000MESA* pImportSemaphoreResourceInfo)
static inline size_t vn_sizeof_vkImportSemaphoreResourceMESA_reply(VkDevice device, const VkImportSemaphoreResourceInfoMESA* pImportSemaphoreResourceInfo)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkImportSemaphoreResource100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkImportSemaphoreResourceMESA_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
@@ -735,11 +735,11 @@ static inline size_t vn_sizeof_vkImportSemaphoreResource100000MESA_reply(VkDevic
return cmd_size;
}
static inline void vn_decode_vkImportSemaphoreResource100000MESA_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImportSemaphoreResourceInfo100000MESA* pImportSemaphoreResourceInfo)
static inline void vn_decode_vkImportSemaphoreResourceMESA_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImportSemaphoreResourceInfoMESA* pImportSemaphoreResourceInfo)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkImportSemaphoreResource100000MESA_EXT);
assert(command_type == VK_COMMAND_TYPE_vkImportSemaphoreResourceMESA_EXT);
/* skip device */
/* skip pImportSemaphoreResourceInfo */
@@ -850,42 +850,42 @@ static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance,
}
}
static inline void vn_submit_vkWaitSemaphoreResource100000MESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, struct vn_instance_submit_command *submit)
static inline void vn_submit_vkWaitSemaphoreResourceMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkWaitSemaphoreResource100000MESA(device, semaphore);
size_t cmd_size = vn_sizeof_vkWaitSemaphoreResourceMESA(device, semaphore);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphoreResource100000MESA_reply(device, semaphore) : 0;
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphoreResourceMESA_reply(device, semaphore) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkWaitSemaphoreResource100000MESA(enc, cmd_flags, device, semaphore);
vn_encode_vkWaitSemaphoreResourceMESA(enc, cmd_flags, device, semaphore);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkImportSemaphoreResource100000MESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImportSemaphoreResourceInfo100000MESA* pImportSemaphoreResourceInfo, struct vn_instance_submit_command *submit)
static inline void vn_submit_vkImportSemaphoreResourceMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImportSemaphoreResourceInfoMESA* pImportSemaphoreResourceInfo, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkImportSemaphoreResource100000MESA(device, pImportSemaphoreResourceInfo);
size_t cmd_size = vn_sizeof_vkImportSemaphoreResourceMESA(device, pImportSemaphoreResourceInfo);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkImportSemaphoreResource100000MESA_reply(device, pImportSemaphoreResourceInfo) : 0;
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkImportSemaphoreResourceMESA_reply(device, pImportSemaphoreResourceInfo) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkImportSemaphoreResource100000MESA(enc, cmd_flags, device, pImportSemaphoreResourceInfo);
vn_encode_vkImportSemaphoreResourceMESA(enc, cmd_flags, device, pImportSemaphoreResourceInfo);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
@@ -999,42 +999,42 @@ static inline void vn_async_vkSignalSemaphore(struct vn_instance *vn_instance, V
vn_submit_vkSignalSemaphore(vn_instance, 0, device, pSignalInfo, &submit);
}
static inline void vn_call_vkWaitSemaphoreResource100000MESA(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore)
static inline void vn_call_vkWaitSemaphoreResourceMESA(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkWaitSemaphoreResource100000MESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, &submit);
vn_submit_vkWaitSemaphoreResourceMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkWaitSemaphoreResource100000MESA_reply(dec, device, semaphore);
vn_decode_vkWaitSemaphoreResourceMESA_reply(dec, device, semaphore);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkWaitSemaphoreResource100000MESA(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore)
static inline void vn_async_vkWaitSemaphoreResourceMESA(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore)
{
struct vn_instance_submit_command submit;
vn_submit_vkWaitSemaphoreResource100000MESA(vn_instance, 0, device, semaphore, &submit);
vn_submit_vkWaitSemaphoreResourceMESA(vn_instance, 0, device, semaphore, &submit);
}
static inline void vn_call_vkImportSemaphoreResource100000MESA(struct vn_instance *vn_instance, VkDevice device, const VkImportSemaphoreResourceInfo100000MESA* pImportSemaphoreResourceInfo)
static inline void vn_call_vkImportSemaphoreResourceMESA(struct vn_instance *vn_instance, VkDevice device, const VkImportSemaphoreResourceInfoMESA* pImportSemaphoreResourceInfo)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkImportSemaphoreResource100000MESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pImportSemaphoreResourceInfo, &submit);
vn_submit_vkImportSemaphoreResourceMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pImportSemaphoreResourceInfo, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkImportSemaphoreResource100000MESA_reply(dec, device, pImportSemaphoreResourceInfo);
vn_decode_vkImportSemaphoreResourceMESA_reply(dec, device, pImportSemaphoreResourceInfo);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkImportSemaphoreResource100000MESA(struct vn_instance *vn_instance, VkDevice device, const VkImportSemaphoreResourceInfo100000MESA* pImportSemaphoreResourceInfo)
static inline void vn_async_vkImportSemaphoreResourceMESA(struct vn_instance *vn_instance, VkDevice device, const VkImportSemaphoreResourceInfoMESA* pImportSemaphoreResourceInfo)
{
struct vn_instance_submit_command submit;
vn_submit_vkImportSemaphoreResource100000MESA(vn_instance, 0, device, pImportSemaphoreResourceInfo, &submit);
vn_submit_vkImportSemaphoreResourceMESA(vn_instance, 0, device, pImportSemaphoreResourceInfo, &submit);
}
#endif /* VN_PROTOCOL_DRIVER_SEMAPHORE_H */

206
src/virtio/venus-protocol/vn_protocol_driver_transport.h
View File

@@ -570,9 +570,9 @@ static inline void vn_decode_vkWriteRingExtraMESA_reply(struct vn_cs_decoder *de
/* skip value */
}
static inline size_t vn_sizeof_vkSubmitVirtqueueSeqno100000MESA(uint64_t ring, uint64_t seqno)
static inline size_t vn_sizeof_vkSubmitVirtqueueSeqnoMESA(uint64_t ring, uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSubmitVirtqueueSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSubmitVirtqueueSeqnoMESA_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
@@ -582,9 +582,9 @@ static inline size_t vn_sizeof_vkSubmitVirtqueueSeqno100000MESA(uint64_t ring, u
return cmd_size;
}
static inline void vn_encode_vkSubmitVirtqueueSeqno100000MESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno)
static inline void vn_encode_vkSubmitVirtqueueSeqnoMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSubmitVirtqueueSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSubmitVirtqueueSeqnoMESA_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
@@ -593,9 +593,9 @@ static inline void vn_encode_vkSubmitVirtqueueSeqno100000MESA(struct vn_cs_encod
vn_encode_uint64_t(enc, &seqno);
}
static inline size_t vn_sizeof_vkSubmitVirtqueueSeqno100000MESA_reply(uint64_t ring, uint64_t seqno)
static inline size_t vn_sizeof_vkSubmitVirtqueueSeqnoMESA_reply(uint64_t ring, uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSubmitVirtqueueSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSubmitVirtqueueSeqnoMESA_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip ring */
@@ -604,19 +604,19 @@ static inline size_t vn_sizeof_vkSubmitVirtqueueSeqno100000MESA_reply(uint64_t r
return cmd_size;
}
static inline void vn_decode_vkSubmitVirtqueueSeqno100000MESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint64_t seqno)
static inline void vn_decode_vkSubmitVirtqueueSeqnoMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint64_t seqno)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkSubmitVirtqueueSeqno100000MESA_EXT);
assert(command_type == VK_COMMAND_TYPE_vkSubmitVirtqueueSeqnoMESA_EXT);
/* skip ring */
/* skip seqno */
}
static inline size_t vn_sizeof_vkWaitVirtqueueSeqno100000MESA(uint64_t seqno)
static inline size_t vn_sizeof_vkWaitVirtqueueSeqnoMESA(uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitVirtqueueSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitVirtqueueSeqnoMESA_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
@@ -625,9 +625,9 @@ static inline size_t vn_sizeof_vkWaitVirtqueueSeqno100000MESA(uint64_t seqno)
return cmd_size;
}
static inline void vn_encode_vkWaitVirtqueueSeqno100000MESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t seqno)
static inline void vn_encode_vkWaitVirtqueueSeqnoMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitVirtqueueSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitVirtqueueSeqnoMESA_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
@@ -635,9 +635,9 @@ static inline void vn_encode_vkWaitVirtqueueSeqno100000MESA(struct vn_cs_encoder
vn_encode_uint64_t(enc, &seqno);
}
static inline size_t vn_sizeof_vkWaitVirtqueueSeqno100000MESA_reply(uint64_t seqno)
static inline size_t vn_sizeof_vkWaitVirtqueueSeqnoMESA_reply(uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitVirtqueueSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitVirtqueueSeqnoMESA_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip seqno */
@@ -645,18 +645,18 @@ static inline size_t vn_sizeof_vkWaitVirtqueueSeqno100000MESA_reply(uint64_t seq
return cmd_size;
}
static inline void vn_decode_vkWaitVirtqueueSeqno100000MESA_reply(struct vn_cs_decoder *dec, uint64_t seqno)
static inline void vn_decode_vkWaitVirtqueueSeqnoMESA_reply(struct vn_cs_decoder *dec, uint64_t seqno)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkWaitVirtqueueSeqno100000MESA_EXT);
assert(command_type == VK_COMMAND_TYPE_vkWaitVirtqueueSeqnoMESA_EXT);
/* skip seqno */
}
static inline size_t vn_sizeof_vkWaitRingSeqno100000MESA(uint64_t ring, uint64_t seqno)
static inline size_t vn_sizeof_vkWaitRingSeqnoMESA(uint64_t ring, uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitRingSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitRingSeqnoMESA_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
@@ -666,9 +666,9 @@ static inline size_t vn_sizeof_vkWaitRingSeqno100000MESA(uint64_t ring, uint64_t
return cmd_size;
}
static inline void vn_encode_vkWaitRingSeqno100000MESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno)
static inline void vn_encode_vkWaitRingSeqnoMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitRingSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitRingSeqnoMESA_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
@@ -677,9 +677,9 @@ static inline void vn_encode_vkWaitRingSeqno100000MESA(struct vn_cs_encoder *enc
vn_encode_uint64_t(enc, &seqno);
}
static inline size_t vn_sizeof_vkWaitRingSeqno100000MESA_reply(uint64_t ring, uint64_t seqno)
static inline size_t vn_sizeof_vkWaitRingSeqnoMESA_reply(uint64_t ring, uint64_t seqno)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitRingSeqno100000MESA_EXT;
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitRingSeqnoMESA_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip ring */
@@ -688,80 +688,16 @@ static inline size_t vn_sizeof_vkWaitRingSeqno100000MESA_reply(uint64_t ring, ui
return cmd_size;
}
static inline void vn_decode_vkWaitRingSeqno100000MESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint64_t seqno)
static inline void vn_decode_vkWaitRingSeqnoMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint64_t seqno)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkWaitRingSeqno100000MESA_EXT);
assert(command_type == VK_COMMAND_TYPE_vkWaitRingSeqnoMESA_EXT);
/* skip ring */
/* skip seqno */
}
static inline size_t vn_sizeof_vkGetVenusExperimentalFeatureData100000MESA(size_t* pDataSize, void* pData)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetVenusExperimentalFeatureData100000MESA_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_simple_pointer(pDataSize);
if (pDataSize)
cmd_size += vn_sizeof_size_t(pDataSize);
cmd_size += vn_sizeof_simple_pointer(pData); /* out */
return cmd_size;
}
static inline void vn_encode_vkGetVenusExperimentalFeatureData100000MESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, size_t* pDataSize, void* pData)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetVenusExperimentalFeatureData100000MESA_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
if (vn_encode_simple_pointer(enc, pDataSize))
vn_encode_size_t(enc, pDataSize);
vn_encode_array_size(enc, pData ? (pDataSize ? *pDataSize : 0) : 0); /* out */
}
static inline size_t vn_sizeof_vkGetVenusExperimentalFeatureData100000MESA_reply(size_t* pDataSize, void* pData)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetVenusExperimentalFeatureData100000MESA_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
cmd_size += vn_sizeof_simple_pointer(pDataSize);
if (pDataSize)
cmd_size += vn_sizeof_size_t(pDataSize);
if (pData) {
cmd_size += vn_sizeof_array_size((pDataSize ? *pDataSize : 0));
cmd_size += vn_sizeof_blob_array(pData, (pDataSize ? *pDataSize : 0));
} else {
cmd_size += vn_sizeof_array_size(0);
}
return cmd_size;
}
static inline void vn_decode_vkGetVenusExperimentalFeatureData100000MESA_reply(struct vn_cs_decoder *dec, size_t* pDataSize, void* pData)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetVenusExperimentalFeatureData100000MESA_EXT);
if (vn_decode_simple_pointer(dec)) {
vn_decode_size_t(dec, pDataSize);
} else {
pDataSize = NULL;
}
if (vn_peek_array_size(dec)) {
const size_t array_size = vn_decode_array_size(dec, (pDataSize ? *pDataSize : 0));
vn_decode_blob_array(dec, pData, array_size);
} else {
vn_decode_array_size_unchecked(dec);
pData = NULL;
}
}
static inline void vn_submit_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
@@ -909,84 +845,63 @@ static inline void vn_submit_vkWriteRingExtraMESA(struct vn_instance *vn_instanc
}
}
static inline void vn_submit_vkSubmitVirtqueueSeqno100000MESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno, struct vn_instance_submit_command *submit)
static inline void vn_submit_vkSubmitVirtqueueSeqnoMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkSubmitVirtqueueSeqno100000MESA(ring, seqno);
size_t cmd_size = vn_sizeof_vkSubmitVirtqueueSeqnoMESA(ring, seqno);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSubmitVirtqueueSeqno100000MESA_reply(ring, seqno) : 0;
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSubmitVirtqueueSeqnoMESA_reply(ring, seqno) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkSubmitVirtqueueSeqno100000MESA(enc, cmd_flags, ring, seqno);
vn_encode_vkSubmitVirtqueueSeqnoMESA(enc, cmd_flags, ring, seqno);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkWaitVirtqueueSeqno100000MESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t seqno, struct vn_instance_submit_command *submit)
static inline void vn_submit_vkWaitVirtqueueSeqnoMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t seqno, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkWaitVirtqueueSeqno100000MESA(seqno);
size_t cmd_size = vn_sizeof_vkWaitVirtqueueSeqnoMESA(seqno);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitVirtqueueSeqno100000MESA_reply(seqno) : 0;
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitVirtqueueSeqnoMESA_reply(seqno) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkWaitVirtqueueSeqno100000MESA(enc, cmd_flags, seqno);
vn_encode_vkWaitVirtqueueSeqnoMESA(enc, cmd_flags, seqno);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkWaitRingSeqno100000MESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno, struct vn_instance_submit_command *submit)
static inline void vn_submit_vkWaitRingSeqnoMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint64_t seqno, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkWaitRingSeqno100000MESA(ring, seqno);
size_t cmd_size = vn_sizeof_vkWaitRingSeqnoMESA(ring, seqno);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitRingSeqno100000MESA_reply(ring, seqno) : 0;
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitRingSeqnoMESA_reply(ring, seqno) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkWaitRingSeqno100000MESA(enc, cmd_flags, ring, seqno);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetVenusExperimentalFeatureData100000MESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, size_t* pDataSize, void* pData, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkGetVenusExperimentalFeatureData100000MESA(pDataSize, pData);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetVenusExperimentalFeatureData100000MESA_reply(pDataSize, pData) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetVenusExperimentalFeatureData100000MESA(enc, cmd_flags, pDataSize, pData);
vn_encode_vkWaitRingSeqnoMESA(enc, cmd_flags, ring, seqno);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
@@ -1126,80 +1041,61 @@ static inline void vn_async_vkWriteRingExtraMESA(struct vn_instance *vn_instance
vn_submit_vkWriteRingExtraMESA(vn_instance, 0, ring, offset, value, &submit);
}
static inline void vn_call_vkSubmitVirtqueueSeqno100000MESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
static inline void vn_call_vkSubmitVirtqueueSeqnoMESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkSubmitVirtqueueSeqno100000MESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, &submit);
vn_submit_vkSubmitVirtqueueSeqnoMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkSubmitVirtqueueSeqno100000MESA_reply(dec, ring, seqno);
vn_decode_vkSubmitVirtqueueSeqnoMESA_reply(dec, ring, seqno);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkSubmitVirtqueueSeqno100000MESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
static inline void vn_async_vkSubmitVirtqueueSeqnoMESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
{
struct vn_instance_submit_command submit;
vn_submit_vkSubmitVirtqueueSeqno100000MESA(vn_instance, 0, ring, seqno, &submit);
vn_submit_vkSubmitVirtqueueSeqnoMESA(vn_instance, 0, ring, seqno, &submit);
}
static inline void vn_call_vkWaitVirtqueueSeqno100000MESA(struct vn_instance *vn_instance, uint64_t seqno)
static inline void vn_call_vkWaitVirtqueueSeqnoMESA(struct vn_instance *vn_instance, uint64_t seqno)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkWaitVirtqueueSeqno100000MESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, seqno, &submit);
vn_submit_vkWaitVirtqueueSeqnoMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, seqno, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkWaitVirtqueueSeqno100000MESA_reply(dec, seqno);
vn_decode_vkWaitVirtqueueSeqnoMESA_reply(dec, seqno);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkWaitVirtqueueSeqno100000MESA(struct vn_instance *vn_instance, uint64_t seqno)
static inline void vn_async_vkWaitVirtqueueSeqnoMESA(struct vn_instance *vn_instance, uint64_t seqno)
{
struct vn_instance_submit_command submit;
vn_submit_vkWaitVirtqueueSeqno100000MESA(vn_instance, 0, seqno, &submit);
vn_submit_vkWaitVirtqueueSeqnoMESA(vn_instance, 0, seqno, &submit);
}
static inline void vn_call_vkWaitRingSeqno100000MESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
static inline void vn_call_vkWaitRingSeqnoMESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkWaitRingSeqno100000MESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, &submit);
vn_submit_vkWaitRingSeqnoMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkWaitRingSeqno100000MESA_reply(dec, ring, seqno);
vn_decode_vkWaitRingSeqnoMESA_reply(dec, ring, seqno);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkWaitRingSeqno100000MESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
static inline void vn_async_vkWaitRingSeqnoMESA(struct vn_instance *vn_instance, uint64_t ring, uint64_t seqno)
{
struct vn_instance_submit_command submit;
vn_submit_vkWaitRingSeqno100000MESA(vn_instance, 0, ring, seqno, &submit);
}
static inline void vn_call_vkGetVenusExperimentalFeatureData100000MESA(struct vn_instance *vn_instance, size_t* pDataSize, void* pData)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkGetVenusExperimentalFeatureData100000MESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pDataSize, pData, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetVenusExperimentalFeatureData100000MESA_reply(dec, pDataSize, pData);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkGetVenusExperimentalFeatureData100000MESA(struct vn_instance *vn_instance, size_t* pDataSize, void* pData)
{
struct vn_instance_submit_command submit;
vn_submit_vkGetVenusExperimentalFeatureData100000MESA(vn_instance, 0, pDataSize, pData, &submit);
vn_submit_vkWaitRingSeqnoMESA(vn_instance, 0, ring, seqno, &submit);
}
#endif /* VN_PROTOCOL_DRIVER_TRANSPORT_H */

4
src/virtio/vulkan/vn_device_memory.c
View File

@@ -762,9 +762,9 @@ vn_get_memory_dma_buf_properties(struct vn_device *dev,
vn_instance_roundtrip(dev->instance);
VkMemoryResourceAllocationSizeProperties100000MESA alloc_size_props = {
VkMemoryResourceAllocationSizePropertiesMESA alloc_size_props = {
.sType =
VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA,
VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA,
};
VkMemoryResourcePropertiesMESA props = {
.sType = VK_STRUCTURE_TYPE_MEMORY_RESOURCE_PROPERTIES_MESA,

6
src/virtio/vulkan/vn_instance.c
View File

@@ -250,8 +250,8 @@ vn_instance_submit_roundtrip(struct vn_instance *instance,
mtx_lock(&instance->ring.roundtrip_mutex);
const uint64_t seqno = instance->ring.roundtrip_next++;
vn_encode_vkSubmitVirtqueueSeqno100000MESA(&local_enc, 0,
instance->ring.id, seqno);
vn_encode_vkSubmitVirtqueueSeqnoMESA(&local_enc, 0, instance->ring.id,
seqno);
VkResult result = vn_renderer_submit_simple(
instance->renderer, local_data, vn_cs_encoder_get_len(&local_enc));
mtx_unlock(&instance->ring.roundtrip_mutex);
@@ -264,7 +264,7 @@ void
vn_instance_wait_roundtrip(struct vn_instance *instance,
uint64_t roundtrip_seqno)
{
vn_async_vkWaitVirtqueueSeqno100000MESA(instance, roundtrip_seqno);
vn_async_vkWaitVirtqueueSeqnoMESA(instance, roundtrip_seqno);
}
struct vn_instance_submission {

33
src/virtio/vulkan/vn_queue.c
View File

@@ -215,13 +215,12 @@ vn_queue_submission_fix_batch_semaphores(struct vn_queue_submission *submit,
assert(dev->physical_device->renderer_sync_fd.semaphore_importable);
const VkImportSemaphoreResourceInfo100000MESA res_info = {
.sType =
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_100000_MESA,
const VkImportSemaphoreResourceInfoMESA res_info = {
.sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_MESA,
.semaphore = sem_handle,
.resourceId = 0,
};
vn_async_vkImportSemaphoreResource100000MESA(
vn_async_vkImportSemaphoreResourceMESA(
dev->instance, vn_device_to_handle(dev), &res_info);
}
@@ -788,9 +787,8 @@ vn_queue_wsi_present(struct vn_queue_submission *submit)
struct vn_cs_encoder local_enc =
VN_CS_ENCODER_INITIALIZER_LOCAL(local_data, sizeof(local_data));
if (submit->external_payload.ring_seqno_valid) {
vn_encode_vkWaitRingSeqno100000MESA(
&local_enc, 0, instance->ring.id,
submit->external_payload.ring_seqno);
vn_encode_vkWaitRingSeqnoMESA(&local_enc, 0, instance->ring.id,
submit->external_payload.ring_seqno);
batch.cs_data = local_data;
batch.cs_size = vn_cs_encoder_get_len(&local_enc);
}
@@ -1368,8 +1366,8 @@ vn_create_sync_file(struct vn_device *dev,
struct vn_cs_encoder local_enc =
VN_CS_ENCODER_INITIALIZER_LOCAL(local_data, sizeof(local_data));
if (external_payload->ring_seqno_valid) {
vn_encode_vkWaitRingSeqno100000MESA(
&local_enc, 0, dev->instance->ring.id, external_payload->ring_seqno);
vn_encode_vkWaitRingSeqnoMESA(&local_enc, 0, dev->instance->ring.id,
external_payload->ring_seqno);
batch.cs_data = local_data;
batch.cs_size = vn_cs_encoder_get_len(&local_enc);
}
@@ -1446,8 +1444,8 @@ vn_GetFenceFdKHR(VkDevice device,
if (result != VK_SUCCESS)
return vn_error(dev->instance, result);
vn_async_vkResetFenceResource100000MESA(dev->instance, device,
pGetFdInfo->fence);
vn_async_vkResetFenceResourceMESA(dev->instance, device,
pGetFdInfo->fence);
vn_sync_payload_release(dev, &fence->temporary);
fence->payload = &fence->permanent;
@@ -1924,19 +1922,18 @@ vn_GetSemaphoreFdKHR(VkDevice device,
* semaphore.
*/
if (payload->type == VN_SYNC_TYPE_IMPORTED_SYNC_FD) {
const VkImportSemaphoreResourceInfo100000MESA res_info = {
.sType =
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_100000_MESA,
const VkImportSemaphoreResourceInfoMESA res_info = {
.sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_RESOURCE_INFO_MESA,
.semaphore = pGetFdInfo->semaphore,
.resourceId = 0,
};
vn_async_vkImportSemaphoreResource100000MESA(dev->instance, device,
&res_info);
vn_async_vkImportSemaphoreResourceMESA(dev->instance, device,
&res_info);
}
/* perform wait operation on the host semaphore */
vn_async_vkWaitSemaphoreResource100000MESA(dev->instance, device,
pGetFdInfo->semaphore);
vn_async_vkWaitSemaphoreResourceMESA(dev->instance, device,
pGetFdInfo->semaphore);
vn_sync_payload_release(dev, &sem->temporary);
sem->payload = &sem->permanent;