xgl: Enable new mem ref functions

v2: remove a stale comment in the sample driver (olv)

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, &copy_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, &copy_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<XGL_GPU_MEMORY>::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<XGL_GPU_MEMORY>::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<XGL_CMD_BUFFER>          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",