diff --git a/include/xgl.h b/include/xgl.h
index be7cd9e..5857b42 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -1227,13 +1227,6 @@
     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 @@
     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 *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_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 479aba7..5235758 100644
--- a/include/xglWsiX11Ext.h
+++ b/include/xglWsiX11Ext.h
@@ -115,7 +115,7 @@
 /**
  * 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 9245e0b..c239119 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1534,12 +1534,12 @@
     }
 }
 
-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 8497163..3af9744 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -583,10 +583,10 @@
     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 6928c8a..e37d177 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -97,70 +97,6 @@
     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 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;
+//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;
-        }
+//        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 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 @@
         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 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 @@
         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 7d23fac..eb4deb4 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -48,7 +48,6 @@
     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 @@
     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 56e407d..b7b15ac 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -299,11 +299,9 @@
     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/tests/blit_tests.cpp b/tests/blit_tests.cpp
index 9a24c71..2cc50d7 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -514,29 +514,24 @@
 
     bool submit_and_done()
     {
-        queue_.submit(cmd_, mem_refs_);
+        queue_.submit(cmd_);
         queue_.wait();
         mem_refs_.clear();
         return true;
     }
 
-    void add_memory_ref(const xgl_testing::Object &obj, XGL_FLAGS flags)
+    void add_memory_ref(const xgl_testing::Object &obj)
     {
         const std::vector<XGL_GPU_MEMORY> mems = obj.memories();
         for (std::vector<XGL_GPU_MEMORY>::const_iterator it = mems.begin(); it != mems.end(); it++) {
-            std::vector<XGL_MEMORY_REF>::iterator ref;
+            std::vector<XGL_GPU_MEMORY>::iterator ref;
             for (ref = mem_refs_.begin(); ref != mem_refs_.end(); ref++) {
-                if (ref->mem == *it)
+                if (*ref == *it)
                     break;
             }
 
             if (ref == mem_refs_.end()) {
-                XGL_MEMORY_REF tmp = {};
-                tmp.mem = *it;
-                tmp.flags = flags;
-                mem_refs_.push_back(tmp);
-            } else {
-                ref->flags &= flags;
+                mem_refs_.push_back(*it);
             }
         }
     }
@@ -545,7 +540,7 @@
     xgl_testing::Queue &queue_;
     xgl_testing::CmdBuffer cmd_;
 
-    std::vector<XGL_MEMORY_REF> mem_refs_;
+    std::vector<XGL_GPU_MEMORY> mem_refs_;
 };
 
 typedef XglCmdBlitTest XglCmdFillBufferTest;
@@ -555,7 +550,7 @@
     xgl_testing::Buffer buf;
 
     buf.init(dev_, 20);
-    add_memory_ref(buf, 0);
+    add_memory_ref(buf);
 
     cmd_.begin();
     xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
@@ -579,7 +574,7 @@
     xgl_testing::Buffer buf;
 
     buf.init(dev_, size);
-    add_memory_ref(buf, 0);
+    add_memory_ref(buf);
 
     cmd_.begin();
     xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
@@ -602,7 +597,7 @@
     xgl_testing::Buffer buf;
 
     buf.init(dev_, 64);
-    add_memory_ref(buf, 0);
+    add_memory_ref(buf);
 
     cmd_.begin();
     xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
@@ -628,7 +623,7 @@
     cmd_.begin();
     for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
         bufs[i].init(dev_, size);
-        add_memory_ref(bufs[i], 0);
+        add_memory_ref(bufs[i]);
         xglCmdFillBuffer(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
         size <<= 1;
     }
@@ -659,10 +654,10 @@
     uint32_t *data = static_cast<uint32_t *>(src.map());
     data[0] = 0x11111111;
     src.unmap();
-    add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
+    add_memory_ref(src);
 
     dst.init(dev_, 4);
-    add_memory_ref(dst, 0);
+    add_memory_ref(dst);
 
     cmd_.begin();
     XGL_BUFFER_COPY region = {};
@@ -688,10 +683,10 @@
     for (offset = 0; offset < size; offset += 4)
         data[offset / 4] = offset;
     src.unmap();
-    add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
+    add_memory_ref(src);
 
     dst.init(dev_, size);
-    add_memory_ref(dst, 0);
+    add_memory_ref(dst);
 
     cmd_.begin();
     XGL_BUFFER_COPY region = {};
@@ -732,10 +727,10 @@
     for (int i = 0; i < 256; i++)
         data[i] = i;
     src.unmap();
-    add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
+    add_memory_ref(src);
 
     dst.init(dev_, 1024);
-    add_memory_ref(dst, 0);
+    add_memory_ref(dst);
 
     cmd_.begin();
     xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
@@ -807,7 +802,7 @@
 
     for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
         bufs[i].init(dev_, 4);
-        add_memory_ref(bufs[i], 0);
+        add_memory_ref(bufs[i]);
 
         uint32_t *data = static_cast<uint32_t *>(bufs[i].map());
         data[0] = 0x22222222 * (i + 1);
@@ -927,8 +922,8 @@
         in_buf.init(dev_, checker.buffer_size());
         checker.fill(in_buf);
 
-        add_memory_ref(in_buf, XGL_MEMORY_REF_READ_ONLY_BIT);
-        add_memory_ref(img, 0);
+        add_memory_ref(in_buf);
+        add_memory_ref(img);
 
         // copy in and tile
         cmd_.begin();
@@ -952,8 +947,8 @@
         xgl_testing::Buffer out_buf;
         out_buf.init(dev_, checker.buffer_size());
 
-        add_memory_ref(img, XGL_MEMORY_REF_READ_ONLY_BIT);
-        add_memory_ref(out_buf, 0);
+        add_memory_ref(img);
+        add_memory_ref(out_buf);
 
         // copy out and linearize
         cmd_.begin();
@@ -989,10 +984,10 @@
 
         buf.init(dev_, checker.buffer_size());
         checker.fill(buf);
-        add_memory_ref(buf, XGL_MEMORY_REF_READ_ONLY_BIT);
+        add_memory_ref(buf);
 
         img.init(dev_, img_info);
-        add_memory_ref(img, 0);
+        add_memory_ref(img);
 
         cmd_.begin();
         xglCmdCopyBufferToImage(cmd_.obj(),
@@ -1057,10 +1052,10 @@
 
         img.init(dev_, img_info);
         fill_src(img, checker);
-        add_memory_ref(img, XGL_MEMORY_REF_READ_ONLY_BIT);
+        add_memory_ref(img);
 
         buf.init(dev_, checker.buffer_size());
-        add_memory_ref(buf, 0);
+        add_memory_ref(buf);
 
         cmd_.begin();
         xglCmdCopyImageToBuffer(cmd_.obj(),
@@ -1150,11 +1145,11 @@
         xgl_testing::Image src;
         src.init(dev_, src_info);
         fill_src(src, src_checker);
-        add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
+        add_memory_ref(src);
 
         xgl_testing::Image dst;
         dst.init(dev_, dst_info);
-        add_memory_ref(dst, 0);
+        add_memory_ref(dst);
 
         cmd_.begin();
         xglCmdCopyImage(cmd_.obj(),
@@ -1213,10 +1208,10 @@
         src.init(dev_, img_info);
         if (src.transparent() || src.copyable())
             fill_src(src, checker);
-        add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
+        add_memory_ref(src);
 
         dst.init(dev_, img_info);
-        add_memory_ref(dst, 0);
+        add_memory_ref(dst);
 
         const XGL_IMAGE_LAYOUT layout = XGL_IMAGE_LAYOUT_GENERAL;
 
@@ -1356,7 +1351,7 @@
     {
         xgl_testing::Image img;
         img.init(dev_, img_info);
-        add_memory_ref(img, 0);
+        add_memory_ref(img);
         const XGL_FLAGS all_cache_outputs =
                 XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
                 XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
@@ -1587,7 +1582,7 @@
     {
         xgl_testing::Image img;
         img.init(dev_, img_info);
-        add_memory_ref(img, 0);
+        add_memory_ref(img);
         const XGL_FLAGS all_cache_outputs =
                 XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
                 XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index 332c1c7..f50520a 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -215,7 +215,7 @@
 
     void RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
                                  XglConstantBufferObj *constantBuffer, XglCommandBufferObj *cmdBuffer);
-    void GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj *pipelineobj, XglDescriptorSetObj *descriptorSet);
+    void GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj &pipelineobj, XglDescriptorSetObj &descriptorSet);
     void InitDepthStencil();
     void XGLTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate);
 
@@ -229,7 +229,6 @@
     XGL_GPU_MEMORY m_textureMem;
 
     XGL_SAMPLER m_sampler;
-    XglMemoryRefManager         m_memoryRefManager;
 
 
     virtual void SetUp() {
@@ -283,14 +282,12 @@
 }
 
 
-void XglRenderTest::GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj *pipelineobj, XglDescriptorSetObj *descriptorSet)
+void XglRenderTest::GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj &pipelineobj, XglDescriptorSetObj &descriptorSet)
 {
     if (m_depthStencil->Initialized()) {
-        cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color,
-                               m_depthStencil->BindInfo(), m_depthStencil->obj());
+        cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, m_depthStencil);
     } else {
-        cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color,
-                               NULL, NULL);
+        cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
     }
 
     cmdBuffer->PrepareAttachments();
@@ -298,9 +295,9 @@
     cmdBuffer->BindStateObject(XGL_STATE_BIND_VIEWPORT, m_stateViewport);
     cmdBuffer->BindStateObject(XGL_STATE_BIND_COLOR_BLEND, m_colorBlend);
     cmdBuffer->BindStateObject(XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil);
-    descriptorSet->CreateXGLDescriptorSet(cmdBuffer);
-    pipelineobj->CreateXGLPipeline(descriptorSet);
-    cmdBuffer->BindPipeline(pipelineobj->GetPipelineHandle());
+    descriptorSet.CreateXGLDescriptorSet(cmdBuffer);
+    pipelineobj.CreateXGLPipeline(descriptorSet);
+    cmdBuffer->BindPipeline(pipelineobj);
     cmdBuffer->BindDescriptorSet(descriptorSet);
 }
 
@@ -322,7 +319,7 @@
         constantBuffer->unmap();
 
         // submit the command buffer to the universal queue
-        cmdBuffer->QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+        cmdBuffer->QueueCommandBuffer();
 
         err = xglQueueWaitIdle( m_device->m_queue );
         ASSERT_XGL_SUCCESS( err );
@@ -410,17 +407,15 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &constantBuffer);
-    m_memoryRefManager.AddMemoryRef(&constantBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, constantBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
@@ -432,7 +427,7 @@
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
 
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 
@@ -694,9 +689,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -720,13 +713,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BIND_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 
@@ -736,7 +728,7 @@
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
 
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -795,11 +787,9 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget(2));
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
 
     XGL_PIPELINE_CB_ATTACHMENT_STATE att = {};
     att.blendEnable = XGL_FALSE;
@@ -814,7 +804,7 @@
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -827,8 +817,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
-
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -893,13 +882,10 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &indexBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, indexBuffer);
 
 
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
-    m_memoryRefManager.AddMemoryRef(&indexBuffer);
-
 #define MESH_BIND_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                           // binding ID
@@ -921,12 +907,11 @@
     pipelineobj.AddVertexInputBindings(&vi_binding,1);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -934,14 +919,14 @@
 #endif
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, MESH_BIND_ID);
-    cmdBuffer.BindIndexBuffer(&indexBuffer,0);
+    cmdBuffer.BindIndexBuffer(&indexBuffer, 0);
 
     // render two triangles
     cmdBuffer.DrawIndexed(0, 6, 0, 0, 1);
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -993,9 +978,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1015,13 +998,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1034,7 +1016,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1086,9 +1068,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1108,13 +1088,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1126,7 +1105,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1189,9 +1168,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1211,13 +1188,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1230,7 +1206,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1283,9 +1259,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BIND_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1305,13 +1279,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1324,7 +1297,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1374,18 +1347,15 @@
 
     // Create descriptor set and attach the constant buffer to it
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &MVPBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&MVPBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     // cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1398,7 +1368,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 
@@ -1457,13 +1427,12 @@
     descriptorSet.AppendDummy();
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -1475,7 +1444,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1524,9 +1493,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BUF_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1550,13 +1517,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1569,7 +1535,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1632,9 +1598,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BUF_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1658,13 +1622,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, MESH_BUF_ID);
 #ifdef DUMP_STATE_DOT
@@ -1677,7 +1640,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1730,9 +1693,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
 
 #define MESH_BUF_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1756,13 +1717,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1775,7 +1735,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1847,11 +1807,7 @@
     pipelineobj.SetDepthStencil(&ds_state);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &MVPBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
-    m_memoryRefManager.AddMemoryRef(&MVPBuffer);
-    m_memoryRefManager.AddMemoryRef(m_depthStencil);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
 
 #define MESH_BUF_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
@@ -1875,13 +1831,12 @@
     pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget(m_depthStencil->BindInfo()));
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
 
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -1895,7 +1850,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -1944,16 +1899,13 @@
     XglDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendSamplerTexture(&sampler, &texture);
 
-    m_memoryRefManager.AddMemoryRef(&texture);
-
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -1965,7 +1917,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2017,16 +1969,13 @@
     XglDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendSamplerTexture(&sampler, &texture);
 
-    m_memoryRefManager.AddMemoryRef(&texture);
-
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2037,7 +1986,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2100,16 +2049,13 @@
     XglDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendSamplerTexture(&sampler, &texture);
 
-    m_memoryRefManager.AddMemoryRef(&texture);
-
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2120,7 +2066,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2172,16 +2118,13 @@
     XglDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendSamplerTexture(&sampler, &texture);
 
-    m_memoryRefManager.AddMemoryRef(&texture);
-
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2192,7 +2135,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2263,18 +2206,13 @@
         descriptorSet.AppendDummy();
     descriptorSet.AppendSamplerTexture(&sampler3, &texture3);
 
-    m_memoryRefManager.AddMemoryRef(&texture1);
-    m_memoryRefManager.AddMemoryRef(&texture2);
-    m_memoryRefManager.AddMemoryRef(&texture3);
-
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2285,7 +2223,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2347,16 +2285,15 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &colorBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, colorBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2367,7 +2304,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2445,19 +2382,18 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2468,7 +2404,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2542,19 +2478,18 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2565,7 +2500,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2634,15 +2569,9 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    // descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); // TODO: Why does this break images??
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &mvpBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mvpBuffer);
     descriptorSet.AppendSamplerTexture(&sampler, &texture);
 
-    m_memoryRefManager.AddMemoryRef(&meshBuffer);
-    m_memoryRefManager.AddMemoryRef(&mvpBuffer);
-    m_memoryRefManager.AddMemoryRef(&texture);
-    m_memoryRefManager.AddMemoryRef(m_depthStencil);
-
 #define MESH_BIND_ID 0
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
         MESH_BIND_ID,                      // binding ID
@@ -2679,13 +2608,12 @@
     pipelineobj.SetDepthStencil(&ds_state);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget(m_depthStencil->BindInfo()));
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
 #ifdef DUMP_STATE_DOT
@@ -2697,7 +2625,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2788,25 +2716,19 @@
     descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
     descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
     descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
     // swap blue and green
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&texture0);
-    m_memoryRefManager.AddMemoryRef(&texture2);
-    m_memoryRefManager.AddMemoryRef(&texture4);
-    m_memoryRefManager.AddMemoryRef(&texture7);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2817,7 +2739,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -2903,24 +2825,18 @@
     descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
     descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
     descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
-
-    m_memoryRefManager.AddMemoryRef(&texture0);
-    m_memoryRefManager.AddMemoryRef(&texture2);
-    m_memoryRefManager.AddMemoryRef(&texture4);
-    m_memoryRefManager.AddMemoryRef(&texture7);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -2931,7 +2847,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
@@ -3162,16 +3078,15 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &mixedBuffer);
+    descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mixedBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
-    m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
     ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
-    GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
+    GenericDrawPreparation(&cmdBuffer, pipelineobj, descriptorSet);
 
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
@@ -3182,7 +3097,7 @@
 
     // finalize recording of the command buffer
     EndCommandBuffer(cmdBuffer);
-    cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
+    cmdBuffer.QueueCommandBuffer();
 
     RecordImages(m_renderTargets);
 }
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index cd7414c..0c29355 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -171,7 +171,6 @@
 }
 void XglRenderFramework::InitRenderTarget()
 {
-
     InitRenderTarget(1);
 }
 
@@ -204,6 +203,7 @@
         load_ops.push_back(XGL_ATTACHMENT_LOAD_OP_LOAD);
         store_ops.push_back(XGL_ATTACHMENT_STORE_OP_STORE);
         clear_colors.push_back(m_clear_color);
+//        m_mem_ref_mgr.AddMemoryRefs(*img);
     }
       // Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
     XGL_FRAMEBUFFER_CREATE_INFO fb_info = {};
@@ -283,7 +283,7 @@
     return m_nextSlot++;
 }
 
-int XglDescriptorSetObj::AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj *constantBuffer)
+int XglDescriptorSetObj::AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer)
 {
     XGL_DESCRIPTOR_TYPE_COUNT tc = {};
     tc.type = type;
@@ -291,7 +291,10 @@
     m_type_counts.push_back(tc);
 
     m_updateBuffers.push_back(xgl_testing::DescriptorSet::update(type,
-                m_nextSlot, 0, 1, &constantBuffer->m_bufferViewInfo));
+                m_nextSlot, 0, 1, &constantBuffer.m_bufferViewInfo));
+
+    // Track mem references for this descriptor set object
+    mem_ref_mgr.AddMemoryRefs(constantBuffer);
 
     return m_nextSlot++;
 }
@@ -311,6 +314,9 @@
     m_updateSamplerTextures.push_back(xgl_testing::DescriptorSet::update(m_nextSlot, 0, 1,
                 (const XGL_SAMPLER_IMAGE_VIEW_INFO *) NULL));
 
+    // Track mem references for the texture referenced here
+    mem_ref_mgr.AddMemoryRefs(*texture);
+
     return m_nextSlot++;
 }
 
@@ -383,7 +389,104 @@
     m_imageInfo.layout = XGL_IMAGE_LAYOUT_GENERAL;
 }
 
-static bool IsCompatible(XGL_FLAGS usage, XGL_FLAGS features)
+void XglImage::ImageMemoryBarrier(
+        XglCommandBufferObj *cmd_buf,
+        XGL_IMAGE_ASPECT aspect,
+        XGL_FLAGS output_mask /*=
+            XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
+            XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+            XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+            XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            XGL_MEMORY_OUTPUT_COPY_BIT*/,
+        XGL_FLAGS input_mask /*=
+            XGL_MEMORY_INPUT_CPU_READ_BIT |
+            XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+            XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
+            XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+            XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
+            XGL_MEMORY_INPUT_SHADER_READ_BIT |
+            XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+            XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            XGL_MEMORY_INPUT_COPY_BIT*/,
+        XGL_IMAGE_LAYOUT image_layout)
+{
+    const XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange = subresource_range(aspect, 0, 1, 0, 1);
+    XGL_IMAGE_MEMORY_BARRIER barrier;
+    barrier = image_memory_barrier(output_mask, input_mask, layout(), image_layout,
+                                   subresourceRange);
+
+    XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &barrier;
+
+    XGL_PIPE_EVENT pipe_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+    XGL_PIPELINE_BARRIER pipeline_barrier = {};
+    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+    pipeline_barrier.pNext = NULL;
+    pipeline_barrier.eventCount = 1;
+    pipeline_barrier.pEvents = pipe_events;
+    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+    pipeline_barrier.memBarrierCount = 1;
+    pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
+
+    // write barrier to the command buffer
+    xglCmdPipelineBarrier(cmd_buf->obj(), &pipeline_barrier);
+}
+
+void XglImage::SetLayout(XglCommandBufferObj *cmd_buf,
+                         XGL_IMAGE_ASPECT aspect,
+                         XGL_IMAGE_LAYOUT image_layout)
+{
+    XGL_FLAGS output_mask, input_mask;
+    const XGL_FLAGS all_cache_outputs =
+            XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
+            XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+            XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+            XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            XGL_MEMORY_OUTPUT_COPY_BIT;
+    const XGL_FLAGS all_cache_inputs =
+            XGL_MEMORY_INPUT_CPU_READ_BIT |
+            XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+            XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
+            XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+            XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
+            XGL_MEMORY_INPUT_SHADER_READ_BIT |
+            XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+            XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+            XGL_MEMORY_INPUT_COPY_BIT;
+
+    if (image_layout == m_imageInfo.layout) {
+        return;
+    }
+
+    switch (image_layout) {
+    case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+        output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
+        input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+        break;
+
+    case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+        output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
+        input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+        break;
+
+    case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+        break;
+
+    case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+        output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
+        input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+        break;
+
+    default:
+        output_mask =  all_cache_outputs;
+        input_mask = all_cache_inputs;
+        break;
+    }
+
+    ImageMemoryBarrier(cmd_buf, aspect, output_mask, input_mask, image_layout);
+    m_imageInfo.layout = image_layout;
+}
+
+bool XglImage::IsCompatible(XGL_FLAGS usage, XGL_FLAGS features)
 {
     if ((usage & XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) &&
             !(features & XGL_FORMAT_IMAGE_SHADER_READ_BIT))
@@ -449,7 +552,7 @@
 
     xgl_testing::Image::init(*m_device, imageCreateInfo);
 
-    m_imageInfo.layout = XGL_IMAGE_LAYOUT_GENERAL;
+    m_imageInfo.layout = XGL_IMAGE_LAYOUT_UNDEFINED;
 }
 
 XGL_RESULT XglImage::MapMemory(void** ptr)
