blob: 3da0b438ef92e211f83848b28544e1436f42edd0 [file] [log] [blame]
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001/*
2 * XGL
3 *
4 * Copyright (C) 2014 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <assert.h>
29#include <pthread.h>
Chia-I Wu0f65b1e2015-01-04 23:11:43 +080030#include "xgl_dispatch_table_helper.h"
Chia-I Wu706533e2015-01-05 13:18:57 +080031#include "xgl_generic_intercept_proc_helper.h"
Tobin Ehlis791a49c2014-11-10 12:29:12 -070032#include "xgl_struct_string_helper.h"
Tobin Ehlis62086412014-11-19 16:19:28 -070033#include "mem_tracker.h"
Jon Ashburnf57ea372014-12-22 13:24:15 -070034#include "layers_config.h"
Tobin Ehlis791a49c2014-11-10 12:29:12 -070035
36static XGL_LAYER_DISPATCH_TABLE nextTable;
37static XGL_BASE_LAYER_OBJECT *pCurObj;
Jon Ashburnf57ea372014-12-22 13:24:15 -070038static pthread_once_t g_initOnce = PTHREAD_ONCE_INIT;
39
Tobin Ehlis62086412014-11-19 16:19:28 -070040// Ptr to LL of dbg functions
Jon Ashburnf57ea372014-12-22 13:24:15 -070041static XGL_LAYER_DBG_FUNCTION_NODE *g_pDbgFunctionHead = NULL;
Tobin Ehlis5b7acaa2015-01-08 14:26:53 -070042static XGL_LAYER_DBG_REPORT_LEVEL g_reportingLevel = XGL_DBG_LAYER_LEVEL_INFO;
Jon Ashburnf57ea372014-12-22 13:24:15 -070043static XGL_LAYER_DBG_ACTION g_debugAction = XGL_DBG_LAYER_ACTION_LOG_MSG;
44static FILE *g_logFile = NULL;
45
Tobin Ehlis2836a7d2015-01-08 15:22:32 -070046#define MAX_BINDING 0xFFFFFFFF
47static XGL_UINT lastVtxBinding = MAX_BINDING;
48
Tobin Ehlis62086412014-11-19 16:19:28 -070049// Utility function to handle reporting
Tobin Ehlis62086412014-11-19 16:19:28 -070050static XGL_VOID layerCbMsg(XGL_DBG_MSG_TYPE msgType,
51 XGL_VALIDATION_LEVEL validationLevel,
52 XGL_BASE_OBJECT srcObject,
53 XGL_SIZE location,
54 XGL_INT msgCode,
Chia-I Wua837c522014-12-16 10:47:33 +080055 const char* pLayerPrefix,
56 const char* pMsg)
Tobin Ehlis62086412014-11-19 16:19:28 -070057{
Jon Ashburnf57ea372014-12-22 13:24:15 -070058 if (g_debugAction & (XGL_DBG_LAYER_ACTION_LOG_MSG | XGL_DBG_LAYER_ACTION_CALLBACK)) {
59 XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
60 switch (msgType) {
Tobin Ehlis62086412014-11-19 16:19:28 -070061 case XGL_DBG_MSG_ERROR:
Jon Ashburnf57ea372014-12-22 13:24:15 -070062 if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_ERROR) {
63 if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
64 fprintf(g_logFile, "{%s}ERROR : %s\n", pLayerPrefix, pMsg);
65 if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
66 while (pTrav) {
67 pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
68 pTrav = pTrav->pNext;
69 }
70 }
Tobin Ehlis62086412014-11-19 16:19:28 -070071 break;
72 case XGL_DBG_MSG_WARNING:
Jon Ashburnf57ea372014-12-22 13:24:15 -070073 if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_WARN) {
74 if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
75 fprintf(g_logFile, "{%s}WARN : %s\n", pLayerPrefix, pMsg);
76 if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
77 while (pTrav) {
78 pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
79 pTrav = pTrav->pNext;
80 }
81 }
Tobin Ehlis62086412014-11-19 16:19:28 -070082 break;
83 case XGL_DBG_MSG_PERF_WARNING:
Jon Ashburnf57ea372014-12-22 13:24:15 -070084 if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_PERF_WARN) {
85 if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
86 fprintf(g_logFile, "{%s}PERF_WARN : %s\n", pLayerPrefix, pMsg);
87 if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
88 while (pTrav) {
89 pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
90 pTrav = pTrav->pNext;
91 }
92 }
Tobin Ehlis62086412014-11-19 16:19:28 -070093 break;
94 default:
Jon Ashburnf57ea372014-12-22 13:24:15 -070095 if (g_reportingLevel <= XGL_DBG_LAYER_LEVEL_INFO) {
96 if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
97 fprintf(g_logFile, "{%s}INFO : %s\n", pLayerPrefix, pMsg);
98 if (g_debugAction & XGL_DBG_LAYER_ACTION_CALLBACK)
99 while (pTrav) {
100 pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
101 pTrav = pTrav->pNext;
102 }
103 }
Tobin Ehlis62086412014-11-19 16:19:28 -0700104 break;
105 }
106 }
107}
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700108
109static GLOBAL_CB_NODE* pGlobalCBHead = NULL;
110static GLOBAL_MEM_OBJ_NODE* pGlobalMemObjHead = NULL;
111static GLOBAL_OBJECT_NODE* pGlobalObjectHead = NULL;
112static XGL_DEVICE globalDevice = NULL;
Tobin Ehlis62086412014-11-19 16:19:28 -0700113static uint64_t numCBNodes = 0;
114static uint64_t numMemObjNodes = 0;
115static uint64_t numObjectNodes = 0;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700116// Check list for data and if it's not included insert new node
117// into HEAD of list pointed to by pHEAD & update pHEAD
Tobin Ehlis62086412014-11-19 16:19:28 -0700118// Increment 'insert' if new node was inserted
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700119// return XGL_SUCCESS if no errors occur
120static XGL_RESULT insertMiniNode(MINI_NODE** pHEAD, const XGL_BASE_OBJECT data, XGL_UINT* insert)
121{
122 MINI_NODE* pTrav = *pHEAD;
123 while (pTrav && (pTrav->data != data)) {
124 pTrav = pTrav->pNext;
125 }
126 if (!pTrav) { // Add node to front of LL
127 pTrav = (MINI_NODE*)malloc(sizeof(MINI_NODE));
128 if (!pTrav)
129 return XGL_ERROR_OUT_OF_MEMORY;
130 memset(pTrav, 0, sizeof(MINI_NODE));
131 if (*pHEAD)
132 pTrav->pNext = *pHEAD;
133 *pHEAD = pTrav;
134 *insert += 1;
135 //pMemTrav->refCount++;
Tobin Ehlis62086412014-11-19 16:19:28 -0700136 //sprintf(str, "MEM INFO : Incremented refCount for mem obj %p to %u", (void*)mem, pMemTrav->refCount);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700137 }
138 if (pTrav->data) { // This is just FYI
139 assert(data == pTrav->data);
Tobin Ehlis62086412014-11-19 16:19:28 -0700140 char str[1024];
141 sprintf(str, "Data %p is already in data LL w/ HEAD at %p", data, *pHEAD);
142 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, data, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700143 }
144 pTrav->data = data;
145 return XGL_SUCCESS;
146}
147
148// Add new CB node for this cb at end of global CB LL
149static void insertGlobalCB(const XGL_CMD_BUFFER cb)
150{
151 GLOBAL_CB_NODE* pTrav = pGlobalCBHead;
152 if (!pTrav) {
153 pTrav = (GLOBAL_CB_NODE*)malloc(sizeof(GLOBAL_CB_NODE));
154 pGlobalCBHead = pTrav;
155 }
156 else {
157 while (NULL != pTrav->pNextGlobalCBNode)
158 pTrav = pTrav->pNextGlobalCBNode;
159 pTrav->pNextGlobalCBNode = (GLOBAL_CB_NODE*)malloc(sizeof(GLOBAL_CB_NODE));
160 pTrav = pTrav->pNextGlobalCBNode;
161 }
Tobin Ehlis62086412014-11-19 16:19:28 -0700162 if (!pTrav) {
163 char str[1024];
164 sprintf(str, "Malloc failed to alloc node for Cmd Buffer %p", (void*)cb);
165 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_OUT_OF_MEMORY_ERROR, "MEM", str);
166 }
167 else {
168 numCBNodes++;
169 memset(pTrav, 0, sizeof(GLOBAL_CB_NODE));
170 pTrav->cmdBuffer = cb;
171 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700172}
173
174// Return ptr to node in global LL containing cb, or NULL if not found
175static GLOBAL_CB_NODE* getGlobalCBNode(const XGL_CMD_BUFFER cb)
176{
177 GLOBAL_CB_NODE* pTrav = pGlobalCBHead;
178 while (pTrav && (pTrav->cmdBuffer != cb))
179 pTrav = pTrav->pNextGlobalCBNode;
180 return pTrav;
181}
182// Set fence for given cb in global cb node
183static XGL_BOOL setCBFence(const XGL_CMD_BUFFER cb, const XGL_FENCE fence)
184{
185 GLOBAL_CB_NODE* pTrav = getGlobalCBNode(cb);
186 if (!pTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700187 char str[1024];
188 sprintf(str, "Unable to find node for CB %p in order to set fence to %p", (void*)cb, (void*)fence);
189 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700190 return XGL_FALSE;
191 }
192 pTrav->fence = fence;
193 return XGL_TRUE;
194}
195
196static XGL_BOOL validateCBMemRef(const XGL_CMD_BUFFER cb, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs)
197{
198 GLOBAL_CB_NODE* pTrav = getGlobalCBNode(cb);
199 if (!pTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700200 char str[1024];
201 sprintf(str, "Unable to find node for CB %p in order to check memory references", (void*)cb);
202 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700203 return XGL_FALSE;
204 }
205 // Validate that all actual references are accounted for in pMemRefs
206 MINI_NODE* pMemNode = pTrav->pMemObjList;
207 uint32_t i;
208 uint8_t found = 0;
209 uint64_t foundCount = 0;
210 while (pMemNode) {
211 // TODO : Improve this algorithm
212 for (i = 0; i < memRefCount; i++) {
213 if (pMemNode->mem == pMemRefs[i].mem) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700214 char str[1024];
215 sprintf(str, "Found Mem Obj %p binding to CB %p", pMemNode->mem, cb);
216 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700217 found = 1;
218 foundCount++;
Tobin Ehlisa747e682014-11-25 14:47:20 -0700219 break;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700220 }
221 }
222 if (!found) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700223 char str[1024];
224 sprintf(str, "Memory reference list for Command Buffer %p is missing ref to mem obj %p", cb, pMemNode->mem);
225 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_CB_MISSING_MEM_REF, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700226 return XGL_FALSE;
227 }
228 found = 0;
229 pMemNode = pMemNode->pNext;
230 }
Tobin Ehlis62086412014-11-19 16:19:28 -0700231 char str[1024];
232 sprintf(str, "Verified all %lu memory dependencies for CB %p are included in pMemRefs list", foundCount, cb);
233 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700234 // TODO : Could report mem refs in pMemRefs that AREN'T in mem LL, that would be primarily informational
235 // Currently just noting that there is a difference
Tobin Ehlis62086412014-11-19 16:19:28 -0700236 if (foundCount != memRefCount) {
237 sprintf(str, "Note that %u mem refs included in pMemRefs list, but only %lu appear to be required", memRefCount, foundCount);
238 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
239 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700240 return XGL_TRUE;
241}
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700242// Return ptr to node in global LL containing mem, or NULL if not found
243static GLOBAL_MEM_OBJ_NODE* getGlobalMemNode(const XGL_GPU_MEMORY mem)
244{
245 GLOBAL_MEM_OBJ_NODE* pTrav = pGlobalMemObjHead;
246 while (pTrav && (pTrav->mem != mem))
247 pTrav = pTrav->pNextGlobalNode;
248 return pTrav;
249}
250
251// Set a memory state transition for region of memory
252static void setMemTransition(const XGL_GPU_MEMORY mem, const XGL_MEMORY_STATE_TRANSITION* pTransition)
253{
254 // find memory node
255 GLOBAL_MEM_OBJ_NODE* pTrav = getGlobalMemNode(mem);
256 if (NULL == pTrav) {
257 // TODO : Flag error for missing node
258 }
259 else {
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700260 MEM_STATE_TRANSITION_NODE* pMTNode = pTrav->pRegions;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700261 MEM_STATE_TRANSITION_NODE* pPrevMTNode = pMTNode;
262 // TODO : Not sure of best way (or need) to distinguish mem from image here
263 // Verify that it's being used as memory (not image)
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700264 //if (!pTrav->pRegions.isMem) {
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700265 // TODO : Flag error for setting mem transition on image memory
266 //}
267 // Basic state update algorithm
268 // 1. Find insertion point where offset of new region will fall
269 // 1a. If insertion falls in middle of existing region, split that region
270 // 2. Find end point where offset+regionSize of new region will fall
271 // 2b. If end falls in middle of existing region, split
272 // 3. Free any newly unneeded regions
273
274 // As we make insertions, set ptr to first node to free and count number of nodes to free
275 uint32_t numToFree = 0;
276 MEM_STATE_TRANSITION_NODE* pFreeMe = NULL;
277 // Bool to track if start node was split so we don't delete it
278 uint32_t saveStartNode = 0;
279 // Create new node
280 MEM_STATE_TRANSITION_NODE* pNewNode = (MEM_STATE_TRANSITION_NODE*)malloc(sizeof(MEM_STATE_TRANSITION_NODE));
281 memset(pNewNode, 0, sizeof(MEM_STATE_TRANSITION_NODE));
282 memcpy(&pNewNode->transition, pTransition, sizeof(XGL_MEMORY_STATE_TRANSITION));
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700283 // Increment numRegions here and will be appropriately decremented below if needed
284 pTrav->numRegions++;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700285 if (!pMTNode) { // Initialization case, just set HEAD ptr to new node
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700286 pTrav->pRegions = pNewNode;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700287 }
288 else {
289 // If offset of new state is less than current offset, insert it & update state after it as needed
290 while (pMTNode->transition.memory.offset > pTransition->offset) {
291 pPrevMTNode = pMTNode;
292 pMTNode = pMTNode->pNext;
293 }
294 // pMTNode is the region where new region's start will fall
295 if (pTransition->offset > pMTNode->transition.memory.offset) {
296 // split start region
297 saveStartNode = 1;
298 pMTNode->transition.memory.regionSize = pTransition->offset - pMTNode->transition.memory.offset;
299 pMTNode->pNext = pNewNode;
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700300 // TODO: Verify that prev newState matches new oldState
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700301 }
302 else { // start point of regions are equal
303 // Prev ptr now points to new region
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700304 if (pPrevMTNode == pTrav->pRegions)
305 pTrav->pRegions = pNewNode;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700306 else
307 pPrevMTNode->pNext = pNewNode;
308 }
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700309 // New region is overlaying old region so make sure states match
310 if (pMTNode->transition.memory.newState != pNewNode->transition.memory.oldState) {
311 char str[1024];
312 sprintf(str, "Setting Memory state transition for mem %p, current newState of %s doesn't match overlapping transition oldState of %s", mem, string_XGL_MEMORY_STATE(pMTNode->transition.memory.newState), string_XGL_MEMORY_STATE(pNewNode->transition.memory.oldState));
313 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
314 }
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700315 // Start point insertion complete, find end point
316 XGL_GPU_SIZE newEndPoint = pTransition->offset + pTransition->regionSize;
317 XGL_GPU_SIZE curEndPoint = pMTNode->transition.memory.offset + pMTNode->transition.memory.regionSize;
318 while (newEndPoint > curEndPoint) {
319 // Flag any passed-over regions here for deletion
320 if (NULL == pFreeMe) {
321 pFreeMe = pMTNode;
322 }
323 numToFree++;
324 pPrevMTNode = pMTNode;
325 pMTNode = pMTNode->pNext;
326 // TODO : Handle NULL pMTNode case
327 curEndPoint = pMTNode->transition.memory.offset + pMTNode->transition.memory.regionSize;
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700328 if (pMTNode->transition.memory.newState != pNewNode->transition.memory.oldState) {
329 char str[1024];
330 sprintf(str, "Setting Memory state transition for mem %p, current newState of %s doesn't match overlapping transition oldState of %s", mem, string_XGL_MEMORY_STATE(pMTNode->transition.memory.newState), string_XGL_MEMORY_STATE(pNewNode->transition.memory.oldState));
331 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
332 }
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700333 }
334 if (newEndPoint < curEndPoint) {
335 // split end region
336 pMTNode->transition.memory.offset = pTransition->offset + pTransition->regionSize;
337 pNewNode->pNext = pMTNode;
338 }
339 else { // end points of regions are equal
340 pNewNode->pNext = pMTNode->pNext;
341 numToFree++;
342 if (NULL == pFreeMe)
343 pFreeMe = pMTNode;
344 }
345 // Free any regions that are no longer needed
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700346 if ((1 == saveStartNode) && (NULL != pFreeMe)) {
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700347 pFreeMe = pFreeMe->pNext;
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700348 numToFree--;
349 }
350 pTrav->numRegions -= numToFree;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700351 MEM_STATE_TRANSITION_NODE* pNodeToFree;
352 while (numToFree) {
353 pNodeToFree = pFreeMe;
354 pFreeMe = pFreeMe->pNext;
355 free(pNodeToFree);
356 numToFree--;
357 }
358 }
359 }
360}
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700361
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700362static void insertGlobalMemObj(const XGL_GPU_MEMORY mem, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_IMAGE_STATE defaultState)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700363{
364 GLOBAL_MEM_OBJ_NODE* pTrav = pGlobalMemObjHead;
365 if (!pTrav) {
366 pTrav = (GLOBAL_MEM_OBJ_NODE*)malloc(sizeof(GLOBAL_MEM_OBJ_NODE));
367 pGlobalMemObjHead = pTrav;
368 }
369 else {
370 while (NULL != pTrav->pNextGlobalNode)
371 pTrav = pTrav->pNextGlobalNode;
372 pTrav->pNextGlobalNode = (GLOBAL_MEM_OBJ_NODE*)malloc(sizeof(GLOBAL_MEM_OBJ_NODE));
373 pTrav = pTrav->pNextGlobalNode;
374 }
Tobin Ehlis62086412014-11-19 16:19:28 -0700375 if (!pTrav) {
376 char str[1024];
377 sprintf(str, "Malloc failed to alloc node for Mem Object %p", (void*)mem);
378 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_OUT_OF_MEMORY_ERROR, "MEM", str);
379 }
380 else {
381 numMemObjNodes++;
382 memset(pTrav, 0, sizeof(GLOBAL_MEM_OBJ_NODE));
383 if (pAllocInfo) // MEM alloc created by xglWsiX11CreatePresentableImage() doesn't have alloc info struct
384 memcpy(&pTrav->allocInfo, pAllocInfo, sizeof(XGL_MEMORY_ALLOC_INFO));
385 pTrav->mem = mem;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700386 if (pAllocInfo) { // TODO : How to handle Wsi-created alloc?
387 // Create initial state node that covers entire allocation
388 // TODO : How to handle image memory?
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700389 pTrav->numRegions = 0; // This will be updated during setMemTransition call
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700390 XGL_MEMORY_STATE_TRANSITION initMemStateTrans;
391 memset(&initMemStateTrans, 0, sizeof(XGL_MEMORY_STATE_TRANSITION));
392 initMemStateTrans.sType = XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION;
393 initMemStateTrans.mem = mem;
394 initMemStateTrans.oldState = defaultState;
395 initMemStateTrans.newState = defaultState;
396 initMemStateTrans.offset = 0;
397 initMemStateTrans.regionSize = pAllocInfo->allocationSize;
398 setMemTransition(mem, &initMemStateTrans);
399 }
Tobin Ehlis62086412014-11-19 16:19:28 -0700400 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700401}
402
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700403// Find Global CB Node and add mem binding to mini LL
404// Find Global Mem Obj Node and add CB binding to mini LL
405static XGL_BOOL updateCBBinding(const XGL_CMD_BUFFER cb, const XGL_GPU_MEMORY mem)
406{
407 // First update CB binding in MemObj mini CB list
408 GLOBAL_MEM_OBJ_NODE* pMemTrav = getGlobalMemNode(mem);
409 if (!pMemTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700410 char str[1024];
411 sprintf(str, "Trying to bind mem obj %p to CB %p but no Node for that mem obj.\n Was it correctly allocated? Did it already get freed?", mem, cb);
412 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700413 return XGL_FALSE;
414 }
415
416 XGL_RESULT result = insertMiniNode(&pMemTrav->pCmdBufferBindings, cb, &pMemTrav->refCount);
417 if (XGL_SUCCESS != result)
418 return result;
419
420 // Now update Global CB's Mini Mem binding list
421 GLOBAL_CB_NODE* pCBTrav = getGlobalCBNode(cb);
422 if (!pCBTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700423 char str[1024];
424 sprintf(str, "Trying to bind mem obj %p to CB %p but no Node for that CB. Was it CB incorrectly destroyed?", mem, cb);
425 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700426 return XGL_FALSE;
427 }
428 XGL_UINT dontCare;
429 result = insertMiniNode(&pCBTrav->pMemObjList, mem, &dontCare);
430 if (XGL_SUCCESS != result)
431 return result;
432
433 return XGL_TRUE;
434}
435// Clear the CB Binding for mem
436static void clearCBBinding(const XGL_CMD_BUFFER cb, const XGL_GPU_MEMORY mem)
437{
438 GLOBAL_MEM_OBJ_NODE* pTrav = getGlobalMemNode(mem);
439 MINI_NODE* pMiniCB = pTrav->pCmdBufferBindings;
440 MINI_NODE* pPrev = pMiniCB;
441 while (pMiniCB && (cb != pMiniCB->cmdBuffer)) {
442 pPrev = pMiniCB;
443 pMiniCB = pMiniCB->pNext;
444 }
445 if (!pMiniCB) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700446 char str[1024];
447 sprintf(str, "Trying to clear CB binding but CB %p not in binding list for mem obj %p", cb, mem);
448 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700449 }
450 else { // remove node from list & decrement refCount
451 pPrev->pNext = pMiniCB->pNext;
452 if (pMiniCB == pTrav->pCmdBufferBindings)
453 pTrav->pCmdBufferBindings = NULL;
454 free(pMiniCB);
455 pTrav->refCount--;
456 }
457}
458// Free bindings related to CB
459static XGL_BOOL freeCBBindings(const XGL_CMD_BUFFER cb)
460{
461 GLOBAL_CB_NODE* pCBTrav = getGlobalCBNode(cb);
462 if (!pCBTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700463 char str[1024];
464 sprintf(str, "Unable to find global CB node %p for deletion", cb);
465 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700466 return XGL_FALSE;
467 }
468 MINI_NODE* pMemTrav = pCBTrav->pMemObjList;
469 MINI_NODE* pDeleteMe = NULL;
470 // We traverse LL in order and free nodes as they're cleared
471 while (pMemTrav) {
472 pDeleteMe = pMemTrav;
473 if (pMemTrav->mem)
474 clearCBBinding(cb, pMemTrav->mem);
475 pMemTrav = pMemTrav->pNext;
476 free(pDeleteMe);
477 }
478 pCBTrav->pMemObjList = NULL;
479 return XGL_TRUE;
480}
481// Delete Global CB Node from list along with all of it's mini mem obj node
482// and also clear Global mem references to CB
483// TODO : When should this be called? There's no Destroy of CBs that I see
484static XGL_BOOL deleteGlobalCBNode(const XGL_CMD_BUFFER cb)
485{
486 if (XGL_FALSE == freeCBBindings(cb))
487 return XGL_FALSE;
488 // Delete the Global CB node
489 GLOBAL_CB_NODE* pCBTrav = getGlobalCBNode(cb);
490 pCBTrav = pGlobalCBHead;
491 GLOBAL_CB_NODE* pPrev = pCBTrav;
492 while (pCBTrav && (cb != pCBTrav->cmdBuffer)) {
493 pPrev = pCBTrav;
494 pCBTrav = pCBTrav->pNextGlobalCBNode;
495 }
496 assert(cb); // We found node at start of function so it should still be here
497 pPrev->pNextGlobalCBNode = pCBTrav->pNextGlobalCBNode;
498 if (pCBTrav == pGlobalCBHead)
499 pGlobalCBHead = pCBTrav->pNextGlobalCBNode;
500 free(pCBTrav);
501 return XGL_TRUE;
502}
503// Delete the entire CB list
504static XGL_BOOL deleteGlobalCBList()
505{
506 XGL_BOOL result = XGL_TRUE;
507 GLOBAL_CB_NODE* pCBTrav = pGlobalCBHead;
508 while (pCBTrav) {
Tobin Ehlisa747e682014-11-25 14:47:20 -0700509 XGL_CMD_BUFFER cbToDelete = pCBTrav->cmdBuffer;
510 pCBTrav = pCBTrav->pNextGlobalCBNode;
511 XGL_BOOL tmpResult = deleteGlobalCBNode(cbToDelete);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700512 // If any result is FALSE, final result should be FALSE
513 if ((XGL_FALSE == tmpResult) || (XGL_FALSE == result))
514 result = XGL_FALSE;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700515 }
516 return result;
517}
518
519// For given MemObj node, report Obj & CB bindings
520static void reportMemReferences(const GLOBAL_MEM_OBJ_NODE* pMemObjTrav)
521{
522 XGL_UINT refCount = 0; // Count found references
523 MINI_NODE* pObjTrav = pMemObjTrav->pObjBindings;
524 MINI_NODE* pCBTrav = pMemObjTrav->pCmdBufferBindings;
525 while (pCBTrav) {
526 refCount++;
Tobin Ehlis62086412014-11-19 16:19:28 -0700527 char str[1024];
528 sprintf(str, "Command Buffer %p has reference to mem obj %p", pCBTrav->cmdBuffer, pMemObjTrav->mem);
529 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCBTrav->cmdBuffer, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700530 pCBTrav = pCBTrav->pNext;
531 }
532 while (pObjTrav) {
533 refCount++;
Tobin Ehlis62086412014-11-19 16:19:28 -0700534 char str[1024];
535 sprintf(str, "XGL Object %p has reference to mem obj %p", pObjTrav->object, pMemObjTrav->mem);
536 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pObjTrav->object, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700537 pObjTrav = pObjTrav->pNext;
538 }
539 if (refCount != pMemObjTrav->refCount) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700540 char str[1024];
541 sprintf(str, "Refcount of %u for Mem Obj %p does't match reported refs of %u", pMemObjTrav->refCount, pMemObjTrav->mem, refCount);
542 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pObjTrav->object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700543 }
544}
545
546static void deleteGlobalMemNode(XGL_GPU_MEMORY mem)
547{
548 GLOBAL_MEM_OBJ_NODE* pTrav = pGlobalMemObjHead;
549 GLOBAL_MEM_OBJ_NODE* pPrev = pTrav;
550 while (pTrav && (pTrav->mem != mem)) {
551 pPrev = pTrav;
552 pTrav = pTrav->pNextGlobalNode;
553 }
554 if (pTrav) {
555 pPrev->pNextGlobalNode = pTrav->pNextGlobalNode;
556 if (pGlobalMemObjHead == pTrav)
557 pGlobalMemObjHead = pTrav->pNextGlobalNode;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700558 // delete transition list off of this node
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700559 MEM_STATE_TRANSITION_NODE* pMSTNode = pTrav->pRegions;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700560 MEM_STATE_TRANSITION_NODE* pPrevMSTNode = pMSTNode;
561 while(pMSTNode) {
562 pPrevMSTNode = pMSTNode;
563 pMSTNode = pMSTNode->pNext;
564 free(pPrevMSTNode);
565 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700566 free(pTrav);
567 }
568 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700569 char str[1024];
570 sprintf(str, "Could not find global mem obj node for %p to delete!", mem);
571 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700572 }
573}
574// Check if fence for given CB is completed
575static XGL_BOOL checkCBCompleted(const XGL_CMD_BUFFER cb)
576{
577 GLOBAL_CB_NODE* pCBTrav = getGlobalCBNode(cb);
578 if (!pCBTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700579 char str[1024];
580 sprintf(str, "Unable to find global CB node %p to check for completion", cb);
581 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700582 return XGL_FALSE;
583 }
584 if (!pCBTrav->fence) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700585 char str[1024];
586 sprintf(str, "No fence found for CB %p to check for completion", cb);
587 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_CB_MISSING_FENCE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700588 return XGL_FALSE;
589 }
590 if (XGL_SUCCESS != nextTable.GetFenceStatus(pCBTrav->fence)) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700591 char str[1024];
592 sprintf(str, "Fence %p for CB %p has not completed", pCBTrav->fence, cb);
593 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700594 return XGL_FALSE;
595 }
596 return XGL_TRUE;
597}
598
599static XGL_BOOL freeMemNode(XGL_GPU_MEMORY mem)
600{
601 XGL_BOOL result = XGL_TRUE;
602 // Parse global list to find node w/ mem
603 GLOBAL_MEM_OBJ_NODE* pTrav = getGlobalMemNode(mem);
604 if (!pTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700605 char str[1024];
606 sprintf(str, "Couldn't find mem node object for %p\n Was %p never allocated or previously freed?", (void*)mem, (void*)mem);
607 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700608 return XGL_FALSE;
609 }
610 else {
611 // First clear any CB bindings for completed CBs
612 // TODO : Is there a better place to do this?
613 MINI_NODE* pMiniCB = pTrav->pCmdBufferBindings;
614 while (pMiniCB) {
615 XGL_CMD_BUFFER curCB = pMiniCB->cmdBuffer;
616 pMiniCB = pMiniCB->pNext;
617 if (XGL_TRUE == checkCBCompleted(curCB)) {
618 freeCBBindings(curCB);
619 }
620 }
621 // Now verify that no references to this mem obj remain
622 if (0 != pTrav->refCount) {
623 // If references remain, report the error and can search down CB LL to find references
624 result = XGL_FALSE;
Tobin Ehlis62086412014-11-19 16:19:28 -0700625 char str[1024];
626 sprintf(str, "Freeing mem obj %p while it still has references", (void*)mem);
627 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700628 reportMemReferences(pTrav);
629 }
630 // Delete global node
631 deleteGlobalMemNode(mem);
632 }
633 return result;
634}
635
636// Return object node for 'object' or return NULL if no node exists
637static GLOBAL_OBJECT_NODE* getGlobalObjectNode(const XGL_OBJECT object)
638{
639 GLOBAL_OBJECT_NODE* pTrav = pGlobalObjectHead;
640 while (pTrav && (object != pTrav->object)) {
641 pTrav = pTrav->pNext;
642 }
643 return pTrav;
644}
645
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700646static GLOBAL_OBJECT_NODE* insertGlobalObjectNode(XGL_OBJECT object, XGL_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, char *name_prefix)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700647{
648 GLOBAL_OBJECT_NODE* pTrav = pGlobalObjectHead;
649 if (!pTrav) {
650 pTrav = (GLOBAL_OBJECT_NODE*)malloc(sizeof(GLOBAL_OBJECT_NODE));
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700651 memset(pTrav, 0, sizeof(GLOBAL_OBJECT_NODE));
652 pGlobalObjectHead = pTrav;
653 }
654 else {
655 GLOBAL_OBJECT_NODE* pPrev = pTrav;
656 while (pTrav) {
657 pPrev = pTrav;
658 pTrav = pTrav->pNext;
659 }
660 pTrav = (GLOBAL_OBJECT_NODE*)malloc(sizeof(GLOBAL_OBJECT_NODE));
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700661 memset(pTrav, 0, sizeof(GLOBAL_OBJECT_NODE));
662 pPrev->pNext = pTrav;
663 }
Tobin Ehlis62086412014-11-19 16:19:28 -0700664 if (!pTrav) {
665 char str[1024];
666 sprintf(str, "Malloc failed to alloc node for XGL Object %p", (void*)object);
667 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_OUT_OF_MEMORY_ERROR, "MEM", str);
668 return NULL;
669 }
670 else {
671 numObjectNodes++;
672 pTrav->object = object;
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700673 pTrav->ref_count = 1;
674 pTrav->sType = sType;
675 memcpy(&pTrav->create_info, pCreateInfo, struct_size);
676 sprintf(pTrav->object_name, "%s_%p", name_prefix, object);
Tobin Ehlis62086412014-11-19 16:19:28 -0700677 return pTrav;
678 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700679}
680
681// Remove object binding performs 3 tasks:
682// 1. Remove object node from Global Mem Obj mini LL of obj bindings & free it
683// 2. Decrement refCount for Global Mem Obj
684// 3. Clear Global Mem Obj ptr from Global Object Node
685static XGL_BOOL clearObjectBinding(XGL_OBJECT object)
686{
687 GLOBAL_OBJECT_NODE* pGlobalObjTrav = getGlobalObjectNode(object);
688 if (!pGlobalObjTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700689 char str[1024];
690 sprintf(str, "Attempting to clear mem binding for object %p", object);
691 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700692 return XGL_FALSE;
693 }
694 if (!pGlobalObjTrav->pMemNode) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700695 char str[1024];
696 sprintf(str, "Attempting to clear mem binding on obj %p but it has no binding.", (void*)object);
697 layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700698 return XGL_FALSE;
699 }
700 MINI_NODE* pObjTrav = pGlobalObjTrav->pMemNode->pObjBindings;
701 MINI_NODE* pPrevObj = pObjTrav;
702 while (pObjTrav) {
703 if (object == pObjTrav->object) {
704 pPrevObj->pNext = pObjTrav->pNext;
705 // check if HEAD needs to be updated
706 if (pGlobalObjTrav->pMemNode->pObjBindings == pObjTrav)
707 pGlobalObjTrav->pMemNode->pObjBindings = pObjTrav->pNext;
708 free(pObjTrav);
709 pGlobalObjTrav->pMemNode->refCount--;
710 pGlobalObjTrav->pMemNode = NULL;
711 return XGL_TRUE;
712 }
713 pPrevObj = pObjTrav;
714 pObjTrav = pObjTrav->pNext;
715 }
Tobin Ehlis62086412014-11-19 16:19:28 -0700716 char str[1024];
717 sprintf(str, "While trying to clear mem binding for object %p, unable to find that object referenced by mem obj %p", object, pGlobalObjTrav->pMemNode->mem);
718 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700719 return XGL_FALSE;
720}
721
722// For NULL mem case, clear any previous binding Else...
723// Make sure given object is in global object LL
Tobin Ehlis62086412014-11-19 16:19:28 -0700724// IF a previous binding existed, clear it
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700725// Add link from global object node to global memory node
726// Add mini-object node & reference off of global obj node
727// Return XGL_TRUE if addition is successful, XGL_FALSE otherwise
728static XGL_BOOL updateObjectBinding(XGL_OBJECT object, XGL_GPU_MEMORY mem)
729{
730 // Handle NULL case separately, just clear previous binding & decrement reference
731 if (mem == XGL_NULL_HANDLE) {
732 clearObjectBinding(object);
733 return XGL_TRUE;
734 }
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700735 char str[1024];
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700736 GLOBAL_OBJECT_NODE* pGlobalObjTrav = getGlobalObjectNode(object);
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700737 assert(pGlobalObjTrav);
738 if (!pGlobalObjTrav) {
739 sprintf(str, "Attempting to update Binding of Obj(%p) that's not in global list()", (void*)object);
740 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
741 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700742 // non-null case so should have real mem obj
743 GLOBAL_MEM_OBJ_NODE* pTrav = getGlobalMemNode(mem);
744 if (!pTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700745 sprintf(str, "While trying to bind mem for obj %p, couldn't find node for mem obj %p", (void*)object, (void*)mem);
746 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700747 return XGL_FALSE;
748 }
749 XGL_RESULT result = insertMiniNode(&pTrav->pObjBindings, object, &pTrav->refCount);
750 if (XGL_SUCCESS != result)
751 return result;
752
Tobin Ehlis62086412014-11-19 16:19:28 -0700753 if (pGlobalObjTrav->pMemNode) {
754 clearObjectBinding(object); // Need to clear the previous object binding before setting new binding
Tobin Ehlis62086412014-11-19 16:19:28 -0700755 sprintf(str, "Updating memory binding for object %p from mem obj %p to %p", object, pGlobalObjTrav->pMemNode->mem, mem);
756 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_NONE, "MEM", str);
757 }
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700758 // For image objects, make sure default memory state is correctly set
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700759 // TODO : What's the best/correct way to handle this?
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700760 if (XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO == pGlobalObjTrav->sType) {
761 if (pGlobalObjTrav->create_info.image_create_info.usage & (XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700762 XGL_MEMORY_STATE_TRANSITION initMemStateTrans;
763 memset(&initMemStateTrans, 0, sizeof(XGL_MEMORY_STATE_TRANSITION));
764 initMemStateTrans.mem = mem;
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700765 //initMemStateTrans.oldState = XGL_IMAGE_STATE_UNINITIALIZED_TARGET;
766 //initMemStateTrans.newState = XGL_IMAGE_STATE_UNINITIALIZED_TARGET;
767 // TODO : For now just using initial memory state
768 initMemStateTrans.oldState = XGL_MEMORY_STATE_DATA_TRANSFER;
769 initMemStateTrans.newState = XGL_MEMORY_STATE_DATA_TRANSFER;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700770 initMemStateTrans.offset = 0;
771 initMemStateTrans.regionSize = pTrav->allocInfo.allocationSize;
772 setMemTransition(mem, &initMemStateTrans);
773/*
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700774 pTrav->transition.image.oldState = XGL_IMAGE_STATE_UNINITIALIZED_TARGET;
775 pTrav->transition.image.newState = XGL_IMAGE_STATE_UNINITIALIZED_TARGET;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700776*/
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700777 }
778 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700779 pGlobalObjTrav->pMemNode = pTrav;
780 return XGL_TRUE;
781}
782// Print details of global Obj tracking list
783static void printObjList()
784{
785 GLOBAL_OBJECT_NODE* pGlobalObjTrav = pGlobalObjectHead;
786 if (!pGlobalObjTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700787 char str[1024];
788 sprintf(str, "Global Object list is empty :(\n");
789 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700790 }
791 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700792 char str[1024];
793 sprintf(str, "Details of Global Object list w/ HEAD at %p", (void*)pGlobalObjTrav);
794 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700795 while (pGlobalObjTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700796 sprintf(str, " GlobObjNode %p has object %p, pNext %p, pMemNode %p", pGlobalObjTrav, pGlobalObjTrav->object, pGlobalObjTrav->pNext, pGlobalObjTrav->pMemNode);
797 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pGlobalObjTrav->object, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700798 pGlobalObjTrav = pGlobalObjTrav->pNext;
799 }
800 }
801}
802// For given Object, get 'mem' obj that it's bound to or NULL if no binding
803static XGL_GPU_MEMORY getMemBindingFromObject(const XGL_OBJECT object)
804{
805 XGL_GPU_MEMORY mem = NULL;
806 GLOBAL_OBJECT_NODE* pObjNode = getGlobalObjectNode(object);
807 if (pObjNode) {
808 if (pObjNode->pMemNode) {
809 mem = pObjNode->pMemNode->mem;
810 }
811 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700812 char str[1024];
813 sprintf(str, "Trying to get mem binding for object %p but object has no mem binding", (void*)object);
814 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700815 printObjList();
816 }
817 }
818 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700819 char str[1024];
820 sprintf(str, "Trying to get mem binding for object %p but no such object in global list", (void*)object);
821 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700822 printObjList();
823 }
824 return mem;
825}
826// Print details of global Mem Obj list
827static void printMemList()
828{
829 GLOBAL_MEM_OBJ_NODE* pTrav = pGlobalMemObjHead;
Tobin Ehlis62086412014-11-19 16:19:28 -0700830 // Just printing each msg individually for now, may want to package these into single large print
831 char str[1024];
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700832 if (!pTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700833 sprintf(str, "MEM INFO : Global Memory Object list is empty :(\n");
834 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700835 }
836 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700837 sprintf(str, "MEM INFO : Details of Global Memory Object list w/ HEAD at %p", (void*)pTrav);
838 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700839 while (pTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700840 sprintf(str, " ===MemObj Node at %p===", (void*)pTrav);
841 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
842 sprintf(str, " Mem object: %p", (void*)pTrav->mem);
843 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
844 sprintf(str, " Ref Count: %u", pTrav->refCount);
845 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
846 sprintf(str, " pNext Mem Obj Node: %p", (void*)pTrav->pNextGlobalNode);
847 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
848 if (0 != pTrav->allocInfo.allocationSize)
849 sprintf(str, " Mem Alloc info:\n%s", xgl_print_xgl_memory_alloc_info(&pTrav->allocInfo, "{MEM}INFO : "));
850 else
851 sprintf(str, " Mem Alloc info is NULL (alloc done by xglWsiX11CreatePresentableImage())");
852 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700853 MINI_NODE* pObjTrav = pTrav->pObjBindings;
Tobin Ehlis62086412014-11-19 16:19:28 -0700854 if (!pObjTrav) {
855 sprintf(str, " No XGL Object bindings");
856 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
857 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700858 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700859 sprintf(str, " XGL OBJECT Binding list w/ HEAD at %p:", pObjTrav);
860 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700861 while (pObjTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700862 sprintf(str, " OBJ_NODE(%p): XGL OBJECT %p, pNext %p", pObjTrav, pObjTrav->object, pObjTrav->pNext);
863 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700864 pObjTrav = pObjTrav->pNext;
865 }
866 }
867 MINI_NODE* pCBTrav = pTrav->pCmdBufferBindings;
Tobin Ehlis62086412014-11-19 16:19:28 -0700868 if (!pCBTrav) {
869 sprintf(str, " No Command Buffer bindings");
870 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
871 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700872 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700873 sprintf(str, " XGL Command Buffer (CB) binding list w/ HEAD at %p:", pCBTrav);
874 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700875 while (pCBTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700876 sprintf(str, " CB_NODE(%p): XGL CB %p, pNext %p", pCBTrav, pCBTrav->cmdBuffer, pCBTrav->pNext);
877 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700878 pCBTrav = pCBTrav->pNext;
879 }
880 }
Tobin Ehlis366fbd32015-01-14 12:47:30 -0700881 MEM_STATE_TRANSITION_NODE* pTrans = pTrav->pRegions;
882 if (!pTrans) {
883 sprintf(str, " No regions");
884 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
885 }
886 else {
887 sprintf(str, " XGL_MEMORY_STATE_TRANSITION (MST) regions list w/ HEAD at %p:", pTrans);
888 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
889 while (pTrans) {
890 sprintf(str, " MST_NODE(%p):\n%s", pTrans, xgl_print_xgl_memory_state_transition(&pTrans->transition.memory, "{MEM}INFO : "));
891 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
892 pTrans = pTrans->pNext;
893 }
894 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700895 pTrav = pTrav->pNextGlobalNode;
896 }
897 }
898}
899
900static void printGlobalCB()
901{
Tobin Ehlis62086412014-11-19 16:19:28 -0700902 char str[1024] = {0};
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700903 GLOBAL_CB_NODE* pTrav = pGlobalCBHead;
904 if (!pTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700905 sprintf(str, "Global Command Buffer (CB) list is empty :(\n");
906 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700907 }
908 else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700909 sprintf(str, "Details of Global CB list w/ HEAD at %p:", (void*)pTrav);
910 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700911 while (pTrav) {
Tobin Ehlisa747e682014-11-25 14:47:20 -0700912 sprintf(str, " Global CB Node (%p) w/ pNextGlobalCBNode (%p) has CB %p, fence %p, and pMemObjList %p", (void*)pTrav, (void*)pTrav->pNextGlobalCBNode, (void*)pTrav->cmdBuffer, (void*)pTrav->fence, (void*)pTrav->pMemObjList);
Tobin Ehlis62086412014-11-19 16:19:28 -0700913 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700914 MINI_NODE* pMemObjTrav = pTrav->pMemObjList;
915 while (pMemObjTrav) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700916 sprintf(str, " MEM_NODE(%p): Mem obj %p, pNext %p", (void*)pMemObjTrav, (void*)pMemObjTrav->mem, (void*)pMemObjTrav->pNext);
917 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700918 pMemObjTrav = pMemObjTrav->pNext;
919 }
920 pTrav = pTrav->pNextGlobalCBNode;
921 }
922 }
923}
924
925static XGL_FENCE createLocalFence()
926{
927 XGL_FENCE_CREATE_INFO fci;
928 fci.sType = XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO;
929 fci.pNext = NULL;
930 fci.flags = 0;
931 XGL_FENCE fence;
932 nextTable.CreateFence(globalDevice, &fci, &fence);
933 return fence;
934}
935
Jon Ashburnf57ea372014-12-22 13:24:15 -0700936static void initMemTracker()
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700937{
Jon Ashburnf57ea372014-12-22 13:24:15 -0700938 const char *strOpt;
939 // initialize MemTracker options
940 strOpt = getLayerOption("MemTrackerReportLevel");
941 if (strOpt != NULL)
942 g_reportingLevel = atoi(strOpt);
Tobin Ehlis5b7acaa2015-01-08 14:26:53 -0700943
Jon Ashburnf57ea372014-12-22 13:24:15 -0700944 strOpt = getLayerOption("MemTrackerDebugAction");
945 if (strOpt != NULL)
Tobin Ehlis5b7acaa2015-01-08 14:26:53 -0700946 g_debugAction = atoi(strOpt);
947
Jon Ashburnf57ea372014-12-22 13:24:15 -0700948 if (g_debugAction & XGL_DBG_LAYER_ACTION_LOG_MSG)
949 {
950 strOpt = getLayerOption("MemTrackerLogFilename");
951 if (strOpt)
952 {
953 g_logFile = fopen(strOpt, "w");
Jon Ashburnf57ea372014-12-22 13:24:15 -0700954 }
955 if (g_logFile == NULL)
956 g_logFile = stdout;
957 }
958
959 // initialize Layer dispatch table
960 // TODO handle multiple GPUs
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600961 xglGetProcAddrType fpNextGPA;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700962 fpNextGPA = pCurObj->pGPA;
963 assert(fpNextGPA);
964
Chia-I Wu0f65b1e2015-01-04 23:11:43 +0800965 layer_initialize_dispatch_table(&nextTable, fpNextGPA, (XGL_PHYSICAL_GPU) pCurObj->nextObject);
966
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600967 xglGetProcAddrType fpGetProcAddr = fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (XGL_CHAR *) "xglGetProcAddr");
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700968 nextTable.GetProcAddr = fpGetProcAddr;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700969}
970
971
972XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
973{
974 XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
975 pCurObj = gpuw;
Jon Ashburnf57ea372014-12-22 13:24:15 -0700976 pthread_once(&g_initOnce, initMemTracker);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700977 XGL_RESULT result = nextTable.GetGpuInfo((XGL_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
978 return result;
979}
980
981XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
982{
983 XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
984 pCurObj = gpuw;
Jon Ashburnf57ea372014-12-22 13:24:15 -0700985 pthread_once(&g_initOnce, initMemTracker);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700986 XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
987 // Save off device in case we need it to create Fences
988 globalDevice = *pDevice;
989 return result;
990}
991
992XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
993{
Tobin Ehlis62086412014-11-19 16:19:28 -0700994 char str[1024];
995 sprintf(str, "Printing List details prior to xglDestroyDevice()");
996 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, device, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700997 printMemList();
998 printGlobalCB();
999 printObjList();
Tobin Ehlis62086412014-11-19 16:19:28 -07001000 if (XGL_FALSE == deleteGlobalCBList()) {
1001 sprintf(str, "Issue deleting global CB list in xglDestroyDevice()");
1002 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
1003 }
Tobin Ehlis22d03232014-11-25 18:01:12 -07001004 // Report any memory leaks
1005 GLOBAL_MEM_OBJ_NODE* pTrav = pGlobalMemObjHead;
1006 while (pTrav) {
1007 sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling xglFreeMemory(%p) prior to xglDestroyDevice().", pTrav->mem, pTrav->mem);
1008 layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, pTrav->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
1009 pTrav = pTrav->pNextGlobalNode;
1010 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001011 XGL_RESULT result = nextTable.DestroyDevice(device);
1012 return result;
1013}
1014
1015XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pExtName)
1016{
1017 XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
1018 pCurObj = gpuw;
Jon Ashburnf57ea372014-12-22 13:24:15 -07001019 pthread_once(&g_initOnce, initMemTracker);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001020 XGL_RESULT result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
1021 return result;
1022}
1023
Mark Lobodzinski953a1692015-01-09 15:12:03 -06001024XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_SIZE* pOutLayerCount, XGL_CHAR* const* pOutLayers, XGL_VOID* pReserved)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001025{
Jon Ashburn451c16f2014-11-25 11:08:42 -07001026 if (gpu != NULL)
1027 {
1028 XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
1029 pCurObj = gpuw;
Jon Ashburnf57ea372014-12-22 13:24:15 -07001030 pthread_once(&g_initOnce, initMemTracker);
Mark Lobodzinski953a1692015-01-09 15:12:03 -06001031 XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
Jon Ashburn451c16f2014-11-25 11:08:42 -07001032 return result;
1033 } else
1034 {
1035 if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
1036 return XGL_ERROR_INVALID_POINTER;
1037 // This layer compatible with all GPUs
1038 *pOutLayerCount = 1;
Chia-I Wua837c522014-12-16 10:47:33 +08001039 strncpy((char *) pOutLayers[0], "MemTracker", maxStringSize);
Jon Ashburn451c16f2014-11-25 11:08:42 -07001040 return XGL_SUCCESS;
1041 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001042}
1043
1044XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, XGL_QUEUE_TYPE queueType, XGL_UINT queueIndex, XGL_QUEUE* pQueue)
1045{
1046 XGL_RESULT result = nextTable.GetDeviceQueue(device, queueType, queueIndex, pQueue);
1047 return result;
1048}
1049
1050XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(XGL_QUEUE queue, XGL_UINT cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence)
1051{
1052 // TODO : Need to track fence and clear mem references when fence clears
1053 XGL_FENCE localFence = fence;
1054 if (XGL_NULL_HANDLE == fence) { // allocate our own fence to track cmd buffer
1055 localFence = createLocalFence();
1056 }
Tobin Ehlis62086412014-11-19 16:19:28 -07001057 char str[1024];
1058 sprintf(str, "In xglQueueSubmit(), checking %u cmdBuffers with %u memRefs", cmdBufferCount, memRefCount);
1059 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001060 printMemList();
1061 printGlobalCB();
1062 for (uint32_t i = 0; i < cmdBufferCount; i++) {
1063 setCBFence(pCmdBuffers[i], localFence);
Tobin Ehlis62086412014-11-19 16:19:28 -07001064 sprintf(str, "Verifying mem refs for CB %p", pCmdBuffers[i]);
1065 layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001066 if (XGL_FALSE == validateCBMemRef(pCmdBuffers[i], memRefCount, pMemRefs)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001067 sprintf(str, "Unable to verify memory references for CB %p", (void*)pCmdBuffers[i]);
1068 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_CB_MISSING_MEM_REF, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001069 }
1070 }
1071 printGlobalCB();
1072 XGL_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, memRefCount, pMemRefs, localFence);
1073 return result;
1074}
1075
1076XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(XGL_QUEUE queue, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs)
1077{
1078 // TODO : Use global mem references as part of list checked on QueueSubmit above
1079 XGL_RESULT result = nextTable.QueueSetGlobalMemReferences(queue, memRefCount, pMemRefs);
1080 return result;
1081}
1082
1083XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
1084{
1085 XGL_RESULT result = nextTable.QueueWaitIdle(queue);
1086 return result;
1087}
1088
1089XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
1090{
1091 XGL_RESULT result = nextTable.DeviceWaitIdle(device);
1092 return result;
1093}
1094
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001095XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
1096{
1097 XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
1098 // TODO : Track allocations and overall size here
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001099 insertGlobalMemObj(*pMem, pAllocInfo, XGL_MEMORY_STATE_DATA_TRANSFER);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001100 printMemList();
1101 return result;
1102}
1103
1104XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
1105{
Tobin Ehlisa747e682014-11-25 14:47:20 -07001106 /* From spec : A memory object is freed by calling xglFreeMemory() when it is no longer needed. Before
1107 * freeing a memory object, an application must ensure the memory object is unbound from
1108 * all API objects referencing it and that it is not referenced by any queued command buffers
1109 */
Tobin Ehlis62086412014-11-19 16:19:28 -07001110 if (XGL_FALSE == freeMemNode(mem)) {
1111 char str[1024];
1112 sprintf(str, "Issue while freeing mem obj %p", (void*)mem);
1113 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_FREE_MEM_ERROR, "MEM", str);
1114 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001115 printMemList();
1116 printObjList();
1117 printGlobalCB();
1118 XGL_RESULT result = nextTable.FreeMemory(mem);
1119 return result;
1120}
1121
1122XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
1123{
1124 // TODO : Update tracking for this alloc
1125 // Make sure memory is not pinned, which can't have priority set
1126 XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
1127 return result;
1128}
1129
1130XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, XGL_VOID** ppData)
1131{
1132 // TODO : Track when memory is mapped
1133 XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
1134 return result;
1135}
1136
1137XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
1138{
1139 // TODO : Track as memory gets unmapped, do we want to check what changed following map?
1140 // Make sure that memory was ever mapped to begin with
1141 XGL_RESULT result = nextTable.UnmapMemory(mem);
1142 return result;
1143}
1144
1145XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const XGL_VOID* pSysMem, XGL_SIZE memSize, XGL_GPU_MEMORY* pMem)
1146{
1147 // TODO : Track this
1148 // Verify that memory is actually pinnable
1149 XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
1150 return result;
1151}
1152
1153XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglRemapVirtualMemoryPages(XGL_DEVICE device, XGL_UINT rangeCount, const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges, XGL_UINT preWaitSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores, XGL_UINT postSignalSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores)
1154{
1155 // TODO : Track this
1156 XGL_RESULT result = nextTable.RemapVirtualMemoryPages(device, rangeCount, pRanges, preWaitSemaphoreCount, pPreWaitSemaphores, postSignalSemaphoreCount, pPostSignalSemaphores);
1157 return result;
1158}
1159
1160XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo)
1161{
1162 XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu0;
1163 pCurObj = gpuw;
Jon Ashburnf57ea372014-12-22 13:24:15 -07001164 pthread_once(&g_initOnce, initMemTracker);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001165 XGL_RESULT result = nextTable.GetMultiGpuCompatibility((XGL_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
1166 return result;
1167}
1168
1169XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
1170{
1171 // TODO : Track this
1172 XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
1173 return result;
1174}
1175
1176XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore)
1177{
1178 XGL_RESULT result = nextTable.OpenSharedQueueSemaphore(device, pOpenInfo, pSemaphore);
1179 return result;
1180}
1181
1182XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
1183{
1184 // TODO : Track this
1185 XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
1186 return result;
1187}
1188
1189XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
1190{
1191 // TODO : Track this
1192 XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
1193 return result;
1194}
1195
1196XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
1197{
Tobin Ehlise6884ef2014-11-27 07:52:04 -07001198 // First check if this is a CmdBuffer
1199 if (NULL != getGlobalCBNode((XGL_CMD_BUFFER)object)) {
1200 deleteGlobalCBNode((XGL_CMD_BUFFER)object);
1201 }
1202 // Now locate node in global list along with prev node
Tobin Ehlis580c1b32014-11-25 12:27:38 -07001203 GLOBAL_OBJECT_NODE* pTrav = pGlobalObjectHead;
1204 GLOBAL_OBJECT_NODE* pPrev = pTrav;
Tobin Ehlis580c1b32014-11-25 12:27:38 -07001205 while (pTrav) {
1206 if (object == pTrav->object)
1207 break;
1208 pPrev = pTrav;
1209 pTrav = pTrav->pNext;
1210 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001211 if (pTrav) {
1212 if (pTrav->pMemNode) {
Tobin Ehlise6884ef2014-11-27 07:52:04 -07001213 // Wsi allocated Memory is tied to image object so clear the binding and free that memory automatically
1214 if (0 == pTrav->pMemNode->allocInfo.allocationSize) { // Wsi allocated memory has NULL allocInfo w/ 0 size
1215 XGL_GPU_MEMORY memToFree = pTrav->pMemNode->mem;
1216 clearObjectBinding(object);
1217 freeMemNode(memToFree);
1218 }
1219 else {
1220 char str[1024];
1221 sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding by calling xglBindObjectMemory(%p, 0, XGL_NULL_HANDLE)", object, (void*)pTrav->pMemNode->mem, object);
1222 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
1223 // From the spec : If an object has previous memory binding, it is required to unbind memory from an API object before it is destroyed.
1224 clearObjectBinding(object);
1225 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001226 }
1227 if (pGlobalObjectHead == pTrav) // update HEAD if needed
1228 pGlobalObjectHead = pTrav->pNext;
Tobin Ehlis580c1b32014-11-25 12:27:38 -07001229 // Delete the obj node from global list
1230 pPrev->pNext = pTrav->pNext;
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001231 free(pTrav);
1232 }
1233 XGL_RESULT result = nextTable.DestroyObject(object);
1234 return result;
1235}
1236
1237XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
1238{
1239 // TODO : What to track here?
1240 // Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object
Tobin Ehlis62086412014-11-19 16:19:28 -07001241 // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues, command buffers, shaders and memory objects.
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001242 XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
1243 return result;
1244}
1245
Jon Ashburned62b412015-01-15 10:39:19 -07001246XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, XGL_UINT allocationIdx, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001247{
Jon Ashburned62b412015-01-15 10:39:19 -07001248 XGL_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001249 // Track objects tied to memory
Tobin Ehlis62086412014-11-19 16:19:28 -07001250 if (XGL_FALSE == updateObjectBinding(object, mem)) {
1251 char str[1024];
1252 sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)object, (void*)mem);
1253 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1254 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001255 printObjList();
1256 printMemList();
1257 return result;
1258}
1259
1260XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
1261{
1262 XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
1263 return result;
1264}
1265
1266XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
1267{
1268 XGL_RESULT result = nextTable.GetFenceStatus(fence);
1269 return result;
1270}
1271
1272XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, XGL_UINT fenceCount, const XGL_FENCE* pFences, XGL_BOOL waitAll, XGL_UINT64 timeout)
1273{
1274 XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
1275 return result;
1276}
1277
1278XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueueSemaphore(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_QUEUE_SEMAPHORE* pSemaphore)
1279{
1280 XGL_RESULT result = nextTable.CreateQueueSemaphore(device, pCreateInfo, pSemaphore);
1281 return result;
1282}
1283
1284XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSignalQueueSemaphore(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore)
1285{
1286 XGL_RESULT result = nextTable.SignalQueueSemaphore(queue, semaphore);
1287 return result;
1288}
1289
1290XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitQueueSemaphore(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore)
1291{
1292 XGL_RESULT result = nextTable.WaitQueueSemaphore(queue, semaphore);
1293 return result;
1294}
1295
1296XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
1297{
1298 XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
1299 return result;
1300}
1301
1302XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(XGL_EVENT event)
1303{
1304 XGL_RESULT result = nextTable.GetEventStatus(event);
1305 return result;
1306}
1307
1308XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetEvent(XGL_EVENT event)
1309{
1310 XGL_RESULT result = nextTable.SetEvent(event);
1311 return result;
1312}
1313
1314XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetEvent(XGL_EVENT event)
1315{
1316 XGL_RESULT result = nextTable.ResetEvent(event);
1317 return result;
1318}
1319
1320XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
1321{
1322 XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
1323 return result;
1324}
1325
1326XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount, XGL_SIZE* pDataSize, XGL_VOID* pData)
1327{
1328 XGL_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
1329 return result;
1330}
1331
1332XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
1333{
1334 XGL_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
1335 return result;
1336}
1337
1338XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
1339{
1340 XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001341 if (XGL_SUCCESS == result) {
1342 insertGlobalObjectNode(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(XGL_IMAGE_CREATE_INFO), "image");
1343 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001344 return result;
1345}
1346
1347XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
1348{
1349 XGL_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
1350 return result;
1351}
1352
1353XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
1354{
1355 XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001356 if (result == XGL_SUCCESS) {
1357 insertGlobalObjectNode(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_IMAGE_VIEW_CREATE_INFO), "image_view");
1358 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001359 return result;
1360}
1361
1362XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView)
1363{
1364 XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001365 if (result == XGL_SUCCESS) {
1366 insertGlobalObjectNode(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO), "color_attachment_view");
1367 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001368 return result;
1369}
1370
1371XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
1372{
1373 XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001374 if (result == XGL_SUCCESS) {
1375 insertGlobalObjectNode(*pView, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO), "ds_view");
1376 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001377 return result;
1378}
1379
1380XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
1381{
1382 XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
1383 return result;
1384}
1385
1386XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
1387{
1388 XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001389 if (result == XGL_SUCCESS) {
1390 insertGlobalObjectNode(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
1391 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001392 return result;
1393}
1394
1395XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
1396{
1397 XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001398 if (result == XGL_SUCCESS) {
1399 insertGlobalObjectNode(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO), "compute_pipeline");
1400 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001401 return result;
1402}
1403
1404XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglStorePipeline(XGL_PIPELINE pipeline, XGL_SIZE* pDataSize, XGL_VOID* pData)
1405{
1406 XGL_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
1407 return result;
1408}
1409
1410XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(XGL_DEVICE device, XGL_SIZE dataSize, const XGL_VOID* pData, XGL_PIPELINE* pPipeline)
1411{
1412 XGL_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
1413 return result;
1414}
1415
1416XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta)
1417{
1418 XGL_RESULT result = nextTable.CreatePipelineDelta(device, p1, p2, delta);
1419 return result;
1420}
1421
1422XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
1423{
1424 XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001425 if (result == XGL_SUCCESS) {
1426 insertGlobalObjectNode(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(XGL_SAMPLER_CREATE_INFO), "sampler");
1427 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001428 return result;
1429}
1430
1431XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSet(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET* pDescriptorSet)
1432{
1433 XGL_RESULT result = nextTable.CreateDescriptorSet(device, pCreateInfo, pDescriptorSet);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001434 if (result == XGL_SUCCESS) {
1435 insertGlobalObjectNode(*pDescriptorSet, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DESCRIPTOR_SET_CREATE_INFO), "descriptor_set");
1436 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001437 return result;
1438}
1439
1440XGL_LAYER_EXPORT XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(XGL_DESCRIPTOR_SET descriptorSet)
1441{
1442 nextTable.BeginDescriptorSetUpdate(descriptorSet);
1443}
1444
1445XGL_LAYER_EXPORT XGL_VOID XGLAPI xglEndDescriptorSetUpdate(XGL_DESCRIPTOR_SET descriptorSet)
1446{
1447 nextTable.EndDescriptorSetUpdate(descriptorSet);
1448}
1449
1450XGL_LAYER_EXPORT XGL_VOID XGLAPI xglAttachSamplerDescriptors(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_SAMPLER* pSamplers)
1451{
1452 nextTable.AttachSamplerDescriptors(descriptorSet, startSlot, slotCount, pSamplers);
1453}
1454
1455XGL_LAYER_EXPORT XGL_VOID XGLAPI xglAttachImageViewDescriptors(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews)
1456{
1457 nextTable.AttachImageViewDescriptors(descriptorSet, startSlot, slotCount, pImageViews);
1458}
1459
1460XGL_LAYER_EXPORT XGL_VOID XGLAPI xglAttachMemoryViewDescriptors(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews)
1461{
1462 nextTable.AttachMemoryViewDescriptors(descriptorSet, startSlot, slotCount, pMemViews);
1463}
1464
1465XGL_LAYER_EXPORT XGL_VOID XGLAPI xglAttachNestedDescriptors(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets)
1466{
1467 nextTable.AttachNestedDescriptors(descriptorSet, startSlot, slotCount, pNestedDescriptorSets);
1468}
1469
1470XGL_LAYER_EXPORT XGL_VOID XGLAPI xglClearDescriptorSetSlots(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount)
1471{
1472 nextTable.ClearDescriptorSetSlots(descriptorSet, startSlot, slotCount);
1473}
1474
1475XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateViewportState(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState)
1476{
1477 XGL_RESULT result = nextTable.CreateViewportState(device, pCreateInfo, pState);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001478 if (result == XGL_SUCCESS) {
1479 // viewport doesn't have an sType
1480 insertGlobalObjectNode(*pState, _XGL_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(XGL_VIEWPORT_STATE_CREATE_INFO), "viewport_state");
1481 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001482 return result;
1483}
1484
1485XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRasterState(XGL_DEVICE device, const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo, XGL_RASTER_STATE_OBJECT* pState)
1486{
1487 XGL_RESULT result = nextTable.CreateRasterState(device, pCreateInfo, pState);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001488 if (result == XGL_SUCCESS) {
1489 insertGlobalObjectNode(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_RASTER_STATE_CREATE_INFO), "raster_state");
1490 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001491 return result;
1492}
1493
1494XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateMsaaState(XGL_DEVICE device, const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo, XGL_MSAA_STATE_OBJECT* pState)
1495{
1496 XGL_RESULT result = nextTable.CreateMsaaState(device, pCreateInfo, pState);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001497 if (result == XGL_SUCCESS) {
1498 insertGlobalObjectNode(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_MSAA_STATE_CREATE_INFO), "msaa_state");
1499 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001500 return result;
1501}
1502
1503XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorBlendState(XGL_DEVICE device, const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo, XGL_COLOR_BLEND_STATE_OBJECT* pState)
1504{
1505 XGL_RESULT result = nextTable.CreateColorBlendState(device, pCreateInfo, pState);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001506 if (result == XGL_SUCCESS) {
1507 insertGlobalObjectNode(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_COLOR_BLEND_STATE_CREATE_INFO), "cb_state");
1508 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001509 return result;
1510}
1511
1512XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilState(XGL_DEVICE device, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_STATE_OBJECT* pState)
1513{
1514 XGL_RESULT result = nextTable.CreateDepthStencilState(device, pCreateInfo, pState);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001515 if (result == XGL_SUCCESS) {
1516 insertGlobalObjectNode(*pState, pCreateInfo->sType, pCreateInfo, sizeof(XGL_DEPTH_STENCIL_STATE_CREATE_INFO), "ds_state");
1517 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001518 return result;
1519}
1520
1521XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
1522{
1523 XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
1524 // At time of cmd buffer creation, create global cmd buffer node for the returned cmd buffer
1525 if (*pCmdBuffer)
1526 insertGlobalCB(*pCmdBuffer);
1527 printGlobalCB();
1528 return result;
1529}
1530
Jon Ashburn57ba18d2014-12-31 17:11:49 -07001531XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001532{
1533 // This implicitly resets the Cmd Buffer so clear memory references
1534 freeCBBindings(cmdBuffer);
Jon Ashburn57ba18d2014-12-31 17:11:49 -07001535 XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001536 return result;
1537}
1538
1539XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
1540{
1541 // TODO : Anything to do here?
1542 XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
1543 return result;
1544}
1545
1546XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
1547{
1548 // Clear memory references as this point. Anything else to do here?
1549 freeCBBindings(cmdBuffer);
1550 XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
1551 return result;
1552}
1553// TODO : For any xglCmdBind* calls that include an object which has mem bound to it,
1554// need to account for that mem now having binding to given cmdBuffer
1555XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline)
1556{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001557#if 0
1558 // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer
1559 if (getPipeline(pipeline)) {
1560 GLOBAL_CB_NODE *pCBTrav = getGlobalCBNode(cmdBuffer);
1561 if (pCBTrav) {
1562 pCBTrav->pipelines[pipelineBindPoint] = pipeline;
1563 } else {
1564 char str[1024];
1565 sprintf(str, "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, cmdBuffer);
1566 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, (XGL_CHAR *) "DS", (XGL_CHAR *) str);
1567 }
1568 }
1569 else {
1570 char str[1024];
1571 sprintf(str, "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
1572 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, MEMTRACK_INVALID_OBJECT, (XGL_CHAR *) "DS", (XGL_CHAR *) str);
1573 }
1574#endif
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001575 nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
1576}
1577
1578XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindPipelineDelta(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta)
1579{
1580 nextTable.CmdBindPipelineDelta(cmdBuffer, pipelineBindPoint, delta);
1581}
1582
1583XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state)
1584{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001585 GLOBAL_OBJECT_NODE *pNode;
1586 GLOBAL_CB_NODE *pCmdBuf = getGlobalCBNode(cmdBuffer);
1587 if (!pCmdBuf) {
1588 char str[1024];
1589 sprintf(str, "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
1590 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
1591 }
1592 pNode = getGlobalObjectNode(state);
1593 if (!pNode) {
1594 char str[1024];
1595 sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
1596 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
1597 }
1598 pCmdBuf->pDynamicState[stateBindPoint] = pNode;
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001599 nextTable.CmdBindStateObject(cmdBuffer, stateBindPoint, state);
1600}
1601
1602XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindDescriptorSet(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT index, XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT slotOffset)
1603{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001604 // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001605 nextTable.CmdBindDescriptorSet(cmdBuffer, pipelineBindPoint, index, descriptorSet, slotOffset);
1606}
1607
1608XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView)
1609{
1610 nextTable.CmdBindDynamicMemoryView(cmdBuffer, pipelineBindPoint, pMemView);
1611}
1612
Chia-I Wufb5062e2015-01-05 13:42:56 +08001613XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindVertexData(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT binding)
1614{
Chia-I Wufb5062e2015-01-05 13:42:56 +08001615 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1616 char str[1024];
1617 sprintf(str, "In xglCmdBindVertexData() call unable to update binding of mem %p to cmdBuffer %p", mem, cmdBuffer);
1618 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1619 }
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001620 // Now update CB's vertex binding list
1621 GLOBAL_CB_NODE* pCBTrav = getGlobalCBNode(cmdBuffer);
1622 if (!pCBTrav) {
1623 char str[1024];
1624 sprintf(str, "Trying to BindVertexData mem obj %p to CB %p but no Node for that CB. Was CB incorrectly destroyed?", mem, cmdBuffer);
1625 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_CB, "MEM", str);
1626 } else {
1627 MEMORY_BINDING *pBindInfo;
1628 XGL_UINT dontCare;
1629 XGL_RESULT result;
1630 pBindInfo = malloc(sizeof(MEMORY_BINDING));
1631 pBindInfo->offset = offset;
1632 pBindInfo->binding = binding;
1633 pBindInfo->mem = mem;
1634 result = insertMiniNode(&pCBTrav->pVertexBufList, pBindInfo, &dontCare);
1635 if (result) {
1636 char str[1024];
1637 sprintf(str, "In xglCmdBindVertexData and ran out of memory to track binding. CmdBuffer: %p, memory %p", cmdBuffer, mem);
1638 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_OUT_OF_MEMORY_ERROR, "MEM", str);
1639 }
1640 }
1641 lastVtxBinding = binding;
Chia-I Wufb5062e2015-01-05 13:42:56 +08001642 nextTable.CmdBindVertexData(cmdBuffer, mem, offset, binding);
1643}
1644
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001645XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindIndexData(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
1646{
1647 // Track this memory. What exactly is this call doing?
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001648 // TODO : verify state of memory is XGL_MEMORY_STATE_INDEX_DATA
Tobin Ehlis62086412014-11-19 16:19:28 -07001649 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1650 char str[1024];
1651 sprintf(str, "In xglCmdBindIndexData() call unable to update binding of mem %p to cmdBuffer %p", mem, cmdBuffer);
1652 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1653 }
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001654 // Now update CB's index binding list
1655 GLOBAL_CB_NODE* pCBTrav = getGlobalCBNode(cmdBuffer);
1656 if (!pCBTrav) {
1657 char str[1024];
1658 sprintf(str, "Trying to BindIndexData mem obj %p to CB %p but no Node for that CB. Was CB incorrectly destroyed?", mem, cmdBuffer);
1659 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_MEM_OBJ, (XGL_CHAR *) "MEM", (XGL_CHAR *) str);
1660 } else {
1661 MEMORY_BINDING *pBindInfo;
1662 XGL_UINT dontCare;
1663 XGL_RESULT result;
1664 pBindInfo = malloc(sizeof(MEMORY_BINDING));
1665 pBindInfo->indexType = indexType;
1666 pBindInfo->mem = mem;
1667 pBindInfo->offset = offset;
1668 pBindInfo->binding = 0;
1669 result = insertMiniNode(&pCBTrav->pIndexBufList, pBindInfo, &dontCare);
1670 if (result) {
1671 char str[1024];
1672 sprintf(str, "In xglCmdBindIndexData and ran out of memory to track binding. CmdBuffer: %p, memory %p", cmdBuffer, mem);
1673 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_OUT_OF_MEMORY_ERROR, "MEM", str);
1674 }
1675 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001676 nextTable.CmdBindIndexData(cmdBuffer, mem, offset, indexType);
1677}
1678
1679XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindAttachments(XGL_CMD_BUFFER cmdBuffer, XGL_UINT colorAttachmentCount, const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments, const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment)
1680{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001681 // TODO : Verify that memory for attachments is in the correct state
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001682 nextTable.CmdBindAttachments(cmdBuffer, colorAttachmentCount, pColorAttachments, pDepthStencilAttachment);
1683}
1684
1685XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdPrepareMemoryRegions(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_MEMORY_STATE_TRANSITION* pStateTransitions)
1686{
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001687 for (int i=0; i < transitionCount; i++) {
1688 XGL_GPU_MEMORY mem = pStateTransitions[i].mem;
1689 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1690 char str[1024];
1691 sprintf(str, "In xglCmdPrepareMemoryRegions() call unable to update binding of mem %p to cmdBuffer %p", mem, cmdBuffer);
1692 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, (XGL_CHAR *) "MEM", (XGL_CHAR *) str);
1693 } else {
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001694 // TODO : Need to intelligently set state so it's captured on per-region basis (not per mem obj)
1695 setMemTransition(mem, &pStateTransitions[i]);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001696 // Validate mem state in order
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001697/* GLOBAL_MEM_OBJ_NODE* pMem = getGlobalMemNode(mem);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001698 if (pMem->transition.memory.newState != pStateTransitions[i].oldState) {
1699 char str[1024];
1700 sprintf(str, "In xglCmdPrepareMemoryRegions() call, mem %p actual oldState of %s doesn't match transition oldState of %s", mem, string_XGL_MEMORY_STATE(pMem->transition.memory.newState), string_XGL_MEMORY_STATE(pStateTransitions[i].oldState));
1701 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_STATE, (XGL_CHAR *) "MEM", (XGL_CHAR *) str);
1702 }
1703 // Once state is validated, update to current state
1704 memcpy(&pMem->transition, &pStateTransitions[i], sizeof(XGL_MEMORY_STATE_TRANSITION));
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001705*/
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001706 }
Tobin Ehlis62086412014-11-19 16:19:28 -07001707 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001708 nextTable.CmdPrepareMemoryRegions(cmdBuffer, transitionCount, pStateTransitions);
1709}
1710
1711XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdPrepareImages(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_IMAGE_STATE_TRANSITION* pStateTransitions)
1712{
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001713 for (int i=0; i < transitionCount; i++) {
1714 XGL_GPU_MEMORY mem = getMemBindingFromObject(pStateTransitions[i].image);
1715 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1716 char str[1024];
1717 sprintf(str, "In xglCmdPrepareImages() call unable to update binding of mem %p to cmdBuffer %p", mem, cmdBuffer);
1718 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, (XGL_CHAR *) "MEM", (XGL_CHAR *) str);
1719 } else {
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001720 // TODO : Need to intelligently set state so it's captured on per-region basis (not per mem obj)
1721 //GLOBAL_MEM_OBJ_NODE* pMem = getGlobalMemNode(mem);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001722 // Validate mem state in order
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001723/*
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001724 if ((XGL_IMAGE_STATE)pMem->transition.image.newState != pStateTransitions[i].oldState) {
1725 char str[1024];
1726 sprintf(str, "In xglCmdPrepareImages() call, mem %p w/ image %p actual oldState of %s doesn't match transition oldState of %s", mem, pStateTransitions[i].image, string_XGL_IMAGE_STATE(pMem->transition.image.newState), string_XGL_IMAGE_STATE(pStateTransitions[i].oldState));
1727 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_INVALID_STATE, (XGL_CHAR *) "MEM", (XGL_CHAR *) str);
1728 }
1729 memcpy(&pMem->transition, &pStateTransitions[i], sizeof(XGL_IMAGE_STATE_TRANSITION));
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001730*/
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001731 }
Tobin Ehlis62086412014-11-19 16:19:28 -07001732 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001733 nextTable.CmdPrepareImages(cmdBuffer, transitionCount, pStateTransitions);
1734}
1735
1736XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDraw(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount)
1737{
1738 nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
1739}
1740
1741XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDrawIndexed(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount)
1742{
1743 nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
1744}
1745
1746XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDrawIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride)
1747{
Tobin Ehlis62086412014-11-19 16:19:28 -07001748 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1749 char str[1024];
1750 sprintf(str, "In xglCmdDrawIndirect() call unable to update binding of mem %p to cmdBuffer %p", mem, cmdBuffer);
1751 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1752 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001753 nextTable.CmdDrawIndirect(cmdBuffer, mem, offset, count, stride);
1754}
1755
1756XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride)
1757{
Tobin Ehlis62086412014-11-19 16:19:28 -07001758 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1759 char str[1024];
1760 sprintf(str, "In xglCmdDrawIndexedIndirect() call unable to update binding of mem %p to cmdBuffer %p", mem, cmdBuffer);
1761 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1762 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001763 nextTable.CmdDrawIndexedIndirect(cmdBuffer, mem, offset, count, stride);
1764}
1765
1766XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDispatch(XGL_CMD_BUFFER cmdBuffer, XGL_UINT x, XGL_UINT y, XGL_UINT z)
1767{
1768 nextTable.CmdDispatch(cmdBuffer, x, y, z);
1769}
1770
1771XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDispatchIndirect(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
1772{
Tobin Ehlis62086412014-11-19 16:19:28 -07001773 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1774 char str[1024];
1775 sprintf(str, "In xglCmdDispatchIndirect() call unable to update binding of mem %p to cmdBuffer %p", mem, cmdBuffer);
1776 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1777 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001778 nextTable.CmdDispatchIndirect(cmdBuffer, mem, offset);
1779}
1780
1781XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCopyMemory(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_COPY* pRegions)
1782{
Tobin Ehlis62086412014-11-19 16:19:28 -07001783 if (XGL_FALSE == updateCBBinding(cmdBuffer, srcMem)) {
1784 char str[1024];
1785 sprintf(str, "In xglCmdCopyMemory() call unable to update binding of srcMem %p to cmdBuffer %p", srcMem, cmdBuffer);
1786 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1787 }
1788 if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) {
1789 char str[1024];
1790 sprintf(str, "In xglCmdCopyMemory() call unable to update binding of destMem %p to cmdBuffer %p", destMem, cmdBuffer);
1791 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1792 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001793 nextTable.CmdCopyMemory(cmdBuffer, srcMem, destMem, regionCount, pRegions);
1794}
1795
1796XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_IMAGE_COPY* pRegions)
1797{
1798 // TODO : Each image will have mem mapping so track them
1799 nextTable.CmdCopyImage(cmdBuffer, srcImage, destImage, regionCount, pRegions);
1800}
1801
1802XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCopyMemoryToImage(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions)
1803{
1804 // TODO : Track this
1805 XGL_GPU_MEMORY mem = getMemBindingFromObject(destImage);
Tobin Ehlis62086412014-11-19 16:19:28 -07001806 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1807 char str[1024];
1808 sprintf(str, "In xglCmdCopyMemoryToImage() call unable to update binding of destImage mem %p to cmdBuffer %p", mem, cmdBuffer);
1809 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1810 }
1811 if (XGL_FALSE == updateCBBinding(cmdBuffer, srcMem)) {
1812 char str[1024];
1813 sprintf(str, "In xglCmdCopyMemoryToImage() call unable to update binding of srcMem %p to cmdBuffer %p", srcMem, cmdBuffer);
1814 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1815 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001816 nextTable.CmdCopyMemoryToImage(cmdBuffer, srcMem, destImage, regionCount, pRegions);
1817}
1818
1819XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCopyImageToMemory(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions)
1820{
1821 // TODO : Track this
1822 XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
Tobin Ehlis62086412014-11-19 16:19:28 -07001823 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1824 char str[1024];
1825 sprintf(str, "In xglCmdCopyImageToMemory() call unable to update binding of srcImage mem %p to cmdBuffer %p", mem, cmdBuffer);
1826 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1827 }
1828 if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) {
1829 char str[1024];
1830 sprintf(str, "In xglCmdCopyImageToMemory() call unable to update binding of destMem %p to cmdBuffer %p", destMem, cmdBuffer);
1831 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1832 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001833 nextTable.CmdCopyImageToMemory(cmdBuffer, srcImage, destMem, regionCount, pRegions);
1834}
1835
Mike Stroyan55658c22014-12-04 11:08:39 +00001836XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001837{
1838 // TODO : Each image will have mem mapping so track them
1839 XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
Tobin Ehlis62086412014-11-19 16:19:28 -07001840 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1841 char str[1024];
1842 sprintf(str, "In xglCmdCloneImageData() call unable to update binding of srcImage mem %p to cmdBuffer %p", mem, cmdBuffer);
1843 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1844 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001845 mem = getMemBindingFromObject(destImage);
Tobin Ehlis62086412014-11-19 16:19:28 -07001846 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1847 char str[1024];
1848 sprintf(str, "In xglCmdCloneImageData() call unable to update binding of destImage mem %p to cmdBuffer %p", mem, cmdBuffer);
1849 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1850 }
Mike Stroyan55658c22014-12-04 11:08:39 +00001851 nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001852}
1853
1854XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdUpdateMemory(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData)
1855{
Tobin Ehlis62086412014-11-19 16:19:28 -07001856 if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) {
1857 char str[1024];
1858 sprintf(str, "In xglCmdUpdateMemory() call unable to update binding of destMem %p to cmdBuffer %p", destMem, cmdBuffer);
1859 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1860 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001861 nextTable.CmdUpdateMemory(cmdBuffer, destMem, destOffset, dataSize, pData);
1862}
1863
1864XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdFillMemory(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data)
1865{
Tobin Ehlis62086412014-11-19 16:19:28 -07001866 if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) {
1867 char str[1024];
1868 sprintf(str, "In xglCmdFillMemory() call unable to update binding of destMem %p to cmdBuffer %p", destMem, cmdBuffer);
1869 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1870 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001871 nextTable.CmdFillMemory(cmdBuffer, destMem, destOffset, fillSize, data);
1872}
1873
1874XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_FLOAT color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
1875{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001876 // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001877 XGL_GPU_MEMORY mem = getMemBindingFromObject(image);
Tobin Ehlis62086412014-11-19 16:19:28 -07001878 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1879 char str[1024];
1880 sprintf(str, "In xglCmdClearColorImage() call unable to update binding of image mem %p to cmdBuffer %p", mem, cmdBuffer);
1881 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1882 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001883 nextTable.CmdClearColorImage(cmdBuffer, image, color, rangeCount, pRanges);
1884}
1885
1886XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdClearColorImageRaw(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_UINT32 color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
1887{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001888 // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001889 XGL_GPU_MEMORY mem = getMemBindingFromObject(image);
Tobin Ehlis62086412014-11-19 16:19:28 -07001890 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1891 char str[1024];
1892 sprintf(str, "In xglCmdClearColorImageRaw() call unable to update binding of image mem %p to cmdBuffer %p", mem, cmdBuffer);
1893 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1894 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001895 nextTable.CmdClearColorImageRaw(cmdBuffer, image, color, rangeCount, pRanges);
1896}
1897
1898XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_FLOAT depth, XGL_UINT32 stencil, XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
1899{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001900 // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001901 XGL_GPU_MEMORY mem = getMemBindingFromObject(image);
Tobin Ehlis62086412014-11-19 16:19:28 -07001902 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1903 char str[1024];
1904 sprintf(str, "In xglCmdClearDepthStencil() call unable to update binding of image mem %p to cmdBuffer %p", mem, cmdBuffer);
1905 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1906 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001907 nextTable.CmdClearDepthStencil(cmdBuffer, image, depth, stencil, rangeCount, pRanges);
1908}
1909
1910XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT rectCount, const XGL_IMAGE_RESOLVE* pRects)
1911{
1912 XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
Tobin Ehlis62086412014-11-19 16:19:28 -07001913 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1914 char str[1024];
1915 sprintf(str, "In xglCmdResolveImage() call unable to update binding of srcImage mem %p to cmdBuffer %p", mem, cmdBuffer);
1916 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1917 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001918 mem = getMemBindingFromObject(destImage);
Tobin Ehlis62086412014-11-19 16:19:28 -07001919 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1920 char str[1024];
1921 sprintf(str, "In xglCmdResolveImage() call unable to update binding of destImage mem %p to cmdBuffer %p", mem, cmdBuffer);
1922 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1923 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001924 nextTable.CmdResolveImage(cmdBuffer, srcImage, destImage, rectCount, pRects);
1925}
1926
Mike Stroyan55658c22014-12-04 11:08:39 +00001927XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_SET_EVENT pipeEvent)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001928{
Mike Stroyan55658c22014-12-04 11:08:39 +00001929 nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001930}
1931
1932XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event)
1933{
1934 nextTable.CmdResetEvent(cmdBuffer, event);
1935}
1936
Mike Stroyan55658c22014-12-04 11:08:39 +00001937XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo)
1938{
1939 nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo);
1940}
1941
1942XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdPipelineBarrier( XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier)
1943{
1944 nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier);
1945}
1946
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001947XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdMemoryAtomic(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp)
1948{
Tobin Ehlis62086412014-11-19 16:19:28 -07001949 if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) {
1950 char str[1024];
1951 sprintf(str, "In xglCmdMemoryAtomic() call unable to update binding of destMem %p to cmdBuffer %p", destMem, cmdBuffer);
1952 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1953 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001954 nextTable.CmdMemoryAtomic(cmdBuffer, destMem, destOffset, srcData, atomicOp);
1955}
1956
1957XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot, XGL_FLAGS flags)
1958{
1959 XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
Tobin Ehlis62086412014-11-19 16:19:28 -07001960 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1961 char str[1024];
1962 sprintf(str, "In xglCmdBeginQuery() call unable to update binding of queryPool mem %p to cmdBuffer %p", mem, cmdBuffer);
1963 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1964 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001965 nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
1966}
1967
1968XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdEndQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot)
1969{
1970 XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
Tobin Ehlis62086412014-11-19 16:19:28 -07001971 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1972 char str[1024];
1973 sprintf(str, "In xglCmdEndQuery() call unable to update binding of queryPool mem %p to cmdBuffer %p", mem, cmdBuffer);
1974 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1975 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001976 nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
1977}
1978
1979XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount)
1980{
1981 XGL_GPU_MEMORY mem = getMemBindingFromObject(queryPool);
Tobin Ehlis62086412014-11-19 16:19:28 -07001982 if (XGL_FALSE == updateCBBinding(cmdBuffer, mem)) {
1983 char str[1024];
1984 sprintf(str, "In xglCmdResetQueryPool() call unable to update binding of queryPool mem %p to cmdBuffer %p", mem, cmdBuffer);
1985 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1986 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001987 nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
1988}
1989
1990XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset)
1991{
Tobin Ehlis62086412014-11-19 16:19:28 -07001992 if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) {
1993 char str[1024];
1994 sprintf(str, "In xglCmdWriteTimestamp() call unable to update binding of destMem %p to cmdBuffer %p", destMem, cmdBuffer);
1995 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
1996 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001997 nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destMem, destOffset);
1998}
1999
2000XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, const XGL_UINT32* pData)
2001{
2002 nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
2003}
2004
2005XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdLoadAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY srcMem, XGL_GPU_SIZE srcOffset)
2006{
Tobin Ehlis62086412014-11-19 16:19:28 -07002007 if (XGL_FALSE == updateCBBinding(cmdBuffer, srcMem)) {
2008 char str[1024];
2009 sprintf(str, "In xglCmdLoadAtomicCounters() call unable to update binding of srcMem %p to cmdBuffer %p", srcMem, cmdBuffer);
2010 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
2011 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002012 nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcMem, srcOffset);
2013}
2014
2015XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdSaveAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset)
2016{
Tobin Ehlis62086412014-11-19 16:19:28 -07002017 if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) {
2018 char str[1024];
2019 sprintf(str, "In xglCmdSaveAtomicCounters() call unable to update binding of destMem %p to cmdBuffer %p", destMem, cmdBuffer);
2020 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
2021 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002022 nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destMem, destOffset);
2023}
2024
2025XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel)
2026{
2027 XGL_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
2028 return result;
2029}
2030
2031XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, XGL_VOID* pUserData)
2032{
Tobin Ehlis62086412014-11-19 16:19:28 -07002033 // This layer intercepts callbacks
2034 XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
2035 if (!pNewDbgFuncNode)
2036 return XGL_ERROR_OUT_OF_MEMORY;
2037 pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
2038 pNewDbgFuncNode->pUserData = pUserData;
Jon Ashburnf57ea372014-12-22 13:24:15 -07002039 pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
2040 g_pDbgFunctionHead = pNewDbgFuncNode;
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002041 XGL_RESULT result = nextTable.DbgRegisterMsgCallback(pfnMsgCallback, pUserData);
2042 return result;
2043}
2044
2045XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
2046{
Jon Ashburnf57ea372014-12-22 13:24:15 -07002047 XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
Tobin Ehlis62086412014-11-19 16:19:28 -07002048 XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
2049 while (pTrav) {
2050 if (pTrav->pfnMsgCallback == pfnMsgCallback) {
2051 pPrev->pNext = pTrav->pNext;
Jon Ashburnf57ea372014-12-22 13:24:15 -07002052 if (g_pDbgFunctionHead == pTrav)
2053 g_pDbgFunctionHead = pTrav->pNext;
Tobin Ehlis62086412014-11-19 16:19:28 -07002054 free(pTrav);
2055 break;
2056 }
2057 pPrev = pTrav;
2058 pTrav = pTrav->pNext;
2059 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002060 XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(pfnMsgCallback);
2061 return result;
2062}
2063
2064XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(XGL_DEVICE device, XGL_INT msgCode, XGL_DBG_MSG_FILTER filter)
2065{
2066 XGL_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
2067 return result;
2068}
2069
2070XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(XGL_BASE_OBJECT object, XGL_SIZE tagSize, const XGL_VOID* pTag)
2071{
2072 XGL_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
2073 return result;
2074}
2075
2076XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_DBG_GLOBAL_OPTION dbgOption, XGL_SIZE dataSize, const XGL_VOID* pData)
2077{
2078 XGL_RESULT result = nextTable.DbgSetGlobalOption(dbgOption, dataSize, pData);
2079 return result;
2080}
2081
2082XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, XGL_SIZE dataSize, const XGL_VOID* pData)
2083{
2084 XGL_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
2085 return result;
2086}
2087
2088XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDbgMarkerBegin(XGL_CMD_BUFFER cmdBuffer, const XGL_CHAR* pMarker)
2089{
2090 nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker);
2091}
2092
2093XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
2094{
2095 nextTable.CmdDbgMarkerEnd(cmdBuffer);
2096}
2097
2098XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11AssociateConnection(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo)
2099{
2100 XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002101 pCurObj = gpuw;
Jon Ashburnf57ea372014-12-22 13:24:15 -07002102 pthread_once(&g_initOnce, initMemTracker);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002103 XGL_RESULT result = nextTable.WsiX11AssociateConnection((XGL_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002104 return result;
2105}
2106
Tobin Ehlis4a5d7e22014-11-11 08:00:58 -07002107XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11GetMSC(XGL_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, XGL_UINT64* pMsc)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002108{
Tobin Ehlis4a5d7e22014-11-11 08:00:58 -07002109 XGL_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002110 return result;
2111}
2112
2113XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
2114{
2115 XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07002116 if (XGL_SUCCESS == result) {
2117 // Add image object, then insert the new Mem Object and then bind it to created image
2118 insertGlobalObjectNode(*pImage, _XGL_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image");
2119 insertGlobalMemObj(*pMem, NULL, XGL_IMAGE_STATE_UNINITIALIZED_TARGET);
2120 if (XGL_FALSE == updateObjectBinding(*pImage, *pMem)) {
2121 char str[1024];
2122 sprintf(str, "In xglWsiX11CreatePresentableImage(), unable to set image %p binding to mem obj %p", (void*)*pImage, (void*)*pMem);
2123 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, *pImage, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
2124 }
Tobin Ehlis62086412014-11-19 16:19:28 -07002125 }
2126 printObjList();
2127 printMemList();
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002128 return result;
2129}
2130
2131XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence)
2132{
2133 XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
2134 return result;
2135}
2136
2137XGL_LAYER_EXPORT XGL_VOID* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* funcName)
2138{
2139 XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
Chia-I Wu706533e2015-01-05 13:18:57 +08002140 void *addr;
2141
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002142 if (gpu == NULL)
2143 return NULL;
2144 pCurObj = gpuw;
Jon Ashburnf57ea372014-12-22 13:24:15 -07002145 pthread_once(&g_initOnce, initMemTracker);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002146
Chia-I Wu706533e2015-01-05 13:18:57 +08002147 addr = layer_intercept_proc(funcName);
2148 if (addr)
2149 return addr;
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002150 else {
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002151 if (gpuw->pGPA == NULL)
2152 return NULL;
2153 return gpuw->pGPA(gpuw->nextObject, funcName);
2154 }
2155}