From c27ec8ea668bdd9e8139842cc8a0decb8666e469 Mon Sep 17 00:00:00 2001 From: Mark Lobodzinski Date: Tue, 7 Apr 2015 16:07:57 -0500 Subject: Updated header file to version 67 (xglResetFences) Added changes to fence semantics for this revision. tests: Create contructor with no args intel: Added Tony's patch for ResetFences support in the ICD. v2: reset fence in intel_fence_seq_seqno(). We need the reset to make xglQueueWaitIdle() work (olv) layers: Added ResetFences support to MemTracker Add new entrypoint and fence semantics for fence status flags. layers: Completed changed fence semantics for MemTracker Completed the changes for xgl header revision 67, adding resetFences. layers: Changes to support xglResetFences v2: squashed into one commit (olv) --- include/xgl.h | 20 +++++++-- include/xglLayer.h | 1 + layers/mem_tracker.cpp | 106 ++++++++++++++++++++++++++++++++--------------- layers/mem_tracker.h | 1 + layers/param_checker.cpp | 7 ++++ xgl.py | 5 +++ 6 files changed, 102 insertions(+), 38 deletions(-) diff --git a/include/xgl.h b/include/xgl.h index 5857b427..92fb1ccb 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, 65, 0) +#define XGL_API_VERSION XGL_MAKE_VERSION(0, 67, 0) #ifdef __cplusplus extern "C" @@ -1220,6 +1220,13 @@ typedef enum _XGL_PIPELINE_CREATE_FLAGS XGL_MAX_ENUM(_XGL_PIPELINE_CREATE_FLAGS) } XGL_PIPELINE_CREATE_FLAGS; +// Fence creation flags +typedef enum _XGL_FENCE_CREATE_FLAGS +{ + XGL_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + XGL_MAX_ENUM(_XGL_FENCE_CREATE_FLAGS) +} XGL_FENCE_CREATE_FLAGS; + // Semaphore creation flags typedef enum _XGL_SEMAPHORE_CREATE_FLAGS { @@ -1877,8 +1884,7 @@ typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO const void* pNext; // Pointer to next structure XGL_PIPELINE_SHADER cs; XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS - XGL_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; - // For local size fields zero is treated an invalid value + XGL_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; // For local size fields zero is treated an invalid value uint32_t localSizeX; uint32_t localSizeY; uint32_t localSizeZ; @@ -2164,7 +2170,7 @@ typedef struct _XGL_FENCE_CREATE_INFO { XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO const void* pNext; // Pointer to next structure - XGL_FLAGS flags; // Reserved + XGL_FENCE_CREATE_FLAGS flags; // XGL_FENCE_CREATE_FLAGS } XGL_FENCE_CREATE_INFO; typedef struct _XGL_SEMAPHORE_CREATE_INFO @@ -2278,6 +2284,7 @@ typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, uint32_t typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, uint32_t allocationIdx, XGL_GPU_SIZE rangeOffset,XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset); typedef XGL_RESULT (XGLAPI *xglBindImageMemoryRangeType)(XGL_IMAGE image, uint32_t allocationIdx, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset); typedef XGL_RESULT (XGLAPI *xglCreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence); +typedef XGL_RESULT (XGLAPI *xglResetFencesType)(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences); 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 *xglCreateSemaphoreType)(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore); @@ -2537,6 +2544,11 @@ XGL_RESULT XGLAPI xglCreateFence( const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence); +XGL_RESULT XGLAPI xglResetFences( + XGL_DEVICE device, + uint32_t fenceCount, + XGL_FENCE* pFences); + XGL_RESULT XGLAPI xglGetFenceStatus( XGL_FENCE fence); diff --git a/include/xglLayer.h b/include/xglLayer.h index 897fe905..c3d63a6e 100644 --- a/include/xglLayer.h +++ b/include/xglLayer.h @@ -60,6 +60,7 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE xglBindImageMemoryRangeType BindImageMemoryRange; xglCreateFenceType CreateFence; xglGetFenceStatusType GetFenceStatus; + xglResetFencesType ResetFences; xglWaitForFencesType WaitForFences; xglCreateSemaphoreType CreateSemaphore; xglQueueSignalSemaphoreType QueueSignalSemaphore; diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index 83cff67c..a6bc088a 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -97,6 +97,32 @@ static MT_CB_INFO* getCBInfo(const XGL_CMD_BUFFER cb) return pCBInfo; } +// Return object info for 'object' or return NULL if no info exists +static MT_OBJ_INFO* getObjectInfo(const XGL_OBJECT object) +{ + MT_OBJ_INFO* pObjInfo = NULL; + + if (objectMap.find(object) != objectMap.end()) { + pObjInfo = objectMap[object]; + } + return pObjInfo; +} + +static MT_OBJ_INFO* addObjectInfo(XGL_OBJECT object, XGL_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix) +{ + MT_OBJ_INFO* pInfo = new MT_OBJ_INFO; + memset(pInfo, 0, sizeof(MT_OBJ_INFO)); + memcpy(&pInfo->create_info, pCreateInfo, struct_size); + sprintf(pInfo->object_name, "%s_%p", name_prefix, object); + + pInfo->object = object; + pInfo->ref_count = 1; + pInfo->sType = sType; + objectMap[object] = pInfo; + + return pInfo; +} + // Add a fence, creating one if necessary to our list of fences/fenceIds static uint64_t addFenceInfo(XGL_FENCE fence, XGL_QUEUE queue) { @@ -110,8 +136,9 @@ static uint64_t addFenceInfo(XGL_FENCE fence, XGL_QUEUE queue) XGL_FENCE_CREATE_INFO fci; fci.sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO; fci.pNext = NULL; - fci.flags = 0; + fci.flags = static_cast(0); nextTable.CreateFence(globalDevice, &fci, &pFenceInfo->fence); + addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(XGL_FENCE_CREATE_INFO), "internalFence"); pFenceInfo->localFence = XGL_TRUE; } else { pFenceInfo->localFence = XGL_FALSE; @@ -159,6 +186,11 @@ static void updateFenceTracking(XGL_FENCE fence) } else { deleteFenceInfo((*ii).first); } + // Update fence state in fenceCreateInfo structure + MT_OBJ_INFO* pObjectInfo = getObjectInfo(fence); + if (pObjectInfo != NULL) { + pObjectInfo->create_info.fence_create_info.flags = XGL_FENCE_CREATE_SIGNALED_BIT; + } } } } @@ -241,8 +273,8 @@ static bool32_t checkMemRef( MT_QUEUE_INFO *pQueueInfo = queueMap[queue]; for (it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { if ((*it) == mem) { - result = XGL_TRUE; - break; + result = XGL_TRUE; + break; } } return result; @@ -261,7 +293,7 @@ static bool32_t validateQueueMemRefs( char str[1024]; sprintf(str, "Unknown Queue %p specified in xglQueueSubmit", queue); layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str); - } + } else { // Iterate through all CBs in pCmdBuffers for (uint32_t i = 0; i < cmdBufferCount; i++) { @@ -549,32 +581,6 @@ static bool32_t freeMemObjInfo(XGL_GPU_MEMORY mem, bool internal) return result; } -// Return object info for 'object' or return NULL if no info exists -static MT_OBJ_INFO* getObjectInfo(const XGL_OBJECT object) -{ - MT_OBJ_INFO* pObjInfo = NULL; - - if (objectMap.find(object) != objectMap.end()) { - pObjInfo = objectMap[object]; - } - return pObjInfo; -} - -static MT_OBJ_INFO* addObjectInfo(XGL_OBJECT object, XGL_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix) -{ - MT_OBJ_INFO* pInfo = new MT_OBJ_INFO; - memset(pInfo, 0, sizeof(MT_OBJ_INFO)); - memcpy(&pInfo->create_info, pCreateInfo, struct_size); - sprintf(pInfo->object_name, "%s_%p", name_prefix, object); - - pInfo->object = object; - pInfo->ref_count = 1; - pInfo->sType = sType; - objectMap[object] = pInfo; - - return pInfo; -} - // Remove object binding performs 3 tasks: // 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it // 2. Decrement refCount for MemObjInfo @@ -903,10 +909,10 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueAddMemReference(XGL_QUEUE queue, XGL_ char str[1024]; sprintf(str, "Unknown Queue %p", queue); layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str); - } + } else { if (checkMemRef(queue, mem) == XGL_TRUE) { - // Alread in list, just warn + // Alread in list, just warn char str[1024]; sprintf(str, "Request to add a memory reference (%p) to Queue %p -- ref is already present in the queue's reference list", mem, queue); layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str); @@ -927,13 +933,13 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueRemoveMemReference(XGL_QUEUE queue, X XGL_RESULT result = nextTable.QueueRemoveMemReference(queue, mem); if (result == XGL_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - + MT_QUEUE_INFO *pQueueInfo = queueMap[queue]; if (pQueueInfo == NULL) { char str[1024]; sprintf(str, "Unknown Queue %p", queue); layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str); - } + } else { for (list::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { if ((*it) == mem) { @@ -1137,6 +1143,24 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_F return result; } +XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetFences(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences) +{ + XGL_RESULT result = nextTable.ResetFences(device, fenceCount, pFences); + if (XGL_SUCCESS == result) { + loader_platform_thread_lock_mutex(&globalLock); + // Reset fence state in fenceCreateInfo structure + for (uint32_t i = 0; i < fenceCount; i++) { + MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]); + if (pObjectInfo != NULL) { + pObjectInfo->create_info.fence_create_info.flags = + static_cast(pObjectInfo->create_info.fence_create_info.flags & ~XGL_FENCE_CREATE_SIGNALED_BIT); + } + } + loader_platform_thread_unlock_mutex(&globalLock); + } + return result; +} + XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence) { XGL_RESULT result = nextTable.GetFenceStatus(fence); @@ -1150,6 +1174,18 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence) XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t fenceCount, const XGL_FENCE* pFences, bool32_t waitAll, uint64_t timeout) { + // Verify fence status of submitted fences + for(uint32_t i = 0; i < fenceCount; i++) { + MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]); + if (pObjectInfo != NULL) { + if (pObjectInfo->create_info.fence_create_info.flags == XGL_FENCE_CREATE_SIGNALED_BIT) { + char str[1024]; + sprintf(str, "xglWaitForFences specified signaled-state Fence %p. Fences must be reset before being submitted", pFences[i]); + layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str); + } + } + } + XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); loader_platform_thread_lock_mutex(&globalLock); @@ -1896,6 +1932,8 @@ XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* f return (void*) xglCreateFence; if (!strcmp(funcName, "xglGetFenceStatus")) return (void*) xglGetFenceStatus; + if (!strcmp(funcName, "xglResetFences")) + return (void*) xglResetFences; if (!strcmp(funcName, "xglWaitForFences")) return (void*) xglWaitForFences; if (!strcmp(funcName, "xglQueueWaitIdle")) diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h index 91cc434f..25480364 100644 --- a/layers/mem_tracker.h +++ b/layers/mem_tracker.h @@ -49,6 +49,7 @@ typedef enum _MEM_TRACK_ERROR MEMTRACK_INVALID_STATE = 15, // Memory not in the correct state MEMTRACK_RESET_CB_WHILE_IN_FLIGHT = 16, // xglResetCommandBuffer() called on a CB that hasn't completed MEMTRACK_INVALID_QUEUE = 17, // Invalid queue requested or selected + MEMTRACK_INVALID_FENCE_STATE = 18, // Invalid Fence State signaled or used } MEM_TRACK_ERROR; /* diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index b7b15ac4..6da0f0c5 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -519,6 +519,13 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, uint32_t return result; } +XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetFences(XGL_DEVICE device, uint32_t fenceCount, XGL_FENCE* pFences) +{ + + XGL_RESULT result = nextTable.ResetFences(device, fenceCount, pFences); + return result; +} + XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSemaphore(XGL_DEVICE device, const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_SEMAPHORE* pSemaphore) { char str[1024]; diff --git a/xgl.py b/xgl.py index 70e3c00f..1b372f0e 100644 --- a/xgl.py +++ b/xgl.py @@ -374,6 +374,11 @@ core = Extension( Param("const XGL_FENCE_CREATE_INFO*", "pCreateInfo"), Param("XGL_FENCE*", "pFence")]), + Proto("XGL_RESULT", "ResetFences", + [Param("XGL_DEVICE", "device"), + Param("uint32_t", "fenceCount"), + Param("XGL_FENCE*", "pFences")]), + Proto("XGL_RESULT", "GetFenceStatus", [Param("XGL_FENCE", "fence")]), -- cgit v1.2.3