@@ -464,84 +567,22 @@
     return XGL_SUCCESS;
 }
 
-XGL_RESULT XglImage::CopyImage(XglImage &fromImage)
+XGL_RESULT XglImage::CopyImage(XglImage &src_image)
 {
     XGL_RESULT err;
+    XglCommandBufferObj cmd_buf(m_device);
+    XGL_IMAGE_LAYOUT src_image_layout, dest_image_layout;
 
-    XGL_CMD_BUFFER cmd_buf;
-    XGL_CMD_BUFFER_CREATE_INFO  cmd_buf_create_info = {};
-    cmd_buf_create_info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
-    cmd_buf_create_info.pNext = NULL;
-    cmd_buf_create_info.queueNodeIndex = m_device->graphics_queue_node_index_;
-    cmd_buf_create_info.flags = 0;
-
-    err = xglCreateCommandBuffer(m_device->device(), &cmd_buf_create_info, &cmd_buf);
+    /* Build command buffer to copy staging texture to usable texture */
+    err = cmd_buf.BeginCommandBuffer();
     assert(!err);
 
-    /* Copy staging texture to usable texture */
-    XGL_CMD_BUFFER_BEGIN_INFO cmd_buf_begin_info = {};
-    cmd_buf_begin_info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
-    cmd_buf_begin_info.pNext = NULL;
-    cmd_buf_begin_info.flags = 0;
+    /* TODO: Can we determine image aspect from image object? */
+    src_image_layout = src_image.layout();
+    src_image.SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
 
-    err = xglResetCommandBuffer(cmd_buf);
-    assert(!err);
-
-    err = xglBeginCommandBuffer(cmd_buf, &cmd_buf_begin_info);
-    assert(!err);
-
-    XGL_IMAGE_MEMORY_BARRIER image_memory_barrier = {};
-    image_memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-    image_memory_barrier.pNext = NULL;
-    image_memory_barrier.outputMask = XGL_MEMORY_OUTPUT_COPY_BIT;
-    image_memory_barrier.inputMask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
-    image_memory_barrier.oldLayout = fromImage.layout();
-    image_memory_barrier.newLayout = XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL;
-    image_memory_barrier.image = fromImage.obj();
-    image_memory_barrier.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
-    image_memory_barrier.subresourceRange.baseMipLevel = 0;
-    image_memory_barrier.subresourceRange.mipLevels = 1;
-    image_memory_barrier.subresourceRange.baseArraySlice = 0;
-    image_memory_barrier.subresourceRange.arraySize = 0;
-
-    XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &image_memory_barrier;
-
-    XGL_PIPE_EVENT pipe_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
-    XGL_PIPELINE_BARRIER pipeline_barrier;
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
-    pipeline_barrier.pNext = NULL;
-    pipeline_barrier.eventCount = 1;
-    pipeline_barrier.pEvents = pipe_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
-    pipeline_barrier.memBarrierCount = 1;
-    pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
-
-    // write barrier to the command buffer
-    xglCmdPipelineBarrier(cmd_buf, &pipeline_barrier);
-
-    image_memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-    image_memory_barrier.pNext = NULL;
-    image_memory_barrier.outputMask = XGL_MEMORY_OUTPUT_COPY_BIT;
-    image_memory_barrier.inputMask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
-    image_memory_barrier.oldLayout = this->layout();
-    image_memory_barrier.newLayout = XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL;
-    image_memory_barrier.image = this->obj();
-    image_memory_barrier.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
-    image_memory_barrier.subresourceRange.baseMipLevel = 0;
-    image_memory_barrier.subresourceRange.mipLevels = 1;
-    image_memory_barrier.subresourceRange.baseArraySlice = 0;
-    image_memory_barrier.subresourceRange.arraySize = 0;
-
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
-    pipeline_barrier.pNext = NULL;
-    pipeline_barrier.eventCount = 1;
-    pipeline_barrier.pEvents = pipe_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
-    pipeline_barrier.memBarrierCount = 1;
-    pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
-
-    // write barrier to the command buffer
-    xglCmdPipelineBarrier(cmd_buf, &pipeline_barrier);
+    dest_image_layout = this->layout();
+    this->SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
 
     XGL_IMAGE_COPY copy_region = {};
     copy_region.srcSubresource.aspect = XGL_IMAGE_ASPECT_COLOR;
@@ -556,91 +597,32 @@
     copy_region.destOffset.x = 0;
     copy_region.destOffset.y = 0;
     copy_region.destOffset.z = 0;
-    copy_region.extent = fromImage.extent();
+    copy_region.extent = src_image.extent();
 
-    xglCmdCopyImage(cmd_buf, fromImage.obj(), fromImage.layout(),
-                    obj(), XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+    xglCmdCopyImage(cmd_buf.obj(),
+                    src_image.obj(), src_image.layout(),
+                    obj(), layout(),
                     1, &copy_region);
+    cmd_buf.mem_ref_mgr.AddMemoryRefs(src_image);
+    cmd_buf.mem_ref_mgr.AddMemoryRefs(*this);
 
-    image_memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-    image_memory_barrier.pNext = NULL;
-    image_memory_barrier.outputMask = XGL_MEMORY_OUTPUT_COPY_BIT;
-    image_memory_barrier.inputMask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
-    image_memory_barrier.oldLayout = XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL;
-    image_memory_barrier.newLayout = fromImage.layout();
-    image_memory_barrier.image = fromImage.obj();
-    image_memory_barrier.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
-    image_memory_barrier.subresourceRange.baseMipLevel = 0;
-    image_memory_barrier.subresourceRange.mipLevels = 1;
-    image_memory_barrier.subresourceRange.baseArraySlice = 0;
-    image_memory_barrier.subresourceRange.arraySize = 0;
+    src_image.SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, src_image_layout);
 
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
-    pipeline_barrier.pNext = NULL;
-    pipeline_barrier.eventCount = 1;
-    pipeline_barrier.pEvents = pipe_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
-    pipeline_barrier.memBarrierCount = 1;
-    pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
+    this->SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, dest_image_layout);
 
