xgl: Enable new mem ref functions
v2: remove a stale comment in the sample driver (olv)
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, ©_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, ®ion);
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",