glave: Big cleanup of codegen related to glvreplay_xgl.
* xglDisplay class was entirely manually-written, but inside the codegen script. This now lives in it's own .h and .cpp files.
* xglReplay implementation is now split between a manually written .cpp file, and a codegen'ed one.
* A bunch of the manually-coded entrypoints for xglReplay are now handled in the manually written .cpp file.
diff --git a/tools/glave/scripts/vk_generate.py b/tools/glave/scripts/vk_generate.py
index 364ef43..1d59dfd 100755
--- a/tools/glave/scripts/vk_generate.py
+++ b/tools/glave/scripts/vk_generate.py
@@ -1699,56 +1699,6 @@
if_body.append('}\n')
return "\n".join(if_body)
- def _generate_replay_class_decls(self):
- cd_body = []
- cd_body.append('class xglDisplay: public glv_replay::DisplayImp {')
- cd_body.append('friend class xglReplay;')
- cd_body.append('public:')
- cd_body.append(' xglDisplay();')
- cd_body.append(' ~xglDisplay();')
- cd_body.append(' int init(const unsigned int gpu_idx);')
- cd_body.append(' int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);')
- cd_body.append(' int create_window(const unsigned int width, const unsigned int height);')
- cd_body.append(' void resize_window(const unsigned int width, const unsigned int height);')
- cd_body.append(' void process_event();')
- cd_body.append(' // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}')
- cd_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- cd_body.append(' xcb_window_t get_window_handle() { return m_XcbWindow; }')
- cd_body.append('#elif defined(WIN32)')
- cd_body.append(' HWND get_window_handle() { return m_windowHandle; }')
- cd_body.append('#endif')
- cd_body.append('private:')
- cd_body.append(' XGL_RESULT init_xgl(const unsigned int gpu_idx);')
- cd_body.append(' bool m_initedXGL;')
- cd_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
- cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')
- cd_body.append(' xcb_screen_t *m_pXcbScreen;')
- cd_body.append(' xcb_window_t m_XcbWindow;')
- cd_body.append('#elif defined(WIN32)')
- cd_body.append(' HWND m_windowHandle;')
- cd_body.append('#endif')
- cd_body.append(' unsigned int m_windowWidth;')
- cd_body.append(' unsigned int m_windowHeight;')
- cd_body.append(' unsigned int m_frameNumber;')
- cd_body.append(' std::vector<uint32_t> imageWidth;')
- cd_body.append(' std::vector<uint32_t> imageHeight;')
- cd_body.append(' std::vector<XGL_IMAGE> imageHandles;')
- cd_body.append(' std::vector<XGL_GPU_MEMORY> imageMemory;')
- cd_body.append('#if 0')
- cd_body.append(' XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];')
- cd_body.append(' uint32_t m_gpuCount;')
- cd_body.append(' unsigned int m_gpuIdx;')
- cd_body.append(' XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];')
- cd_body.append(' XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];')
- cd_body.append('#endif')
- cd_body.append(' std::vector<char *>m_extensions;')
- cd_body.append('};\n')
- cd_body.append('typedef struct _XGLAllocInfo {')
- cd_body.append(' XGL_GPU_SIZE size;')
- cd_body.append(' void *pData;')
- cd_body.append('} XGLAllocInfo;')
- return "\n".join(cd_body)
-
def _generate_replay_func_ptrs(self):
xf_body = []
xf_body.append('struct xglFuncs {')
@@ -1798,6 +1748,11 @@
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('typedef struct _XGLAllocInfo {')
+ rc_body.append(' XGL_GPU_SIZE size;')
+ rc_body.append(' void *pData;')
+ rc_body.append('} XGLAllocInfo;\n')
+ rc_body.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')
rc_body.append('class xglReplay {')
rc_body.append('public:')
rc_body.append(' ~xglReplay();')
@@ -1828,6 +1783,29 @@
rc_body.append(' };')
rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')
rc_body.append(' std::vector<int> m_screenshotFrames;')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateDevice(struct_xglCreateDevice* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglEnumerateGpus(struct_xglEnumerateGpus* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetGpuInfo(struct_xglGetGpuInfo* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetExtensionSupport(struct_xglGetExtensionSupport* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglQueueSubmit(struct_xglQueueSubmit* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetObjectInfo(struct_xglGetObjectInfo* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetFormatInfo(struct_xglGetFormatInfo* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetImageSubresourceInfo(struct_xglGetImageSubresourceInfo* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglUpdateDescriptors(struct_xglUpdateDescriptors* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateDescriptorSetLayout(struct_xglCreateDescriptorSetLayout* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateGraphicsPipeline(struct_xglCreateGraphicsPipeline* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCmdWaitEvents(struct_xglCmdWaitEvents* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCmdPipelineBarrier(struct_xglCmdPipelineBarrier* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateFramebuffer(struct_xglCreateFramebuffer* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateRenderPass(struct_xglCreateRenderPass* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglBeginCommandBuffer(struct_xglBeginCommandBuffer* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglStorePipeline(struct_xglStorePipeline* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetMultiGpuCompatibility(struct_xglGetMultiGpuCompatibility* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglDestroyObject(struct_xglDestroyObject* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglWaitForFences(struct_xglWaitForFences* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglFreeMemory(struct_xglFreeMemory* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglMapMemory(struct_xglMapMemory* pPacket);')
+ rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglUnmapMemory(struct_xglUnmapMemory* pPacket);')
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)')
@@ -1948,358 +1926,6 @@
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('}')
- return "\n".join(dw_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_pGlvSnapshotPrint = NULL;')
- 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(' m_pDSDump((char *) "pipeline_dump.dot");')
- rvf_body.append(' m_pCBDump((char *) "cb_dump.dot");')
- rvf_body.append(' }')
- rvf_body.append(' if (m_pGlvSnapshotPrint != NULL) { m_pGlvSnapshotPrint(); }')
- rvf_body.append(' return 0;')
- rvf_body.append('}')
- return "\n".join(rvf_body)
def _generate_replay_init_funcs(self):
rif_body = []
@@ -2324,689 +1950,102 @@
def _gen_replay_enum_gpus(self):
ieg_body = []
- ieg_body.append(' if (!m_display->m_initedXGL)')
- ieg_body.append(' {')
- ieg_body.append(' uint32_t gpuCount;')
- ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')
- ieg_body.append(' uint32_t maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;')
- ieg_body.append(' replayResult = m_xglFuncs.real_xglEnumerateGpus(remap(pPacket->instance), maxGpus, &gpuCount, &gpus[0]);')
- ieg_body.append(' CHECK_RETURN_VALUE(xglEnumerateGpus);')
- ieg_body.append(' //TODO handle different number of gpus in trace versus replay')
- ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')
- ieg_body.append(' {')
- ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')
- ieg_body.append(' }')
- ieg_body.append(' else if (gpuCount == 0)')
- ieg_body.append(' {')
- ieg_body.append(' glv_LogError("xglEnumerateGpus number of gpus is zero\\n");')
- ieg_body.append(' }')
- ieg_body.append(' else')
- ieg_body.append(' {')
- ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')
- ieg_body.append(' }')
- ieg_body.append(' // TODO handle enumeration results in a different order from trace to replay')
- ieg_body.append(' for (uint32_t i = 0; i < gpuCount; i++)')
- ieg_body.append(' {')
- ieg_body.append(' if (pPacket->pGpus)')
- ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')
- ieg_body.append(' }')
- ieg_body.append(' }')
+ ieg_body.append(' returnValue = manually_handle_xglEnumerateGpus(pPacket);')
return "\n".join(ieg_body)
def _gen_replay_get_gpu_info(self):
ggi_body = []
- ggi_body.append(' if (!m_display->m_initedXGL)')
- ggi_body.append(' {')
- ggi_body.append(' switch (pPacket->infoType) {')
- ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')
- ggi_body.append(' {')
- ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')
- ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')
- ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
- ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')
- ggi_body.append(' if (pPacket->pData != NULL)')
- ggi_body.append(' {')
- ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')
- ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')
- ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')
- ggi_body.append(' }')
- ggi_body.append(' break;')
- ggi_body.append(' }')
- ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')
- ggi_body.append(' {')
- ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')
- ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')
- ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
- ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')
- ggi_body.append(' if (pPacket->pData != NULL)')
- ggi_body.append(' {')
- ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')
- ggi_body.append(' glv_LogInfo("Max GPU clock %f, max shader ALUs/clock %f, max texel fetches/clock %f\\n",gpuPerfs.maxGpuClock, gpuPerfs.aluPerClock, gpuPerfs.texPerClock);')
- ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')
- ggi_body.append(' }')
- ggi_body.append(' break;')
- ggi_body.append(' }')
- ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')
- ggi_body.append(' {')
- ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')
- ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')
- ggi_body.append(' size_t numQueues = 1;')
- ggi_body.append(' assert(pPacket->pDataSize);')
- ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')
- ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')
- ggi_body.append(' else')
- ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')
- ggi_body.append(' dataSize = numQueues * dataSize;')
- ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')
- ggi_body.append(' pGpuQueue = pQ;')
- ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
- ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')
- ggi_body.append(' if (pPacket->pData != NULL)')
- ggi_body.append(' {')
- ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')
- ggi_body.append(' {')
- ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')
- ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')
- ggi_body.append(' pGpuQueue++;')
- ggi_body.append(' }')
- ggi_body.append(' }')
- ggi_body.append(' glv_free(pQ);')
- ggi_body.append(' break;')
- ggi_body.append(' }')
- ggi_body.append(' default:')
- ggi_body.append(' {')
- ggi_body.append(' size_t size = 0;')
- ggi_body.append(' void* pData = NULL;')
- ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
- ggi_body.append(' {')
- ggi_body.append(' size = *pPacket->pDataSize;')
- ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
- ggi_body.append(' }')
- ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')
- ggi_body.append(' if (replayResult == XGL_SUCCESS)')
- ggi_body.append(' {')
- ggi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
- ggi_body.append(' {')
- ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
- ggi_body.append(' }')
- ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
- ggi_body.append(' {')
- ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')
- ggi_body.append(' }')
- ggi_body.append(' }')
- ggi_body.append(' glv_free(pData);')
- ggi_body.append(' break;')
- ggi_body.append(' }')
- ggi_body.append(' };')
- ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')
- ggi_body.append(' }')
+ ggi_body.append(' returnValue = manually_handle_xglGetGpuInfo(pPacket);')
return "\n".join(ggi_body)
def _gen_replay_create_device(self):
cd_body = []
- cd_body.append(' if (!m_display->m_initedXGL)')
- cd_body.append(' {')
- cd_body.append(' XGL_DEVICE device;')
- cd_body.append(' if (g_xglReplaySettings.debugLevel > 0)')
- cd_body.append(' {')
- cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo, *ci, *pCreateInfoSaved;')
- cd_body.append(' unsigned int numLayers = 0;')
- cd_body.append(' char ** layersStr = get_enableLayers_list(&numLayers);')
- cd_body.append(' apply_layerSettings_overrides();')
- cd_body.append(' XGL_LAYER_CREATE_INFO layerInfo;')
- cd_body.append(' pCreateInfoSaved = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
- cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
-
- cd_body.append(' if (layersStr != NULL && numLayers > 0)')
- cd_body.append(' {')
- cd_body.append(' while (ci->pNext != NULL)')
- cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) ci->pNext;')
- cd_body.append(' ci->pNext = &layerInfo;')
- cd_body.append(' layerInfo.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;')
- cd_body.append(' layerInfo.pNext = 0;')
- cd_body.append(' layerInfo.layerCount = numLayers;')
- cd_body.append(' layerInfo.ppActiveLayerNames = layersStr;')
- cd_body.append(' }')
-
- cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')
- cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')
- cd_body.append(' cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((g_xglReplaySettings.debugLevel <= 4) ? (unsigned int) XGL_VALIDATION_LEVEL_0 + g_xglReplaySettings.debugLevel : (unsigned int) XGL_VALIDATION_LEVEL_0);')
- cd_body.append(' pPacket->pCreateInfo = &cInfo;')
- cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
- cd_body.append(' // restore the packet for next replay')
- cd_body.append(' ci->pNext = NULL;')
- cd_body.append(' pPacket->pCreateInfo = pCreateInfoSaved;')
- cd_body.append(' release_enableLayer_list(layersStr);')
- cd_body.append(' if (xglDbgRegisterMsgCallback(g_fpDbgMsgCallback, NULL) != XGL_SUCCESS)')
- cd_body.append(' glv_LogError("Failed to register xgl callback for replayer error handling\\n");')
- cd_body.append('#if !defined(_WIN32)')
- cd_body.append(' m_pDSDump = (DRAW_STATE_DUMP_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(remap(pPacket->gpu), "drawStateDumpDotFile");')
- cd_body.append(' m_pCBDump = (DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(remap(pPacket->gpu), "drawStateDumpCommandBufferDotFile");')
- cd_body.append(' m_pGlvSnapshotPrint = (GLVSNAPSHOT_PRINT_OBJECTS) m_xglFuncs.real_xglGetProcAddr(remap(pPacket->gpu), "glvSnapshotPrintObjects");')
- cd_body.append('#endif')
- cd_body.append(' }')
- cd_body.append(' else ')
- cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
- cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')
- cd_body.append(' if (replayResult == XGL_SUCCESS)')
- cd_body.append(' {')
- cd_body.append(' add_to_map(pPacket->pDevice, &device);')
- cd_body.append(' }')
- cd_body.append(' }')
+ cd_body.append(' returnValue = manually_handle_xglCreateDevice(pPacket);')
return "\n".join(cd_body)
def _gen_replay_get_extension_support(self):
ges_body = []
- ges_body.append(' if (!m_display->m_initedXGL) {')
- ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')
- ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')
- ges_body.append(' if (replayResult == XGL_SUCCESS) {')
- ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')
- ges_body.append(' {')
- ges_body.append(' if (!strncmp(g_extensions[ext], pPacket->pExtName, strlen(g_extensions[ext]))) {')
- ges_body.append(' bool extInList = false;')
- ges_body.append(' for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {')
- ges_body.append(' if (!strncmp(m_display->m_extensions[j], g_extensions[ext], strlen(g_extensions[ext])))')
- ges_body.append(' extInList = true;')
- ges_body.append(' break;')
- ges_body.append(' }')
- ges_body.append(' if (!extInList)')
- ges_body.append(' m_display->m_extensions.push_back((char *) g_extensions[ext]);')
- ges_body.append(' break;')
- ges_body.append(' }')
- ges_body.append(' }')
- ges_body.append(' }')
- ges_body.append(' }')
+ ges_body.append(' returnValue = manually_handle_xglGetExtensionSupport(pPacket);')
return "\n".join(ges_body)
def _gen_replay_queue_submit(self):
qs_body = []
- qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')
- qs_body.append(' if (pPacket->pCmdBuffers != NULL)')
- qs_body.append(' {')
- qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')
- qs_body.append(' for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)')
- qs_body.append(' {')
- qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')
- qs_body.append(' }')
- qs_body.append(' }')
- qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')
- qs_body.append(' if (pPacket->pMemRefs != NULL)')
- qs_body.append(' {')
- qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')
- qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')
- qs_body.append(' for (uint32_t i = 0; i < pPacket->memRefCount; i++)')
- qs_body.append(' {')
- qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')
- qs_body.append(' }')
- qs_body.append(' }')
- qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')
- qs_body.append(' memRefs, remap(pPacket->fence));')
- qs_body.append(' GLV_DELETE(remappedBuffers);')
- qs_body.append(' GLV_DELETE(memRefs);')
+ qs_body.append(' returnValue = manually_handle_xglQueueSubmit(pPacket);')
return "\n".join(qs_body)
def _gen_replay_get_object_info(self):
goi_body = []
- goi_body.append(' size_t size = 0;')
- goi_body.append(' void* pData = NULL;')
- goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
- goi_body.append(' {')
- goi_body.append(' size = *pPacket->pDataSize;')
- goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
- goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')
- goi_body.append(' }')
- goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')
- goi_body.append(' if (replayResult == XGL_SUCCESS)')
- goi_body.append(' {')
- goi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
- goi_body.append(' {')
- goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
- goi_body.append(' }')
- goi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
- goi_body.append(' {')
- goi_body.append(' glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\\n");')
- goi_body.append(' }')
- goi_body.append(' }')
- goi_body.append(' glv_free(pData);')
+ goi_body.append(' returnValue = manually_handle_xglGetObjectInfo(pPacket);')
return "\n".join(goi_body)
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)
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):
ud_body = []
- # 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
- ud_body.append(' XGL_UPDATE_SAMPLERS* pUpdateChain = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;')
- ud_body.append(' std::queue<XGL_SAMPLER> saveSamplers;')
- ud_body.append(' std::queue<XGL_BUFFER_VIEW> saveBufferViews;')
- ud_body.append(' std::queue<XGL_IMAGE_VIEW> saveImageViews;')
- ud_body.append(' std::queue<XGL_DESCRIPTOR_SET> saveDescSets;')
- ud_body.append(' while (pUpdateChain) {')
- ud_body.append(' switch(pUpdateChain->sType)')
- ud_body.append(' {')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
- ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {')
- ud_body.append(' XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];')
- ud_body.append(' saveSamplers.push(*pLocalSampler);')
- ud_body.append(' *pLocalSampler = remap(((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i]);')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
- ud_body.append(' {')
- ud_body.append(' XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;')
- ud_body.append(' for (uint32_t i = 0; i < pUST->count; i++) {')
- ud_body.append(' XGL_SAMPLER *pLocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;')
- ud_body.append(' saveSamplers.push(*pLocalSampler);')
- ud_body.append(' *pLocalSampler = remap(pUST->pSamplerImageViews[i].pSampler);')
- ud_body.append(' XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;')
- ud_body.append(' saveImageViews.push(*pLocalView);')
- ud_body.append(' *pLocalView = remap(pUST->pSamplerImageViews[i].pImageView->view);')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
- ud_body.append(' {')
- ud_body.append(' XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;')
- ud_body.append(' for (uint32_t i = 0; i < pUI->count; i++) {')
- ud_body.append(' XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;')
- ud_body.append(' saveImageViews.push(*pLocalView);')
- ud_body.append(' *pLocalView = remap(pUI->pImageViews[i]->view);')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
- ud_body.append(' {')
- ud_body.append(' XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;')
- ud_body.append(' for (uint32_t i = 0; i < pUB->count; i++) {')
- ud_body.append(' XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;')
- ud_body.append(' saveBufferViews.push(*pLocalView);')
- ud_body.append(' *pLocalView = remap(pUB->pBufferViews[i]->view);')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
- ud_body.append(' saveDescSets.push(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);')
- ud_body.append(' ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = remap(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);')
- ud_body.append(' break;')
- ud_body.append(' default:')
- ud_body.append(' assert(0);')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;')
- ud_body.append(' }')
- ud_body.append(' m_xglFuncs.real_xglUpdateDescriptors(remap(pPacket->descriptorSet), pPacket->pUpdateChain);')
- ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pPacket->pUpdateChain;')
- ud_body.append(' while (pUpdateChain) {')
- ud_body.append(' switch(pUpdateChain->sType)')
- ud_body.append(' {')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
- ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {')
- ud_body.append(' XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];')
- ud_body.append(' *pLocalSampler = saveSamplers.front();')
- ud_body.append(' saveSamplers.pop();')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
- ud_body.append(' {')
- ud_body.append(' XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;')
- ud_body.append(' for (uint32_t i = 0; i < pUST->count; i++) {')
- ud_body.append(' XGL_SAMPLER *plocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;')
- ud_body.append(' *plocalSampler = saveSamplers.front();')
- ud_body.append(' saveSamplers.pop();')
- ud_body.append(' XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;')
- ud_body.append(' *pLocalView = saveImageViews.front();')
- ud_body.append(' saveImageViews.pop();')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
- ud_body.append(' {')
- ud_body.append(' XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;')
- ud_body.append(' for (uint32_t i = 0; i < pUI->count; i++) {')
- ud_body.append(' XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;')
- ud_body.append(' *pLocalView = saveImageViews.front();')
- ud_body.append(' saveImageViews.pop();')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
- ud_body.append(' {')
- ud_body.append(' XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;')
- ud_body.append(' for (uint32_t i = 0; i < pUB->count; i++) {')
- ud_body.append(' XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;')
- ud_body.append(' *pLocalView = saveBufferViews.front();')
- ud_body.append(' saveBufferViews.pop();')
- ud_body.append(' }')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
- ud_body.append(' ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = saveDescSets.front();')
- ud_body.append(' saveDescSets.pop();')
- ud_body.append(' //pFreeMe = (XGL_UPDATE_SAMPLERS*)pLocalUpdateChain;')
- ud_body.append(' //pLocalUpdateChain = (void*)((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->pNext;')
- ud_body.append(' //free(pFreeMe);')
- ud_body.append(' break;')
- ud_body.append(' default:')
- ud_body.append(' assert(0);')
- ud_body.append(' break;')
- ud_body.append(' }')
- ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;')
- ud_body.append(' }')
+ ud_body.append(' returnValue = manually_handle_xglUpdateDescriptors(pPacket);')
return "\n".join(ud_body)
def _gen_replay_create_descriptor_set_layout(self):
cdsl_body = []
- cdsl_body.append(' XGL_SAMPLER saveSampler;')
- cdsl_body.append(' if (pPacket->pSetLayoutInfoList != NULL) {')
- cdsl_body.append(' XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;')
- cdsl_body.append(' saveSampler = pPacket->pSetLayoutInfoList->immutableSampler;')
- cdsl_body.append(' *pSampler = remap(saveSampler);')
- cdsl_body.append(' }')
- cdsl_body.append(' XGL_DESCRIPTOR_SET_LAYOUT setLayout;')
- cdsl_body.append(' replayResult = m_xglFuncs.real_xglCreateDescriptorSetLayout(remap(pPacket->device), pPacket->stageFlags, pPacket->pSetBindPoints, remap(pPacket->priorSetLayout), pPacket->pSetLayoutInfoList, &setLayout);')
- cdsl_body.append(' if (replayResult == XGL_SUCCESS)')
- cdsl_body.append(' {')
- cdsl_body.append(' add_to_map(pPacket->pSetLayout, &setLayout);')
- cdsl_body.append(' }')
- cdsl_body.append(' if (pPacket->pSetLayoutInfoList != NULL) {')
- cdsl_body.append(' XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;')
- cdsl_body.append(' *pSampler = saveSampler;')
- cdsl_body.append(' }')
+ cdsl_body.append(' returnValue = manually_handle_xglCreateDescriptorSetLayout(pPacket);')
return "\n".join(cdsl_body)
def _gen_replay_create_graphics_pipeline(self):
cgp_body = []
- cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')
- cgp_body.append(' struct shaderPair saveShader[10];')
- cgp_body.append(' unsigned int idx = 0;')
- cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')
- cgp_body.append(' createInfo.lastSetLayout = remap(createInfo.lastSetLayout);')
- cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')
- cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')
- cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')
- cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')
- cgp_body.append(' {')
- cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')
- cgp_body.append(' {')
- cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')
- cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')
- cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')
- cgp_body.append(' }')
- cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')
- cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')
- cgp_body.append(' }')
- cgp_body.append(' XGL_PIPELINE pipeline;')
- cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')
- cgp_body.append(' if (replayResult == XGL_SUCCESS)')
- cgp_body.append(' {')
- cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')
- cgp_body.append(' }')
- cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')
- cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')
+ cgp_body.append(' returnValue = manually_handle_xglCreateGraphicsPipeline(pPacket);')
return "\n".join(cgp_body)
def _gen_replay_cmd_wait_events(self):
cwe_body = []
- cwe_body.append(' XGL_EVENT saveEvent[100];')
- cwe_body.append(' uint32_t idx, numRemapBuf=0, numRemapImg=0;')
- cwe_body.append(' assert(pPacket->pWaitInfo && pPacket->pWaitInfo->eventCount <= 100);')
- cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++)')
- cwe_body.append(' {')
- cwe_body.append(' XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);')
- cwe_body.append(' saveEvent[idx] = pPacket->pWaitInfo->pEvents[idx];')
- cwe_body.append(' *pEvent = remap(pPacket->pWaitInfo->pEvents[idx]);')
- cwe_body.append(' }')
- cwe_body.append('')
- cwe_body.append(' XGL_BUFFER saveBuf[100];')
- cwe_body.append(' XGL_IMAGE saveImg[100];')
- cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++)')
- cwe_body.append(' {')
- cwe_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
- cwe_body.append(' assert(pNext);')
- cwe_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
- cwe_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
- cwe_body.append(' assert(numRemapBuf < 100);')
- cwe_body.append(' saveBuf[numRemapBuf++] = pNextBuf->buffer;')
- cwe_body.append(' pNextBuf->buffer = remap(pNextBuf->buffer);')
- cwe_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
- cwe_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
- cwe_body.append(' assert(numRemapImg < 100);')
- cwe_body.append(' saveImg[numRemapImg++] = pNextImg->image;')
- cwe_body.append(' pNextImg->image = remap(pNextImg->image);')
- cwe_body.append(' }')
- cwe_body.append(' }')
- cwe_body.append(' m_xglFuncs.real_xglCmdWaitEvents(remap(pPacket->cmdBuffer), pPacket->pWaitInfo);')
- cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++) {')
- cwe_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
- cwe_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
- cwe_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
- cwe_body.append(' pNextBuf->buffer = saveBuf[idx];')
- cwe_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
- cwe_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
- cwe_body.append(' pNextImg->image = saveImg[idx];')
- cwe_body.append(' }')
- cwe_body.append(' }')
- cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++) {')
- cwe_body.append(' XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);')
- cwe_body.append(' *pEvent = saveEvent[idx];')
- cwe_body.append(' }')
+ cwe_body.append(' returnValue = manually_handle_xglCmdWaitEvents(pPacket);')
return "\n".join(cwe_body)
def _gen_replay_cmd_pipeline_barrier(self):
cpb_body = []
- cpb_body.append(' uint32_t idx, numRemapBuf=0, numRemapImg=0;')
- cpb_body.append(' XGL_BUFFER saveBuf[100];')
- cpb_body.append(' XGL_IMAGE saveImg[100];')
- cpb_body.append(' for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++)')
- cpb_body.append(' {')
- cpb_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
- cpb_body.append(' assert(pNext);')
- cpb_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
- cpb_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
- cpb_body.append(' assert(numRemapBuf < 100);')
- cpb_body.append(' saveBuf[numRemapBuf++] = pNextBuf->buffer;')
- cpb_body.append(' pNextBuf->buffer = remap(pNextBuf->buffer);')
- cpb_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
- cpb_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
- cpb_body.append(' assert(numRemapImg < 100);')
- cpb_body.append(' saveImg[numRemapImg++] = pNextImg->image;')
- cpb_body.append(' pNextImg->image = remap(pNextImg->image);')
- cpb_body.append(' }')
- cpb_body.append(' }')
- cpb_body.append(' m_xglFuncs.real_xglCmdPipelineBarrier(remap(pPacket->cmdBuffer), pPacket->pBarrier);')
- cpb_body.append(' for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++) {')
- cpb_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
- cpb_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
- cpb_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
- cpb_body.append(' pNextBuf->buffer = saveBuf[idx];')
- cpb_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
- cpb_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
- cpb_body.append(' pNextImg->image = saveImg[idx];')
- cpb_body.append(' }')
- cpb_body.append(' }')
+ cpb_body.append(' returnValue = manually_handle_xglCmdPipelineBarrier(pPacket);')
return "\n".join(cpb_body)
def _gen_replay_create_framebuffer(self):
cf_body = []
- cf_body.append(' XGL_FRAMEBUFFER_CREATE_INFO *pInfo = (XGL_FRAMEBUFFER_CREATE_INFO *) pPacket->pCreateInfo;')
- cf_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO *pColorAttachments, *pSavedColor = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pInfo->pColorAttachments;')
- cf_body.append(' bool allocatedColorAttachments = false;')
- cf_body.append(' if (pSavedColor != NULL)')
- cf_body.append(' {')
- cf_body.append(' allocatedColorAttachments = true;')
- cf_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pInfo->colorAttachmentCount);')
- cf_body.append(' memcpy(pColorAttachments, pSavedColor, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pInfo->colorAttachmentCount);')
- cf_body.append(' for (uint32_t i = 0; i < pInfo->colorAttachmentCount; i++)')
- cf_body.append(' {')
- cf_body.append(' pColorAttachments[i].view = remap(pInfo->pColorAttachments[i].view);')
- cf_body.append(' }')
- cf_body.append(' pInfo->pColorAttachments = pColorAttachments;')
- cf_body.append(' }')
- cf_body.append(' // remap depth stencil target')
- cf_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO *pSavedDS = pInfo->pDepthStencilAttachment;')
- cf_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')
- cf_body.append(' if (pSavedDS != NULL)')
- cf_body.append(' {')
- cf_body.append(' memcpy(&depthTarget, pSavedDS, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')
- cf_body.append(' depthTarget.view = remap(pSavedDS->view);')
- cf_body.append(' pInfo->pDepthStencilAttachment = &depthTarget;')
- cf_body.append(' }')
- cf_body.append(' XGL_FRAMEBUFFER local_framebuffer;')
- cf_body.append(' replayResult = m_xglFuncs.real_xglCreateFramebuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_framebuffer);')
- cf_body.append(' pInfo->pColorAttachments = pSavedColor;')
- cf_body.append(' pInfo->pDepthStencilAttachment = pSavedDS;')
- cf_body.append(' if (replayResult == XGL_SUCCESS)')
- cf_body.append(' {')
- cf_body.append(' add_to_map(pPacket->pFramebuffer, &local_framebuffer);')
- cf_body.append(' }')
- cf_body.append(' if (allocatedColorAttachments)')
- cf_body.append(' {')
- cf_body.append(' GLV_DELETE((void*)pColorAttachments);')
- cf_body.append(' }')
+ cf_body.append(' returnValue = manually_handle_xglCreateFramebuffer(pPacket);')
return "\n".join(cf_body)
def _gen_replay_create_renderpass(self):
cr_body = []
- cr_body.append(' XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;')
- cr_body.append(' // remap framebuffer')
- cr_body.append(' XGL_FRAMEBUFFER savedFB = 0, *pFB = &(pInfo->framebuffer);')
- cr_body.append(' if (*pFB != NULL)')
- cr_body.append(' {')
- cr_body.append(' savedFB = pInfo->framebuffer;')
- cr_body.append(' *pFB = remap(pInfo->framebuffer);')
- cr_body.append(' }')
- cr_body.append(' XGL_RENDER_PASS local_renderpass;')
- cr_body.append(' replayResult = m_xglFuncs.real_xglCreateRenderPass(remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);')
- cr_body.append(' if (*pFB != NULL)')
- cr_body.append(' pInfo->framebuffer = savedFB;')
- cr_body.append(' if (replayResult == XGL_SUCCESS)')
- cr_body.append(' {')
- cr_body.append(' add_to_map(pPacket->pRenderPass, &local_renderpass);')
- cr_body.append(' }')
+ cr_body.append(' returnValue = manually_handle_xglCreateRenderPass(pPacket);')
return "\n".join(cr_body)
def _gen_replay_begin_command_buffer(self):
bcb_body = []
- bcb_body.append(' XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;')
- bcb_body.append(' // assume only zero or one graphics_begin_info in the chain')
- bcb_body.append(' XGL_RENDER_PASS savedRP, *pRP;')
- bcb_body.append(' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;')
- bcb_body.append(' while (pInfo != NULL)')
- bcb_body.append(' {')
- bcb_body.append('')
- bcb_body.append(' if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)')
- bcb_body.append(' {')
- bcb_body.append(' pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;')
- bcb_body.append(' savedRP = pGInfo->renderPass;')
- bcb_body.append(' pRP = &(pGInfo->renderPass);')
- bcb_body.append(' *pRP = remap(pGInfo->renderPass);')
- bcb_body.append(' break;')
- bcb_body.append(' }')
- bcb_body.append(' pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*) pInfo->pNext;')
- bcb_body.append(' }')
- bcb_body.append(' replayResult = m_xglFuncs.real_xglBeginCommandBuffer(remap(pPacket->cmdBuffer), pPacket->pBeginInfo);')
- bcb_body.append(' if (pGInfo != NULL)')
- bcb_body.append(' pGInfo->renderPass = savedRP;')
+ bcb_body.append(' returnValue = manually_handle_xglBeginCommandBuffer(pPacket);')
return "\n".join(bcb_body)
def _gen_replay_store_pipeline(self):
sp_body = []
- sp_body.append(' size_t size = 0;')
- sp_body.append(' void* pData = NULL;')
- sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
- sp_body.append(' {')
- sp_body.append(' size = *pPacket->pDataSize;')
- sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
- sp_body.append(' }')
- sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')
- sp_body.append(' if (replayResult == XGL_SUCCESS)')
- sp_body.append(' {')
- sp_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
- sp_body.append(' {')
- sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
- sp_body.append(' }')
- sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
- sp_body.append(' {')
- sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')
- sp_body.append(' }')
- sp_body.append(' }')
- sp_body.append(' glv_free(pData);')
+ sp_body.append(' returnValue = manually_handle_xglStorePipeline(pPacket);')
return "\n".join(sp_body)
def _gen_replay_get_multi_gpu_compatibility(self):
gmgc_body = []
- gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')
- gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')
- gmgc_body.append(' handle0 = remap(pPacket->gpu0);')
- gmgc_body.append(' handle1 = remap(pPacket->gpu1);')
- gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')
+ gmgc_body.append(' returnValue = manually_handle_xglGetMultiGpuCompatibility(pPacket);')
return "\n".join(gmgc_body)
def _gen_replay_destroy_object(self):
do_body = []
- do_body.append(' XGL_OBJECT object = remap(pPacket->object);')
- do_body.append(' if (object != XGL_NULL_HANDLE)')
- do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')
- do_body.append(' if (replayResult == XGL_SUCCESS)')
- do_body.append(' rm_from_map(pPacket->object);')
+ do_body.append(' returnValue = manually_handle_xglDestroyObject(pPacket);')
return "\n".join(do_body)
def _gen_replay_wait_for_fences(self):
wf_body = []
- wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')
- wf_body.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
- wf_body.append(' {')
- wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')
- wf_body.append(' }')
- wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')
- wf_body.append(' GLV_DELETE(pFence);')
+ wf_body.append(' returnValue = manually_handle_xglWaitForFences(pPacket);')
return "\n".join(wf_body)
def _gen_replay_wsi_associate_connection(self):
@@ -3088,34 +2127,22 @@
wqp_body.append(' m_display->m_frameNumber++;')
return "\n".join(wqp_body)
- # I don't like making these 3 mem functions 'fully' custom, but just doing it for now to avoid being too cute
def _gen_replay_free_memory(self):
fm_body = []
- fm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
- fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(handle);')
- fm_body.append(' if (replayResult == XGL_SUCCESS) ')
- fm_body.append(' {')
- fm_body.append(' rm_entry_from_mapData(handle);')
- 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):
mm_body = []
- mm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
- mm_body.append(' void* pData;')
- mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);')
- mm_body.append(' if (replayResult == XGL_SUCCESS)')
- mm_body.append(' add_mapping_to_mapData(handle, pData);')
+ mm_body.append(' returnValue = manually_handle_xglMapMemory(pPacket);')
return "\n".join(mm_body)
def _gen_replay_unmap_memory(self):
um_body = []
- um_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
- um_body.append(' rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer')
- um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(handle);')
+ um_body.append(' returnValue = manually_handle_xglUnmapMemory(pPacket);')
return "\n".join(um_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;')
@@ -3157,7 +2184,10 @@
'CmdPipelineBarrier': self._gen_replay_cmd_pipeline_barrier}
# TODO : Need to guard CreateInstance with "if (!m_display->m_initedXGL)" check
# Despite returning a value, don't check these funcs b/c custom code includes check already
- custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']
+ custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport', 'QueueSubmit', 'GetObjectInfo',
+ 'GetFormatInfo', 'GetImageSubresourceInfo', 'CreateDescriptorSetLayout', 'CreateGraphicsPipeline',
+ 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'StorePipeline', 'GetMultiGpuCompatibility',
+ 'DestroyObject', 'WaitForFences', 'FreeMemory', 'MapMemory', 'UnmapMemory']
# multi-gpu Open funcs w/ list of local params to create
custom_open_params = {'OpenSharedMemory': (-1,),
'OpenSharedQueueSemaphore': (-1,),
@@ -3170,7 +2200,6 @@
# A couple funcs use do while loops
do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result && pPacket->result == XGL_SUCCESS', 'GetEventStatus': '(pPacket->result == XGL_EVENT_SET || pPacket->result == XGL_EVENT_RESET) && replayResult != pPacket->result'}
rbody = []
- rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')
rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')
rbody.append('{')
rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
@@ -3562,6 +2591,9 @@
header_txt.append('#include "glvreplay_window.h"')
header_txt.append('#include "glvreplay_factory.h"')
header_txt.append('#include "glv_trace_packet_identifiers.h"\n')
+ header_txt.append('extern "C" {\n')
+ header_txt.append('#include "glv_vk_vk_structs.h"\n')
+ header_txt.append('}\n')
header_txt.append('#include "xgl.h"')
header_txt.append('#include "xglDbg.h"')
header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
@@ -3571,12 +2603,12 @@
header_txt.append('#endif')
header_txt.append('#include "draw_state.h"')
header_txt.append('#include "glave_snapshot.h"')
+ header_txt.append('#include "glvreplay_xgl_xgldisplay.h"')
header_txt.append('#include "glvreplay_xgl_func_ptrs.h"')
return "\n".join(header_txt)
def generate_body(self):
- body = [self._generate_replay_class_decls(),
- self._generate_replay_class()]
+ body = [self._generate_replay_class()]
return "\n".join(body)
@@ -3589,7 +2621,7 @@
header_txt.append('#include "glvreplay_main.h"\n')
header_txt.append('#include <algorithm>')
header_txt.append('#include <queue>')
- header_txt.append('glvreplay_settings *g_pReplaySettings;')
+ header_txt.append('\n')
header_txt.append('extern "C" {')
header_txt.append('#include "glv_vk_vk_structs.h"')
header_txt.append('#include "glv_vk_vkdbg_structs.h"')
@@ -3598,29 +2630,11 @@
header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
header_txt.append('#define APP_NAME "glvreplay_xgl"')
header_txt.append('#define IDI_ICON 101\n')
- header_txt.append('static const char* g_extensions[] =')
- header_txt.append('{')
- header_txt.append(' "XGL_WSI_WINDOWS",')
- header_txt.append(' "XGL_TIMER_QUEUE",')
- header_txt.append(' "XGL_GPU_TIMESTAMP_CALIBRATION",')
- header_txt.append(' "XGL_DMA_QUEUE",')
- header_txt.append(' "XGL_COMMAND_BUFFER_CONTROL_FLOW",')
- header_txt.append(' "XGL_COPY_OCCLUSION_QUERY_DATA",')
- header_txt.append(' "XGL_ADVANCED_MULTISAMPLING",')
- header_txt.append(' "XGL_BORDER_COLOR_PALETTE"')
- header_txt.append('};')
+
return "\n".join(header_txt)
def generate_body(self):
- body = [self._generate_replay_display_init_xgl(),
- self._generate_replay_display_init(),
- self._generate_replay_display_structors(),
- self._generate_replay_display_window(),
- self._generate_replay_structors(),
- self._generate_replay_init(),
- self._generate_replay_errors(),
- self._generate_replay_validation_funcs(),
- self._generate_replay_init_funcs(),
+ body = [self._generate_replay_init_funcs(),
self._generate_replay()]
return "\n".join(body)