1
/* This file is generated by venus-protocol. See vn_protocol_driver.h. */
4
* Copyright 2020 Google LLC
5
* SPDX-License-Identifier: MIT
8
#ifndef VN_PROTOCOL_DRIVER_SEMAPHORE_H
9
#define VN_PROTOCOL_DRIVER_SEMAPHORE_H
11
#include "vn_instance.h"
12
#include "vn_protocol_driver_structs.h"
14
/* struct VkExportSemaphoreCreateInfo chain */
17
vn_sizeof_VkExportSemaphoreCreateInfo_pnext(const void *val)
19
/* no known/supported struct */
20
return vn_sizeof_simple_pointer(NULL);
24
vn_sizeof_VkExportSemaphoreCreateInfo_self(const VkExportSemaphoreCreateInfo *val)
27
/* skip val->{sType,pNext} */
28
size += vn_sizeof_VkFlags(&val->handleTypes);
33
vn_sizeof_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo *val)
37
size += vn_sizeof_VkStructureType(&val->sType);
38
size += vn_sizeof_VkExportSemaphoreCreateInfo_pnext(val->pNext);
39
size += vn_sizeof_VkExportSemaphoreCreateInfo_self(val);
45
vn_encode_VkExportSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
47
/* no known/supported struct */
48
vn_encode_simple_pointer(enc, NULL);
52
vn_encode_VkExportSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
54
/* skip val->{sType,pNext} */
55
vn_encode_VkFlags(enc, &val->handleTypes);
59
vn_encode_VkExportSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
61
assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO);
62
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO });
63
vn_encode_VkExportSemaphoreCreateInfo_pnext(enc, val->pNext);
64
vn_encode_VkExportSemaphoreCreateInfo_self(enc, val);
67
/* struct VkSemaphoreCreateInfo chain */
70
vn_sizeof_VkSemaphoreCreateInfo_pnext(const void *val)
72
const VkBaseInStructure *pnext = val;
76
switch ((int32_t)pnext->sType) {
77
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
78
size += vn_sizeof_simple_pointer(pnext);
79
size += vn_sizeof_VkStructureType(&pnext->sType);
80
size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
81
size += vn_sizeof_VkExportSemaphoreCreateInfo_self((const VkExportSemaphoreCreateInfo *)pnext);
83
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
84
size += vn_sizeof_simple_pointer(pnext);
85
size += vn_sizeof_VkStructureType(&pnext->sType);
86
size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
87
size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
90
/* ignore unknown/unsupported struct */
96
return vn_sizeof_simple_pointer(NULL);
100
vn_sizeof_VkSemaphoreCreateInfo_self(const VkSemaphoreCreateInfo *val)
103
/* skip val->{sType,pNext} */
104
size += vn_sizeof_VkFlags(&val->flags);
109
vn_sizeof_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo *val)
113
size += vn_sizeof_VkStructureType(&val->sType);
114
size += vn_sizeof_VkSemaphoreCreateInfo_pnext(val->pNext);
115
size += vn_sizeof_VkSemaphoreCreateInfo_self(val);
121
vn_encode_VkSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
123
const VkBaseInStructure *pnext = val;
126
switch ((int32_t)pnext->sType) {
127
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
128
vn_encode_simple_pointer(enc, pnext);
129
vn_encode_VkStructureType(enc, &pnext->sType);
130
vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
131
vn_encode_VkExportSemaphoreCreateInfo_self(enc, (const VkExportSemaphoreCreateInfo *)pnext);
133
case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
134
vn_encode_simple_pointer(enc, pnext);
135
vn_encode_VkStructureType(enc, &pnext->sType);
136
vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
137
vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
140
/* ignore unknown/unsupported struct */
143
pnext = pnext->pNext;
146
vn_encode_simple_pointer(enc, NULL);
150
vn_encode_VkSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
152
/* skip val->{sType,pNext} */
153
vn_encode_VkFlags(enc, &val->flags);
157
vn_encode_VkSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
159
assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
160
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO });
161
vn_encode_VkSemaphoreCreateInfo_pnext(enc, val->pNext);
162
vn_encode_VkSemaphoreCreateInfo_self(enc, val);
165
/* struct VkSemaphoreWaitInfo chain */
168
vn_sizeof_VkSemaphoreWaitInfo_pnext(const void *val)
170
/* no known/supported struct */
171
return vn_sizeof_simple_pointer(NULL);
175
vn_sizeof_VkSemaphoreWaitInfo_self(const VkSemaphoreWaitInfo *val)
178
/* skip val->{sType,pNext} */
179
size += vn_sizeof_VkFlags(&val->flags);
180
size += vn_sizeof_uint32_t(&val->semaphoreCount);
181
if (val->pSemaphores) {
182
size += vn_sizeof_array_size(val->semaphoreCount);
183
for (uint32_t i = 0; i < val->semaphoreCount; i++)
184
size += vn_sizeof_VkSemaphore(&val->pSemaphores[i]);
186
size += vn_sizeof_array_size(0);
189
size += vn_sizeof_array_size(val->semaphoreCount);
190
size += vn_sizeof_uint64_t_array(val->pValues, val->semaphoreCount);
192
size += vn_sizeof_array_size(0);
198
vn_sizeof_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo *val)
202
size += vn_sizeof_VkStructureType(&val->sType);
203
size += vn_sizeof_VkSemaphoreWaitInfo_pnext(val->pNext);
204
size += vn_sizeof_VkSemaphoreWaitInfo_self(val);
210
vn_encode_VkSemaphoreWaitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
212
/* no known/supported struct */
213
vn_encode_simple_pointer(enc, NULL);
217
vn_encode_VkSemaphoreWaitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
219
/* skip val->{sType,pNext} */
220
vn_encode_VkFlags(enc, &val->flags);
221
vn_encode_uint32_t(enc, &val->semaphoreCount);
222
if (val->pSemaphores) {
223
vn_encode_array_size(enc, val->semaphoreCount);
224
for (uint32_t i = 0; i < val->semaphoreCount; i++)
225
vn_encode_VkSemaphore(enc, &val->pSemaphores[i]);
227
vn_encode_array_size(enc, 0);
230
vn_encode_array_size(enc, val->semaphoreCount);
231
vn_encode_uint64_t_array(enc, val->pValues, val->semaphoreCount);
233
vn_encode_array_size(enc, 0);
238
vn_encode_VkSemaphoreWaitInfo(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
240
assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO);
241
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO });
242
vn_encode_VkSemaphoreWaitInfo_pnext(enc, val->pNext);
243
vn_encode_VkSemaphoreWaitInfo_self(enc, val);
246
/* struct VkSemaphoreSignalInfo chain */
249
vn_sizeof_VkSemaphoreSignalInfo_pnext(const void *val)
251
/* no known/supported struct */
252
return vn_sizeof_simple_pointer(NULL);
256
vn_sizeof_VkSemaphoreSignalInfo_self(const VkSemaphoreSignalInfo *val)
259
/* skip val->{sType,pNext} */
260
size += vn_sizeof_VkSemaphore(&val->semaphore);
261
size += vn_sizeof_uint64_t(&val->value);
266
vn_sizeof_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo *val)
270
size += vn_sizeof_VkStructureType(&val->sType);
271
size += vn_sizeof_VkSemaphoreSignalInfo_pnext(val->pNext);
272
size += vn_sizeof_VkSemaphoreSignalInfo_self(val);
278
vn_encode_VkSemaphoreSignalInfo_pnext(struct vn_cs_encoder *enc, const void *val)
280
/* no known/supported struct */
281
vn_encode_simple_pointer(enc, NULL);
285
vn_encode_VkSemaphoreSignalInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
287
/* skip val->{sType,pNext} */
288
vn_encode_VkSemaphore(enc, &val->semaphore);
289
vn_encode_uint64_t(enc, &val->value);
293
vn_encode_VkSemaphoreSignalInfo(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
295
assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
296
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO });
297
vn_encode_VkSemaphoreSignalInfo_pnext(enc, val->pNext);
298
vn_encode_VkSemaphoreSignalInfo_self(enc, val);
301
static inline size_t vn_sizeof_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
303
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
304
const VkFlags cmd_flags = 0;
305
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
307
cmd_size += vn_sizeof_VkDevice(&device);
308
cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
310
cmd_size += vn_sizeof_VkSemaphoreCreateInfo(pCreateInfo);
311
cmd_size += vn_sizeof_simple_pointer(pAllocator);
314
cmd_size += vn_sizeof_simple_pointer(pSemaphore);
316
cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
321
static inline void vn_encode_vkCreateSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
323
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
325
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
326
vn_encode_VkFlags(enc, &cmd_flags);
328
vn_encode_VkDevice(enc, &device);
329
if (vn_encode_simple_pointer(enc, pCreateInfo))
330
vn_encode_VkSemaphoreCreateInfo(enc, pCreateInfo);
331
if (vn_encode_simple_pointer(enc, pAllocator))
333
if (vn_encode_simple_pointer(enc, pSemaphore))
334
vn_encode_VkSemaphore(enc, pSemaphore);
337
static inline size_t vn_sizeof_vkCreateSemaphore_reply(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
339
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
340
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
343
cmd_size += vn_sizeof_VkResult(&ret);
345
/* skip pCreateInfo */
346
/* skip pAllocator */
347
cmd_size += vn_sizeof_simple_pointer(pSemaphore);
349
cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
354
static inline VkResult vn_decode_vkCreateSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
356
VkCommandTypeEXT command_type;
357
vn_decode_VkCommandTypeEXT(dec, &command_type);
358
assert(command_type == VK_COMMAND_TYPE_vkCreateSemaphore_EXT);
361
vn_decode_VkResult(dec, &ret);
363
/* skip pCreateInfo */
364
/* skip pAllocator */
365
if (vn_decode_simple_pointer(dec)) {
366
vn_decode_VkSemaphore(dec, pSemaphore);
374
static inline size_t vn_sizeof_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
376
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
377
const VkFlags cmd_flags = 0;
378
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
380
cmd_size += vn_sizeof_VkDevice(&device);
381
cmd_size += vn_sizeof_VkSemaphore(&semaphore);
382
cmd_size += vn_sizeof_simple_pointer(pAllocator);
389
static inline void vn_encode_vkDestroySemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
391
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
393
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
394
vn_encode_VkFlags(enc, &cmd_flags);
396
vn_encode_VkDevice(enc, &device);
397
vn_encode_VkSemaphore(enc, &semaphore);
398
if (vn_encode_simple_pointer(enc, pAllocator))
402
static inline size_t vn_sizeof_vkDestroySemaphore_reply(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
404
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
405
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
409
/* skip pAllocator */
414
static inline void vn_decode_vkDestroySemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
416
VkCommandTypeEXT command_type;
417
vn_decode_VkCommandTypeEXT(dec, &command_type);
418
assert(command_type == VK_COMMAND_TYPE_vkDestroySemaphore_EXT);
422
/* skip pAllocator */
425
static inline size_t vn_sizeof_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
427
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
428
const VkFlags cmd_flags = 0;
429
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
431
cmd_size += vn_sizeof_VkDevice(&device);
432
cmd_size += vn_sizeof_VkSemaphore(&semaphore);
433
cmd_size += vn_sizeof_simple_pointer(pValue); /* out */
438
static inline void vn_encode_vkGetSemaphoreCounterValue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
440
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
442
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
443
vn_encode_VkFlags(enc, &cmd_flags);
445
vn_encode_VkDevice(enc, &device);
446
vn_encode_VkSemaphore(enc, &semaphore);
447
vn_encode_simple_pointer(enc, pValue); /* out */
450
static inline size_t vn_sizeof_vkGetSemaphoreCounterValue_reply(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
452
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
453
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
456
cmd_size += vn_sizeof_VkResult(&ret);
459
cmd_size += vn_sizeof_simple_pointer(pValue);
461
cmd_size += vn_sizeof_uint64_t(pValue);
466
static inline VkResult vn_decode_vkGetSemaphoreCounterValue_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
468
VkCommandTypeEXT command_type;
469
vn_decode_VkCommandTypeEXT(dec, &command_type);
470
assert(command_type == VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT);
473
vn_decode_VkResult(dec, &ret);
476
if (vn_decode_simple_pointer(dec)) {
477
vn_decode_uint64_t(dec, pValue);
485
static inline size_t vn_sizeof_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
487
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
488
const VkFlags cmd_flags = 0;
489
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
491
cmd_size += vn_sizeof_VkDevice(&device);
492
cmd_size += vn_sizeof_simple_pointer(pWaitInfo);
494
cmd_size += vn_sizeof_VkSemaphoreWaitInfo(pWaitInfo);
495
cmd_size += vn_sizeof_uint64_t(&timeout);
500
static inline void vn_encode_vkWaitSemaphores(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
502
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
504
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
505
vn_encode_VkFlags(enc, &cmd_flags);
507
vn_encode_VkDevice(enc, &device);
508
if (vn_encode_simple_pointer(enc, pWaitInfo))
509
vn_encode_VkSemaphoreWaitInfo(enc, pWaitInfo);
510
vn_encode_uint64_t(enc, &timeout);
513
static inline size_t vn_sizeof_vkWaitSemaphores_reply(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
515
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
516
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
519
cmd_size += vn_sizeof_VkResult(&ret);
527
static inline VkResult vn_decode_vkWaitSemaphores_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
529
VkCommandTypeEXT command_type;
530
vn_decode_VkCommandTypeEXT(dec, &command_type);
531
assert(command_type == VK_COMMAND_TYPE_vkWaitSemaphores_EXT);
534
vn_decode_VkResult(dec, &ret);
542
static inline size_t vn_sizeof_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
544
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
545
const VkFlags cmd_flags = 0;
546
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
548
cmd_size += vn_sizeof_VkDevice(&device);
549
cmd_size += vn_sizeof_simple_pointer(pSignalInfo);
551
cmd_size += vn_sizeof_VkSemaphoreSignalInfo(pSignalInfo);
556
static inline void vn_encode_vkSignalSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
558
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
560
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
561
vn_encode_VkFlags(enc, &cmd_flags);
563
vn_encode_VkDevice(enc, &device);
564
if (vn_encode_simple_pointer(enc, pSignalInfo))
565
vn_encode_VkSemaphoreSignalInfo(enc, pSignalInfo);
568
static inline size_t vn_sizeof_vkSignalSemaphore_reply(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
570
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
571
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
574
cmd_size += vn_sizeof_VkResult(&ret);
576
/* skip pSignalInfo */
581
static inline VkResult vn_decode_vkSignalSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
583
VkCommandTypeEXT command_type;
584
vn_decode_VkCommandTypeEXT(dec, &command_type);
585
assert(command_type == VK_COMMAND_TYPE_vkSignalSemaphore_EXT);
588
vn_decode_VkResult(dec, &ret);
590
/* skip pSignalInfo */
595
static inline void vn_submit_vkCreateSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, struct vn_instance_submit_command *submit)
597
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
598
void *cmd_data = local_cmd_data;
599
size_t cmd_size = vn_sizeof_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
600
if (cmd_size > sizeof(local_cmd_data)) {
601
cmd_data = malloc(cmd_size);
605
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSemaphore_reply(device, pCreateInfo, pAllocator, pSemaphore) : 0;
607
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
609
vn_encode_vkCreateSemaphore(enc, cmd_flags, device, pCreateInfo, pAllocator, pSemaphore);
610
vn_instance_submit_command(vn_instance, submit);
611
if (cmd_data != local_cmd_data)
616
static inline void vn_submit_vkDestroySemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
618
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
619
void *cmd_data = local_cmd_data;
620
size_t cmd_size = vn_sizeof_vkDestroySemaphore(device, semaphore, pAllocator);
621
if (cmd_size > sizeof(local_cmd_data)) {
622
cmd_data = malloc(cmd_size);
626
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySemaphore_reply(device, semaphore, pAllocator) : 0;
628
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
630
vn_encode_vkDestroySemaphore(enc, cmd_flags, device, semaphore, pAllocator);
631
vn_instance_submit_command(vn_instance, submit);
632
if (cmd_data != local_cmd_data)
637
static inline void vn_submit_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, struct vn_instance_submit_command *submit)
639
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
640
void *cmd_data = local_cmd_data;
641
size_t cmd_size = vn_sizeof_vkGetSemaphoreCounterValue(device, semaphore, pValue);
642
if (cmd_size > sizeof(local_cmd_data)) {
643
cmd_data = malloc(cmd_size);
647
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetSemaphoreCounterValue_reply(device, semaphore, pValue) : 0;
649
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
651
vn_encode_vkGetSemaphoreCounterValue(enc, cmd_flags, device, semaphore, pValue);
652
vn_instance_submit_command(vn_instance, submit);
653
if (cmd_data != local_cmd_data)
658
static inline void vn_submit_vkWaitSemaphores(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, struct vn_instance_submit_command *submit)
660
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
661
void *cmd_data = local_cmd_data;
662
size_t cmd_size = vn_sizeof_vkWaitSemaphores(device, pWaitInfo, timeout);
663
if (cmd_size > sizeof(local_cmd_data)) {
664
cmd_data = malloc(cmd_size);
668
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphores_reply(device, pWaitInfo, timeout) : 0;
670
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
672
vn_encode_vkWaitSemaphores(enc, cmd_flags, device, pWaitInfo, timeout);
673
vn_instance_submit_command(vn_instance, submit);
674
if (cmd_data != local_cmd_data)
679
static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, struct vn_instance_submit_command *submit)
681
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
682
void *cmd_data = local_cmd_data;
683
size_t cmd_size = vn_sizeof_vkSignalSemaphore(device, pSignalInfo);
684
if (cmd_size > sizeof(local_cmd_data)) {
685
cmd_data = malloc(cmd_size);
689
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSignalSemaphore_reply(device, pSignalInfo) : 0;
691
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
693
vn_encode_vkSignalSemaphore(enc, cmd_flags, device, pSignalInfo);
694
vn_instance_submit_command(vn_instance, submit);
695
if (cmd_data != local_cmd_data)
700
static inline VkResult vn_call_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
704
struct vn_instance_submit_command submit;
705
vn_submit_vkCreateSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSemaphore, &submit);
706
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
708
const VkResult ret = vn_decode_vkCreateSemaphore_reply(dec, device, pCreateInfo, pAllocator, pSemaphore);
709
vn_instance_free_command_reply(vn_instance, &submit);
712
return VK_ERROR_OUT_OF_HOST_MEMORY;
716
static inline void vn_async_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
718
struct vn_instance_submit_command submit;
719
vn_submit_vkCreateSemaphore(vn_instance, 0, device, pCreateInfo, pAllocator, pSemaphore, &submit);
722
static inline void vn_call_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
726
struct vn_instance_submit_command submit;
727
vn_submit_vkDestroySemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pAllocator, &submit);
728
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
730
vn_decode_vkDestroySemaphore_reply(dec, device, semaphore, pAllocator);
731
vn_instance_free_command_reply(vn_instance, &submit);
735
static inline void vn_async_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
737
struct vn_instance_submit_command submit;
738
vn_submit_vkDestroySemaphore(vn_instance, 0, device, semaphore, pAllocator, &submit);
741
static inline VkResult vn_call_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
745
struct vn_instance_submit_command submit;
746
vn_submit_vkGetSemaphoreCounterValue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pValue, &submit);
747
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
749
const VkResult ret = vn_decode_vkGetSemaphoreCounterValue_reply(dec, device, semaphore, pValue);
750
vn_instance_free_command_reply(vn_instance, &submit);
753
return VK_ERROR_OUT_OF_HOST_MEMORY;
757
static inline void vn_async_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
759
struct vn_instance_submit_command submit;
760
vn_submit_vkGetSemaphoreCounterValue(vn_instance, 0, device, semaphore, pValue, &submit);
763
static inline VkResult vn_call_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
767
struct vn_instance_submit_command submit;
768
vn_submit_vkWaitSemaphores(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pWaitInfo, timeout, &submit);
769
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
771
const VkResult ret = vn_decode_vkWaitSemaphores_reply(dec, device, pWaitInfo, timeout);
772
vn_instance_free_command_reply(vn_instance, &submit);
775
return VK_ERROR_OUT_OF_HOST_MEMORY;
779
static inline void vn_async_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
781
struct vn_instance_submit_command submit;
782
vn_submit_vkWaitSemaphores(vn_instance, 0, device, pWaitInfo, timeout, &submit);
785
static inline VkResult vn_call_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
789
struct vn_instance_submit_command submit;
790
vn_submit_vkSignalSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pSignalInfo, &submit);
791
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
793
const VkResult ret = vn_decode_vkSignalSemaphore_reply(dec, device, pSignalInfo);
794
vn_instance_free_command_reply(vn_instance, &submit);
797
return VK_ERROR_OUT_OF_HOST_MEMORY;
801
static inline void vn_async_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
803
struct vn_instance_submit_command submit;
804
vn_submit_vkSignalSemaphore(vn_instance, 0, device, pSignalInfo, &submit);
807
#endif /* VN_PROTOCOL_DRIVER_SEMAPHORE_H */
added
removed
src/virtio/venus-protocol/vn_protocol_driver_semaphore.h