-    // write barrier to the command buffer
-    xglCmdPipelineBarrier(cmd_buf, &pipeline_barrier);
-
-    image_memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-    image_memory_barrier.pNext = NULL;
-    image_memory_barrier.outputMask = XGL_MEMORY_OUTPUT_COPY_BIT;
-    image_memory_barrier.inputMask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
-    image_memory_barrier.oldLayout = XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL;
-    image_memory_barrier.newLayout = this->layout();
-    image_memory_barrier.image = this->obj();
-    image_memory_barrier.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
-    image_memory_barrier.subresourceRange.baseMipLevel = 0;
-    image_memory_barrier.subresourceRange.mipLevels = 1;
-    image_memory_barrier.subresourceRange.baseArraySlice = 0;
-    image_memory_barrier.subresourceRange.arraySize = 0;
-
-    pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
-    pipeline_barrier.pNext = NULL;
-    pipeline_barrier.eventCount = 1;
-    pipeline_barrier.pEvents = pipe_events;
-    pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
-    pipeline_barrier.memBarrierCount = 1;
-    pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
-
-    // write barrier to the command buffer
-    xglCmdPipelineBarrier(cmd_buf, &pipeline_barrier);
-
-    err = xglEndCommandBuffer(cmd_buf);
+    err = cmd_buf.EndCommandBuffer();
     assert(!err);
 
