xgl: Rename XGL_QUEUE_SEMAPHORE to XGL_SEMAPHORE
bug #13473
header: r29790 (0.63.0)
diff --git a/include/xgl.h b/include/xgl.h
index 7954643..8e7aa16 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -33,7 +33,7 @@
#include "xglPlatform.h"
// XGL API version supported by this file
-#define XGL_API_VERSION XGL_MAKE_VERSION(0, 62, 1)
+#define XGL_API_VERSION XGL_MAKE_VERSION(0, 63, 0)
#ifdef __cplusplus
extern "C"
@@ -80,7 +80,7 @@
XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_CMD_BUFFER, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_FENCE, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE_SEMAPHORE, XGL_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_SEMAPHORE, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_EVENT, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUERY_POOL, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_FRAMEBUFFER, XGL_OBJECT)
@@ -1024,8 +1024,8 @@
XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
- XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO = 23,
- XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO = 24,
+ XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23,
+ XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24,
XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
@@ -2163,20 +2163,20 @@
XGL_FLAGS flags; // Reserved
} XGL_FENCE_CREATE_INFO;
-typedef struct _XGL_QUEUE_SEMAPHORE_CREATE_INFO
+typedef struct _XGL_SEMAPHORE_CREATE_INFO
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
const void* pNext; // Pointer to next structure
uint32_t initialCount;
XGL_FLAGS flags; // XGL_SEMAPHORE_CREATE_FLAGS
-} XGL_QUEUE_SEMAPHORE_CREATE_INFO;
+} XGL_SEMAPHORE_CREATE_INFO;
-typedef struct _XGL_QUEUE_SEMAPHORE_OPEN_INFO
+typedef struct _XGL_SEMAPHORE_OPEN_INFO
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
const void* pNext; // Pointer to next structure
- XGL_QUEUE_SEMAPHORE sharedSemaphore;
-} XGL_QUEUE_SEMAPHORE_OPEN_INFO;
+ XGL_SEMAPHORE sharedSemaphore;
+} XGL_SEMAPHORE_OPEN_INFO;
typedef struct _XGL_PIPELINE_STATISTICS_DATA
{
@@ -2264,7 +2264,7 @@
typedef XGL_RESULT (XGLAPI *xglPinSystemMemoryType)(XGL_DEVICE device, const void* pSysMem, size_t memSize, XGL_GPU_MEMORY* pMem);
typedef XGL_RESULT (XGLAPI *xglGetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo);
typedef XGL_RESULT (XGLAPI *xglOpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglOpenSharedQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
+typedef XGL_RESULT (XGLAPI *xglOpenSharedSemaphoreType)(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore);
typedef XGL_RESULT (XGLAPI *xglOpenPeerMemoryType)(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
typedef XGL_RESULT (XGLAPI *xglOpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
typedef XGL_RESULT (XGLAPI *xglDestroyObjectType)(XGL_OBJECT object);
@@ -2275,9 +2275,9 @@
typedef XGL_RESULT (XGLAPI *xglCreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence);
typedef XGL_RESULT (XGLAPI *xglGetFenceStatusType)(XGL_FENCE fence);
typedef XGL_RESULT (XGLAPI *xglWaitForFencesType)(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout);
-typedef XGL_RESULT (XGLAPI *xglCreateQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
-typedef XGL_RESULT (XGLAPI *xglSignalQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
-typedef XGL_RESULT (XGLAPI *xglWaitQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
+typedef XGL_RESULT (XGLAPI *xglCreateSemaphoreType)(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore);
+typedef XGL_RESULT (XGLAPI *xglQueueSignalSemaphoreType)(XGL_QUEUE queue, XGL_SEMAPHORE semaphore);
+typedef XGL_RESULT (XGLAPI *xglQueueWaitSemaphoreType)(XGL_QUEUE queue, XGL_SEMAPHORE semaphore);
typedef XGL_RESULT (XGLAPI *xglCreateEventType)(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent);
typedef XGL_RESULT (XGLAPI *xglGetEventStatusType)(XGL_EVENT event);
typedef XGL_RESULT (XGLAPI *xglSetEventType)(XGL_EVENT event);
@@ -2475,10 +2475,10 @@
const XGL_MEMORY_OPEN_INFO* pOpenInfo,
XGL_GPU_MEMORY* pMem);
-XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
+XGL_RESULT XGLAPI xglOpenSharedSemaphore(
XGL_DEVICE device,
- const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
- XGL_QUEUE_SEMAPHORE* pSemaphore);
+ const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ XGL_SEMAPHORE* pSemaphore);
XGL_RESULT XGLAPI xglOpenPeerMemory(
XGL_DEVICE device,
@@ -2542,18 +2542,18 @@
// Queue semaphore functions
-XGL_RESULT XGLAPI xglCreateQueueSemaphore(
+XGL_RESULT XGLAPI xglCreateSemaphore(
XGL_DEVICE device,
- const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
- XGL_QUEUE_SEMAPHORE* pSemaphore);
+ const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ XGL_SEMAPHORE* pSemaphore);
-XGL_RESULT XGLAPI xglSignalQueueSemaphore(
+XGL_RESULT XGLAPI xglQueueSignalSemaphore(
XGL_QUEUE queue,
- XGL_QUEUE_SEMAPHORE semaphore);
+ XGL_SEMAPHORE semaphore);
-XGL_RESULT XGLAPI xglWaitQueueSemaphore(
+XGL_RESULT XGLAPI xglQueueWaitSemaphore(
XGL_QUEUE queue,
- XGL_QUEUE_SEMAPHORE semaphore);
+ XGL_SEMAPHORE semaphore);
// Event functions
diff --git a/include/xglDbg.h b/include/xglDbg.h
index d589dbe..be63828 100644
--- a/include/xglDbg.h
+++ b/include/xglDbg.h
@@ -75,11 +75,11 @@
XGL_DBG_OBJECT_DEPTH_STENCIL_STATE = 0x11,
XGL_DBG_OBJECT_CMD_BUFFER = 0x12,
XGL_DBG_OBJECT_FENCE = 0x13,
- XGL_DBG_OBJECT_QUEUE_SEMAPHORE = 0x14,
+ XGL_DBG_OBJECT_SEMAPHORE = 0x14,
XGL_DBG_OBJECT_EVENT = 0x15,
XGL_DBG_OBJECT_QUERY_POOL = 0x16,
XGL_DBG_OBJECT_SHARED_GPU_MEMORY = 0x17,
- XGL_DBG_OBJECT_SHARED_QUEUE_SEMAPHORE = 0x18,
+ XGL_DBG_OBJECT_SHARED_SEMAPHORE = 0x18,
XGL_DBG_OBJECT_PEER_GPU_MEMORY = 0x19,
XGL_DBG_OBJECT_PEER_IMAGE = 0x1a,
XGL_DBG_OBJECT_PINNED_GPU_MEMORY = 0x1b,
diff --git a/include/xglLayer.h b/include/xglLayer.h
index 74eaa40..5a25ca0 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -49,7 +49,7 @@
xglPinSystemMemoryType PinSystemMemory;
xglGetMultiGpuCompatibilityType GetMultiGpuCompatibility;
xglOpenSharedMemoryType OpenSharedMemory;
- xglOpenSharedQueueSemaphoreType OpenSharedQueueSemaphore;
+ xglOpenSharedSemaphoreType OpenSharedSemaphore;
xglOpenPeerMemoryType OpenPeerMemory;
xglOpenPeerImageType OpenPeerImage;
xglDestroyObjectType DestroyObject;
@@ -60,9 +60,9 @@
xglCreateFenceType CreateFence;
xglGetFenceStatusType GetFenceStatus;
xglWaitForFencesType WaitForFences;
- xglCreateQueueSemaphoreType CreateQueueSemaphore;
- xglSignalQueueSemaphoreType SignalQueueSemaphore;
- xglWaitQueueSemaphoreType WaitQueueSemaphore;
+ xglCreateSemaphoreType CreateSemaphore;
+ xglQueueSignalSemaphoreType QueueSignalSemaphore;
+ xglQueueWaitSemaphoreType QueueWaitSemaphore;
xglCreateEventType CreateEvent;
xglGetEventStatusType GetEventStatus;
xglSetEventType SetEvent;
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index c1b127a..b80986b 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -708,12 +708,12 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_SEMAPHORE* pSemaphore)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.OpenSharedQueueSemaphore(device, pOpenInfo, pSemaphore);
+ XGL_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
return result;
}
@@ -815,12 +815,12 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueueSemaphore(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_QUEUE_SEMAPHORE* pSemaphore)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)device, XGL_OBJECT_TYPE_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
- XGL_RESULT result = nextTable.CreateQueueSemaphore(device, pCreateInfo, pSemaphore);
+ XGL_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore);
if (result == XGL_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
@@ -831,15 +831,15 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSignalQueueSemaphore(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSignalSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
{
- XGL_RESULT result = nextTable.SignalQueueSemaphore(queue, semaphore);
+ XGL_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitQueueSemaphore(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitSemaphore(XGL_QUEUE queue, XGL_SEMAPHORE semaphore)
{
- XGL_RESULT result = nextTable.WaitQueueSemaphore(queue, semaphore);
+ XGL_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore);
return result;
}
diff --git a/layers/object_track.h b/layers/object_track.h
index 9c224c5..e9b3eb7 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -64,7 +64,7 @@
XGL_OBJECT_TYPE_DESCRIPTOR_REGION,
XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
XGL_OBJECT_TYPE_IMAGE_VIEW,
- XGL_OBJECT_TYPE_QUEUE_SEMAPHORE,
+ XGL_OBJECT_TYPE_SEMAPHORE,
XGL_OBJECT_TYPE_SHADER,
XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
XGL_OBJECT_TYPE_BUFFER,
@@ -113,8 +113,8 @@
return "IMAGE";
case XGL_OBJECT_TYPE_CMD_BUFFER:
return "CMD_BUFFER";
- case XGL_OBJECT_TYPE_QUEUE_SEMAPHORE:
- return "QUEUE_SEMAPHORE";
+ case XGL_OBJECT_TYPE_SEMAPHORE:
+ return "SEMAPHORE";
case XGL_OBJECT_TYPE_FRAMEBUFFER:
return "FRAMEBUFFER";
case XGL_OBJECT_TYPE_SAMPLER:
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index 76c471b..f92faae 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -540,14 +540,14 @@
EXPECT(xglQueueWaitIdle(obj()) == XGL_SUCCESS);
}
-void Queue::signal_semaphore(QueueSemaphore &sem)
+void Queue::signal_semaphore(Semaphore &sem)
{
- EXPECT(xglSignalQueueSemaphore(obj(), sem.obj()) == XGL_SUCCESS);
+ EXPECT(xglQueueSignalSemaphore(obj(), sem.obj()) == XGL_SUCCESS);
}
-void Queue::wait_semaphore(QueueSemaphore &sem)
+void Queue::wait_semaphore(Semaphore &sem)
{
- EXPECT(xglWaitQueueSemaphore(obj(), sem.obj()) == XGL_SUCCESS);
+ EXPECT(xglQueueWaitSemaphore(obj(), sem.obj()) == XGL_SUCCESS);
}
GpuMemory::~GpuMemory()
@@ -610,15 +610,15 @@
alloc_memory(dev);
}
-void QueueSemaphore::init(const Device &dev, const XGL_QUEUE_SEMAPHORE_CREATE_INFO &info)
+void Semaphore::init(const Device &dev, const XGL_SEMAPHORE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateQueueSemaphore, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateSemaphore, dev.obj(), &info);
alloc_memory(dev);
}
-void QueueSemaphore::init(const Device &dev, const XGL_QUEUE_SEMAPHORE_OPEN_INFO &info)
+void Semaphore::init(const Device &dev, const XGL_SEMAPHORE_OPEN_INFO &info)
{
- DERIVED_OBJECT_INIT(xglOpenSharedQueueSemaphore, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglOpenSharedSemaphore, dev.obj(), &info);
}
void Event::init(const Device &dev, const XGL_EVENT_CREATE_INFO &info)
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index 0bb7706..023dcfb 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -40,7 +40,7 @@
class Queue;
class GpuMemory;
class Fence;
-class QueueSemaphore;
+class Semaphore;
class Event;
class QueryPool;
class Buffer;
@@ -264,10 +264,10 @@
// xglQueueWaitIdle()
void wait();
- // xglSignalQueueSemaphore()
- // xglWaitQueueSemaphore()
- void signal_semaphore(QueueSemaphore &sem);
- void wait_semaphore(QueueSemaphore &sem);
+ // xglQueueSignalSemaphore()
+ // xglQueueWaitSemaphore()
+ void signal_semaphore(Semaphore &sem);
+ void wait_semaphore(Semaphore &sem);
};
class GpuMemory : public DerivedObject<XGL_GPU_MEMORY, BaseObject> {
@@ -312,14 +312,14 @@
static XGL_FENCE_CREATE_INFO create_info(XGL_FLAGS flags);
};
-class QueueSemaphore : public DerivedObject<XGL_QUEUE_SEMAPHORE, Object> {
+class Semaphore : public DerivedObject<XGL_SEMAPHORE, Object> {
public:
- // xglCreateQueueSemaphore()
- void init(const Device &dev, const XGL_QUEUE_SEMAPHORE_CREATE_INFO &info);
- // xglOpenSharedQueueSemaphore()
- void init(const Device &dev, const XGL_QUEUE_SEMAPHORE_OPEN_INFO &info);
+ // xglCreateSemaphore()
+ void init(const Device &dev, const XGL_SEMAPHORE_CREATE_INFO &info);
+ // xglOpenSharedSemaphore()
+ void init(const Device &dev, const XGL_SEMAPHORE_OPEN_INFO &info);
- static XGL_QUEUE_SEMAPHORE_CREATE_INFO create_info(uint32_t init_count, XGL_FLAGS flags);
+ static XGL_SEMAPHORE_CREATE_INFO create_info(uint32_t init_count, XGL_FLAGS flags);
};
class Event : public DerivedObject<XGL_EVENT, Object> {
@@ -648,10 +648,10 @@
return info;
}
-inline XGL_QUEUE_SEMAPHORE_CREATE_INFO QueueSemaphore::create_info(uint32_t init_count, XGL_FLAGS flags)
+inline XGL_SEMAPHORE_CREATE_INFO Semaphore::create_info(uint32_t init_count, XGL_FLAGS flags)
{
- XGL_QUEUE_SEMAPHORE_CREATE_INFO info = {};
- info.sType = XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO;
+ XGL_SEMAPHORE_CREATE_INFO info = {};
+ info.sType = XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
info.initialCount = init_count;
info.flags = flags;
return info;
diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py
index 98a62ce..33b1683 100755
--- a/xgl-layer-generate.py
+++ b/xgl-layer-generate.py
@@ -630,7 +630,7 @@
using_line += ' g_debugAction &= ~XGL_DBG_LAYER_ACTION_CALLBACK;\n'
using_line += ' }\n'
# Special cases for API funcs that don't use an object as first arg
- elif True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueSetGlobalMemReferences', 'QueueWaitIdle', 'CreateDevice', 'GetGpuInfo', 'SignalQueueSemaphore', 'WaitQueueSemaphore', 'WsiX11QueuePresent']]:
+ elif True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueSetGlobalMemReferences', 'QueueWaitIdle', 'CreateDevice', 'GetGpuInfo', 'QueueSignalSemaphore', 'QueueWaitSemaphore', 'WsiX11QueuePresent']]:
using_line = ''
else:
using_line = ' loader_platform_thread_lock_mutex(&objLock);\n'
diff --git a/xgl.py b/xgl.py
index c5988ee..b150b17 100644
--- a/xgl.py
+++ b/xgl.py
@@ -209,7 +209,7 @@
"XGL_DYNAMIC_DS_STATE_OBJECT",
"XGL_CMD_BUFFER",
"XGL_FENCE",
- "XGL_QUEUE_SEMAPHORE",
+ "XGL_SEMAPHORE",
"XGL_EVENT",
"XGL_QUERY_POOL",
"XGL_FRAMEBUFFER",
@@ -321,10 +321,10 @@
Param("const XGL_MEMORY_OPEN_INFO*", "pOpenInfo"),
Param("XGL_GPU_MEMORY*", "pMem")]),
- Proto("XGL_RESULT", "OpenSharedQueueSemaphore",
+ Proto("XGL_RESULT", "OpenSharedSemaphore",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_QUEUE_SEMAPHORE_OPEN_INFO*", "pOpenInfo"),
- Param("XGL_QUEUE_SEMAPHORE*", "pSemaphore")]),
+ Param("const XGL_SEMAPHORE_OPEN_INFO*", "pOpenInfo"),
+ Param("XGL_SEMAPHORE*", "pSemaphore")]),
Proto("XGL_RESULT", "OpenPeerMemory",
[Param("XGL_DEVICE", "device"),
@@ -382,18 +382,18 @@
Param("bool32_t", "waitAll"),
Param("uint64_t", "timeout")]),
- Proto("XGL_RESULT", "CreateQueueSemaphore",
+ Proto("XGL_RESULT", "CreateSemaphore",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_QUEUE_SEMAPHORE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_QUEUE_SEMAPHORE*", "pSemaphore")]),
+ Param("const XGL_SEMAPHORE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_SEMAPHORE*", "pSemaphore")]),
- Proto("XGL_RESULT", "SignalQueueSemaphore",
+ Proto("XGL_RESULT", "QueueSignalSemaphore",
[Param("XGL_QUEUE", "queue"),
- Param("XGL_QUEUE_SEMAPHORE", "semaphore")]),
+ Param("XGL_SEMAPHORE", "semaphore")]),
- Proto("XGL_RESULT", "WaitQueueSemaphore",
+ Proto("XGL_RESULT", "QueueWaitSemaphore",
[Param("XGL_QUEUE", "queue"),
- Param("XGL_QUEUE_SEMAPHORE", "semaphore")]),
+ Param("XGL_SEMAPHORE", "semaphore")]),
Proto("XGL_RESULT", "CreateEvent",
[Param("XGL_DEVICE", "device"),
@@ -928,7 +928,7 @@
"XGL_DYNAMIC_STATE_OBJECT",
"XGL_CMD_BUFFER",
"XGL_FENCE",
- "XGL_QUEUE_SEMAPHORE",
+ "XGL_SEMAPHORE",
"XGL_EVENT",
"XGL_QUERY_POOL",
"XGL_FRAMEBUFFER",
diff --git a/xgl_helper.py b/xgl_helper.py
index 14f1902..9a52e33 100755
--- a/xgl_helper.py
+++ b/xgl_helper.py
@@ -1502,10 +1502,10 @@
#if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
# struct_name = 'XGL_PIPELINE_CB_STATE'
if 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
- struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO'
+ struct_name = 'XGL_SEMAPHORE_CREATE_INFO'
print_func_name = self._get_gv_func_name(struct_name)
elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name:
- struct_name = 'XGL_QUEUE_SEMAPHORE_OPEN_INFO'
+ struct_name = 'XGL_SEMAPHORE_OPEN_INFO'
print_func_name = self._get_gv_func_name(struct_name)
gv_funcs.append(' case %s:\n' % (v))
gv_funcs.append(' return %s((%s*)pStruct, nodeName);\n' % (print_func_name, struct_name))