From 2c2fbbf922918685c9bda0d670197bd0ad2077ca Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Tue, 7 Apr 2015 17:13:38 -0600 Subject: xgl: Enable new mem ref functions v2: remove a stale comment in the sample driver (olv) --- demos/cube.c | 45 ++------ demos/tri.c | 45 ++------ icd/nulldrv/nulldrv.c | 2 - include/xgl.h | 17 +-- include/xglWsiX11Ext.h | 2 +- layers/draw_state.cpp | 4 +- layers/glave_snapshot.c | 4 +- layers/mem_tracker.cpp | 267 +++++++++++------------------------------------ layers/mem_tracker.h | 9 -- layers/param_checker.cpp | 6 +- xgl-layer-generate.py | 15 +-- xgl.py | 2 - 12 files changed, 93 insertions(+), 325 deletions(-) diff --git a/demos/cube.c b/demos/cube.c index 91751c39..e8f174c7 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -243,8 +243,6 @@ struct demo { } uniform_data; XGL_CMD_BUFFER cmd; // Buffer for initialization commands - XGL_MEMORY_REF mem_refs[16]; - int num_refs; XGL_DESCRIPTOR_SET_LAYOUT_CHAIN desc_layout_chain; XGL_DESCRIPTOR_SET_LAYOUT desc_layout; XGL_PIPELINE pipeline; @@ -284,8 +282,7 @@ static void demo_flush_init_cmd(struct demo *demo) const XGL_CMD_BUFFER cmd_bufs[] = { demo->cmd }; - err = xglQueueSubmit(demo->queue, 1, cmd_bufs, - demo->num_refs, demo->mem_refs, XGL_NULL_HANDLE); + err = xglQueueSubmit(demo->queue, 1, cmd_bufs, XGL_NULL_HANDLE); assert(!err); err = xglQueueWaitIdle(demo->queue); @@ -293,19 +290,13 @@ static void demo_flush_init_cmd(struct demo *demo) xglDestroyObject(demo->cmd); demo->cmd = XGL_NULL_HANDLE; - demo->num_refs = 0; } static void demo_add_mem_refs( struct demo *demo, - XGL_MEMORY_REF_FLAGS flags, int num_refs, XGL_GPU_MEMORY *mem) { for (int i = 0; i < num_refs; i++) { - demo->mem_refs[demo->num_refs].flags = flags; - demo->mem_refs[demo->num_refs].mem = mem[i]; - demo->num_refs++; - assert(demo->num_refs < 16); xglQueueAddMemReference(demo->queue, mem[i]); } } @@ -526,30 +517,8 @@ static void demo_draw(struct demo *demo) err = xglWaitForFences(demo->device, 1, &fence, XGL_TRUE, ~((uint64_t) 0)); assert(err == XGL_SUCCESS || err == XGL_ERROR_UNAVAILABLE); - uint32_t i, idx = 0; - XGL_MEMORY_REF *memRefs; - memRefs = malloc(sizeof(XGL_MEMORY_REF) * (DEMO_BUFFER_COUNT + - demo->depth.num_mem + - demo->textures[0].num_mem + - demo->uniform_data.num_mem)); - for (i = 0; i < demo->depth.num_mem; i++, idx++) { - memRefs[idx].mem = demo->depth.mem[i]; - memRefs[idx].flags = 0; - } - for (i = 0; i < demo->textures[0].num_mem; i++, idx++) { - memRefs[idx].mem = demo->textures[0].mem[i]; - memRefs[idx].flags = 0; - } - memRefs[idx].mem = demo->buffers[0].mem; - memRefs[idx++].flags = 0; - memRefs[idx].mem = demo->buffers[1].mem; - memRefs[idx++].flags = 0; - for (i = 0; i < demo->uniform_data.num_mem; i++, idx++) { - memRefs[idx].mem = demo->uniform_data.mem[i]; - memRefs[idx].flags = 0; - } err = xglQueueSubmit(demo->queue, 1, &demo->buffers[demo->current_buffer].cmd, - idx, memRefs, XGL_NULL_HANDLE); + XGL_NULL_HANDLE); assert(!err); err = xglWsiX11QueuePresent(demo->queue, &present, fence); @@ -591,7 +560,7 @@ static void demo_prepare_buffers(struct demo *demo) &demo->buffers[i].image, &demo->buffers[i].mem); assert(!err); - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, 1, &demo->buffers[i].mem); + demo_add_mem_refs(demo, 1, &demo->buffers[i].mem); demo_set_image_layout(demo, demo->buffers[i].image, XGL_IMAGE_LAYOUT_UNDEFINED, @@ -695,7 +664,7 @@ static void demo_prepare_depth(struct demo *demo) XGL_IMAGE_LAYOUT_UNDEFINED, XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, num_allocations, demo->depth.mem); + demo_add_mem_refs(demo, demo->depth.num_mem, demo->depth.mem); /* create image view */ view.image = demo->depth.image; @@ -1056,8 +1025,8 @@ static void demo_prepare_textures(struct demo *demo) demo->textures[i].image, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, ©_region); - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, staging_texture.num_mem, staging_texture.mem); - demo_add_mem_refs(demo, 0, demo->textures[i].num_mem, demo->textures[i].mem); + demo_add_mem_refs(demo, staging_texture.num_mem, staging_texture.mem); + demo_add_mem_refs(demo, demo->textures[i].num_mem, demo->textures[i].mem); demo_set_image_layout(demo, demo->textures[i].image, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, @@ -1201,7 +1170,7 @@ void demo_prepare_cube_data_buffer(struct demo *demo) demo->uniform_data.mem[i], 0); assert(!err); } - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, demo->uniform_data.num_mem, demo->uniform_data.mem); + demo_add_mem_refs(demo, demo->uniform_data.num_mem, demo->uniform_data.mem); memset(&view_info, 0, sizeof(view_info)); view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; diff --git a/demos/tri.c b/demos/tri.c index 44538b80..b702cab7 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -78,8 +78,6 @@ struct demo { } vertices; XGL_CMD_BUFFER cmd; // Buffer for initialization commands - XGL_MEMORY_REF mem_refs[16]; - int num_refs; XGL_DESCRIPTOR_SET_LAYOUT_CHAIN desc_layout_chain; XGL_DESCRIPTOR_SET_LAYOUT desc_layout; XGL_PIPELINE pipeline; @@ -112,8 +110,7 @@ static void demo_flush_init_cmd(struct demo *demo) const XGL_CMD_BUFFER cmd_bufs[] = { demo->cmd }; - err = xglQueueSubmit(demo->queue, 1, cmd_bufs, - demo->num_refs, demo->mem_refs, XGL_NULL_HANDLE); + err = xglQueueSubmit(demo->queue, 1, cmd_bufs, XGL_NULL_HANDLE); assert(!err); err = xglQueueWaitIdle(demo->queue); @@ -121,19 +118,13 @@ static void demo_flush_init_cmd(struct demo *demo) xglDestroyObject(demo->cmd); demo->cmd = XGL_NULL_HANDLE; - demo->num_refs = 0; } static void demo_add_mem_refs( struct demo *demo, - XGL_MEMORY_REF_FLAGS flags, int num_refs, XGL_GPU_MEMORY *mem) { for (int i = 0; i < num_refs; i++) { - demo->mem_refs[demo->num_refs].flags = flags; - demo->mem_refs[demo->num_refs].mem = mem[i]; - demo->num_refs++; - assert(demo->num_refs < 16); xglQueueAddMemReference(demo->queue, mem[i]); } } @@ -332,29 +323,7 @@ static void demo_draw(struct demo *demo) err = xglWaitForFences(demo->device, 1, &fence, XGL_TRUE, ~((uint64_t) 0)); assert(err == XGL_SUCCESS || err == XGL_ERROR_UNAVAILABLE); - uint32_t i, idx = 0; - XGL_MEMORY_REF *memRefs = 0; - memRefs = malloc(sizeof(XGL_MEMORY_REF) * (DEMO_BUFFER_COUNT + - demo->depth.num_mem + demo->textures[0].num_mem + - demo->vertices.num_mem)); - for (i = 0; i < demo->depth.num_mem; i++, idx++) { - memRefs[idx].mem = demo->depth.mem[i]; - memRefs[idx].flags = 0; - } - for (i = 0; i < demo->textures[0].num_mem; i++, idx++) { - memRefs[idx].mem = demo->textures[0].mem[i]; - memRefs[idx].flags = 0; - } - for (i = 0; i < DEMO_BUFFER_COUNT; i++) { - memRefs[idx].mem = demo->buffers[i].mem; - memRefs[idx++].flags = 0; - } - for (i = 0; i < demo->vertices.num_mem; i++, idx++) { - memRefs[idx].mem = demo->vertices.mem[i]; - memRefs[idx].flags = 0; - } - err = xglQueueSubmit(demo->queue, 1, &demo->cmd, - idx, memRefs, XGL_NULL_HANDLE); + err = xglQueueSubmit(demo->queue, 1, &demo->cmd, XGL_NULL_HANDLE); assert(!err); err = xglWsiX11QueuePresent(demo->queue, &present, fence); @@ -396,7 +365,7 @@ static void demo_prepare_buffers(struct demo *demo) &demo->buffers[i].image, &demo->buffers[i].mem); assert(!err); - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, 1, &demo->buffers[i].mem); + demo_add_mem_refs(demo, 1, &demo->buffers[i].mem); demo_set_image_layout(demo, demo->buffers[i].image, XGL_IMAGE_LAYOUT_UNDEFINED, XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); @@ -502,7 +471,7 @@ static void demo_prepare_depth(struct demo *demo) XGL_IMAGE_LAYOUT_UNDEFINED, XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, num_allocations, demo->depth.mem); + demo_add_mem_refs(demo, demo->depth.num_mem, demo->depth.mem); /* create image view */ view.image = demo->depth.image; @@ -700,8 +669,8 @@ static void demo_prepare_textures(struct demo *demo) demo->textures[i].image, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, ©_region); - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, staging_texture.num_mem, staging_texture.mem); - demo_add_mem_refs(demo, 0, demo->textures[i].num_mem, demo->textures[i].mem); + demo_add_mem_refs(demo, staging_texture.num_mem, staging_texture.mem); + demo_add_mem_refs(demo, demo->textures[i].num_mem, demo->textures[i].mem); demo_set_image_layout(demo, demo->textures[i].image, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, @@ -834,7 +803,7 @@ static void demo_prepare_vertices(struct demo *demo) assert(!err); } - demo_add_mem_refs(demo, XGL_MEMORY_REF_READ_ONLY_BIT, demo->vertices.num_mem, demo->vertices.mem); + demo_add_mem_refs(demo, demo->vertices.num_mem, demo->vertices.mem); demo->vertices.vi.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO; demo->vertices.vi.pNext = NULL; diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c index 34d31485..43a35af1 100644 --- a/icd/nulldrv/nulldrv.c +++ b/icd/nulldrv/nulldrv.c @@ -1745,8 +1745,6 @@ ICD_EXPORT XGL_RESULT XGLAPI xglQueueSubmit( XGL_QUEUE queue_, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, - uint32_t memRefCount, - const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence_) { NULLDRV_LOG_FUNC; diff --git a/include/xgl.h b/include/xgl.h index be7cd9e1..5857b427 100644 --- a/include/xgl.h +++ b/include/xgl.h @@ -1227,13 +1227,6 @@ typedef enum _XGL_SEMAPHORE_CREATE_FLAGS XGL_MAX_ENUM(_XGL_SEMAPHORE_CREATE_FLAGS) } XGL_SEMAPHORE_CREATE_FLAGS; -// Memory reference flags -typedef enum _XGL_MEMORY_REF_FLAGS -{ - XGL_MEMORY_REF_READ_ONLY_BIT = 0x00000001, - XGL_MAX_ENUM(_XGL_MEMORY_REF_FLAGS) -} XGL_MEMORY_REF_FLAGS; - // Format capability flags typedef enum _XGL_FORMAT_FEATURE_FLAGS { @@ -2160,12 +2153,6 @@ typedef struct _XGL_RENDER_PASS_CREATE_INFO XGL_ATTACHMENT_STORE_OP stencilStoreOp; } XGL_RENDER_PASS_CREATE_INFO; -typedef struct _XGL_MEMORY_REF -{ - XGL_GPU_MEMORY mem; - XGL_FLAGS flags; // XGL_MEMORY_REF_FLAGS -} XGL_MEMORY_REF; - typedef struct _XGL_EVENT_CREATE_INFO { XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO @@ -2269,7 +2256,7 @@ typedef XGL_RESULT (XGLAPI *xglDestroyDeviceType)(XGL_DEVICE device); typedef XGL_RESULT (XGLAPI *xglGetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const char* pExtName); typedef XGL_RESULT (XGLAPI *xglEnumerateLayersType)(XGL_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved); typedef XGL_RESULT (XGLAPI *xglGetDeviceQueueType)(XGL_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, XGL_QUEUE* pQueue); -typedef XGL_RESULT (XGLAPI *xglQueueSubmitType)(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, uint32_t memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence); +typedef XGL_RESULT (XGLAPI *xglQueueSubmitType)(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence); typedef XGL_RESULT (XGLAPI *xglQueueAddMemReferenceType)(XGL_QUEUE queue, XGL_GPU_MEMORY mem); typedef XGL_RESULT (XGLAPI *xglQueueRemoveMemReferenceType)(XGL_QUEUE queue, XGL_GPU_MEMORY mem); typedef XGL_RESULT (XGLAPI *xglQueueWaitIdleType)(XGL_QUEUE queue); @@ -2439,8 +2426,6 @@ XGL_RESULT XGLAPI xglQueueSubmit( XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, - uint32_t memRefCount, - const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence); XGL_RESULT XGLAPI xglQueueAddMemReference( diff --git a/include/xglWsiX11Ext.h b/include/xglWsiX11Ext.h index 479aba71..5235758d 100644 --- a/include/xglWsiX11Ext.h +++ b/include/xglWsiX11Ext.h @@ -115,7 +115,7 @@ XGL_RESULT XGLAPI xglWsiX11GetMSC( /** * Create an XGL_IMAGE that can be presented. An XGL_GPU_MEMORY is created * and bound automatically. The memory returned can only be used in - * XGL_MEMORY_REF. Destroying the memory or binding another memory to the + * xglQueue[Add|Remove]MemReference. Destroying the memory or binding another memory to the * image is not allowed. */ XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage( diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index 9245e0ba..c2391192 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -1534,12 +1534,12 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size } } -XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, uint32_t memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence) +XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence) { for (uint32_t i=0; i < cmdBufferCount; i++) { // Validate that cmd buffers have been updated } - XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, memRefCount, pMemRefs, fence); + XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c index 84971632..3af97440 100644 --- a/layers/glave_snapshot.c +++ b/layers/glave_snapshot.c @@ -583,10 +583,10 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t return result; } -XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, uint32_t memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence) +XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence) { set_status((void*)fence, XGL_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED); - XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, memRefCount, pMemRefs, fence); + XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index 6928c8ac..e37d1778 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -97,70 +97,6 @@ static MT_CB_INFO* getCBInfo(const XGL_CMD_BUFFER cb) return pCBInfo; } -// Add new Queue node for this cb at end of global CB LL -static void insertGlobalQueue(const XGL_QUEUE queue) -{ -#if 0 // TODO: Add tracking of Queue's - MT_QUEUE_NODE* pTrav = pGlobalQueueHead; - if (!pTrav) { - pTrav = (MT_QUEUE_NODE*)malloc(sizeof(MT_QUEUE_NODE)); - pGlobalQueueHead = pTrav; - } - else { - while (NULL != pTrav->pNextGlobalQueueNode) - pTrav = pTrav->pNextGlobalQueueNode; - pTrav->pNextGlobalQueueNode = (MT_QUEUE_NODE*)malloc(sizeof(MT_QUEUE_NODE)); - pTrav = pTrav->pNextGlobalQueueNode; - } - if (!pTrav) { - char str[1024]; - sprintf(str, "Malloc failed to alloc node for Queue %p", (void*)queue); - layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_OUT_OF_MEMORY_ERROR, "MEM", str); - } - else { - numQueueNodes++; - memset(pTrav, 0, sizeof(MT_QUEUE_NODE)); - pTrav->queue = queue; - } -#endif -} - -// Return ptr to node in global LL containing cb, or NULL if not found -static MT_QUEUE_NODE* getGlobalQueueNode(const XGL_QUEUE queue) -{ -#if 0 - MT_QUEUE_NODE* pTrav = pGlobalQueueHead; - while (pTrav && (pTrav->queue != queue)) { - pTrav = pTrav->pNextGlobalQueueNode; - } - return pTrav; -#endif -} - -static void insertQueueMemRef(MT_QUEUE_NODE *pQueueNode, XGL_GPU_MEMORY mem) -{ -#if 0 - if (pQueueNode->numMemRefs >= pQueueNode->refListSize) { - pQueueNode->refListSize += 16; - pQueueNode->pMemRefList = realloc(pQueueNode->pMemRefList, pQueueNode->refListSize); - } - pQueueNode->pMemRefList[pQueueNode->numMemRefs++] = mem; -#endif -} - -static void removeQueueMemRef(MT_QUEUE_NODE *pQueueNode, XGL_GPU_MEMORY mem) -{ - uint32_t idx; - - for (idx = 0; idx < pQueueNode->numMemRefs; idx++) { - if (pQueueNode->pMemRefList[idx] == mem) { - pQueueNode->numMemRefs--; - memcpy(&pQueueNode->pMemRefList[idx], pQueueNode->pMemRefList[idx+1], - pQueueNode->numMemRefs * sizeof(XGL_GPU_MEMORY)); - } - } -} - // Add a fence, creating one if necessary to our list of fences/fenceIds static uint64_t addFenceInfo(XGL_FENCE fence, XGL_QUEUE queue) { @@ -294,55 +230,56 @@ static void retireDeviceFences(XGL_DEVICE device) } } -static bool32_t validateCBMemRef(const XGL_CMD_BUFFER cb, uint32_t memRefCount, const XGL_MEMORY_REF* pMemRefs) -{ - bool32_t result = XGL_TRUE; - MT_CB_INFO* pInfo = getCBInfo(cb); - if (!pInfo) { - char str[1024]; - sprintf(str, "Unable to find info for CB %p in order to check memory references", (void*)cb); - layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str); - result = XGL_FALSE; - } else { - // Validate that all actual references are accounted for in pMemRefs - uint32_t i; - uint8_t found = 0; - uint64_t foundCount = 0; - - for (list::iterator it = pInfo->pMemObjList.begin(); it != pInfo->pMemObjList.end(); ++it) { - for (i = 0; i < memRefCount; i++) { - if ((*it) == pMemRefs[i].mem) { - char str[1024]; - sprintf(str, "Found Mem Obj %p binding to CB %p", (*it), cb); - layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str); - found = 1; - foundCount++; - break; - } - } - if (!found) { - char str[1024]; - sprintf(str, "Memory reference list for Command Buffer %p is missing ref to mem obj %p", cb, (*it)); - layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_CB_MISSING_MEM_REF, "MEM", str); - result = XGL_FALSE; - } - found = 0; - } +//static bool32_t validateCBMemRef(const XGL_CMD_BUFFER cb, uint32_t memRefCount, const XGL_MEMORY_REF* pMemRefs) +//{ +// bool32_t result = XGL_TRUE; +// MT_CB_INFO* pInfo = getCBInfo(cb); +// if (!pInfo) { +// char str[1024]; +// sprintf(str, "Unable to find info for CB %p in order to check memory references", (void*)cb); +// layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str); +// result = XGL_FALSE; +// } else { +// // Validate that all actual references are accounted for in pMemRefs +// uint32_t i; +// uint8_t found = 0; +// uint64_t foundCount = 0; + +// for (list::iterator it = pInfo->pMemObjList.begin(); it != pInfo->pMemObjList.end(); ++it) { +// for (i = 0; i < memRefCount; i++) { +// if ((*it) == pMemRefs[i].mem) { +// char str[1024]; +// sprintf(str, "Found Mem Obj %p binding to CB %p", (*it), cb); +// layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str); +// found = 1; +// foundCount++; +// break; +// } +// } +// if (!found) { +// char str[1024]; +// sprintf(str, "Memory reference list for Command Buffer %p is missing ref to mem obj %p", cb, (*it)); +// layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_CB_MISSING_MEM_REF, "MEM", str); +// result = XGL_FALSE; +// } +// found = 0; +// } + +// if (result == XGL_TRUE) { +// char str[1024]; +// sprintf(str, "Verified all %lu memory dependencies for CB %p are included in pMemRefs list", foundCount, cb); +// layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str); +// // TODO : Could report mem refs in pMemRefs that AREN'T in mem list, that would be primarily informational +// // Currently just noting that there is a difference +// if (foundCount != memRefCount) { +// sprintf(str, "There are %u mem refs included in pMemRefs list, but only %lu are required", memRefCount, foundCount); +// layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str); +// } +// } +// } +// return result; +//} - if (result == XGL_TRUE) { - char str[1024]; - sprintf(str, "Verified all %lu memory dependencies for CB %p are included in pMemRefs list", foundCount, cb); - layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str); - // TODO : Could report mem refs in pMemRefs that AREN'T in mem list, that would be primarily informational - // Currently just noting that there is a difference - if (foundCount != memRefCount) { - sprintf(str, "There are %u mem refs included in pMemRefs list, but only %lu are required", memRefCount, foundCount); - layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str); - } - } - } - return result; -} // Return ptr to info in map container containing mem, or NULL if not found // Calls to this function should be wrapped in mutex static MT_MEM_OBJ_INFO* getMemObjInfo(const XGL_GPU_MEMORY mem) @@ -923,15 +860,14 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size } } -XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, - uint32_t memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence) +XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence) { loader_platform_thread_lock_mutex(&globalLock); // TODO : Need to track fence and clear mem references when fence clears MT_CB_INFO* pCBInfo = NULL; uint64_t fenceId = addFenceInfo(fence, queue); char str[1024]; - sprintf(str, "In xglQueueSubmit(), checking %u cmdBuffers with %u memRefs", cmdBufferCount, memRefCount); + sprintf(str, "In xglQueueSubmit(), checking %u cmdBuffers memRefs", cmdBufferCount); layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str); printMemList(); printCBList(); @@ -940,84 +876,14 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdB pCBInfo->fenceId = fenceId; sprintf(str, "Verifying mem refs for CB %p", pCmdBuffers[i]); layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_NONE, "MEM", str); - if (XGL_FALSE == validateCBMemRef(pCmdBuffers[i], memRefCount, pMemRefs)) { - sprintf(str, "Unable to verify memory references for CB %p", (void*)pCmdBuffers[i]); - layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_CB_MISSING_MEM_REF, "MEM", str); - } +// if (XGL_FALSE == validateCBMemRef(pCmdBuffers[i], memRefCount, pMemRefs)) { +// sprintf(str, "Unable to verify memory references for CB %p", (void*)pCmdBuffers[i]); +// layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_CB_MISSING_MEM_REF, "MEM", str); +// } } printCBList(); loader_platform_thread_unlock_mutex(&globalLock); - XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, memRefCount, pMemRefs, getFenceFromId(fenceId)); - return result; -} - -XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue( - XGL_DEVICE device, - uint32_t queueNodeIndex, - uint32_t queueIndex, - XGL_QUEUE* pQueue) -{ - XGL_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); - if (result == XGL_SUCCESS) { - loader_platform_thread_lock_mutex(&globalLock); - MT_QUEUE_NODE *pQueueNode = getGlobalQueueNode(*pQueue); - if (pQueueNode == NULL) { - addQueueInfo(*pQueue); - insertGlobalQueue(*pQueue); - } - loader_platform_thread_unlock_mutex(&globalLock); - } - return result; -} - -XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueAddMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem) -{ - XGL_RESULT result = nextTable.QueueAddMemReference(queue, mem); - if (result == XGL_SUCCESS) { - loader_platform_thread_lock_mutex(&globalLock); - MT_QUEUE_NODE *pQueueNode = getGlobalQueueNode(queue); - if (pQueueNode == 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 { - MT_MEM_OBJ_INFO *pMem = getMemObjInfo(mem); - if (pMem == NULL) { - char str[1024]; - sprintf(str, "Unknown GPU Memory Object %p", mem); - layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str); - } else { - insertQueueMemRef(pQueueNode, mem); - } - } - loader_platform_thread_unlock_mutex(&globalLock); - } - return result; -} - -XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueRemoveMemReference(XGL_QUEUE queue, XGL_GPU_MEMORY mem) -{ - // TODO : Decrement ref count for this memory reference on this queue. Remove if ref count is zero. - XGL_RESULT result = nextTable.QueueRemoveMemReference(queue, mem); - if (result == XGL_SUCCESS) { - loader_platform_thread_lock_mutex(&globalLock); - MT_QUEUE_NODE *pQueueNode = getGlobalQueueNode(queue); - if (pQueueNode == 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 { - MT_MEM_OBJ_INFO *pMem = getMemObjInfo(mem); - if (pMem == NULL) { - char str[1024]; - sprintf(str, "Unknown GPU Memory Object %p", mem); - layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str); - } else { - removeQueueMemRef(pQueueNode, mem); - } - } - loader_platform_thread_unlock_mutex(&globalLock); - } + XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId)); return result; } @@ -1527,15 +1393,14 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuff } XGL_LAYER_EXPORT void XGLAPI xglCmdBindDescriptorSets( - XGL_CMD_BUFFER cmdBuffer, - XGL_PIPELINE_BIND_POINT pipelineBindPoint, - XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, - uint32_t layoutChainSlot, - uint32_t count, - const XGL_DESCRIPTOR_SET* pDescriptorSets, - const uint32_t* pUserData) + XGL_CMD_BUFFER cmdBuffer, + XGL_PIPELINE_BIND_POINT pipelineBindPoint, + XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, + uint32_t layoutChainSlot, + uint32_t count, + const XGL_DESCRIPTOR_SET* pDescriptorSets, + const uint32_t* pUserData) { - // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } @@ -1915,12 +1780,6 @@ XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* f return (void*) xglEnumerateLayers; if (!strcmp(funcName, "xglQueueSubmit")) return (void*) xglQueueSubmit; - if (!strcmp(funcName, "xglGetDeviceQueue")) - return (void*) xglGetDeviceQueue; - if (!strcmp(funcName, "xglQueueAddMemReference")) - return (void*) xglQueueAddMemReference; - if (!strcmp(funcName, "xglQueueRemoveMemReference")) - return (void*) xglQueueRemoveMemReference; if (!strcmp(funcName, "xglAllocMemory")) return (void*) xglAllocMemory; if (!strcmp(funcName, "xglFreeMemory")) diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h index 7d23fac7..eb4deb47 100644 --- a/layers/mem_tracker.h +++ b/layers/mem_tracker.h @@ -48,7 +48,6 @@ typedef enum _MEM_TRACK_ERROR MEMTRACK_MEMORY_LEAK = 14, // Failure to call xglFreeMemory on Mem Obj prior to DestroyDevice 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, // Unknown Queue object } MEM_TRACK_ERROR; /* @@ -141,14 +140,6 @@ struct MT_QUEUE_INFO { list pQueueCmdBuffers; }; -struct MT_QUEUE_NODE { - struct _MT_QUEUE_NODE* pNextGlobalQueueNode; - XGL_QUEUE queue; - uint32_t numMemRefs; - uint32_t refListSize; - XGL_GPU_MEMORY *pMemRefList; -}; - #ifdef __cplusplus } #endif diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index 56e407d8..b7b15ac4 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -299,11 +299,9 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, uint32_t return result; } -XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, uint32_t memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence) +XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, uint32_t cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_FENCE fence) { - char str[1024]; - uint32_t i; - XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, memRefCount, pMemRefs, fence); + XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py index 0e21ccb1..01b1dd74 100755 --- a/xgl-layer-generate.py +++ b/xgl-layer-generate.py @@ -1235,14 +1235,14 @@ class ObjectTrackerSubcommand(Subcommand): header_txt.append(' validate_status((void*)pObj, XGL_OBJECT_TYPE_CMD_BUFFER, OBJSTATUS_DEPTH_STENCIL_BOUND, OBJSTATUS_DEPTH_STENCIL_BOUND, XGL_DBG_MSG_UNKNOWN, OBJTRACK_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer");') header_txt.append('}') header_txt.append('') - header_txt.append('static void validate_memory_mapping_status(const XGL_MEMORY_REF* pMemRefs, uint32_t numRefs) {') + header_txt.append('static void validate_memory_mapping_status(const XGL_GPU_MEMORY* pMemRefs, uint32_t numRefs) {') header_txt.append(' uint32_t i;') header_txt.append(' for (i = 0; i < numRefs; i++) {') - header_txt.append(' if(pMemRefs[i].mem) {') - header_txt.append(' // If mem reference is in presentable image memory list, skip the check of the GPU_MEMORY list') - header_txt.append(' if (!validate_status((void *)pMemRefs[i].mem, XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY, OBJSTATUS_NONE, OBJSTATUS_NONE, XGL_DBG_MSG_UNKNOWN, OBJTRACK_NONE, NULL) == XGL_TRUE)') + header_txt.append(' if (pMemRefs[i]) {') + header_txt.append(' // If mem reference is in a presentable image memory list, skip the check of the GPU_MEMORY list') + header_txt.append(' if (!validate_status((void *)pMemRefs[i], XGL_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY, OBJSTATUS_NONE, OBJSTATUS_NONE, XGL_DBG_MSG_UNKNOWN, OBJTRACK_NONE, NULL) == XGL_TRUE)') header_txt.append(' {') - header_txt.append(' validate_status((void *)pMemRefs[i].mem, XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED, OBJSTATUS_NONE, XGL_DBG_MSG_ERROR, OBJTRACK_GPU_MEM_MAPPED, "A Mapped Memory Object was referenced in a command buffer");') + header_txt.append(' validate_status((void *)pMemRefs[i], XGL_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED, OBJSTATUS_NONE, XGL_DBG_MSG_ERROR, OBJTRACK_GPU_MEM_MAPPED, "A Mapped Memory Object was referenced in a command buffer");') header_txt.append(' }') header_txt.append(' }') header_txt.append(' }') @@ -1291,8 +1291,9 @@ class ObjectTrackerSubcommand(Subcommand): using_line += ' loader_platform_thread_unlock_mutex(&objLock);\n' if 'QueueSubmit' in proto.name: using_line += ' set_status((void*)fence, XGL_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);\n' - using_line += ' validate_memory_mapping_status(pMemRefs, memRefCount);\n' - using_line += ' validate_mem_ref_count(memRefCount);\n' + using_line += ' // TODO: Fix for updated memory reference mechanism\n' + using_line += ' // validate_memory_mapping_status(pMemRefs, memRefCount);\n' + using_line += ' // validate_mem_ref_count(memRefCount);\n' elif 'GetFenceStatus' in proto.name: using_line += ' // Warn if submitted_flag is not set\n' using_line += ' validate_status((void*)fence, XGL_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED, XGL_DBG_MSG_ERROR, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");\n' diff --git a/xgl.py b/xgl.py index 53074ea4..70e3c00f 100644 --- a/xgl.py +++ b/xgl.py @@ -271,8 +271,6 @@ core = Extension( [Param("XGL_QUEUE", "queue"), Param("uint32_t", "cmdBufferCount"), Param("const XGL_CMD_BUFFER*", "pCmdBuffers"), - Param("uint32_t", "memRefCount"), - Param("const XGL_MEMORY_REF*", "pMemRefs"), Param("XGL_FENCE", "fence")]), Proto("XGL_RESULT", "QueueAddMemReference", -- cgit v1.2.3