-    const XGL_CMD_BUFFER cmd_bufs[] = { cmd_buf };
-    XGL_MEMORY_REF mem_refs[16];
-    uint32_t num_refs = 0;
-    const std::vector<XGL_GPU_MEMORY> from_mems = fromImage.memories();
-    const std::vector<XGL_GPU_MEMORY> to_mems = memories();
+    /*
+     * Tell driver about memory references made in this command buffer
+     * Note: Since this command buffer only has a PipelineBarrier
+     * command there really aren't any memory refs to worry about.
+     */
+    cmd_buf.mem_ref_mgr.EmitAddMemoryRefs(m_device->m_queue);
 
-    for (uint32_t j = 0; j < from_mems.size(); j++) {
-        mem_refs[num_refs].flags = XGL_MEMORY_REF_READ_ONLY_BIT;
-        mem_refs[num_refs].mem = from_mems[j];
-        num_refs++;
-        assert(num_refs < 16);
-    }
+    cmd_buf.QueueCommandBuffer();
 
-    for (uint32_t j = 0; j < to_mems.size(); j++) {
-        mem_refs[num_refs].flags = XGL_MEMORY_REF_READ_ONLY_BIT;
-        mem_refs[num_refs].mem = to_mems[j];
-        num_refs++;
-        assert(num_refs < 16);
-    }
-
-    err = xglQueueSubmit(m_device->m_queue, 1, cmd_bufs,
-                         num_refs, mem_refs, XGL_NULL_HANDLE);
-    assert(!err);
-
-    err = xglQueueWaitIdle(m_device->m_queue);
-    assert(!err);
-
-    xglDestroyObject(cmd_buf);
+    cmd_buf.mem_ref_mgr.EmitRemoveMemoryRefs(m_device->m_queue);
 
     return XGL_SUCCESS;
 }
