add_xgl_layer(Basic basic.cpp)
add_xgl_layer(Multi multi.cpp)
-add_xgl_layer(DrawState draw_state.c)
-add_xgl_layer(MemTracker mem_tracker.c)
+add_xgl_layer(DrawState draw_state.cpp)
+add_xgl_layer(MemTracker mem_tracker.cpp)
+ add_xgl_layer(GlaveSnapshot glave_snapshot.c)
# generated
add_xgl_layer(Generic generic_layer.c)
add_xgl_layer(APIDump api_dump.c)
def _remap_decl(self, ty, name):
txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)
txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
- txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }' % name
+ txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }\n' % name
return txt
- def _generate_replay_class(self):
++ def _generate_replay_objMemory_funcs(self):
++ rof_body = []
++ # Custom code for memory mapping functions for app writes into mapped memory
++ rof_body.append('// memory mapping functions for app writes into mapped memory')
++ rof_body.append(' bool isPendingAlloc()')
++ rof_body.append(' {')
++ rof_body.append(' return m_pendingAlloc;')
++ rof_body.append(' }')
++ rof_body.append('')
++ rof_body.append(' void setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending)')
++ rof_body.append(' {')
++ rof_body.append(' m_pendingAlloc = pending;')
++ rof_body.append(' m_allocInfo = *info;')
++ rof_body.append(' }')
++ rof_body.append('')
++ rof_body.append(' void setMemoryDataAddr(void *pBuf)')
++ rof_body.append(' {')
++ rof_body.append(' if (m_mapRange.empty())')
++ rof_body.append(' {')
++ rof_body.append(' glv_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty\\n");')
++ rof_body.append(' return;')
++ rof_body.append(' }')
++ rof_body.append(' MapRange mr = m_mapRange.back();')
++ rof_body.append(' if (mr.pData != NULL)')
++ rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping\\n");')
++ rof_body.append(' else if (pBuf == NULL)')
++ rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() adding NULL pointer\\n");')
++ rof_body.append(' mr.pData = pBuf;')
++ rof_body.append(' }')
++ rof_body.append('')
++ rof_body.append(' void setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending)')
++ rof_body.append(' {')
++ rof_body.append(' MapRange mr;')
++ rof_body.append(' mr.pData = pBuf;')
++ rof_body.append(' mr.size = size;')
++ rof_body.append(' mr.offset = offset;')
++ rof_body.append(' mr.pending = pending;')
++ rof_body.append(' m_mapRange.push_back(mr);')
++ rof_body.append(' }')
++ rof_body.append('')
++ rof_body.append(' void copyMappingData(const void* pSrcData)')
++ rof_body.append(' {')
++ rof_body.append(' if (m_mapRange.empty())')
++ rof_body.append(' {')
++ rof_body.append(' glv_LogError("gpuMemory::copyMappingData() m_mapRange is empty\\n");')
++ rof_body.append(' return;')
++ rof_body.append(' }')
++ rof_body.append(' MapRange mr = m_mapRange.back();')
++ rof_body.append(' if (!pSrcData || !mr.pData)')
++ rof_body.append(' {')
++ rof_body.append(' if (!pSrcData)')
++ rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null src pointer\\n");')
++ rof_body.append(' else')
++ rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null dest pointer size=%u\\n", m_allocInfo.allocationSize);')
++ rof_body.append(' m_mapRange.pop_back();')
++ rof_body.append(' return;')
++ rof_body.append(' }')
++ rof_body.append(' memcpy(mr.pData, pSrcData, m_allocInfo.allocationSize);')
++ rof_body.append(' if (!mr.pending)')
++ rof_body.append(' m_mapRange.pop_back();')
++ rof_body.append(' }')
++ rof_body.append('')
++ rof_body.append(' size_t getMemoryMapSize()')
++ rof_body.append(' {')
++ rof_body.append(' return (!m_mapRange.empty()) ? m_mapRange.back().size : 0;')
++ rof_body.append(' }\n')
++ return "\n".join(rof_body)
++
+ def _generate_replay_objmapper_class(self):
# Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')
obj_map_dict = {}
for ty in xgl.object_type_list:
mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
obj_map_dict[mem_var] = ty
rc_body = []
- rc_body.append('class xglReplay : public ApiReplay {')
+ rc_body.append('typedef struct _XGLAllocInfo {')
+ rc_body.append(' XGL_GPU_SIZE size;')
+ rc_body.append(' void *pData;')
+ rc_body.append('} XGLAllocInfo;')
+ rc_body.append('')
++ rc_body.append('class objMemory {')
+ rc_body.append('public:')
- rc_body.append(' ~xglReplay();')
- rc_body.append(' xglReplay(glvreplay_settings *pReplaySettings);\n')
- rc_body.append(' int init(glv_replay::Display & disp);')
- rc_body.append(' xglDisplay * get_display() {return m_display;}')
- rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')
- rc_body.append(' glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);\n')
- rc_body.append(' void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg);')
- rc_body.append(' glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();')
- rc_body.append(' int dump_validation_data();')
- rc_body.append('private:')
- rc_body.append(' struct xglFuncs m_xglFuncs;')
- rc_body.append(' DRAW_STATE_DUMP_DOT_FILE m_pDSDump;')
- rc_body.append(' DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE m_pCBDump;')
- rc_body.append(' xglDisplay *m_display;')
- rc_body.append(' struct shaderPair {')
- rc_body.append(' XGL_SHADER *addr;')
- rc_body.append(' XGL_SHADER val;')
- rc_body.append(' };')
- rc_body.append(' struct validationMsg {')
- rc_body.append(' XGL_VALIDATION_LEVEL validationLevel;')
- rc_body.append(' XGL_BASE_OBJECT srcObject;')
- rc_body.append(' size_t location;')
- rc_body.append(' int32_t msgCode;')
- rc_body.append(' char msg[256];')
- rc_body.append(' };')
- rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')
- rc_body.append(' std::vector<int> m_screenshotFrames;')
- rc_body.append(' bool m_adjustForGPU; // true if replay adjusts behavior based on GPU')
- # Code for memory objects for handling replay GPU != trace GPU object memory requirements
- rc_body.append(' struct imageObj {')
- rc_body.append(' objMemory imageMem;')
- rc_body.append(' XGL_IMAGE replayImage;')
- rc_body.append(' };\n')
- rc_body.append(' struct bufferObj {')
- rc_body.append(' objMemory bufferMem;')
- rc_body.append(' XGL_BUFFER replayBuffer;')
- rc_body.append(' };\n')
- rc_body.append(' struct gpuMemObj {')
- rc_body.append(' gpuMemory *pGpuMem;')
- rc_body.append(' XGL_GPU_MEMORY replayGpuMem;')
- rc_body.append(' };\n')
- rc_body.append(' void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num)\n {')
- rc_body.append(' XGL_IMAGE img = static_cast <XGL_IMAGE> (object);')
- rc_body.append(' std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);')
- rc_body.append(' if (it != m_images.end())')
- rc_body.append(' {')
- rc_body.append(' objMemory obj = it->second.imageMem;')
- rc_body.append(' obj.setCount(num);')
- rc_body.append(' return;')
- rc_body.append(' }')
- rc_body.append(' XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);')
- rc_body.append(' std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);')
- rc_body.append(' if (itb != m_buffers.end())')
++ rc_body.append(' objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}')
++ rc_body.append(' ~objMemory() { free(m_pMemReqs);}')
++ rc_body.append(' void setCount(const uint32_t num)')
++ rc_body.append(' {')
++ rc_body.append(' m_numAllocations = num;')
++ rc_body.append(' }\n')
++ rc_body.append(' void setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num)')
++ rc_body.append(' {')
++ rc_body.append(' if (m_numAllocations != num && m_numAllocations != 0)')
++ rc_body.append(' glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");')
++ rc_body.append(' if (m_pMemReqs == NULL && pReqs != NULL)')
+ rc_body.append(' {')
- rc_body.append(' objMemory obj = itb->second.bufferMem;')
- rc_body.append(' obj.setCount(num);')
- rc_body.append(' return;')
++ rc_body.append(' m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS));')
++ rc_body.append(' if (m_pMemReqs == NULL)')
++ rc_body.append(' {')
++ rc_body.append(' glv_LogError("objMemory::setReqs out of memory");')
++ rc_body.append(' return;')
++ rc_body.append(' }')
++ rc_body.append(' memcpy(m_pMemReqs, pReqs, num);')
+ rc_body.append(' }')
- rc_body.append(' return;')
+ rc_body.append(' }\n')
++ rc_body.append('private:')
++ rc_body.append(' uint32_t m_numAllocations;')
++ rc_body.append(' XGL_MEMORY_REQUIREMENTS *m_pMemReqs;')
++ rc_body.append('};')
++ rc_body.append('')
++ rc_body.append('class gpuMemory {')
++ rc_body.append('public:')
++ rc_body.append(' gpuMemory() : m_pendingAlloc(false) {m_allocInfo.allocationSize = 0;}')
++ rc_body.append(' ~gpuMemory() {}')
++ rc_body.append(self._generate_replay_objMemory_funcs())
++# rc_body.append(' bool isPendingAlloc();')
++# rc_body.append(' void setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending);')
++# rc_body.append(' void setMemoryDataAddr(void* pBuf);')
++# rc_body.append(' void setMemoryMapRange(void* pBuf, const size_t size, const size_t offset, const bool pending);')
++# rc_body.append(' void copyMappingData(const void *pSrcData);')
++# rc_body.append(' size_t getMemoryMapSize();')
++ rc_body.append('private:')
++ rc_body.append(' bool m_pendingAlloc;')
++ rc_body.append(' struct MapRange {')
++ rc_body.append(' bool pending;')
++ rc_body.append(' size_t size;')
++ rc_body.append(' size_t offset;')
++ rc_body.append(' void* pData;')
++ rc_body.append(' };')
++ rc_body.append(' std::vector<MapRange> m_mapRange;')
++ rc_body.append(' XGL_MEMORY_ALLOC_INFO m_allocInfo;')
++ rc_body.append('};')
++ rc_body.append('')
++ rc_body.append('typedef struct _imageObj {')
++ rc_body.append(' objMemory imageMem;')
++ rc_body.append(' XGL_IMAGE replayImage;')
++ rc_body.append(' } imageObj;')
++ rc_body.append('')
++ rc_body.append('typedef struct _bufferObj {')
++ rc_body.append(' objMemory bufferMem;')
++ rc_body.append(' XGL_BUFFER replayBuffer;')
++ rc_body.append(' } bufferObj;')
++ rc_body.append('')
++ rc_body.append('typedef struct _gpuMemObj {')
++ rc_body.append(' gpuMemory *pGpuMem;')
++ rc_body.append(' XGL_GPU_MEMORY replayGpuMem;')
++ rc_body.append(' } gpuMemObj;')
++ rc_body.append('')
+ rc_body.append('class xglReplayObjMapper {')
+ rc_body.append('public:')
+ rc_body.append(' xglReplayObjMapper() {}')
+ rc_body.append(' ~xglReplayObjMapper() {}')
+ rc_body.append('')
- rc_body.append(self._map_decl('XGL_GPU_MEMORY', 'XGLAllocInfo', 'm_mapData'))
- # Custom code for 1-off memory mapping functions
- rc_body.append(' void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)')
- rc_body.append(' {')
- rc_body.append(' XGLAllocInfo info;')
- rc_body.append(' info.pData = NULL;')
- rc_body.append(' info.size = size;')
- rc_body.append(' m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));')
- rc_body.append(' }')
- rc_body.append('')
- rc_body.append(' void add_mapping_to_mapData(XGL_GPU_MEMORY handle, void *pData)')
- rc_body.append(' {')
- rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
- rc_body.append(' if (it == m_mapData.end())')
++ rc_body.append(' bool m_adjustForGPU; // true if replay adjusts behavior based on GPU')
++ # Code for memory objects for handling replay GPU != trace GPU object memory requirements
++ rc_body.append(' void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num)\n {')
++ rc_body.append(' XGL_IMAGE img = static_cast <XGL_IMAGE> (object);')
++ rc_body.append(' std::map<XGL_IMAGE, imageObj>::const_iterator it = m_images.find(img);')
++ rc_body.append(' if (it != m_images.end())')
++ rc_body.append(' {')
++ rc_body.append(' objMemory obj = it->second.imageMem;')
++ rc_body.append(' obj.setCount(num);')
++ rc_body.append(' return;')
++ rc_body.append(' }')
++ rc_body.append(' XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);')
++ rc_body.append(' std::map<XGL_BUFFER, bufferObj>::const_iterator itb = m_buffers.find(buf);')
++ rc_body.append(' if (itb != m_buffers.end())')
++ rc_body.append(' {')
++ rc_body.append(' objMemory obj = itb->second.bufferMem;')
++ rc_body.append(' obj.setCount(num);')
++ rc_body.append(' return;')
++ rc_body.append(' }')
++ rc_body.append(' return;')
++ rc_body.append(' }\n')
+ rc_body.append(' void init_objMemReqs(const XGL_BASE_OBJECT& object, const XGL_MEMORY_REQUIREMENTS *pMemReqs, const unsigned int num)\n {')
+ rc_body.append(' XGL_IMAGE img = static_cast <XGL_IMAGE> (object);')
- rc_body.append(' std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);')
++ rc_body.append(' std::map<XGL_IMAGE, imageObj>::const_iterator it = m_images.find(img);')
+ rc_body.append(' if (it != m_images.end())')
rc_body.append(' {')
- rc_body.append(' glv_LogWarn("add_mapping_to_mapData() could not find entry\\n");')
+ rc_body.append(' objMemory obj = it->second.imageMem;')
+ rc_body.append(' obj.setReqs(pMemReqs, num);')
rc_body.append(' return;')
rc_body.append(' }')
- rc_body.append(' XGLAllocInfo &info = it->second;')
- rc_body.append(' if (info.pData != NULL)')
- rc_body.append(' glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\\n");')
- rc_body.append(' else if (pData == NULL)')
- rc_body.append(' glv_LogWarn("add_mapping_to_mapData() adding NULL pointer\\n");')
- rc_body.append(' info.pData = pData;')
- rc_body.append(' }')
- rc_body.append('')
- rc_body.append(' void rm_entry_from_mapData(XGL_GPU_MEMORY handle)')
- rc_body.append(' {')
- rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
- rc_body.append(' if (it == m_mapData.end())')
- rc_body.append(' return;')
- rc_body.append(' m_mapData.erase(it);')
- rc_body.append(' }')
- rc_body.append('')
- rc_body.append(' void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, void* pData)')
- rc_body.append(' {')
- rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
- rc_body.append(' if (it == m_mapData.end())')
- rc_body.append(' return;\n')
- rc_body.append(' XGLAllocInfo &info = it->second;')
- rc_body.append(' if (!pData || !info.pData)')
+ rc_body.append(' XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);')
- rc_body.append(' std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);')
++ rc_body.append(' std::map<XGL_BUFFER, bufferObj>::const_iterator itb = m_buffers.find(buf);')
+ rc_body.append(' if (itb != m_buffers.end())')
rc_body.append(' {')
- rc_body.append(' if (!pData)')
- rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null src pointer\\n");')
- rc_body.append(' else')
- rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null dest pointer size=%u\\n", info.size);')
- rc_body.append(' info.pData = NULL;')
+ rc_body.append(' objMemory obj = itb->second.bufferMem;')
+ rc_body.append(' obj.setReqs(pMemReqs, num);')
rc_body.append(' return;')
rc_body.append(' }')
- rc_body.append(' memcpy(info.pData, pData, info.size);')
- rc_body.append(' info.pData = NULL;')
+ rc_body.append(' return;')
- rc_body.append(' }\n')
+ rc_body.append(' }')
+ rc_body.append('')
- rc_body.append(' /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;')
- rc_body.append(' void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)')
- rc_body.append(' {')
- rc_body.append(' assert(pTraceGpu != NULL);')
- rc_body.append(' assert(pReplayGpu != NULL);')
- rc_body.append(' m_gpus[*pTraceGpu] = *pReplayGpu;')
- rc_body.append(' }')
- rc_body.append('')
- rc_body.append(' XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)')
- rc_body.append(' {')
- rc_body.append(' std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);')
- rc_body.append(' return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;')
- rc_body.append(' }*/')
- rc_body.append('')
rc_body.append(' void clear_all_map_handles()\n {')
for var in sorted(obj_map_dict):
rc_body.append(' %s.clear();' % var)
- rc_body.append(' }')
+ rc_body.append(' }\n')
for var in sorted(obj_map_dict):
- rc_body.append('')
- rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
- rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
- rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
- rc_body.append(self._remap_decl(obj_map_dict[var], var))
+ if obj_map_dict[var] == 'XGL_IMAGE':
- rc_body.append(self._map_decl(obj_map_dict[var], 'struct imageObj', var))
- rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'struct imageObj', var))
++ rc_body.append(self._map_decl(obj_map_dict[var], 'imageObj', var))
++ rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'imageObj', var))
+ rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
+ rc_body.append(' XGL_IMAGE remap(const XGL_IMAGE& value)')
+ rc_body.append(' {')
- rc_body.append(' std::map<XGL_IMAGE, struct imageObj>::const_iterator q = m_images.find(value);')
++ rc_body.append(' std::map<XGL_IMAGE, imageObj>::const_iterator q = m_images.find(value);')
+ rc_body.append(' return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second.replayImage;')
+ rc_body.append(' }\n')
+ elif obj_map_dict[var] == 'XGL_BUFFER':
- rc_body.append(self._map_decl(obj_map_dict[var], 'struct bufferObj', var))
- rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'struct bufferObj', var))
++ rc_body.append(self._map_decl(obj_map_dict[var], 'bufferObj', var))
++ rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'bufferObj', var))
+ rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
+ rc_body.append(' XGL_BUFFER remap(const XGL_BUFFER& value)')
+ rc_body.append(' {')
- rc_body.append(' std::map<XGL_BUFFER, struct bufferObj>::const_iterator q = m_buffers.find(value);')
++ rc_body.append(' std::map<XGL_BUFFER, bufferObj>::const_iterator q = m_buffers.find(value);')
+ rc_body.append(' return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second.replayBuffer;')
+ rc_body.append(' }\n')
+ elif obj_map_dict[var] == 'XGL_GPU_MEMORY':
- rc_body.append(self._map_decl(obj_map_dict[var], 'struct gpuMemObj', var))
- rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'struct gpuMemObj', var))
++ rc_body.append(self._map_decl(obj_map_dict[var], 'gpuMemObj', var))
++ rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'gpuMemObj', var))
+ rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
+ rc_body.append(' XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& value)')
+ rc_body.append(' {')
- rc_body.append(' std::map<XGL_GPU_MEMORY, struct gpuMemObj>::const_iterator q = m_gpuMemorys.find(value);')
++ rc_body.append(' std::map<XGL_GPU_MEMORY, gpuMemObj>::const_iterator q = m_gpuMemorys.find(value);')
+ rc_body.append(' return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second.replayGpuMem;')
+ rc_body.append(' }\n')
+ else:
+ rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
+ rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
+ rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
+ rc_body.append(self._remap_decl(obj_map_dict[var], var))
# XGL_DYNAMIC_STATE_OBJECT code
state_obj_remap_types = xgl.object_dynamic_state_list
rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
for t in base_obj_remap_types:
rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)
rc_body.append(' return obj;')
- rc_body.append(' return XGL_NULL_HANDLE;\n }')
- rc_body.append('void process_screenshot_list(const char *list)')
- rc_body.append('{')
- rc_body.append(' std::string spec(list), word;')
- rc_body.append(' size_t start = 0, comma = 0;\n')
- rc_body.append(' while (start < spec.size()) {')
- rc_body.append(' comma = spec.find(\',\', start);\n')
- rc_body.append(' if (comma == std::string::npos)')
- rc_body.append(' word = std::string(spec, start);')
- rc_body.append(' else')
- rc_body.append(' word = std::string(spec, start, comma - start);\n')
- rc_body.append(' m_screenshotFrames.push_back(atoi(word.c_str()));')
- rc_body.append(' if (comma == std::string::npos)')
- rc_body.append(' break;\n')
- rc_body.append(' start = comma + 1;\n')
+ rc_body.append(' return XGL_NULL_HANDLE;')
- rc_body.append(' }\n')
+ rc_body.append(' }')
- rc_body.append('}')
rc_body.append('};')
return "\n".join(rc_body)
- def _generate_replay_display_init_xgl(self):
- dix_body = []
- dix_body.append('XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)')
- dix_body.append('{')
- dix_body.append('#if 0')
- dix_body.append(' XGL_APPLICATION_INFO appInfo = {};')
- dix_body.append(' appInfo.pAppName = APP_NAME;')
- dix_body.append(' appInfo.pEngineName = "";')
- dix_body.append(' appInfo.apiVersion = XGL_API_VERSION;')
- dix_body.append(' XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);')
- dix_body.append(' if ( res == XGL_SUCCESS ) {')
- dix_body.append(' // retrieve the GPU information for all GPUs')
- dix_body.append(' for( uint32_t gpu = 0; gpu < m_gpuCount; gpu++)')
- dix_body.append(' {')
- dix_body.append(' size_t gpuInfoSize = sizeof(m_gpuProps[0]);\n')
- dix_body.append(' // get the GPU physical properties:')
- dix_body.append(' res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);')
- dix_body.append(' if (res != XGL_SUCCESS)')
- dix_body.append(' glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\\n", gpu, res);')
- dix_body.append(' }')
- dix_body.append(' res = XGL_SUCCESS;')
- dix_body.append(' } else if ((gpu_idx + 1) > m_gpuCount) {')
- dix_body.append(' glv_LogError("xglInitAndEnumerate number of gpus does not include requested index: num %d, requested %d\\n", m_gpuCount, gpu_idx);')
- dix_body.append(' return -1;')
- dix_body.append(' } else {')
- dix_body.append(' glv_LogError("xglInitAndEnumerate failed\\n");')
- dix_body.append(' return res;')
- dix_body.append(' }')
- dix_body.append(' // TODO add multi-gpu support always use gpu[gpu_idx] for now')
- dix_body.append(' // get all extensions supported by this device gpu[gpu_idx]')
- dix_body.append(' // first check if extensions are available and save a list of them')
- dix_body.append(' bool foundWSIExt = false;')
- dix_body.append(' for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)')
- dix_body.append(' {')
- dix_body.append(' res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );')
- dix_body.append(' if (res == XGL_SUCCESS) {')
- dix_body.append(' m_extensions.push_back((char *) extensions[ext]);')
- dix_body.append(' if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))')
- dix_body.append(' foundWSIExt = true;')
- dix_body.append(' }')
- dix_body.append(' }')
- dix_body.append(' if (!foundWSIExt) {')
- dix_body.append(' glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\\n", gpu_idx);')
- dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')
- dix_body.append(' }')
- dix_body.append(' // TODO generalize this: use one universal queue for now')
- dix_body.append(' XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};')
- dix_body.append(' dqci.queueCount = 1;')
- dix_body.append(' dqci.queueType = XGL_QUEUE_UNIVERSAL;')
- dix_body.append(' // create the device enabling validation level 4')
- dix_body.append(' const char * const * extNames = &m_extensions[0];')
- dix_body.append(' XGL_DEVICE_CREATE_INFO info = {};')
- dix_body.append(' info.queueRecordCount = 1;')
- dix_body.append(' info.pRequestedQueues = &dqci;')
- dix_body.append(' info.extensionCount = static_cast <uint32_t> (m_extensions.size());')
- dix_body.append(' info.ppEnabledExtensionNames = extNames;')
- dix_body.append(' info.flags = XGL_DEVICE_CREATE_VALIDATION;')
- dix_body.append(' info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;')
- dix_body.append(' bool32_t xglTrue = XGL_TRUE;')
- dix_body.append(' res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );')
- dix_body.append(' if (res != XGL_SUCCESS)')
- dix_body.append(' glv_LogWarn("Could not set debug option break on error\\n");')
- dix_body.append(' res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);')
- dix_body.append(' return res;')
- dix_body.append('#else')
- dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')
- dix_body.append('#endif')
- dix_body.append('}')
- return "\n".join(dix_body)
-
- def _generate_replay_display_init(self):
- di_body = []
- di_body.append('int xglDisplay::init(const unsigned int gpu_idx)')
- di_body.append('{')
- di_body.append(' //m_gpuIdx = gpu_idx;')
- di_body.append('#if 0')
- di_body.append(' XGL_RESULT result = init_xgl(gpu_idx);')
- di_body.append(' if (result != XGL_SUCCESS) {')
- di_body.append(' glv_LogError("could not init xgl library");')
- di_body.append(' return -1;')
- di_body.append(' } else {')
- di_body.append(' m_initedXGL = true;')
- di_body.append(' }')
- di_body.append('#endif')
- di_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- di_body.append(' const xcb_setup_t *setup;')
- di_body.append(' xcb_screen_iterator_t iter;')
- di_body.append(' int scr;')
- di_body.append(' xcb_connection_t *pConnection;')
- di_body.append(' pConnection = xcb_connect(NULL, &scr);')
- di_body.append(' setup = xcb_get_setup(pConnection);')
- di_body.append(' iter = xcb_setup_roots_iterator(setup);')
- di_body.append(' while (scr-- > 0)')
- di_body.append(' xcb_screen_next(&iter);')
- di_body.append(' m_pXcbScreen = iter.data;')
- di_body.append(' m_WsiConnection.pConnection = pConnection;')
- di_body.append(' m_WsiConnection.root = m_pXcbScreen->root;')
- di_body.append('#endif')
- di_body.append(' return 0;')
- di_body.append('}')
- return "\n".join(di_body)
-
- def _generate_replay_display_structors(self):
- ds_body = []
- ds_body.append('xglDisplay::xglDisplay()')
- ds_body.append(' : m_initedXGL(false),')
- ds_body.append(' m_windowWidth(0),')
- ds_body.append(' m_windowHeight(0)')
- ds_body.append('{')
- ds_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- ds_body.append(' m_WsiConnection.pConnection = NULL;')
- ds_body.append(' m_WsiConnection.root = 0;')
- ds_body.append(' m_WsiConnection.provider = 0;')
- ds_body.append(' m_pXcbScreen = NULL;')
- ds_body.append(' m_XcbWindow = 0;')
- ds_body.append('#elif defined(WIN32)')
- ds_body.append(' m_windowHandle = NULL;')
- ds_body.append('#endif')
- ds_body.append('}')
- ds_body.append('xglDisplay::~xglDisplay()')
- ds_body.append('{')
- ds_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- ds_body.append(' if (m_XcbWindow != 0)')
- ds_body.append(' {')
- ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')
- ds_body.append(' }')
- ds_body.append(' if (m_WsiConnection.pConnection != NULL)')
- ds_body.append(' {')
- ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')
- ds_body.append(' }')
- ds_body.append('#endif')
- ds_body.append('}')
- return "\n".join(ds_body)
-
- def _generate_replay_display_window(self):
- dw_body = []
- dw_body.append('#if defined(WIN32)')
- dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')
- dw_body.append('{')
- dw_body.append(' switch(msg)')
- dw_body.append(' {')
- dw_body.append(' case WM_CLOSE:')
- dw_body.append(' DestroyWindow( window);')
- dw_body.append(' // fall-thru')
- dw_body.append(' case WM_DESTROY:')
- dw_body.append(' PostQuitMessage(0) ;')
- dw_body.append(' return 0L ;')
- dw_body.append(' default:')
- dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')
- dw_body.append(' }')
- dw_body.append('}')
- dw_body.append('#endif')
- dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')
- dw_body.append('{')
- dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- dw_body.append(' m_XcbWindow = hWindow;')
- dw_body.append('#elif defined(WIN32)')
- dw_body.append(' m_windowHandle = hWindow;')
- dw_body.append('#endif')
- dw_body.append(' m_windowWidth = width;')
- dw_body.append(' m_windowHeight = height;')
- dw_body.append(' return 0;')
- dw_body.append('}\n')
- dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')
- dw_body.append('{')
- dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)\n')
- dw_body.append(' uint32_t value_mask, value_list[32];')
- dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')
- dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')
- dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')
- dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')
- dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')
- dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')
- dw_body.append(' XCB_COPY_FROM_PARENT,')
- dw_body.append(' m_XcbWindow, m_WsiConnection.root,')
- dw_body.append(' 0, 0, width, height, 0,')
- dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')
- dw_body.append(' m_pXcbScreen->root_visual,')
- dw_body.append(' value_mask, value_list);\n')
- dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')
- dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')
- dw_body.append(' return 0;')
- dw_body.append('#elif defined(WIN32)')
- dw_body.append(' // Register Window class')
- dw_body.append(' WNDCLASSEX wcex = {};')
- dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')
- dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')
- dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')
- dw_body.append(' wcex.cbClsExtra = 0;')
- dw_body.append(' wcex.cbWndExtra = 0;')
- dw_body.append(' wcex.hInstance = GetModuleHandle(0);')
- dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
- dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')
- dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')
- dw_body.append(' wcex.lpszMenuName = NULL;')
- dw_body.append(' wcex.lpszClassName = APP_NAME;')
- dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
- dw_body.append(' if( !RegisterClassEx( &wcex))')
- dw_body.append(' {')
- dw_body.append(' glv_LogError("Failed to register windows class\\n");')
- dw_body.append(' return -1;')
- dw_body.append(' }\n')
- dw_body.append(' // create the window')
- dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')
- dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')
- dw_body.append(' if (m_windowHandle)')
- dw_body.append(' {')
- dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')
- dw_body.append(' m_windowWidth = width;')
- dw_body.append(' m_windowHeight = height;')
- dw_body.append(' } else {')
- dw_body.append(' glv_LogError("Failed to create window\\n");')
- dw_body.append(' return -1;')
- dw_body.append(' }')
- dw_body.append(' return 0;')
- dw_body.append('#endif')
- dw_body.append('}\n')
- dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')
- dw_body.append('{')
- dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
- dw_body.append(' {')
- dw_body.append(' uint32_t values[2];')
- dw_body.append(' values[0] = width;')
- dw_body.append(' values[1] = height;')
- dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')
- dw_body.append(' m_windowWidth = width;')
- dw_body.append(' m_windowHeight = height;')
- dw_body.append(' }')
- dw_body.append('#elif defined(WIN32)')
- dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
- dw_body.append(' {')
- dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')
- dw_body.append(' m_windowWidth = width;')
- dw_body.append(' m_windowHeight = height;')
- dw_body.append(' }')
- dw_body.append('#endif')
- dw_body.append('}\n')
- dw_body.append('void xglDisplay::process_event()')
- dw_body.append('{')
- dw_body.append('}\n')
- return "\n".join(dw_body)
-
- def _generate_replay_objMemory_funcs(self):
- rof_body = []
- rof_body.append('void objMemory::setCount(const uint32_t num)')
- rof_body.append('{')
- rof_body.append(' m_numAllocations = num;')
- rof_body.append('}\n')
- rof_body.append('void objMemory::setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num)')
- rof_body.append('{')
- rof_body.append(' if (m_numAllocations != num && m_numAllocations != 0)')
- rof_body.append(' glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");')
- rof_body.append(' if (m_pMemReqs == NULL && pReqs != NULL)')
- rof_body.append(' {')
- rof_body.append(' m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS));')
- rof_body.append(' if (m_pMemReqs == NULL)')
- rof_body.append(' {')
- rof_body.append(' glv_LogError("objMemory::setReqs out of memory");')
- rof_body.append(' return;')
- rof_body.append(' }')
- rof_body.append(' memcpy(m_pMemReqs, pReqs, num);')
- rof_body.append(' }')
- rof_body.append('}\n')
- # Custom code for memory mapping functions for app writes into mapped memory
- rof_body.append(' // memory mapping functions for app writes into mapped memory')
- rof_body.append(' bool gpuMemory::isPendingAlloc()')
- rof_body.append(' {')
- rof_body.append(' return m_pendingAlloc;')
- rof_body.append(' }\n')
- rof_body.append(' void gpuMemory::setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending)')
- rof_body.append(' {')
- rof_body.append(' m_pendingAlloc = pending;')
- rof_body.append(' m_allocInfo = *info;')
- rof_body.append(' }\n')
- rof_body.append(' void gpuMemory::setMemoryDataAddr(void *pBuf)')
- rof_body.append(' {')
- rof_body.append(' if (m_mapRange.empty())')
- rof_body.append(' {')
- rof_body.append(' glv_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty\\n");')
- rof_body.append(' return;')
- rof_body.append(' }')
- rof_body.append(' struct mapRange mr = m_mapRange.back();')
- rof_body.append(' if (mr.pData != NULL)')
- rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping\\n");')
- rof_body.append(' else if (pBuf == NULL)')
- rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() adding NULL pointer\\n");')
- rof_body.append(' mr.pData = pBuf;')
- rof_body.append(' }\n')
- rof_body.append(' void gpuMemory::setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending)')
- rof_body.append(' {')
- rof_body.append(' struct mapRange mr;')
- rof_body.append(' mr.pData = pBuf;')
- rof_body.append(' mr.size = size;')
- rof_body.append(' mr.offset = offset;')
- rof_body.append(' mr.pending = pending;')
- rof_body.append(' m_mapRange.push_back(mr);')
- rof_body.append(' }\n')
- rof_body.append(' void gpuMemory::copyMappingData(const void* pSrcData)')
- rof_body.append(' {')
- rof_body.append(' if (m_mapRange.empty())')
- rof_body.append(' {')
- rof_body.append(' glv_LogError("gpuMemory::copyMappingData() m_mapRange is empty\\n");')
- rof_body.append(' return;')
- rof_body.append(' }')
- rof_body.append(' struct mapRange mr = m_mapRange.back();')
- rof_body.append(' if (!pSrcData || !mr.pData)')
- rof_body.append(' {')
- rof_body.append(' if (!pSrcData)')
- rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null src pointer\\n");')
- rof_body.append(' else')
- rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null dest pointer size=%u\\n", m_allocInfo.allocationSize);')
- rof_body.append(' m_mapRange.pop_back();')
- rof_body.append(' return;')
- rof_body.append(' }')
- rof_body.append(' memcpy(mr.pData, pSrcData, m_allocInfo.allocationSize);')
- rof_body.append(' if (!mr.pending)')
- rof_body.append(' m_mapRange.pop_back();')
- rof_body.append(' }\n')
- rof_body.append(' size_t gpuMemory::getMemoryMapSize()')
- rof_body.append(' {')
- rof_body.append(' return (!m_mapRange.empty()) ? m_mapRange.back().size : 0;')
- rof_body.append(' }\n')
- return "\n".join(rof_body)
-
- def _generate_replay_structors(self):
- rs_body = []
- rs_body.append('xglReplay::xglReplay(glvreplay_settings *pReplaySettings)')
- rs_body.append('{')
- rs_body.append(' g_pReplaySettings = pReplaySettings;')
- rs_body.append(' m_display = new xglDisplay();')
- rs_body.append(' m_pDSDump = NULL;')
- rs_body.append(' m_pCBDump = NULL;')
- rs_body.append(' m_adjustForGPU = false;')
- rs_body.append(' if (g_pReplaySettings && g_pReplaySettings->screenshotList) {')
- rs_body.append(' process_screenshot_list(g_pReplaySettings->screenshotList);')
- rs_body.append(' }')
- rs_body.append('}\n')
- rs_body.append('xglReplay::~xglReplay()')
- rs_body.append('{')
- rs_body.append(' delete m_display;')
- rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')
- rs_body.append('}')
- return "\n".join(rs_body)
-
- def _generate_replay_init(self):
- ri_body = []
- ri_body.append('int xglReplay::init(glv_replay::Display & disp)')
- ri_body.append('{')
- ri_body.append(' int err;')
- ri_body.append('#if defined PLATFORM_LINUX')
- ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')
- ri_body.append('#else')
- ri_body.append(' HMODULE handle = LoadLibrary("xgl.dll" );')
- ri_body.append('#endif\n')
- ri_body.append(' if (handle == NULL) {')
- ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')
- ri_body.append(' return -1;')
- ri_body.append(' }')
- ri_body.append(' m_xglFuncs.init_funcs(handle);')
- ri_body.append(' disp.set_implementation(m_display);')
- ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')
- ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')
- ri_body.append(' return err;')
- ri_body.append(' }')
- ri_body.append(' if (disp.get_window_handle() == 0)')
- ri_body.append(' {')
- ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')
- ri_body.append(' glv_LogError("Failed to create Window\\n");')
- ri_body.append(' return err;')
- ri_body.append(' }')
- ri_body.append(' }')
- ri_body.append(' else')
- ri_body.append(' {')
- ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')
- ri_body.append(' {')
- ri_body.append(' glv_LogError("Failed to set Window\\n");')
- ri_body.append(' return err;')
- ri_body.append(' }')
- ri_body.append(' }')
- ri_body.append(' return 0;')
- ri_body.append('}')
- return "\n".join(ri_body)
-
- def _generate_replay_errors(self):
- re_body = []
- re_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)')
- re_body.append('{')
- re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')
- re_body.append(' if (resCall != resTrace) {')
- re_body.append(' glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\\n", entrypointName,')
- re_body.append(' string_XGL_RESULT((XGL_RESULT)resTrace), string_XGL_RESULT((XGL_RESULT)resCall));')
- re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')
- re_body.append(' }')
- re_body.append('#if 0')
- re_body.append(' if (resCall != XGL_SUCCESS) {')
- re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')
- re_body.append(' }')
- re_body.append('#endif')
- re_body.append(' return res;')
- re_body.append('}')
- return "\n".join(re_body)
-
- def _generate_replay_validation_funcs(self):
- rvf_body = []
- rvf_body.append('void xglReplay::push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char * pMsg)')
- rvf_body.append('{')
- rvf_body.append(' struct validationMsg msgObj;')
- rvf_body.append(' msgObj.validationLevel = validationLevel;')
- rvf_body.append(' msgObj.srcObject = srcObject;')
- rvf_body.append(' msgObj.location = location;')
- rvf_body.append(' msgObj.msgCode = msgCode;')
- rvf_body.append(' strncpy(msgObj.msg, pMsg, 256);')
- rvf_body.append(" msgObj.msg[255] = '\\0';")
- rvf_body.append(' m_validationMsgs.push_back(msgObj);')
- rvf_body.append('}\n')
- rvf_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::pop_validation_msgs()')
- rvf_body.append('{')
- rvf_body.append(' if (m_validationMsgs.size() == 0)')
- rvf_body.append(' return glv_replay::GLV_REPLAY_SUCCESS;')
- rvf_body.append(' m_validationMsgs.clear();')
- rvf_body.append(' return glv_replay::GLV_REPLAY_VALIDATION_ERROR;')
- rvf_body.append('}')
- rvf_body.append('int xglReplay::dump_validation_data()')
- rvf_body.append('{')
- rvf_body.append(' if (!m_pDSDump || !m_pCBDump)')
- rvf_body.append(' {')
- rvf_body.append(' return -1;')
- rvf_body.append(' }')
- rvf_body.append(' m_pDSDump((char *) "pipeline_dump.dot");')
- rvf_body.append(' m_pCBDump((char *) "cb_dump.dot");')
- rvf_body.append(' return 0;')
- rvf_body.append('}')
- return "\n".join(rvf_body)
--
def _generate_replay_init_funcs(self):
rif_body = []
rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
def _gen_replay_get_format_info(self):
gfi_body = []
- gfi_body.append(' size_t size = 0;')
- gfi_body.append(' void* pData = NULL;')
- gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
- gfi_body.append(' {')
- gfi_body.append(' size = *pPacket->pDataSize;')
- gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
- gfi_body.append(' }')
- gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')
- gfi_body.append(' if (replayResult == XGL_SUCCESS)')
- gfi_body.append(' {')
- gfi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
- gfi_body.append(' {')
- gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
- gfi_body.append(' }')
- gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
- gfi_body.append(' {')
- gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')
- gfi_body.append(' }')
- gfi_body.append(' }')
- gfi_body.append(' glv_free(pData);')
+ gfi_body.append(' returnValue = manually_handle_xglGetFormatInfo(pPacket);')
return "\n".join(gfi_body)
- ci_body.append(' struct imageObj local_imageObj;')
- ci_body.append(' replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);')
+ def _gen_replay_create_image(self):
+ ci_body = []
- ci_body.append(' add_to_map(pPacket->pImage, &local_imageObj);')
++ ci_body.append(' imageObj local_imageObj;')
++ ci_body.append(' replayResult = m_xglFuncs.real_xglCreateImage(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);')
+ ci_body.append(' if (replayResult == XGL_SUCCESS)')
+ ci_body.append(' {')
- cb_body.append(' struct bufferObj local_bufferObj;')
- cb_body.append(' replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
++ ci_body.append(' m_objMapper.add_to_map(pPacket->pImage, &local_imageObj);')
+ ci_body.append(' }')
+ return "\n".join(ci_body)
+
+ def _gen_replay_create_buffer(self):
+ cb_body = []
- cb_body.append(' add_to_map(pPacket->pBuffer, &local_bufferObj);')
++ cb_body.append(' bufferObj local_bufferObj;')
++ cb_body.append(' replayResult = m_xglFuncs.real_xglCreateBuffer(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
+ cb_body.append(' if (replayResult == XGL_SUCCESS)')
+ cb_body.append(' {')
++ cb_body.append(' m_objMapper.add_to_map(pPacket->pBuffer, &local_bufferObj);')
+ cb_body.append(' }')
+ return "\n".join(cb_body)
+
def _gen_replay_get_image_subresource_info(self):
isi_body = []
- isi_body.append(' size_t size = 0;')
- isi_body.append(' void* pData = NULL;')
- isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
- isi_body.append(' {')
- isi_body.append(' size = *pPacket->pDataSize;')
- isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
- isi_body.append(' }')
- isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')
- isi_body.append(' if (replayResult == XGL_SUCCESS)')
- isi_body.append(' {')
- isi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
- isi_body.append(' {')
- isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
- isi_body.append(' }')
- isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
- isi_body.append(' {')
- isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')
- isi_body.append(' }')
- isi_body.append(' }')
- isi_body.append(' glv_free(pData);')
+ isi_body.append(' returnValue = manually_handle_xglGetImageSubresourceInfo(pPacket);')
return "\n".join(isi_body)
def _gen_replay_update_descriptors(self):
def _gen_replay_wsi_queue_present(self):
wqp_body = []
- wqp_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')
- wqp_body.append(' std::vector<int>::iterator it;')
- wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')
- wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')
- wqp_body.append(' // use replayers Xcb window')
- wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')
- wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')
- wqp_body.append(' it = std::find(m_screenshotFrames.begin(), m_screenshotFrames.end(), m_display->m_frameNumber);')
- wqp_body.append(' if (it != m_screenshotFrames.end())')
- wqp_body.append(' {')
- wqp_body.append(' for(unsigned int i=0; i<m_display->imageHandles.size(); i++)')
- wqp_body.append(' {')
- wqp_body.append(' if (m_display->imageHandles[i] == pInfo.srcImage)')
- wqp_body.append(' {')
- wqp_body.append(' char frameName[32];')
- wqp_body.append(' sprintf(frameName, "%d",m_display->m_frameNumber);')
- wqp_body.append(' glvWritePPM(frameName, m_display->imageWidth[i], m_display->imageHeight[i],')
- wqp_body.append(' m_display->imageHandles[i], m_display->imageMemory[i], &m_xglFuncs);')
- wqp_body.append(' break;')
- wqp_body.append(' }')
- wqp_body.append(' }')
- wqp_body.append(' }')
- wqp_body.append('#elif defined(WIN32)')
- wqp_body.append(' //TBD')
- wqp_body.append(' replayResult = XGL_SUCCESS;')
- wqp_body.append('#endif')
- wqp_body.append(' m_display->m_frameNumber++;')
+ wqp_body.append(' returnValue = manually_handle_xglWsiX11QueuePresent(pPacket);')
return "\n".join(wqp_body)
- am_body.append(' struct gpuMemObj local_mem;')
- am_body.append(' if (!m_adjustForGPU)')
- am_body.append(' replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);')
- am_body.append(' if (replayResult == XGL_SUCCESS || m_adjustForGPU)')
+ def _gen_replay_alloc_memory(self):
+ am_body = []
- am_body.append(' local_mem.pGpuMem->setAllocInfo(pPacket->pAllocInfo, m_adjustForGPU);')
- am_body.append(' add_to_map(pPacket->pMem, &local_mem);')
++ am_body.append(' gpuMemObj local_mem;')
++ am_body.append(' if (!m_objMapper.m_adjustForGPU)')
++ am_body.append(' replayResult = m_xglFuncs.real_xglAllocMemory(m_objMapper.remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);')
++ am_body.append(' if (replayResult == XGL_SUCCESS || m_objMapper.m_adjustForGPU)')
+ am_body.append(' {')
+ am_body.append(' local_mem.pGpuMem = new (gpuMemory);')
+ am_body.append(' if (local_mem.pGpuMem)')
++ am_body.append(' local_mem.pGpuMem->setAllocInfo(pPacket->pAllocInfo, m_objMapper.m_adjustForGPU);')
++ am_body.append(' m_objMapper.add_to_map(pPacket->pMem, &local_mem);')
+ am_body.append(' }')
+ return "\n".join(am_body)
+
def _gen_replay_free_memory(self):
fm_body = []
- fm_body.append(' struct gpuMemObj local_mem;')
- fm_body.append(' local_mem = m_gpuMemorys.find(pPacket->mem)->second;')
- fm_body.append(' // TODO how/when to free pendingAlloc that did not use and existing gpuMemObj')
- fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(local_mem.replayGpuMem);')
- fm_body.append(' if (replayResult == XGL_SUCCESS) ')
- fm_body.append(' {')
- fm_body.append(' delete local_mem.pGpuMem;')
- fm_body.append(' rm_from_map(pPacket->mem);')
- fm_body.append(' }')
+ fm_body.append(' returnValue = manually_handle_xglFreeMemory(pPacket);')
return "\n".join(fm_body)
def _gen_replay_map_memory(self):
def _gen_replay_unmap_memory(self):
um_body = []
- um_body.append(' struct gpuMemObj local_mem = m_gpuMemorys.find(pPacket->mem)->second;')
- um_body.append(' if (!local_mem.pGpuMem->isPendingAlloc())')
- um_body.append(' {')
- um_body.append(' if (local_mem.pGpuMem)')
- um_body.append(' local_mem.pGpuMem->copyMappingData(pPacket->pData); // copies data from packet into memory buffer')
- um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(local_mem.replayGpuMem);')
- um_body.append(' } else')
- um_body.append(' {')
- um_body.append(' if (local_mem.pGpuMem)')
- um_body.append(' {')
- um_body.append(' unsigned char *pBuf = (unsigned char *) glv_malloc(local_mem.pGpuMem->getMemoryMapSize());')
- um_body.append(' if (!pBuf)')
- um_body.append(' glv_LogError("vkUnmapMemory() malloc failed");')
- um_body.append(' local_mem.pGpuMem->setMemoryDataAddr(pBuf);')
- um_body.append(' local_mem.pGpuMem->copyMappingData(pPacket->pData);')
- um_body.append(' }')
- um_body.append(' }')
+ um_body.append(' returnValue = manually_handle_xglUnmapMemory(pPacket);')
return "\n".join(um_body)
- psm_body.append(' struct gpuMemObj local_mem;')
+ def _gen_replay_pin_system_memory(self):
+ psm_body = []
- psm_body.append(' replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);')
++ psm_body.append(' gpuMemObj local_mem;')
+ psm_body.append(' /* TODO do we need to skip (make pending) this call for m_adjustForGPU */')
- psm_body.append(' add_to_map(pPacket->pMem, &local_mem);')
++ psm_body.append(' replayResult = m_xglFuncs.real_xglPinSystemMemory(m_objMapper.remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);')
+ psm_body.append(' if (replayResult == XGL_SUCCESS)')
++ psm_body.append(' m_objMapper.add_to_map(pPacket->pMem, &local_mem);')
+ return "\n".join(psm_body)
+
+ # I don't think this function is being generated anymore (ie, it may have been removed from XGL)
def _gen_replay_bind_dynamic_memory_view(self):
bdmv_body = []
bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')
--- /dev/null
-class xglReplayObjMapper {
+ /* THIS FILE IS GENERATED. DO NOT EDIT. */
+
+ /*
+ * XGL
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+ #pragma once
+
+ #include <set>
+ #include <map>
+ #include <vector>
+ #include <string>
+ #include "xgl.h"
+ #include "xglDbg.h"
+ #if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
+ #include "xglWsiX11Ext.h"
+ #else
+ #include "xglWsiWinExt.h"
+ #endif
+
+ typedef struct _XGLAllocInfo {
+ XGL_GPU_SIZE size;
+ void *pData;
+ } XGLAllocInfo;
+
- xglReplayObjMapper() {}
- ~xglReplayObjMapper() {}
++class objMemory {
+ public:
- std::map<XGL_GPU_MEMORY, XGLAllocInfo> m_mapData;
- void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)
++ objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}
++ ~objMemory() { free(m_pMemReqs);}
++ void setCount(const uint32_t num)
++ {
++ m_numAllocations = num;
++ }
+
- XGLAllocInfo info;
- info.pData = NULL;
- info.size = size;
- m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));
++ void setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num)
++ {
++ if (m_numAllocations != num && m_numAllocations != 0)
++ glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");
++ if (m_pMemReqs == NULL && pReqs != NULL)
++ {
++ m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS));
++ if (m_pMemReqs == NULL)
++ {
++ glv_LogError("objMemory::setReqs out of memory");
++ return;
++ }
++ memcpy(m_pMemReqs, pReqs, num);
++ }
++ }
++
++private:
++ uint32_t m_numAllocations;
++ XGL_MEMORY_REQUIREMENTS *m_pMemReqs;
++};
++
++class gpuMemory {
++public:
++ gpuMemory() : m_pendingAlloc(false) {m_allocInfo.allocationSize = 0;}
++ ~gpuMemory() {}
++// memory mapping functions for app writes into mapped memory
++ bool isPendingAlloc()
+ {
- void add_mapping_to_mapData(XGL_GPU_MEMORY handle, void *pData)
++ return m_pendingAlloc;
+ }
+
- std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);
- if (it == m_mapData.end())
++ void setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending)
+ {
- glv_LogWarn("add_mapping_to_mapData() could not find entry\n");
++ m_pendingAlloc = pending;
++ m_allocInfo = *info;
++ }
++
++ void setMemoryDataAddr(void *pBuf)
++ {
++ if (m_mapRange.empty())
+ {
- XGLAllocInfo &info = it->second;
- if (info.pData != NULL)
- glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\n");
- else if (pData == NULL)
- glv_LogWarn("add_mapping_to_mapData() adding NULL pointer\n");
- info.pData = pData;
++ glv_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty\n");
+ return;
+ }
- void rm_entry_from_mapData(XGL_GPU_MEMORY handle)
++ MapRange mr = m_mapRange.back();
++ if (mr.pData != NULL)
++ glv_LogWarn("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping\n");
++ else if (pBuf == NULL)
++ glv_LogWarn("gpuMemory::setMemoryDataAddr() adding NULL pointer\n");
++ mr.pData = pBuf;
+ }
+
- std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);
- if (it == m_mapData.end())
- return;
- m_mapData.erase(it);
++ void setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending)
+ {
- void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, void* pData)
++ MapRange mr;
++ mr.pData = pBuf;
++ mr.size = size;
++ mr.offset = offset;
++ mr.pending = pending;
++ m_mapRange.push_back(mr);
+ }
+
- std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);
- if (it == m_mapData.end())
++ void copyMappingData(const void* pSrcData)
+ {
-
- XGLAllocInfo &info = it->second;
- if (!pData || !info.pData)
++ if (m_mapRange.empty())
++ {
++ glv_LogError("gpuMemory::copyMappingData() m_mapRange is empty\n");
+ return;
- if (!pData)
- glv_LogWarn("rm_mapping_from_mapData() null src pointer\n");
++ }
++ MapRange mr = m_mapRange.back();
++ if (!pSrcData || !mr.pData)
+ {
- glv_LogWarn("rm_mapping_from_mapData() null dest pointer size=%u\n", info.size);
- info.pData = NULL;
++ if (!pSrcData)
++ glv_LogError("gpuMemory::copyMappingData() null src pointer\n");
+ else
- memcpy(info.pData, pData, info.size);
- info.pData = NULL;
++ glv_LogError("gpuMemory::copyMappingData() null dest pointer size=%u\n", m_allocInfo.allocationSize);
++ m_mapRange.pop_back();
+ return;
+ }
- /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;
- void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)
++ memcpy(mr.pData, pSrcData, m_allocInfo.allocationSize);
++ if (!mr.pending)
++ m_mapRange.pop_back();
+ }
+
- assert(pTraceGpu != NULL);
- assert(pReplayGpu != NULL);
- m_gpus[*pTraceGpu] = *pReplayGpu;
++ size_t getMemoryMapSize()
+ {
- XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)
- {
- std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);
- return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;
- }*/
++ return (!m_mapRange.empty()) ? m_mapRange.back().size : 0;
+ }
+
- std::map<XGL_BUFFER, XGL_BUFFER> m_buffers;
- void add_to_map(XGL_BUFFER* pTraceVal, XGL_BUFFER* pReplayVal)
++private:
++ bool m_pendingAlloc;
++ struct MapRange {
++ bool pending;
++ size_t size;
++ size_t offset;
++ void* pData;
++ };
++ std::vector<MapRange> m_mapRange;
++ XGL_MEMORY_ALLOC_INFO m_allocInfo;
++};
++
++typedef struct _imageObj {
++ objMemory imageMem;
++ XGL_IMAGE replayImage;
++ } imageObj;
++
++typedef struct _bufferObj {
++ objMemory bufferMem;
++ XGL_BUFFER replayBuffer;
++ } bufferObj;
++
++typedef struct _gpuMemObj {
++ gpuMemory *pGpuMem;
++ XGL_GPU_MEMORY replayGpuMem;
++ } gpuMemObj;
++
++class xglReplayObjMapper {
++public:
++ xglReplayObjMapper() {}
++ ~xglReplayObjMapper() {}
++
++ bool m_adjustForGPU; // true if replay adjusts behavior based on GPU
++ void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num)
++ {
++ XGL_IMAGE img = static_cast <XGL_IMAGE> (object);
++ std::map<XGL_IMAGE, imageObj>::const_iterator it = m_images.find(img);
++ if (it != m_images.end())
++ {
++ objMemory obj = it->second.imageMem;
++ obj.setCount(num);
++ return;
++ }
++ XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);
++ std::map<XGL_BUFFER, bufferObj>::const_iterator itb = m_buffers.find(buf);
++ if (itb != m_buffers.end())
++ {
++ objMemory obj = itb->second.bufferMem;
++ obj.setCount(num);
++ return;
++ }
++ return;
++ }
++
++ void init_objMemReqs(const XGL_BASE_OBJECT& object, const XGL_MEMORY_REQUIREMENTS *pMemReqs, const unsigned int num)
++ {
++ XGL_IMAGE img = static_cast <XGL_IMAGE> (object);
++ std::map<XGL_IMAGE, imageObj>::const_iterator it = m_images.find(img);
++ if (it != m_images.end())
++ {
++ objMemory obj = it->second.imageMem;
++ obj.setReqs(pMemReqs, num);
++ return;
++ }
++ XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);
++ std::map<XGL_BUFFER, bufferObj>::const_iterator itb = m_buffers.find(buf);
++ if (itb != m_buffers.end())
++ {
++ objMemory obj = itb->second.bufferMem;
++ obj.setReqs(pMemReqs, num);
++ return;
++ }
++ return;
++ }
+
+ void clear_all_map_handles()
+ {
+ m_bufferViews.clear();
+ m_buffers.clear();
+ m_cmdBuffers.clear();
+ m_colorAttachmentViews.clear();
+ m_depthStencilViews.clear();
+ m_descriptorRegions.clear();
+ m_descriptorSetLayouts.clear();
+ m_descriptorSets.clear();
+ m_devices.clear();
+ m_dynamicCbStateObjects.clear();
+ m_dynamicDsStateObjects.clear();
+ m_dynamicRsStateObjects.clear();
+ m_dynamicVpStateObjects.clear();
+ m_events.clear();
+ m_fences.clear();
+ m_framebuffers.clear();
+ m_gpuMemorys.clear();
+ m_imageViews.clear();
+ m_images.clear();
+ m_instances.clear();
+ m_physicalGpus.clear();
+ m_pipelineDeltas.clear();
+ m_pipelines.clear();
+ m_queryPools.clear();
+ m_queueSemaphores.clear();
+ m_queues.clear();
+ m_renderPasss.clear();
+ m_samplers.clear();
+ m_shaders.clear();
+ }
+
+ std::map<XGL_BUFFER_VIEW, XGL_BUFFER_VIEW> m_bufferViews;
+ void add_to_map(XGL_BUFFER_VIEW* pTraceVal, XGL_BUFFER_VIEW* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_bufferViews[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_BUFFER_VIEW& key)
+ {
+ m_bufferViews.erase(key);
+ }
++
+ XGL_BUFFER_VIEW remap(const XGL_BUFFER_VIEW& value)
+ {
+ std::map<XGL_BUFFER_VIEW, XGL_BUFFER_VIEW>::const_iterator q = m_bufferViews.find(value);
+ return (q == m_bufferViews.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
- std::map<XGL_BUFFER, XGL_BUFFER>::const_iterator q = m_buffers.find(value);
- return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second;
++ std::map<XGL_BUFFER, bufferObj> m_buffers;
++ void add_to_map(XGL_BUFFER* pTraceVal, bufferObj* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_buffers[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_BUFFER& key)
+ {
+ m_buffers.erase(key);
+ }
++
+ XGL_BUFFER remap(const XGL_BUFFER& value)
+ {
- std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY> m_gpuMemorys;
- void add_to_map(XGL_GPU_MEMORY* pTraceVal, XGL_GPU_MEMORY* pReplayVal)
++ std::map<XGL_BUFFER, bufferObj>::const_iterator q = m_buffers.find(value);
++ return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second.replayBuffer;
+ }
+
+ std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER> m_cmdBuffers;
+ void add_to_map(XGL_CMD_BUFFER* pTraceVal, XGL_CMD_BUFFER* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_cmdBuffers[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_CMD_BUFFER& key)
+ {
+ m_cmdBuffers.erase(key);
+ }
++
+ XGL_CMD_BUFFER remap(const XGL_CMD_BUFFER& value)
+ {
+ std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER>::const_iterator q = m_cmdBuffers.find(value);
+ return (q == m_cmdBuffers.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW> m_colorAttachmentViews;
+ void add_to_map(XGL_COLOR_ATTACHMENT_VIEW* pTraceVal, XGL_COLOR_ATTACHMENT_VIEW* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_colorAttachmentViews[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_COLOR_ATTACHMENT_VIEW& key)
+ {
+ m_colorAttachmentViews.erase(key);
+ }
++
+ XGL_COLOR_ATTACHMENT_VIEW remap(const XGL_COLOR_ATTACHMENT_VIEW& value)
+ {
+ std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW>::const_iterator q = m_colorAttachmentViews.find(value);
+ return (q == m_colorAttachmentViews.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW> m_depthStencilViews;
+ void add_to_map(XGL_DEPTH_STENCIL_VIEW* pTraceVal, XGL_DEPTH_STENCIL_VIEW* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_depthStencilViews[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DEPTH_STENCIL_VIEW& key)
+ {
+ m_depthStencilViews.erase(key);
+ }
++
+ XGL_DEPTH_STENCIL_VIEW remap(const XGL_DEPTH_STENCIL_VIEW& value)
+ {
+ std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW>::const_iterator q = m_depthStencilViews.find(value);
+ return (q == m_depthStencilViews.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DESCRIPTOR_REGION, XGL_DESCRIPTOR_REGION> m_descriptorRegions;
+ void add_to_map(XGL_DESCRIPTOR_REGION* pTraceVal, XGL_DESCRIPTOR_REGION* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_descriptorRegions[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DESCRIPTOR_REGION& key)
+ {
+ m_descriptorRegions.erase(key);
+ }
++
+ XGL_DESCRIPTOR_REGION remap(const XGL_DESCRIPTOR_REGION& value)
+ {
+ std::map<XGL_DESCRIPTOR_REGION, XGL_DESCRIPTOR_REGION>::const_iterator q = m_descriptorRegions.find(value);
+ return (q == m_descriptorRegions.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DESCRIPTOR_SET_LAYOUT, XGL_DESCRIPTOR_SET_LAYOUT> m_descriptorSetLayouts;
+ void add_to_map(XGL_DESCRIPTOR_SET_LAYOUT* pTraceVal, XGL_DESCRIPTOR_SET_LAYOUT* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_descriptorSetLayouts[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DESCRIPTOR_SET_LAYOUT& key)
+ {
+ m_descriptorSetLayouts.erase(key);
+ }
++
+ XGL_DESCRIPTOR_SET_LAYOUT remap(const XGL_DESCRIPTOR_SET_LAYOUT& value)
+ {
+ std::map<XGL_DESCRIPTOR_SET_LAYOUT, XGL_DESCRIPTOR_SET_LAYOUT>::const_iterator q = m_descriptorSetLayouts.find(value);
+ return (q == m_descriptorSetLayouts.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET> m_descriptorSets;
+ void add_to_map(XGL_DESCRIPTOR_SET* pTraceVal, XGL_DESCRIPTOR_SET* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_descriptorSets[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DESCRIPTOR_SET& key)
+ {
+ m_descriptorSets.erase(key);
+ }
++
+ XGL_DESCRIPTOR_SET remap(const XGL_DESCRIPTOR_SET& value)
+ {
+ std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET>::const_iterator q = m_descriptorSets.find(value);
+ return (q == m_descriptorSets.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DEVICE, XGL_DEVICE> m_devices;
+ void add_to_map(XGL_DEVICE* pTraceVal, XGL_DEVICE* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_devices[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DEVICE& key)
+ {
+ m_devices.erase(key);
+ }
++
+ XGL_DEVICE remap(const XGL_DEVICE& value)
+ {
+ std::map<XGL_DEVICE, XGL_DEVICE>::const_iterator q = m_devices.find(value);
+ return (q == m_devices.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_CB_STATE_OBJECT> m_dynamicCbStateObjects;
+ void add_to_map(XGL_DYNAMIC_CB_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_CB_STATE_OBJECT* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_dynamicCbStateObjects[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DYNAMIC_CB_STATE_OBJECT& key)
+ {
+ m_dynamicCbStateObjects.erase(key);
+ }
++
+ XGL_DYNAMIC_CB_STATE_OBJECT remap(const XGL_DYNAMIC_CB_STATE_OBJECT& value)
+ {
+ std::map<XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_CB_STATE_OBJECT>::const_iterator q = m_dynamicCbStateObjects.find(value);
+ return (q == m_dynamicCbStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_DS_STATE_OBJECT> m_dynamicDsStateObjects;
+ void add_to_map(XGL_DYNAMIC_DS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_DS_STATE_OBJECT* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_dynamicDsStateObjects[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DYNAMIC_DS_STATE_OBJECT& key)
+ {
+ m_dynamicDsStateObjects.erase(key);
+ }
++
+ XGL_DYNAMIC_DS_STATE_OBJECT remap(const XGL_DYNAMIC_DS_STATE_OBJECT& value)
+ {
+ std::map<XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_DS_STATE_OBJECT>::const_iterator q = m_dynamicDsStateObjects.find(value);
+ return (q == m_dynamicDsStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_RS_STATE_OBJECT> m_dynamicRsStateObjects;
+ void add_to_map(XGL_DYNAMIC_RS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_RS_STATE_OBJECT* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_dynamicRsStateObjects[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DYNAMIC_RS_STATE_OBJECT& key)
+ {
+ m_dynamicRsStateObjects.erase(key);
+ }
++
+ XGL_DYNAMIC_RS_STATE_OBJECT remap(const XGL_DYNAMIC_RS_STATE_OBJECT& value)
+ {
+ std::map<XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_RS_STATE_OBJECT>::const_iterator q = m_dynamicRsStateObjects.find(value);
+ return (q == m_dynamicRsStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_VP_STATE_OBJECT> m_dynamicVpStateObjects;
+ void add_to_map(XGL_DYNAMIC_VP_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_VP_STATE_OBJECT* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_dynamicVpStateObjects[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_DYNAMIC_VP_STATE_OBJECT& key)
+ {
+ m_dynamicVpStateObjects.erase(key);
+ }
++
+ XGL_DYNAMIC_VP_STATE_OBJECT remap(const XGL_DYNAMIC_VP_STATE_OBJECT& value)
+ {
+ std::map<XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_VP_STATE_OBJECT>::const_iterator q = m_dynamicVpStateObjects.find(value);
+ return (q == m_dynamicVpStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_EVENT, XGL_EVENT> m_events;
+ void add_to_map(XGL_EVENT* pTraceVal, XGL_EVENT* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_events[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_EVENT& key)
+ {
+ m_events.erase(key);
+ }
++
+ XGL_EVENT remap(const XGL_EVENT& value)
+ {
+ std::map<XGL_EVENT, XGL_EVENT>::const_iterator q = m_events.find(value);
+ return (q == m_events.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_FENCE, XGL_FENCE> m_fences;
+ void add_to_map(XGL_FENCE* pTraceVal, XGL_FENCE* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_fences[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_FENCE& key)
+ {
+ m_fences.erase(key);
+ }
++
+ XGL_FENCE remap(const XGL_FENCE& value)
+ {
+ std::map<XGL_FENCE, XGL_FENCE>::const_iterator q = m_fences.find(value);
+ return (q == m_fences.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER> m_framebuffers;
+ void add_to_map(XGL_FRAMEBUFFER* pTraceVal, XGL_FRAMEBUFFER* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_framebuffers[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_FRAMEBUFFER& key)
+ {
+ m_framebuffers.erase(key);
+ }
++
+ XGL_FRAMEBUFFER remap(const XGL_FRAMEBUFFER& value)
+ {
+ std::map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER>::const_iterator q = m_framebuffers.find(value);
+ return (q == m_framebuffers.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
- std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY>::const_iterator q = m_gpuMemorys.find(value);
- return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second;
++ std::map<XGL_GPU_MEMORY, gpuMemObj> m_gpuMemorys;
++ void add_to_map(XGL_GPU_MEMORY* pTraceVal, gpuMemObj* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_gpuMemorys[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_GPU_MEMORY& key)
+ {
+ m_gpuMemorys.erase(key);
+ }
++
+ XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& value)
+ {
- std::map<XGL_IMAGE, XGL_IMAGE> m_images;
- void add_to_map(XGL_IMAGE* pTraceVal, XGL_IMAGE* pReplayVal)
++ std::map<XGL_GPU_MEMORY, gpuMemObj>::const_iterator q = m_gpuMemorys.find(value);
++ return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second.replayGpuMem;
+ }
+
+ std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW> m_imageViews;
+ void add_to_map(XGL_IMAGE_VIEW* pTraceVal, XGL_IMAGE_VIEW* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_imageViews[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_IMAGE_VIEW& key)
+ {
+ m_imageViews.erase(key);
+ }
++
+ XGL_IMAGE_VIEW remap(const XGL_IMAGE_VIEW& value)
+ {
+ std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW>::const_iterator q = m_imageViews.find(value);
+ return (q == m_imageViews.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
- std::map<XGL_IMAGE, XGL_IMAGE>::const_iterator q = m_images.find(value);
- return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second;
++ std::map<XGL_IMAGE, imageObj> m_images;
++ void add_to_map(XGL_IMAGE* pTraceVal, imageObj* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_images[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_IMAGE& key)
+ {
+ m_images.erase(key);
+ }
++
+ XGL_IMAGE remap(const XGL_IMAGE& value)
+ {
-
++ std::map<XGL_IMAGE, imageObj>::const_iterator q = m_images.find(value);
++ return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second.replayImage;
+ }
+
+ std::map<XGL_INSTANCE, XGL_INSTANCE> m_instances;
+ void add_to_map(XGL_INSTANCE* pTraceVal, XGL_INSTANCE* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_instances[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_INSTANCE& key)
+ {
+ m_instances.erase(key);
+ }
++
+ XGL_INSTANCE remap(const XGL_INSTANCE& value)
+ {
+ std::map<XGL_INSTANCE, XGL_INSTANCE>::const_iterator q = m_instances.find(value);
+ return (q == m_instances.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_physicalGpus;
+ void add_to_map(XGL_PHYSICAL_GPU* pTraceVal, XGL_PHYSICAL_GPU* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_physicalGpus[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_PHYSICAL_GPU& key)
+ {
+ m_physicalGpus.erase(key);
+ }
++
+ XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& value)
+ {
+ std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_physicalGpus.find(value);
+ return (q == m_physicalGpus.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA> m_pipelineDeltas;
+ void add_to_map(XGL_PIPELINE_DELTA* pTraceVal, XGL_PIPELINE_DELTA* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_pipelineDeltas[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_PIPELINE_DELTA& key)
+ {
+ m_pipelineDeltas.erase(key);
+ }
++
+ XGL_PIPELINE_DELTA remap(const XGL_PIPELINE_DELTA& value)
+ {
+ std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA>::const_iterator q = m_pipelineDeltas.find(value);
+ return (q == m_pipelineDeltas.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_PIPELINE, XGL_PIPELINE> m_pipelines;
+ void add_to_map(XGL_PIPELINE* pTraceVal, XGL_PIPELINE* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_pipelines[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_PIPELINE& key)
+ {
+ m_pipelines.erase(key);
+ }
++
+ XGL_PIPELINE remap(const XGL_PIPELINE& value)
+ {
+ std::map<XGL_PIPELINE, XGL_PIPELINE>::const_iterator q = m_pipelines.find(value);
+ return (q == m_pipelines.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_QUERY_POOL, XGL_QUERY_POOL> m_queryPools;
+ void add_to_map(XGL_QUERY_POOL* pTraceVal, XGL_QUERY_POOL* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_queryPools[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_QUERY_POOL& key)
+ {
+ m_queryPools.erase(key);
+ }
++
+ XGL_QUERY_POOL remap(const XGL_QUERY_POOL& value)
+ {
+ std::map<XGL_QUERY_POOL, XGL_QUERY_POOL>::const_iterator q = m_queryPools.find(value);
+ return (q == m_queryPools.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE> m_queueSemaphores;
+ void add_to_map(XGL_QUEUE_SEMAPHORE* pTraceVal, XGL_QUEUE_SEMAPHORE* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_queueSemaphores[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_QUEUE_SEMAPHORE& key)
+ {
+ m_queueSemaphores.erase(key);
+ }
++
+ XGL_QUEUE_SEMAPHORE remap(const XGL_QUEUE_SEMAPHORE& value)
+ {
+ std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE>::const_iterator q = m_queueSemaphores.find(value);
+ return (q == m_queueSemaphores.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_QUEUE, XGL_QUEUE> m_queues;
+ void add_to_map(XGL_QUEUE* pTraceVal, XGL_QUEUE* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_queues[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_QUEUE& key)
+ {
+ m_queues.erase(key);
+ }
++
+ XGL_QUEUE remap(const XGL_QUEUE& value)
+ {
+ std::map<XGL_QUEUE, XGL_QUEUE>::const_iterator q = m_queues.find(value);
+ return (q == m_queues.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_RENDER_PASS, XGL_RENDER_PASS> m_renderPasss;
+ void add_to_map(XGL_RENDER_PASS* pTraceVal, XGL_RENDER_PASS* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_renderPasss[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_RENDER_PASS& key)
+ {
+ m_renderPasss.erase(key);
+ }
++
+ XGL_RENDER_PASS remap(const XGL_RENDER_PASS& value)
+ {
+ std::map<XGL_RENDER_PASS, XGL_RENDER_PASS>::const_iterator q = m_renderPasss.find(value);
+ return (q == m_renderPasss.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_SAMPLER, XGL_SAMPLER> m_samplers;
+ void add_to_map(XGL_SAMPLER* pTraceVal, XGL_SAMPLER* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_samplers[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_SAMPLER& key)
+ {
+ m_samplers.erase(key);
+ }
++
+ XGL_SAMPLER remap(const XGL_SAMPLER& value)
+ {
+ std::map<XGL_SAMPLER, XGL_SAMPLER>::const_iterator q = m_samplers.find(value);
+ return (q == m_samplers.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_SHADER, XGL_SHADER> m_shaders;
+ void add_to_map(XGL_SHADER* pTraceVal, XGL_SHADER* pReplayVal)
+ {
+ assert(pTraceVal != NULL);
+ assert(pReplayVal != NULL);
+ m_shaders[*pTraceVal] = *pReplayVal;
+ }
++
+ void rm_from_map(const XGL_SHADER& key)
+ {
+ m_shaders.erase(key);
+ }
++
+ XGL_SHADER remap(const XGL_SHADER& value)
+ {
+ std::map<XGL_SHADER, XGL_SHADER>::const_iterator q = m_shaders.find(value);
+ return (q == m_shaders.end()) ? XGL_NULL_HANDLE : q->second;
+ }
++
+ XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)
+ {
+ XGL_DYNAMIC_STATE_OBJECT obj;
+ if ((obj = remap(static_cast <XGL_DYNAMIC_VP_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DYNAMIC_RS_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DYNAMIC_CB_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DYNAMIC_DS_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ return XGL_NULL_HANDLE;
+ }
+ void rm_from_map(const XGL_DYNAMIC_STATE_OBJECT& state)
+ {
+ rm_from_map(static_cast <XGL_DYNAMIC_VP_STATE_OBJECT> (state));
+ rm_from_map(static_cast <XGL_DYNAMIC_RS_STATE_OBJECT> (state));
+ rm_from_map(static_cast <XGL_DYNAMIC_CB_STATE_OBJECT> (state));
+ rm_from_map(static_cast <XGL_DYNAMIC_DS_STATE_OBJECT> (state));
+ }
+
+ XGL_OBJECT remap(const XGL_OBJECT& object)
+ {
+ XGL_OBJECT obj;
+ if ((obj = remap(static_cast <XGL_BUFFER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_BUFFER_VIEW> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_IMAGE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_IMAGE_VIEW> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_COLOR_ATTACHMENT_VIEW> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DEPTH_STENCIL_VIEW> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_SHADER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_PIPELINE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_PIPELINE_DELTA> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_SAMPLER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DESCRIPTOR_SET> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DESCRIPTOR_SET_LAYOUT> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DESCRIPTOR_REGION> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DYNAMIC_STATE_OBJECT> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_CMD_BUFFER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_FENCE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_QUEUE_SEMAPHORE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_EVENT> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_QUERY_POOL> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_FRAMEBUFFER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_RENDER_PASS> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ return XGL_NULL_HANDLE;
+ }
+ void rm_from_map(const XGL_OBJECT & objKey)
+ {
+ rm_from_map(static_cast <XGL_BUFFER> (objKey));
+ rm_from_map(static_cast <XGL_BUFFER_VIEW> (objKey));
+ rm_from_map(static_cast <XGL_IMAGE> (objKey));
+ rm_from_map(static_cast <XGL_IMAGE_VIEW> (objKey));
+ rm_from_map(static_cast <XGL_COLOR_ATTACHMENT_VIEW> (objKey));
+ rm_from_map(static_cast <XGL_DEPTH_STENCIL_VIEW> (objKey));
+ rm_from_map(static_cast <XGL_SHADER> (objKey));
+ rm_from_map(static_cast <XGL_PIPELINE> (objKey));
+ rm_from_map(static_cast <XGL_PIPELINE_DELTA> (objKey));
+ rm_from_map(static_cast <XGL_SAMPLER> (objKey));
+ rm_from_map(static_cast <XGL_DESCRIPTOR_SET> (objKey));
+ rm_from_map(static_cast <XGL_DESCRIPTOR_SET_LAYOUT> (objKey));
+ rm_from_map(static_cast <XGL_DESCRIPTOR_REGION> (objKey));
+ rm_from_map(static_cast <XGL_DYNAMIC_STATE_OBJECT> (objKey));
+ rm_from_map(static_cast <XGL_CMD_BUFFER> (objKey));
+ rm_from_map(static_cast <XGL_FENCE> (objKey));
+ rm_from_map(static_cast <XGL_QUEUE_SEMAPHORE> (objKey));
+ rm_from_map(static_cast <XGL_EVENT> (objKey));
+ rm_from_map(static_cast <XGL_QUERY_POOL> (objKey));
+ rm_from_map(static_cast <XGL_FRAMEBUFFER> (objKey));
+ rm_from_map(static_cast <XGL_RENDER_PASS> (objKey));
+ }
+ XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)
+ {
+ XGL_BASE_OBJECT obj;
+ if ((obj = remap(static_cast <XGL_DEVICE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_QUEUE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_GPU_MEMORY> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_OBJECT> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ return XGL_NULL_HANDLE;
+ }
+ };
--- /dev/null
- XGL_GPU_MEMORY local_pMem;
- replayResult = m_xglFuncs.real_xglAllocMemory(m_objMapper.remap(pPacket->device), pPacket->pAllocInfo, &local_pMem);
- if (replayResult == XGL_SUCCESS)
+ /* THIS FILE IS GENERATED. DO NOT EDIT. */
+
+ /*
+ * XGL
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+ #include "glvreplay_xgl_xglreplay.h"
+
+ #include "glvreplay_xgl.h"
+
+ #include "glvreplay_main.h"
+
+ #include <algorithm>
+ #include <queue>
+
+
+ extern "C" {
+ #include "glv_vk_vk_structs.h"
+ #include "glv_vk_vkdbg_structs.h"
+ #include "glv_vk_vkwsix11ext_structs.h"
+ #include "glv_vk_packet_id.h"
+ #include "xgl_enum_string_helper.h"
+ }
+
+ #define APP_NAME "glvreplay_xgl"
+ #define IDI_ICON 101
+
+
+ void xglFuncs::init_funcs(void * handle)
+ {
+ m_libHandle = handle;
+ real_xglCreateInstance = (type_xglCreateInstance)(glv_platform_get_library_entrypoint(handle, "xglCreateInstance"));
+ real_xglDestroyInstance = (type_xglDestroyInstance)(glv_platform_get_library_entrypoint(handle, "xglDestroyInstance"));
+ real_xglEnumerateGpus = (type_xglEnumerateGpus)(glv_platform_get_library_entrypoint(handle, "xglEnumerateGpus"));
+ real_xglGetGpuInfo = (type_xglGetGpuInfo)(glv_platform_get_library_entrypoint(handle, "xglGetGpuInfo"));
+ real_xglGetProcAddr = (type_xglGetProcAddr)(glv_platform_get_library_entrypoint(handle, "xglGetProcAddr"));
+ real_xglCreateDevice = (type_xglCreateDevice)(glv_platform_get_library_entrypoint(handle, "xglCreateDevice"));
+ real_xglDestroyDevice = (type_xglDestroyDevice)(glv_platform_get_library_entrypoint(handle, "xglDestroyDevice"));
+ real_xglGetExtensionSupport = (type_xglGetExtensionSupport)(glv_platform_get_library_entrypoint(handle, "xglGetExtensionSupport"));
+ real_xglEnumerateLayers = (type_xglEnumerateLayers)(glv_platform_get_library_entrypoint(handle, "xglEnumerateLayers"));
+ real_xglGetDeviceQueue = (type_xglGetDeviceQueue)(glv_platform_get_library_entrypoint(handle, "xglGetDeviceQueue"));
+ real_xglQueueSubmit = (type_xglQueueSubmit)(glv_platform_get_library_entrypoint(handle, "xglQueueSubmit"));
+ real_xglQueueSetGlobalMemReferences = (type_xglQueueSetGlobalMemReferences)(glv_platform_get_library_entrypoint(handle, "xglQueueSetGlobalMemReferences"));
+ real_xglQueueWaitIdle = (type_xglQueueWaitIdle)(glv_platform_get_library_entrypoint(handle, "xglQueueWaitIdle"));
+ real_xglDeviceWaitIdle = (type_xglDeviceWaitIdle)(glv_platform_get_library_entrypoint(handle, "xglDeviceWaitIdle"));
+ real_xglAllocMemory = (type_xglAllocMemory)(glv_platform_get_library_entrypoint(handle, "xglAllocMemory"));
+ real_xglFreeMemory = (type_xglFreeMemory)(glv_platform_get_library_entrypoint(handle, "xglFreeMemory"));
+ real_xglSetMemoryPriority = (type_xglSetMemoryPriority)(glv_platform_get_library_entrypoint(handle, "xglSetMemoryPriority"));
+ real_xglMapMemory = (type_xglMapMemory)(glv_platform_get_library_entrypoint(handle, "xglMapMemory"));
+ real_xglUnmapMemory = (type_xglUnmapMemory)(glv_platform_get_library_entrypoint(handle, "xglUnmapMemory"));
+ real_xglPinSystemMemory = (type_xglPinSystemMemory)(glv_platform_get_library_entrypoint(handle, "xglPinSystemMemory"));
+ real_xglGetMultiGpuCompatibility = (type_xglGetMultiGpuCompatibility)(glv_platform_get_library_entrypoint(handle, "xglGetMultiGpuCompatibility"));
+ real_xglOpenSharedMemory = (type_xglOpenSharedMemory)(glv_platform_get_library_entrypoint(handle, "xglOpenSharedMemory"));
+ real_xglOpenSharedQueueSemaphore = (type_xglOpenSharedQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglOpenSharedQueueSemaphore"));
+ real_xglOpenPeerMemory = (type_xglOpenPeerMemory)(glv_platform_get_library_entrypoint(handle, "xglOpenPeerMemory"));
+ real_xglOpenPeerImage = (type_xglOpenPeerImage)(glv_platform_get_library_entrypoint(handle, "xglOpenPeerImage"));
+ real_xglDestroyObject = (type_xglDestroyObject)(glv_platform_get_library_entrypoint(handle, "xglDestroyObject"));
+ real_xglGetObjectInfo = (type_xglGetObjectInfo)(glv_platform_get_library_entrypoint(handle, "xglGetObjectInfo"));
+ real_xglBindObjectMemory = (type_xglBindObjectMemory)(glv_platform_get_library_entrypoint(handle, "xglBindObjectMemory"));
+ real_xglBindObjectMemoryRange = (type_xglBindObjectMemoryRange)(glv_platform_get_library_entrypoint(handle, "xglBindObjectMemoryRange"));
+ real_xglBindImageMemoryRange = (type_xglBindImageMemoryRange)(glv_platform_get_library_entrypoint(handle, "xglBindImageMemoryRange"));
+ real_xglCreateFence = (type_xglCreateFence)(glv_platform_get_library_entrypoint(handle, "xglCreateFence"));
+ real_xglGetFenceStatus = (type_xglGetFenceStatus)(glv_platform_get_library_entrypoint(handle, "xglGetFenceStatus"));
+ real_xglWaitForFences = (type_xglWaitForFences)(glv_platform_get_library_entrypoint(handle, "xglWaitForFences"));
+ real_xglCreateQueueSemaphore = (type_xglCreateQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglCreateQueueSemaphore"));
+ real_xglSignalQueueSemaphore = (type_xglSignalQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglSignalQueueSemaphore"));
+ real_xglWaitQueueSemaphore = (type_xglWaitQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglWaitQueueSemaphore"));
+ real_xglCreateEvent = (type_xglCreateEvent)(glv_platform_get_library_entrypoint(handle, "xglCreateEvent"));
+ real_xglGetEventStatus = (type_xglGetEventStatus)(glv_platform_get_library_entrypoint(handle, "xglGetEventStatus"));
+ real_xglSetEvent = (type_xglSetEvent)(glv_platform_get_library_entrypoint(handle, "xglSetEvent"));
+ real_xglResetEvent = (type_xglResetEvent)(glv_platform_get_library_entrypoint(handle, "xglResetEvent"));
+ real_xglCreateQueryPool = (type_xglCreateQueryPool)(glv_platform_get_library_entrypoint(handle, "xglCreateQueryPool"));
+ real_xglGetQueryPoolResults = (type_xglGetQueryPoolResults)(glv_platform_get_library_entrypoint(handle, "xglGetQueryPoolResults"));
+ real_xglGetFormatInfo = (type_xglGetFormatInfo)(glv_platform_get_library_entrypoint(handle, "xglGetFormatInfo"));
+ real_xglCreateBuffer = (type_xglCreateBuffer)(glv_platform_get_library_entrypoint(handle, "xglCreateBuffer"));
+ real_xglCreateBufferView = (type_xglCreateBufferView)(glv_platform_get_library_entrypoint(handle, "xglCreateBufferView"));
+ real_xglCreateImage = (type_xglCreateImage)(glv_platform_get_library_entrypoint(handle, "xglCreateImage"));
+ real_xglSetFastClearColor = (type_xglSetFastClearColor)(glv_platform_get_library_entrypoint(handle, "xglSetFastClearColor"));
+ real_xglSetFastClearDepth = (type_xglSetFastClearDepth)(glv_platform_get_library_entrypoint(handle, "xglSetFastClearDepth"));
+ real_xglGetImageSubresourceInfo = (type_xglGetImageSubresourceInfo)(glv_platform_get_library_entrypoint(handle, "xglGetImageSubresourceInfo"));
+ real_xglCreateImageView = (type_xglCreateImageView)(glv_platform_get_library_entrypoint(handle, "xglCreateImageView"));
+ real_xglCreateColorAttachmentView = (type_xglCreateColorAttachmentView)(glv_platform_get_library_entrypoint(handle, "xglCreateColorAttachmentView"));
+ real_xglCreateDepthStencilView = (type_xglCreateDepthStencilView)(glv_platform_get_library_entrypoint(handle, "xglCreateDepthStencilView"));
+ real_xglCreateShader = (type_xglCreateShader)(glv_platform_get_library_entrypoint(handle, "xglCreateShader"));
+ real_xglCreateGraphicsPipeline = (type_xglCreateGraphicsPipeline)(glv_platform_get_library_entrypoint(handle, "xglCreateGraphicsPipeline"));
+ real_xglCreateComputePipeline = (type_xglCreateComputePipeline)(glv_platform_get_library_entrypoint(handle, "xglCreateComputePipeline"));
+ real_xglStorePipeline = (type_xglStorePipeline)(glv_platform_get_library_entrypoint(handle, "xglStorePipeline"));
+ real_xglLoadPipeline = (type_xglLoadPipeline)(glv_platform_get_library_entrypoint(handle, "xglLoadPipeline"));
+ real_xglCreatePipelineDelta = (type_xglCreatePipelineDelta)(glv_platform_get_library_entrypoint(handle, "xglCreatePipelineDelta"));
+ real_xglCreateSampler = (type_xglCreateSampler)(glv_platform_get_library_entrypoint(handle, "xglCreateSampler"));
+ real_xglCreateDescriptorSetLayout = (type_xglCreateDescriptorSetLayout)(glv_platform_get_library_entrypoint(handle, "xglCreateDescriptorSetLayout"));
+ real_xglBeginDescriptorRegionUpdate = (type_xglBeginDescriptorRegionUpdate)(glv_platform_get_library_entrypoint(handle, "xglBeginDescriptorRegionUpdate"));
+ real_xglEndDescriptorRegionUpdate = (type_xglEndDescriptorRegionUpdate)(glv_platform_get_library_entrypoint(handle, "xglEndDescriptorRegionUpdate"));
+ real_xglCreateDescriptorRegion = (type_xglCreateDescriptorRegion)(glv_platform_get_library_entrypoint(handle, "xglCreateDescriptorRegion"));
+ real_xglClearDescriptorRegion = (type_xglClearDescriptorRegion)(glv_platform_get_library_entrypoint(handle, "xglClearDescriptorRegion"));
+ real_xglAllocDescriptorSets = (type_xglAllocDescriptorSets)(glv_platform_get_library_entrypoint(handle, "xglAllocDescriptorSets"));
+ real_xglClearDescriptorSets = (type_xglClearDescriptorSets)(glv_platform_get_library_entrypoint(handle, "xglClearDescriptorSets"));
+ real_xglUpdateDescriptors = (type_xglUpdateDescriptors)(glv_platform_get_library_entrypoint(handle, "xglUpdateDescriptors"));
+ real_xglCreateDynamicViewportState = (type_xglCreateDynamicViewportState)(glv_platform_get_library_entrypoint(handle, "xglCreateDynamicViewportState"));
+ real_xglCreateDynamicRasterState = (type_xglCreateDynamicRasterState)(glv_platform_get_library_entrypoint(handle, "xglCreateDynamicRasterState"));
+ real_xglCreateDynamicColorBlendState = (type_xglCreateDynamicColorBlendState)(glv_platform_get_library_entrypoint(handle, "xglCreateDynamicColorBlendState"));
+ real_xglCreateDynamicDepthStencilState = (type_xglCreateDynamicDepthStencilState)(glv_platform_get_library_entrypoint(handle, "xglCreateDynamicDepthStencilState"));
+ real_xglCreateCommandBuffer = (type_xglCreateCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglCreateCommandBuffer"));
+ real_xglBeginCommandBuffer = (type_xglBeginCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglBeginCommandBuffer"));
+ real_xglEndCommandBuffer = (type_xglEndCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglEndCommandBuffer"));
+ real_xglResetCommandBuffer = (type_xglResetCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglResetCommandBuffer"));
+ real_xglCmdBindPipeline = (type_xglCmdBindPipeline)(glv_platform_get_library_entrypoint(handle, "xglCmdBindPipeline"));
+ real_xglCmdBindPipelineDelta = (type_xglCmdBindPipelineDelta)(glv_platform_get_library_entrypoint(handle, "xglCmdBindPipelineDelta"));
+ real_xglCmdBindDynamicStateObject = (type_xglCmdBindDynamicStateObject)(glv_platform_get_library_entrypoint(handle, "xglCmdBindDynamicStateObject"));
+ real_xglCmdBindDescriptorSet = (type_xglCmdBindDescriptorSet)(glv_platform_get_library_entrypoint(handle, "xglCmdBindDescriptorSet"));
+ real_xglCmdBindVertexBuffer = (type_xglCmdBindVertexBuffer)(glv_platform_get_library_entrypoint(handle, "xglCmdBindVertexBuffer"));
+ real_xglCmdBindIndexBuffer = (type_xglCmdBindIndexBuffer)(glv_platform_get_library_entrypoint(handle, "xglCmdBindIndexBuffer"));
+ real_xglCmdDraw = (type_xglCmdDraw)(glv_platform_get_library_entrypoint(handle, "xglCmdDraw"));
+ real_xglCmdDrawIndexed = (type_xglCmdDrawIndexed)(glv_platform_get_library_entrypoint(handle, "xglCmdDrawIndexed"));
+ real_xglCmdDrawIndirect = (type_xglCmdDrawIndirect)(glv_platform_get_library_entrypoint(handle, "xglCmdDrawIndirect"));
+ real_xglCmdDrawIndexedIndirect = (type_xglCmdDrawIndexedIndirect)(glv_platform_get_library_entrypoint(handle, "xglCmdDrawIndexedIndirect"));
+ real_xglCmdDispatch = (type_xglCmdDispatch)(glv_platform_get_library_entrypoint(handle, "xglCmdDispatch"));
+ real_xglCmdDispatchIndirect = (type_xglCmdDispatchIndirect)(glv_platform_get_library_entrypoint(handle, "xglCmdDispatchIndirect"));
+ real_xglCmdCopyBuffer = (type_xglCmdCopyBuffer)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyBuffer"));
+ real_xglCmdCopyImage = (type_xglCmdCopyImage)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyImage"));
+ real_xglCmdCopyBufferToImage = (type_xglCmdCopyBufferToImage)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyBufferToImage"));
+ real_xglCmdCopyImageToBuffer = (type_xglCmdCopyImageToBuffer)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyImageToBuffer"));
+ real_xglCmdCloneImageData = (type_xglCmdCloneImageData)(glv_platform_get_library_entrypoint(handle, "xglCmdCloneImageData"));
+ real_xglCmdUpdateBuffer = (type_xglCmdUpdateBuffer)(glv_platform_get_library_entrypoint(handle, "xglCmdUpdateBuffer"));
+ real_xglCmdFillBuffer = (type_xglCmdFillBuffer)(glv_platform_get_library_entrypoint(handle, "xglCmdFillBuffer"));
+ real_xglCmdClearColorImage = (type_xglCmdClearColorImage)(glv_platform_get_library_entrypoint(handle, "xglCmdClearColorImage"));
+ real_xglCmdClearColorImageRaw = (type_xglCmdClearColorImageRaw)(glv_platform_get_library_entrypoint(handle, "xglCmdClearColorImageRaw"));
+ real_xglCmdClearDepthStencil = (type_xglCmdClearDepthStencil)(glv_platform_get_library_entrypoint(handle, "xglCmdClearDepthStencil"));
+ real_xglCmdResolveImage = (type_xglCmdResolveImage)(glv_platform_get_library_entrypoint(handle, "xglCmdResolveImage"));
+ real_xglCmdSetEvent = (type_xglCmdSetEvent)(glv_platform_get_library_entrypoint(handle, "xglCmdSetEvent"));
+ real_xglCmdResetEvent = (type_xglCmdResetEvent)(glv_platform_get_library_entrypoint(handle, "xglCmdResetEvent"));
+ real_xglCmdWaitEvents = (type_xglCmdWaitEvents)(glv_platform_get_library_entrypoint(handle, "xglCmdWaitEvents"));
+ real_xglCmdPipelineBarrier = (type_xglCmdPipelineBarrier)(glv_platform_get_library_entrypoint(handle, "xglCmdPipelineBarrier"));
+ real_xglCmdBeginQuery = (type_xglCmdBeginQuery)(glv_platform_get_library_entrypoint(handle, "xglCmdBeginQuery"));
+ real_xglCmdEndQuery = (type_xglCmdEndQuery)(glv_platform_get_library_entrypoint(handle, "xglCmdEndQuery"));
+ real_xglCmdResetQueryPool = (type_xglCmdResetQueryPool)(glv_platform_get_library_entrypoint(handle, "xglCmdResetQueryPool"));
+ real_xglCmdWriteTimestamp = (type_xglCmdWriteTimestamp)(glv_platform_get_library_entrypoint(handle, "xglCmdWriteTimestamp"));
+ real_xglCmdInitAtomicCounters = (type_xglCmdInitAtomicCounters)(glv_platform_get_library_entrypoint(handle, "xglCmdInitAtomicCounters"));
+ real_xglCmdLoadAtomicCounters = (type_xglCmdLoadAtomicCounters)(glv_platform_get_library_entrypoint(handle, "xglCmdLoadAtomicCounters"));
+ real_xglCmdSaveAtomicCounters = (type_xglCmdSaveAtomicCounters)(glv_platform_get_library_entrypoint(handle, "xglCmdSaveAtomicCounters"));
+ real_xglCreateFramebuffer = (type_xglCreateFramebuffer)(glv_platform_get_library_entrypoint(handle, "xglCreateFramebuffer"));
+ real_xglCreateRenderPass = (type_xglCreateRenderPass)(glv_platform_get_library_entrypoint(handle, "xglCreateRenderPass"));
+ real_xglCmdBeginRenderPass = (type_xglCmdBeginRenderPass)(glv_platform_get_library_entrypoint(handle, "xglCmdBeginRenderPass"));
+ real_xglCmdEndRenderPass = (type_xglCmdEndRenderPass)(glv_platform_get_library_entrypoint(handle, "xglCmdEndRenderPass"));
+ real_xglDbgSetValidationLevel = (type_xglDbgSetValidationLevel)(glv_platform_get_library_entrypoint(handle, "xglDbgSetValidationLevel"));
+ real_xglDbgRegisterMsgCallback = (type_xglDbgRegisterMsgCallback)(glv_platform_get_library_entrypoint(handle, "xglDbgRegisterMsgCallback"));
+ real_xglDbgUnregisterMsgCallback = (type_xglDbgUnregisterMsgCallback)(glv_platform_get_library_entrypoint(handle, "xglDbgUnregisterMsgCallback"));
+ real_xglDbgSetMessageFilter = (type_xglDbgSetMessageFilter)(glv_platform_get_library_entrypoint(handle, "xglDbgSetMessageFilter"));
+ real_xglDbgSetObjectTag = (type_xglDbgSetObjectTag)(glv_platform_get_library_entrypoint(handle, "xglDbgSetObjectTag"));
+ real_xglDbgSetGlobalOption = (type_xglDbgSetGlobalOption)(glv_platform_get_library_entrypoint(handle, "xglDbgSetGlobalOption"));
+ real_xglDbgSetDeviceOption = (type_xglDbgSetDeviceOption)(glv_platform_get_library_entrypoint(handle, "xglDbgSetDeviceOption"));
+ real_xglCmdDbgMarkerBegin = (type_xglCmdDbgMarkerBegin)(glv_platform_get_library_entrypoint(handle, "xglCmdDbgMarkerBegin"));
+ real_xglCmdDbgMarkerEnd = (type_xglCmdDbgMarkerEnd)(glv_platform_get_library_entrypoint(handle, "xglCmdDbgMarkerEnd"));
+ real_xglWsiX11AssociateConnection = (type_xglWsiX11AssociateConnection)(glv_platform_get_library_entrypoint(handle, "xglWsiX11AssociateConnection"));
+ real_xglWsiX11GetMSC = (type_xglWsiX11GetMSC)(glv_platform_get_library_entrypoint(handle, "xglWsiX11GetMSC"));
+ real_xglWsiX11CreatePresentableImage = (type_xglWsiX11CreatePresentableImage)(glv_platform_get_library_entrypoint(handle, "xglWsiX11CreatePresentableImage"));
+ real_xglWsiX11QueuePresent = (type_xglWsiX11QueuePresent)(glv_platform_get_library_entrypoint(handle, "xglWsiX11QueuePresent"));
+ }
+ glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)
+ {
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ switch (packet->packet_id)
+ {
+ case GLV_TPI_XGL_xglApiVersion:
+ break; // nothing to replay on the version packet
+ case GLV_TPI_XGL_xglCreateInstance:
+ {
+ struct_xglCreateInstance* pPacket = (struct_xglCreateInstance*)(packet->pBody);
+ XGL_INSTANCE local_pInstance;
+ replayResult = m_xglFuncs.real_xglCreateInstance(pPacket->pAppInfo, pPacket->pAllocCb, &local_pInstance);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pInstance, &local_pInstance);
+ }
+ CHECK_RETURN_VALUE(xglCreateInstance);
+ break;
+ }
+ case GLV_TPI_XGL_xglDestroyInstance:
+ {
+ struct_xglDestroyInstance* pPacket = (struct_xglDestroyInstance*)(packet->pBody);
+ xglDbgUnregisterMsgCallback(g_fpDbgMsgCallback);
+ replayResult = m_xglFuncs.real_xglDestroyInstance(m_objMapper.remap(pPacket->instance));
+ if (replayResult == XGL_SUCCESS)
+ {
+ // TODO need to handle multiple instances and only clearing maps within an instance.
+ // TODO this only works with a single instance used at any given time.
+ m_objMapper.clear_all_map_handles();
+ }
+ CHECK_RETURN_VALUE(xglDestroyInstance);
+ break;
+ }
+ case GLV_TPI_XGL_xglEnumerateGpus:
+ {
+ struct_xglEnumerateGpus* pPacket = (struct_xglEnumerateGpus*)(packet->pBody);
+ returnValue = manually_handle_xglEnumerateGpus(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetGpuInfo:
+ {
+ struct_xglGetGpuInfo* pPacket = (struct_xglGetGpuInfo*)(packet->pBody);
+ returnValue = manually_handle_xglGetGpuInfo(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetProcAddr:
+ {
+ struct_xglGetProcAddr* pPacket = (struct_xglGetProcAddr*)(packet->pBody);
+ m_xglFuncs.real_xglGetProcAddr(m_objMapper.remap(pPacket->gpu), pPacket->pName);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDevice:
+ {
+ struct_xglCreateDevice* pPacket = (struct_xglCreateDevice*)(packet->pBody);
+ returnValue = manually_handle_xglCreateDevice(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglDestroyDevice:
+ {
+ struct_xglDestroyDevice* pPacket = (struct_xglDestroyDevice*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglDestroyDevice(m_objMapper.remap(pPacket->device));
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_pCBDump = NULL;
+ m_pDSDump = NULL;
+ m_pGlvSnapshotPrint = NULL;
+ m_objMapper.rm_from_map(pPacket->device);
+ m_display->m_initedXGL = false;
+ }
+ CHECK_RETURN_VALUE(xglDestroyDevice);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetExtensionSupport:
+ {
+ struct_xglGetExtensionSupport* pPacket = (struct_xglGetExtensionSupport*)(packet->pBody);
+ returnValue = manually_handle_xglGetExtensionSupport(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglEnumerateLayers:
+ {
+ struct_xglEnumerateLayers* pPacket = (struct_xglEnumerateLayers*)(packet->pBody);
+ char **bufptr = GLV_NEW_ARRAY(char *, pPacket->maxLayerCount);
+ char **ptrLayers = (pPacket->pOutLayers == NULL) ? bufptr : (char **) pPacket->pOutLayers;
+ for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)
+ bufptr[i] = GLV_NEW_ARRAY(char, pPacket->maxStringSize);
+ replayResult = m_xglFuncs.real_xglEnumerateLayers(m_objMapper.remap(pPacket->gpu), pPacket->maxLayerCount, pPacket->maxStringSize, pPacket->pOutLayerCount, ptrLayers, pPacket->pReserved);
+ for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)
+ GLV_DELETE(bufptr[i]);
+ CHECK_RETURN_VALUE(xglEnumerateLayers);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetDeviceQueue:
+ {
+ struct_xglGetDeviceQueue* pPacket = (struct_xglGetDeviceQueue*)(packet->pBody);
+ XGL_QUEUE local_pQueue;
+ replayResult = m_xglFuncs.real_xglGetDeviceQueue(m_objMapper.remap(pPacket->device), pPacket->queueType, pPacket->queueIndex, &local_pQueue);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pQueue, &local_pQueue);
+ }
+ CHECK_RETURN_VALUE(xglGetDeviceQueue);
+ break;
+ }
+ case GLV_TPI_XGL_xglQueueSubmit:
+ {
+ struct_xglQueueSubmit* pPacket = (struct_xglQueueSubmit*)(packet->pBody);
+ returnValue = manually_handle_xglQueueSubmit(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
+ {
+ struct_xglQueueSetGlobalMemReferences* pPacket = (struct_xglQueueSetGlobalMemReferences*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglQueueSetGlobalMemReferences(m_objMapper.remap(pPacket->queue), pPacket->memRefCount, pPacket->pMemRefs);
+ CHECK_RETURN_VALUE(xglQueueSetGlobalMemReferences);
+ break;
+ }
+ case GLV_TPI_XGL_xglQueueWaitIdle:
+ {
+ struct_xglQueueWaitIdle* pPacket = (struct_xglQueueWaitIdle*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglQueueWaitIdle(m_objMapper.remap(pPacket->queue));
+ CHECK_RETURN_VALUE(xglQueueWaitIdle);
+ break;
+ }
+ case GLV_TPI_XGL_xglDeviceWaitIdle:
+ {
+ struct_xglDeviceWaitIdle* pPacket = (struct_xglDeviceWaitIdle*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglDeviceWaitIdle(m_objMapper.remap(pPacket->device));
+ CHECK_RETURN_VALUE(xglDeviceWaitIdle);
+ break;
+ }
+ case GLV_TPI_XGL_xglAllocMemory:
+ {
+ struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(packet->pBody);
- m_objMapper.add_to_map(pPacket->pMem, &local_pMem);
- m_objMapper.add_entry_to_mapData(local_pMem, pPacket->pAllocInfo->allocationSize);
++ gpuMemObj local_mem;
++ if (!m_objMapper.m_adjustForGPU)
++ replayResult = m_xglFuncs.real_xglAllocMemory(m_objMapper.remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);
++ if (replayResult == XGL_SUCCESS || m_objMapper.m_adjustForGPU)
+ {
- XGL_GPU_MEMORY local_pMem;
- replayResult = m_xglFuncs.real_xglPinSystemMemory(m_objMapper.remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_pMem);
++ local_mem.pGpuMem = new (gpuMemory);
++ if (local_mem.pGpuMem)
++ local_mem.pGpuMem->setAllocInfo(pPacket->pAllocInfo, m_objMapper.m_adjustForGPU);
++ m_objMapper.add_to_map(pPacket->pMem, &local_mem);
+ }
+ CHECK_RETURN_VALUE(xglAllocMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglFreeMemory:
+ {
+ struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(packet->pBody);
+ returnValue = manually_handle_xglFreeMemory(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglSetMemoryPriority:
+ {
+ struct_xglSetMemoryPriority* pPacket = (struct_xglSetMemoryPriority*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglSetMemoryPriority(m_objMapper.remap(pPacket->mem), pPacket->priority);
+ CHECK_RETURN_VALUE(xglSetMemoryPriority);
+ break;
+ }
+ case GLV_TPI_XGL_xglMapMemory:
+ {
+ struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(packet->pBody);
+ returnValue = manually_handle_xglMapMemory(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglUnmapMemory:
+ {
+ struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(packet->pBody);
+ returnValue = manually_handle_xglUnmapMemory(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglPinSystemMemory:
+ {
+ struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(packet->pBody);
- {
- m_objMapper.add_to_map(pPacket->pMem, &local_pMem);
- }
++ gpuMemObj local_mem;
++ /* TODO do we need to skip (make pending) this call for m_adjustForGPU */
++ replayResult = m_xglFuncs.real_xglPinSystemMemory(m_objMapper.remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);
+ if (replayResult == XGL_SUCCESS)
- XGL_BUFFER local_pBuffer;
- replayResult = m_xglFuncs.real_xglCreateBuffer(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pBuffer);
++ m_objMapper.add_to_map(pPacket->pMem, &local_mem);
+ CHECK_RETURN_VALUE(xglPinSystemMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
+ {
+ struct_xglGetMultiGpuCompatibility* pPacket = (struct_xglGetMultiGpuCompatibility*)(packet->pBody);
+ returnValue = manually_handle_xglGetMultiGpuCompatibility(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenSharedMemory:
+ {
+ struct_xglOpenSharedMemory* pPacket = (struct_xglOpenSharedMemory*)(packet->pBody);
+ XGL_DEVICE handle;
+ XGL_GPU_MEMORY local_pMem;
+ handle = m_objMapper.remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenSharedMemory(handle, pPacket->pOpenInfo, &local_pMem);
+ CHECK_RETURN_VALUE(xglOpenSharedMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
+ {
+ struct_xglOpenSharedQueueSemaphore* pPacket = (struct_xglOpenSharedQueueSemaphore*)(packet->pBody);
+ XGL_DEVICE handle;
+ XGL_QUEUE_SEMAPHORE local_pSemaphore;
+ handle = m_objMapper.remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenSharedQueueSemaphore(handle, pPacket->pOpenInfo, &local_pSemaphore);
+ CHECK_RETURN_VALUE(xglOpenSharedQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenPeerMemory:
+ {
+ struct_xglOpenPeerMemory* pPacket = (struct_xglOpenPeerMemory*)(packet->pBody);
+ XGL_DEVICE handle;
+ XGL_GPU_MEMORY local_pMem;
+ handle = m_objMapper.remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenPeerMemory(handle, pPacket->pOpenInfo, &local_pMem);
+ CHECK_RETURN_VALUE(xglOpenPeerMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenPeerImage:
+ {
+ struct_xglOpenPeerImage* pPacket = (struct_xglOpenPeerImage*)(packet->pBody);
+ XGL_DEVICE handle;
+ XGL_GPU_MEMORY local_pMem;
+ XGL_IMAGE local_pImage;
+ handle = m_objMapper.remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenPeerImage(handle, pPacket->pOpenInfo, &local_pImage, &local_pMem);
+ CHECK_RETURN_VALUE(xglOpenPeerImage);
+ break;
+ }
+ case GLV_TPI_XGL_xglDestroyObject:
+ {
+ struct_xglDestroyObject* pPacket = (struct_xglDestroyObject*)(packet->pBody);
+ returnValue = manually_handle_xglDestroyObject(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetObjectInfo:
+ {
+ struct_xglGetObjectInfo* pPacket = (struct_xglGetObjectInfo*)(packet->pBody);
+ returnValue = manually_handle_xglGetObjectInfo(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglBindObjectMemory:
+ {
+ struct_xglBindObjectMemory* pPacket = (struct_xglBindObjectMemory*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglBindObjectMemory(m_objMapper.remap(pPacket->object), pPacket->allocationIdx, m_objMapper.remap(pPacket->mem), pPacket->offset);
+ CHECK_RETURN_VALUE(xglBindObjectMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglBindObjectMemoryRange:
+ {
+ struct_xglBindObjectMemoryRange* pPacket = (struct_xglBindObjectMemoryRange*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglBindObjectMemoryRange(m_objMapper.remap(pPacket->object), pPacket->allocationIdx, pPacket->rangeOffset, pPacket->rangeSize, m_objMapper.remap(pPacket->mem), pPacket->memOffset);
+ CHECK_RETURN_VALUE(xglBindObjectMemoryRange);
+ break;
+ }
+ case GLV_TPI_XGL_xglBindImageMemoryRange:
+ {
+ struct_xglBindImageMemoryRange* pPacket = (struct_xglBindImageMemoryRange*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglBindImageMemoryRange(m_objMapper.remap(pPacket->image), pPacket->allocationIdx, pPacket->bindInfo, m_objMapper.remap(pPacket->mem), pPacket->memOffset);
+ CHECK_RETURN_VALUE(xglBindImageMemoryRange);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateFence:
+ {
+ struct_xglCreateFence* pPacket = (struct_xglCreateFence*)(packet->pBody);
+ XGL_FENCE local_pFence;
+ replayResult = m_xglFuncs.real_xglCreateFence(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pFence);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pFence, &local_pFence);
+ }
+ CHECK_RETURN_VALUE(xglCreateFence);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetFenceStatus:
+ {
+ struct_xglGetFenceStatus* pPacket = (struct_xglGetFenceStatus*)(packet->pBody);
+ do {
+ replayResult = m_xglFuncs.real_xglGetFenceStatus(m_objMapper.remap(pPacket->fence));
+ } while (replayResult != pPacket->result && pPacket->result == XGL_SUCCESS);
+ if (pPacket->result != XGL_NOT_READY || replayResult != XGL_SUCCESS)
+ CHECK_RETURN_VALUE(xglGetFenceStatus);
+ break;
+ }
+ case GLV_TPI_XGL_xglWaitForFences:
+ {
+ struct_xglWaitForFences* pPacket = (struct_xglWaitForFences*)(packet->pBody);
+ returnValue = manually_handle_xglWaitForFences(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateQueueSemaphore:
+ {
+ struct_xglCreateQueueSemaphore* pPacket = (struct_xglCreateQueueSemaphore*)(packet->pBody);
+ XGL_QUEUE_SEMAPHORE local_pSemaphore;
+ replayResult = m_xglFuncs.real_xglCreateQueueSemaphore(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pSemaphore);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pSemaphore, &local_pSemaphore);
+ }
+ CHECK_RETURN_VALUE(xglCreateQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglSignalQueueSemaphore:
+ {
+ struct_xglSignalQueueSemaphore* pPacket = (struct_xglSignalQueueSemaphore*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglSignalQueueSemaphore(m_objMapper.remap(pPacket->queue), m_objMapper.remap(pPacket->semaphore));
+ CHECK_RETURN_VALUE(xglSignalQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglWaitQueueSemaphore:
+ {
+ struct_xglWaitQueueSemaphore* pPacket = (struct_xglWaitQueueSemaphore*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglWaitQueueSemaphore(m_objMapper.remap(pPacket->queue), m_objMapper.remap(pPacket->semaphore));
+ CHECK_RETURN_VALUE(xglWaitQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateEvent:
+ {
+ struct_xglCreateEvent* pPacket = (struct_xglCreateEvent*)(packet->pBody);
+ XGL_EVENT local_pEvent;
+ replayResult = m_xglFuncs.real_xglCreateEvent(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pEvent);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pEvent, &local_pEvent);
+ }
+ CHECK_RETURN_VALUE(xglCreateEvent);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetEventStatus:
+ {
+ struct_xglGetEventStatus* pPacket = (struct_xglGetEventStatus*)(packet->pBody);
+ do {
+ replayResult = m_xglFuncs.real_xglGetEventStatus(m_objMapper.remap(pPacket->event));
+ } while ((pPacket->result == XGL_EVENT_SET || pPacket->result == XGL_EVENT_RESET) && replayResult != pPacket->result);
+ if (pPacket->result != XGL_NOT_READY || replayResult != XGL_SUCCESS)
+ CHECK_RETURN_VALUE(xglGetEventStatus);
+ break;
+ }
+ case GLV_TPI_XGL_xglSetEvent:
+ {
+ struct_xglSetEvent* pPacket = (struct_xglSetEvent*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglSetEvent(m_objMapper.remap(pPacket->event));
+ CHECK_RETURN_VALUE(xglSetEvent);
+ break;
+ }
+ case GLV_TPI_XGL_xglResetEvent:
+ {
+ struct_xglResetEvent* pPacket = (struct_xglResetEvent*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglResetEvent(m_objMapper.remap(pPacket->event));
+ CHECK_RETURN_VALUE(xglResetEvent);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateQueryPool:
+ {
+ struct_xglCreateQueryPool* pPacket = (struct_xglCreateQueryPool*)(packet->pBody);
+ XGL_QUERY_POOL local_pQueryPool;
+ replayResult = m_xglFuncs.real_xglCreateQueryPool(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pQueryPool);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pQueryPool, &local_pQueryPool);
+ }
+ CHECK_RETURN_VALUE(xglCreateQueryPool);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetQueryPoolResults:
+ {
+ struct_xglGetQueryPoolResults* pPacket = (struct_xglGetQueryPoolResults*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglGetQueryPoolResults(m_objMapper.remap(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount, pPacket->pDataSize, pPacket->pData);
+ CHECK_RETURN_VALUE(xglGetQueryPoolResults);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetFormatInfo:
+ {
+ struct_xglGetFormatInfo* pPacket = (struct_xglGetFormatInfo*)(packet->pBody);
+ returnValue = manually_handle_xglGetFormatInfo(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateBuffer:
+ {
+ struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(packet->pBody);
- m_objMapper.add_to_map(pPacket->pBuffer, &local_pBuffer);
++ bufferObj local_bufferObj;
++ replayResult = m_xglFuncs.real_xglCreateBuffer(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);
+ if (replayResult == XGL_SUCCESS)
+ {
- XGL_IMAGE local_pImage;
- replayResult = m_xglFuncs.real_xglCreateImage(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pImage);
++ m_objMapper.add_to_map(pPacket->pBuffer, &local_bufferObj);
+ }
+ CHECK_RETURN_VALUE(xglCreateBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateBufferView:
+ {
+ struct_xglCreateBufferView* pPacket = (struct_xglCreateBufferView*)(packet->pBody);
+ XGL_BUFFER_VIEW_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_BUFFER_VIEW_CREATE_INFO));
+ createInfo.buffer = m_objMapper.remap(pPacket->pCreateInfo->buffer);
+ XGL_BUFFER_VIEW local_pView;
+ replayResult = m_xglFuncs.real_xglCreateBufferView(m_objMapper.remap(pPacket->device), &createInfo, &local_pView);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pView, &local_pView);
+ }
+ CHECK_RETURN_VALUE(xglCreateBufferView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateImage:
+ {
+ struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(packet->pBody);
- m_objMapper.add_to_map(pPacket->pImage, &local_pImage);
++ imageObj local_imageObj;
++ replayResult = m_xglFuncs.real_xglCreateImage(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);
+ if (replayResult == XGL_SUCCESS)
+ {
++ m_objMapper.add_to_map(pPacket->pImage, &local_imageObj);
+ }
+ CHECK_RETURN_VALUE(xglCreateImage);
+ break;
+ }
+ case GLV_TPI_XGL_xglSetFastClearColor:
+ {
+ struct_xglSetFastClearColor* pPacket = (struct_xglSetFastClearColor*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglSetFastClearColor(m_objMapper.remap(pPacket->image), pPacket->color);
+ CHECK_RETURN_VALUE(xglSetFastClearColor);
+ break;
+ }
+ case GLV_TPI_XGL_xglSetFastClearDepth:
+ {
+ struct_xglSetFastClearDepth* pPacket = (struct_xglSetFastClearDepth*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglSetFastClearDepth(m_objMapper.remap(pPacket->image), pPacket->depth);
+ CHECK_RETURN_VALUE(xglSetFastClearDepth);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetImageSubresourceInfo:
+ {
+ struct_xglGetImageSubresourceInfo* pPacket = (struct_xglGetImageSubresourceInfo*)(packet->pBody);
+ returnValue = manually_handle_xglGetImageSubresourceInfo(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateImageView:
+ {
+ struct_xglCreateImageView* pPacket = (struct_xglCreateImageView*)(packet->pBody);
+ XGL_IMAGE_VIEW_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_IMAGE_VIEW_CREATE_INFO));
+ createInfo.image = m_objMapper.remap(pPacket->pCreateInfo->image);
+ XGL_IMAGE_VIEW local_pView;
+ replayResult = m_xglFuncs.real_xglCreateImageView(m_objMapper.remap(pPacket->device), &createInfo, &local_pView);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pView, &local_pView);
+ }
+ CHECK_RETURN_VALUE(xglCreateImageView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateColorAttachmentView:
+ {
+ struct_xglCreateColorAttachmentView* pPacket = (struct_xglCreateColorAttachmentView*)(packet->pBody);
+ XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO));
+ createInfo.image = m_objMapper.remap(pPacket->pCreateInfo->image);
+ XGL_COLOR_ATTACHMENT_VIEW local_pView;
+ replayResult = m_xglFuncs.real_xglCreateColorAttachmentView(m_objMapper.remap(pPacket->device), &createInfo, &local_pView);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pView, &local_pView);
+ }
+ CHECK_RETURN_VALUE(xglCreateColorAttachmentView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDepthStencilView:
+ {
+ struct_xglCreateDepthStencilView* pPacket = (struct_xglCreateDepthStencilView*)(packet->pBody);
+ XGL_DEPTH_STENCIL_VIEW_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO));
+ createInfo.image = m_objMapper.remap(pPacket->pCreateInfo->image);
+ XGL_DEPTH_STENCIL_VIEW local_pView;
+ replayResult = m_xglFuncs.real_xglCreateDepthStencilView(m_objMapper.remap(pPacket->device), &createInfo, &local_pView);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pView, &local_pView);
+ }
+ CHECK_RETURN_VALUE(xglCreateDepthStencilView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateShader:
+ {
+ struct_xglCreateShader* pPacket = (struct_xglCreateShader*)(packet->pBody);
+ XGL_SHADER local_pShader;
+ replayResult = m_xglFuncs.real_xglCreateShader(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pShader);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pShader, &local_pShader);
+ }
+ CHECK_RETURN_VALUE(xglCreateShader);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateGraphicsPipeline:
+ {
+ struct_xglCreateGraphicsPipeline* pPacket = (struct_xglCreateGraphicsPipeline*)(packet->pBody);
+ returnValue = manually_handle_xglCreateGraphicsPipeline(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateComputePipeline:
+ {
+ struct_xglCreateComputePipeline* pPacket = (struct_xglCreateComputePipeline*)(packet->pBody);
+ XGL_COMPUTE_PIPELINE_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO));
+ createInfo.cs.shader = m_objMapper.remap(pPacket->pCreateInfo->cs.shader);
+ XGL_PIPELINE local_pPipeline;
+ replayResult = m_xglFuncs.real_xglCreateComputePipeline(m_objMapper.remap(pPacket->device), &createInfo, &local_pPipeline);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pPipeline, &local_pPipeline);
+ }
+ CHECK_RETURN_VALUE(xglCreateComputePipeline);
+ break;
+ }
+ case GLV_TPI_XGL_xglStorePipeline:
+ {
+ struct_xglStorePipeline* pPacket = (struct_xglStorePipeline*)(packet->pBody);
+ returnValue = manually_handle_xglStorePipeline(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglLoadPipeline:
+ {
+ struct_xglLoadPipeline* pPacket = (struct_xglLoadPipeline*)(packet->pBody);
+ XGL_PIPELINE local_pPipeline;
+ replayResult = m_xglFuncs.real_xglLoadPipeline(m_objMapper.remap(pPacket->device), pPacket->dataSize, pPacket->pData, &local_pPipeline);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pPipeline, &local_pPipeline);
+ }
+ CHECK_RETURN_VALUE(xglLoadPipeline);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreatePipelineDelta:
+ {
+ struct_xglCreatePipelineDelta* pPacket = (struct_xglCreatePipelineDelta*)(packet->pBody);
+ XGL_PIPELINE_DELTA local_delta;
+ replayResult = m_xglFuncs.real_xglCreatePipelineDelta(m_objMapper.remap(pPacket->device), pPacket->p1, pPacket->p2, &local_delta);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->delta, &local_delta);
+ }
+ CHECK_RETURN_VALUE(xglCreatePipelineDelta);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateSampler:
+ {
+ struct_xglCreateSampler* pPacket = (struct_xglCreateSampler*)(packet->pBody);
+ XGL_SAMPLER local_pSampler;
+ replayResult = m_xglFuncs.real_xglCreateSampler(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pSampler);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pSampler, &local_pSampler);
+ }
+ CHECK_RETURN_VALUE(xglCreateSampler);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
+ {
+ struct_xglCreateDescriptorSetLayout* pPacket = (struct_xglCreateDescriptorSetLayout*)(packet->pBody);
+ returnValue = manually_handle_xglCreateDescriptorSetLayout(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
+ {
+ struct_xglBeginDescriptorRegionUpdate* pPacket = (struct_xglBeginDescriptorRegionUpdate*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglBeginDescriptorRegionUpdate(m_objMapper.remap(pPacket->device), pPacket->updateMode);
+ CHECK_RETURN_VALUE(xglBeginDescriptorRegionUpdate);
+ break;
+ }
+ case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
+ {
+ struct_xglEndDescriptorRegionUpdate* pPacket = (struct_xglEndDescriptorRegionUpdate*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglEndDescriptorRegionUpdate(m_objMapper.remap(pPacket->device), m_objMapper.remap(pPacket->cmd));
+ CHECK_RETURN_VALUE(xglEndDescriptorRegionUpdate);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDescriptorRegion:
+ {
+ struct_xglCreateDescriptorRegion* pPacket = (struct_xglCreateDescriptorRegion*)(packet->pBody);
+ XGL_DESCRIPTOR_REGION local_pDescriptorRegion;
+ replayResult = m_xglFuncs.real_xglCreateDescriptorRegion(m_objMapper.remap(pPacket->device), pPacket->regionUsage, pPacket->maxSets, pPacket->pCreateInfo, &local_pDescriptorRegion);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pDescriptorRegion, &local_pDescriptorRegion);
+ }
+ CHECK_RETURN_VALUE(xglCreateDescriptorRegion);
+ break;
+ }
+ case GLV_TPI_XGL_xglClearDescriptorRegion:
+ {
+ struct_xglClearDescriptorRegion* pPacket = (struct_xglClearDescriptorRegion*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglClearDescriptorRegion(m_objMapper.remap(pPacket->descriptorRegion));
+ CHECK_RETURN_VALUE(xglClearDescriptorRegion);
+ break;
+ }
+ case GLV_TPI_XGL_xglAllocDescriptorSets:
+ {
+ struct_xglAllocDescriptorSets* pPacket = (struct_xglAllocDescriptorSets*)(packet->pBody);
+ uint32_t local_pCount;
+ XGL_DESCRIPTOR_SET local_pDescriptorSets[100];
+ XGL_DESCRIPTOR_SET_LAYOUT localDescSets[100];
+ assert(pPacket->count <= 100);
+ for (uint32_t i = 0; i < pPacket->count; i++)
+ {
+ localDescSets[i] = m_objMapper.remap(pPacket->pSetLayouts[i]);
+ }
+ replayResult = m_xglFuncs.real_xglAllocDescriptorSets(m_objMapper.remap(pPacket->descriptorRegion), pPacket->setUsage, pPacket->count, localDescSets, local_pDescriptorSets, &local_pCount);
+ if (replayResult == XGL_SUCCESS)
+ {
+ for (uint32_t i = 0; i < local_pCount; i++) {
+ m_objMapper.add_to_map(&pPacket->pDescriptorSets[i], &local_pDescriptorSets[i]);
+ }
+ }
+ CHECK_RETURN_VALUE(xglAllocDescriptorSets);
+ break;
+ }
+ case GLV_TPI_XGL_xglClearDescriptorSets:
+ {
+ struct_xglClearDescriptorSets* pPacket = (struct_xglClearDescriptorSets*)(packet->pBody);
+ XGL_DESCRIPTOR_SET localDescSets[100];
+ assert(pPacket->count <= 100);
+ for (uint32_t i = 0; i < pPacket->count; i++)
+ {
+ localDescSets[i] = m_objMapper.remap(pPacket->pDescriptorSets[i]);
+ }
+ m_xglFuncs.real_xglClearDescriptorSets(m_objMapper.remap(pPacket->descriptorRegion), pPacket->count, localDescSets);
+ break;
+ }
+ case GLV_TPI_XGL_xglUpdateDescriptors:
+ {
+ struct_xglUpdateDescriptors* pPacket = (struct_xglUpdateDescriptors*)(packet->pBody);
+ returnValue = manually_handle_xglUpdateDescriptors(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDynamicViewportState:
+ {
+ struct_xglCreateDynamicViewportState* pPacket = (struct_xglCreateDynamicViewportState*)(packet->pBody);
+ XGL_DYNAMIC_VP_STATE_OBJECT local_pState;
+ replayResult = m_xglFuncs.real_xglCreateDynamicViewportState(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pState);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pState, &local_pState);
+ }
+ CHECK_RETURN_VALUE(xglCreateDynamicViewportState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDynamicRasterState:
+ {
+ struct_xglCreateDynamicRasterState* pPacket = (struct_xglCreateDynamicRasterState*)(packet->pBody);
+ XGL_DYNAMIC_RS_STATE_OBJECT local_pState;
+ replayResult = m_xglFuncs.real_xglCreateDynamicRasterState(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pState);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pState, &local_pState);
+ }
+ CHECK_RETURN_VALUE(xglCreateDynamicRasterState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
+ {
+ struct_xglCreateDynamicColorBlendState* pPacket = (struct_xglCreateDynamicColorBlendState*)(packet->pBody);
+ XGL_DYNAMIC_CB_STATE_OBJECT local_pState;
+ replayResult = m_xglFuncs.real_xglCreateDynamicColorBlendState(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pState);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pState, &local_pState);
+ }
+ CHECK_RETURN_VALUE(xglCreateDynamicColorBlendState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
+ {
+ struct_xglCreateDynamicDepthStencilState* pPacket = (struct_xglCreateDynamicDepthStencilState*)(packet->pBody);
+ XGL_DYNAMIC_DS_STATE_OBJECT local_pState;
+ replayResult = m_xglFuncs.real_xglCreateDynamicDepthStencilState(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pState);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pState, &local_pState);
+ }
+ CHECK_RETURN_VALUE(xglCreateDynamicDepthStencilState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateCommandBuffer:
+ {
+ struct_xglCreateCommandBuffer* pPacket = (struct_xglCreateCommandBuffer*)(packet->pBody);
+ XGL_CMD_BUFFER local_pCmdBuffer;
+ replayResult = m_xglFuncs.real_xglCreateCommandBuffer(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_pCmdBuffer);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pCmdBuffer, &local_pCmdBuffer);
+ }
+ CHECK_RETURN_VALUE(xglCreateCommandBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglBeginCommandBuffer:
+ {
+ struct_xglBeginCommandBuffer* pPacket = (struct_xglBeginCommandBuffer*)(packet->pBody);
+ returnValue = manually_handle_xglBeginCommandBuffer(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglEndCommandBuffer:
+ {
+ struct_xglEndCommandBuffer* pPacket = (struct_xglEndCommandBuffer*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglEndCommandBuffer(m_objMapper.remap(pPacket->cmdBuffer));
+ CHECK_RETURN_VALUE(xglEndCommandBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglResetCommandBuffer:
+ {
+ struct_xglResetCommandBuffer* pPacket = (struct_xglResetCommandBuffer*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglResetCommandBuffer(m_objMapper.remap(pPacket->cmdBuffer));
+ CHECK_RETURN_VALUE(xglResetCommandBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindPipeline:
+ {
+ struct_xglCmdBindPipeline* pPacket = (struct_xglCmdBindPipeline*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBindPipeline(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, m_objMapper.remap(pPacket->pipeline));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindPipelineDelta:
+ {
+ struct_xglCmdBindPipelineDelta* pPacket = (struct_xglCmdBindPipelineDelta*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBindPipelineDelta(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, m_objMapper.remap(pPacket->delta));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
+ {
+ struct_xglCmdBindDynamicStateObject* pPacket = (struct_xglCmdBindDynamicStateObject*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBindDynamicStateObject(m_objMapper.remap(pPacket->cmdBuffer), pPacket->stateBindPoint, m_objMapper.remap(pPacket->state));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindDescriptorSet:
+ {
+ struct_xglCmdBindDescriptorSet* pPacket = (struct_xglCmdBindDescriptorSet*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBindDescriptorSet(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, m_objMapper.remap(pPacket->descriptorSet), pPacket->pUserData);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindVertexBuffer:
+ {
+ struct_xglCmdBindVertexBuffer* pPacket = (struct_xglCmdBindVertexBuffer*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBindVertexBuffer(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->buffer), pPacket->offset, pPacket->binding);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindIndexBuffer:
+ {
+ struct_xglCmdBindIndexBuffer* pPacket = (struct_xglCmdBindIndexBuffer*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBindIndexBuffer(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->buffer), pPacket->offset, pPacket->indexType);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDraw:
+ {
+ struct_xglCmdDraw* pPacket = (struct_xglCmdDraw*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDraw(m_objMapper.remap(pPacket->cmdBuffer), pPacket->firstVertex, pPacket->vertexCount, pPacket->firstInstance, pPacket->instanceCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDrawIndexed:
+ {
+ struct_xglCmdDrawIndexed* pPacket = (struct_xglCmdDrawIndexed*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDrawIndexed(m_objMapper.remap(pPacket->cmdBuffer), pPacket->firstIndex, pPacket->indexCount, pPacket->vertexOffset, pPacket->firstInstance, pPacket->instanceCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDrawIndirect:
+ {
+ struct_xglCmdDrawIndirect* pPacket = (struct_xglCmdDrawIndirect*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDrawIndirect(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->buffer), pPacket->offset, pPacket->count, pPacket->stride);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
+ {
+ struct_xglCmdDrawIndexedIndirect* pPacket = (struct_xglCmdDrawIndexedIndirect*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDrawIndexedIndirect(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->buffer), pPacket->offset, pPacket->count, pPacket->stride);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDispatch:
+ {
+ struct_xglCmdDispatch* pPacket = (struct_xglCmdDispatch*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDispatch(m_objMapper.remap(pPacket->cmdBuffer), pPacket->x, pPacket->y, pPacket->z);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDispatchIndirect:
+ {
+ struct_xglCmdDispatchIndirect* pPacket = (struct_xglCmdDispatchIndirect*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDispatchIndirect(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->buffer), pPacket->offset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyBuffer:
+ {
+ struct_xglCmdCopyBuffer* pPacket = (struct_xglCmdCopyBuffer*)(packet->pBody);
+ m_xglFuncs.real_xglCmdCopyBuffer(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->srcBuffer), m_objMapper.remap(pPacket->destBuffer), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyImage:
+ {
+ struct_xglCmdCopyImage* pPacket = (struct_xglCmdCopyImage*)(packet->pBody);
+ m_xglFuncs.real_xglCmdCopyImage(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->srcImage), m_objMapper.remap(pPacket->destImage), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyBufferToImage:
+ {
+ struct_xglCmdCopyBufferToImage* pPacket = (struct_xglCmdCopyBufferToImage*)(packet->pBody);
+ m_xglFuncs.real_xglCmdCopyBufferToImage(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->srcBuffer), m_objMapper.remap(pPacket->destImage), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
+ {
+ struct_xglCmdCopyImageToBuffer* pPacket = (struct_xglCmdCopyImageToBuffer*)(packet->pBody);
+ m_xglFuncs.real_xglCmdCopyImageToBuffer(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->srcImage), m_objMapper.remap(pPacket->destBuffer), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCloneImageData:
+ {
+ struct_xglCmdCloneImageData* pPacket = (struct_xglCmdCloneImageData*)(packet->pBody);
+ m_xglFuncs.real_xglCmdCloneImageData(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->srcImage), pPacket->srcImageLayout, m_objMapper.remap(pPacket->destImage), pPacket->destImageLayout);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdUpdateBuffer:
+ {
+ struct_xglCmdUpdateBuffer* pPacket = (struct_xglCmdUpdateBuffer*)(packet->pBody);
+ m_xglFuncs.real_xglCmdUpdateBuffer(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->destBuffer), pPacket->destOffset, pPacket->dataSize, pPacket->pData);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdFillBuffer:
+ {
+ struct_xglCmdFillBuffer* pPacket = (struct_xglCmdFillBuffer*)(packet->pBody);
+ m_xglFuncs.real_xglCmdFillBuffer(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->destBuffer), pPacket->destOffset, pPacket->fillSize, pPacket->data);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdClearColorImage:
+ {
+ struct_xglCmdClearColorImage* pPacket = (struct_xglCmdClearColorImage*)(packet->pBody);
+ m_xglFuncs.real_xglCmdClearColorImage(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->image), pPacket->color, pPacket->rangeCount, pPacket->pRanges);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdClearColorImageRaw:
+ {
+ struct_xglCmdClearColorImageRaw* pPacket = (struct_xglCmdClearColorImageRaw*)(packet->pBody);
+ m_xglFuncs.real_xglCmdClearColorImageRaw(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->image), pPacket->color, pPacket->rangeCount, pPacket->pRanges);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdClearDepthStencil:
+ {
+ struct_xglCmdClearDepthStencil* pPacket = (struct_xglCmdClearDepthStencil*)(packet->pBody);
+ m_xglFuncs.real_xglCmdClearDepthStencil(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->image), pPacket->depth, pPacket->stencil, pPacket->rangeCount, pPacket->pRanges);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdResolveImage:
+ {
+ struct_xglCmdResolveImage* pPacket = (struct_xglCmdResolveImage*)(packet->pBody);
+ m_xglFuncs.real_xglCmdResolveImage(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->srcImage), m_objMapper.remap(pPacket->destImage), pPacket->rectCount, pPacket->pRects);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdSetEvent:
+ {
+ struct_xglCmdSetEvent* pPacket = (struct_xglCmdSetEvent*)(packet->pBody);
+ m_xglFuncs.real_xglCmdSetEvent(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->event), pPacket->pipeEvent);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdResetEvent:
+ {
+ struct_xglCmdResetEvent* pPacket = (struct_xglCmdResetEvent*)(packet->pBody);
+ m_xglFuncs.real_xglCmdResetEvent(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->event));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdWaitEvents:
+ {
+ struct_xglCmdWaitEvents* pPacket = (struct_xglCmdWaitEvents*)(packet->pBody);
+ returnValue = manually_handle_xglCmdWaitEvents(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdPipelineBarrier:
+ {
+ struct_xglCmdPipelineBarrier* pPacket = (struct_xglCmdPipelineBarrier*)(packet->pBody);
+ returnValue = manually_handle_xglCmdPipelineBarrier(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBeginQuery:
+ {
+ struct_xglCmdBeginQuery* pPacket = (struct_xglCmdBeginQuery*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBeginQuery(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->queryPool), pPacket->slot, pPacket->flags);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdEndQuery:
+ {
+ struct_xglCmdEndQuery* pPacket = (struct_xglCmdEndQuery*)(packet->pBody);
+ m_xglFuncs.real_xglCmdEndQuery(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->queryPool), pPacket->slot);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdResetQueryPool:
+ {
+ struct_xglCmdResetQueryPool* pPacket = (struct_xglCmdResetQueryPool*)(packet->pBody);
+ m_xglFuncs.real_xglCmdResetQueryPool(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdWriteTimestamp:
+ {
+ struct_xglCmdWriteTimestamp* pPacket = (struct_xglCmdWriteTimestamp*)(packet->pBody);
+ m_xglFuncs.real_xglCmdWriteTimestamp(m_objMapper.remap(pPacket->cmdBuffer), pPacket->timestampType, m_objMapper.remap(pPacket->destBuffer), pPacket->destOffset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdInitAtomicCounters:
+ {
+ struct_xglCmdInitAtomicCounters* pPacket = (struct_xglCmdInitAtomicCounters*)(packet->pBody);
+ m_xglFuncs.real_xglCmdInitAtomicCounters(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, pPacket->startCounter, pPacket->counterCount, pPacket->pData);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
+ {
+ struct_xglCmdLoadAtomicCounters* pPacket = (struct_xglCmdLoadAtomicCounters*)(packet->pBody);
+ m_xglFuncs.real_xglCmdLoadAtomicCounters(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, pPacket->startCounter, pPacket->counterCount, m_objMapper.remap(pPacket->srcBuffer), pPacket->srcOffset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
+ {
+ struct_xglCmdSaveAtomicCounters* pPacket = (struct_xglCmdSaveAtomicCounters*)(packet->pBody);
+ m_xglFuncs.real_xglCmdSaveAtomicCounters(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, pPacket->startCounter, pPacket->counterCount, m_objMapper.remap(pPacket->destBuffer), pPacket->destOffset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateFramebuffer:
+ {
+ struct_xglCreateFramebuffer* pPacket = (struct_xglCreateFramebuffer*)(packet->pBody);
+ returnValue = manually_handle_xglCreateFramebuffer(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateRenderPass:
+ {
+ struct_xglCreateRenderPass* pPacket = (struct_xglCreateRenderPass*)(packet->pBody);
+ returnValue = manually_handle_xglCreateRenderPass(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBeginRenderPass:
+ {
+ struct_xglCmdBeginRenderPass* pPacket = (struct_xglCmdBeginRenderPass*)(packet->pBody);
+ m_xglFuncs.real_xglCmdBeginRenderPass(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->renderPass));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdEndRenderPass:
+ {
+ struct_xglCmdEndRenderPass* pPacket = (struct_xglCmdEndRenderPass*)(packet->pBody);
+ m_xglFuncs.real_xglCmdEndRenderPass(m_objMapper.remap(pPacket->cmdBuffer), m_objMapper.remap(pPacket->renderPass));
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetValidationLevel:
+ {
+ struct_xglDbgSetValidationLevel* pPacket = (struct_xglDbgSetValidationLevel*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglDbgSetValidationLevel(m_objMapper.remap(pPacket->device), pPacket->validationLevel);
+ CHECK_RETURN_VALUE(xglDbgSetValidationLevel);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
+ {
+ // Just eating these calls as no way to restore dbg func ptr.
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
+ {
+ // Just eating these calls as no way to restore dbg func ptr.
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetMessageFilter:
+ {
+ struct_xglDbgSetMessageFilter* pPacket = (struct_xglDbgSetMessageFilter*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglDbgSetMessageFilter(m_objMapper.remap(pPacket->device), pPacket->msgCode, pPacket->filter);
+ CHECK_RETURN_VALUE(xglDbgSetMessageFilter);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetObjectTag:
+ {
+ struct_xglDbgSetObjectTag* pPacket = (struct_xglDbgSetObjectTag*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglDbgSetObjectTag(m_objMapper.remap(pPacket->object), pPacket->tagSize, pPacket->pTag);
+ CHECK_RETURN_VALUE(xglDbgSetObjectTag);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetGlobalOption:
+ {
+ struct_xglDbgSetGlobalOption* pPacket = (struct_xglDbgSetGlobalOption*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglDbgSetGlobalOption(pPacket->dbgOption, pPacket->dataSize, pPacket->pData);
+ CHECK_RETURN_VALUE(xglDbgSetGlobalOption);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetDeviceOption:
+ {
+ struct_xglDbgSetDeviceOption* pPacket = (struct_xglDbgSetDeviceOption*)(packet->pBody);
+ replayResult = m_xglFuncs.real_xglDbgSetDeviceOption(m_objMapper.remap(pPacket->device), pPacket->dbgOption, pPacket->dataSize, pPacket->pData);
+ CHECK_RETURN_VALUE(xglDbgSetDeviceOption);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
+ {
+ struct_xglCmdDbgMarkerBegin* pPacket = (struct_xglCmdDbgMarkerBegin*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDbgMarkerBegin(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pMarker);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
+ {
+ struct_xglCmdDbgMarkerEnd* pPacket = (struct_xglCmdDbgMarkerEnd*)(packet->pBody);
+ m_xglFuncs.real_xglCmdDbgMarkerEnd(m_objMapper.remap(pPacket->cmdBuffer));
+ break;
+ }
+ case GLV_TPI_XGL_xglWsiX11AssociateConnection:
+ {
+ struct_xglWsiX11AssociateConnection* pPacket = (struct_xglWsiX11AssociateConnection*)(packet->pBody);
+ returnValue = manually_handle_xglWsiX11AssociateConnection(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglWsiX11GetMSC:
+ {
+ struct_xglWsiX11GetMSC* pPacket = (struct_xglWsiX11GetMSC*)(packet->pBody);
+ returnValue = manually_handle_xglWsiX11GetMSC(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
+ {
+ struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(packet->pBody);
+ returnValue = manually_handle_xglWsiX11CreatePresentableImage(pPacket);
+ break;
+ }
+ case GLV_TPI_XGL_xglWsiX11QueuePresent:
+ {
+ struct_xglWsiX11QueuePresent* pPacket = (struct_xglWsiX11QueuePresent*)(packet->pBody);
+ returnValue = manually_handle_xglWsiX11QueuePresent(pPacket);
+ break;
+ }
+ default:
+ glv_LogWarn("Unrecognized packet_id %u, skipping\n", packet->packet_id);
+ returnValue = glv_replay::GLV_REPLAY_INVALID_ID;
+ break;
+ }
+ return returnValue;
+ }
--- /dev/null
- glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
- }
- else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ /*
+ * Vulkan
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ * Copyright (C) 2015 Valve Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+ #include "xgl.h"
+ #include "glvreplay_xgl_xglreplay.h"
+ #include "glvreplay_xgl.h"
+ #include "glvreplay_xgl_settings.h"
+ #include "glvreplay_xgl_write_ppm.h"
+
+ #include <algorithm>
+ #include <queue>
+
+ extern "C" {
+ #include "glv_vk_vk_structs.h"
+ #include "xgl_enum_string_helper.h"
+ }
+
+ glvreplay_settings *g_pReplaySettings;
+
+ static const char* g_extensions[] =
+ {
+ "XGL_WSI_WINDOWS",
+ "XGL_TIMER_QUEUE",
+ "XGL_GPU_TIMESTAMP_CALIBRATION",
+ "XGL_DMA_QUEUE",
+ "XGL_COMMAND_BUFFER_CONTROL_FLOW",
+ "XGL_COPY_OCCLUSION_QUERY_DATA",
+ "XGL_ADVANCED_MULTISAMPLING",
+ "XGL_BORDER_COLOR_PALETTE"
+ };
+
+ xglReplay::xglReplay(glvreplay_settings *pReplaySettings)
+ {
+ g_pReplaySettings = pReplaySettings;
+ m_display = new xglDisplay();
+ m_pDSDump = NULL;
+ m_pCBDump = NULL;
+ m_pGlvSnapshotPrint = NULL;
+ if (g_pReplaySettings && g_pReplaySettings->screenshotList) {
+ process_screenshot_list(g_pReplaySettings->screenshotList);
+ }
+ }
+
+ xglReplay::~xglReplay()
+ {
+ delete m_display;
+ glv_platform_close_library(m_xglFuncs.m_libHandle);
+ }
+
+ int xglReplay::init(glv_replay::Display & disp)
+ {
+ int err;
+ #if defined PLATFORM_LINUX
+ void * handle = dlopen("libXGL.so", RTLD_LAZY);
+ #else
+ HMODULE handle = LoadLibrary("xgl.dll" );
+ #endif
+
+ if (handle == NULL) {
+ glv_LogError("Failed to open xgl library.\n");
+ return -1;
+ }
+ m_xglFuncs.init_funcs(handle);
+ disp.set_implementation(m_display);
+ if ((err = m_display->init(disp.get_gpu())) != 0) {
+ glv_LogError("Failed to init XGL display.\n");
+ return err;
+ }
+ if (disp.get_window_handle() == 0)
+ {
+ if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {
+ glv_LogError("Failed to create Window\n");
+ return err;
+ }
+ }
+ else
+ {
+ if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)
+ {
+ glv_LogError("Failed to set Window\n");
+ return err;
+ }
+ }
+ return 0;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)
+ {
+ glv_replay::GLV_REPLAY_RESULT res = resIn;
+ if (resCall != resTrace) {
+ glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\n", entrypointName,
+ string_XGL_RESULT((XGL_RESULT)resTrace), string_XGL_RESULT((XGL_RESULT)resCall));
+ res = glv_replay::GLV_REPLAY_BAD_RETURN;
+ }
+ #if 0
+ if (resCall != XGL_SUCCESS) {
+ glv_LogWarn("API call (%s) returned failed result %s\n", entrypointName, string_XGL_RESULT(resCall));
+ }
+ #endif
+ return res;
+ }
+
+ void xglReplay::push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char * pMsg)
+ {
+ struct validationMsg msgObj;
+ msgObj.validationLevel = validationLevel;
+ msgObj.srcObject = srcObject;
+ msgObj.location = location;
+ msgObj.msgCode = msgCode;
+ strncpy(msgObj.msg, pMsg, 256);
+ msgObj.msg[255] = '\0';
+ m_validationMsgs.push_back(msgObj);
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::pop_validation_msgs()
+ {
+ if (m_validationMsgs.size() == 0)
+ return glv_replay::GLV_REPLAY_SUCCESS;
+ m_validationMsgs.clear();
+ return glv_replay::GLV_REPLAY_VALIDATION_ERROR;
+ }
+
+ int xglReplay::dump_validation_data()
+ {
+ if (m_pDSDump && m_pCBDump)
+ {
+ m_pDSDump((char *) "pipeline_dump.dot");
+ m_pCBDump((char *) "cb_dump.dot");
+ }
+ if (m_pGlvSnapshotPrint != NULL) { m_pGlvSnapshotPrint(); }
+ return 0;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglCreateDevice(struct_xglCreateDevice* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ if (!m_display->m_initedXGL)
+ {
+ XGL_DEVICE device;
+ if (g_xglReplaySettings.debugLevel > 0)
+ {
+ XGL_DEVICE_CREATE_INFO cInfo, *ci, *pCreateInfoSaved;
+ unsigned int numLayers = 0;
+ char ** layersStr = get_enableLayers_list(&numLayers);
+ apply_layerSettings_overrides();
+ XGL_LAYER_CREATE_INFO layerInfo;
+ pCreateInfoSaved = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;
+ ci = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;
+ if (layersStr != NULL && numLayers > 0)
+ {
+ while (ci->pNext != NULL)
+ ci = (XGL_DEVICE_CREATE_INFO *) ci->pNext;
+ ci->pNext = &layerInfo;
+ layerInfo.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;
+ layerInfo.pNext = 0;
+ layerInfo.layerCount = numLayers;
+ layerInfo.ppActiveLayerNames = layersStr;
+ }
+ memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));
+ cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;
+ cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((g_xglReplaySettings.debugLevel <= 4) ? (unsigned int) XGL_VALIDATION_LEVEL_0 + g_xglReplaySettings.debugLevel : (unsigned int) XGL_VALIDATION_LEVEL_0);
+ pPacket->pCreateInfo = &cInfo;
+ replayResult = m_xglFuncs.real_xglCreateDevice(m_objMapper.remap(pPacket->gpu), pPacket->pCreateInfo, &device);
+ // restore the packet for next replay
+ ci->pNext = NULL;
+ pPacket->pCreateInfo = pCreateInfoSaved;
+ release_enableLayer_list(layersStr);
+ if (xglDbgRegisterMsgCallback(g_fpDbgMsgCallback, NULL) != XGL_SUCCESS)
+ glv_LogError("Failed to register xgl callback for replayer error handling\n");
+ #if !defined(_WIN32)
+ m_pDSDump = (DRAW_STATE_DUMP_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(m_objMapper.remap(pPacket->gpu), "drawStateDumpDotFile");
+ m_pCBDump = (DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(m_objMapper.remap(pPacket->gpu), "drawStateDumpCommandBufferDotFile");
+ m_pGlvSnapshotPrint = (GLVSNAPSHOT_PRINT_OBJECTS) m_xglFuncs.real_xglGetProcAddr(m_objMapper.remap(pPacket->gpu), "glvSnapshotPrintObjects");
+ #endif
+ }
+ else
+ replayResult = m_xglFuncs.real_xglCreateDevice(m_objMapper.remap(pPacket->gpu), pPacket->pCreateInfo, &device);
+ CHECK_RETURN_VALUE(xglCreateDevice);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pDevice, &device);
+ }
+ }
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglEnumerateGpus(struct_xglEnumerateGpus* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ if (!m_display->m_initedXGL)
+ {
+ uint32_t gpuCount;
+ XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];
+ uint32_t maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;
+ replayResult = m_xglFuncs.real_xglEnumerateGpus(m_objMapper.remap(pPacket->instance), maxGpus, &gpuCount, &gpus[0]);
+ CHECK_RETURN_VALUE(xglEnumerateGpus);
+ //TODO handle different number of gpus in trace versus replay
+ if (gpuCount != *(pPacket->pGpuCount))
+ {
+ glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\n", gpuCount, *(pPacket->pGpuCount));
+ }
+ else if (gpuCount == 0)
+ {
+ glv_LogError("xglEnumerateGpus number of gpus is zero\n");
+ }
+ else
+ {
+ glv_LogInfo("Enumerated %d GPUs in the system\n", gpuCount);
+ }
+ // TODO handle enumeration results in a different order from trace to replay
+ for (uint32_t i = 0; i < gpuCount; i++)
+ {
+ if (pPacket->pGpus)
+ m_objMapper.add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));
+ }
+ }
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglGetGpuInfo(struct_xglGetGpuInfo* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ if (!m_display->m_initedXGL)
+ {
+ switch (pPacket->infoType) {
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ {
+ XGL_PHYSICAL_GPU_PROPERTIES gpuProps;
+ size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(m_objMapper.remap(pPacket->gpu), pPacket->infoType, &dataSize,
+ (pPacket->pData == NULL) ? NULL : &gpuProps);
+ if (pPacket->pData != NULL)
+ {
+ glv_LogInfo("Replay Gpu Properties\n");
+ glv_LogInfo("Vendor ID %x, Device ID %x, name %s\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);
+ glv_LogInfo("API version %u, Driver version %u, gpu Type %u\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);
+ }
+ break;
+ }
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ {
+ XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;
+ size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(m_objMapper.remap(pPacket->gpu), pPacket->infoType, &dataSize,
+ (pPacket->pData == NULL) ? NULL : &gpuPerfs);
+ if (pPacket->pData != NULL)
+ {
+ glv_LogInfo("Replay Gpu Performance\n");
+ glv_LogInfo("Max GPU clock %f, max shader ALUs/clock %f, max texel fetches/clock %f\n",gpuPerfs.maxGpuClock, gpuPerfs.aluPerClock, gpuPerfs.texPerClock);
+ glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);
+ }
+ break;
+ }
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ {
+ XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;
+ size_t dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
+ size_t numQueues = 1;
+ assert(pPacket->pDataSize);
+ if ((*(pPacket->pDataSize) % dataSize) != 0)
+ glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\n");
+ else
+ numQueues = *(pPacket->pDataSize) / dataSize;
+ dataSize = numQueues * dataSize;
+ pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));
+ pGpuQueue = pQ;
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(m_objMapper.remap(pPacket->gpu), pPacket->infoType, &dataSize,
+ (pPacket->pData == NULL) ? NULL : pGpuQueue);
+ if (pPacket->pData != NULL)
+ {
+ for (unsigned int i = 0; i < numQueues; i++)
+ {
+ glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\n", i, pGpuQueue->queueFlags);
+ glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);
+ pGpuQueue++;
+ }
+ }
+ glv_free(pQ);
+ break;
+ }
+ default:
+ {
+ size_t size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(m_objMapper.remap(pPacket->gpu), pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData != NULL)
+ {
+ glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ break;
+ }
+ };
+ CHECK_RETURN_VALUE(xglGetGpuInfo);
+ }
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglGetExtensionSupport(struct_xglGetExtensionSupport* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ if (!m_display->m_initedXGL) {
+ replayResult = m_xglFuncs.real_xglGetExtensionSupport(m_objMapper.remap(pPacket->gpu), pPacket->pExtName);
+ CHECK_RETURN_VALUE(xglGetExtensionSupport);
+ if (replayResult == XGL_SUCCESS) {
+ for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)
+ {
+ if (!strncmp(g_extensions[ext], pPacket->pExtName, strlen(g_extensions[ext]))) {
+ bool extInList = false;
+ for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {
+ if (!strncmp(m_display->m_extensions[j], g_extensions[ext], strlen(g_extensions[ext])))
+ extInList = true;
+ break;
+ }
+ if (!extInList)
+ m_display->m_extensions.push_back((char *) g_extensions[ext]);
+ break;
+ }
+ }
+ }
+ }
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglQueueSubmit(struct_xglQueueSubmit* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_CMD_BUFFER *remappedBuffers = NULL;
+ if (pPacket->pCmdBuffers != NULL)
+ {
+ remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);
+ for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)
+ {
+ *(remappedBuffers + i) = m_objMapper.remap(*(pPacket->pCmdBuffers + i));
+ }
+ }
+ XGL_MEMORY_REF* memRefs = NULL;
+ if (pPacket->pMemRefs != NULL)
+ {
+ memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);
+ memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);
+ for (uint32_t i = 0; i < pPacket->memRefCount; i++)
+ {
+ memRefs[i].mem = m_objMapper.remap(pPacket->pMemRefs[i].mem);
+ }
+ }
+ replayResult = m_xglFuncs.real_xglQueueSubmit(m_objMapper.remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,
+ memRefs, m_objMapper.remap(pPacket->fence));
+ GLV_DELETE(remappedBuffers);
+ GLV_DELETE(memRefs);
+ CHECK_RETURN_VALUE(xglQueueSubmit);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglGetObjectInfo(struct_xglGetObjectInfo* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ size_t size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ memcpy(pData, pPacket->pData, *pPacket->pDataSize);
+ }
++ // TODO only search for object once rather than at remap() and init_objMemXXX()
+ replayResult = m_xglFuncs.real_xglGetObjectInfo(m_objMapper.remap(pPacket->object), pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData != NULL)
+ {
- glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\n");
++ glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);
++ } else if (pData != NULL)
+ {
- XGL_GPU_MEMORY handle = m_objMapper.remap(pPacket->mem);
- replayResult = m_xglFuncs.real_xglFreeMemory(handle);
++ switch (pPacket->infoType)
++ {
++ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
++ {
++ uint32_t traceCount = *((uint32_t *) pPacket->pData);
++ uint32_t replayCount = *((uint32_t *) pData);
++ if (traceCount != replayCount)
++ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_ALLOCATION_COUNT) mismatch: trace count %u, replay count %u\\n", traceCount, replayCount);
++ if (m_objMapper.m_adjustForGPU)
++ m_objMapper.init_objMemCount(pPacket->object, replayCount);
++ break;
++ }
++ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
++ {
++ XGL_MEMORY_REQUIREMENTS *traceReqs = (XGL_MEMORY_REQUIREMENTS *) pPacket->pData;
++ XGL_MEMORY_REQUIREMENTS *replayReqs = (XGL_MEMORY_REQUIREMENTS *) pData;
++ unsigned int num = size / sizeof(XGL_MEMORY_REQUIREMENTS);
++ for (unsigned int i = 0; i < num; i++)
++ {
++ if (traceReqs->size != replayReqs->size)
++ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace size %u, replay size %u\\n", traceReqs->size, replayReqs->size);
++ if (traceReqs->alignment != replayReqs->alignment)
++ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace alignment %u, replay aligmnent %u\\n", traceReqs->alignment, replayReqs->alignment);
++ if (traceReqs->granularity != replayReqs->granularity)
++ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace granularity %u, replay granularity %u\\n", traceReqs->granularity, replayReqs->granularity);
++ if (traceReqs->memProps != replayReqs->memProps)
++ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memProps %u, replay memProps %u\\n", traceReqs->memProps, replayReqs->memProps);
++ if (traceReqs->memType != replayReqs->memType)
++ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memType %u, replay memType %u\\n", traceReqs->memType, replayReqs->memType);
++ traceReqs++;
++ replayReqs++;
++ }
++ if (m_objMapper.m_adjustForGPU)
++ m_objMapper.init_objMemReqs(pPacket->object, replayReqs - num, num);
++ break;
++ }
++ default:
++ if (memcmp(pData, pPacket->pData, size) != 0)
++ glv_LogWarn("xglGetObjectInfo() mismatch on *pData: between trace and replay *pDataSize %u\\n", size);
++ }
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglGetObjectInfo);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglGetFormatInfo(struct_xglGetFormatInfo* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ size_t size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglGetFormatInfo(m_objMapper.remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData != NULL)
+ {
+ glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglGetFormatInfo);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglGetImageSubresourceInfo(struct_xglGetImageSubresourceInfo* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ size_t size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(m_objMapper.remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData != NULL)
+ {
+ glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglGetImageSubresourceInfo);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglUpdateDescriptors(struct_xglUpdateDescriptors* pPacket)
+ {
+ // We have to remap handles internal to the structures so save the handles prior to remap and then restore
+ // Rather than doing a deep memcpy of the entire struct and fixing any intermediate pointers, do save and restores via STL queue
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_UPDATE_SAMPLERS* pUpdateChain = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;
+ std::queue<XGL_SAMPLER> saveSamplers;
+ std::queue<XGL_BUFFER_VIEW> saveBufferViews;
+ std::queue<XGL_IMAGE_VIEW> saveImageViews;
+ std::queue<XGL_DESCRIPTOR_SET> saveDescSets;
+ while (pUpdateChain) {
+ switch(pUpdateChain->sType)
+ {
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {
+ XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];
+ saveSamplers.push(*pLocalSampler);
+ *pLocalSampler = m_objMapper.remap(((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i]);
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ {
+ XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;
+ for (uint32_t i = 0; i < pUST->count; i++) {
+ XGL_SAMPLER *pLocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;
+ saveSamplers.push(*pLocalSampler);
+ *pLocalSampler = m_objMapper.remap(pUST->pSamplerImageViews[i].pSampler);
+ XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;
+ saveImageViews.push(*pLocalView);
+ *pLocalView = m_objMapper.remap(pUST->pSamplerImageViews[i].pImageView->view);
+ }
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ {
+ XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;
+ for (uint32_t i = 0; i < pUI->count; i++) {
+ XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;
+ saveImageViews.push(*pLocalView);
+ *pLocalView = m_objMapper.remap(pUI->pImageViews[i]->view);
+ }
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ {
+ XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;
+ for (uint32_t i = 0; i < pUB->count; i++) {
+ XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;
+ saveBufferViews.push(*pLocalView);
+ *pLocalView = m_objMapper.remap(pUB->pBufferViews[i]->view);
+ }
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ saveDescSets.push(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);
+ ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = m_objMapper.remap(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;
+ }
+ m_xglFuncs.real_xglUpdateDescriptors(m_objMapper.remap(pPacket->descriptorSet), pPacket->pUpdateChain);
+ pUpdateChain = (XGL_UPDATE_SAMPLERS*) pPacket->pUpdateChain;
+ while (pUpdateChain) {
+ switch(pUpdateChain->sType)
+ {
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {
+ XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];
+ *pLocalSampler = saveSamplers.front();
+ saveSamplers.pop();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ {
+ XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;
+ for (uint32_t i = 0; i < pUST->count; i++) {
+ XGL_SAMPLER *plocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;
+ *plocalSampler = saveSamplers.front();
+ saveSamplers.pop();
+ XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;
+ *pLocalView = saveImageViews.front();
+ saveImageViews.pop();
+ }
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ {
+ XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;
+ for (uint32_t i = 0; i < pUI->count; i++) {
+ XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;
+ *pLocalView = saveImageViews.front();
+ saveImageViews.pop();
+ }
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ {
+ XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;
+ for (uint32_t i = 0; i < pUB->count; i++) {
+ XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;
+ *pLocalView = saveBufferViews.front();
+ saveBufferViews.pop();
+ }
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = saveDescSets.front();
+ saveDescSets.pop();
+ //pFreeMe = (XGL_UPDATE_SAMPLERS*)pLocalUpdateChain;
+ //pLocalUpdateChain = (void*)((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->pNext;
+ //free(pFreeMe);
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;
+ }
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglCreateDescriptorSetLayout(struct_xglCreateDescriptorSetLayout* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_SAMPLER saveSampler;
+ if (pPacket->pSetLayoutInfoList != NULL) {
+ XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;
+ saveSampler = pPacket->pSetLayoutInfoList->immutableSampler;
+ *pSampler = m_objMapper.remap(saveSampler);
+ }
+ XGL_DESCRIPTOR_SET_LAYOUT setLayout;
+ replayResult = m_xglFuncs.real_xglCreateDescriptorSetLayout(m_objMapper.remap(pPacket->device), pPacket->stageFlags, pPacket->pSetBindPoints, m_objMapper.remap(pPacket->priorSetLayout), pPacket->pSetLayoutInfoList, &setLayout);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pSetLayout, &setLayout);
+ }
+ if (pPacket->pSetLayoutInfoList != NULL) {
+ XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;
+ *pSampler = saveSampler;
+ }
+ CHECK_RETURN_VALUE(xglCreateDescriptorSetLayout);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglCreateGraphicsPipeline(struct_xglCreateGraphicsPipeline* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;
+ struct shaderPair saveShader[10];
+ unsigned int idx = 0;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));
+ createInfo.lastSetLayout = m_objMapper.remap(createInfo.lastSetLayout);
+ // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;
+ while (XGL_NULL_HANDLE != pPacketNext)
+ {
+ if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)
+ {
+ saveShader[idx].val = pNext->shader.shader;
+ saveShader[idx++].addr = &(pNext->shader.shader);
+ pNext->shader.shader = m_objMapper.remap(pPacketNext->shader.shader);
+ }
+ pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;
+ pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;
+ }
+ XGL_PIPELINE pipeline;
+ replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(m_objMapper.remap(pPacket->device), &createInfo, &pipeline);
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pPipeline, &pipeline);
+ }
+ for (unsigned int i = 0; i < idx; i++)
+ *(saveShader[i].addr) = saveShader[i].val;
+ CHECK_RETURN_VALUE(xglCreateGraphicsPipeline);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglCmdWaitEvents(struct_xglCmdWaitEvents* pPacket)
+ {
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_EVENT saveEvent[100];
+ uint32_t idx, numRemapBuf=0, numRemapImg=0;
+ assert(pPacket->pWaitInfo && pPacket->pWaitInfo->eventCount <= 100);
+ for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++)
+ {
+ XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);
+ saveEvent[idx] = pPacket->pWaitInfo->pEvents[idx];
+ *pEvent = m_objMapper.remap(pPacket->pWaitInfo->pEvents[idx]);
+ }
+
+ XGL_BUFFER saveBuf[100];
+ XGL_IMAGE saveImg[100];
+ for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++)
+ {
+ XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];
+ assert(pNext);
+ if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {
+ XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];
+ assert(numRemapBuf < 100);
+ saveBuf[numRemapBuf++] = pNextBuf->buffer;
+ pNextBuf->buffer = m_objMapper.remap(pNextBuf->buffer);
+ } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {
+ XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];
+ assert(numRemapImg < 100);
+ saveImg[numRemapImg++] = pNextImg->image;
+ pNextImg->image = m_objMapper.remap(pNextImg->image);
+ }
+ }
+ m_xglFuncs.real_xglCmdWaitEvents(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pWaitInfo);
+ for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++) {
+ XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];
+ if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {
+ XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];
+ pNextBuf->buffer = saveBuf[idx];
+ } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {
+ XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];
+ pNextImg->image = saveImg[idx];
+ }
+ }
+ for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++) {
+ XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);
+ *pEvent = saveEvent[idx];
+ }
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglCmdPipelineBarrier(struct_xglCmdPipelineBarrier* pPacket)
+ {
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ uint32_t idx, numRemapBuf=0, numRemapImg=0;
+ XGL_BUFFER saveBuf[100];
+ XGL_IMAGE saveImg[100];
+ for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++)
+ {
+ XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];
+ assert(pNext);
+ if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {
+ XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];
+ assert(numRemapBuf < 100);
+ saveBuf[numRemapBuf++] = pNextBuf->buffer;
+ pNextBuf->buffer = m_objMapper.remap(pNextBuf->buffer);
+ } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {
+ XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];
+ assert(numRemapImg < 100);
+ saveImg[numRemapImg++] = pNextImg->image;
+ pNextImg->image = m_objMapper.remap(pNextImg->image);
+ }
+ }
+ m_xglFuncs.real_xglCmdPipelineBarrier(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pBarrier);
+ for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++) {
+ XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];
+ if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {
+ XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];
+ pNextBuf->buffer = saveBuf[idx];
+ } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {
+ XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];
+ pNextImg->image = saveImg[idx];
+ }
+ }
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglCreateFramebuffer(struct_xglCreateFramebuffer* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_FRAMEBUFFER_CREATE_INFO *pInfo = (XGL_FRAMEBUFFER_CREATE_INFO *) pPacket->pCreateInfo;
+ XGL_COLOR_ATTACHMENT_BIND_INFO *pColorAttachments, *pSavedColor = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pInfo->pColorAttachments;
+ bool allocatedColorAttachments = false;
+ if (pSavedColor != NULL)
+ {
+ allocatedColorAttachments = true;
+ pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pInfo->colorAttachmentCount);
+ memcpy(pColorAttachments, pSavedColor, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pInfo->colorAttachmentCount);
+ for (uint32_t i = 0; i < pInfo->colorAttachmentCount; i++)
+ {
+ pColorAttachments[i].view = m_objMapper.remap(pInfo->pColorAttachments[i].view);
+ }
+ pInfo->pColorAttachments = pColorAttachments;
+ }
+ // remap depth stencil target
+ const XGL_DEPTH_STENCIL_BIND_INFO *pSavedDS = pInfo->pDepthStencilAttachment;
+ XGL_DEPTH_STENCIL_BIND_INFO depthTarget;
+ if (pSavedDS != NULL)
+ {
+ memcpy(&depthTarget, pSavedDS, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));
+ depthTarget.view = m_objMapper.remap(pSavedDS->view);
+ pInfo->pDepthStencilAttachment = &depthTarget;
+ }
+ XGL_FRAMEBUFFER local_framebuffer;
+ replayResult = m_xglFuncs.real_xglCreateFramebuffer(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_framebuffer);
+ pInfo->pColorAttachments = pSavedColor;
+ pInfo->pDepthStencilAttachment = pSavedDS;
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pFramebuffer, &local_framebuffer);
+ }
+ if (allocatedColorAttachments)
+ {
+ GLV_DELETE((void*)pColorAttachments);
+ }
+ CHECK_RETURN_VALUE(xglCreateFramebuffer);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglCreateRenderPass(struct_xglCreateRenderPass* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;
+ // remap framebuffer
+ XGL_FRAMEBUFFER savedFB = 0, *pFB = &(pInfo->framebuffer);
+ if (*pFB != NULL)
+ {
+ savedFB = pInfo->framebuffer;
+ *pFB = m_objMapper.remap(pInfo->framebuffer);
+ }
+ XGL_RENDER_PASS local_renderpass;
+ replayResult = m_xglFuncs.real_xglCreateRenderPass(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);
+ if (*pFB != NULL)
+ pInfo->framebuffer = savedFB;
+ if (replayResult == XGL_SUCCESS)
+ {
+ m_objMapper.add_to_map(pPacket->pRenderPass, &local_renderpass);
+ }
+ CHECK_RETURN_VALUE(xglCreateRenderPass);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglBeginCommandBuffer(struct_xglBeginCommandBuffer* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;
+ // assume only zero or one graphics_begin_info in the chain
+ XGL_RENDER_PASS savedRP, *pRP;
+ XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;
+ while (pInfo != NULL)
+ {
+
+ if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)
+ {
+ pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;
+ savedRP = pGInfo->renderPass;
+ pRP = &(pGInfo->renderPass);
+ *pRP = m_objMapper.remap(pGInfo->renderPass);
+ break;
+ }
+ pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*) pInfo->pNext;
+ }
+ replayResult = m_xglFuncs.real_xglBeginCommandBuffer(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pBeginInfo);
+ if (pGInfo != NULL)
+ pGInfo->renderPass = savedRP;
+ CHECK_RETURN_VALUE(xglBeginCommandBuffer);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglStorePipeline(struct_xglStorePipeline* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ size_t size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglStorePipeline(m_objMapper.remap(pPacket->pipeline), &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData != NULL)
+ {
+ glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglStorePipeline);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglGetMultiGpuCompatibility(struct_xglGetMultiGpuCompatibility* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_GPU_COMPATIBILITY_INFO cInfo;
+ XGL_PHYSICAL_GPU handle0, handle1;
+ handle0 = m_objMapper.remap(pPacket->gpu0);
+ handle1 = m_objMapper.remap(pPacket->gpu1);
+ replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);
+ CHECK_RETURN_VALUE(xglGetMultiGpuCompatibility);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglDestroyObject(struct_xglDestroyObject* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_OBJECT object = m_objMapper.remap(pPacket->object);
+ if (object != XGL_NULL_HANDLE)
+ replayResult = m_xglFuncs.real_xglDestroyObject(object);
+ if (replayResult == XGL_SUCCESS)
+ m_objMapper.rm_from_map(pPacket->object);
+ CHECK_RETURN_VALUE(xglDestroyObject);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglWaitForFences(struct_xglWaitForFences* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);
+ for (uint32_t i = 0; i < pPacket->fenceCount; i++)
+ {
+ *(pFence + i) = m_objMapper.remap(*(pPacket->pFences + i));
+ }
+ replayResult = m_xglFuncs.real_xglWaitForFences(m_objMapper.remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);
+ GLV_DELETE(pFence);
+ CHECK_RETURN_VALUE(xglWaitForFences);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglFreeMemory(struct_xglFreeMemory* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
- m_objMapper.rm_entry_from_mapData(handle);
++ gpuMemObj local_mem;
++ local_mem = m_objMapper.m_gpuMemorys.find(pPacket->mem)->second;
++ // TODO how/when to free pendingAlloc that did not use and existing gpuMemObj
++ replayResult = m_xglFuncs.real_xglFreeMemory(local_mem.replayGpuMem);
+ if (replayResult == XGL_SUCCESS)
+ {
- XGL_GPU_MEMORY handle = m_objMapper.remap(pPacket->mem);
++ delete local_mem.pGpuMem;
+ m_objMapper.rm_from_map(pPacket->mem);
+ }
+ CHECK_RETURN_VALUE(xglFreeMemory);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglMapMemory(struct_xglMapMemory* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
- replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);
- if (replayResult == XGL_SUCCESS)
- m_objMapper.add_mapping_to_mapData(handle, pData);
++ gpuMemObj local_mem = m_objMapper.m_gpuMemorys.find(pPacket->mem)->second;
+ void* pData;
- XGL_GPU_MEMORY handle = m_objMapper.remap(pPacket->mem);
- m_objMapper.rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer
- replayResult = m_xglFuncs.real_xglUnmapMemory(handle);
++ if (!local_mem.pGpuMem->isPendingAlloc())
++ {
++ replayResult = m_xglFuncs.real_xglMapMemory(local_mem.replayGpuMem, pPacket->flags, &pData);
++ if (replayResult == XGL_SUCCESS)
++ {
++ if (local_mem.pGpuMem)
++ {
++ local_mem.pGpuMem->setMemoryMapRange(pData, 0, 0, false);
++ }
++ }
++ }
++ else
++ {
++ if (local_mem.pGpuMem)
++ {
++ local_mem.pGpuMem->setMemoryMapRange(NULL, 0, 0, true);
++ }
++ }
+ CHECK_RETURN_VALUE(xglMapMemory);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglUnmapMemory(struct_xglUnmapMemory* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
- XGL_IMAGE img;
- XGL_GPU_MEMORY mem;
++ gpuMemObj local_mem = m_objMapper.m_gpuMemorys.find(pPacket->mem)->second;
++ if (!local_mem.pGpuMem->isPendingAlloc())
++ {
++ if (local_mem.pGpuMem)
++ {
++ local_mem.pGpuMem->copyMappingData(pPacket->pData); // copies data from packet into memory buffer
++ }
++ replayResult = m_xglFuncs.real_xglUnmapMemory(local_mem.replayGpuMem);
++ }
++ else
++ {
++ if (local_mem.pGpuMem)
++ {
++ unsigned char *pBuf = (unsigned char *) glv_malloc(local_mem.pGpuMem->getMemoryMapSize());
++ if (!pBuf)
++ {
++ glv_LogError("vkUnmapMemory() malloc failed");
++ }
++ local_mem.pGpuMem->setMemoryDataAddr(pBuf);
++ local_mem.pGpuMem->copyMappingData(pPacket->pData);
++ }
++ }
+ CHECK_RETURN_VALUE(xglUnmapMemory);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglWsiX11AssociateConnection(struct_xglWsiX11AssociateConnection* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ #if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
+ //associate with the replayers Wsi connection rather than tracers
+ replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(m_objMapper.remap(pPacket->gpu), &(m_display->m_WsiConnection));
+ #elif defined(WIN32)
+ //TBD
+ replayResult = XGL_SUCCESS;
+ #endif
+ CHECK_RETURN_VALUE(xglWsiX11AssociateConnection);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglWsiX11GetMSC(struct_xglWsiX11GetMSC* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ #if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
+ xcb_window_t window = m_display->m_XcbWindow;
+ replayResult = m_xglFuncs.real_xglWsiX11GetMSC(m_objMapper.remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);
+ #elif defined(WIN32)
+ //TBD
+ replayResult = XGL_SUCCESS;
+ #else
+ #endif
+ CHECK_RETURN_VALUE(xglWsiX11GetMSC);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglWsiX11CreatePresentableImage(struct_xglWsiX11CreatePresentableImage* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ #if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
- replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);
++ imageObj local_imgObj;
++ gpuMemObj local_mem;
+ m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);
+ m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width);
- m_objMapper.add_to_map(pPacket->pImage, &img);
++ replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_imgObj.replayImage, &local_mem.replayGpuMem);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (pPacket->pImage != NULL)
- m_objMapper.add_to_map(pPacket->pMem, &mem);
- m_display->imageHandles.push_back(img);
- m_display->imageMemory.push_back(mem);
++ m_objMapper.add_to_map(pPacket->pImage, &local_imgObj);
+ if(pPacket->pMem != NULL)
++ m_objMapper.add_to_map(pPacket->pMem, &local_mem);
++ m_display->imageHandles.push_back(local_imgObj.replayImage);
++ m_display->imageMemory.push_back(local_mem.replayGpuMem);
+ }
+ #elif defined(WIN32)
+ //TBD
+ replayResult = XGL_SUCCESS;
+ #endif
+ CHECK_RETURN_VALUE(xglWsiX11CreatePresentableImage);
+ return returnValue;
+ }
+
+ glv_replay::GLV_REPLAY_RESULT xglReplay::manually_handle_xglWsiX11QueuePresent(struct_xglWsiX11QueuePresent* pPacket)
+ {
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ #if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
+ XGL_WSI_X11_PRESENT_INFO pInfo;
+ std::vector<int>::iterator it;
+ memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));
+ pInfo.srcImage = m_objMapper.remap(pPacket->pPresentInfo->srcImage);
+ // use replayers Xcb window
+ pInfo.destWindow = m_display->m_XcbWindow;
+ replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(m_objMapper.remap(pPacket->queue), &pInfo, m_objMapper.remap(pPacket->fence));
+ it = std::find(m_screenshotFrames.begin(), m_screenshotFrames.end(), m_display->m_frameNumber);
+ if (it != m_screenshotFrames.end())
+ {
+ for(unsigned int i=0; i<m_display->imageHandles.size(); i++)
+ {
+ if (m_display->imageHandles[i] == pInfo.srcImage)
+ {
+ char frameName[32];
+ sprintf(frameName, "%d",m_display->m_frameNumber);
+ glvWritePPM(frameName, m_display->imageWidth[i], m_display->imageHeight[i],
+ m_display->imageHandles[i], m_display->imageMemory[i], &m_xglFuncs);
+ break;
+ }
+ }
+ }
+ #elif defined(WIN32)
+ //TBD
+ replayResult = XGL_SUCCESS;
+ #endif
+ m_display->m_frameNumber++;
+ CHECK_RETURN_VALUE(xglWsiX11QueuePresent);
+ return returnValue;
+ }
+
projects / platform / upstream / Vulkan-LoaderAndValidationLayers.git / commitdiff