@@ -737,6 +719,7 @@
 
 XglConstantBufferObj::~XglConstantBufferObj()
 {
+    // TODO: Should we call QueueRemoveMemReference for the constant buffer memory here?
     if (m_commandBuffer) {
         delete m_commandBuffer;
     }
@@ -802,11 +785,11 @@
         m_fence.init(*m_device, xgl_testing::Fence::create_info(0));
 
         m_commandBuffer = new XglCommandBufferObj(m_device);
-
     }
     else
     {
         m_device->wait(m_fence);
+        m_commandBuffer->mem_ref_mgr.EmitRemoveMemoryRefs(m_device->m_queue);
     }
 
     // open the command buffer
@@ -838,16 +821,17 @@
     err = m_commandBuffer->EndCommandBuffer();
     ASSERT_XGL_SUCCESS(err);
 
-    uint32_t     numMemRefs=1;
-    XGL_MEMORY_REF memRefs;
-    // this command buffer only uses the vertex buffer memory
-    memRefs.flags = 0;
-    memRefs.mem = memories()[0];
+    /*
+     * Tell driver about memory references made in this command buffer
+     * Note: Since this command buffer only has a PipelineBarrier
+     * command there really aren't any memory refs to worry about.
+     */
+    m_commandBuffer->mem_ref_mgr.EmitAddMemoryRefs(m_device->m_queue);
 
     // submit the command buffer to the universal queue
     XGL_CMD_BUFFER bufferArray[1];
     bufferArray[0] = m_commandBuffer->GetBufferHandle();
-    err = xglQueueSubmit( m_device->m_queue, 1, bufferArray, numMemRefs, &memRefs, m_fence.obj() );
+    err = xglQueueSubmit( m_device->m_queue, 1, bufferArray, m_fence.obj() );
     ASSERT_XGL_SUCCESS(err);
 }
 
@@ -1072,7 +1056,7 @@
     m_ds_state.front = ds_state->front;
 }
 
-void XglPipelineObj::CreateXGLPipeline(XglDescriptorSetObj *descriptorSet)
+void XglPipelineObj::CreateXGLPipeline(XglDescriptorSetObj &descriptorSet)
 {
     void* head_ptr = &m_ds_state;
     XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
@@ -1096,7 +1080,7 @@
     info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
     info.pNext = head_ptr;
     info.flags = 0;
-    info.pSetLayoutChain = descriptorSet->GetLayoutChain();
+    info.pSetLayoutChain = descriptorSet.GetLayoutChain();
 
     m_cb_state.attachmentCount = m_colorAttachments.size();
     m_cb_state.pAttachments = &m_colorAttachments[0];
@@ -1104,93 +1088,47 @@
     init(*m_device, info);
 }
 
-XGL_PIPELINE XglPipelineObj::GetPipelineHandle()
+vector<XGL_GPU_MEMORY> XglMemoryRefManager::mem_refs() const
 {
-    return obj();
+    std::vector<XGL_GPU_MEMORY> mems;
+    if (this->mem_refs_.size()) {
+        mems.reserve(this->mem_refs_.size());
+        for (uint32_t i = 0; i < this->mem_refs_.size(); i++)
+            mems.push_back(this->mem_refs_[i]);
+    }
+
+    return mems;
 }
 
-void XglPipelineObj::BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj *descriptorSet)
+void XglMemoryRefManager::AddMemoryRefs(xgl_testing::Object &xglObject)
 {
-    void* head_ptr = &m_ds_state;
-    XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
+    const std::vector<XGL_GPU_MEMORY> mems = xglObject.memories();
+    AddMemoryRefs(mems);
+}
 
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
-
-    for (int i=0; i<m_shaderObjs.size(); i++)
-    {
-        shaderCreateInfo = m_shaderObjs[i]->GetStageCreateInfo();
-        shaderCreateInfo->pNext = head_ptr;
-        head_ptr = shaderCreateInfo;
-    }
-
-    if (m_vi_state.attributeCount && m_vi_state.bindingCount)
-    {
-        m_vi_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
-        m_vi_state.pNext = head_ptr;
-        head_ptr = &m_vi_state;
-    }
-
-    info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-    info.pNext = head_ptr;
-    info.flags = 0;
-    info.pSetLayoutChain = descriptorSet->GetLayoutChain();
-
-    init(*m_device, info);
-
-    xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, obj() );
-
-
-    for (int i=0; i < m_vertexBufferCount; i++)
-    {
-        m_vertexBufferObjs[i]->Bind(m_cmdBuffer, 0,  m_vertexBufferBindings[i]);
+void XglMemoryRefManager::AddMemoryRefs(vector<XGL_GPU_MEMORY> mem)
+{
+    for (size_t i = 0; i < mem.size(); i++) {
+        if (mem[i] != NULL) {
+            this->mem_refs_.push_back(mem[i]);
+        }
     }
 }
 
-XglMemoryRefManager::XglMemoryRefManager() {
-
-}
-
-void XglMemoryRefManager::AddMemoryRef(xgl_testing::Object *xglObject) {
-    const std::vector<XGL_GPU_MEMORY> mems = xglObject->memories();
-    for (size_t i = 0; i < mems.size(); i++) {
-        m_bufferObjs.push_back(mems[i]);
+void XglMemoryRefManager::EmitAddMemoryRefs(XGL_QUEUE queue)
+{
+    for (uint32_t i = 0; i < mem_refs_.size(); i++) {
+        xglQueueAddMemReference(queue, mem_refs_[i]);
     }
 }
 
-void XglMemoryRefManager::AddMemoryRef(XGL_GPU_MEMORY *mem, uint32_t refCount) {
-    for (size_t i = 0; i < refCount; i++) {
-        m_bufferObjs.push_back(mem[i]);
+void XglMemoryRefManager::EmitRemoveMemoryRefs(XGL_QUEUE queue)
+{
+    for (uint32_t i = 0; i < mem_refs_.size(); i++) {
+        xglQueueRemoveMemReference(queue, mem_refs_[i]);
     }
 }
 
-void XglMemoryRefManager::AddRTMemoryRefs(vector<XglImage*>images, uint32_t rtCount) {
-    for (uint32_t i = 0; i < rtCount; i++) {
-        const std::vector<XGL_GPU_MEMORY> mems = images[i]->memories();
-        if (!mems.empty())
-            m_bufferObjs.push_back(mems[0]);
-    }
-}
-
-XGL_MEMORY_REF* XglMemoryRefManager::GetMemoryRefList() {
-
-    XGL_MEMORY_REF *localRefs;
-    uint32_t       numRefs=m_bufferObjs.size();
-
-    if (numRefs <= 0)
-        return NULL;
-
-    localRefs = (XGL_MEMORY_REF*) malloc( numRefs * sizeof(XGL_MEMORY_REF) );
-    for (int i=0; i<numRefs; i++)
-    {
-        localRefs[i].flags = 0;
-        localRefs[i].mem = m_bufferObjs[i];
-    }
-    return localRefs;
-}
-int XglMemoryRefManager::GetNumRefs() {
-    return m_bufferObjs.size();
-}
-
 XglCommandBufferObj::XglCommandBufferObj(XglDevice *device)
     : xgl_testing::CmdBuffer(*device, xgl_testing::CmdBuffer::create_info(device->graphics_queue_node_index_))
 {
@@ -1232,7 +1170,7 @@
 }
 
 void XglCommandBufferObj::ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color,
-                                          XGL_DEPTH_STENCIL_BIND_INFO *depthStencilBinding, XGL_IMAGE depthStencilImage)
+                                          XglDepthStencilObj *depthStencilObj)
 {
     uint32_t i;
     const XGL_FLAGS output_mask =
@@ -1277,9 +1215,11 @@
         xglCmdClearColorImage(obj(),
                m_renderTargets[i]->image(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                clear_color, 1, &srRange );
+
+        mem_ref_mgr.AddMemoryRefs(*m_renderTargets[i]);
     }
 
-    if (depthStencilImage)
+    if (depthStencilObj)
     {
         XGL_IMAGE_SUBRESOURCE_RANGE dsRange = {};
         dsRange.aspect = XGL_IMAGE_ASPECT_DEPTH;
@@ -1290,26 +1230,25 @@
 
         // prepare the depth buffer for clear
 
-        memory_barrier.oldLayout = depthStencilBinding->layout;
+        memory_barrier.oldLayout = depthStencilObj->BindInfo()->layout;
         memory_barrier.newLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
-        memory_barrier.image = depthStencilImage;
+        memory_barrier.image = depthStencilObj->obj();
         memory_barrier.subresourceRange = dsRange;
 
         xglCmdPipelineBarrier( obj(), &pipeline_barrier);
-        depthStencilBinding->layout = memory_barrier.newLayout;
 
         xglCmdClearDepthStencil(obj(),
-                                depthStencilImage, XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+                                depthStencilObj->obj(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
                                 depth_clear_color,  stencil_clear_color,
                                 1, &dsRange);
+        mem_ref_mgr.AddMemoryRefs(*depthStencilObj);
 
         // prepare depth buffer for rendering
-        memory_barrier.image = depthStencilImage;
+        memory_barrier.image = depthStencilObj->obj();
         memory_barrier.oldLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
-        memory_barrier.newLayout = depthStencilBinding->layout;
+        memory_barrier.newLayout = depthStencilObj->BindInfo()->layout;
         memory_barrier.subresourceRange = dsRange;
         xglCmdPipelineBarrier( obj(), &pipeline_barrier);
-        depthStencilBinding->layout = memory_barrier.newLayout;
     }
 }
 
@@ -1401,12 +1340,14 @@
     xglCmdDraw(obj(), firstVertex, vertexCount, firstInstance, instanceCount);
 }
 
-void XglCommandBufferObj::QueueCommandBuffer(XGL_MEMORY_REF *memRefs, uint32_t numMemRefs)
+void XglCommandBufferObj::QueueCommandBuffer()
 {
     XGL_RESULT err = XGL_SUCCESS;
 
+    mem_ref_mgr.EmitAddMemoryRefs(m_device->m_queue);
+
     // submit the command buffer to the universal queue
-    err = xglQueueSubmit( m_device->m_queue, 1, &obj(), numMemRefs, memRefs, NULL );
+    err = xglQueueSubmit( m_device->m_queue, 1, &obj(), NULL );
     ASSERT_XGL_SUCCESS( err );
 
     err = xglQueueWaitIdle( m_device->m_queue );
@@ -1415,28 +1356,44 @@
     // Wait for work to finish before cleaning up.
     xglDeviceWaitIdle(m_device->device());
 
-}
-void XglCommandBufferObj::BindPipeline(XGL_PIPELINE pipeline)
-{
-        xglCmdBindPipeline( obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, pipeline );
+    /*
+     * Now that processing on this command buffer is complete
+     * we can remove the memory references.
+     */
+    mem_ref_mgr.EmitRemoveMemoryRefs(m_device->m_queue);
 }
 
-void XglCommandBufferObj::BindDescriptorSet(const XglDescriptorSetObj *set)
+void XglCommandBufferObj::BindPipeline(XglPipelineObj &pipeline)
 {
-    XGL_DESCRIPTOR_SET set_obj = set->GetDescriptorSetHandle();
+    xglCmdBindPipeline( obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, pipeline.obj() );
+    mem_ref_mgr.AddMemoryRefs(pipeline);
+}
+
+void XglCommandBufferObj::BindDescriptorSet(XglDescriptorSetObj &descriptorSet)
+{
+    XGL_DESCRIPTOR_SET set_obj = descriptorSet.GetDescriptorSetHandle();
 
     // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
     xglCmdBindDescriptorSets(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS,
-            set->GetLayoutChain(), 0, 1, &set_obj, NULL );
+           descriptorSet.GetLayoutChain(), 0, 1, &set_obj, NULL );
+
+    // Add descriptor set mem refs to command buffer's list
+    mem_ref_mgr.AddMemoryRefs(descriptorSet.memories());
+    mem_ref_mgr.AddMemoryRefs(descriptorSet.mem_ref_mgr.mem_refs());
 }
+
 void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset)
 {
     xglCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
+    mem_ref_mgr.AddMemoryRefs(*indexBuffer);
 }
+
 void XglCommandBufferObj::BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding)
 {
     xglCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
+    mem_ref_mgr.AddMemoryRefs(*vertexBuffer);
 }
+
 XglDepthStencilObj::XglDepthStencilObj()
 {
     m_initialized = false;
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
index 4a08f83..035e5b5 100644
--- a/tests/xglrenderframework.h
+++ b/tests/xglrenderframework.h
@@ -46,6 +46,20 @@
     XGL_QUEUE m_queue;
 };
 
+class XglMemoryRefManager
+{
+public:
+    void AddMemoryRefs(xgl_testing::Object &xglObject);
+    void AddMemoryRefs(vector<XGL_GPU_MEMORY> mem);
+    void EmitAddMemoryRefs(XGL_QUEUE queue);
+    void EmitRemoveMemoryRefs(XGL_QUEUE queue);
+    vector<XGL_GPU_MEMORY> mem_refs() const;
+
+protected:
+    vector<XGL_GPU_MEMORY>      mem_refs_;
+
+};
+
 class XglDepthStencilObj : public xgl_testing::Image
 {
 public:
@@ -92,7 +106,6 @@
     XGL_CMD_BUFFER                          m_cmdBuffer;
     XGL_RENDER_PASS                         m_renderPass;
     XGL_FRAMEBUFFER                         m_framebuffer;
-    XGL_MEMORY_REF                          m_memRefs[5];
     XGL_DYNAMIC_RS_STATE_OBJECT             m_stateRaster;
     XGL_DYNAMIC_CB_STATE_OBJECT             m_colorBlend;
     XGL_DYNAMIC_VP_STATE_OBJECT             m_stateViewport;
@@ -106,6 +119,7 @@
     float                                   m_depth_clear_color;
     uint32_t                                m_stencil_clear_color;
     XglDepthStencilObj                     *m_depthStencil;
+    XglMemoryRefManager                     m_mem_ref_mgr;
 
     /*
      * SetUp and TearDown are called by the Google Test framework
@@ -131,23 +145,28 @@
 class XglDescriptorSetObj;
 class XglIndexBufferObj;
 class XglConstantBufferObj;
+class XglPipelineObj;
+class XglDescriptorSetObj;
 
 class XglCommandBufferObj : public xgl_testing::CmdBuffer
 {
 public:
     XglCommandBufferObj(XglDevice *device);
     XGL_CMD_BUFFER GetBufferHandle();
+    XGL_RESULT BeginCommandBuffer();
     XGL_RESULT BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo);
     XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj);
-    XGL_RESULT BeginCommandBuffer();
     XGL_RESULT EndCommandBuffer();
     void PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr);
     void AddRenderTarget(XglImage *renderTarget);
     void AddDepthStencil();
-    void ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, XGL_DEPTH_STENCIL_BIND_INFO *depthStencilBinding, XGL_IMAGE depthStencilImage);
+    void ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, XglDepthStencilObj *depthStencilObj);
     void PrepareAttachments();
-    void BindPipeline(XGL_PIPELINE pipeline);
-    void BindDescriptorSet(const XglDescriptorSetObj *set);
+    void AddMemoryRefs(xgl_testing::Object &xglObject);
+    void AddMemoryRefs(uint32_t ref_count, const XGL_GPU_MEMORY *mem);
+    void AddMemoryRefs(vector<xgl_testing::Object *> images);
+    void BindPipeline(XglPipelineObj &pipeline);
+    void BindDescriptorSet(XglDescriptorSetObj &descriptorSet);
     void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding);
     void BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset);
     void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject);
@@ -155,12 +174,13 @@
     void EndRenderPass(XGL_RENDER_PASS renderpass);
     void Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
     void DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
-    void QueueCommandBuffer(XGL_MEMORY_REF *memRefs, uint32_t numMemRefs);
+    void QueueCommandBuffer();
+
+    XglMemoryRefManager             mem_ref_mgr;
 
 protected:
     XglDevice                      *m_device;
     vector<XglImage*>               m_renderTargets;
-
 };
 
 class XglConstantBufferObj : public xgl_testing::Buffer
@@ -216,30 +236,39 @@
 {
 public:
     XglImage(XglDevice *dev);
+    bool IsCompatible(XGL_FLAGS usage, XGL_FLAGS features);
 
 public:
-    void init( uint32_t w, uint32_t h,
-                     XGL_FORMAT fmt, XGL_FLAGS usage,
-                     XGL_IMAGE_TILING tiling=XGL_LINEAR_TILING);
+    void init(uint32_t w, uint32_t h,
+              XGL_FORMAT fmt, XGL_FLAGS usage,
+              XGL_IMAGE_TILING tiling=XGL_LINEAR_TILING);
 
     //    void clear( CommandBuffer*, uint32_t[4] );
-    //    void prepare( CommandBuffer*, XGL_IMAGE_STATE );
 
     void layout( XGL_IMAGE_LAYOUT layout )
     {
         m_imageInfo.layout = layout;
     }
+
     XGL_GPU_MEMORY memory() const
     {
         const std::vector<XGL_GPU_MEMORY> mems = memories();
         return mems.empty() ? XGL_NULL_HANDLE : mems[0];
     }
 
-    XGL_RESULT CopyImage(XglImage &fromImage);
+    void ImageMemoryBarrier(XglCommandBufferObj *cmd,
+                            XGL_IMAGE_ASPECT aspect,
+                            XGL_FLAGS output_mask,
+                            XGL_FLAGS input_mask,
+                            XGL_IMAGE_LAYOUT image_layout);
+
+    XGL_RESULT CopyImage(XglImage &src_image);
+
     XGL_IMAGE image() const
     {
         return obj();
     }
+
     XGL_COLOR_ATTACHMENT_VIEW targetView()
     {
         if (!m_targetView.initialized())
@@ -258,6 +287,8 @@
         return m_targetView.obj();
     }
 
+    void SetLayout(XglCommandBufferObj *cmd_buf, XGL_IMAGE_ASPECT aspect, XGL_IMAGE_LAYOUT image_layout);
+
     XGL_IMAGE_LAYOUT layout() const
     {
         return ( XGL_IMAGE_LAYOUT )m_imageInfo.layout;
@@ -315,13 +346,15 @@
     ~XglDescriptorSetObj();
 
     int AppendDummy();
-    int AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj* constantBuffer);
+    int AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer);
     int AppendSamplerTexture(XglSamplerObj* sampler, XglTextureObj* texture);
     void CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer);
 
     XGL_DESCRIPTOR_SET GetDescriptorSetHandle() const;
     XGL_DESCRIPTOR_SET_LAYOUT_CHAIN GetLayoutChain() const;
 
+    XglMemoryRefManager                  mem_ref_mgr;
+
 protected:
     XglDevice                           *m_device;
     vector<XGL_DESCRIPTOR_TYPE_COUNT>    m_type_counts;
@@ -355,15 +388,13 @@
 {
 public:
     XglPipelineObj(XglDevice *device);
-    void BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj *descriptorSet);
     void AddShader(XglShaderObj* shaderObj);
     void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
     void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
     void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
     void AddColorAttachment(uint32_t binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att);
     void SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *);
-    void CreateXGLPipeline(XglDescriptorSetObj *descriptorSet);
-    XGL_PIPELINE GetPipelineHandle();
+    void CreateXGLPipeline(XglDescriptorSetObj &descriptorSet);
 
 protected:
     XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state;
@@ -380,20 +411,5 @@
     int m_vertexBufferCount;
 
 };
-class XglMemoryRefManager{
-public:
-    XglMemoryRefManager();
-    void AddMemoryRef(xgl_testing::Object *xglObject);
-    void AddMemoryRef(XGL_GPU_MEMORY *mem, uint32_t refCount);
-    void AddRTMemoryRefs(vector<XglImage *>images, uint32_t rtCount);
-    XGL_MEMORY_REF* GetMemoryRefList();
-    int GetNumRefs();
-
-protected:
-    int m_numRefs;
-    vector<XGL_GPU_MEMORY> m_bufferObjs;
-
-};
-
 
 #endif // XGLRENDERFRAMEWORK_H
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index d4a06f8..92ca983 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -513,23 +513,36 @@
     EXPECT(xglEndDescriptorPoolUpdate(obj(), cmd.obj()) == XGL_SUCCESS);
 }
 
-void Queue::submit(const std::vector<const CmdBuffer *> &cmds, const std::vector<XGL_MEMORY_REF> &mem_refs, Fence &fence)
+void Queue::submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence)
 {
     const std::vector<XGL_CMD_BUFFER> cmd_objs = make_objects<XGL_CMD_BUFFER>(cmds);
-    EXPECT(xglQueueSubmit(obj(), cmd_objs.size(), &cmd_objs[0], mem_refs.size(), &mem_refs[0], fence.obj()) == XGL_SUCCESS);
+    EXPECT(xglQueueSubmit(obj(), cmd_objs.size(), &cmd_objs[0], fence.obj()) == XGL_SUCCESS);
 }
 
-void Queue::submit(const CmdBuffer &cmd, const std::vector<XGL_MEMORY_REF> &mem_refs, Fence &fence)
+void Queue::submit(const CmdBuffer &cmd, Fence &fence)
 {
-    submit(std::vector<const CmdBuffer*>(1, &cmd), mem_refs, fence);
+    submit(std::vector<const CmdBuffer*>(1, &cmd), fence);
 }
 
-void Queue::submit(const CmdBuffer &cmd, const std::vector<XGL_MEMORY_REF> &mem_refs)
+void Queue::submit(const CmdBuffer &cmd)
 {
     Fence fence;
-    submit(cmd, mem_refs, fence);
+    submit(cmd, fence);
 }
 
+void Queue::add_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs)
+{
+    for (int i = 0; i < mem_refs.size(); i++) {
+        EXPECT(xglQueueAddMemReference(obj(), mem_refs[i]) == XGL_SUCCESS);
+    }
+}
+
+void Queue::remove_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs)
+{
+    for (int i = 0; i < mem_refs.size(); i++) {
+        EXPECT(xglQueueRemoveMemReference(obj(), mem_refs[i]) == XGL_SUCCESS);
+    }
+}
 
 void Queue::wait()
 {
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index c311508..ae3fbba 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -138,7 +138,7 @@
 
     // Unless an object is initialized with init_no_mem(), memories are
     // automatically allocated and bound.  These methods can be used to get
-    // the memories (for XGL_MEMORY_REFs), or to map/unmap the primary memory.
+    // the memories (for xglQueueAddMemReference), or to map/unmap the primary memory.
     std::vector<XGL_GPU_MEMORY> memories() const;
 
     const void *map(XGL_FLAGS flags) const;
@@ -255,9 +255,14 @@
     explicit Queue(XGL_QUEUE queue) : DerivedObject(queue) {}
 
     // xglQueueSubmit()
-    void submit(const std::vector<const CmdBuffer *> &cmds, const std::vector<XGL_MEMORY_REF> &mem_refs, Fence &fence);
-    void submit(const CmdBuffer &cmd, const std::vector<XGL_MEMORY_REF> &mem_refs, Fence &fence);
-    void submit(const CmdBuffer &cmd, const std::vector<XGL_MEMORY_REF> &mem_refs);
+    void submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence);
+    void submit(const CmdBuffer &cmd, Fence &fence);
+    void submit(const CmdBuffer &cmd);
+
+    // xglQueueAddMemReference()
+    // xglQueueRemoveMemReference()
+    void add_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs);
+    void remove_mem_references(const std::vector<XGL_GPU_MEMORY> &mem_refs);
 
     // xglQueueWaitIdle()
     void wait();
diff --git a/tests/xgltestframework.cpp b/tests/xgltestframework.cpp
index 5a9935f..55c6081 100644
--- a/tests/xgltestframework.cpp
+++ b/tests/xgltestframework.cpp
@@ -523,19 +523,17 @@
                 1, &region);
         m_cmdbuf.end();
 
-        uint32_t     numMemRefs=2;
-        XGL_MEMORY_REF memRefs[2];
-        memRefs[0].flags = 0;
-        memRefs[0].mem = m_display_image->m_presentableMemory;
-        memRefs[1].flags = 0;
-        memRefs[1].mem = buf.memories()[0];
+        xglQueueAddMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
+        xglQueueAddMemReference(m_queue.obj(), buf.memories()[0]);
 
         XGL_CMD_BUFFER cmdBufs[1];
         cmdBufs[0] = m_cmdbuf.obj();
 
-        xglQueueSubmit(m_queue.obj(), 1, cmdBufs, numMemRefs, memRefs, NULL);
+        xglQueueSubmit(m_queue.obj(), 1, cmdBufs, NULL);
         m_queue.wait();
 
+        xglQueueRemoveMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
+        xglQueueRemoveMemReference(m_queue.obj(), buf.memories()[0]);
 
         if (m_display_image->m_width > m_width)
             m_width = m_display_image->m_width;
@@ -594,6 +592,10 @@
 
 void TestFrameworkXglPresent::TearDown()
 {
+    std::list<XglTestImageRecord>::const_iterator iterator;
+    for (iterator = m_images.begin(); iterator != m_images.end(); ++iterator) {
+        xglDestroyObject(iterator->m_presentableImage);
+    }
     xcb_destroy_window(environment->m_connection, m_window);
 }
 
diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py
index 0e21ccb..01b1dd7 100755
--- a/xgl-layer-generate.py
+++ b/xgl-layer-generate.py
@@ -1235,14 +1235,14 @@
         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 @@
             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 53074ea..70e3c00 100644
--- a/xgl.py
+++ b/xgl.py
@@ -271,8 +271,6 @@
             [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",