# Build Instructions
This project fully supports Linux today.
-Support for Windows is for the loader, layers, and the Glave debugger (additional info below). Additional Windows support will be coming in Q1'15.
+Support for Windows is for the loader, layers, and the VkTrace trace/replay tools.
Support for Android is TBD.
## Git the Bits
sudo apt-get install git subversion cmake libgl1-mesa-dev freeglut3-dev libglm-dev libpng12-dev libmagickwand-dev qt5-default libpciaccess-dev libpthread-stubs0-dev libudev-dev
sudo apt-get build-dep mesa
```
-Warning: Recent versions of 14.10 have **REMOVED** DRI 3.
-Version: 2:2.99.914-1~exp1ubuntu4.1 is known to work.
+Warning: Recent versions of 14.10 have **REMOVED** DRI 3.
+Version: 2:2.99.914-1~exp1ubuntu4.1 is known to work.
To see status of this package:
```
dpkg -s xserver-xorg-video-intel
```
-Note:
-Version 2:2.99.914-1~exp1ubuntu4.2 does not work anymore.
-To install the working driver from launchpadlibrarian.net:
-- Remove the current driver:
+Note:
+Version 2:2.99.914-1~exp1ubuntu4.2 does not work anymore.
+To install the working driver from launchpadlibrarian.net:
+- Remove the current driver:
```
sudo apt-get purge xserver-xorg-video-intel
```
-- Download the old driver:
+- Download the old driver:
```
wget http://launchpadlibrarian.net/189418339/xserver-xorg-video-intel_2.99.914-1%7Eexp1ubuntu4.1_amd64.deb
```
sudo bash -c "echo $'Package: xserver-xorg-video-intel\nPin: version 2:2.99.914-1~exp1ubuntu4.1\nPin-Priority: 1001' > /etc/apt/preferences.d/xserver-xorg-video-intel"
```
-- Either restart Ubuntu or just X11.
-
+- Either restart Ubuntu or just X11.
+
## Clone the repository
To create your local git repository:
- Microsoft Visual Studio 2013 Professional. Note: it is possible that lesser/older versions may work, but that has not been tested.
- CMake (from http://www.cmake.org/download/). Notes:
- - In order to build the Glave debugger, you need at least version 3.0.
+ - In order to build the VkTrace tools, you need at least version 3.0.
- Tell the installer to "Add CMake to the system PATH" environment variable.
- Python 3 (from https://www.python.org/downloads). Notes:
- Select to install the optional sub-package to add Python to the system PATH environment variable.
- - Need python3.3 or later to get the Windows py.exe launcher that is used to get pyhton3 rather than python2 if both are installed on Windows
+ - Need python3.3 or later to get the Windows py.exe launcher that is used to get python3 rather than python2 if both are installed on Windows
- Git (from http://git-scm.com/download/win).
- Note: If you use Cygwin, you can normally use Cygwin's "git.exe". However, in order to use the "update_external_sources.bat" script, you must have this version.
- Tell the installer to allow it to be used for "Developer Prompt" as well as "Git Bash".
Optional software packages:
-- Qt 5.3 (from http://www.qt.io/download/). Notes:
- - Qt 5.3 is required in order to build the Glave debugger (GUI). The Glave trace and replay tools can be built without Qt, but the debugger/GUI is built on top of Qt 5.3. Various dependencies, from the Qt package are copied to the directory where the Glave debugger and its libraries are built. In order to copy and run the debugger in another directory, these libraries must also be copied. Other notes:
- - While there are commercial licenses, you can also use the "Community" (free) license.
- - By default, the installer will select the latest version (e.g. Qt 5.4) as well as some other components. You must select "Qt 5.3"! You can have multiple versions installed (e.g. Qt 5.2.1, 5.3, and 5.4).
- - Installing Qt takes a long time.
- Cygwin (from https://www.cygwin.com/). Notes:
- Cygwin provides some Linux-like tools, which are valuable for obtaining the source code, and running CMake.
Especially valuable are the BASH shell and git packages.
- VK Library and header files, which include:\r
- [*ICD Loader*](loader) and [*Layer Manager*](layers/README.md)\r
- Snapshot of *VK* and *BIL* header files from [*Khronos*](www.khronos.org)\r
- \r
-- [*GLAVE Debugger*](tools/glave)\r
+\r
+- [*VKTRACE tools*](tools/vktrace)\r
\r
\r
\r
Supports new resource binding model, memory allocation, pixel FORMATs and\r
other updates.\r
APIDump layer is working with these new API elements.\r
- Glave can trace and replay the cube and tri demos.\r
+ VkTrace can trace and replay the cube and tri demos.\r
Other layers in progress.\r
-- Warning: Recent versions of 14.10 have **REMOVED** DRI 3. \r
- Version: 2:2.99.914-1~exp1ubuntu4.1 is known to work. \r
+- Warning: Recent versions of 14.10 have **REMOVED** DRI 3.\r
+ Version: 2:2.99.914-1~exp1ubuntu4.1 is known to work.\r
\r
## Prior updates\r
\r
-- VK API trace and capture tools. See tools/glave/README.md for details.\r
+- VK API trace and capture tools. See tools/vktrace/README.md for details.\r
- Sample driver now supports multiple render targets. Added TriangleMRT to test that functionality.\r
- Added VK_SLOT_SHADER_TEXTURE_RESOURCE to vulkan.h as a descriptor slot type to work around confusion in GLSL\r
between textures and buffers as shader resources.\r
FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/golden GOLDEN)
FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/_run_all_tests.ps1 RUN_ALL)
FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/_run_all_tests_with_layers.ps1 RUN_ALL_WITH_LAYERS)
- FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/_vktracereplay.ps1 VKGLAVETRACEREPLAY)
+ FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/_vktracereplay.ps1 VKTRACEREPLAY)
add_custom_target(binary-dir-symlinks ALL
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${RUN_ALL} run_all_tests.ps1
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${RUN_ALL_WITH_LAYERS} run_all_tests_with_layers.ps1
- COMMAND ${CMAKE_COMMAND} -E copy_if_different ${VKGLAVETRACEREPLAY} vktracereplay.ps1
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different ${VKTRACEREPLAY} vktracereplay.ps1
COMMAND IF NOT EXIST golden mklink /J golden ${GOLDEN}
VERBATIM
)
def handle_args():
parser = argparse.ArgumentParser(description='Perform analysis of vogl trace.')
parser.add_argument('input_file', help='The input header file from which code will be generated.')
- parser.add_argument('--rel_out_dir', required=False, default='glave_gen', help='Path relative to exec path to write output files. Will be created if needed.')
+ parser.add_argument('--rel_out_dir', required=False, default='vktrace_gen', help='Path relative to exec path to write output files. Will be created if needed.')
parser.add_argument('--abs_out_dir', required=False, default=None, help='Absolute path to write output files. Will be created if needed.')
parser.add_argument('--gen_enum_string_helper', required=False, action='store_true', default=False, help='Enable generation of helper header file to print string versions of enums.')
parser.add_argument('--gen_struct_wrappers', required=False, action='store_true', default=False, help='Enable generation of struct wrapper classes.')
self.typedef_rev_dict = {}
self.types_dict = {}
self.last_struct_count_name = ''
-
+
def setHeaderFile(self, header_file):
self.header_file = header_file
if ';' in line:
self._add_struct(line, base_type, member_num)
member_num = member_num + 1
-
+
# populate enum dicts based on enum lines
def _add_enum(self, line_txt, enum_type, def_enum_val):
#print("Parsing enum line %s" % line_txt)
self.filename = filename
self.contents = {'copyright': copyright_txt, 'header': header_txt, 'body': body_txt, 'footer': footer_txt}
# TODO : Set a default copyright & footer at least
-
+
def setFilename(self, filename):
self.filename = filename
-
+
def setCopyright(self, c):
self.contents['copyright'] = c
-
+
def setHeader(self, h):
self.contents['header'] = h
-
+
def setBody(self, b):
self.contents['body'] = b
-
+
def setFooter(self, f):
self.contents['footer'] = f
-
+
def generate(self):
#print("Generate to file %s" % self.filename)
with open(self.filename, "w") as f:
#print(self.header_filename)
self.header_txt = ""
self.definition_txt = ""
-
+
def set_include_headers(self, include_headers):
self.include_headers = include_headers
def get_class_name(self, struct_name):
class_name = struct_name.strip('_').lower() + "_struct_wrapper"
return class_name
-
+
def get_file_list(self):
return [os.path.basename(self.header_filename), os.path.basename(self.class_filename), os.path.basename(self.string_helper_filename)]
- # Generate class header file
+ # Generate class header file
def generateHeader(self):
self.hfg.setCopyright(self._generateCopyright())
self.hfg.setHeader(self._generateHeader())
self.hfg.setBody(self._generateClassDeclaration())
self.hfg.setFooter(self._generateFooter())
self.hfg.generate()
-
+
# Generate class definition
def generateBody(self):
self.cfg.setCopyright(self._generateCopyright())
header.append("//#includes, #defines, globals and such...\n")
header.append("#include <stdio.h>\n#include <%s>\n#include <%s_enum_string_helper.h>\n" % (os.path.basename(self.header_filename), self.api_prefix))
return "".join(header)
-
+
def _generateClassDefinition(self):
class_def = []
- if 'vk' == self.api: # Mantle doesn't have pNext to worry about
+ if 'vk' == self.api:
class_def.append(self._generateDynamicPrintFunctions())
for s in sorted(self.struct_dict):
class_def.append("\n// %s class definition" % self.get_class_name(s))
class_def.append(self._generateDestructorDefinitions(s))
class_def.append(self._generateDisplayDefinitions(s))
return "\n".join(class_def)
-
+
def _generateConstructorDefinitions(self, s):
con_defs = []
con_defs.append("%s::%s() : m_struct(), m_indent(0), m_dummy_prefix('\\0'), m_origStructAddr(NULL) {}" % (self.get_class_name(s), self.get_class_name(s)))
con_defs.append("%s::%s(%s* pInStruct) : m_indent(0), m_dummy_prefix('\\0')\n{\n m_struct = *pInStruct;\n m_origStructAddr = pInStruct;\n}" % (self.get_class_name(s), self.get_class_name(s), typedef_fwd_dict[s]))
con_defs.append("%s::%s(const %s* pInStruct) : m_indent(0), m_dummy_prefix('\\0')\n{\n m_struct = *pInStruct;\n m_origStructAddr = pInStruct;\n}" % (self.get_class_name(s), self.get_class_name(s), typedef_fwd_dict[s]))
return "\n".join(con_defs)
-
+
def _generateDestructorDefinitions(self, s):
return "%s::~%s() {}" % (self.get_class_name(s), self.get_class_name(s))
-
+
def _generateDynamicPrintFunctions(self):
dp_funcs = []
dp_funcs.append("\nvoid dynamic_display_full_txt(const void* pStruct, uint32_t indent)\n{\n // Cast to APP_INFO ptr initially just to pull sType off struct")
sh_funcs.append(" }")
sh_funcs.append("}")
return "\n".join(sh_funcs)
-
+
def _genStructMemberPrint(self, member, s, array, struct_array):
(p_out, p_arg) = self._get_struct_print_formatted(self.struct_dict[s][member], pre_var_name="&m_dummy_prefix", struct_var_name="m_struct", struct_ptr=False, print_array=True)
extra_indent = ""
class_num += 1
disp_def.append("}\n")
return "\n".join(disp_def)
-
+
def _generateStringHelperHeader(self):
header = []
header.append("//#includes, #defines, globals and such...\n")
for f in self.include_headers:
header.append("#include <%s>\n" % f)
return "".join(header)
-
+
# Declarations
def _generateConstructorDeclarations(self, s):
constructors = []
constructors.append(" %s(%s* pInStruct);\n" % (self.get_class_name(s), typedef_fwd_dict[s]))
constructors.append(" %s(const %s* pInStruct);\n" % (self.get_class_name(s), typedef_fwd_dict[s]))
return "".join(constructors)
-
+
def _generateDestructorDeclarations(self, s):
return " virtual ~%s();\n" % self.get_class_name(s)
-
+
def _generateDisplayDeclarations(self, s):
return " void display_txt();\n void display_single_txt();\n void display_full_txt();\n"
-
+
def _generateGetSetDeclarations(self, s):
get_set = []
get_set.append(" void set_indent(uint32_t indent) { m_indent = indent; }\n")
if not self.struct_dict[s][member]['const']:
get_set.append(" void set_%s(%s inValue) { m_struct.%s = inValue; }\n" % (self.struct_dict[s][member]['name'], self.struct_dict[s][member]['full_type'], self.struct_dict[s][member]['name']))
return "".join(get_set)
-
+
def _generatePrivateMembers(self, s):
priv = []
priv.append("\nprivate:\n")
priv.append(" const char m_dummy_prefix;\n")
priv.append(" void display_struct_members();\n")
return "".join(priv)
-
+
def _generateClassDeclaration(self):
class_decl = []
for s in sorted(self.struct_dict):
class_decl.append(self._generatePrivateMembers(s))
class_decl.append("};\n")
return "\n".join(class_decl)
-
+
def _generateFooter(self):
return "\n//any footer info for class\n"
self.eshfg = CommonFileGen(self.out_sh_file)
self.out_vh_file = out_vh_file
self.evhfg = CommonFileGen(self.out_vh_file)
-
+
def generateStringHelper(self):
self.eshfg.setHeader(self._generateSHHeader())
self.eshfg.setBody(self._generateSHBody())
body.append(' case %s:\n return "%s";' % (e, e))
body.append(' default:\n return "Unhandled %s";\n }\n}\n\n' % (fet))
return "\n".join(body)
-
+
def _generateSHHeader(self):
header = []
header.append('#pragma once\n')
header.append('#endif\n')
header.append('#include <%s>\n\n\n' % self.in_file)
return "\n".join(header)
-
+
class CMakeGen:
def __init__(self, struct_wrapper=None, out_dir=None):
self.out_dir = out_dir
self.out_file = os.path.join(self.out_dir, "CMakeLists.txt")
self.cmg = CommonFileGen(self.out_file)
-
+
def generate(self):
self.cmg.setBody(self._generateBody())
self.cmg.generate()
-
+
def _generateBody(self):
body = []
body.append("project(%s)" % os.path.basename(self.out_dir))
# hdr.append('node [\nfontsize = "16"\nshape = "plaintext"\n];')
# hdr.append('edge [\n];\n')
# return "\n".join(hdr)
-#
+#
# def _generateBody(self):
# body = []
# for s in sorted(self.struc_dict):
message(FATAL_ERROR "Missing PythonInterp. Install python interpreter 2.7 (on linux use cmd: sudo apt-get install python2.7)")
endif()
-
-#set(CODE_GEN_DIR "vktrace_extensions/glave_vk_gen")
-
-#execute_process(COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../../vk-helper.py --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/src/${CODE_GEN_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/../../include/vulkan.h)
-
-
message("")
message("cmake options:")
message(" -DCMAKE_BUILD_TYPE='${CMAKE_BUILD_TYPE}': Build debug or release. (Debug|Release)")
#
# Components to build
#
-set(GLV_VULKAN_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(VKTRACE_VULKAN_DIR ${CMAKE_CURRENT_SOURCE_DIR})
add_subdirectory(src/vktrace_common)
add_subdirectory(src/vktrace_trace)
-Glave Debugger
-==============
+Vktrace Trace and Replay Tool
+=============================
-Glave is a tracer and debugger for graphics applications. The Vulkan API is currently the most supported.
+Vktrace is a Vulkan API tracer for graphics applications.
-##Screen Shots##
-The following screen shots illustrate the current functionality available from the interactive debugger.
+##Using Vktrace on Linux###
+Vktrace builds two binaries with associated Vulkan libraries: a tracer with Vulkan
+tracing library and a replayer.
-###Open###
-Freshly opened tool.
-
-
-
-###Generate Trace###
-Click on "Generate Trace" button to launch the application with the trace and save the trace file, then prompt user to load it.
-
-
-
-###Play Trace###
-Click "Play" and you will see the Vulkan entrypoints being replayed.
-
-
-
-###Pause###
-"Pause" the replay and the upcoming entrypoint will be highlighted. The timeline shows progress in the tracefile.
-
-
-
-###Search For Memory###
-Search the trace file for an entrypoint and parameter. In this case we find all the calls to a specifc memory object.
-
-
-
-##Glave Status for Tracing and Replay##
-Based on vulkan.h Version 90
-
-* cube -works
-* tri -works but SEG FAULT on closing window (XCB connection)
-* vk\_image\_tests -works, nothing rendered by this test
-* vkbase -works, nothing rendered by this test
-* vulkaninfo -works, nothing rendered by this test
-* vk\_blit\_tests -crashes due to improper handling of PipelineBarrier
-* vk\_render\_test -crashes
-
-##Using Glave on Linux###
-Glave builds three binaries with associated Vulkan libraries: a tracer with Vulkan
-tracing library; a replayer with Vulkan replayer library; and a debugger with
-Vulkan debugger and replayer libraries.
-
-###Running Glave tracer as standalone server on Linux###
-The Glave tracer program can run as a server. Then the app/game to be traced
-is launched separately with the Glave tracer library preloaded. To run
-GLave tracer as a server one should omit the "-p" option and use the -l<number>
-option. The "-l<number>" option specifies a Glave tracing library to listen for
-socket connections.
+###Running Vktrace tracer as standalone server on Linux###
+The Vktrace tracer program can run as a server. Then the app/game to be traced
+is launched separately with the Vktrace tracer library preloaded. To run
+Vktrace as a server one should omit the "-p" option.
```
-cd <glave build directory>
-./glvtrace <options>
+cd <vktrace build directory>
+./vktrace <options>
Example to trace spinning cube demo.
-export VK_ICD_FILENAMES=/home/jon/main_icd.json
-export LD_LIBRARY_PATH=/home/jon/dbuild/loader
-./glvtrace -l0 /home/jon/vulkan/dbuild/tools/glave/libglvtrace_vk.so -o glvtrace_cube.glv
+export VK_ICD_FILENAMES=/home/jon/LoaderAndTools/main_icd.json
+export LD_LIBRARY_PATH=/home/jon/LoaderAndTools/dbuild/loader
+./vktrace -o vktrace_cube.vktrace
```
In a separate terminal run your app, the cube demo in this example:
```
-cd /home/jon/vulkan/dbuild/demos
-export LIBVK_DRIVERS_PATH=/home/jon/dbuild/icd/intel
-export LD_LIBRARY_PATH=/home/jon/dbuild/loader
-LD_PRELOAD=/home/jon/xgl/dbuild/tools/glave/libglvtrace_vk.so ./cube
+cd /home/jon/LoaderAndTools/dbuild/demos
+export VK_ICD_FILENAMES=/home/jon/LoaderAndTools/dbuild/icd/intel/intel_icd.json
+export LD_LIBRARY_PATH=/home/jon/LoaderAndTools/dbuild/loader
+LD_PRELOAD=/home/jon/LoaderAndTools/dbuild/vktrace/libvulkan_trace.so ./cube
```
-Trace file is written into "glvtrace_cube<number>.glv".
-As the app is rerun, the Glave tracer server will increment the output file
+Trace file is written into "vktrace_cube<number>.vktrace".
+As the app is rerun, the Vktrace tracer server will increment the output file
number for each succesive run of the app.
-One can also set GLVLIB_TRACE_IPADDR to a remote system IP address. Then
+One can also set VKTRACE_LIB_IPADDR to a remote system IP address. Then
the tracer inserted into an app will send the tarce packets to the remote
system rather than local system. In this case, the remote system should be
running the trace server.
-###Running Glave tracer and launch app/game from tracer on Linux###
-The Glave tracer program launches the app/game you desire and then traces it.
-To launch app/game from Glave tracer one must use the "-p" option. Also the
+###Running Vktrace tracer and launch app/game from tracer on Linux###
+The Vktrace tracer program launches the app/game you desire and then traces it.
+To launch app/game from Vktrace tracer one must use the "-p" option. Also the
-l<number> option should be given for specifying the tracing library.
```
-cd <glave build dir>
-./
glvtrace -p <path to app to launch> <more options>
+cd <vktrace build dir>
+./
vktrace -p <path to app to launch> <more options>
```
Example to trace the spinning cube demo from sample implementation
```
-export VK_ICD_FILENAMES=/home/jon/main_icd.json
-export LD_LIBRARY_PATH=/home/jon/dbuild/loader
-./glvtrace -p /home/jon/dbuild/demos/cube -l0 /home/jon/dbuild/tools/glave/libglvtrace_vk.so -o glvtrace_cube.glv -w /home/jon/dbuild/demos
+export VK_ICD_FILENAMES=/home/jon/LoaderAndTools/main_icd.json
+export LD_LIBRARY_PATH=/home/jon/LoaderAndTools/dbuild/loader
+./vktrace -p /home/jon/LoaderAndTools/dbuild/demos/cube -o vktrace_cube.vktrace -w /home/jon/LoaderAndTools/dbuild/demos
```
-Trace file is in "glvtrace_cube.glv".
+Trace file is in "vktrace_cube.vktrace".
###Running replayer on Linux###
-The Glave replayer takes a trace file and will launch an Vulkan session based
+The Vktrace replayer takes a trace file and will launch an Vulkan session based
on trace file.
```
-cd <glave build dir>
-export LD_LIBRARY_PATH=<glave build dir>:<loader dir>
-./glvreplay <options> -t trace_filename
+cd <vktrace build dir>
+export LD_LIBRARY_PATH=<vktrace build dir>:<loader dir>
+./vkreplay <options> -t trace_filename
```
Example to replay trace file captured above
```
-export VK_ICD_FILENAMES=/home/jon/main_icd.json
-export LD_LIBRARY_PATH=/home/jon/glave/dbuild:/home/jon/dbuild/loader
-./glvreplay -t glvtrace_cube.glv
-```
-###Running debugger on Linux###
-
-NOTE : Debugger is currently disabled and cannot be built or used.
-
-```
-cd <glave build dir>
-export VK_ICD_FILENAMES=/home/jon/main_icd.json
-export LD_LIBRARY_PATH=/home/jon/dbuild/loader
-./glvdebug
+export VK_ICD_FILENAMES=/home/jon/LoaderAndTools/main_icd.json
+export LD_LIBRARY_PATH=/home/jon/LoaderAndTools/dbuild:/home/jon/LoaderAndTools/dbuild/loader
+./vkreplay -t vktrace_cube.vktrace
```
-##Using Glave on Windows##
-Glave builds three binaries with associated Vulkan libraries: a tracer with Vulkan
-tracing library; a replayer with Vulkan replayer library; and a debugger with
-Vulkan debugger and replayer libraries.
+##Using Vktrace on Windows##
+Vktrace builds two binaries with associated Vulkan libraries: a tracer with Vulkan
+tracing library and a replayer.
-###Running Glave tracer and launch app/game from tracer on Windows###
-The Glave tracer program launches the app/game you desire and then traces it.
-To launch app/game from Glave tracer one must use the "-p" option. Also the
+###Running Vktrace tracer and launch app/game from tracer on Windows###
+The Vktrace tracer program launches the app/game you desire and then traces it.
+To launch app/game from Vktrace tracer one must use the "-p" option. Also the
-l<number> option should be given for specifying the tracing library (zero for Vulkan).
-Also, you may need to copy the Vulkan.dll library into the directory of Glave,
+Also, you may need to copy the Vulkan.dll library into the directory of Vktrace,
and of the app/game (while we continue to put Windows support into place).
```
-cd <glave build dir>
-./glvtrace -p <path-to-app-to-launch> -l0 <path-to-glvtrace_vk-dll> -w <working-dir-path-of-app> <more options>
+cd <vktrace build dir>
+./vktrace -p <path-to-app-to-launch> -w <working-dir-path-of-app> <more options>
```
Example to trace the spinning cube demo (Note: see other files for how to configure your ICD):
```
cd C:\\Users\developer\\Vktrace\\_out64\\Debug
-glvtrace -p C:\\Users\developer\\vulkan\\_out64\\demos\\cube.exe
- -l0 C:\\Users\developer\\vulkan\\_out64\\tools\\glave\\Debug\\glvtrace_xgl.dll
- -w C:\\Users\developer\\vulkan\\_out64\\demos
- -o glvtrace_cube.glv
+vktrace -p C:\\Users\developer\\LoaderAndTools\\_out64\\demos\\cube.exe
+ -w C:\\Users\developer\\LoaderAndTools\\_out64\\demos
+ -o vktrace_cube.vktrace
```
-Trace file is in "glvtrace_cube.glv".
+Trace file is in "vktrace_cube.vktrace".
###Running replayer on Windows###
-The Glave replayer takes a trace file and will launch an Vulkan session based
+The Vktrace replayer takes a trace file and will launch an Vulkan session based
on trace file.
```
-cd <glave build dir>
-glvreplay <options> -t trace_filename
+cd <vktrace build dir>
+vkreplay <options> -t trace_filename
```
Example to replay trace file captured above
```
cd C:\\Users\developer\\Vktrace\\_out64\\Debug
-glvreplay -t glvtrace_cube.glv
-```
-###Running debugger on Windows###
+vkreplay -t vktrace_cube.vktrace
```
-cd <glave build dir>
-glvdebug
-```
-
-##Building Glave##
+##Building Vktrace##
###External dependencies###
* Python 3.4
- Ubuntu package: python3.4-dev
- For Windows, download from: https://www.python.org/downloads.
You must select to install the optional sub-package to add Python to the system PATH environment variable.
-* Qt 5
- - Ubuntu package: qt5-default (only needed for Glave debugger).
- - For Windows, download from: http://www.qt.io/download/. You must select "Qt 5.3" in the installer. This is only needed for the Glave debugger.
###Building on Linux (make)###
-Glave is built as part of top level Vulkan Cmake for project. Follow the
-build directions for the top level Vulkan project build. Glave binaries and
+Vktrace is built as part of top level Vulkan Cmake for project. Follow the
+build directions for the top level Vulkan project build. Vktrace binaries and
libraries will be place in <build_dir>.
-To build Glave project only:
+To build Vktrace project only:
```
-cd tools/glave
-mkdir glv_build
-cd glv_build
+cd vktrace
+mkdir dbuild
+cd dbuild
cmake -DCMAKE_BUILD_TYPE=Debug ..
make
```
###Building on Windows###
```
-cd <glave repo work dir>
+cd <vktrace repo work dir>
mkdir _out64
cd _out64
cmake -G "Visual Studio 12 2013 Win64" ..
###Building on Linux (QtCreator)###
-open tools/glave/CMakeLists.txt with QtCreator
+open vktrace/CMakeLists.txt with QtCreator
For Debug Builds:
Cmake options: -DCMAKE_BUILD_TYPE=Debug -DBUILD_X64=On
-Change build directory from the suggested 'GL-Next/tools/glave-build/' to 'GL-Next/dbuild/tools/glave'
+Change build directory from the suggested 'LoaderAndTools/vktrace-build/' to 'LoaderAndTools/dbuild/vktrace'
For Release Builds:
Cmake Options: -DCMAKE_BUILD_TYPE=Release -DBUILD_X64=On
-Change build directory from the suggested 'GL-Next/tools/glave-build/' to 'GL-Next/build/tools/glave'
+Change build directory from the suggested 'LoaderAndTools/vktrace-build/' to 'LoaderAndTools/dbuild/vktrace'
-Here is a list of all supported features in GLAVE, followed by a TODO list of features that we'd like to add soon in the development process. We've also listed the features that we'd "like to have" in the future, but don't have a short-term plan to implement.
+Here is a list of all supported features in VkTrace, followed by a TODO list of features that we'd like to add soon in the development process. We've also listed the features that we'd "like to have" in the future, but don't have a short-term plan to implement.
Feel Free to vote things up in the lists, attempt to implement them yourself, or add to the list!
* Optimize trace file loading by memory-mapping the file
**SUPPORTED FEATURES IN TRACING/REPLAYING COMMAND LINE TOOLS AND LIBRARIES**
-* Command line Tracer app (glvtrace) which launches game/app with tracing library(ies) inserted and writes trace packets to a file
+* Command line Tracer app (vktrace) which launches game/app with tracing library(ies) inserted and writes trace packets to a file
* Command line Tracer server which collects tracing packets over a socket connection and writes them to a file
* Vulkan tracer library supports multithreaded Vulkan apps
-* Command line Replayer app (glvreplay) replays a Vulkan trace file with Window display on Linux
+* Command line Replayer app (vkreplay) replays a Vulkan trace file with Window display on Linux
**TODO LIST IN TRACING/REPLAYING COMMAND LINE TOOLS AND LIBRARIES**
* Optimize replay speed by using hash maps for opaque handles
#if defined(WIN32)
-#define GLVTRACER_EXPORT __declspec(dllexport)
-#define GLVTRACER_STDCALL __stdcall
-#define GLVTRACER_CDECL __cdecl
-#define GLVTRACER_EXIT void __cdecl
-#define GLVTRACER_ENTRY void
-#define GLVTRACER_LEAVE void
+#define VKTRACER_EXPORT __declspec(dllexport)
+#define VKTRACER_STDCALL __stdcall
+#define VKTRACER_CDECL __cdecl
+#define VKTRACER_EXIT void __cdecl
+#define VKTRACER_ENTRY void
+#define VKTRACER_LEAVE void
#elif defined(PLATFORM_LINUX)
-#define GLVTRACER_EXPORT __attribute__ ((visibility ("default")))
-#define GLVTRACER_STDCALL
-#define GLVTRACER_CDECL
-#define GLVTRACER_EXIT void
-#define GLVTRACER_ENTRY void __attribute__ ((constructor))
-#define GLVTRACER_LEAVE void __attribute__ ((destructor))
+#define VKTRACER_EXPORT __attribute__ ((visibility ("default")))
+#define VKTRACER_STDCALL
+#define VKTRACER_CDECL
+#define VKTRACER_EXIT void
+#define VKTRACER_ENTRY void __attribute__ ((constructor))
+#define VKTRACER_LEAVE void __attribute__ ((destructor))
#endif
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
-Checkpoint* glv_Checkpoint_create(const char* _str)
+Checkpoint* vktrace_Checkpoint_create(const char* _str)
{
- Checkpoint* pCheckpoint = GLV_NEW(Checkpoint);
+ Checkpoint* pCheckpoint = VKTRACE_NEW(Checkpoint);
pCheckpoint->mToken = _str;
pCheckpoint->mTokenLength = strlen(_str) + 1;
return pCheckpoint;
}
// ------------------------------------------------------------------------------------------------
-void glv_Checkpoint_write(Checkpoint* pCheckpoint, FileLike* _out)
+void vktrace_Checkpoint_write(Checkpoint* pCheckpoint, FileLike* _out)
{
- glv_FileLike_Write(_out, pCheckpoint->mToken, pCheckpoint->mTokenLength);
+ vktrace_FileLike_Write(_out, pCheckpoint->mToken, pCheckpoint->mTokenLength);
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_Checkpoint_read(Checkpoint* pCheckpoint, FileLike* _in)
+BOOL vktrace_Checkpoint_read(Checkpoint* pCheckpoint, FileLike* _in)
{
if (pCheckpoint->mTokenLength < 64) {
char buffer[64];
- glv_FileLike_Read(_in, buffer, pCheckpoint->mTokenLength);
+ vktrace_FileLike_Read(_in, buffer, pCheckpoint->mTokenLength);
if (strcmp(buffer, pCheckpoint->mToken) != 0) {
return FALSE;
}
} else {
- char* buffer = GLV_NEW_ARRAY(char, pCheckpoint->mTokenLength);
- glv_FileLike_Read(_in, buffer, pCheckpoint->mTokenLength);
+ char* buffer = VKTRACE_NEW_ARRAY(char, pCheckpoint->mTokenLength);
+ vktrace_FileLike_Read(_in, buffer, pCheckpoint->mTokenLength);
if (strcmp(buffer, pCheckpoint->mToken) != 0) {
- GLV_DELETE(buffer);
+ VKTRACE_DELETE(buffer);
return FALSE;
}
- GLV_DELETE(buffer);
+ VKTRACE_DELETE(buffer);
}
return TRUE;
}
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
-FileLike* glv_FileLike_create_file(FILE* fp)
+FileLike* vktrace_FileLike_create_file(FILE* fp)
{
FileLike* pFile = NULL;
if (fp != NULL)
{
- pFile = GLV_NEW(FileLike);
+ pFile = VKTRACE_NEW(FileLike);
pFile->mMode = File;
pFile->mFile = fp;
pFile->mMessageStream = NULL;
}
// ------------------------------------------------------------------------------------------------
-FileLike* glv_FileLike_create_msg(MessageStream* _msgStream)
+FileLike* vktrace_FileLike_create_msg(MessageStream* _msgStream)
{
FileLike* pFile = NULL;
if (_msgStream != NULL)
{
- pFile = GLV_NEW(FileLike);
+ pFile = VKTRACE_NEW(FileLike);
pFile->mMode = Socket;
pFile->mFile = NULL;
pFile->mMessageStream = _msgStream;
}
// ------------------------------------------------------------------------------------------------
-size_t glv_FileLike_Read(FileLike* pFileLike, void* _bytes, size_t _len)
+size_t vktrace_FileLike_Read(FileLike* pFileLike, void* _bytes, size_t _len)
{
size_t minSize = 0;
size_t bytesInStream = 0;
- if (glv_FileLike_ReadRaw(pFileLike, &bytesInStream, sizeof(bytesInStream)) == FALSE)
+ if (vktrace_FileLike_ReadRaw(pFileLike, &bytesInStream, sizeof(bytesInStream)) == FALSE)
return 0;
minSize = (_len < bytesInStream) ? _len: bytesInStream;
if (bytesInStream > 0) {
assert(_len >= bytesInStream);
- if (glv_FileLike_ReadRaw(pFileLike, _bytes, minSize) == FALSE)
+ if (vktrace_FileLike_ReadRaw(pFileLike, _bytes, minSize) == FALSE)
return 0;
}
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_FileLike_ReadRaw(FileLike* pFileLike, void* _bytes, size_t _len)
+BOOL vktrace_FileLike_ReadRaw(FileLike* pFileLike, void* _bytes, size_t _len)
{
BOOL result = TRUE;
assert((pFileLike->mFile != 0) ^ (pFileLike->mMessageStream != 0));
}
else if (feof(pFileLike->mFile) != 0)
{
- glv_LogWarning("Reached end of file.");
+ vktrace_LogWarning("Reached end of file.");
}
result = FALSE;
}
}
case Socket:
{
- result = glv_MessageStream_BlockingRecv(pFileLike->mMessageStream, _bytes, _len);
+ result = vktrace_MessageStream_BlockingRecv(pFileLike->mMessageStream, _bytes, _len);
break;
}
return result;
}
-void glv_FileLike_Write(FileLike* pFileLike, const void* _bytes, size_t _len)
+void vktrace_FileLike_Write(FileLike* pFileLike, const void* _bytes, size_t _len)
{
- glv_FileLike_WriteRaw(pFileLike, &_len, sizeof(_len));
+ vktrace_FileLike_WriteRaw(pFileLike, &_len, sizeof(_len));
if (_len) {
- glv_FileLike_WriteRaw(pFileLike, _bytes, _len);
+ vktrace_FileLike_WriteRaw(pFileLike, _bytes, _len);
}
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_FileLike_WriteRaw(FileLike* pFile, const void* _bytes, size_t _len)
+BOOL vktrace_FileLike_WriteRaw(FileLike* pFile, const void* _bytes, size_t _len)
{
BOOL result = TRUE;
assert((pFile->mFile != 0) ^ (pFile->mMessageStream != 0));
}
break;
case Socket:
- result = glv_MessageStream_Send(pFile->mMessageStream, _bytes, _len);
+ result = vktrace_MessageStream_Send(pFile->mMessageStream, _bytes, _len);
break;
default:
assert(!"Invalid mode in FileLike_WriteRaw");
size_t mTokenLength;
} Checkpoint;
-Checkpoint* glv_Checkpoint_create(const char* _str);
-void glv_Checkpoint_write(Checkpoint* pCheckpoint, FileLike* _out);
-BOOL glv_Checkpoint_read(Checkpoint* pCheckpoint, FileLike* _in);
+Checkpoint* vktrace_Checkpoint_create(const char* _str);
+void vktrace_Checkpoint_write(Checkpoint* pCheckpoint, FileLike* _out);
+BOOL vktrace_Checkpoint_read(Checkpoint* pCheckpoint, FileLike* _in);
// An interface for interacting with sockets, files, and memory streams with a file-like interface.
// This is a simple file-like interface--it doesn't support rewinding or anything fancy, just fifo
// reads and writes.
// create a filelike interface for file streaming
-FileLike* glv_FileLike_create_file(FILE* fp);
+FileLike* vktrace_FileLike_create_file(FILE* fp);
// create a filelike interface for network streaming
-FileLike* glv_FileLike_create_msg(MessageStream* _msgStream);
+FileLike* vktrace_FileLike_create_msg(MessageStream* _msgStream);
// read a size and then a buffer of that size
-size_t glv_FileLike_Read(FileLike* pFileLike, void* _bytes, size_t _len);
+size_t vktrace_FileLike_Read(FileLike* pFileLike, void* _bytes, size_t _len);
// Normally, Read expects the size to live in the stream prefixing the data to be read.
// With ReadRaw, no size is expected first, and the bytes are directly read.
-BOOL glv_FileLike_ReadRaw(FileLike* pFileLike, void* _bytes, size_t _len);
+BOOL vktrace_FileLike_ReadRaw(FileLike* pFileLike, void* _bytes, size_t _len);
// write _len and then the buffer of size _len
-void glv_FileLike_Write(FileLike* pFileLike, const void* _bytes, size_t _len);
+void vktrace_FileLike_Write(FileLike* pFileLike, const void* _bytes, size_t _len);
// Normally, Write outputs the _len to the stream first--with WriteRaw the bytes are simply written,
// no size parameter first.
-BOOL glv_FileLike_WriteRaw(FileLike* pFile, const void* _bytes, size_t _len);
+BOOL vktrace_FileLike_WriteRaw(FileLike* pFile, const void* _bytes, size_t _len);
const size_t kSendBufferSize = 1024 * 1024;
MessageStream* gMessageStream = NULL;
-static GLV_CRITICAL_SECTION gSendLock;
+static VKTRACE_CRITICAL_SECTION gSendLock;
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// private functions
-BOOL glv_MessageStream_SetupSocket(MessageStream* pStream);
-BOOL glv_MessageStream_SetupHostSocket(MessageStream* pStream);
-BOOL glv_MessageStream_SetupClientSocket(MessageStream* pStream);
-BOOL glv_MessageStream_Handshake(MessageStream* pStream);
-BOOL glv_MessageStream_ReallySend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional);
-void glv_MessageStream_FlushSendBuffer(MessageStream* pStream, BOOL _optional);
+BOOL vktrace_MessageStream_SetupSocket(MessageStream* pStream);
+BOOL vktrace_MessageStream_SetupHostSocket(MessageStream* pStream);
+BOOL vktrace_MessageStream_SetupClientSocket(MessageStream* pStream);
+BOOL vktrace_MessageStream_Handshake(MessageStream* pStream);
+BOOL vktrace_MessageStream_ReallySend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional);
+void vktrace_MessageStream_FlushSendBuffer(MessageStream* pStream, BOOL _optional);
// public functions
-MessageStream* glv_MessageStream_create_port_string(BOOL _isHost, const char* _address, const char* _port)
+MessageStream* vktrace_MessageStream_create_port_string(BOOL _isHost, const char* _address, const char* _port)
{
MessageStream* pStream;
// make sure the strings are shorter than the destination buffer we have to store them!
assert(strlen(_address) + 1 <= 64);
assert(strlen(_port) + 1 <= 8);
- pStream = GLV_NEW(MessageStream);
+ pStream = VKTRACE_NEW(MessageStream);
memcpy(pStream->mAddress, _address, strlen(_address) + 1);
memcpy(pStream->mPort, _port, strlen(_port) + 1);
pStream->mSocket = INVALID_SOCKET;
pStream->mSendBuffer = NULL;
- if (glv_MessageStream_SetupSocket(pStream) == FALSE)
+ if (vktrace_MessageStream_SetupSocket(pStream) == FALSE)
{
- pStream->mErrorNum = GLV_WSAGetLastError();
+ pStream->mErrorNum = VKTRACE_WSAGetLastError();
}
return pStream;
}
-MessageStream* glv_MessageStream_create(BOOL _isHost, const char* _address, unsigned int _port)
+MessageStream* vktrace_MessageStream_create(BOOL _isHost, const char* _address, unsigned int _port)
{
char portBuf[32];
memset(portBuf, 0, 32 * sizeof(char));
sprintf(portBuf, "%u", _port);
- return glv_MessageStream_create_port_string(_isHost, _address, portBuf);
+ return vktrace_MessageStream_create_port_string(_isHost, _address, portBuf);
}
-void glv_MessageStream_destroy(MessageStream** ppStream)
+void vktrace_MessageStream_destroy(MessageStream** ppStream)
{
if ((*ppStream)->mSendBuffer != NULL) {
// Try to get our data out.
- glv_MessageStream_FlushSendBuffer(*ppStream, TRUE);
- glv_SimpleBuffer_destroy(&(*ppStream)->mSendBuffer);
+ vktrace_MessageStream_FlushSendBuffer(*ppStream, TRUE);
+ vktrace_SimpleBuffer_destroy(&(*ppStream)->mSendBuffer);
}
if ((*ppStream)->mHostAddressInfo != NULL)
(*ppStream)->mHostAddressInfo = NULL;
}
- glv_LogDebug("Destroyed socket connection.");
+ vktrace_LogDebug("Destroyed socket connection.");
#if defined(WIN32)
WSACleanup();
#endif
- GLV_DELETE(*ppStream);
+ VKTRACE_DELETE(*ppStream);
(*ppStream) = NULL;
}
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// private function implementations
-BOOL glv_MessageStream_SetupSocket(MessageStream* pStream)
+BOOL vktrace_MessageStream_SetupSocket(MessageStream* pStream)
{
BOOL result = TRUE;
#if defined(WIN32)
#endif
{
if (pStream->mHost) {
- result = glv_MessageStream_SetupHostSocket(pStream);
+ result = vktrace_MessageStream_SetupHostSocket(pStream);
} else {
- result = glv_MessageStream_SetupClientSocket(pStream);
+ result = vktrace_MessageStream_SetupClientSocket(pStream);
}
}
return result;
}
-BOOL glv_MessageStream_SetupHostSocket(MessageStream* pStream)
+BOOL vktrace_MessageStream_SetupHostSocket(MessageStream* pStream)
{
int hr = 0;
#ifdef PLATFORM_LINUX
struct addrinfo hostAddrInfo = { 0 };
SOCKET listenSocket;
- glv_create_critical_section(&gSendLock);
+ vktrace_create_critical_section(&gSendLock);
hostAddrInfo.ai_family = AF_INET;
hostAddrInfo.ai_socktype = SOCK_STREAM;
hostAddrInfo.ai_protocol = IPPROTO_TCP;
hr = getaddrinfo(NULL, pStream->mPort, &hostAddrInfo, &pStream->mHostAddressInfo);
if (hr != 0) {
- glv_LogError("Host: Failed getaddrinfo.");
+ vktrace_LogError("Host: Failed getaddrinfo.");
return FALSE;
}
listenSocket = socket(pStream->mHostAddressInfo->ai_family, pStream->mHostAddressInfo->ai_socktype, pStream->mHostAddressInfo->ai_protocol);
if (listenSocket == INVALID_SOCKET) {
// TODO: Figure out errors
- glv_LogError("Host: Failed creating a listen socket.");
+ vktrace_LogError("Host: Failed creating a listen socket.");
freeaddrinfo(pStream->mHostAddressInfo);
pStream->mHostAddressInfo = NULL;
return FALSE;
#endif
hr = bind(listenSocket, pStream->mHostAddressInfo->ai_addr, (int)pStream->mHostAddressInfo->ai_addrlen);
if (hr == SOCKET_ERROR) {
- glv_LogError("Host: Failed binding socket err=%d.", GLV_WSAGetLastError());
+ vktrace_LogError("Host: Failed binding socket err=%d.", VKTRACE_WSAGetLastError());
freeaddrinfo(pStream->mHostAddressInfo);
pStream->mHostAddressInfo = NULL;
closesocket(listenSocket);
hr = listen(listenSocket, 1);
if (hr == SOCKET_ERROR) {
- glv_LogError("Host: Failed listening on socket err=%d.");
+ vktrace_LogError("Host: Failed listening on socket err=%d.");
closesocket(listenSocket);
return FALSE;
}
// Fo reals.
- glv_LogAlways("Listening for connections on port %s.", pStream->mPort);
+ vktrace_LogAlways("Listening for connections on port %s.", pStream->mPort);
pStream->mSocket = accept(listenSocket, NULL, NULL);
closesocket(listenSocket);
if (pStream->mSocket == INVALID_SOCKET) {
- glv_LogError("Host: Failed accepting socket connection.");
+ vktrace_LogError("Host: Failed accepting socket connection.");
return FALSE;
}
- glv_LogAlways("Connected on port %s.", pStream->mPort);
- if (glv_MessageStream_Handshake(pStream))
+ vktrace_LogAlways("Connected on port %s.", pStream->mPort);
+ if (vktrace_MessageStream_Handshake(pStream))
{
// TODO: The SendBuffer can cause big delays in sending messages back to the client.
// We haven't verified if this improves performance in real applications,
// so disable it for now.
- //pStream->mSendBuffer = glv_SimpleBuffer_create(kSendBufferSize);
+ //pStream->mSendBuffer = vktrace_SimpleBuffer_create(kSendBufferSize);
pStream->mSendBuffer = NULL;
}
else
{
- glv_LogError("glv_MessageStream_SetupHostSocket failed handshake.");
+ vktrace_LogError("vktrace_MessageStream_SetupHostSocket failed handshake.");
}
return TRUE;
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_MessageStream_SetupClientSocket(MessageStream* pStream)
+BOOL vktrace_MessageStream_SetupClientSocket(MessageStream* pStream)
{
int hr = 0;
unsigned int attempt = 0;
BOOL bConnected = FALSE;
struct addrinfo hostAddrInfo = { 0 },
*currentAttempt = NULL;
- glv_create_critical_section(&gSendLock);
+ vktrace_create_critical_section(&gSendLock);
hostAddrInfo.ai_family = AF_UNSPEC;
hostAddrInfo.ai_socktype = SOCK_STREAM;
hostAddrInfo.ai_protocol = IPPROTO_TCP;
hr = getaddrinfo(pStream->mAddress, pStream->mPort, &hostAddrInfo, &pStream->mHostAddressInfo);
if (hr != 0) {
- glv_LogError("Client: Failed getaddrinfo result=%d.", hr);
+ vktrace_LogError("Client: Failed getaddrinfo result=%d.", hr);
return FALSE;
}
hr = connect(pStream->mSocket, currentAttempt->ai_addr, (int)currentAttempt->ai_addrlen);
if (hr == SOCKET_ERROR)
{
- glv_LogVerbose("Client: Failed connect. Possibly non-fatal.");
+ vktrace_LogVerbose("Client: Failed connect. Possibly non-fatal.");
closesocket(pStream->mSocket);
pStream->mSocket = INVALID_SOCKET;
continue;
if (!bConnected)
{
Sleep(1);
- glv_LogVerbose("Client: Connect attempt %u on port %s failed, trying again.", attempt, pStream->mPort);
+ vktrace_LogVerbose("Client: Connect attempt %u on port %s failed, trying again.", attempt, pStream->mPort);
}
else
{
- glv_LogVerbose("Client: Connected to port %s successfully.", pStream->mPort);
+ vktrace_LogVerbose("Client: Connected to port %s successfully.", pStream->mPort);
}
}
pStream->mHostAddressInfo = NULL;
if (pStream->mSocket == INVALID_SOCKET) {
- glv_LogError("Client: Couldn't find any connections.");
+ vktrace_LogError("Client: Couldn't find any connections.");
return FALSE;
}
- if (!glv_MessageStream_Handshake(pStream))
+ if (!vktrace_MessageStream_Handshake(pStream))
{
- glv_LogError("Client: Failed handshake with host.");
+ vktrace_LogError("Client: Failed handshake with host.");
return FALSE;
}
return TRUE;
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_MessageStream_Handshake(MessageStream* pStream)
+BOOL vktrace_MessageStream_Handshake(MessageStream* pStream)
{
BOOL result = TRUE;
- FileLike* fileLike = glv_FileLike_create_msg(pStream);
- Checkpoint* syn = glv_Checkpoint_create("It's a trap!");
- Checkpoint* ack = glv_Checkpoint_create(" - Admiral Ackbar");
+ FileLike* fileLike = vktrace_FileLike_create_msg(pStream);
+ Checkpoint* syn = vktrace_Checkpoint_create("It's a trap!");
+ Checkpoint* ack = vktrace_Checkpoint_create(" - Admiral Ackbar");
if (pStream->mHost) {
- glv_Checkpoint_write(syn, fileLike);
- result = glv_Checkpoint_read(ack, fileLike);
+ vktrace_Checkpoint_write(syn, fileLike);
+ result = vktrace_Checkpoint_read(ack, fileLike);
} else {
- if (glv_Checkpoint_read(syn, fileLike))
+ if (vktrace_Checkpoint_read(syn, fileLike))
{
- glv_Checkpoint_write(ack, fileLike);
+ vktrace_Checkpoint_write(ack, fileLike);
}
else
{
#endif
}
- GLV_DELETE(syn);
- GLV_DELETE(ack);
- GLV_DELETE(fileLike);
+ VKTRACE_DELETE(syn);
+ VKTRACE_DELETE(ack);
+ VKTRACE_DELETE(fileLike);
return result;
}
// ------------------------------------------------------------------------------------------------
-void glv_MessageStream_FlushSendBuffer(MessageStream* pStream, BOOL _optional)
+void vktrace_MessageStream_FlushSendBuffer(MessageStream* pStream, BOOL _optional)
{
size_t bufferedByteSize = 0;
- const void* bufferBytes = glv_SimpleBuffer_GetBytes(pStream->mSendBuffer, &bufferedByteSize);
+ const void* bufferBytes = vktrace_SimpleBuffer_GetBytes(pStream->mSendBuffer, &bufferedByteSize);
if (bufferedByteSize > 0) {
// TODO use return value from ReallySend
- glv_MessageStream_ReallySend(pStream, bufferBytes, bufferedByteSize, _optional);
- glv_SimpleBuffer_EmptyBuffer(pStream->mSendBuffer);
+ vktrace_MessageStream_ReallySend(pStream, bufferBytes, bufferedByteSize, _optional);
+ vktrace_SimpleBuffer_EmptyBuffer(pStream->mSendBuffer);
}
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_MessageStream_BufferedSend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional)
+BOOL vktrace_MessageStream_BufferedSend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional)
{
BOOL result = TRUE;
if (pStream->mSendBuffer == NULL) {
- result = glv_MessageStream_ReallySend(pStream, _bytes, _size, _optional);
+ result = vktrace_MessageStream_ReallySend(pStream, _bytes, _size, _optional);
}
else
{
- if (!glv_SimpleBuffer_WouldOverflow(pStream->mSendBuffer, _size)) {
- result = glv_SimpleBuffer_AddBytes(pStream->mSendBuffer, _bytes, _size);
+ if (!vktrace_SimpleBuffer_WouldOverflow(pStream->mSendBuffer, _size)) {
+ result = vktrace_SimpleBuffer_AddBytes(pStream->mSendBuffer, _bytes, _size);
} else {
// Time to flush the cache.
- glv_MessageStream_FlushSendBuffer(pStream, FALSE);
+ vktrace_MessageStream_FlushSendBuffer(pStream, FALSE);
// Check to see if the packet is larger than the send buffer
- if (glv_SimpleBuffer_WouldOverflow(pStream->mSendBuffer, _size)) {
- result = glv_MessageStream_ReallySend(pStream, _bytes, _size, _optional);
+ if (vktrace_SimpleBuffer_WouldOverflow(pStream->mSendBuffer, _size)) {
+ result = vktrace_MessageStream_ReallySend(pStream, _bytes, _size, _optional);
} else {
- result = glv_SimpleBuffer_AddBytes(pStream->mSendBuffer, _bytes, _size);
+ result = vktrace_SimpleBuffer_AddBytes(pStream->mSendBuffer, _bytes, _size);
}
}
}
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_MessageStream_Send(MessageStream* pStream, const void* _bytes, size_t _len)
+BOOL vktrace_MessageStream_Send(MessageStream* pStream, const void* _bytes, size_t _len)
{
- return glv_MessageStream_BufferedSend(pStream, _bytes, _len, FALSE);
+ return vktrace_MessageStream_BufferedSend(pStream, _bytes, _len, FALSE);
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_MessageStream_ReallySend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional)
+BOOL vktrace_MessageStream_ReallySend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional)
{
size_t bytesSent = 0;
assert(_size > 0);
- glv_enter_critical_section(&gSendLock);
+ vktrace_enter_critical_section(&gSendLock);
do {
int sentThisTime = send(pStream->mSocket, (const char*)_bytes + bytesSent, (int)_size - (int)bytesSent, 0);
if (sentThisTime == SOCKET_ERROR) {
- int socketError = GLV_WSAGetLastError();
+ int socketError = VKTRACE_WSAGetLastError();
if (socketError == WSAEWOULDBLOCK) {
// Try again. Don't sleep, because that nukes performance from orbit.
continue;
}
if (!_optional) {
- glv_leave_critical_section(&gSendLock);
+ vktrace_leave_critical_section(&gSendLock);
return FALSE;
}
}
if (sentThisTime == 0) {
if (!_optional) {
- glv_leave_critical_section(&gSendLock);
+ vktrace_leave_critical_section(&gSendLock);
return FALSE;
}
- glv_LogDebug("Send on socket 0 bytes, totalbytes sent so far %u.", bytesSent);
+ vktrace_LogDebug("Send on socket 0 bytes, totalbytes sent so far %u.", bytesSent);
break;
}
bytesSent += sentThisTime;
} while (bytesSent < _size);
- glv_leave_critical_section(&gSendLock);
+ vktrace_leave_critical_section(&gSendLock);
return TRUE;
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_MessageStream_Recv(MessageStream* pStream, void* _out, size_t _len)
+BOOL vktrace_MessageStream_Recv(MessageStream* pStream, void* _out, size_t _len)
{
unsigned int totalDataRead = 0;
do {
int dataRead = recv(pStream->mSocket, ((char*)_out) + totalDataRead, (int)_len - totalDataRead, 0);
if (dataRead == SOCKET_ERROR) {
- pStream->mErrorNum = GLV_WSAGetLastError();
+ pStream->mErrorNum = VKTRACE_WSAGetLastError();
if (pStream->mErrorNum == WSAEWOULDBLOCK || pStream->mErrorNum == EAGAIN) {
if (totalDataRead == 0) {
return FALSE;
} else {
// I don't do partial reads--once I start receiving I wait for everything.
- //glv_LogDebug("Sleep on partial socket recv (%u bytes / %u), error num %d.", totalDataRead, _len, pStream->mErrorNum);
+ //vktrace_LogDebug("Sleep on partial socket recv (%u bytes / %u), error num %d.", totalDataRead, _len, pStream->mErrorNum);
Sleep(1);
}
// I've split these into two blocks because one of them is expected and the other isn't.
} else if (pStream->mErrorNum == WSAECONNRESET) {
// The remote client disconnected, probably not an issue.
- //glv_LogDebug("Connection was reset by client.");
+ //vktrace_LogDebug("Connection was reset by client.");
return FALSE;
} else {
// Some other wonky network error--place a breakpoint here.
- glv_LogError("Unexpected error (%d) while receiving message stream.", pStream->mErrorNum);
+ vktrace_LogError("Unexpected error (%d) while receiving message stream.", pStream->mErrorNum);
return FALSE;
}
} else {
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_MessageStream_BlockingRecv(MessageStream* pStream, void* _outBuffer, size_t _len)
+BOOL vktrace_MessageStream_BlockingRecv(MessageStream* pStream, void* _outBuffer, size_t _len)
{
- while (!glv_MessageStream_Recv(pStream, _outBuffer, _len)) {
+ while (!vktrace_MessageStream_Recv(pStream, _outBuffer, _len)) {
Sleep(1);
}
return TRUE;
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
-SimpleBuffer* glv_SimpleBuffer_create(size_t _bufferSize)
+SimpleBuffer* vktrace_SimpleBuffer_create(size_t _bufferSize)
{
- SimpleBuffer* pBuffer = GLV_NEW(SimpleBuffer);
- pBuffer->mBuffer = (unsigned char*)glv_malloc(_bufferSize);
+ SimpleBuffer* pBuffer = VKTRACE_NEW(SimpleBuffer);
+ pBuffer->mBuffer = (unsigned char*)vktrace_malloc(_bufferSize);
if (pBuffer->mBuffer == NULL)
{
- GLV_DELETE(pBuffer);
+ VKTRACE_DELETE(pBuffer);
return NULL;
}
return pBuffer;
}
-void glv_SimpleBuffer_destroy(SimpleBuffer** ppBuffer)
+void vktrace_SimpleBuffer_destroy(SimpleBuffer** ppBuffer)
{
- glv_free((*ppBuffer)->mBuffer);
- GLV_DELETE(*ppBuffer);
+ vktrace_free((*ppBuffer)->mBuffer);
+ VKTRACE_DELETE(*ppBuffer);
}
-BOOL glv_SimpleBuffer_AddBytes(SimpleBuffer* pBuffer, const void* _bytes, size_t _size)
+BOOL vktrace_SimpleBuffer_AddBytes(SimpleBuffer* pBuffer, const void* _bytes, size_t _size)
{
- if (glv_SimpleBuffer_WouldOverflow(pBuffer, _size))
+ if (vktrace_SimpleBuffer_WouldOverflow(pBuffer, _size))
{
return FALSE;
}
return TRUE;
}
-void glv_SimpleBuffer_EmptyBuffer(SimpleBuffer* pBuffer)
+void vktrace_SimpleBuffer_EmptyBuffer(SimpleBuffer* pBuffer)
{
pBuffer->mEnd = 0;
}
-BOOL glv_SimpleBuffer_WouldOverflow(SimpleBuffer* pBuffer, size_t _requestedSize)
+BOOL vktrace_SimpleBuffer_WouldOverflow(SimpleBuffer* pBuffer, size_t _requestedSize)
{
return pBuffer->mEnd + _requestedSize > pBuffer->mSize;
}
-const void* glv_SimpleBuffer_GetBytes(SimpleBuffer* pBuffer, size_t* _outByteCount)
+const void* vktrace_SimpleBuffer_GetBytes(SimpleBuffer* pBuffer, size_t* _outByteCount)
{
(*_outByteCount) = pBuffer->mEnd;
return pBuffer->mBuffer;
#define INVALID_SOCKET 0
#define SOCKET_ERROR -1
#define closesocket close
- #define GLV_WSAGetLastError() errno
+ #define VKTRACE_WSAGetLastError() errno
#define WSAEWOULDBLOCK EWOULDBLOCK
#define WSAEAGAIN EAGAIN
#define WSAECONNRESET ECONNRESET
#include <WinSock2.h>
#include <WS2tcpip.h>
#pragma comment (lib, "Ws2_32.lib")
- #define GLV_WSAGetLastError() WSAGetLastError()
+ #define VKTRACE_WSAGetLastError() WSAGetLastError()
#endif
-static const unsigned int GLV_BASE_PORT = 34199;
+static const unsigned int VKTRACE_BASE_PORT = 34199;
struct SSerializeDataPacket;
struct SimpleBuffer;
int mErrorNum;
} MessageStream;
-MessageStream* glv_MessageStream_create_port_string(BOOL _isHost, const char* _address, const char* _port);
-MessageStream* glv_MessageStream_create(BOOL _isHost, const char* _address, unsigned int _port);
-void glv_MessageStream_destroy(MessageStream** ppStream);
-BOOL glv_MessageStream_BufferedSend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional);
-BOOL glv_MessageStream_Send(MessageStream* pStream, const void* _bytes, size_t _len);
+MessageStream* vktrace_MessageStream_create_port_string(BOOL _isHost, const char* _address, const char* _port);
+MessageStream* vktrace_MessageStream_create(BOOL _isHost, const char* _address, unsigned int _port);
+void vktrace_MessageStream_destroy(MessageStream** ppStream);
+BOOL vktrace_MessageStream_BufferedSend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional);
+BOOL vktrace_MessageStream_Send(MessageStream* pStream, const void* _bytes, size_t _len);
-BOOL glv_MessageStream_Recv(MessageStream* pStream, void* _out, size_t _len);
-BOOL glv_MessageStream_BlockingRecv(MessageStream* pStream, void* _outBuffer, size_t _len);
+BOOL vktrace_MessageStream_Recv(MessageStream* pStream, void* _out, size_t _len);
+BOOL vktrace_MessageStream_BlockingRecv(MessageStream* pStream, void* _outBuffer, size_t _len);
extern MessageStream* gMessageStream;
size_t mSize;
} SimpleBuffer;
-SimpleBuffer* glv_SimpleBuffer_create(size_t _bufferSize);
-void glv_SimpleBuffer_destroy(SimpleBuffer** ppBuffer);
-BOOL glv_SimpleBuffer_AddBytes(SimpleBuffer* pBuffer, const void* _bytes, size_t _size);
-void glv_SimpleBuffer_EmptyBuffer(SimpleBuffer* pBuffer);
-BOOL glv_SimpleBuffer_WouldOverflow(SimpleBuffer* pBuffer, size_t _requestedSize);
-const void* glv_SimpleBuffer_GetBytes(SimpleBuffer* pBuffer, size_t* _outByteCount);
+SimpleBuffer* vktrace_SimpleBuffer_create(size_t _bufferSize);
+void vktrace_SimpleBuffer_destroy(SimpleBuffer** ppBuffer);
+BOOL vktrace_SimpleBuffer_AddBytes(SimpleBuffer* pBuffer, const void* _bytes, size_t _size);
+void vktrace_SimpleBuffer_EmptyBuffer(SimpleBuffer* pBuffer);
+BOOL vktrace_SimpleBuffer_WouldOverflow(SimpleBuffer* pBuffer, size_t _requestedSize);
+const void* vktrace_SimpleBuffer_GetBytes(SimpleBuffer* pBuffer, size_t* _outByteCount);
#include <string.h>
#include <stdarg.h>
-#define GLV_NEW(type) (type*)glv_malloc(sizeof(type))
-#define GLV_NEW_ARRAY(type, count) (type*)glv_malloc(sizeof(type)*count)
-#define GLV_DELETE(ptr) glv_free(ptr);
-#define GLV_REALLOC(ptr, size) glv_realloc(ptr, size);
+#define VKTRACE_NEW(type) (type*)vktrace_malloc(sizeof(type))
+#define VKTRACE_NEW_ARRAY(type, count) (type*)vktrace_malloc(sizeof(type)*count)
+#define VKTRACE_DELETE(ptr) vktrace_free(ptr);
+#define VKTRACE_REALLOC(ptr, size) vktrace_realloc(ptr, size);
-static void* glv_malloc(size_t size)
+static void* vktrace_malloc(size_t size)
{
void* pMem;
if (size == 0)
return pMem;
}
-static void glv_free(void* ptr)
+static void vktrace_free(void* ptr)
{
free(ptr);
ptr = NULL;
}
-static void * glv_realloc(void *ptr,size_t size)
+static void * vktrace_realloc(void *ptr,size_t size)
{
void *pMem;
if (size == 0)
return pMem;
}
-static char* glv_allocate_and_copy(const char* _src)
+static char* vktrace_allocate_and_copy(const char* _src)
{
if (_src == NULL)
{
{
size_t bufferSize = 1 + strlen(_src);
- char* retVal = GLV_NEW_ARRAY(char, bufferSize);
+ char* retVal = VKTRACE_NEW_ARRAY(char, bufferSize);
#ifdef WIN32
strcpy_s(retVal, bufferSize, _src);
#else // linux
}
}
-static char* glv_allocate_and_copy_n(const char* _src, int _count)
+static char* vktrace_allocate_and_copy_n(const char* _src, int _count)
{
size_t bufferSize = 1 + _count;
- char* retVal = GLV_NEW_ARRAY(char, bufferSize);
+ char* retVal = VKTRACE_NEW_ARRAY(char, bufferSize);
#ifdef WIN32
strncpy_s(retVal, bufferSize, _src, _count);
return retVal;
}
-static char* glv_copy_and_append(const char* pBaseString, const char* pSeparator, const char* pAppendString)
+static char* vktrace_copy_and_append(const char* pBaseString, const char* pSeparator, const char* pAppendString)
{
size_t baseSize = (pBaseString != NULL) ? strlen(pBaseString) : 0;
size_t separatorSize = ((pAppendString != NULL) && strlen(pAppendString) && (pSeparator != NULL)) ?
strlen(pSeparator) : 0;
size_t appendSize = (pAppendString != NULL) ? strlen(pAppendString) : 0;
size_t bufferSize = baseSize + separatorSize + appendSize + 1;
- char* retVal = GLV_NEW_ARRAY(char, bufferSize);
+ char* retVal = VKTRACE_NEW_ARRAY(char, bufferSize);
if (retVal != NULL)
{
#ifdef WIN32
return retVal;
}
-static char* glv_copy_and_append_args(const char* pBaseString, const char* pSeparator, const char* pAppendFormat, va_list args)
+static char* vktrace_copy_and_append_args(const char* pBaseString, const char* pSeparator, const char* pAppendFormat, va_list args)
{
size_t baseSize = (pBaseString != NULL) ? strlen(pBaseString) : 0;
size_t separatorSize = (pSeparator != NULL) ? strlen(pSeparator) : 0;
#endif
bufferSize = baseSize + separatorSize + appendSize + 1;
- retVal = GLV_NEW_ARRAY(char, bufferSize);
+ retVal = VKTRACE_NEW_ARRAY(char, bufferSize);
if (retVal != NULL)
{
#ifdef WIN32
#include "vktrace_tracelog.h"
#include <stdio.h>
-#define GLV_MHOOK_SETHOOK(entrypoint) Mhook_SetHook((PVOID*)&real_##entrypoint, hooked_##entrypoint); \
- if (hookSuccess == FALSE) { glv_LogError("Failed to hook " #entrypoint); }
+#define VKTRACE_MHOOK_SETHOOK(entrypoint) Mhook_SetHook((PVOID*)&real_##entrypoint, hooked_##entrypoint); \
+ if (hookSuccess == FALSE) { vktrace_LogError("Failed to hook " #entrypoint); }
-#define GLV_MHOOK_UNHOOK(entrypoint) Mhook_Unhook((PVOID*)&real_##entrypoint); \
+#define VKTRACE_MHOOK_UNHOOK(entrypoint) Mhook_Unhook((PVOID*)&real_##entrypoint); \
if (unhookSuccess == FALSE) { printf("Failed to unhook " #entrypoint "\n"); }
#include <pthread.h>
#endif
-glv_process_id glv_get_pid()
+vktrace_process_id vktrace_get_pid()
{
#if defined(PLATFORM_LINUX)
return getpid();
#endif
}
-char* glv_platform_get_current_executable_directory()
+char* vktrace_platform_get_current_executable_directory()
{
- char* exePath = (char*)glv_malloc(_MAX_PATH);
+ char* exePath = (char*)vktrace_malloc(_MAX_PATH);
#if defined(WIN32)
DWORD s = GetModuleFileName(NULL, exePath, MAX_PATH);
#elif defined(PLATFORM_LINUX)
if (s <= 0)
{
- assert(!"Unexpected path returned in glv_platform_get_current_executable_directory");
- glv_free(exePath);
+ assert(!"Unexpected path returned in vktrace_platform_get_current_executable_directory");
+ vktrace_free(exePath);
exePath = NULL;
}
return exePath;
}
-BOOL glv_is_loaded_into_glvtrace()
+BOOL vktrace_is_loaded_into_vktrace()
{
char exePath[_MAX_PATH];
#if defined(WIN32)
- char* substr = ((sizeof(void*) == 4)? "glvtrace32.exe" : "glvtrace.exe");
+ char* substr = ((sizeof(void*) == 4)? "vktrace32.exe" : "vktrace.exe");
GetModuleFileName(NULL, exePath, MAX_PATH);
#elif defined(PLATFORM_LINUX)
- char* substr = ((sizeof(void*) == 4)? "glvtrace32" : "glvtrace");
+ char* substr = ((sizeof(void*) == 4)? "vktrace32" : "vktrace");
ssize_t s = readlink("/proc/self/exe", exePath, _MAX_PATH);
if (s >= 0)
{
return (strstr(exePath, substr) != NULL);
}
-BOOL glv_platform_get_next_lib_sym(void * *ppFunc, const char * name)
+BOOL vktrace_platform_get_next_lib_sym(void * *ppFunc, const char * name)
{
#if defined(PLATFORM_LINUX)
if ((*ppFunc = dlsym(RTLD_NEXT, name)) == NULL) {
- glv_LogError("dlsym: failed to find symbol %s %s", name, dlerror());
+ vktrace_LogError("dlsym: failed to find symbol %s %s", name, dlerror());
return FALSE;
}
#elif defined(WIN32)
- glv_LogError("unimplemented");
+ vktrace_LogError("unimplemented");
assert(0);
return FALSE;
#endif
return TRUE;
}
-glv_thread_id glv_platform_get_thread_id()
+vktrace_thread_id vktrace_platform_get_thread_id()
{
#if defined(PLATFORM_LINUX)
- //return (glv_thread_id)syscall(SYS_gettid);
+ //return (vktrace_thread_id)syscall(SYS_gettid);
return pthread_self();
#elif defined(WIN32)
return GetCurrentThreadId();
#endif
}
-char *glv_get_global_var(const char *name)
+char *vktrace_get_global_var(const char *name)
{
#if defined(PLATFORM_LINUX)
return getenv(name);
#endif
}
-void glv_set_global_var(const char *name, const char *val)
+void vktrace_set_global_var(const char *name, const char *val)
{
#if defined(PLATFORM_LINUX)
setenv(name, val, 1);
#endif
}
-size_t glv_platform_rand_s(uint32_t* out_array, size_t out_array_length)
+size_t vktrace_platform_rand_s(uint32_t* out_array, size_t out_array_length)
{
#if defined(PLATFORM_LINUX)
static __thread unsigned int s_seed = 0;
{
struct timeval time;
gettimeofday(&time, NULL);
- s_seed = glv_platform_get_thread_id() ^ ((time.tv_sec * 1000) + (time.tv_usec / 1000));
+ s_seed = vktrace_platform_get_thread_id() ^ ((time.tv_sec * 1000) + (time.tv_usec / 1000));
}
}
return out_array_length;
#elif defined(WIN32)
- //GLV_ASSUME(sizeof(uint32_t) == sizeof(unsigned int));
+ //VKTRACE_ASSUME(sizeof(uint32_t) == sizeof(unsigned int));
size_t ret_values = 0;
for (ret_values = 0; ret_values < out_array_length; ++ret_values)
#endif
}
-void * glv_platform_open_library(const char* libPath)
+void * vktrace_platform_open_library(const char* libPath)
{
#if defined(WIN32)
return LoadLibrary(libPath);
#endif
}
-void * glv_platform_get_library_entrypoint(void * libHandle, const char *name)
+void * vktrace_platform_get_library_entrypoint(void * libHandle, const char *name)
{
#ifdef WIN32
FARPROC proc = GetProcAddress((HMODULE)libHandle, name);
if (!proc)
- glv_LogError("Failed to find symbol %s in library handle %p", name, libHandle);
+ vktrace_LogError("Failed to find symbol %s in library handle %p", name, libHandle);
#else
void * proc = dlsym(libHandle, name);
if (!proc)
- glv_LogError("Failed to find symbol %s in library handle %p, dlerror: %s", name, libHandle, dlerror());
+ vktrace_LogError("Failed to find symbol %s in library handle %p, dlerror: %s", name, libHandle, dlerror());
#endif
return proc;
}
-void glv_platform_close_library(void* pLibrary)
+void vktrace_platform_close_library(void* pLibrary)
{
#if defined(WIN32)
FreeLibrary((HMODULE)pLibrary);
#endif
}
-void glv_platform_full_path(const char* partPath, unsigned long bytes, char* buffer)
+void vktrace_platform_full_path(const char* partPath, unsigned long bytes, char* buffer)
{
assert(buffer != NULL);
#if defined(WIN32)
#endif
}
-char* glv_platform_extract_path(char* _path)
+char* vktrace_platform_extract_path(char* _path)
{
// These functions actually work on const strings, but the C decl version exposed by the macro
// takes non-const TCHAR*.
if (lastPathSep == NULL)
{
- return glv_allocate_and_copy(".\\");
+ return vktrace_allocate_and_copy(".\\");
}
- pDir = GLV_NEW_ARRAY(char, strlen(_path) + 1);
+ pDir = VKTRACE_NEW_ARRAY(char, strlen(_path) + 1);
newLen = strlen(_path) - strlen(lastPathSep);
strncpy(pDir, _path, newLen);
pDir[newLen] = '\0';
// The following linux paths are based on:
// standards.freedesktop.org/basedir-spec/basedir-spec-0.8.html
-char* glv_platform_get_settings_path()
+char* vktrace_platform_get_settings_path()
{
#if defined(__linux__)
char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
if (xdgConfigHome != NULL && strlen(xdgConfigHome) > 0)
{
- return glv_copy_and_append(xdgConfigHome, GLV_PATH_SEPARATOR, "glave");
+ return vktrace_copy_and_append(xdgConfigHome, VKTRACE_PATH_SEPARATOR, "vktrace");
}
else
{
- return glv_copy_and_append(getenv("HOME"), GLV_PATH_SEPARATOR, ".config/glave");
+ return vktrace_copy_and_append(getenv("HOME"), VKTRACE_PATH_SEPARATOR, ".config/vktrace");
}
#elif defined(WIN32)
DWORD reqLength = GetEnvironmentVariable("localappdata", NULL, 0);
- TCHAR* localAppData = GLV_NEW_ARRAY(TCHAR*, reqLength);
+ TCHAR* localAppData = VKTRACE_NEW_ARRAY(TCHAR*, reqLength);
GetEnvironmentVariable("localappdata", localAppData, reqLength);
- TCHAR* localGlaveData = glv_copy_and_append(localAppData, GLV_PATH_SEPARATOR, "glave");
- GLV_DELETE(localAppData);
- return localGlaveData;
+ TCHAR* localVktraceData = vktrace_copy_and_append(localAppData, VKTRACE_PATH_SEPARATOR, "vktrace");
+ VKTRACE_DELETE(localAppData);
+ return localVktraceData;
#else
assert(!"not implemented");
#endif
}
-char* glv_platform_get_data_path()
+char* vktrace_platform_get_data_path()
{
#if defined(__linux__)
char* xdgDataHome = getenv("XDG_DATA_HOME");
if (xdgDataHome != NULL && strlen(xdgDataHome) > 0)
{
- return glv_copy_and_append(xdgDataHome, GLV_PATH_SEPARATOR, "glave");
+ return vktrace_copy_and_append(xdgDataHome, VKTRACE_PATH_SEPARATOR, "vktrace");
}
else
{
- return glv_copy_and_append(getenv("HOME"), GLV_PATH_SEPARATOR, ".local/share/glave");
+ return vktrace_copy_and_append(getenv("HOME"), VKTRACE_PATH_SEPARATOR, ".local/share/vktrace");
}
#elif defined(WIN32)
DWORD reqLength = GetEnvironmentVariable("localappdata", NULL, 0);
- TCHAR* localAppData = GLV_NEW_ARRAY(TCHAR*, reqLength);
+ TCHAR* localAppData = VKTRACE_NEW_ARRAY(TCHAR*, reqLength);
GetEnvironmentVariable("localappdata", localAppData, reqLength);
- TCHAR* localGlaveData = glv_copy_and_append(localAppData, GLV_PATH_SEPARATOR, "glave");
- GLV_DELETE(localAppData);
- return localGlaveData;
+ TCHAR* localVktraceData = vktrace_copy_and_append(localAppData, VKTRACE_PATH_SEPARATOR, "vktrace");
+ VKTRACE_DELETE(localAppData);
+ return localVktraceData;
#else
assert(!"not implemented");
#endif
}
-glv_thread glv_platform_create_thread(GLV_THREAD_ROUTINE_RETURN_TYPE(*start_routine)(LPVOID), void* args)
+vktrace_thread vktrace_platform_create_thread(VKTRACE_THREAD_ROUTINE_RETURN_TYPE(*start_routine)(LPVOID), void* args)
{
#if defined(PLATFORM_LINUX)
- glv_thread thread = 0;
+ vktrace_thread thread = 0;
if(pthread_create(&thread, NULL, (void *(*) (void*)) start_routine, args) != 0)
{
- glv_LogError("Failed to create thread");
+ vktrace_LogError("Failed to create thread");
}
return thread;
#elif defined(WIN32)
#endif
}
-void glv_platform_resume_thread(glv_thread* pThread)
+void vktrace_platform_resume_thread(vktrace_thread* pThread)
{
assert(pThread != NULL);
#if defined(PLATFORM_LINUX)
#endif
}
-void glv_platform_sync_wait_for_thread(glv_thread* pThread)
+void vktrace_platform_sync_wait_for_thread(vktrace_thread* pThread)
{
assert(pThread != NULL);
#if defined(PLATFORM_LINUX)
if (WaitForSingleObject(*pThread, INFINITE) != WAIT_OBJECT_0)
#endif
{
- glv_LogError("Error occurred while waiting for thread to end.");
+ vktrace_LogError("Error occurred while waiting for thread to end.");
}
}
-void glv_platform_delete_thread(glv_thread* pThread)
+void vktrace_platform_delete_thread(vktrace_thread* pThread)
{
assert(pThread != NULL);
#if defined(PLATFORM_LINUX)
#endif
}
-void glv_platform_thread_once(void *ctl, void (* func) (void))
+void vktrace_platform_thread_once(void *ctl, void (* func) (void))
{
assert(func != NULL);
assert(ctl != NULL);
#endif
}
-void glv_create_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+void vktrace_create_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection)
{
#if defined(WIN32)
InitializeCriticalSection(pCriticalSection);
#endif
}
-void glv_enter_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+void vktrace_enter_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection)
{
#if defined(WIN32)
EnterCriticalSection(pCriticalSection);
#endif
}
-void glv_leave_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+void vktrace_leave_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection)
{
#if defined(WIN32)
LeaveCriticalSection(pCriticalSection);
#endif
}
-void glv_delete_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+void vktrace_delete_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection)
{
#if defined(WIN32)
DeleteCriticalSection(pCriticalSection);
#endif
}
-BOOL glv_platform_remote_load_library(glv_process_handle pProcessHandle, const char* dllPath, glv_thread* pTracingThread, char ** ldPreload)
+BOOL vktrace_platform_remote_load_library(vktrace_process_handle pProcessHandle, const char* dllPath, vktrace_thread* pTracingThread, char ** ldPreload)
{
#if defined(WIN32)
SIZE_T bytesWritten = 0;
void* targetProcessMem = NULL;
- glv_thread thread = NULL;
+ vktrace_thread thread = NULL;
size_t byteCount = sizeof(char) * (strlen(dllPath) + 1);
targetProcessMem = VirtualAllocEx(pProcessHandle, 0, byteCount, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!targetProcessMem)
{
- glv_LogError("Failed to inject ourselves into target process--couldn't allocate process memory.");
+ vktrace_LogError("Failed to inject ourselves into target process--couldn't allocate process memory.");
return FALSE;
}
if (!WriteProcessMemory(pProcessHandle, targetProcessMem, dllPath, byteCount, &bytesWritten))
{
- glv_LogError("Failed to inject ourselves into target process--couldn't write inception DLL name into process.");
+ vktrace_LogError("Failed to inject ourselves into target process--couldn't write inception DLL name into process.");
return FALSE;
}
thread = CreateRemoteThread(pProcessHandle, NULL, 0, (LPTHREAD_START_ROUTINE)LoadLibrary, targetProcessMem, 0, NULL);
if (thread == NULL)
{
- glv_LogError("Failed to inject ourselves into target process--couldn't spawn thread.");
+ vktrace_LogError("Failed to inject ourselves into target process--couldn't spawn thread.");
return FALSE;
}
assert(pTracingThread != NULL);
char *tmp;
if (*ldPreload == NULL)
{
- tmp = glv_copy_and_append("LD_PRELOAD", "=", dllPath);
+ tmp = vktrace_copy_and_append("LD_PRELOAD", "=", dllPath);
}
else
{
- tmp = glv_copy_and_append(*ldPreload, " ", dllPath);
- GLV_DELETE((void*)*ldPreload);
+ tmp = vktrace_copy_and_append(*ldPreload, " ", dllPath);
+ VKTRACE_DELETE((void*)*ldPreload);
}
*ldPreload = tmp;
#endif
#include "wintypes.h"
#define APIENTRY
#define Sleep(n) usleep(n * 1000)
-#define GLV_WINAPI
-typedef pthread_t glv_thread;
-typedef pid_t glv_process_handle;
-typedef pid_t glv_thread_id;
-typedef pid_t glv_process_id;
-typedef unsigned int GLV_THREAD_ROUTINE_RETURN_TYPE;
-typedef pthread_mutex_t GLV_CRITICAL_SECTION;
-#define GLV_NULL_THREAD 0
+#define VKTRACE_WINAPI
+typedef pthread_t vktrace_thread;
+typedef pid_t vktrace_process_handle;
+typedef pid_t vktrace_thread_id;
+typedef pid_t vktrace_process_id;
+typedef unsigned int VKTRACE_THREAD_ROUTINE_RETURN_TYPE;
+typedef pthread_mutex_t VKTRACE_CRITICAL_SECTION;
+#define VKTRACE_NULL_THREAD 0
#define _MAX_PATH PATH_MAX
-#define GLV_PATH_SEPARATOR "/"
-#define GLV_THREAD_LOCAL __thread
+#define VKTRACE_PATH_SEPARATOR "/"
+#define VKTRACE_THREAD_LOCAL __thread
#elif defined(WIN32)
#define _CRT_RAND_S
#define NOMINMAX
#include <Windows.h>
#include <tchar.h>
-#define GLV_WINAPI WINAPI
-typedef HANDLE glv_thread;
-typedef HANDLE glv_process_handle;
-typedef DWORD glv_thread_id;
-typedef DWORD glv_process_id;
-typedef DWORD GLV_THREAD_ROUTINE_RETURN_TYPE;
-typedef CRITICAL_SECTION GLV_CRITICAL_SECTION;
-#define GLV_NULL_THREAD NULL
-#define GLV_PATH_SEPARATOR "\\"
-#define GLV_THREAD_LOCAL __declspec(thread)
+#define VKTRACE_WINAPI WINAPI
+typedef HANDLE vktrace_thread;
+typedef HANDLE vktrace_process_handle;
+typedef DWORD vktrace_thread_id;
+typedef DWORD vktrace_process_id;
+typedef DWORD VKTRACE_THREAD_ROUTINE_RETURN_TYPE;
+typedef CRITICAL_SECTION VKTRACE_CRITICAL_SECTION;
+#define VKTRACE_NULL_THREAD NULL
+#define VKTRACE_PATH_SEPARATOR "\\"
+#define VKTRACE_THREAD_LOCAL __declspec(thread)
#endif
#if defined(WIN32)
#endif
// return the process ID of current process
-glv_process_id glv_get_pid();
+vktrace_process_id vktrace_get_pid();
// Get the path of the currently running executable.
// The string returned must be freed by the caller.
-char* glv_platform_get_current_executable_directory();
+char* vktrace_platform_get_current_executable_directory();
-// Determine if the current process is glvtrace[32|64]
-BOOL glv_is_loaded_into_glvtrace();
+// Determine if the current process is vktrace[32|64]
+BOOL vktrace_is_loaded_into_vktrace();
// Get the thread id for this thread.
-glv_thread_id glv_platform_get_thread_id();
+vktrace_thread_id vktrace_platform_get_thread_id();
// Get the Registry or Environment variable
-char *glv_get_global_var(const char *);
+char *vktrace_get_global_var(const char *);
// Set the Registry or Environment variable
-void glv_set_global_var(const char *, const char *);
+void vktrace_set_global_var(const char *, const char *);
// Provides out_array_length uint32s of random data from a secure service
-size_t glv_platform_rand_s(uint32_t* out_array, size_t byteCount);
+size_t vktrace_platform_rand_s(uint32_t* out_array, size_t byteCount);
// Alternatives to loading libraries, getting proc addresses, etc
-void * glv_platform_open_library(const char* libPath);
-void * glv_platform_get_library_entrypoint(void * libHandle, const char *name);
-void glv_platform_close_library(void* plibrary);
-BOOL glv_platform_get_next_lib_sym(void * *ppFunc, const char * name);
+void * vktrace_platform_open_library(const char* libPath);
+void * vktrace_platform_get_library_entrypoint(void * libHandle, const char *name);
+void vktrace_platform_close_library(void* plibrary);
+BOOL vktrace_platform_get_next_lib_sym(void * *ppFunc, const char * name);
// Returns the partial path appended to the current directory to provide a full path.
// Note the resulting string may not point to an existing file.
-void glv_platform_full_path(const char* partPath, unsigned long bytes, char* buffer);
+void vktrace_platform_full_path(const char* partPath, unsigned long bytes, char* buffer);
// returns a newly allocated string which contains just the directory structure of the supplied file path.
-char* glv_platform_extract_path(char* _path);
+char* vktrace_platform_extract_path(char* _path);
// returns platform specific path for settings / configuration files
-char* glv_platform_get_settings_path();
+char* vktrace_platform_get_settings_path();
// returns platform specific path for all data files
-char* glv_platform_get_data_path();
+char* vktrace_platform_get_data_path();
-glv_thread glv_platform_create_thread(GLV_THREAD_ROUTINE_RETURN_TYPE(*start_routine)(LPVOID), void* args);
-void glv_platform_resume_thread(glv_thread* pThread);
-void glv_platform_sync_wait_for_thread(glv_thread* pThread);
-void glv_platform_delete_thread(glv_thread* pThread);
-void glv_platform_thread_once(void *ctl, void (* func) (void));
+vktrace_thread vktrace_platform_create_thread(VKTRACE_THREAD_ROUTINE_RETURN_TYPE(*start_routine)(LPVOID), void* args);
+void vktrace_platform_resume_thread(vktrace_thread* pThread);
+void vktrace_platform_sync_wait_for_thread(vktrace_thread* pThread);
+void vktrace_platform_delete_thread(vktrace_thread* pThread);
+void vktrace_platform_thread_once(void *ctl, void (* func) (void));
-void glv_create_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
-void glv_enter_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
-void glv_leave_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
-void glv_delete_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
+void vktrace_create_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection);
+void vktrace_enter_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection);
+void vktrace_leave_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection);
+void vktrace_delete_critical_section(VKTRACE_CRITICAL_SECTION* pCriticalSection);
#if defined(PLATFORM_LINUX)
-#define GLV_LIBRARY_NAME(projname) (sizeof(void*) == 4)? "lib"#projname"32.so" : "lib"#projname".so"
+#define VKTRACE_LIBRARY_NAME(projname) (sizeof(void*) == 4)? "lib"#projname"32.so" : "lib"#projname".so"
#endif
#if defined(WIN32)
-#define GLV_LIBRARY_NAME(projname) (sizeof(void*) == 4)? #projname"32.dll" : #projname".dll"
+#define VKTRACE_LIBRARY_NAME(projname) (sizeof(void*) == 4)? #projname"32.dll" : #projname".dll"
#endif
-BOOL glv_platform_remote_load_library(glv_process_handle pProcessHandle, const char* dllPath, glv_thread* pTracingThread, char **ldPreload);
+BOOL vktrace_platform_remote_load_library(vktrace_process_handle pProcessHandle, const char* dllPath, vktrace_thread* pTracingThread, char **ldPreload);
#include "vktrace_process.h"
-BOOL glv_process_spawn(glv_process_info* pInfo)
+BOOL vktrace_process_spawn(vktrace_process_info* pInfo)
{
assert(pInfo != NULL);
processCreateFlags, NULL, pInfo->workingDirectory,
&si, &processInformation))
{
- glv_LogError("Failed to inject ourselves into target process--couldn't spawn '%s'.", fullExePath);
+ vktrace_LogError("Failed to inject ourselves into target process--couldn't spawn '%s'.", fullExePath);
return FALSE;
}
pInfo->processId = fork();
if (pInfo->processId == -1)
{
- glv_LogError("Failed to spawn process.");
+ vktrace_LogError("Failed to spawn process.");
return FALSE;
}
else if (pInfo->processId == 0)
const char delim[] = " \t";
unsigned int idx;
- glv_set_global_var("LD_PRELOAD", strchr(pInfo->processLDPreload, '=')+1);
+ vktrace_set_global_var("LD_PRELOAD", strchr(pInfo->processLDPreload, '=')+1);
// Change process name so the the tracer DLLs will behave as expected when loaded.
// NOTE: Must be 15 characters or less.
- const char * tmpProcName = "glvChildProcess";
+ const char * tmpProcName = "vktraceChildProcess";
prctl(PR_SET_NAME, (unsigned long)tmpProcName, 0, 0, 0);
// Change working directory
if (chdir(pInfo->workingDirectory) == -1)
{
- glv_LogError("Failed to set working directory.");
+ vktrace_LogError("Failed to set working directory.");
}
args[0] = pInfo->exeName;
idx++;
args[idx] = strtok(NULL, delim);
}
- glv_LogDebug("exec process=%s argc=%u\n", pInfo->exeName, idx);
+ vktrace_LogDebug("exec process=%s argc=%u\n", pInfo->exeName, idx);
#if 0 //uncoment to print out list of env vars
char *env = environ[0];
idx = 0;
while (env && strlen(env)) {
- glv_LogDebug("env[%d] = %s", idx++, env);
+ vktrace_LogDebug("env[%d] = %s", idx++, env);
env = environ[idx];
}
#endif
if (execv(pInfo->exeName, args) < 0)
{
- glv_LogError("Failed to spawn process.");
+ vktrace_LogError("Failed to spawn process.");
return FALSE;
}
}
return TRUE;
}
-void glv_process_info_delete(glv_process_info* pInfo)
+void vktrace_process_info_delete(vktrace_process_info* pInfo)
{
unsigned int i = 0;
if (pInfo->pCaptureThreads != NULL)
{
for (i = 0; i < pInfo->tracerCount; i++)
{
- glv_platform_delete_thread(&(pInfo->pCaptureThreads[i].recordingThread));
+ vktrace_platform_delete_thread(&(pInfo->pCaptureThreads[i].recordingThread));
}
- GLV_DELETE(pInfo->pCaptureThreads);
+ VKTRACE_DELETE(pInfo->pCaptureThreads);
}
#ifdef WIN32
- glv_platform_delete_thread(&(pInfo->watchdogThread));
+ vktrace_platform_delete_thread(&(pInfo->watchdogThread));
#endif
- GLV_DELETE(pInfo->traceFilename);
- GLV_DELETE(pInfo->workingDirectory);
- GLV_DELETE(pInfo->processArgs);
- GLV_DELETE(pInfo->fullProcessCmdLine);
- GLV_DELETE(pInfo->exeName);
+ VKTRACE_DELETE(pInfo->traceFilename);
+ VKTRACE_DELETE(pInfo->workingDirectory);
+ VKTRACE_DELETE(pInfo->processArgs);
+ VKTRACE_DELETE(pInfo->fullProcessCmdLine);
+ VKTRACE_DELETE(pInfo->exeName);
if (pInfo->pTraceFile != NULL)
{
fclose(pInfo->pTraceFile);
}
- glv_delete_critical_section(&(pInfo->traceFileCriticalSection));
+ vktrace_delete_critical_section(&(pInfo->traceFileCriticalSection));
}
#include "vktrace_platform.h"
#include "vktrace_trace_packet_identifiers.h"
-typedef struct glv_process_capture_trace_thread_info glv_process_capture_trace_thread_info;
+typedef struct vktrace_process_capture_trace_thread_info vktrace_process_capture_trace_thread_info;
-typedef struct glv_process_info
+typedef struct vktrace_process_info
{
char* exeName;
char* processArgs;
char* traceFilename;
FILE* pTraceFile;
- // glvtrace's thread id
- glv_thread_id parentThreadId;
+ // vktrace's thread id
+ vktrace_thread_id parentThreadId;
- GLV_CRITICAL_SECTION traceFileCriticalSection;
+ VKTRACE_CRITICAL_SECTION traceFileCriticalSection;
volatile BOOL serverRequestsTermination;
unsigned int tracerCount;
- glv_process_capture_trace_thread_info* pCaptureThreads;
+ vktrace_process_capture_trace_thread_info* pCaptureThreads;
// process id, handle, and main thread
- glv_process_id processId;
- glv_process_handle hProcess;
- glv_thread hThread;
- glv_thread watchdogThread;
+ vktrace_process_id processId;
+ vktrace_process_handle hProcess;
+ vktrace_thread hThread;
+ vktrace_thread watchdogThread;
char* processLDPreload;
-} glv_process_info;
+} vktrace_process_info;
-typedef struct glv_process_tracer_dll
+typedef struct vktrace_process_tracer_dll
{
char * dllPath;
BOOL bLoaded;
- GLV_TRACER_ID tid;
-} glv_process_tracer_dll;
+ VKTRACE_TRACER_ID tid;
+} vktrace_process_tracer_dll;
-struct glv_process_capture_trace_thread_info
+struct vktrace_process_capture_trace_thread_info
{
- glv_thread tracingThread;
- glv_thread recordingThread;
- glv_process_info* pProcessInfo;
- GLV_TRACER_ID tracerId;
+ vktrace_thread tracingThread;
+ vktrace_thread recordingThread;
+ vktrace_process_info* pProcessInfo;
+ VKTRACE_TRACER_ID tracerId;
char* tracerPath;
};
-BOOL glv_process_spawn(glv_process_info* pInfo);
-void glv_process_info_delete(glv_process_info* pInfo);
+BOOL vktrace_process_spawn(vktrace_process_info* pInfo);
+void vktrace_process_info_delete(vktrace_process_info* pInfo);
#include "vktrace_settings.h"
// ------------------------------------------------------------------------------------------------
-void glv_SettingInfo_print(const glv_SettingInfo* pSetting)
+void vktrace_SettingInfo_print(const vktrace_SettingInfo* pSetting)
{
if (pSetting->bPrintInHelp)
{
char * pStrParams;
- if (pSetting->type == GLV_SETTING_STRING)
+ if (pSetting->type == VKTRACE_SETTING_STRING)
{
pStrParams = "<string>";
- } else if (pSetting->type == GLV_SETTING_BOOL) {
+ } else if (pSetting->type == VKTRACE_SETTING_BOOL) {
pStrParams = "<BOOL> ";
- } else if (pSetting->type == GLV_SETTING_UINT) {
+ } else if (pSetting->type == VKTRACE_SETTING_UINT) {
pStrParams = "<uint> ";
- } else if (pSetting->type == GLV_SETTING_INT) {
+ } else if (pSetting->type == VKTRACE_SETTING_INT) {
pStrParams = "<int> ";
} else {
pStrParams = "< ??? > ";
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_print(const glv_SettingGroup* pSettingGroup)
+void vktrace_SettingGroup_print(const vktrace_SettingGroup* pSettingGroup)
{
unsigned int i;
printf("%s available options:\n", pSettingGroup->pName);
for (i = 0; i < pSettingGroup->numSettings; i++)
{
- glv_SettingInfo_print(&(pSettingGroup->pSettings[i]));
+ vktrace_SettingInfo_print(&(pSettingGroup->pSettings[i]));
}
}
// ------------------------------------------------------------------------------------------------
-BOOL glv_SettingInfo_parse_value(glv_SettingInfo* pSetting, const char* arg)
+BOOL vktrace_SettingInfo_parse_value(vktrace_SettingInfo* pSetting, const char* arg)
{
switch(pSetting->type)
{
- case GLV_SETTING_STRING:
+ case VKTRACE_SETTING_STRING:
{
- glv_free(*pSetting->Data.ppChar);
- *pSetting->Data.ppChar = glv_allocate_and_copy(arg);
+ vktrace_free(*pSetting->Data.ppChar);
+ *pSetting->Data.ppChar = vktrace_allocate_and_copy(arg);
}
break;
- case GLV_SETTING_BOOL:
+ case VKTRACE_SETTING_BOOL:
{
BOOL bTrue = FALSE;
#if defined(PLATFORM_LINUX)
*pSetting->Data.pBool = bTrue;
}
break;
- case GLV_SETTING_UINT:
+ case VKTRACE_SETTING_UINT:
{
if (sscanf(arg, "%u", pSetting->Data.pUint) != 1)
{
- glv_LogWarning("Invalid unsigned int setting: '%s'. Resetting to default value instead.", arg);
+ vktrace_LogWarning("Invalid unsigned int setting: '%s'. Resetting to default value instead.", arg);
*(pSetting->Data.pUint) = *(pSetting->Default.pUint);
}
}
break;
- case GLV_SETTING_INT:
+ case VKTRACE_SETTING_INT:
{
if (sscanf(arg, "%d", pSetting->Data.pInt) != 1)
{
- glv_LogWarning("Invalid int setting: '%s'. Resetting to default value instead.", arg);
+ vktrace_LogWarning("Invalid int setting: '%s'. Resetting to default value instead.", arg);
*(pSetting->Data.pInt) = *(pSetting->Default.pInt);
}
}
break;
default:
- glv_LogError("Unhandled setting type (%d).", pSetting->type);
+ vktrace_LogError("Unhandled setting type (%d).", pSetting->type);
return FALSE;
}
}
// ------------------------------------------------------------------------------------------------
-char* glv_SettingInfo_stringify_value(glv_SettingInfo* pSetting)
+char* vktrace_SettingInfo_stringify_value(vktrace_SettingInfo* pSetting)
{
switch(pSetting->type)
{
- case GLV_SETTING_STRING:
+ case VKTRACE_SETTING_STRING:
{
- return glv_allocate_and_copy(*pSetting->Data.ppChar);
+ return vktrace_allocate_and_copy(*pSetting->Data.ppChar);
}
break;
- case GLV_SETTING_BOOL:
+ case VKTRACE_SETTING_BOOL:
{
- return (*pSetting->Data.pBool ? glv_allocate_and_copy("TRUE") : glv_allocate_and_copy("FALSE"));
+ return (*pSetting->Data.pBool ? vktrace_allocate_and_copy("TRUE") : vktrace_allocate_and_copy("FALSE"));
}
break;
- case GLV_SETTING_UINT:
+ case VKTRACE_SETTING_UINT:
{
char value[100];
memset(value, 0, 100);
sprintf(value, "%u", *pSetting->Data.pUint);
- return glv_allocate_and_copy(value);
+ return vktrace_allocate_and_copy(value);
}
break;
- case GLV_SETTING_INT:
+ case VKTRACE_SETTING_INT:
{
char value[100];
memset(value, 0, 100);
sprintf(value, "%d", *pSetting->Data.pInt);
- return glv_allocate_and_copy(value);
+ return vktrace_allocate_and_copy(value);
}
break;
default:
assert(!"Unhandled setting type");
break;
}
- return glv_allocate_and_copy("<unhandled setting type>");
+ return vktrace_allocate_and_copy("<unhandled setting type>");
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_reset_defaults(glv_SettingGroup* pSettingGroup)
+void vktrace_SettingGroup_reset_defaults(vktrace_SettingGroup* pSettingGroup)
{
if (pSettingGroup != NULL)
{
unsigned int u;
for (u = 0; u < pSettingGroup->numSettings; u++)
{
- glv_SettingInfo_reset_default(&pSettingGroup->pSettings[u]);
+ vktrace_SettingInfo_reset_default(&pSettingGroup->pSettings[u]);
}
}
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingInfo_reset_default(glv_SettingInfo* pSetting)
+void vktrace_SettingInfo_reset_default(vktrace_SettingInfo* pSetting)
{
assert(pSetting != NULL);
switch(pSetting->type)
{
- case GLV_SETTING_STRING:
+ case VKTRACE_SETTING_STRING:
if (*pSetting->Data.ppChar != NULL)
{
- glv_free(*pSetting->Data.ppChar);
+ vktrace_free(*pSetting->Data.ppChar);
}
if (pSetting->Default.ppChar == NULL)
}
else
{
- *pSetting->Data.ppChar = glv_allocate_and_copy(*pSetting->Default.ppChar);
+ *pSetting->Data.ppChar = vktrace_allocate_and_copy(*pSetting->Default.ppChar);
}
break;
- case GLV_SETTING_BOOL:
+ case VKTRACE_SETTING_BOOL:
*pSetting->Data.pBool = *pSetting->Default.pBool;
break;
- case GLV_SETTING_UINT:
+ case VKTRACE_SETTING_UINT:
*pSetting->Data.pUint = *pSetting->Default.pUint;
break;
- case GLV_SETTING_INT:
+ case VKTRACE_SETTING_INT:
*pSetting->Data.pInt = *pSetting->Default.pInt;
break;
default:
- assert(!"Unhandled GLV_SETTING_TYPE");
+ assert(!"Unhandled VKTRACE_SETTING_TYPE");
break;
}
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_merge(glv_SettingGroup* pSrc, glv_SettingGroup** ppDestGroups, unsigned int* pNumDestGroups)
+void vktrace_SettingGroup_merge(vktrace_SettingGroup* pSrc, vktrace_SettingGroup** ppDestGroups, unsigned int* pNumDestGroups)
{
unsigned int g;
- glv_SettingGroup* pDestGroup = NULL;
+ vktrace_SettingGroup* pDestGroup = NULL;
assert(pSrc != NULL);
assert(ppDestGroups != NULL);
assert(pNumDestGroups != NULL);
if (pDestGroup == NULL)
{
// need to replicate pSrc into ppDestGroups
- pDestGroup = glv_SettingGroup_Create(glv_allocate_and_copy(pSrc->pName), ppDestGroups, pNumDestGroups);
+ pDestGroup = vktrace_SettingGroup_Create(vktrace_allocate_and_copy(pSrc->pName), ppDestGroups, pNumDestGroups);
assert(pDestGroup != NULL);
}
if (bFound == FALSE)
{
- glv_SettingGroup_Add_Info(&pSrc->pSettings[srcIndex], pDestGroup);
+ vktrace_SettingGroup_Add_Info(&pSrc->pSettings[srcIndex], pDestGroup);
}
}
}
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_Add_Info(glv_SettingInfo* pSrcInfo, glv_SettingGroup* pDestGroup)
+void vktrace_SettingGroup_Add_Info(vktrace_SettingInfo* pSrcInfo, vktrace_SettingGroup* pDestGroup)
{
assert(pSrcInfo != NULL);
assert(pDestGroup != NULL);
if (pDestGroup != NULL)
{
// create a SettingInfo to store the copied information
- glv_SettingInfo info;
- glv_SettingInfo* pTmp;
- memset(&info, 0, sizeof(glv_SettingInfo));
+ vktrace_SettingInfo info;
+ vktrace_SettingInfo* pTmp;
+ memset(&info, 0, sizeof(vktrace_SettingInfo));
// copy necessary buffers so that deletion works correctly
info.pShortName = pSrcInfo->pShortName;
- info.pLongName = glv_allocate_and_copy(pSrcInfo->pLongName);
- info.type = GLV_SETTING_STRING;
- info.Data.ppChar = glv_malloc(sizeof(char**));
- *info.Data.ppChar = glv_SettingInfo_stringify_value(pSrcInfo);
+ info.pLongName = vktrace_allocate_and_copy(pSrcInfo->pLongName);
+ info.type = VKTRACE_SETTING_STRING;
+ info.Data.ppChar = vktrace_malloc(sizeof(char**));
+ *info.Data.ppChar = vktrace_SettingInfo_stringify_value(pSrcInfo);
// add it to the current group
pTmp = pDestGroup->pSettings;
pDestGroup->numSettings += 1;
- pDestGroup->pSettings = GLV_NEW_ARRAY(glv_SettingInfo, pDestGroup->numSettings);
+ pDestGroup->pSettings = VKTRACE_NEW_ARRAY(vktrace_SettingInfo, pDestGroup->numSettings);
if (pDestGroup->pSettings == NULL)
{
// failed to allocate new info array
{
if (pTmp != NULL)
{
- memcpy(pDestGroup->pSettings, pTmp, pDestGroup->numSettings * sizeof(glv_SettingInfo));
+ memcpy(pDestGroup->pSettings, pTmp, pDestGroup->numSettings * sizeof(vktrace_SettingInfo));
}
pDestGroup->pSettings[pDestGroup->numSettings - 1] = info;
}
// ------------------------------------------------------------------------------------------------
-glv_SettingGroup* glv_SettingGroup_Create(const char* pGroupName, glv_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups)
+vktrace_SettingGroup* vktrace_SettingGroup_Create(const char* pGroupName, vktrace_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups)
{
- glv_SettingGroup* pNewGroup = NULL;
- glv_SettingGroup* pTmp = *ppSettingGroups;
+ vktrace_SettingGroup* pNewGroup = NULL;
+ vktrace_SettingGroup* pTmp = *ppSettingGroups;
unsigned int lastIndex = *pNumSettingGroups;
(*pNumSettingGroups) += 1;
- *ppSettingGroups = GLV_NEW_ARRAY(glv_SettingGroup, *pNumSettingGroups);
+ *ppSettingGroups = VKTRACE_NEW_ARRAY(vktrace_SettingGroup, *pNumSettingGroups);
if (*ppSettingGroups == NULL)
{
// out of memory!
else
{
// copy old settings to new ones
- memcpy(*ppSettingGroups, pTmp, lastIndex * sizeof(glv_SettingGroup));
+ memcpy(*ppSettingGroups, pTmp, lastIndex * sizeof(vktrace_SettingGroup));
// clean up old array
- GLV_DELETE(pTmp);
+ VKTRACE_DELETE(pTmp);
// initialize new group
- memset(&(*ppSettingGroups)[lastIndex], 0, sizeof(glv_SettingGroup));
+ memset(&(*ppSettingGroups)[lastIndex], 0, sizeof(vktrace_SettingGroup));
// name the new group
pNewGroup = &(*ppSettingGroups)[lastIndex];
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_update(glv_SettingGroup* pSrc, glv_SettingGroup* pDestGroups, unsigned int numDestGroups)
+void vktrace_SettingGroup_update(vktrace_SettingGroup* pSrc, vktrace_SettingGroup* pDestGroups, unsigned int numDestGroups)
{
unsigned int i;
- glv_SettingGroup* pGroup;
+ vktrace_SettingGroup* pGroup;
for (i = 0; i < numDestGroups; i++)
{
pGroup = &pDestGroups[i];
if (strcmp(pSrc->pName, pGroup->pName) == 0)
{
- glv_SettingGroup_Apply_Overrides(pGroup, pSrc, 1);
+ vktrace_SettingGroup_Apply_Overrides(pGroup, pSrc, 1);
break;
}
}
}
// ------------------------------------------------------------------------------------------------
-int glv_SettingGroup_Load_from_file(FILE* pFile, glv_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups)
+int vktrace_SettingGroup_Load_from_file(FILE* pFile, vktrace_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups)
{
int retVal = 0;
- char* line = GLV_NEW_ARRAY(char, 1024);
+ char* line = VKTRACE_NEW_ARRAY(char, 1024);
assert(pFile != NULL);
assert(ppSettingGroups != NULL);
if (line == NULL)
{
- glv_LogError("Out of memory while reading settings file.");
+ vktrace_LogError("Out of memory while reading settings file.");
retVal = -1;
}
else
{
- glv_SettingGroup* pCurGroup = NULL;
+ vktrace_SettingGroup* pCurGroup = NULL;
while (feof(pFile) == 0 && ferror(pFile) == 0)
{
char* lineStart;
{
// a group was found!
unsigned int i;
- char* pGroupName = glv_allocate_and_copy_n(pOpenBracket + 1,
+ char* pGroupName = vktrace_allocate_and_copy_n(pOpenBracket + 1,
(int) (pCloseBracket - pOpenBracket - 1));
// Check to see if we already have this group
if (pCurGroup == NULL)
{
// Need to grow our list of groups!
- pCurGroup = glv_SettingGroup_Create(pGroupName, ppSettingGroups, pNumSettingGroups);
+ pCurGroup = vktrace_SettingGroup_Create(pGroupName, ppSettingGroups, pNumSettingGroups);
}
}
else
if (pCurGroup != NULL)
{
// create a SettingInfo to store this information
- glv_SettingInfo info;
- glv_SettingInfo* pTmp;
- memset(&info, 0, sizeof(glv_SettingInfo));
+ vktrace_SettingInfo info;
+ vktrace_SettingInfo* pTmp;
+ memset(&info, 0, sizeof(vktrace_SettingInfo));
// trim trailing whitespace by turning it into a null char
while (*pTmpEndName != '\0')
}
}
- info.pLongName = glv_allocate_and_copy(pTokName);
- info.type = GLV_SETTING_STRING;
+ info.pLongName = vktrace_allocate_and_copy(pTokName);
+ info.type = VKTRACE_SETTING_STRING;
// remove leading whitespace from value
while (*pValueStart == ' ') { ++pValueStart; }
- info.Data.ppChar = glv_malloc(sizeof(char**));
- *info.Data.ppChar = glv_allocate_and_copy(pValueStart);
+ info.Data.ppChar = vktrace_malloc(sizeof(char**));
+ *info.Data.ppChar = vktrace_allocate_and_copy(pValueStart);
// add it to the current group
pTmp = pCurGroup->pSettings;
pCurGroup->numSettings += 1;
- pCurGroup->pSettings = GLV_NEW_ARRAY(glv_SettingInfo, pCurGroup->numSettings);
+ pCurGroup->pSettings = VKTRACE_NEW_ARRAY(vktrace_SettingInfo, pCurGroup->numSettings);
if (pCurGroup->pSettings == NULL)
{
// failed to allocate new info array
{
if (pTmp != NULL)
{
- memcpy(pCurGroup->pSettings, pTmp, pCurGroup->numSettings * sizeof(glv_SettingInfo));
+ memcpy(pCurGroup->pSettings, pTmp, pCurGroup->numSettings * sizeof(vktrace_SettingInfo));
}
pCurGroup->pSettings[pCurGroup->numSettings - 1] = info;
}
else
{
- glv_LogWarning("Could not parse a line in settings file: '%s'.", line);
+ vktrace_LogWarning("Could not parse a line in settings file: '%s'.", line);
}
}
}
}
- GLV_DELETE(line);
+ VKTRACE_DELETE(line);
return retVal;
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_Delete_Loaded(glv_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups)
+void vktrace_SettingGroup_Delete_Loaded(vktrace_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups)
{
unsigned int g;
unsigned int s;
for (g = 0; g < *pNumSettingGroups; g++)
{
- glv_SettingGroup* pGroup = &(*ppSettingGroups)[g];
- glv_free((void*)pGroup->pName);
+ vktrace_SettingGroup* pGroup = &(*ppSettingGroups)[g];
+ vktrace_free((void*)pGroup->pName);
pGroup->pName = NULL;
for (s = 0; s < pGroup->numSettings; s++)
{
- glv_free((void*)pGroup->pSettings[s].pLongName);
+ vktrace_free((void*)pGroup->pSettings[s].pLongName);
pGroup->pSettings[s].pLongName = NULL;
- glv_free(*pGroup->pSettings[s].Data.ppChar);
- glv_free(pGroup->pSettings[s].Data.ppChar);
+ vktrace_free(*pGroup->pSettings[s].Data.ppChar);
+ vktrace_free(pGroup->pSettings[s].Data.ppChar);
}
- GLV_DELETE(pGroup->pSettings);
+ VKTRACE_DELETE(pGroup->pSettings);
pGroup->pSettings = NULL;
}
- GLV_DELETE(*ppSettingGroups);
+ VKTRACE_DELETE(*ppSettingGroups);
*pNumSettingGroups = 0;
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_Apply_Overrides(glv_SettingGroup* pSettingGroup, glv_SettingGroup* pOverrideGroups, unsigned int numOverrideGroups)
+void vktrace_SettingGroup_Apply_Overrides(vktrace_SettingGroup* pSettingGroup, vktrace_SettingGroup* pOverrideGroups, unsigned int numOverrideGroups)
{
unsigned int overrideGroupIndex;
assert(pSettingGroup != NULL);
if (strcmp(pSettingGroup->pName, pOverrideGroups[overrideGroupIndex].pName) == 0)
{
unsigned int overrideSettingIndex;
- glv_SettingGroup* pOverride = &pOverrideGroups[overrideGroupIndex];
+ vktrace_SettingGroup* pOverride = &pOverrideGroups[overrideGroupIndex];
for (overrideSettingIndex = 0; overrideSettingIndex < pOverride->numSettings; overrideSettingIndex++)
{
unsigned int baseSettingIndex;
- glv_SettingInfo* pOverrideSetting = &pOverride->pSettings[overrideSettingIndex];
+ vktrace_SettingInfo* pOverrideSetting = &pOverride->pSettings[overrideSettingIndex];
// override matching settings based on long name
for (baseSettingIndex = 0; baseSettingIndex < pSettingGroup->numSettings; baseSettingIndex++)
{
if (strcmp(pSettingGroup->pSettings[baseSettingIndex].pLongName, pOverrideSetting->pLongName) == 0)
{
- char* pTmp = glv_SettingInfo_stringify_value(pOverrideSetting);
- if (glv_SettingInfo_parse_value(&pSettingGroup->pSettings[baseSettingIndex], pTmp) == FALSE)
+ char* pTmp = vktrace_SettingInfo_stringify_value(pOverrideSetting);
+ if (vktrace_SettingInfo_parse_value(&pSettingGroup->pSettings[baseSettingIndex], pTmp) == FALSE)
{
- glv_LogWarning("Failed to parse override value.");
+ vktrace_LogWarning("Failed to parse override value.");
}
- glv_free(pTmp);
+ vktrace_free(pTmp);
break;
}
}
}
//-----------------------------------------------------------------------------
-BOOL glv_SettingGroup_save(glv_SettingGroup* pSettingGroup, unsigned int numSettingGroups, FILE* pSettingsFile)
+BOOL vktrace_SettingGroup_save(vktrace_SettingGroup* pSettingGroup, unsigned int numSettingGroups, FILE* pSettingsFile)
{
BOOL retVal = TRUE;
if (pSettingGroup == NULL)
{
- glv_LogError("Cannot save a null group of settings.");
+ vktrace_LogError("Cannot save a null group of settings.");
retVal = FALSE;
}
if (pSettingsFile == NULL)
{
- glv_LogError("Cannot save an unnamed settings file.");
+ vktrace_LogError("Cannot save an unnamed settings file.");
retVal = FALSE;
}
fputs(" ", pSettingsFile);
fputs(pSettingGroup[g].pSettings[index].pLongName, pSettingsFile);
fputs(" = ", pSettingsFile);
- value = glv_SettingInfo_stringify_value(&pSettingGroup[g].pSettings[index]);
+ value = vktrace_SettingInfo_stringify_value(&pSettingGroup[g].pSettings[index]);
if (value != NULL)
{
fputs(value, pSettingsFile);
- glv_free(value);
+ vktrace_free(value);
}
else
{
}
//-----------------------------------------------------------------------------
-int glv_SettingGroup_init_from_cmdline(glv_SettingGroup* pSettingGroup, int argc, char* argv[], char** ppOut_remaining_args)
+int vktrace_SettingGroup_init_from_cmdline(vktrace_SettingGroup* pSettingGroup, int argc, char* argv[], char** ppOut_remaining_args)
{
int i = 0;
if (pSettingGroup != NULL)
{
- glv_SettingInfo* pSettings = pSettingGroup->pSettings;
+ vktrace_SettingInfo* pSettings = pSettingGroup->pSettings;
unsigned int num_settings = pSettingGroup->numSettings;
// update settings based on command line options
{
if (*ppOut_remaining_args == NULL || strlen(*ppOut_remaining_args) == 0)
{
- *ppOut_remaining_args = glv_allocate_and_copy(argv[i]);
+ *ppOut_remaining_args = vktrace_allocate_and_copy(argv[i]);
}
else
{
- *ppOut_remaining_args = glv_copy_and_append(*ppOut_remaining_args, " ", argv[i]);
+ *ppOut_remaining_args = vktrace_copy_and_append(*ppOut_remaining_args, " ", argv[i]);
}
consumed++;
}
if (pSettingName != NULL && strcmp(curArg, pSettingName) == 0)
{
- if (glv_SettingInfo_parse_value(&pSettings[settingIndex], argv[i+1]))
+ if (vktrace_SettingInfo_parse_value(&pSettings[settingIndex], argv[i+1]))
{
consumed += 2;
}
if (consumed == 0)
{
printf("Error: Invalid argument found '%s'\n", curArg);
- glv_SettingGroup_print(pSettingGroup);
- glv_SettingGroup_delete(pSettingGroup);
+ vktrace_SettingGroup_print(pSettingGroup);
+ vktrace_SettingGroup_delete(pSettingGroup);
return -1;
}
}
// ------------------------------------------------------------------------------------------------
-int glv_SettingGroup_init(glv_SettingGroup* pSettingGroup, FILE* pSettingsFile, int argc, char* argv[], char** ppOut_remaining_args)
+int vktrace_SettingGroup_init(vktrace_SettingGroup* pSettingGroup, FILE* pSettingsFile, int argc, char* argv[], char** ppOut_remaining_args)
{
if (pSettingGroup == NULL)
{
- assert(!"No need to call glv_SettingGroup_init if the application has no settings");
+ assert(!"No need to call vktrace_SettingGroup_init if the application has no settings");
return 0;
}
if (argc == 2 && (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0))
{
- glv_SettingGroup_print(pSettingGroup);
+ vktrace_SettingGroup_print(pSettingGroup);
return -1;
}
// Initially, set all options to their defaults
- glv_SettingGroup_reset_defaults(pSettingGroup);
+ vktrace_SettingGroup_reset_defaults(pSettingGroup);
// Secondly set options based on settings file
if (pSettingsFile != NULL)
{
- glv_SettingGroup* pGroups = NULL;
+ vktrace_SettingGroup* pGroups = NULL;
unsigned int numGroups = 0;
- if (glv_SettingGroup_Load_from_file(pSettingsFile, &pGroups, &numGroups) == -1)
+ if (vktrace_SettingGroup_Load_from_file(pSettingsFile, &pGroups, &numGroups) == -1)
{
- glv_SettingGroup_print(pSettingGroup);
+ vktrace_SettingGroup_print(pSettingGroup);
return -1;
}
- glv_SettingGroup_Apply_Overrides(pSettingGroup, pGroups, numGroups);
+ vktrace_SettingGroup_Apply_Overrides(pSettingGroup, pGroups, numGroups);
- glv_SettingGroup_Delete_Loaded(&pGroups, &numGroups);
+ vktrace_SettingGroup_Delete_Loaded(&pGroups, &numGroups);
}
// Thirdly set options based on cmd line args
- if (glv_SettingGroup_init_from_cmdline(pSettingGroup, argc, argv, ppOut_remaining_args) == -1)
+ if (vktrace_SettingGroup_init_from_cmdline(pSettingGroup, argc, argv, ppOut_remaining_args) == -1)
{
- glv_SettingGroup_print(pSettingGroup);
+ vktrace_SettingGroup_print(pSettingGroup);
return -1;
}
}
// ------------------------------------------------------------------------------------------------
-void glv_SettingGroup_delete(glv_SettingGroup* pSettingGroup)
+void vktrace_SettingGroup_delete(vktrace_SettingGroup* pSettingGroup)
{
if (pSettingGroup != NULL)
{
// need to delete all strings
for (i = 0; i < pSettingGroup->numSettings; i++)
{
- if (pSettingGroup->pSettings[i].type == GLV_SETTING_STRING)
+ if (pSettingGroup->pSettings[i].type == VKTRACE_SETTING_STRING)
{
if (*(pSettingGroup->pSettings[i].Data.ppChar) != NULL)
{
- glv_free(*pSettingGroup->pSettings[i].Data.ppChar);
+ vktrace_free(*pSettingGroup->pSettings[i].Data.ppChar);
*pSettingGroup->pSettings[i].Data.ppChar = NULL;
}
}
#include "vktrace_common.h"
-typedef enum GLV_SETTING_TYPE
+typedef enum VKTRACE_SETTING_TYPE
{
- GLV_SETTING_STRING,
- GLV_SETTING_BOOL,
- GLV_SETTING_UINT,
- GLV_SETTING_INT
-} GLV_SETTING_TYPE;
+ VKTRACE_SETTING_STRING,
+ VKTRACE_SETTING_BOOL,
+ VKTRACE_SETTING_UINT,
+ VKTRACE_SETTING_INT
+} VKTRACE_SETTING_TYPE;
// ------------------------------------------------------------------------------------------------
-typedef struct glv_SettingInfo
+typedef struct vktrace_SettingInfo
{
const char* pShortName;
const char* pLongName;
- GLV_SETTING_TYPE type;
+ VKTRACE_SETTING_TYPE type;
union Data
{
void* pVoid;
} Default;
BOOL bPrintInHelp;
const char* pDesc;
-} glv_SettingInfo;
+} vktrace_SettingInfo;
-typedef struct glv_SettingGroup
+typedef struct vktrace_SettingGroup
{
const char* pName;
unsigned int numSettings;
- glv_SettingInfo* pSettings;
-} glv_SettingGroup;
+ vktrace_SettingInfo* pSettings;
+} vktrace_SettingGroup;
-int glv_SettingGroup_init(glv_SettingGroup* pSettingGroup, FILE *pSettingsFile, int argc, char* argv[], char** ppOut_remaining_args);
-BOOL glv_SettingGroup_save(glv_SettingGroup* pSettingGroup, unsigned int numSettingGroups, FILE* pSettingsFile);
-void glv_SettingGroup_delete(glv_SettingGroup* pSettingGroup);
-void glv_SettingGroup_reset_defaults(glv_SettingGroup* pSettingGroup);
+int vktrace_SettingGroup_init(vktrace_SettingGroup* pSettingGroup, FILE *pSettingsFile, int argc, char* argv[], char** ppOut_remaining_args);
+BOOL vktrace_SettingGroup_save(vktrace_SettingGroup* pSettingGroup, unsigned int numSettingGroups, FILE* pSettingsFile);
+void vktrace_SettingGroup_delete(vktrace_SettingGroup* pSettingGroup);
+void vktrace_SettingGroup_reset_defaults(vktrace_SettingGroup* pSettingGroup);
// Adds pSrc group to ppDestGroups if the named group is not already there,
// or adds missing settings from pSrc into the existing group in ppDestGroups.
// pNumDestGroups is updated if pSrc is added to ppDestGroups.
-void glv_SettingGroup_merge(glv_SettingGroup* pSrc, glv_SettingGroup** ppDestGroups, unsigned int* pNumDestGroups);
+void vktrace_SettingGroup_merge(vktrace_SettingGroup* pSrc, vktrace_SettingGroup** ppDestGroups, unsigned int* pNumDestGroups);
// Updates DestGroups with values from Src
-void glv_SettingGroup_update(glv_SettingGroup* pSrc, glv_SettingGroup* pDestGroups, unsigned int numDestGroups);
+void vktrace_SettingGroup_update(vktrace_SettingGroup* pSrc, vktrace_SettingGroup* pDestGroups, unsigned int numDestGroups);
// Creates a new named group at the end of the ppSettingGroups array, and updates pNumSettingGroups.
-glv_SettingGroup* glv_SettingGroup_Create(const char* pGroupName, glv_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups);
+vktrace_SettingGroup* vktrace_SettingGroup_Create(const char* pGroupName, vktrace_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups);
// Adds a STRING settingInfo to pDestGroup which holds a copy of pSrcInfo, but with a stringified value.
// The conversion to string is necessary for memory management purposes.
-void glv_SettingGroup_Add_Info(glv_SettingInfo* pSrcInfo, glv_SettingGroup* pDestGroup);
+void vktrace_SettingGroup_Add_Info(vktrace_SettingInfo* pSrcInfo, vktrace_SettingGroup* pDestGroup);
-int glv_SettingGroup_Load_from_file(FILE* pFile, glv_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups);
-void glv_SettingGroup_Delete_Loaded(glv_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups);
+int vktrace_SettingGroup_Load_from_file(FILE* pFile, vktrace_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups);
+void vktrace_SettingGroup_Delete_Loaded(vktrace_SettingGroup** ppSettingGroups, unsigned int* pNumSettingGroups);
-void glv_SettingGroup_Apply_Overrides(glv_SettingGroup* pSettingGroup, glv_SettingGroup* pOverrideGroups, unsigned int numOverrideGroups);
+void vktrace_SettingGroup_Apply_Overrides(vktrace_SettingGroup* pSettingGroup, vktrace_SettingGroup* pOverrideGroups, unsigned int numOverrideGroups);
-int glv_SettingGroup_init_from_cmdline(glv_SettingGroup* pSettingGroup, int argc, char* argv[], char** ppOut_remaining_args);
+int vktrace_SettingGroup_init_from_cmdline(vktrace_SettingGroup* pSettingGroup, int argc, char* argv[], char** ppOut_remaining_args);
-void glv_SettingGroup_print(const glv_SettingGroup* pSettingGroup);
-void glv_SettingInfo_print(const glv_SettingInfo* pSetting);
+void vktrace_SettingGroup_print(const vktrace_SettingGroup* pSettingGroup);
+void vktrace_SettingInfo_print(const vktrace_SettingInfo* pSetting);
-char* glv_SettingInfo_stringify_value(glv_SettingInfo* pSetting);
-BOOL glv_SettingInfo_parse_value(glv_SettingInfo* pSetting, const char* arg);
-void glv_SettingInfo_reset_default(glv_SettingInfo* pSetting);
+char* vktrace_SettingInfo_stringify_value(vktrace_SettingInfo* pSetting);
+BOOL vktrace_SettingInfo_parse_value(vktrace_SettingInfo* pSetting, const char* arg);
+void vktrace_SettingInfo_reset_default(vktrace_SettingInfo* pSetting);
#include "vktrace_common.h"
-#define GLV_TRACE_FILE_VERSION_2 0x0002
-#define GLV_TRACE_FILE_VERSION_3 0x0003
-#define GLV_TRACE_FILE_VERSION GLV_TRACE_FILE_VERSION_3
-#define GLV_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE GLV_TRACE_FILE_VERSION_3
+#define VKTRACE_TRACE_FILE_VERSION_2 0x0002
+#define VKTRACE_TRACE_FILE_VERSION_3 0x0003
+#define VKTRACE_TRACE_FILE_VERSION VKTRACE_TRACE_FILE_VERSION_3
+#define VKTRACE_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE VKTRACE_TRACE_FILE_VERSION_3
-#define GLV_MAX_TRACER_ID_ARRAY_SIZE 16
+#define VKTRACE_MAX_TRACER_ID_ARRAY_SIZE 14
-typedef enum GLV_TRACER_ID
+typedef enum VKTRACE_TRACER_ID
{
- GLV_TID_RESERVED = 0,
- GLV_TID_GL_FPS,
- GLV_TID_MANTLE,
- GLV_TID_VULKAN,
- GLV_TID_MANTLE_PERF
- // Max enum must be less than GLV_MAX_TRACER_ID_ARRAY_SIZE
-} GLV_TRACER_ID;
+ VKTRACE_TID_RESERVED = 0,
+ VKTRACE_TID_GL_FPS,
+ VKTRACE_TID_VULKAN
+ // Max enum must be less than VKTRACE_MAX_TRACER_ID_ARRAY_SIZE
+} VKTRACE_TRACER_ID;
-typedef struct GLV_TRACER_REPLAYER_INFO
+typedef struct VKTRACE_TRACER_REPLAYER_INFO
{
- GLV_TRACER_ID tracerId;
+ VKTRACE_TRACER_ID tracerId;
BOOL needsReplayer;
const char* const replayerLibraryName;
const char* const debuggerLibraryname;
-} GLV_TRACER_REPLAYER_INFO;
+} VKTRACE_TRACER_REPLAYER_INFO;
-// The index here should match the value of the GLV_TRACER_ID
-static const GLV_TRACER_REPLAYER_INFO gs_tracerReplayerInfo[GLV_MAX_TRACER_ID_ARRAY_SIZE] = {
- {GLV_TID_RESERVED, FALSE, "", ""},
- {GLV_TID_GL_FPS, FALSE, "", ""},
- {GLV_TID_MANTLE, TRUE, GLV_LIBRARY_NAME(glvreplay_mantle), GLV_LIBRARY_NAME(glvdebug_mantle)},
- {GLV_TID_VULKAN, TRUE, GLV_LIBRARY_NAME(vulkan_replay), GLV_LIBRARY_NAME(glvdebug_vk)},
- {GLV_TID_MANTLE_PERF, FALSE, "", ""},
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
- {GLV_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+// The index here should match the value of the VKTRACE_TRACER_ID
+static const VKTRACE_TRACER_REPLAYER_INFO gs_tracerReplayerInfo[VKTRACE_MAX_TRACER_ID_ARRAY_SIZE] = {
+ {VKTRACE_TID_RESERVED, FALSE, "", ""},
+ {VKTRACE_TID_GL_FPS, FALSE, "", ""},
+ {VKTRACE_TID_VULKAN, TRUE, VKTRACE_LIBRARY_NAME(vulkan_replay), VKTRACE_LIBRARY_NAME(vktracedebug_vk)},
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
+ {VKTRACE_TID_RESERVED, FALSE, "", ""}, // this can be updated as new tracers are added
};
-typedef enum _GLV_TRACE_PACKET_ID
+typedef enum _VKTRACE_TRACE_PACKET_ID
{
- GLV_TPI_MESSAGE,
- GLV_TPI_MARKER_CHECKPOINT,
- GLV_TPI_MARKER_API_BOUNDARY,
- GLV_TPI_MARKER_API_GROUP_BEGIN,
- GLV_TPI_MARKER_API_GROUP_END,
- GLV_TPI_MARKER_TERMINATE_PROCESS,
- GLV_TPI_BEGIN_API_HERE // this enum should always be the last in the list. Feel free to insert new ID above this one.
-} GLV_TRACE_PACKET_ID;
+ VKTRACE_TPI_MESSAGE,
+ VKTRACE_TPI_MARKER_CHECKPOINT,
+ VKTRACE_TPI_MARKER_API_BOUNDARY,
+ VKTRACE_TPI_MARKER_API_GROUP_BEGIN,
+ VKTRACE_TPI_MARKER_API_GROUP_END,
+ VKTRACE_TPI_MARKER_TERMINATE_PROCESS,
+ VKTRACE_TPI_BEGIN_API_HERE // this enum should always be the last in the list. Feel free to insert new ID above this one.
+} VKTRACE_TRACE_PACKET_ID;
typedef struct {
uint8_t id;
uint8_t is_64_bit;
-} glv_tracer_info;
+} vktrace_tracer_info;
typedef struct {
uint16_t trace_file_version;
uint32_t uuid[4];
uint64_t first_packet_offset; // will be size of header including size of tracer_id_array and state_snapshot_path/binary
uint8_t tracer_count; // number of tracers referenced in this trace file
- glv_tracer_info tracer_id_array[GLV_MAX_TRACER_ID_ARRAY_SIZE]; // array of tracer_ids and values which are referenced in the trace file
+ vktrace_tracer_info tracer_id_array[VKTRACE_MAX_TRACER_ID_ARRAY_SIZE]; // array of tracer_ids and values which are referenced in the trace file
uint64_t trace_start_time;
-} glv_trace_file_header;
+} vktrace_trace_file_header;
typedef struct {
uint64_t size; // total size, including extra data, needed to get to the next packet_header
uint64_t global_packet_index;
uint8_t tracer_id; // TODO: need to uniquely identify tracers in a way that is known by the replayer
- uint16_t packet_id; // GLV_TRACE_PACKET_ID (or one of the api-specific IDs)
+ uint16_t packet_id; // VKTRACE_TRACE_PACKET_ID (or one of the api-specific IDs)
uint32_t thread_id;
- uint64_t glave_begin_time; // start of measuring glave's overhead related to this packet
+ uint64_t vktrace_begin_time; // start of measuring vktrace's overhead related to this packet
uint64_t entrypoint_begin_time;
uint64_t entrypoint_end_time;
- uint64_t glave_end_time; // end of measuring glave's overhead related to this packet
+ uint64_t vktrace_end_time; // end of measuring vktrace's overhead related to this packet
uint64_t next_buffers_offset; // used for tracking the addition of buffers to the trace packet
uintptr_t pBody; // points to the body of the packet
-} glv_trace_packet_header;
+} vktrace_trace_packet_header;
typedef struct {
- glv_trace_packet_header* pHeader;
- GlvLogLevel type;
+ vktrace_trace_packet_header* pHeader;
+ VktraceLogLevel type;
uint32_t length;
char* message;
-} glv_trace_packet_message;
+} vktrace_trace_packet_message;
typedef struct {
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
unsigned int length;
char* label;
-} glv_trace_packet_marker_checkpoint;
+} vktrace_trace_packet_marker_checkpoint;
-typedef glv_trace_packet_marker_checkpoint glv_trace_packet_marker_api_boundary;
-typedef glv_trace_packet_marker_checkpoint glv_trace_packet_marker_api_group_begin;
-typedef glv_trace_packet_marker_checkpoint glv_trace_packet_marker_api_group_end;
+typedef vktrace_trace_packet_marker_checkpoint vktrace_trace_packet_marker_api_boundary;
+typedef vktrace_trace_packet_marker_checkpoint vktrace_trace_packet_marker_api_group_begin;
+typedef vktrace_trace_packet_marker_checkpoint vktrace_trace_packet_marker_api_group_end;
-typedef GLV_TRACER_ID (GLVTRACER_CDECL *funcptr_GLV_GetTracerId)();
+typedef VKTRACE_TRACER_ID (VKTRACER_CDECL *funcptr_VKTRACE_GetTracerId)();
static uint64_t g_packet_index = 0;
static int g_reliable_rdtsc = -1;
-void glv_gen_uuid(uint32_t* pUuid)
+void vktrace_gen_uuid(uint32_t* pUuid)
{
uint32_t buf[] = { 0xABCDEF, 0x12345678, 0xFFFECABC, 0xABCDDEF0 };
- glv_platform_rand_s(buf, sizeof(buf)/sizeof(uint32_t));
+ vktrace_platform_rand_s(buf, sizeof(buf)/sizeof(uint32_t));
pUuid[0] = buf[0];
pUuid[1] = buf[1];
pUuid[3] = buf[3];
}
-BOOL glv_init_time()
+BOOL vktrace_init_time()
{
#if defined(PLATFORM_LINUX)
if (g_reliable_rdtsc == -1)
#endif
}
-uint64_t glv_get_time()
+uint64_t vktrace_get_time()
{
-#if defined(GLV_USE_LINUX_API)
+#if defined(VKTRACE_USE_LINUX_API)
extern int g_reliable_rdtsc;
if (g_reliable_rdtsc == -1)
init_rdtsc();
//=============================================================================
// trace file header
-glv_trace_file_header* glv_create_trace_file_header()
+vktrace_trace_file_header* vktrace_create_trace_file_header()
{
- glv_trace_file_header* pHeader = GLV_NEW(glv_trace_file_header);
- memset(pHeader, 0, sizeof(glv_trace_file_header));
- pHeader->trace_file_version = GLV_TRACE_FILE_VERSION;
- glv_gen_uuid(pHeader->uuid);
- pHeader->trace_start_time = glv_get_time();
+ vktrace_trace_file_header* pHeader = VKTRACE_NEW(vktrace_trace_file_header);
+ memset(pHeader, 0, sizeof(vktrace_trace_file_header));
+ pHeader->trace_file_version = VKTRACE_TRACE_FILE_VERSION;
+ vktrace_gen_uuid(pHeader->uuid);
+ pHeader->trace_start_time = vktrace_get_time();
return pHeader;
}
-void glv_delete_trace_file_header(glv_trace_file_header** ppHeader)
+void vktrace_delete_trace_file_header(vktrace_trace_file_header** ppHeader)
{
- glv_free(*ppHeader);
+ vktrace_free(*ppHeader);
*ppHeader = NULL;
}
//=============================================================================
// Methods for creating, populating, and writing trace packets
-glv_trace_packet_header* glv_create_trace_packet(uint8_t tracer_id, uint16_t packet_id, uint64_t packet_size, uint64_t additional_buffers_size)
+vktrace_trace_packet_header* vktrace_create_trace_packet(uint8_t tracer_id, uint16_t packet_id, uint64_t packet_size, uint64_t additional_buffers_size)
{
// Always allocate at least enough space for the packet header
- uint64_t total_packet_size = sizeof(glv_trace_packet_header) + packet_size + additional_buffers_size;
- void* pMem = glv_malloc((size_t)total_packet_size);
+ uint64_t total_packet_size = sizeof(vktrace_trace_packet_header) + packet_size + additional_buffers_size;
+ void* pMem = vktrace_malloc((size_t)total_packet_size);
memset(pMem, 0, (size_t)total_packet_size);
- glv_trace_packet_header* pHeader = (glv_trace_packet_header*)pMem;
+ vktrace_trace_packet_header* pHeader = (vktrace_trace_packet_header*)pMem;
pHeader->size = total_packet_size;
pHeader->global_packet_index = g_packet_index++;
pHeader->tracer_id = tracer_id;
- pHeader->thread_id = glv_platform_get_thread_id();
+ pHeader->thread_id = vktrace_platform_get_thread_id();
pHeader->packet_id = packet_id;
- pHeader->glave_begin_time = glv_get_time();
- pHeader->entrypoint_begin_time = pHeader->glave_begin_time;
+ pHeader->vktrace_begin_time = vktrace_get_time();
+ pHeader->entrypoint_begin_time = pHeader->vktrace_begin_time;
pHeader->entrypoint_end_time = 0;
- pHeader->glave_end_time = 0;
- pHeader->next_buffers_offset = sizeof(glv_trace_packet_header) + packet_size; // initial offset is from start of header to after the packet body
- if (total_packet_size > sizeof(glv_trace_packet_header))
+ pHeader->vktrace_end_time = 0;
+ pHeader->next_buffers_offset = sizeof(vktrace_trace_packet_header) + packet_size; // initial offset is from start of header to after the packet body
+ if (total_packet_size > sizeof(vktrace_trace_packet_header))
{
- pHeader->pBody = (uintptr_t)(((char*)pMem) + sizeof(glv_trace_packet_header));
+ pHeader->pBody = (uintptr_t)(((char*)pMem) + sizeof(vktrace_trace_packet_header));
}
return pHeader;
}
-void glv_delete_trace_packet(glv_trace_packet_header** ppHeader)
+void vktrace_delete_trace_packet(vktrace_trace_packet_header** ppHeader)
{
if (ppHeader == NULL)
return;
if (*ppHeader == NULL)
return;
- GLV_DELETE(*ppHeader);
+ VKTRACE_DELETE(*ppHeader);
*ppHeader = NULL;
}
-void* glv_trace_packet_get_new_buffer_address(glv_trace_packet_header* pHeader, uint64_t byteCount)
+void* vktrace_trace_packet_get_new_buffer_address(vktrace_trace_packet_header* pHeader, uint64_t byteCount)
{
void* pBufferStart;
assert(byteCount > 0);
return pBufferStart;
}
-void glv_add_buffer_to_trace_packet(glv_trace_packet_header* pHeader, void** ptr_address, uint64_t size, const void* pBuffer)
+void vktrace_add_buffer_to_trace_packet(vktrace_trace_packet_header* pHeader, void** ptr_address, uint64_t size, const void* pBuffer)
{
assert(ptr_address != NULL);
if (pBuffer == NULL || size == 0)
else
{
// set ptr to the location of the added buffer
- *ptr_address = glv_trace_packet_get_new_buffer_address(pHeader, size);
+ *ptr_address = vktrace_trace_packet_get_new_buffer_address(pHeader, size);
// copy buffer to the location
memcpy(*ptr_address, pBuffer, (size_t)size);
}
}
-void glv_finalize_buffer_address(glv_trace_packet_header* pHeader, void** ptr_address)
+void vktrace_finalize_buffer_address(vktrace_trace_packet_header* pHeader, void** ptr_address)
{
assert(ptr_address != NULL);
}
}
-void glv_set_packet_entrypoint_end_time(glv_trace_packet_header* pHeader)
+void vktrace_set_packet_entrypoint_end_time(vktrace_trace_packet_header* pHeader)
{
- pHeader->entrypoint_end_time = glv_get_time();
+ pHeader->entrypoint_end_time = vktrace_get_time();
}
-void glv_finalize_trace_packet(glv_trace_packet_header* pHeader)
+void vktrace_finalize_trace_packet(vktrace_trace_packet_header* pHeader)
{
if (pHeader->entrypoint_end_time == 0)
{
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
}
- pHeader->glave_end_time = glv_get_time();
+ pHeader->vktrace_end_time = vktrace_get_time();
}
-void glv_write_trace_packet(const glv_trace_packet_header* pHeader, FileLike* pFile)
+void vktrace_write_trace_packet(const vktrace_trace_packet_header* pHeader, FileLike* pFile)
{
- BOOL res = glv_FileLike_WriteRaw(pFile, pHeader, (size_t)pHeader->size);
+ BOOL res = vktrace_FileLike_WriteRaw(pFile, pHeader, (size_t)pHeader->size);
if (!res)
- glv_LogError("Failed to send trace packet index %u packetId %u size %u.", pHeader->global_packet_index, pHeader->packet_id, pHeader->size);
+ vktrace_LogError("Failed to send trace packet index %u packetId %u size %u.", pHeader->global_packet_index, pHeader->packet_id, pHeader->size);
}
//=============================================================================
// Methods for Reading and interpretting trace packets
-glv_trace_packet_header* glv_read_trace_packet(FileLike* pFile)
+vktrace_trace_packet_header* vktrace_read_trace_packet(FileLike* pFile)
{
// read size
// allocate space
// read the rest of the packet
uint64_t total_packet_size = 0;
void* pMem;
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
- if (glv_FileLike_ReadRaw(pFile, &total_packet_size, sizeof(uint64_t)) == FALSE)
+ if (vktrace_FileLike_ReadRaw(pFile, &total_packet_size, sizeof(uint64_t)) == FALSE)
{
- //glv_LogError("Failed to read trace packet size.");
+ //vktrace_LogError("Failed to read trace packet size.");
return NULL;
}
// allocate space
- pMem = glv_malloc((size_t)total_packet_size);
- pHeader = (glv_trace_packet_header*)pMem;
+ pMem = vktrace_malloc((size_t)total_packet_size);
+ pHeader = (vktrace_trace_packet_header*)pMem;
if (pHeader != NULL)
{
pHeader->size = total_packet_size;
- if (glv_FileLike_ReadRaw(pFile, (char*)pHeader + sizeof(uint64_t), (size_t)total_packet_size - sizeof(uint64_t)) == FALSE)
+ if (vktrace_FileLike_ReadRaw(pFile, (char*)pHeader + sizeof(uint64_t), (size_t)total_packet_size - sizeof(uint64_t)) == FALSE)
{
- glv_LogError("Failed to read trace packet with size of %u.", total_packet_size);
+ vktrace_LogError("Failed to read trace packet with size of %u.", total_packet_size);
return NULL;
}
- pHeader->pBody = (uintptr_t)pHeader + sizeof(glv_trace_packet_header);
+ pHeader->pBody = (uintptr_t)pHeader + sizeof(vktrace_trace_packet_header);
}
else {
- glv_LogError("Malloc failed in glv_read_trace_packet of size %u.", total_packet_size);
+ vktrace_LogError("Malloc failed in vktrace_read_trace_packet of size %u.", total_packet_size);
}
return pHeader;
}
-void* glv_trace_packet_interpret_buffer_pointer(glv_trace_packet_header* pHeader, intptr_t ptr_variable)
+void* vktrace_trace_packet_interpret_buffer_pointer(vktrace_trace_packet_header* pHeader, intptr_t ptr_variable)
{
// the pointer variable actually contains a byte offset from the packet body to the start of the buffer.
uint64_t offset = ptr_variable;
#include "vktrace_process.h"
// pUuid is expected to be an array of 4 unsigned ints
-void glv_gen_uuid(uint32_t* pUuid);
+void vktrace_gen_uuid(uint32_t* pUuid);
-BOOL glv_init_time();
-uint64_t glv_get_time();
+BOOL vktrace_init_time();
+uint64_t vktrace_get_time();
//=============================================================================
// trace file header
// there is a file header at the start of every trace file
-glv_trace_file_header* glv_create_trace_file_header();
+vktrace_trace_file_header* vktrace_create_trace_file_header();
// deletes the trace file header and sets pointer to NULL
-void glv_delete_trace_file_header(glv_trace_file_header** ppHeader);
+void vktrace_delete_trace_file_header(vktrace_trace_file_header** ppHeader);
-static FILE* glv_write_trace_file_header(glv_process_info* pProcInfo)
+static FILE* vktrace_write_trace_file_header(vktrace_process_info* pProcInfo)
{
FILE* tracefp = NULL;
unsigned int index = 0;
- glv_trace_file_header* pHeader = NULL;
+ vktrace_trace_file_header* pHeader = NULL;
size_t items_written = 0;
assert(pProcInfo != NULL);
tracefp = fopen(pProcInfo->traceFilename, "wb");
if (tracefp == NULL)
{
- glv_LogError("Cannot open trace file for writing %s.", pProcInfo->traceFilename);
+ vktrace_LogError("Cannot open trace file for writing %s.", pProcInfo->traceFilename);
return tracefp;
}
// populate header information
- pHeader = glv_create_trace_file_header();
- pHeader->first_packet_offset = sizeof(glv_trace_file_header);
+ pHeader = vktrace_create_trace_file_header();
+ pHeader->first_packet_offset = sizeof(vktrace_trace_file_header);
pHeader->tracer_count = pProcInfo->tracerCount;
for (index = 0; index < pProcInfo->tracerCount; index++)
}
// create critical section
- glv_create_critical_section(&pProcInfo->traceFileCriticalSection);
+ vktrace_create_critical_section(&pProcInfo->traceFileCriticalSection);
// write header into file
- glv_enter_critical_section(&pProcInfo->traceFileCriticalSection);
- items_written = fwrite(pHeader, sizeof(glv_trace_file_header), 1, tracefp);
- glv_leave_critical_section(&pProcInfo->traceFileCriticalSection);
+ vktrace_enter_critical_section(&pProcInfo->traceFileCriticalSection);
+ items_written = fwrite(pHeader, sizeof(vktrace_trace_file_header), 1, tracefp);
+ vktrace_leave_critical_section(&pProcInfo->traceFileCriticalSection);
if (items_written != 1)
{
- glv_LogError("Failed to write trace file header.");
- glv_delete_critical_section(&pProcInfo->traceFileCriticalSection);
+ vktrace_LogError("Failed to write trace file header.");
+ vktrace_delete_critical_section(&pProcInfo->traceFileCriticalSection);
fclose(tracefp);
return NULL;
}
- glv_delete_trace_file_header(&pHeader);
+ vktrace_delete_trace_file_header(&pHeader);
return tracefp;
};
// \param packet_size should include the total bytes for the specific type of packet, and any additional buffers needed by the packet.
// The size of the header will be added automatically within the function.
-glv_trace_packet_header* glv_create_trace_packet(uint8_t tracer_id, uint16_t packet_id, uint64_t packet_size, uint64_t additional_buffers_size);
+vktrace_trace_packet_header* vktrace_create_trace_packet(uint8_t tracer_id, uint16_t packet_id, uint64_t packet_size, uint64_t additional_buffers_size);
// deletes a trace packet and sets pointer to NULL
-void glv_delete_trace_packet(glv_trace_packet_header** ppHeader);
+void vktrace_delete_trace_packet(vktrace_trace_packet_header** ppHeader);
// gets the next address available to write a buffer into the packet
-void* glv_trace_packet_get_new_buffer_address(glv_trace_packet_header* pHeader, uint64_t byteCount);
+void* vktrace_trace_packet_get_new_buffer_address(vktrace_trace_packet_header* pHeader, uint64_t byteCount);
// copies buffer data into a trace packet at the specified offset (from the end of the header).
// it is up to the caller to ensure that buffers do not overlap.
-void glv_add_buffer_to_trace_packet(glv_trace_packet_header* pHeader, void** ptr_address, uint64_t size, const void* pBuffer);
+void vktrace_add_buffer_to_trace_packet(vktrace_trace_packet_header* pHeader, void** ptr_address, uint64_t size, const void* pBuffer);
// converts buffer pointers into byte offset so that pointer can be interpretted after being read into memory
-void glv_finalize_buffer_address(glv_trace_packet_header* pHeader, void** ptr_address);
+void vktrace_finalize_buffer_address(vktrace_trace_packet_header* pHeader, void** ptr_address);
// sets entrypoint end time
-void glv_set_packet_entrypoint_end_time(glv_trace_packet_header* pHeader);
+void vktrace_set_packet_entrypoint_end_time(vktrace_trace_packet_header* pHeader);
-//void initialize_trace_packet_header(glv_trace_packet_header* pHeader, uint8_t tracer_id, uint16_t packet_id, uint64_t total_packet_size);
-void glv_finalize_trace_packet(glv_trace_packet_header* pHeader);
+//void initialize_trace_packet_header(vktrace_trace_packet_header* pHeader, uint8_t tracer_id, uint16_t packet_id, uint64_t total_packet_size);
+void vktrace_finalize_trace_packet(vktrace_trace_packet_header* pHeader);
// Write the trace packet to the filelike thing.
// This has no knowledge of the details of the packet other than its size.
-void glv_write_trace_packet(const glv_trace_packet_header* pHeader, FileLike* pFile);
+void vktrace_write_trace_packet(const vktrace_trace_packet_header* pHeader, FileLike* pFile);
//=============================================================================
// Methods for Reading and interpretting trace packets
// Reads in the trace packet header, the body of the packet, and additional buffers
-glv_trace_packet_header* glv_read_trace_packet(FileLike* pFile);
+vktrace_trace_packet_header* vktrace_read_trace_packet(FileLike* pFile);
// converts a pointer variable that is currently byte offset into a pointer to the actual offset location
-void* glv_trace_packet_interpret_buffer_pointer(glv_trace_packet_header* pHeader, intptr_t ptr_variable);
+void* vktrace_trace_packet_interpret_buffer_pointer(vktrace_trace_packet_header* pHeader, intptr_t ptr_variable);
//=============================================================================
// trace packet message
// 2) immediately after the packet was read from memory
// All other conversions of the trace packet body from the header should
// be performed using a C-style cast.
-static glv_trace_packet_message* glv_interpret_body_as_trace_packet_message(glv_trace_packet_header* pHeader)
+static vktrace_trace_packet_message* vktrace_interpret_body_as_trace_packet_message(vktrace_trace_packet_header* pHeader)
{
- glv_trace_packet_message* pPacket = (glv_trace_packet_message*)pHeader->pBody;
+ vktrace_trace_packet_message* pPacket = (vktrace_trace_packet_message*)pHeader->pBody;
// update pointers
pPacket->pHeader = pHeader;
- pPacket->message = (char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->message);
+ pPacket->message = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->message);
return pPacket;
}
// filelike thing that is used for outputting trace messages
static FileLike* g_pFileOut = NULL;
-GLV_TRACER_ID g_tracelog_tracer_id = GLV_TID_RESERVED;
+VKTRACE_TRACER_ID g_tracelog_tracer_id = VKTRACE_TID_RESERVED;
-void glv_trace_set_trace_file(FileLike* pFileLike)
+void vktrace_trace_set_trace_file(FileLike* pFileLike)
{
g_pFileOut = pFileLike;
}
-FileLike* glv_trace_get_trace_file()
+FileLike* vktrace_trace_get_trace_file()
{
return g_pFileOut;
}
-void glv_tracelog_set_tracer_id(uint8_t tracerId)
+void vktrace_tracelog_set_tracer_id(uint8_t tracerId)
{
- g_tracelog_tracer_id = (GLV_TRACER_ID)tracerId;
+ g_tracelog_tracer_id = (VKTRACE_TRACER_ID)tracerId;
}
-GLV_REPORT_CALLBACK_FUNCTION s_reportFunc;
-GlvLogLevel s_logLevel = GLV_LOG_LEVEL_MAXIMUM;
+VKTRACE_REPORT_CALLBACK_FUNCTION s_reportFunc;
+VktraceLogLevel s_logLevel = VKTRACE_LOG_LEVEL_MAXIMUM;
-const char* glv_LogLevelToString(GlvLogLevel level)
+const char* vktrace_LogLevelToString(VktraceLogLevel level)
{
switch(level)
{
- case GLV_LOG_ALWAYS: return "GLV_LOG_ALWAYS";
- case GLV_LOG_DEBUG: return "GLV_LOG_DEBUG";
- case GLV_LOG_LEVEL_MINIMUM: return "GLV_LOG_LEVEL_MINIMUM";
- case GLV_LOG_ERROR: return "GLV_LOG_ERROR";
- case GLV_LOG_WARNING: return "GLV_LOG_WARNING";
- case GLV_LOG_VERBOSE: return "GLV_LOG_VERBOSE";
- case GLV_LOG_LEVEL_MAXIMUM: return "GLV_LOG_LEVEL_MAXIMUM";
+ case VKTRACE_LOG_ALWAYS: return "VKTRACE_LOG_ALWAYS";
+ case VKTRACE_LOG_DEBUG: return "VKTRACE_LOG_DEBUG";
+ case VKTRACE_LOG_LEVEL_MINIMUM: return "VKTRACE_LOG_LEVEL_MINIMUM";
+ case VKTRACE_LOG_ERROR: return "VKTRACE_LOG_ERROR";
+ case VKTRACE_LOG_WARNING: return "VKTRACE_LOG_WARNING";
+ case VKTRACE_LOG_VERBOSE: return "VKTRACE_LOG_VERBOSE";
+ case VKTRACE_LOG_LEVEL_MAXIMUM: return "VKTRACE_LOG_LEVEL_MAXIMUM";
default:
return "Unknown";
}
}
-const char* glv_LogLevelToShortString(GlvLogLevel level)
+const char* vktrace_LogLevelToShortString(VktraceLogLevel level)
{
switch(level)
{
- case GLV_LOG_ALWAYS: return "Always";
- case GLV_LOG_DEBUG: return "Debug";
- case GLV_LOG_LEVEL_MINIMUM: return "Miniumm";
- case GLV_LOG_ERROR: return "Error";
- case GLV_LOG_WARNING: return "Warning";
- case GLV_LOG_VERBOSE: return "Verbose";
- case GLV_LOG_LEVEL_MAXIMUM: return "Maximum";
+ case VKTRACE_LOG_ALWAYS: return "Always";
+ case VKTRACE_LOG_DEBUG: return "Debug";
+ case VKTRACE_LOG_LEVEL_MINIMUM: return "Miniumm";
+ case VKTRACE_LOG_ERROR: return "Error";
+ case VKTRACE_LOG_WARNING: return "Warning";
+ case VKTRACE_LOG_VERBOSE: return "Verbose";
+ case VKTRACE_LOG_LEVEL_MAXIMUM: return "Maximum";
default:
return "Unknown";
}
// For use by both tools and libraries.
-void glv_LogSetCallback(GLV_REPORT_CALLBACK_FUNCTION pCallback)
+void vktrace_LogSetCallback(VKTRACE_REPORT_CALLBACK_FUNCTION pCallback)
{
s_reportFunc = pCallback;
}
-void glv_LogSetLevel(GlvLogLevel level)
+void vktrace_LogSetLevel(VktraceLogLevel level)
{
s_logLevel = level;
- glv_LogDebug("Log Level = %u (%s)", level, glv_LogLevelToString(level));
+ vktrace_LogDebug("Log Level = %u (%s)", level, vktrace_LogLevelToString(level));
}
-BOOL glv_LogIsLogging(GlvLogLevel level)
+BOOL vktrace_LogIsLogging(VktraceLogLevel level)
{
#if defined(_DEBUG)
- if (level == GLV_LOG_DEBUG)
+ if (level == VKTRACE_LOG_DEBUG)
{
return TRUE;
}
return (level <= s_logLevel) ? TRUE : FALSE;
}
-void LogGuts(GlvLogLevel level, const char* fmt, va_list args)
+void LogGuts(VktraceLogLevel level, const char* fmt, va_list args)
{
#if defined(WIN32)
int requiredLength = _vscprintf(fmt, args) + 1;
requiredLength = vsnprintf(NULL, 0, fmt, argcopy) + 1;
va_end(argcopy);
#endif
- static GLV_THREAD_LOCAL BOOL logging = FALSE;
+ static VKTRACE_THREAD_LOCAL BOOL logging = FALSE;
// Don't recursively log problems found during logging
if (logging)
}
logging = TRUE;
- char* message = (char*)glv_malloc(requiredLength);
+ char* message = (char*)vktrace_malloc(requiredLength);
#if defined(WIN32)
_vsnprintf_s(message, requiredLength, requiredLength - 1, fmt, args);
#elif defined(PLATFORM_LINUX)
}
else
{
- printf("%s: %s\n", glv_LogLevelToString(level), message);
+ printf("%s: %s\n", vktrace_LogLevelToString(level), message);
}
- glv_free(message);
+ vktrace_free(message);
logging = FALSE;
}
-void glv_LogAlways(const char* format, ...)
+void vktrace_LogAlways(const char* format, ...)
{
va_list args;
va_start(args, format);
- LogGuts(GLV_LOG_ALWAYS, format, args);
+ LogGuts(VKTRACE_LOG_ALWAYS, format, args);
va_end(args);
}
-void glv_LogDebug(const char* format, ...)
+void vktrace_LogDebug(const char* format, ...)
{
#if defined(_DEBUG)
va_list args;
va_start(args, format);
- LogGuts(GLV_LOG_DEBUG, format, args);
+ LogGuts(VKTRACE_LOG_DEBUG, format, args);
va_end(args);
#endif
}
-void glv_LogError(const char* format, ...)
+void vktrace_LogError(const char* format, ...)
{
- if (glv_LogIsLogging(GLV_LOG_ERROR))
+ if (vktrace_LogIsLogging(VKTRACE_LOG_ERROR))
{
va_list args;
va_start(args, format);
- LogGuts(GLV_LOG_ERROR, format, args);
+ LogGuts(VKTRACE_LOG_ERROR, format, args);
va_end(args);
}
}
-void glv_LogWarning(const char* format, ...)
+void vktrace_LogWarning(const char* format, ...)
{
- if (glv_LogIsLogging(GLV_LOG_WARNING))
+ if (vktrace_LogIsLogging(VKTRACE_LOG_WARNING))
{
va_list args;
va_start(args, format);
- LogGuts(GLV_LOG_WARNING, format, args);
+ LogGuts(VKTRACE_LOG_WARNING, format, args);
va_end(args);
}
}
-void glv_LogVerbose(const char* format, ...)
+void vktrace_LogVerbose(const char* format, ...)
{
- if (glv_LogIsLogging(GLV_LOG_VERBOSE))
+ if (vktrace_LogIsLogging(VKTRACE_LOG_VERBOSE))
{
va_list args;
va_start(args, format);
- LogGuts(GLV_LOG_VERBOSE, format, args);
+ LogGuts(VKTRACE_LOG_VERBOSE, format, args);
va_end(args);
}
}
typedef struct FileLike FileLike;
typedef enum {
- GLV_LOG_ALWAYS = 0,
- GLV_LOG_DEBUG,
- GLV_LOG_LEVEL_MINIMUM,
- GLV_LOG_ERROR,
- GLV_LOG_WARNING,
- GLV_LOG_VERBOSE,
- GLV_LOG_LEVEL_MAXIMUM
-} GlvLogLevel;
+ VKTRACE_LOG_ALWAYS = 0,
+ VKTRACE_LOG_DEBUG,
+ VKTRACE_LOG_LEVEL_MINIMUM,
+ VKTRACE_LOG_ERROR,
+ VKTRACE_LOG_WARNING,
+ VKTRACE_LOG_VERBOSE,
+ VKTRACE_LOG_LEVEL_MAXIMUM
+} VktraceLogLevel;
-const char* glv_LogLevelToString(GlvLogLevel level);
-const char* glv_LogLevelToShortString(GlvLogLevel level);
+const char* vktrace_LogLevelToString(VktraceLogLevel level);
+const char* vktrace_LogLevelToShortString(VktraceLogLevel level);
-void glv_trace_set_trace_file(FileLike* pFileLike);
-FileLike* glv_trace_get_trace_file();
-void glv_tracelog_set_tracer_id(uint8_t tracerId);
+void vktrace_trace_set_trace_file(FileLike* pFileLike);
+FileLike* vktrace_trace_get_trace_file();
+void vktrace_tracelog_set_tracer_id(uint8_t tracerId);
// Logging is done by reporting the messages back to a callback.
// Plugins should register a callback from the parent tool;
// Tools should register their own callback so that they can output messages as desired.
-typedef void (*GLV_REPORT_CALLBACK_FUNCTION)(GlvLogLevel level, const char* pMsg);
-extern GLV_REPORT_CALLBACK_FUNCTION s_reportFunc;
-extern GlvLogLevel s_logLevel;
+typedef void (*VKTRACE_REPORT_CALLBACK_FUNCTION)(VktraceLogLevel level, const char* pMsg);
+extern VKTRACE_REPORT_CALLBACK_FUNCTION s_reportFunc;
+extern VktraceLogLevel s_logLevel;
-void glv_LogSetCallback(GLV_REPORT_CALLBACK_FUNCTION pCallback);
-void glv_LogSetLevel(GlvLogLevel level);
+void vktrace_LogSetCallback(VKTRACE_REPORT_CALLBACK_FUNCTION pCallback);
+void vktrace_LogSetLevel(VktraceLogLevel level);
// Allows checking if a level is being logged so that string-related functions
// can be skipped if they will not reported.
-BOOL glv_LogIsLogging(GlvLogLevel level);
+BOOL vktrace_LogIsLogging(VktraceLogLevel level);
// Always log the message, no matter what the ReportingLevel is.
-void glv_LogAlways(const char* format, ...);
+void vktrace_LogAlways(const char* format, ...);
-// Log debug information that is primarly helpful for Glave developers
+// Log debug information that is primarly helpful for Vktrace developers
// and will only appear in _DEBUG builds.
// This will also always be logged, no matter what the ReportingLevel is.
-void glv_LogDebug(const char* format, ...);
+void vktrace_LogDebug(const char* format, ...);
// Log an error message.
-void glv_LogError(const char* format, ...);
+void vktrace_LogError(const char* format, ...);
// Log a warning.
-void glv_LogWarning(const char* format, ...);
+void vktrace_LogWarning(const char* format, ...);
// Log any misc information that might help a user understand what is going on.
-void glv_LogVerbose(const char* format, ...);
+void vktrace_LogVerbose(const char* format, ...);
endif()
-# if Glave is being built as part of a vulkan driver build, then use that target instead of the locally-commited binary.
+# if Vktrace is being built as part of a vulkan driver build, then use that target instead of the locally-commited binary.
#if (TARGET vulkan)
# message(STATUS "Using external Vulkan header and library.")
-# set(GLV_VULKAN_LIB vulkan)
- set(GLV_VULKAN_DRIVER_DIR ${CMAKE_SOURCE_DIR})
- set(GLV_VULKAN_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include)
- set(GLV_VULKAN_HEADER ${CMAKE_SOURCE_DIR}/include/vulkan.h)
- set(GLV_VULKAN_DEBUG_REPORT_LUNARG_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vk_debug_report_lunarg.h)
- set(GLV_VULKAN_DEBUG_MARKER_LUNARG_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vk_debug_marker_lunarg.h)
- set(GLV_VULKAN_WSI_SWAPCHAIN_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vk_wsi_swapchain.h)
- set(GLV_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vk_wsi_device_swapchain.h)
+# set(VKTRACE_VULKAN_LIB vulkan)
+ set(VKTRACE_VULKAN_DRIVER_DIR ${CMAKE_SOURCE_DIR})
+ set(VKTRACE_VULKAN_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include)
+ set(VKTRACE_VULKAN_HEADER ${CMAKE_SOURCE_DIR}/include/vulkan.h)
+ set(VKTRACE_VULKAN_DEBUG_REPORT_LUNARG_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vk_debug_report_lunarg.h)
+ set(VKTRACE_VULKAN_DEBUG_MARKER_LUNARG_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vk_debug_marker_lunarg.h)
+ set(VKTRACE_VULKAN_WSI_SWAPCHAIN_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vk_wsi_swapchain.h)
+ set(VKTRACE_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vk_wsi_device_swapchain.h)
#else()
# Use a locally committed vulkan header and binary
-# message(STATUS "Using Glave-supplied Vulkan header and library.")
-# set(GLV_VULKAN_DRIVER_DIR ${CMAKE_CURRENT_SOURCE_DIR}/vulkan)
-# set(GLV_VULKAN_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/vulkan/include)
-# set(GLV_VULKAN_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vulkan.h)
-# set(GLV_VULKAN_DEBUG_REPORT_LUNARG_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vk_debug_report_lunarg.h)
-# set(GLV_VULKAN_WSI_SWAPCHAIN_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vk_wsi_swapchain.h)
-# set(GLV_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER ${GLV_VULKAN_INCLUDE_DIR}/vk_wsi_device_swapchain.h)
+# message(STATUS "Using Vktrace-supplied Vulkan header and library.")
+# set(VKTRACE_VULKAN_DRIVER_DIR ${CMAKE_CURRENT_SOURCE_DIR}/vulkan)
+# set(VKTRACE_VULKAN_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/vulkan/include)
+# set(VKTRACE_VULKAN_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vulkan.h)
+# set(VKTRACE_VULKAN_DEBUG_REPORT_LUNARG_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vk_debug_report_lunarg.h)
+# set(VKTRACE_VULKAN_WSI_SWAPCHAIN_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vk_wsi_swapchain.h)
+# set(VKTRACE_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER ${VKTRACE_VULKAN_INCLUDE_DIR}/vk_wsi_device_swapchain.h)
if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
- set(GLV_VULKAN_LIB
+ set(VKTRACE_VULKAN_LIB
${CMAKE_BINARY_DIR}/loader/${CMAKE_CFG_INTDIR}/vulkan.0.lib
)
endif()
if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
- set(GLV_VULKAN_LIB
+ set(VKTRACE_VULKAN_LIB
${CMAKE_BINARY_DIR}/loader/libvulkan.so
)
endif()
#endif()
-message(STATUS "GLV_VULKAN_LIB = " ${GLV_VULKAN_LIB})
-#message(STATUS "GLV_VULKAN_DRIVER_DIR = " ${GLV_VULKAN_DRIVER_DIR})
-#message(STATUS "GLV_VULKAN_HEADER = " ${GLV_VULKAN_HEADER})
-#message(STATUS "GLV_VULKAN_DEBUG_REPORT_LUNARG_HEADER = " ${GLV_VULKAN_DEBUG_REPORT_LUNARG_HEADER})
+message(STATUS "VKTRACE_VULKAN_LIB = " ${VKTRACE_VULKAN_LIB})
+#message(STATUS "VKTRACE_VULKAN_DRIVER_DIR = " ${VKTRACE_VULKAN_DRIVER_DIR})
+#message(STATUS "VKTRACE_VULKAN_HEADER = " ${VKTRACE_VULKAN_HEADER})
+#message(STATUS "VKTRACE_VULKAN_DEBUG_REPORT_LUNARG_HEADER = " ${VKTRACE_VULKAN_DEBUG_REPORT_LUNARG_HEADER})
# Run a codegen script to generate utilities that are vulkan-specific, dependent on the vulkan header files, and may be shared by the tracer, replayer, or debugger.
# Generally, these are likely to be things that SHOULD be provided by the vulkan SDK.
-set(GLV_VULKAN_CODEGEN_UTILS "vulkan/codegen_utils")
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
+set(VKTRACE_VULKAN_CODEGEN_UTILS "vulkan/codegen_utils")
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
# generate files for vulkan.h
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${GLV_VULKAN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${GLV_VULKAN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${VKTRACE_VULKAN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${VKTRACE_VULKAN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
# generate files for vk_wsi_swapchain.h
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${GLV_VULKAN_WSI_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
-#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${GLV_VULKAN_WSI_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${VKTRACE_VULKAN_WSI_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
+#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${VKTRACE_VULKAN_WSI_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
# generate files for vk_wsi_device_swapchain.h
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${GLV_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
-#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${GLV_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${VKTRACE_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
+#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${VKTRACE_VULKAN_WSI_DEVICE_SWAPCHAIN_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
# generate files for vk_debug_report_lunarg.h
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${GLV_VULKAN_DEBUG_REPORT_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
-#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${GLV_VULKAN_DEBUG_REPORT_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${VKTRACE_VULKAN_DEBUG_REPORT_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
+#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${VKTRACE_VULKAN_DEBUG_REPORT_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
# generate files for vk_debug_marker_lunarg.h
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${GLV_VULKAN_DEBUG_MARKER_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
-#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${GLV_VULKAN_DEBUG_MARKER_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${GLV_VULKAN_CODEGEN_UTILS})
-
-# Run a codegen script to generate glave-specific vulkan utils
-set(CODEGEN_GLVVK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/codegen_vktrace_utils")
-file(MAKE_DIRECTORY ${CODEGEN_GLVVK_DIR})
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-packet-id vk_core OUTPUT_FILE ${CODEGEN_GLVVK_DIR}/vktrace_vk_packet_id.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-core-trace-packets vk_core OUTPUT_FILE ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_packets.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-packets vk_wsi_swapchain OUTPUT_FILE ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_wsi_swapchain_packets.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-packets vk_wsi_device_swapchain OUTPUT_FILE ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_wsi_device_swapchain_packets.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-packets vk_debug_report_lunarg OUTPUT_FILE ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_debug_report_lunarg_packets.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-packets vk_debug_marker_lunarg OUTPUT_FILE ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_debug_marker_lunarg_packets.h)
-
-# Directories which actually contain vulkan-specific glave plugins.
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_struct_sizes ${VKTRACE_VULKAN_DEBUG_MARKER_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
+#execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DRIVER_DIR}/vk_helper.py --gen_enum_string_helper ${VKTRACE_VULKAN_DEBUG_MARKER_LUNARG_HEADER} --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/${VKTRACE_VULKAN_CODEGEN_UTILS})
+
+# Run a codegen script to generate vktrace-specific vulkan utils
+set(CODEGEN_VKTRACE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/codegen_vktrace_utils")
+file(MAKE_DIRECTORY ${CODEGEN_VKTRACE_DIR})
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-packet-id vk_core OUTPUT_FILE ${CODEGEN_VKTRACE_DIR}/vktrace_vk_packet_id.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-core-trace-packets vk_core OUTPUT_FILE ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_packets.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-packets vk_wsi_swapchain OUTPUT_FILE ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_wsi_swapchain_packets.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-packets vk_wsi_device_swapchain OUTPUT_FILE ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_wsi_device_swapchain_packets.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-packets vk_debug_report_lunarg OUTPUT_FILE ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_debug_report_lunarg_packets.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-packets vk_debug_marker_lunarg OUTPUT_FILE ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_debug_marker_lunarg_packets.h)
+
+# Directories which actually contain vulkan-specific vktrace plugins.
add_subdirectory(vkreplay/)
add_subdirectory(vktrace/)
/*
- * GLAVE & vulkan
+ * VKTRACE & vulkan
*
* Copyright (C) 2015 LunarG, Inc. and Valve Corporation
*
#include "vktrace_snapshot.h"
#include "vk_struct_string_helper.h"
-#define LAYER_NAME_STR "GlaveSnapshot"
-#define LAYER_ABBREV_STR "GLVSnap"
+#define LAYER_NAME_STR "VktraceSnapshot"
+#define LAYER_ABBREV_STR "VKTRACESnap"
static VkLayerDispatchTable nextTable;
static VkBaseLayerObject *pCurObj;
static loader_platform_thread_mutex objLock;
// The 'masterSnapshot' which gets the delta merged into it when 'GetSnapshot()' is called.
-static GLV_VK_SNAPSHOT s_snapshot = {0};
+static VKTRACE_VK_SNAPSHOT s_snapshot = {0};
// The 'deltaSnapshot' which tracks all object creation and deletion.
-static GLV_VK_SNAPSHOT s_delta = {0};
+static VKTRACE_VK_SNAPSHOT s_delta = {0};
//=============================================================================
-// Helper structure for a GLAVE vulkan snapshot.
+// Helper structure for a VKTRACE vulkan snapshot.
// These can probably be auto-generated at some point.
//=============================================================================
-void glv_vk_malloc_and_copy(void** ppDest, size_t size, const void* pSrc)
+void vktrace_vk_malloc_and_copy(void** ppDest, size_t size, const void* pSrc)
{
*ppDest = malloc(size);
memcpy(*ppDest, pSrc, size);
}
-VkDeviceCreateInfo* glv_deepcopy_VkDeviceCreateInfo(const VkDeviceCreateInfo* pSrcCreateInfo)
+VkDeviceCreateInfo* vktrace_deepcopy_VkDeviceCreateInfo(const VkDeviceCreateInfo* pSrcCreateInfo)
{
VkDeviceCreateInfo* pDestCreateInfo;
// NOTE: partially duplicated code from add_VkDeviceCreateInfo_to_packet(...)
{
uint32_t i;
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VkDeviceCreateInfo), pSrcCreateInfo);
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VkDeviceQueueCreateInfo), pSrcCreateInfo->pRequestedQueues);
+ vktrace_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VkDeviceCreateInfo), pSrcCreateInfo);
+ vktrace_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VkDeviceQueueCreateInfo), pSrcCreateInfo->pRequestedQueues);
if (pSrcCreateInfo->extensionCount > 0)
{
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames, pSrcCreateInfo->extensionCount * sizeof(char *), pSrcCreateInfo->ppEnabledExtensionNames);
+ vktrace_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames, pSrcCreateInfo->extensionCount * sizeof(char *), pSrcCreateInfo->ppEnabledExtensionNames);
for (i = 0; i < pSrcCreateInfo->extensionCount; i++)
{
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames[i], strlen(pSrcCreateInfo->ppEnabledExtensionNames[i]) + 1, pSrcCreateInfo->ppEnabledExtensionNames[i]);
+ vktrace_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames[i], strlen(pSrcCreateInfo->ppEnabledExtensionNames[i]) + 1, pSrcCreateInfo->ppEnabledExtensionNames[i]);
}
}
VkLayerCreateInfo *pSrcNext = ( VkLayerCreateInfo *) pSrcCreateInfo->pNext;
{
if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
{
- glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(VkLayerCreateInfo), pSrcNext);
- glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames, pSrcNext->layerCount * sizeof(char*), pSrcNext->ppActiveLayerNames);
+ vktrace_vk_malloc_and_copy((void**)ppDstNext, sizeof(VkLayerCreateInfo), pSrcNext);
+ vktrace_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames, pSrcNext->layerCount * sizeof(char*), pSrcNext->ppActiveLayerNames);
for (i = 0; i < pSrcNext->layerCount; i++)
{
- glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames[i], strlen(pSrcNext->ppActiveLayerNames[i]) + 1, pSrcNext->ppActiveLayerNames[i]);
+ vktrace_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames[i], strlen(pSrcNext->ppActiveLayerNames[i]) + 1, pSrcNext->ppActiveLayerNames[i]);
}
ppDstNext = (VkLayerCreateInfo**) &(*ppDstNext)->pNext;
return pDestCreateInfo;
}
-void glv_deepfree_VkDeviceCreateInfo(VkDeviceCreateInfo* pCreateInfo)
+void vktrace_deepfree_VkDeviceCreateInfo(VkDeviceCreateInfo* pCreateInfo)
{
uint32_t i;
if (pCreateInfo->pRequestedQueues != NULL)
free(pCreateInfo);
}
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+void vktrace_vk_snapshot_copy_createdevice_params(VKTRACE_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
{
pDest->physicalDevice = physicalDevice;
- pDest->pCreateInfo = glv_deepcopy_VkDeviceCreateInfo(pCreateInfo);
+ pDest->pCreateInfo = vktrace_deepcopy_VkDeviceCreateInfo(pCreateInfo);
pDest->pDevice = (VkDevice*)malloc(sizeof(VkDevice));
*pDest->pDevice = *pDevice;
}
-void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc)
+void vktrace_vk_snapshot_destroy_createdevice_params(VKTRACE_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc)
{
memset(&pSrc->physicalDevice, 0, sizeof(VkPhysicalDevice));
- glv_deepfree_VkDeviceCreateInfo(pSrc->pCreateInfo);
+ vktrace_deepfree_VkDeviceCreateInfo(pSrc->pCreateInfo);
pSrc->pCreateInfo = NULL;
free(pSrc->pDevice);
// add a new node to the global and object lists, then return it so the caller can populate the object information.
-static GLV_VK_SNAPSHOT_LL_NODE* snapshot_insert_object(GLV_VK_SNAPSHOT* pSnapshot, VkObject object, VkObjectType type)
+static VKTRACE_VK_SNAPSHOT_LL_NODE* snapshot_insert_object(VKTRACE_VK_SNAPSHOT* pSnapshot, VkObject object, VkObjectType type)
{
// Create a new node
- GLV_VK_SNAPSHOT_LL_NODE* pNewObjNode = (GLV_VK_SNAPSHOT_LL_NODE*)malloc(sizeof(GLV_VK_SNAPSHOT_LL_NODE));
- memset(pNewObjNode, 0, sizeof(GLV_VK_SNAPSHOT_LL_NODE));
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNewObjNode = (VKTRACE_VK_SNAPSHOT_LL_NODE*)malloc(sizeof(VKTRACE_VK_SNAPSHOT_LL_NODE));
+ memset(pNewObjNode, 0, sizeof(VKTRACE_VK_SNAPSHOT_LL_NODE));
pNewObjNode->obj.object = object;
pNewObjNode->obj.objType = type;
pNewObjNode->obj.status = OBJSTATUS_NONE;
}
// This is just a helper function to snapshot_remove_object(..). It is not intended for this to be called directly.
-static void snapshot_remove_obj_type(GLV_VK_SNAPSHOT* pSnapshot, VkObject object, VkObjectType objType) {
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pObjectHead[objType];
- GLV_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pObjectHead[objType];
+static void snapshot_remove_obj_type(VKTRACE_VK_SNAPSHOT* pSnapshot, VkObject object, VkObjectType objType) {
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pObjectHead[objType];
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pObjectHead[objType];
while (pTrav) {
if (pTrav->obj.object == object) {
pPrev->pNextObj = pTrav->pNextObj;
}
char str[1024];
sprintf(str, "OBJ INTERNAL ERROR : Obj %p was in global list but not in %s list", (void*)object, string_VK_OBJECT_TYPE(objType));
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, VKTRACESNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
}
// Search global list to find object,
// else:
// Report message that we didn't see it get created,
// return NULL.
-static GLV_VK_SNAPSHOT_LL_NODE* snapshot_remove_object(GLV_VK_SNAPSHOT* pSnapshot, VkObject object)
+static VKTRACE_VK_SNAPSHOT_LL_NODE* snapshot_remove_object(VKTRACE_VK_SNAPSHOT* pSnapshot, VkObject object)
{
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pGlobalObjs;
- GLV_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pGlobalObjs;
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pGlobalObjs;
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pGlobalObjs;
while (pTrav)
{
if (pTrav->obj.object == object)
// Object not found.
char str[1024];
sprintf(str, "Object %p was not found in the created object list. It should be added as a deleted object.", (void*)object);
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, object, 0, VKTRACESNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
return NULL;
}
// Add a new deleted object node to the list
-static void snapshot_insert_deleted_object(GLV_VK_SNAPSHOT* pSnapshot, VkObject object, VkObjectType type)
+static void snapshot_insert_deleted_object(VKTRACE_VK_SNAPSHOT* pSnapshot, VkObject object, VkObjectType type)
{
// Create a new node
- GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pNewObjNode = (GLV_VK_SNAPSHOT_DELETED_OBJ_NODE*)malloc(sizeof(GLV_VK_SNAPSHOT_DELETED_OBJ_NODE));
- memset(pNewObjNode, 0, sizeof(GLV_VK_SNAPSHOT_DELETED_OBJ_NODE));
+ VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE* pNewObjNode = (VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE*)malloc(sizeof(VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE));
+ memset(pNewObjNode, 0, sizeof(VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE));
pNewObjNode->objType = type;
pNewObjNode->object = object;
}
// Note: the parameters after pSnapshot match the order of vkCreateDevice(..)
-static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+static void snapshot_insert_device(VKTRACE_VK_SNAPSHOT* pSnapshot, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
{
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, VK_OBJECT_TYPE_DEVICE);
- pNode->obj.pStruct = malloc(sizeof(GLV_VK_SNAPSHOT_DEVICE_NODE));
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, VK_OBJECT_TYPE_DEVICE);
+ pNode->obj.pStruct = malloc(sizeof(VKTRACE_VK_SNAPSHOT_DEVICE_NODE));
- GLV_VK_SNAPSHOT_DEVICE_NODE* pDevNode = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pNode->obj.pStruct;
- glv_vk_snapshot_copy_createdevice_params(&pDevNode->params, physicalDevice, pCreateInfo, pDevice);
+ VKTRACE_VK_SNAPSHOT_DEVICE_NODE* pDevNode = (VKTRACE_VK_SNAPSHOT_DEVICE_NODE*)pNode->obj.pStruct;
+ vktrace_vk_snapshot_copy_createdevice_params(&pDevNode->params, physicalDevice, pCreateInfo, pDevice);
// insert at front of device list
pNode->pNextObj = pSnapshot->pDevices;
pSnapshot->deviceCount++;
}
-static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VkDevice device)
+static void snapshot_remove_device(VKTRACE_VK_SNAPSHOT* pSnapshot, VkDevice device)
{
- GLV_VK_SNAPSHOT_LL_NODE* pFoundObject = snapshot_remove_object(pSnapshot, device);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pFoundObject = snapshot_remove_object(pSnapshot, device);
if (pFoundObject != NULL)
{
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pDevices;
- GLV_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pDevices;
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = pSnapshot->pDevices;
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pPrev = pSnapshot->pDevices;
while (pTrav != NULL)
{
if (pTrav->obj.object == device)
// delete the object
if (pTrav->obj.pStruct != NULL)
{
- GLV_VK_SNAPSHOT_DEVICE_NODE* pDevNode = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pTrav->obj.pStruct;
- glv_vk_snapshot_destroy_createdevice_params(&pDevNode->params);
+ VKTRACE_VK_SNAPSHOT_DEVICE_NODE* pDevNode = (VKTRACE_VK_SNAPSHOT_DEVICE_NODE*)pTrav->obj.pStruct;
+ vktrace_vk_snapshot_destroy_createdevice_params(&pDevNode->params);
free(pDevNode);
}
free(pTrav);
// Traverse global list and return type for given object
static VkObjectType ll_get_obj_type(VkObject object) {
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
while (pTrav) {
if (pTrav->obj.object == object)
return pTrav->obj.objType;
}
char str[1024];
sprintf(str, "Attempting look-up on obj %p but it is NOT in the global list!", (void*)object);
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_MISSING_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, VKTRACESNAPSHOT_MISSING_OBJECT, LAYER_ABBREV_STR, str);
return (VkObjectType)-1;
}
static void ll_increment_use_count(VkObject object, VkObjectType objType) {
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
while (pTrav) {
if (pTrav->obj.object == object) {
pTrav->obj.numUses++;
// to confirm that the referenced objects actually exist in the snapshot; otherwise I guess the merge should fail.
char str[1024];
sprintf(str, "Unable to increment count for obj %p, will add to list as %s type and increment count", (void*)object, string_VK_OBJECT_TYPE(objType));
- layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, VKTRACESNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
// ll_insert_obj(pObj, objType);
// ll_increment_use_count(pObj, objType);
// Set selected flag state for an object node
static void set_status(VkObject object, VkObjectType objType, OBJECT_STATUS status_flag) {
if ((void*)object != NULL) {
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
while (pTrav) {
if (pTrav->obj.object == object) {
pTrav->obj.status |= status_flag;
// If we do not find it print an error
char str[1024];
sprintf(str, "Unable to set status for non-existent object %p of %s type", (void*)object, string_VK_OBJECT_TYPE(objType));
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, VKTRACESNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
}
}
// Track selected state for an object node
static void track_object_status(VkObject object, VkStateBindPoint stateBindPoint) {
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[VK_OBJECT_TYPE_COMMAND_BUFFER];
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[VK_OBJECT_TYPE_COMMAND_BUFFER];
while (pTrav) {
if (pTrav->obj.object == object) {
// If we do not find it print an error
char str[1024];
sprintf(str, "Unable to track status for non-existent Command Buffer object %p", (void*)object);
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, VKTRACESNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
}
// Reset selected flag state for an object node
static void reset_status(VkObject object, VkObjectType objType, OBJECT_STATUS status_flag) {
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[objType];
while (pTrav) {
if (pTrav->obj.object == object) {
pTrav->obj.status &= ~status_flag;
// If we do not find it print an error
char str[1024];
sprintf(str, "Unable to reset status for non-existent object %p of %s type", (void*)object, string_VK_OBJECT_TYPE(objType));
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, GLVSNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, VKTRACESNAPSHOT_UNKNOWN_OBJECT, LAYER_ABBREV_STR, str);
}
#include "vk_dispatch_table_helper.h"
-static void initGlaveSnapshot(void)
+static void initVktraceSnapshot(void)
{
const char *strOpt;
- // initialize GlaveSnapshot options
+ // initialize VktraceSnapshot options
getLayerOptionEnum(LAYER_NAME_STR "ReportLevel", (uint32_t *) &g_reportingLevel);
g_actionIsDefault = getLayerOptionEnum(LAYER_NAME_STR "DebugAction", (uint32_t *) &g_debugAction);
{
VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
pCurObj = gpuw;
- loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
+ loader_platform_thread_once(&tabOnce, initVktraceSnapshot);
VkResult result = nextTable.GetPhysicalDeviceInfo((VkPhysicalDevice)gpuw->nextObject, infoType, pDataSize, pData);
return result;
}
{
VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
pCurObj = gpuw;
- loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
+ loader_platform_thread_once(&tabOnce, initVktraceSnapshot);
VkResult result = nextTable.CreateDevice((VkPhysicalDevice)gpuw->nextObject, pCreateInfo, pDevice);
if (result == VK_SUCCESS)
{
loader_platform_thread_unlock_mutex(&objLock);
// Report any remaining objects in LL
- GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs;
while (pTrav != NULL)
{
// if (pTrav->obj.objType == VK_OBJECT_TYPE_SWAP_CHAIN_IMAGE_WSI ||
// pTrav->obj.objType == VK_OBJECT_TYPE_SWAP_CHAIN_MEMORY_WSI)
// {
-// GLV_VK_SNAPSHOT_LL_NODE *pDel = pTrav;
+// VKTRACE_VK_SNAPSHOT_LL_NODE *pDel = pTrav;
// pTrav = pTrav->pNextGlobal;
// snapshot_remove_object(&s_delta, (void*)(pDel->obj.pVkObject));
// } else {
char str[1024];
sprintf(str, "OBJ ERROR : %s object %p has not been destroyed (was used %lu times).", string_VK_OBJECT_TYPE(pTrav->obj.objType), (void*)pTrav->obj.object, pTrav->obj.numUses);
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, GLVSNAPSHOT_OBJECT_LEAK, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, device, 0, VKTRACESNAPSHOT_OBJECT_LEAK, LAYER_ABBREV_STR, str);
pTrav = pTrav->pNextGlobal;
// }
}
ll_increment_use_count(physicalDevice, VK_OBJECT_TYPE_PHYSICAL_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
pCurObj = gpuw;
- loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
+ loader_platform_thread_once(&tabOnce, initVktraceSnapshot);
VkResult result = nextTable.EnumerateLayers((VkPhysicalDevice)gpuw->nextObject, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
return result;
} else {
const char * const name;
};
-#define GLAVE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE 1
-static const struct extProps mtExts[GLAVE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE] = {
+#define VKTRACE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE 1
+static const struct extProps mtExts[VKTRACE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE] = {
// TODO what is the version?
{ 0x10, LAYER_NAME_STR }
};
if (pData == NULL)
return VK_SUCCESS;
count = (uint32_t *) pData;
- *count = GLAVE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE;
+ *count = VKTRACE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE;
break;
case VK_EXTENSION_INFO_TYPE_PROPERTIES:
*pDataSize = sizeof(VkExtensionProperties);
if (pData == NULL)
return VK_SUCCESS;
- if (extensionIndex >= GLAVE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE)
+ if (extensionIndex >= VKTRACE_SNAPSHOT_LAYER_EXT_ARRAY_SIZE)
return VK_ERROR_INVALID_VALUE;
ext_props = (VkExtensionProperties *) pData;
ext_props->version = mtExts[extensionIndex].version;
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_DEVICE_MEMORY);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_DEVICE_MEMORY);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
ll_increment_use_count(physicalDevice0, VK_OBJECT_TYPE_PHYSICAL_DEVICE);
loader_platform_thread_unlock_mutex(&objLock);
pCurObj = gpuw;
- loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
+ loader_platform_thread_once(&tabOnce, initVktraceSnapshot);
VkResult result = nextTable.GetMultiDeviceCompatibility((VkPhysicalDevice)gpuw->nextObject, physicalDevice1, pInfo);
return result;
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFence, VK_OBJECT_TYPE_FENCE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFence, VK_OBJECT_TYPE_FENCE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSemaphore, VK_OBJECT_TYPE_SEMAPHORE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSemaphore, VK_OBJECT_TYPE_SEMAPHORE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pEvent, VK_OBJECT_TYPE_EVENT);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pEvent, VK_OBJECT_TYPE_EVENT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pQueryPool, VK_OBJECT_TYPE_QUERY_POOL);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pQueryPool, VK_OBJECT_TYPE_QUERY_POOL);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pBuffer, VK_OBJECT_TYPE_BUFFER);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pBuffer, VK_OBJECT_TYPE_BUFFER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_BUFFER_VIEW);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_BUFFER_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_IMAGE_VIEW);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_IMAGE_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pView, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pShader, VK_OBJECT_TYPE_SHADER);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pShader, VK_OBJECT_TYPE_SHADER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pPipeline, VK_OBJECT_TYPE_PIPELINE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSampler, VK_OBJECT_TYPE_SAMPLER);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSampler, VK_OBJECT_TYPE_SAMPLER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSetLayout, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pSetLayout, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pDescriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pDescriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
{
for (uint32_t i = 0; i < *pCount; i++) {
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_VP_STATE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_VP_STATE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_CB_STATE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_CB_STATE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pState, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pCmdBuffer, VK_OBJECT_TYPE_COMMAND_BUFFER);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pCmdBuffer, VK_OBJECT_TYPE_COMMAND_BUFFER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFramebuffer, VK_OBJECT_TYPE_FRAMEBUFFER);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pFramebuffer, VK_OBJECT_TYPE_FRAMEBUFFER);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
if (result == VK_SUCCESS)
{
loader_platform_thread_lock_mutex(&objLock);
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pRenderPass, VK_OBJECT_TYPE_RENDER_PASS);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pRenderPass, VK_OBJECT_TYPE_RENDER_PASS);
pNode->obj.pStruct = NULL;
loader_platform_thread_unlock_mutex(&objLock);
}
loader_platform_thread_lock_mutex(&objLock);
#if 0
- GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(&s_delta, *pImage, VK_OBJECT_TYPE_IMAGE);
pNode->obj.pStruct = NULL;
- GLV_VK_SNAPSHOT_LL_NODE* pMemNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pMemNode = snapshot_insert_object(&s_delta, *pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);
pMemNode->obj.pStruct = NULL;
#else
snapshot_insert_object(&s_delta, *pSwapChain, VK_OBJECT_TYPE_SWAP_CHAIN_WSI);
//=================================================================================================
// Exported methods
//=================================================================================================
-void glvSnapshotStartTracking(void)
+void vktraceSnapshotStartTracking(void)
{
assert(!"Not Implemented");
}
//=================================================================================================
-GLV_VK_SNAPSHOT glvSnapshotGetDelta(void)
+VKTRACE_VK_SNAPSHOT vktraceSnapshotGetDelta(void)
{
// copy the delta by merging it into an empty snapshot
- GLV_VK_SNAPSHOT empty;
- memset(&empty, 0, sizeof(GLV_VK_SNAPSHOT));
+ VKTRACE_VK_SNAPSHOT empty;
+ memset(&empty, 0, sizeof(VKTRACE_VK_SNAPSHOT));
- return glvSnapshotMerge(&s_delta, &empty);
+ return vktraceSnapshotMerge(&s_delta, &empty);
}
//=================================================================================================
-GLV_VK_SNAPSHOT glvSnapshotGetSnapshot(void)
+VKTRACE_VK_SNAPSHOT vktraceSnapshotGetSnapshot(void)
{
// copy the master snapshot by merging it into an empty snapshot
- GLV_VK_SNAPSHOT empty;
- memset(&empty, 0, sizeof(GLV_VK_SNAPSHOT));
+ VKTRACE_VK_SNAPSHOT empty;
+ memset(&empty, 0, sizeof(VKTRACE_VK_SNAPSHOT));
- return glvSnapshotMerge(&s_snapshot, &empty);
+ return vktraceSnapshotMerge(&s_snapshot, &empty);
}
//=================================================================================================
-void glvSnapshotPrintDelta()
+void vktraceSnapshotPrintDelta()
{
char str[2048];
- GLV_VK_SNAPSHOT_LL_NODE* pTrav = s_delta.pGlobalObjs;
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pTrav = s_delta.pGlobalObjs;
sprintf(str, "==== DELTA SNAPSHOT contains %lu objects, %lu devices, and %lu deleted objects", s_delta.globalObjCount, s_delta.deviceCount, s_delta.deltaDeletedObjectCount);
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)NULL, 0, VKTRACESNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
// print all objects
if (s_delta.globalObjCount > 0)
{
sprintf(str, "======== DELTA SNAPSHOT Created Objects:");
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.object, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.object, 0, VKTRACESNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
while (pTrav != NULL)
{
sprintf(str, "\t%s obj %p", string_VK_OBJECT_TYPE(pTrav->obj.objType), (void*)pTrav->obj.object);
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.object, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pTrav->obj.object, 0, VKTRACESNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
pTrav = pTrav->pNextGlobal;
}
}
// print devices
if (s_delta.deviceCount > 0)
{
- GLV_VK_SNAPSHOT_LL_NODE* pDeviceNode = s_delta.pDevices;
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pDeviceNode = s_delta.pDevices;
sprintf(str, "======== DELTA SNAPSHOT Devices:");
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)NULL, 0, VKTRACESNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
while (pDeviceNode != NULL)
{
- GLV_VK_SNAPSHOT_DEVICE_NODE* pDev = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pDeviceNode->obj.pStruct;
+ VKTRACE_VK_SNAPSHOT_DEVICE_NODE* pDev = (VKTRACE_VK_SNAPSHOT_DEVICE_NODE*)pDeviceNode->obj.pStruct;
char * createInfoStr = vk_print_vkdevicecreateinfo(pDev->params.pCreateInfo, "\t\t");
sprintf(str, "\t%s obj %p:\n%s", string_VK_OBJECT_TYPE(VK_OBJECT_TYPE_DEVICE), (void*)pDeviceNode->obj.object, createInfoStr);
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDeviceNode->obj.object, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDeviceNode->obj.object, 0, VKTRACESNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
pDeviceNode = pDeviceNode->pNextObj;
}
}
// print deleted objects
if (s_delta.deltaDeletedObjectCount > 0)
{
- GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pDelObjNode = s_delta.pDeltaDeletedObjects;
+ VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE* pDelObjNode = s_delta.pDeltaDeletedObjects;
sprintf(str, "======== DELTA SNAPSHOT Deleted Objects:");
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)NULL, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkObject)NULL, 0, VKTRACESNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
while (pDelObjNode != NULL)
{
sprintf(str, " %s obj %p", string_VK_OBJECT_TYPE(pDelObjNode->objType), (void*)pDelObjNode->object);
- layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDelObjNode->object, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDelObjNode->object, 0, VKTRACESNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
pDelObjNode = pDelObjNode->pNextObj;
}
}
}
-void glvSnapshotStopTracking(void)
+void vktraceSnapshotStopTracking(void)
{
assert(!"Not Implemented");
}
-void glvSnapshotClear(void)
+void vktraceSnapshotClear(void)
{
assert(!"Not Implemented");
}
-GLV_VK_SNAPSHOT glvSnapshotMerge(const GLV_VK_SNAPSHOT* const pDelta, const GLV_VK_SNAPSHOT* const pSnapshot)
+VKTRACE_VK_SNAPSHOT vktraceSnapshotMerge(const VKTRACE_VK_SNAPSHOT* const pDelta, const VKTRACE_VK_SNAPSHOT* const pSnapshot)
{
assert(!"Not Implemented");
}
//=============================================================================
// Old Exported methods
//=============================================================================
-uint64_t glvSnapshotGetObjectCount(VkObjectType type)
+uint64_t vktraceSnapshotGetObjectCount(VkObjectType type)
{
uint64_t retVal = /*(type == VK_OBJECT_TYPE_ANY) ? s_delta.globalObjCount :*/ s_delta.numObjs[type];
return retVal;
}
-VkResult glvSnapshotGetObjects(VkObjectType type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray)
+VkResult vktraceSnapshotGetObjects(VkObjectType type, uint64_t objCount, VKTRACE_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray)
{
// This bool flags if we're pulling all objs or just a single class of objs
bool32_t bAllObjs = false; /*(type == VK_OBJECT_TYPE_ANY);*/
if (objCount > maxObjCount) {
char str[1024];
sprintf(str, "OBJ ERROR : Received objTrackGetObjects() request for %lu objs, but there are only %lu objs of type %s", objCount, maxObjCount, string_VK_OBJECT_TYPE(type));
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_OBJCOUNT_MAX_EXCEEDED, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, VKTRACESNAPSHOT_OBJCOUNT_MAX_EXCEEDED, LAYER_ABBREV_STR, str);
return VK_ERROR_INVALID_VALUE;
}
- GLV_VK_SNAPSHOT_LL_NODE* pTrav = (bAllObjs) ? s_delta.pGlobalObjs : s_delta.pObjectHead[type];
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pTrav = (bAllObjs) ? s_delta.pGlobalObjs : s_delta.pObjectHead[type];
for (uint64_t i = 0; i < objCount; i++) {
if (!pTrav) {
char str[1024];
sprintf(str, "OBJ INTERNAL ERROR : Ran out of %s objs! Should have %lu, but only copied %lu and not the requested %lu.", string_VK_OBJECT_TYPE(type), maxObjCount, i, objCount);
- layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, GLVSNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
+ layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, 0, 0, VKTRACESNAPSHOT_INTERNAL_ERROR, LAYER_ABBREV_STR, str);
return VK_ERROR_UNKNOWN;
}
- memcpy(&pObjNodeArray[i], pTrav, sizeof(GLV_VK_SNAPSHOT_OBJECT_NODE));
+ memcpy(&pObjNodeArray[i], pTrav, sizeof(VKTRACE_VK_SNAPSHOT_OBJECT_NODE));
pTrav = (bAllObjs) ? pTrav->pNextGlobal : pTrav->pNextObj;
}
return VK_SUCCESS;
}
-void glvSnapshotPrintObjects(void)
+void vktraceSnapshotPrintObjects(void)
{
- glvSnapshotPrintDelta();
+ vktraceSnapshotPrintDelta();
}
#include "vk_generic_intercept_proc_helper.h"
if ((void*)physicalDevice == NULL)
return NULL;
pCurObj = gpuw;
- loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
+ loader_platform_thread_once(&tabOnce, initVktraceSnapshot);
// TODO: This needs to be changed, need only the entry points this layer intercepts
//addr = layer_intercept_proc(funcName);
//if (addr)
// return addr;
//else
- if (!strncmp("glvSnapshotGetObjectCount", funcName, sizeof("glvSnapshotGetObjectCount")))
- return glvSnapshotGetObjectCount;
- else if (!strncmp("glvSnapshotGetObjects", funcName, sizeof("glvSnapshotGetObjects")))
- return glvSnapshotGetObjects;
- else if (!strncmp("glvSnapshotPrintObjects", funcName, sizeof("glvSnapshotPrintObjects")))
- return glvSnapshotPrintObjects;
- else if (!strncmp("glvSnapshotStartTracking", funcName, sizeof("glvSnapshotStartTracking")))
- return glvSnapshotStartTracking;
- else if (!strncmp("glvSnapshotGetDelta", funcName, sizeof("glvSnapshotGetDelta")))
- return glvSnapshotGetDelta;
- else if (!strncmp("glvSnapshotGetSnapshot", funcName, sizeof("glvSnapshotGetSnapshot")))
- return glvSnapshotGetSnapshot;
- else if (!strncmp("glvSnapshotPrintDelta", funcName, sizeof("glvSnapshotPrintDelta")))
- return glvSnapshotPrintDelta;
- else if (!strncmp("glvSnapshotStopTracking", funcName, sizeof("glvSnapshotStopTracking")))
- return glvSnapshotStopTracking;
- else if (!strncmp("glvSnapshotClear", funcName, sizeof("glvSnapshotClear")))
- return glvSnapshotClear;
- else if (!strncmp("glvSnapshotMerge", funcName, sizeof("glvSnapshotMerge")))
- return glvSnapshotMerge;
+ if (!strncmp("vktraceSnapshotGetObjectCount", funcName, sizeof("vktraceSnapshotGetObjectCount")))
+ return vktraceSnapshotGetObjectCount;
+ else if (!strncmp("vktraceSnapshotGetObjects", funcName, sizeof("vktraceSnapshotGetObjects")))
+ return vktraceSnapshotGetObjects;
+ else if (!strncmp("vktraceSnapshotPrintObjects", funcName, sizeof("vktraceSnapshotPrintObjects")))
+ return vktraceSnapshotPrintObjects;
+ else if (!strncmp("vktraceSnapshotStartTracking", funcName, sizeof("vktraceSnapshotStartTracking")))
+ return vktraceSnapshotStartTracking;
+ else if (!strncmp("vktraceSnapshotGetDelta", funcName, sizeof("vktraceSnapshotGetDelta")))
+ return vktraceSnapshotGetDelta;
+ else if (!strncmp("vktraceSnapshotGetSnapshot", funcName, sizeof("vktraceSnapshotGetSnapshot")))
+ return vktraceSnapshotGetSnapshot;
+ else if (!strncmp("vktraceSnapshotPrintDelta", funcName, sizeof("vktraceSnapshotPrintDelta")))
+ return vktraceSnapshotPrintDelta;
+ else if (!strncmp("vktraceSnapshotStopTracking", funcName, sizeof("vktraceSnapshotStopTracking")))
+ return vktraceSnapshotStopTracking;
+ else if (!strncmp("vktraceSnapshotClear", funcName, sizeof("vktraceSnapshotClear")))
+ return vktraceSnapshotClear;
+ else if (!strncmp("vktraceSnapshotMerge", funcName, sizeof("vktraceSnapshotMerge")))
+ return vktraceSnapshotMerge;
else {
if (gpuw->pGPA == NULL)
return NULL;
/*
- * GLAVE & vulkan
+ * VKTRACE & vulkan
*
* Copyright (C) 2015 LunarG, Inc. and Valve Corporation
*
#include "vkLayer.h"
#include "vulkan.h"
-// Glave Snapshot ERROR codes
-typedef enum _GLAVE_SNAPSHOT_ERROR
+// VkTrace Snapshot ERROR codes
+typedef enum _VKTRACE_SNAPSHOT_ERROR
{
- GLVSNAPSHOT_NONE, // Used for INFO & other non-error messages
- GLVSNAPSHOT_UNKNOWN_OBJECT, // Updating uses of object that's not in global object list
- GLVSNAPSHOT_INTERNAL_ERROR, // Bug with data tracking within the layer
- GLVSNAPSHOT_DESTROY_OBJECT_FAILED, // Couldn't find object to be destroyed
- GLVSNAPSHOT_MISSING_OBJECT, // Attempted look-up on object that isn't in global object list
- GLVSNAPSHOT_OBJECT_LEAK, // OBJECT was not correctly freed/destroyed
- GLVSNAPSHOT_OBJCOUNT_MAX_EXCEEDED, // Request for Object data in excess of max obj count
- GLVSNAPSHOT_INVALID_FENCE, // Requested status of unsubmitted fence object
- GLVSNAPSHOT_VIEWPORT_NOT_BOUND, // Draw submitted with no viewport state object bound
- GLVSNAPSHOT_RASTER_NOT_BOUND, // Draw submitted with no raster state object bound
- GLVSNAPSHOT_COLOR_BLEND_NOT_BOUND, // Draw submitted with no color blend state object bound
- GLVSNAPSHOT_DEPTH_STENCIL_NOT_BOUND, // Draw submitted with no depth-stencil state object bound
- GLVSNAPSHOT_GPU_MEM_MAPPED, // Mem object ref'd in cmd buff is still mapped
- GLVSNAPSHOT_GETGPUINFO_NOT_CALLED, // Gpu Information has not been requested before drawing
- GLVSNAPSHOT_MEMREFCOUNT_MAX_EXCEEDED, // Number of QueueSubmit memory references exceeds GPU maximum
- GLVSNAPSHOT_SNAPSHOT_DATA, // Message being printed is actually snapshot data
-} GLAVE_SNAPSHOT_ERROR;
+ VKTRACESNAPSHOT_NONE, // Used for INFO & other non-error messages
+ VKTRACESNAPSHOT_UNKNOWN_OBJECT, // Updating uses of object that's not in global object list
+ VKTRACESNAPSHOT_INTERNAL_ERROR, // Bug with data tracking within the layer
+ VKTRACESNAPSHOT_DESTROY_OBJECT_FAILED, // Couldn't find object to be destroyed
+ VKTRACESNAPSHOT_MISSING_OBJECT, // Attempted look-up on object that isn't in global object list
+ VKTRACESNAPSHOT_OBJECT_LEAK, // OBJECT was not correctly freed/destroyed
+ VKTRACESNAPSHOT_OBJCOUNT_MAX_EXCEEDED, // Request for Object data in excess of max obj count
+ VKTRACESNAPSHOT_INVALID_FENCE, // Requested status of unsubmitted fence object
+ VKTRACESNAPSHOT_VIEWPORT_NOT_BOUND, // Draw submitted with no viewport state object bound
+ VKTRACESNAPSHOT_RASTER_NOT_BOUND, // Draw submitted with no raster state object bound
+ VKTRACESNAPSHOT_COLOR_BLEND_NOT_BOUND, // Draw submitted with no color blend state object bound
+ VKTRACESNAPSHOT_DEPTH_STENCIL_NOT_BOUND, // Draw submitted with no depth-stencil state object bound
+ VKTRACESNAPSHOT_GPU_MEM_MAPPED, // Mem object ref'd in cmd buff is still mapped
+ VKTRACESNAPSHOT_GETGPUINFO_NOT_CALLED, // Gpu Information has not been requested before drawing
+ VKTRACESNAPSHOT_MEMREFCOUNT_MAX_EXCEEDED, // Number of QueueSubmit memory references exceeds GPU maximum
+ VKTRACESNAPSHOT_SNAPSHOT_DATA, // Message being printed is actually snapshot data
+} VKTRACE_SNAPSHOT_ERROR;
// Object Status -- used to track state of individual objects
typedef enum _OBJECT_STATUS
}
//=============================================================================
-// Helper structure for a GLAVE vulkan snapshot.
+// Helper structure for a VKTRACE vulkan snapshot.
// These can probably be auto-generated at some point.
//=============================================================================
-void glv_vk_malloc_and_copy(void** ppDest, size_t size, const void* pSrc);
+void vktrace_vk_malloc_and_copy(void** ppDest, size_t size, const void* pSrc);
-typedef struct _GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS
+typedef struct _VKTRACE_VK_SNAPSHOT_CREATEDEVICE_PARAMS
{
VkPhysicalDevice physicalDevice;
VkDeviceCreateInfo* pCreateInfo;
VkDevice* pDevice;
-} GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS;
+} VKTRACE_VK_SNAPSHOT_CREATEDEVICE_PARAMS;
-VkDeviceCreateInfo* glv_deepcopy_xgl_device_create_info(const VkDeviceCreateInfo* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VkDeviceCreateInfo* pCreateInfo);
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
-void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc);
+VkDeviceCreateInfo* vktrace_deepcopy_xgl_device_create_info(const VkDeviceCreateInfo* pSrcCreateInfo);void vktrace_deepfree_xgl_device_create_info(VkDeviceCreateInfo* pCreateInfo);
+void vktrace_vk_snapshot_copy_createdevice_params(VKTRACE_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
+void vktrace_vk_snapshot_destroy_createdevice_params(VKTRACE_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc);
//=============================================================================
-// Glave Snapshot helper structs
+// VkTrace Snapshot helper structs
//=============================================================================
// Node that stores information about an object
-typedef struct _GLV_VK_SNAPSHOT_OBJECT_NODE {
+typedef struct _VKTRACE_VK_SNAPSHOT_OBJECT_NODE {
VkObject object;
VkObjectType objType;
uint64_t numUses;
OBJECT_STATUS status;
- void* pStruct; //< optionally points to a device-specific struct (ie, GLV_VK_SNAPSHOT_DEVICE_NODE)
-} GLV_VK_SNAPSHOT_OBJECT_NODE;
+ void* pStruct; //< optionally points to a device-specific struct (ie, VKTRACE_VK_SNAPSHOT_DEVICE_NODE)
+} VKTRACE_VK_SNAPSHOT_OBJECT_NODE;
// Node that stores information about an VkDevice
-typedef struct _GLV_VK_SNAPSHOT_DEVICE_NODE {
+typedef struct _VKTRACE_VK_SNAPSHOT_DEVICE_NODE {
// This object
VkDevice device;
// CreateDevice parameters
- GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS params;
+ VKTRACE_VK_SNAPSHOT_CREATEDEVICE_PARAMS params;
// Other information a device needs to store.
// TODO: anything?
-} GLV_VK_SNAPSHOT_DEVICE_NODE;
+} VKTRACE_VK_SNAPSHOT_DEVICE_NODE;
// Linked-List node that stores information about an object
// We maintain a "Global" list which links every object and a
// per-Object list which just links objects of a given type
// The object node has both pointers so the actual nodes are shared between the two lists
-typedef struct _GLV_VK_SNAPSHOT_LL_NODE {
- struct _GLV_VK_SNAPSHOT_LL_NODE *pNextObj;
- struct _GLV_VK_SNAPSHOT_LL_NODE *pNextGlobal;
- GLV_VK_SNAPSHOT_OBJECT_NODE obj;
-} GLV_VK_SNAPSHOT_LL_NODE;
+typedef struct _VKTRACE_VK_SNAPSHOT_LL_NODE {
+ struct _VKTRACE_VK_SNAPSHOT_LL_NODE *pNextObj;
+ struct _VKTRACE_VK_SNAPSHOT_LL_NODE *pNextGlobal;
+ VKTRACE_VK_SNAPSHOT_OBJECT_NODE obj;
+} VKTRACE_VK_SNAPSHOT_LL_NODE;
// Linked-List node to identify an object that has been deleted,
// but the delta snapshot never saw it get created.
-typedef struct _GLV_VK_SNAPSHOT_DELETED_OBJ_NODE {
- struct _GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pNextObj;
+typedef struct _VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE {
+ struct _VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE* pNextObj;
VkObject object;
VkObjectType objType;
-} GLV_VK_SNAPSHOT_DELETED_OBJ_NODE;
+} VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE;
//=============================================================================
-// Main structure for a GLAVE vulkan snapshot.
+// Main structure for a VKTRACE vulkan snapshot.
//=============================================================================
-typedef struct _GLV_VK_SNAPSHOT {
+typedef struct _VKTRACE_VK_SNAPSHOT {
// Stores a list of all the objects known by this snapshot.
// This may be used as a shortcut to more easily find objects.
uint64_t globalObjCount;
- GLV_VK_SNAPSHOT_LL_NODE* pGlobalObjs;
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pGlobalObjs;
// TEMPORARY: Keep track of all objects of each type
uint64_t numObjs[VK_NUM_OBJECT_TYPE];
- GLV_VK_SNAPSHOT_LL_NODE *pObjectHead[VK_NUM_OBJECT_TYPE];
+ VKTRACE_VK_SNAPSHOT_LL_NODE *pObjectHead[VK_NUM_OBJECT_TYPE];
// List of created devices and [potentially] hierarchical tree of the objects on it.
// This is used to represent ownership of the objects
uint64_t deviceCount;
- GLV_VK_SNAPSHOT_LL_NODE* pDevices;
+ VKTRACE_VK_SNAPSHOT_LL_NODE* pDevices;
// This is used to support snapshot deltas.
uint64_t deltaDeletedObjectCount;
- GLV_VK_SNAPSHOT_DELETED_OBJ_NODE* pDeltaDeletedObjects;
-} GLV_VK_SNAPSHOT;
+ VKTRACE_VK_SNAPSHOT_DELETED_OBJ_NODE* pDeltaDeletedObjects;
+} VKTRACE_VK_SNAPSHOT;
//=============================================================================
// prototype for extension functions
// 7) 'Clear()' will clear the 'deltaSnapshot' and the 'masterSnapshot'.
//=============================================================================
-void glvSnapshotStartTracking(void);
-GLV_VK_SNAPSHOT glvSnapshotGetDelta(void);
-GLV_VK_SNAPSHOT glvSnapshotGetSnapshot(void);
-void glvSnapshotPrintDelta(void);
-void glvSnapshotStopTracking(void);
-void glvSnapshotClear(void);
+void vktraceSnapshotStartTracking(void);
+VKTRACE_VK_SNAPSHOT vktraceSnapshotGetDelta(void);
+VKTRACE_VK_SNAPSHOT vktraceSnapshotGetSnapshot(void);
+void vktraceSnapshotPrintDelta(void);
+void vktraceSnapshotStopTracking(void);
+void vktraceSnapshotClear(void);
// utility
// merge a delta into a snapshot and return the updated snapshot
-GLV_VK_SNAPSHOT glvSnapshotMerge(const GLV_VK_SNAPSHOT * const pDelta, const GLV_VK_SNAPSHOT * const pSnapshot);
+VKTRACE_VK_SNAPSHOT vktraceSnapshotMerge(const VKTRACE_VK_SNAPSHOT * const pDelta, const VKTRACE_VK_SNAPSHOT * const pSnapshot);
-uint64_t glvSnapshotGetObjectCount(VkObjectType type);
-VkResult glvSnapshotGetObjects(VkObjectType type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray);
-void glvSnapshotPrintObjects(void);
+uint64_t vktraceSnapshotGetObjectCount(VkObjectType type);
+VkResult vktraceSnapshotGetObjects(VkObjectType type, uint64_t objCount, VKTRACE_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray);
+void vktraceSnapshotPrintObjects(void);
// Func ptr typedefs
-typedef uint64_t (*GLVSNAPSHOT_GET_OBJECT_COUNT)(VkObjectType);
-typedef VkResult (*GLVSNAPSHOT_GET_OBJECTS)(VkObjectType, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*);
-typedef void (*GLVSNAPSHOT_PRINT_OBJECTS)(void);
-typedef void (*GLVSNAPSHOT_START_TRACKING)(void);
-typedef GLV_VK_SNAPSHOT (*GLVSNAPSHOT_GET_DELTA)(void);
-typedef GLV_VK_SNAPSHOT (*GLVSNAPSHOT_GET_SNAPSHOT)(void);
-typedef void (*GLVSNAPSHOT_PRINT_DELTA)(void);
-typedef void (*GLVSNAPSHOT_STOP_TRACKING)(void);
-typedef void (*GLVSNAPSHOT_CLEAR)(void);
+typedef uint64_t (*VKTRACESNAPSHOT_GET_OBJECT_COUNT)(VkObjectType);
+typedef VkResult (*VKTRACESNAPSHOT_GET_OBJECTS)(VkObjectType, uint64_t, VKTRACE_VK_SNAPSHOT_OBJECT_NODE*);
+typedef void (*VKTRACESNAPSHOT_PRINT_OBJECTS)(void);
+typedef void (*VKTRACESNAPSHOT_START_TRACKING)(void);
+typedef VKTRACE_VK_SNAPSHOT (*VKTRACESNAPSHOT_GET_DELTA)(void);
+typedef VKTRACE_VK_SNAPSHOT (*VKTRACESNAPSHOT_GET_SNAPSHOT)(void);
+typedef void (*VKTRACESNAPSHOT_PRINT_DELTA)(void);
+typedef void (*VKTRACESNAPSHOT_STOP_TRACKING)(void);
+typedef void (*VKTRACESNAPSHOT_CLEAR)(void);
include("${SRC_DIR}/build_options.cmake")
file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-replay-vk-funcs vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vkreplay_vk_func_ptrs.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-replay-c vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vkreplay_vk_replay_gen.cpp)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-replay-obj-mapper-h vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vkreplay_vk_objmapper.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-replay-vk-funcs vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vkreplay_vk_func_ptrs.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-replay-c vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vkreplay_vk_replay_gen.cpp)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-replay-obj-mapper-h vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vkreplay_vk_objmapper.h)
if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
set(OS_REPLAYER_LIBS
codegen/vkreplay_vk_func_ptrs.h
codegen/vkreplay_vk_objmapper.h
${CMAKE_CURRENT_SOURCE_DIR}/../vulkan/codegen_utils/vk_enum_string_helper.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_packet_id.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_packets.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_wsi_swapchain_packets.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_wsi_device_swapchain_packets.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_debug_report_lunarg_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_packet_id.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_wsi_swapchain_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_wsi_device_swapchain_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_debug_report_lunarg_packets.h
)
include_directories(
${SRC_DIR}/vktrace_common
${SRC_DIR}/thirdparty
${CMAKE_CURRENT_SOURCE_DIR}
- ${CODEGEN_GLVVK_DIR}
- ${GLV_VULKAN_INCLUDE_DIR}
+ ${CODEGEN_VKTRACE_DIR}
+ ${VKTRACE_VULKAN_INCLUDE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../vulkan/codegen_utils
)
target_link_libraries(${PROJECT_NAME}
${OS_REPLAYER_LIBS}
- ${GLV_VULKAN_LIB}
+ ${VKTRACE_VULKAN_LIB}
vktrace_common
)
}
vkReplay* g_pReplayer = NULL;
-GLV_CRITICAL_SECTION g_handlerLock;
+VKTRACE_CRITICAL_SECTION g_handlerLock;
PFN_vkDbgMsgCallback g_fpDbgMsgCallback;
-glv_replay::GLV_DBG_MSG_CALLBACK_FUNCTION g_fpGlvCallback = NULL;
+vktrace_replay::VKTRACE_DBG_MSG_CALLBACK_FUNCTION g_fpVktraceCallback = NULL;
static void VKAPI vkErrorHandler(
VkFlags msgFlags,
const char* pMsg,
void* pUserData)
{
- glv_enter_critical_section(&g_handlerLock);
+ vktrace_enter_critical_section(&g_handlerLock);
if ((msgFlags & VK_DBG_REPORT_ERROR_BIT) == VK_DBG_REPORT_ERROR_BIT)
{
- glv_LogError("MsgFlags %d with object %#" PRIxLEAST64 ", location %u returned msgCode %d and msg %s",
+ vktrace_LogError("MsgFlags %d with object %#" PRIxLEAST64 ", location %u returned msgCode %d and msg %s",
msgFlags, srcObjectHandle, location, msgCode, (char *) pMsg);
g_pReplayer->push_validation_msg(msgFlags, objType, srcObjectHandle, location, msgCode, pLayerPrefix, (char *) pMsg, pUserData);
- if (g_fpGlvCallback != NULL)
+ if (g_fpVktraceCallback != NULL)
{
- g_fpGlvCallback(glv_replay::GLV_DBG_MSG_ERROR, pMsg);
+ g_fpVktraceCallback(vktrace_replay::VKTRACE_DBG_MSG_ERROR, pMsg);
}
}
else if ((msgFlags & VK_DBG_REPORT_WARN_BIT) == VK_DBG_REPORT_WARN_BIT ||
(msgFlags & VK_DBG_REPORT_PERF_WARN_BIT) == VK_DBG_REPORT_PERF_WARN_BIT)
{
- if (g_fpGlvCallback != NULL)
+ if (g_fpVktraceCallback != NULL)
{
- g_fpGlvCallback(glv_replay::GLV_DBG_MSG_WARNING, pMsg);
+ g_fpVktraceCallback(vktrace_replay::VKTRACE_DBG_MSG_WARNING, pMsg);
}
}
else
{
- if (g_fpGlvCallback != NULL)
+ if (g_fpVktraceCallback != NULL)
{
- g_fpGlvCallback(glv_replay::GLV_DBG_MSG_INFO, pMsg);
+ g_fpVktraceCallback(vktrace_replay::VKTRACE_DBG_MSG_INFO, pMsg);
}
}
- glv_leave_critical_section(&g_handlerLock);
+ vktrace_leave_critical_section(&g_handlerLock);
}
-void VkReplaySetLogCallback(GLV_REPORT_CALLBACK_FUNCTION pCallback)
+void VkReplaySetLogCallback(VKTRACE_REPORT_CALLBACK_FUNCTION pCallback)
{
- glv_LogSetCallback(pCallback);
+ vktrace_LogSetCallback(pCallback);
}
-void VkReplaySetLogLevel(GlvLogLevel level)
+void VkReplaySetLogLevel(VktraceLogLevel level)
{
- glv_LogSetLevel(level);
+ vktrace_LogSetLevel(level);
}
-void VkReplayRegisterDbgMsgCallback(glv_replay::GLV_DBG_MSG_CALLBACK_FUNCTION pCallback)
+void VkReplayRegisterDbgMsgCallback(vktrace_replay::VKTRACE_DBG_MSG_CALLBACK_FUNCTION pCallback)
{
- g_fpGlvCallback = pCallback;
+ g_fpVktraceCallback = pCallback;
}
-glv_SettingGroup* GLVTRACER_CDECL VkReplayGetSettings()
+vktrace_SettingGroup* VKTRACER_CDECL VkReplayGetSettings()
{
static BOOL bFirstTime = TRUE;
if (bFirstTime == TRUE)
{
- glv_SettingGroup_reset_defaults(&g_vkReplaySettingGroup);
+ vktrace_SettingGroup_reset_defaults(&g_vkReplaySettingGroup);
bFirstTime = FALSE;
}
return &g_vkReplaySettingGroup;
}
-void GLVTRACER_CDECL VkReplayUpdateFromSettings(glv_SettingGroup* pSettingGroups, unsigned int numSettingGroups)
+void VKTRACER_CDECL VkReplayUpdateFromSettings(vktrace_SettingGroup* pSettingGroups, unsigned int numSettingGroups)
{
- glv_SettingGroup_Apply_Overrides(&g_vkReplaySettingGroup, pSettingGroups, numSettingGroups);
+ vktrace_SettingGroup_Apply_Overrides(&g_vkReplaySettingGroup, pSettingGroups, numSettingGroups);
}
-int GLVTRACER_CDECL VkReplayInitialize(glv_replay::Display* pDisplay, glvreplay_settings *pReplaySettings)
+int VKTRACER_CDECL VkReplayInitialize(vktrace_replay::Display* pDisplay, vkreplayer_settings *pReplaySettings)
{
try
{
}
catch (int e)
{
- glv_LogError("Failed to create vkReplay, probably out of memory. Error %d", e);
+ vktrace_LogError("Failed to create vkReplay, probably out of memory. Error %d", e);
return -1;
}
- glv_create_critical_section(&g_handlerLock);
+ vktrace_create_critical_section(&g_handlerLock);
g_fpDbgMsgCallback = vkErrorHandler;
int result = g_pReplayer->init(*pDisplay);
return result;
}
-void GLVTRACER_CDECL VkReplayDeinitialize()
+void VKTRACER_CDECL VkReplayDeinitialize()
{
if (g_pReplayer != NULL)
{
delete g_pReplayer;
g_pReplayer = NULL;
}
- glv_delete_critical_section(&g_handlerLock);
+ vktrace_delete_critical_section(&g_handlerLock);
}
-glv_trace_packet_header* GLVTRACER_CDECL VkReplayInterpret(glv_trace_packet_header* pPacket)
+vktrace_trace_packet_header* VKTRACER_CDECL VkReplayInterpret(vktrace_trace_packet_header* pPacket)
{
// Attempt to interpret the packet as a Vulkan packet
- glv_trace_packet_header* pInterpretedHeader = interpret_trace_packet_vk(pPacket);
+ vktrace_trace_packet_header* pInterpretedHeader = interpret_trace_packet_vk(pPacket);
if (pInterpretedHeader == NULL)
{
- glv_LogError("Unrecognized Vulkan packet_id: %u", pPacket->packet_id);
+ vktrace_LogError("Unrecognized Vulkan packet_id: %u", pPacket->packet_id);
}
return pInterpretedHeader;
}
-glv_replay::GLV_REPLAY_RESULT GLVTRACER_CDECL VkReplayReplay(glv_trace_packet_header* pPacket)
+vktrace_replay::VKTRACE_REPLAY_RESULT VKTRACER_CDECL VkReplayReplay(vktrace_trace_packet_header* pPacket)
{
- glv_replay::GLV_REPLAY_RESULT result = glv_replay::GLV_REPLAY_ERROR;
+ vktrace_replay::VKTRACE_REPLAY_RESULT result = vktrace_replay::VKTRACE_REPLAY_ERROR;
if (g_pReplayer != NULL)
{
result = g_pReplayer->replay(pPacket);
- if (result == glv_replay::GLV_REPLAY_SUCCESS)
+ if (result == vktrace_replay::VKTRACE_REPLAY_SUCCESS)
result = g_pReplayer->pop_validation_msgs();
}
return result;
}
-int GLVTRACER_CDECL VkReplayDump()
+int VKTRACER_CDECL VkReplayDump()
{
if (g_pReplayer != NULL)
{
#include "vk_debug_report_lunarg.h"
-extern void VkReplaySetLogCallback(GLV_REPORT_CALLBACK_FUNCTION pCallback);
-extern void VkReplaySetLogLevel(GlvLogLevel level);
-extern void VkReplayRegisterDbgMsgCallback(glv_replay::GLV_DBG_MSG_CALLBACK_FUNCTION pCallback);
-extern glv_SettingGroup* GLVTRACER_CDECL VkReplayGetSettings();
-extern void GLVTRACER_CDECL VkReplayUpdateFromSettings(glv_SettingGroup* pSettingGroups, unsigned int numSettingGroups);
-extern int GLVTRACER_CDECL VkReplayInitialize(glv_replay::Display* pDisplay, glvreplay_settings *pReplaySettings);
-extern void GLVTRACER_CDECL VkReplayDeinitialize();
-extern glv_trace_packet_header* GLVTRACER_CDECL VkReplayInterpret(glv_trace_packet_header* pPacket);
-extern glv_replay::GLV_REPLAY_RESULT GLVTRACER_CDECL VkReplayReplay(glv_trace_packet_header* pPacket);
-extern int GLVTRACER_CDECL VkReplayDump();
+extern void VkReplaySetLogCallback(VKTRACE_REPORT_CALLBACK_FUNCTION pCallback);
+extern void VkReplaySetLogLevel(VktraceLogLevel level);
+extern void VkReplayRegisterDbgMsgCallback(vktrace_replay::VKTRACE_DBG_MSG_CALLBACK_FUNCTION pCallback);
+extern vktrace_SettingGroup* VKTRACER_CDECL VkReplayGetSettings();
+extern void VKTRACER_CDECL VkReplayUpdateFromSettings(vktrace_SettingGroup* pSettingGroups, unsigned int numSettingGroups);
+extern int VKTRACER_CDECL VkReplayInitialize(vktrace_replay::Display* pDisplay, vkreplayer_settings *pReplaySettings);
+extern void VKTRACER_CDECL VkReplayDeinitialize();
+extern vktrace_trace_packet_header* VKTRACER_CDECL VkReplayInterpret(vktrace_trace_packet_header* pPacket);
+extern vktrace_replay::VKTRACE_REPLAY_RESULT VKTRACER_CDECL VkReplayReplay(vktrace_trace_packet_header* pPacket);
+extern int VKTRACER_CDECL VkReplayDump();
extern PFN_vkDbgMsgCallback g_fpDbgMsgCallback;
STRINGIFY(VK_DBG_LAYER_LEVEL_ERROR), STRINGIFY(VK_DBG_LAYER_ACTION_CALLBACK)};
vkreplay_settings g_vkReplaySettings;
-glv_SettingInfo g_vk_settings_info[] =
+vktrace_SettingInfo g_vk_settings_info[] =
{
- { "dl", "DebugLevel", GLV_SETTING_UINT, &g_vkReplaySettings.debugLevel, &s_defaultVkReplaySettings.debugLevel, FALSE, "Sets the Debug Level of the Vulkan validation layers."},
- { "e", "EnableLayers", GLV_SETTING_STRING, &g_vkReplaySettings.enableLayers, &s_defaultVkReplaySettings.enableLayers, TRUE, "Comma separated list of Vulkan layers to enable."},
- { "dsrf", "DrawStateReportFlags", GLV_SETTING_STRING, &g_vkReplaySettings.drawStateReportFlags, &s_defaultVkReplaySettings.drawStateReportFlags, TRUE, "DrawState Layer reporting level"},
- { "dsda", "DrawStateDebugAction", GLV_SETTING_STRING, &g_vkReplaySettings.drawStateDebugAction, &s_defaultVkReplaySettings.drawStateDebugAction, TRUE, "DrawState Layer debug action"},
- { "mtrf", "MemTrackerReportFlags", GLV_SETTING_STRING, &g_vkReplaySettings.memTrackerReportFlags, &s_defaultVkReplaySettings.memTrackerReportFlags, TRUE, "MemTracker Layer reporting level"},
- { "mtda", "MemTrackerDebugAction", GLV_SETTING_STRING, &g_vkReplaySettings.memTrackerDebugAction, &s_defaultVkReplaySettings.memTrackerDebugAction, TRUE, "MemTracker Layer debug action"},
- { "dsrf", "ObjectTrackerReportFlags", GLV_SETTING_STRING, &g_vkReplaySettings.objectTrackerReportFlags, &s_defaultVkReplaySettings.objectTrackerReportFlags, TRUE, "ObjectTracker Layer reporting level"},
- { "dsda", "ObjectTrackerDebugAction", GLV_SETTING_STRING, &g_vkReplaySettings.objectTrackerDebugAction, &s_defaultVkReplaySettings.objectTrackerDebugAction, TRUE, "ObjectTracker Layer debug action"},};
-glv_SettingGroup g_vkReplaySettingGroup =
+ { "dl", "DebugLevel", VKTRACE_SETTING_UINT, &g_vkReplaySettings.debugLevel, &s_defaultVkReplaySettings.debugLevel, FALSE, "Sets the Debug Level of the Vulkan validation layers."},
+ { "e", "EnableLayers", VKTRACE_SETTING_STRING, &g_vkReplaySettings.enableLayers, &s_defaultVkReplaySettings.enableLayers, TRUE, "Comma separated list of Vulkan layers to enable."},
+ { "dsrf", "DrawStateReportFlags", VKTRACE_SETTING_STRING, &g_vkReplaySettings.drawStateReportFlags, &s_defaultVkReplaySettings.drawStateReportFlags, TRUE, "DrawState Layer reporting level"},
+ { "dsda", "DrawStateDebugAction", VKTRACE_SETTING_STRING, &g_vkReplaySettings.drawStateDebugAction, &s_defaultVkReplaySettings.drawStateDebugAction, TRUE, "DrawState Layer debug action"},
+ { "mtrf", "MemTrackerReportFlags", VKTRACE_SETTING_STRING, &g_vkReplaySettings.memTrackerReportFlags, &s_defaultVkReplaySettings.memTrackerReportFlags, TRUE, "MemTracker Layer reporting level"},
+ { "mtda", "MemTrackerDebugAction", VKTRACE_SETTING_STRING, &g_vkReplaySettings.memTrackerDebugAction, &s_defaultVkReplaySettings.memTrackerDebugAction, TRUE, "MemTracker Layer debug action"},
+ { "dsrf", "ObjectTrackerReportFlags", VKTRACE_SETTING_STRING, &g_vkReplaySettings.objectTrackerReportFlags, &s_defaultVkReplaySettings.objectTrackerReportFlags, TRUE, "ObjectTracker Layer reporting level"},
+ { "dsda", "ObjectTrackerDebugAction", VKTRACE_SETTING_STRING, &g_vkReplaySettings.objectTrackerDebugAction, &s_defaultVkReplaySettings.objectTrackerDebugAction, TRUE, "ObjectTracker Layer debug action"},};
+vktrace_SettingGroup g_vkReplaySettingGroup =
{
"vkreplay_vk",
sizeof(g_vk_settings_info) / sizeof(g_vk_settings_info[0]),
}
// allocate an array to contain pointers to the layer names
- pList = GLV_NEW_ARRAY(char*, (*pNumLayers));
+ pList = VKTRACE_NEW_ARRAY(char*, (*pNumLayers));
// copy the entire string to the first element in the list to keep
// the layer names localized in memory.
- pList[0] = (char*)glv_allocate_and_copy(g_vkReplaySettings.enableLayers);
+ pList[0] = (char*)vktrace_allocate_and_copy(g_vkReplaySettings.enableLayers);
// now walk the string and replace commas with NULL and record
// the pointers in the pList array.
{
if (pList[0] != NULL)
{
- GLV_DELETE(pList[0]);
+ VKTRACE_DELETE(pList[0]);
}
- GLV_DELETE(pList);
+ VKTRACE_DELETE(pList);
}
}
* THE SOFTWARE.
*
**************************************************************************/
-#ifndef GLVREPLAY_VK_SETTINGS_H
-#define GLVREPLAY_VK_SETTINGS_H
+#ifndef VKREPLAY__VK_SETTINGS_H
+#define VKREPLAY__VK_SETTINGS_H
extern "C"
{
} vkreplay_settings;
extern vkreplay_settings g_vkReplaySettings;
-extern glv_SettingGroup g_vkReplaySettingGroup;
+extern vktrace_SettingGroup g_vkReplaySettingGroup;
void apply_layerSettings_overrides();
char** get_enableLayers_list(unsigned int* pNumLayers);
void release_enableLayer_list(char** pList);
-#endif // GLVREPLAY_VK_SETTINGS_H
+#endif // VKREPLAY__VK_SETTINGS_H
// get the GPU physical properties:
res = vkGetGpuInfo( m_gpus[gpu], VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);
if (res != VK_SUCCESS)
- glv_LogWarning("Failed to retrieve properties for gpu[%d] result %d", gpu, res);
+ vktrace_LogWarning("Failed to retrieve properties for gpu[%d] result %d", gpu, res);
}
res = VK_SUCCESS;
} else if ((gpu_idx + 1) > m_gpuCount) {
- glv_LogError("vkInitAndEnumerate number of gpus does not include requested index: num %d, requested %d", m_gpuCount, gpu_idx);
+ vktrace_LogError("vkInitAndEnumerate number of gpus does not include requested index: num %d, requested %d", m_gpuCount, gpu_idx);
return -1;
} else {
- glv_LogError("vkInitAndEnumerate failed");
+ vktrace_LogError("vkInitAndEnumerate failed");
return res;
}
// TODO add multi-gpu support always use gpu[gpu_idx] for now
}
}
if (!foundWSIExt) {
- glv_LogError("VK_WSI_WINDOWS extension not supported by gpu[%d]", gpu_idx);
+ vktrace_LogError("VK_WSI_WINDOWS extension not supported by gpu[%d]", gpu_idx);
return VK_ERROR_INCOMPATIBLE_DEVICE;
}
// TODO generalize this: use one universal queue for now
bool32_t vkTrue = VK_TRUE;
res = vkDbgSetGlobalOption( VK_DBG_OPTION_BREAK_ON_ERROR, sizeof( vkTrue ), &vkTrue );
if (res != VK_SUCCESS)
- glv_LogWarning("Could not set debug option break on error");
+ vktrace_LogWarning("Could not set debug option break on error");
res = vkCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);
return res;
#else
#if 0
VkResult result = init_vk(gpu_idx);
if (result != VK_SUCCESS) {
- glv_LogError("could not init vulkan library");
+ vktrace_LogError("could not init vulkan library");
return -1;
} else {
m_initedVK = true;
}
#endif
-int vkDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)
+int vkDisplay::set_window(vktrace_window_handle hWindow, unsigned int width, unsigned int height)
{
#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
m_XcbWindow = hWindow;
wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));
if( !RegisterClassEx( &wcex))
{
- glv_LogError("Failed to register windows class");
+ vktrace_LogError("Failed to register windows class");
return -1;
}
m_windowWidth = width;
m_windowHeight = height;
} else {
- glv_LogError("Failed to create window");
+ vktrace_LogError("Failed to create window");
return -1;
}
// TODO : Not sure of best place to put this, but I have all the info I need here so just setting it all here for now
#include "vkreplay_vkreplay.h"
-class vkDisplay: public glv_replay::DisplayImp {
+class vkDisplay: public vktrace_replay::DisplayImp {
friend class vkReplay;
public:
vkDisplay();
~vkDisplay();
int init(const unsigned int gpu_idx);
- int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);
+ int set_window(vktrace_window_handle hWindow, unsigned int width, unsigned int height);
int create_window(const unsigned int width, const unsigned int height);
void resize_window(const unsigned int width, const unsigned int height);
void process_event();
#include "vk_enum_string_helper.h"
}
-glvreplay_settings *g_pReplaySettings;
+vkreplayer_settings *g_pReplaySettings;
-vkReplay::vkReplay(glvreplay_settings *pReplaySettings)
+vkReplay::vkReplay(vkreplayer_settings *pReplaySettings)
{
g_pReplaySettings = pReplaySettings;
m_display = new vkDisplay();
m_pDSDump = NULL;
m_pCBDump = NULL;
-// m_pGlvSnapshotPrint = NULL;
+// m_pVktraceSnapshotPrint = NULL;
m_objMapper.m_adjustForGPU = false;
}
vkReplay::~vkReplay()
{
delete m_display;
- glv_platform_close_library(m_vkFuncs.m_libHandle);
+ vktrace_platform_close_library(m_vkFuncs.m_libHandle);
}
-int vkReplay::init(glv_replay::Display & disp)
+int vkReplay::init(vktrace_replay::Display & disp)
{
int err;
#if defined PLATFORM_LINUX
#endif
if (handle == NULL) {
- glv_LogError("Failed to open vulkan library.");
+ vktrace_LogError("Failed to open vulkan library.");
return -1;
}
m_vkFuncs.init_funcs(handle);
disp.set_implementation(m_display);
if ((err = m_display->init(disp.get_gpu())) != 0) {
- glv_LogError("Failed to init vulkan display.");
+ vktrace_LogError("Failed to init vulkan display.");
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");
+ vktrace_LogError("Failed to create Window");
return err;
}
}
{
if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)
{
- glv_LogError("Failed to set Window");
+ vktrace_LogError("Failed to set Window");
return err;
}
}
return 0;
}
-glv_replay::GLV_REPLAY_RESULT vkReplay::handle_replay_errors(const char* entrypointName, const VkResult resCall, const VkResult resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)
+vktrace_replay::VKTRACE_REPLAY_RESULT vkReplay::handle_replay_errors(const char* entrypointName, const VkResult resCall, const VkResult resTrace, const vktrace_replay::VKTRACE_REPLAY_RESULT resIn)
{
- glv_replay::GLV_REPLAY_RESULT res = resIn;
+ vktrace_replay::VKTRACE_REPLAY_RESULT res = resIn;
if (resCall != resTrace) {
- glv_LogError("Return value %s from API call (%s) does not match return value from trace file %s.", entrypointName,
+ vktrace_LogError("Return value %s from API call (%s) does not match return value from trace file %s.", entrypointName,
string_VkResult((VkResult)resCall), string_VkResult((VkResult)resTrace));
- res = glv_replay::GLV_REPLAY_BAD_RETURN;
+ res = vktrace_replay::VKTRACE_REPLAY_BAD_RETURN;
}
#if 0
if (resCall != VK_SUCCESS) {
- glv_LogWarning("API call (%s) returned failed result %s", entrypointName, string_VK_RESULT(resCall));
+ vktrace_LogWarning("API call (%s) returned failed result %s", entrypointName, string_VK_RESULT(resCall));
}
#endif
return res;
m_validationMsgs.push_back(msgObj);
}
-glv_replay::GLV_REPLAY_RESULT vkReplay::pop_validation_msgs()
+vktrace_replay::VKTRACE_REPLAY_RESULT vkReplay::pop_validation_msgs()
{
if (m_validationMsgs.size() == 0)
- return glv_replay::GLV_REPLAY_SUCCESS;
+ return vktrace_replay::VKTRACE_REPLAY_SUCCESS;
m_validationMsgs.clear();
- return glv_replay::GLV_REPLAY_VALIDATION_ERROR;
+ return vktrace_replay::VKTRACE_REPLAY_VALIDATION_ERROR;
}
int vkReplay::dump_validation_data()
m_pDSDump((char *) "pipeline_dump.dot");
m_pCBDump((char *) "cb_dump.dot");
}
-// if (m_pGlvSnapshotPrint != NULL)
+// if (m_pVktraceSnapshotPrint != NULL)
// {
-// m_pGlvSnapshotPrint();
+// m_pVktraceSnapshotPrint();
// }
return 0;
}
// err = vkGetGlobalExtensionInfo(VK_EXTENSION_INFO_TYPE_COUNT, 0, &extSize, &total_extension_count);
// if (err != VK_SUCCESS)
// {
-// glv_LogWarning("Internal call to vkGetGlobalExtensionInfo failed to get number of extensions available.");
+// vktrace_LogWarning("Internal call to vkGetGlobalExtensionInfo failed to get number of extensions available.");
// }
//
-// glv_LogDebug("Total Extensions found: %u", total_extension_count);
+// vktrace_LogDebug("Total Extensions found: %u", total_extension_count);
VkExtensionProperties extProp;
// extSize = sizeof(VkExtensionProperties);
for (uint32_t i = 0; i < total_extension_count; i++)
{
// err = vkGetGlobalExtensionInfo(VK_EXTENSION_INFO_TYPE_PROPERTIES, i, &extSize, &extProp);
-// glv_LogDebug("Ext %u: '%s' v%u from '%s'.", i, extProp.name, extProp.version, extProp.description);
+// vktrace_LogDebug("Ext %u: '%s' v%u from '%s'.", i, extProp.name, extProp.version, extProp.description);
//
// bool bCheckIfNeeded = true;
bool bFound = false;
//
- // First, check extensions required by glvreplay
+ // First, check extensions required by vkreplay
#if 0
if (bCheckIfNeeded)
{
{
bCheckIfNeeded = false;
bFound = true;
- glv_LogDebug("... required by glvreplay.");
+ vktrace_LogDebug("... required by vkreplay.");
break;
}
}
// {
// //bCheckIfNeeded = false;
// bFound = true;
-// glv_LogDebug("... required by user.");
+// vktrace_LogDebug("... required by user.");
// break;
// }
// }
// {
// bCheckIfNeeded = false;
// bFound = true;
-// glv_LogDebug("... required by application.");
+// vktrace_LogDebug("... required by application.");
// break;
// }
// }
//#if !defined(_WIN32)
// m_pDSDump = (void (*)(char*)) m_vkFuncs.real_vkGetInstanceProcAddr(inst, "drawStateDumpDotFile");
// m_pCBDump = (void (*)(char*)) m_vkFuncs.real_vkGetInstanceProcAddr(inst, "drawStateDumpCommandBufferDotFile");
-//// m_pGlvSnapshotPrint = (GLVSNAPSHOT_PRINT_OBJECTS) m_vkFuncs.real_vkGetInstanceProcAddr(inst, "glvSnapshotPrintObjects");
+//// m_pVktraceSnapshotPrint = (VKTRACESNAPSHOT_PRINT_OBJECTS) m_vkFuncs.real_vkGetInstanceProcAddr(inst, "vktraceSnapshotPrintObjects");
//#endif
}
else
return VK_ERROR_UNKNOWN;
}
const char strScreenShot[] = "ScreenShot";
- char *strScreenShotEnv = glv_get_global_var("_VK_SCREENSHOT");
+ char *strScreenShotEnv = vktrace_get_global_var("_VK_SCREENSHOT");
pCreateInfo = (VkDeviceCreateInfo *) pPacket->pCreateInfo;
if (strScreenShotEnv && strlen(strScreenShotEnv) != 0) {
// query to find if ScreenShot layer is available
m_vkFuncs.real_vkGetPhysicalDeviceLayerProperties(remappedPhysicalDevice, &count, NULL);
- VkLayerProperties *props = (VkLayerProperties *) glv_malloc(count * sizeof (VkLayerProperties));
+ VkLayerProperties *props = (VkLayerProperties *) vktrace_malloc(count * sizeof (VkLayerProperties));
if (props && count > 0)
m_vkFuncs.real_vkGetPhysicalDeviceLayerProperties(remappedPhysicalDevice, &count, props);
for (uint32_t i = 0; i < count; i++) {
}
if (found_ss) {
// screenshot layer is available so enable it
- ppEnabledLayerNames = (char **) glv_malloc((pCreateInfo->layerCount+1) * sizeof(char *));
+ ppEnabledLayerNames = (char **) vktrace_malloc((pCreateInfo->layerCount+1) * sizeof(char *));
for (uint32_t i = 0; i < pCreateInfo->layerCount && ppEnabledLayerNames; i++)
{
ppEnabledLayerNames[i] = (char *) pCreateInfo->ppEnabledLayerNames[i];
}
- ppEnabledLayerNames[pCreateInfo->layerCount] = (char *) glv_malloc(strlen(strScreenShot) + 1);
+ ppEnabledLayerNames[pCreateInfo->layerCount] = (char *) vktrace_malloc(strlen(strScreenShot) + 1);
strcpy(ppEnabledLayerNames[pCreateInfo->layerCount++], strScreenShot);
saved_ppLayers = (char **) pCreateInfo->ppEnabledLayerNames;
pCreateInfo->ppEnabledLayerNames = ppEnabledLayerNames;
}
- glv_free(props);
+ vktrace_free(props);
}
}
replayResult = m_vkFuncs.real_vkCreateDevice(remappedPhysicalDevice, pPacket->pCreateInfo, &device);
if (ppEnabledLayerNames)
{
// restore the packets CreateInfo struct
- glv_free(ppEnabledLayerNames[pCreateInfo->layerCount-1]);
- glv_free(ppEnabledLayerNames);
+ vktrace_free(ppEnabledLayerNames[pCreateInfo->layerCount-1]);
+ vktrace_free(ppEnabledLayerNames);
pCreateInfo->ppEnabledLayerNames = saved_ppLayers;
}
if (replayResult == VK_SUCCESS)
if (remappedInstance == VK_NULL_HANDLE)
return VK_ERROR_UNKNOWN;
if (pPacket->pPhysicalDevices != NULL)
- pDevices = GLV_NEW_ARRAY(VkPhysicalDevice, deviceCount);
+ pDevices = VKTRACE_NEW_ARRAY(VkPhysicalDevice, deviceCount);
replayResult = m_vkFuncs.real_vkEnumeratePhysicalDevices(remappedInstance, &deviceCount, pDevices);
//TODO handle different number of physical devices in trace versus replay
if (deviceCount != *(pPacket->pPhysicalDeviceCount))
{
- glv_LogWarning("Number of physical devices mismatched in replay %u versus trace %u.", deviceCount, *(pPacket->pPhysicalDeviceCount));
+ vktrace_LogWarning("Number of physical devices mismatched in replay %u versus trace %u.", deviceCount, *(pPacket->pPhysicalDeviceCount));
}
else if (deviceCount == 0)
{
- glv_LogError("vkEnumeratePhysicalDevices number of gpus is zero.");
+ vktrace_LogError("vkEnumeratePhysicalDevices number of gpus is zero.");
}
else if (pDevices != NULL)
{
- glv_LogVerbose("Enumerated %d physical devices in the system.", deviceCount);
+ vktrace_LogVerbose("Enumerated %d physical devices in the system.", deviceCount);
}
// TODO handle enumeration results in a different order from trace to replay
for (uint32_t i = 0; i < deviceCount; i++)
m_objMapper.add_to_physicaldevices_map(pPacket->pPhysicalDevices[i], pDevices[i]);
}
}
- GLV_DELETE(pDevices);
+ VKTRACE_DELETE(pDevices);
}
if (pPacket->pPhysicalDevices != NULL)
{
{
if (m_vkFuncs.real_vkDbgCreateMsgCallback(remappedInstance, reportFlags, g_fpDbgMsgCallback, NULL, &m_dbgMsgCallbackObj) != VK_SUCCESS)
{
- glv_LogWarning("Failed to register vulkan callback for replayer error handling.");
+ vktrace_LogWarning("Failed to register vulkan callback for replayer error handling.");
}
}
}
// (pPacket->pData == NULL) ? NULL : &deviceProps);
// if (pPacket->pData != NULL)
// {
-// glv_LogVerbose("Replay Physical Device Properties");
-// glv_LogVerbose("Vendor ID %x, Device ID %x, name %s", deviceProps.vendorId, deviceProps.deviceId, deviceProps.deviceName);
-// glv_LogVerbose("API version %u, Driver version %u, gpu Type %u", deviceProps.apiVersion, deviceProps.driverVersion, deviceProps.deviceType);
-// glv_LogVerbose("Max Descriptor Sets: %u", deviceProps.maxDescriptorSets);
-// glv_LogVerbose("Max Bound Descriptor Sets: %u", deviceProps.maxBoundDescriptorSets);
-// glv_LogVerbose("Max Thread Group Size: %u", deviceProps.maxThreadGroupSize);
-// glv_LogVerbose("Max Color Attachments: %u", deviceProps.maxColorAttachments);
-// glv_LogVerbose("Max Inline Memory Update Size: %llu", deviceProps.maxInlineMemoryUpdateSize);
+// vktrace_LogVerbose("Replay Physical Device Properties");
+// vktrace_LogVerbose("Vendor ID %x, Device ID %x, name %s", deviceProps.vendorId, deviceProps.deviceId, deviceProps.deviceName);
+// vktrace_LogVerbose("API version %u, Driver version %u, gpu Type %u", deviceProps.apiVersion, deviceProps.driverVersion, deviceProps.deviceType);
+// vktrace_LogVerbose("Max Descriptor Sets: %u", deviceProps.maxDescriptorSets);
+// vktrace_LogVerbose("Max Bound Descriptor Sets: %u", deviceProps.maxBoundDescriptorSets);
+// vktrace_LogVerbose("Max Thread Group Size: %u", deviceProps.maxThreadGroupSize);
+// vktrace_LogVerbose("Max Color Attachments: %u", deviceProps.maxColorAttachments);
+// vktrace_LogVerbose("Max Inline Memory Update Size: %llu", deviceProps.maxInlineMemoryUpdateSize);
// }
// break;
// }
// (pPacket->pData == NULL) ? NULL : &devicePerfs);
// if (pPacket->pData != NULL)
// {
-// glv_LogVerbose("Replay Physical Device Performance");
-// glv_LogVerbose("Max device clock %f, max shader ALUs/clock %f, max texel fetches/clock %f", devicePerfs.maxDeviceClock, devicePerfs.aluPerClock, devicePerfs.texPerClock);
-// glv_LogVerbose("Max primitives/clock %f, Max pixels/clock %f",devicePerfs.primsPerClock, devicePerfs.pixelsPerClock);
+// vktrace_LogVerbose("Replay Physical Device Performance");
+// vktrace_LogVerbose("Max device clock %f, max shader ALUs/clock %f, max texel fetches/clock %f", devicePerfs.maxDeviceClock, devicePerfs.aluPerClock, devicePerfs.texPerClock);
+// vktrace_LogVerbose("Max primitives/clock %f, Max pixels/clock %f",devicePerfs.primsPerClock, devicePerfs.pixelsPerClock);
// }
// break;
// }
// size_t numQueues = 1;
// assert(pPacket->pDataSize);
// if ((*(pPacket->pDataSize) % dataSize) != 0)
-// glv_LogWarning("vkGetPhysicalDeviceInfo() for QUEUE_PROPERTIES not an integral data size assuming 1");
+// vktrace_LogWarning("vkGetPhysicalDeviceInfo() for QUEUE_PROPERTIES not an integral data size assuming 1");
// else
// numQueues = *(pPacket->pDataSize) / dataSize;
// dataSize = numQueues * dataSize;
-// pQ = static_cast < VkPhysicalDeviceQueueProperties *> (glv_malloc(dataSize));
+// pQ = static_cast < VkPhysicalDeviceQueueProperties *> (vktrace_malloc(dataSize));
// pGpuQueue = pQ;
// replayResult = m_vkFuncs.real_vkGetPhysicalDeviceInfo(remappedPhysicalDevice, pPacket->infoType, &dataSize,
// (pPacket->pData == NULL) ? NULL : pGpuQueue);
// {
// for (unsigned int i = 0; i < numQueues; i++)
// {
-// glv_LogVerbose("Replay Physical Device Queue Property for index %d, flags %u.", i, pGpuQueue->queueFlags);
-// glv_LogVerbose("Max available count %u, max atomic counters %u, supports timestamps %u.",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);
+// vktrace_LogVerbose("Replay Physical Device Queue Property for index %d, flags %u.", i, pGpuQueue->queueFlags);
+// vktrace_LogVerbose("Max available count %u, max atomic counters %u, supports timestamps %u.",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);
// pGpuQueue++;
// }
// }
-// glv_free(pQ);
+// vktrace_free(pQ);
// break;
// }
// default:
// if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
// {
// size = *pPacket->pDataSize;
-// pData = glv_malloc(*pPacket->pDataSize);
+// pData = vktrace_malloc(*pPacket->pDataSize);
// }
// replayResult = m_vkFuncs.real_vkGetPhysicalDeviceInfo(remappedPhysicalDevice, pPacket->infoType, &size, pData);
// if (replayResult == VK_SUCCESS)
//// }
// else*/ if (size != *pPacket->pDataSize && pData != NULL)
// {
-// glv_LogWarning("vkGetPhysicalDeviceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)", size, *pPacket->pDataSize);
+// vktrace_LogWarning("vkGetPhysicalDeviceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)", size, *pPacket->pDataSize);
// }
// else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
// {
-// glv_LogWarning("vkGetPhysicalDeviceInfo returned differing data contents than the trace file contained.");
+// vktrace_LogWarning("vkGetPhysicalDeviceInfo returned differing data contents than the trace file contained.");
// }
// }
-// glv_free(pData);
+// vktrace_free(pData);
// break;
// }
// };
// VkResult replayResult = VK_ERROR_UNKNOWN;
//
// size_t dataSize = *pPacket->pDataSize;
-// void* pData = glv_malloc(dataSize);
+// void* pData = vktrace_malloc(dataSize);
// VkSwapChainWSI remappedSwapChain = m_objMapper.remap_swapchainwsis(pPacket->swapChain);
// if (remappedSwapChain == VK_NULL_HANDLE)
// return VK_ERROR_UNKNOWN;
// {
// if (dataSize != *pPacket->pDataSize)
// {
-// glv_LogWarning("SwapChainInfo dataSize differs between trace (%d bytes) and replay (%d bytes)", *pPacket->pDataSize, dataSize);
+// vktrace_LogWarning("SwapChainInfo dataSize differs between trace (%d bytes) and replay (%d bytes)", *pPacket->pDataSize, dataSize);
// }
// if (pPacket->infoType == VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI)
// {
// }
// }
// }
-// glv_free(pData);
+// vktrace_free(pData);
// return replayResult;
//}
VkCmdBuffer *remappedBuffers = NULL;
if (pPacket->pCmdBuffers != NULL)
{
- remappedBuffers = GLV_NEW_ARRAY( VkCmdBuffer, pPacket->cmdBufferCount);
+ remappedBuffers = VKTRACE_NEW_ARRAY( VkCmdBuffer, pPacket->cmdBufferCount);
for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)
{
*(remappedBuffers + i) = m_objMapper.remap_cmdbuffers(*(pPacket->pCmdBuffers + i));
if (*(remappedBuffers + i) == VK_NULL_HANDLE)
{
- GLV_DELETE(remappedBuffers);
+ VKTRACE_DELETE(remappedBuffers);
return replayResult;
}
}
pPacket->cmdBufferCount,
remappedBuffers,
remappedFence);
- GLV_DELETE(remappedBuffers);
+ VKTRACE_DELETE(remappedBuffers);
return replayResult;
}
// if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
// {
// size = *pPacket->pDataSize;
-// pData = glv_malloc(*pPacket->pDataSize);
+// pData = vktrace_malloc(*pPacket->pDataSize);
// memcpy(pData, pPacket->pData, *pPacket->pDataSize);
// }
// // TODO only search for object once rather than at remap() and init_objMemXXX()
// {
// if (size != *pPacket->pDataSize && pData != NULL)
// {
-// glv_LogWarning("vkGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes).", size, *pPacket->pDataSize);
+// vktrace_LogWarning("vkGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes).", size, *pPacket->pDataSize);
// }
// else if (pData != NULL)
// {
// for (unsigned int i = 0; i < num; i++)
// {
// if (traceReqs->size != replayReqs->size)
-// glv_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace size %u, replay size %u.", traceReqs->size, replayReqs->size);
+// vktrace_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace size %u, replay size %u.", traceReqs->size, replayReqs->size);
// if (traceReqs->alignment != replayReqs->alignment)
-// glv_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace alignment %u, replay aligmnent %u.", traceReqs->alignment, replayReqs->alignment);
+// vktrace_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace alignment %u, replay aligmnent %u.", traceReqs->alignment, replayReqs->alignment);
// if (traceReqs->granularity != replayReqs->granularity)
-// glv_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace granularity %u, replay granularity %u.", traceReqs->granularity, replayReqs->granularity);
+// vktrace_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace granularity %u, replay granularity %u.", traceReqs->granularity, replayReqs->granularity);
// if (traceReqs->memPropsAllowed != replayReqs->memPropsAllowed)
-// glv_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memPropsAllowed %u, replay memPropsAllowed %u.", traceReqs->memPropsAllowed, replayReqs->memPropsAllowed);
+// vktrace_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memPropsAllowed %u, replay memPropsAllowed %u.", traceReqs->memPropsAllowed, replayReqs->memPropsAllowed);
// if (traceReqs->memPropsRequired != replayReqs->memPropsRequired)
-// glv_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memPropsRequired %u, replay memPropsRequired %u.", traceReqs->memPropsRequired, replayReqs->memPropsRequired);
+// vktrace_LogWarning("vkGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memPropsRequired %u, replay memPropsRequired %u.", traceReqs->memPropsRequired, replayReqs->memPropsRequired);
// traceReqs++;
// replayReqs++;
// }
// }
// default:
// if (memcmp(pData, pPacket->pData, size) != 0)
-// glv_LogWarning("vkGetObjectInfo() mismatch on *pData: between trace and replay *pDataSize %u.", size);
+// vktrace_LogWarning("vkGetObjectInfo() mismatch on *pData: between trace and replay *pDataSize %u.", size);
// }
// }
// }
-// glv_free(pData);
+// vktrace_free(pData);
// return replayResult;
//}
// if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
// {
// size = *pPacket->pDataSize;
-// pData = glv_malloc(*pPacket->pDataSize);
+// pData = vktrace_malloc(*pPacket->pDataSize);
// }
// replayResult = m_vkFuncs.real_vkGetImageSubresourceInfo(remappedDevice, remappedImage, pPacket->pSubresource, pPacket->infoType, &size, pData);
// if (replayResult == VK_SUCCESS)
// {
// if (size != *pPacket->pDataSize && pData != NULL)
// {
-// glv_LogWarning("vkGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes).", size, *pPacket->pDataSize);
+// vktrace_LogWarning("vkGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes).", size, *pPacket->pDataSize);
// }
// else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
// {
-// glv_LogWarning("vkGetImageSubresourceInfo returned differing data contents than the trace file contained.");
+// vktrace_LogWarning("vkGetImageSubresourceInfo returned differing data contents than the trace file contained.");
// }
// }
-// glv_free(pData);
+// vktrace_free(pData);
// return replayResult;
//}
VkDevice remappedDevice = m_objMapper.remap_devices(pPacket->device);
if (remappedDevice == VK_NULL_HANDLE)
{
- glv_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkDevice.");
+ vktrace_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkDevice.");
return VK_ERROR_UNKNOWN;
}
- VkWriteDescriptorSet* pRemappedWrites = GLV_NEW_ARRAY(VkWriteDescriptorSet, pPacket->writeCount);
+ VkWriteDescriptorSet* pRemappedWrites = VKTRACE_NEW_ARRAY(VkWriteDescriptorSet, pPacket->writeCount);
memcpy(pRemappedWrites, pPacket->pDescriptorWrites, pPacket->writeCount * sizeof(VkWriteDescriptorSet));
- VkCopyDescriptorSet* pRemappedCopies = GLV_NEW_ARRAY(VkCopyDescriptorSet, pPacket->copyCount);
+ VkCopyDescriptorSet* pRemappedCopies = VKTRACE_NEW_ARRAY(VkCopyDescriptorSet, pPacket->copyCount);
memcpy(pRemappedCopies, pPacket->pDescriptorCopies, pPacket->copyCount * sizeof(VkCopyDescriptorSet));
for (uint32_t i = 0; i < pPacket->writeCount; i++)
pRemappedWrites[i].destSet.handle = m_objMapper.remap_descriptorsets(pPacket->pDescriptorWrites[i].destSet.handle);
if (pRemappedWrites[i].destSet.handle == 0)
{
- glv_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped write VkDescriptorSet.");
- GLV_DELETE(pRemappedWrites);
- GLV_DELETE(pRemappedCopies);
+ vktrace_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped write VkDescriptorSet.");
+ VKTRACE_DELETE(pRemappedWrites);
+ VKTRACE_DELETE(pRemappedCopies);
return VK_ERROR_UNKNOWN;
}
- pRemappedWrites[i].pDescriptors = GLV_NEW_ARRAY(VkDescriptorInfo, pPacket->pDescriptorWrites[i].count);
+ pRemappedWrites[i].pDescriptors = VKTRACE_NEW_ARRAY(VkDescriptorInfo, pPacket->pDescriptorWrites[i].count);
memcpy((void*)pRemappedWrites[i].pDescriptors, pPacket->pDescriptorWrites[i].pDescriptors, pPacket->pDescriptorWrites[i].count * sizeof(VkDescriptorInfo));
for (uint32_t j = 0; j < pPacket->pDescriptorWrites[i].count; j++)
const_cast<VkDescriptorInfo*>(pRemappedWrites[i].pDescriptors)[j].bufferView.handle = m_objMapper.remap_bufferviews(pPacket->pDescriptorWrites[i].pDescriptors[j].bufferView.handle);
if (pRemappedWrites[i].pDescriptors[j].bufferView.handle == 0)
{
- glv_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkBufferView.");
- GLV_DELETE(pRemappedWrites);
- GLV_DELETE(pRemappedCopies);
+ vktrace_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkBufferView.");
+ VKTRACE_DELETE(pRemappedWrites);
+ VKTRACE_DELETE(pRemappedCopies);
return VK_ERROR_UNKNOWN;
}
}
const_cast<VkDescriptorInfo*>(pRemappedWrites[i].pDescriptors)[j].sampler.handle = m_objMapper.remap_samplers(pPacket->pDescriptorWrites[i].pDescriptors[j].sampler.handle);
if (pRemappedWrites[i].pDescriptors[j].sampler.handle == 0)
{
- glv_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkSampler.");
- GLV_DELETE(pRemappedWrites);
- GLV_DELETE(pRemappedCopies);
+ vktrace_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkSampler.");
+ VKTRACE_DELETE(pRemappedWrites);
+ VKTRACE_DELETE(pRemappedCopies);
return VK_ERROR_UNKNOWN;
}
}
const_cast<VkDescriptorInfo*>(pRemappedWrites[i].pDescriptors)[j].imageView.handle = m_objMapper.remap_imageviews(pPacket->pDescriptorWrites[i].pDescriptors[j].imageView.handle);
if (pRemappedWrites[i].pDescriptors[j].imageView.handle == 0)
{
- glv_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkImageView.");
- GLV_DELETE(pRemappedWrites);
- GLV_DELETE(pRemappedCopies);
+ vktrace_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped VkImageView.");
+ VKTRACE_DELETE(pRemappedWrites);
+ VKTRACE_DELETE(pRemappedCopies);
return VK_ERROR_UNKNOWN;
}
}
pRemappedCopies[i].destSet.handle = m_objMapper.remap_descriptorsets(pPacket->pDescriptorCopies[i].destSet.handle);
if (pRemappedCopies[i].destSet.handle == 0)
{
- glv_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped destination VkDescriptorSet.");
- GLV_DELETE(pRemappedWrites);
- GLV_DELETE(pRemappedCopies);
+ vktrace_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped destination VkDescriptorSet.");
+ VKTRACE_DELETE(pRemappedWrites);
+ VKTRACE_DELETE(pRemappedCopies);
return VK_ERROR_UNKNOWN;
}
pRemappedCopies[i].srcSet.handle = m_objMapper.remap_descriptorsets(pPacket->pDescriptorCopies[i].srcSet.handle);
if (pRemappedCopies[i].srcSet.handle == 0)
{
- glv_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped source VkDescriptorSet.");
- GLV_DELETE(pRemappedWrites);
- GLV_DELETE(pRemappedCopies);
+ vktrace_LogError("Skipping vkUpdateDescriptorSets() due to invalid remapped source VkDescriptorSet.");
+ VKTRACE_DELETE(pRemappedWrites);
+ VKTRACE_DELETE(pRemappedCopies);
return VK_ERROR_UNKNOWN;
}
}
VkDescriptorPool descriptorPool;
descriptorPool.handle = m_objMapper.remap_descriptorpools(pPacket->descriptorPool.handle);
- VkDescriptorSet* localDSs = GLV_NEW_ARRAY(VkDescriptorSet, pPacket->count);
+ VkDescriptorSet* localDSs = VKTRACE_NEW_ARRAY(VkDescriptorSet, pPacket->count);
uint32_t i;
for (i = 0; i < pPacket->count; ++i) {
localDSs[i].handle = m_objMapper.remap_descriptorsets(pPacket->pDescriptorSets[i].handle);
VkCmdBuffer remappedCmdBuffer = m_objMapper.remap_cmdbuffers(pPacket->cmdBuffer);
if (remappedCmdBuffer == VK_NULL_HANDLE)
{
- glv_LogError("Skipping vkCmdBindDescriptorSets() due to invalid remapped VkCmdBuffer.");
+ vktrace_LogError("Skipping vkCmdBindDescriptorSets() due to invalid remapped VkCmdBuffer.");
return;
}
uint64_t remappedLayoutHandle = m_objMapper.remap_pipelinelayouts(pPacket->layout.handle);
if (remappedLayoutHandle == 0)
{
- glv_LogError("Skipping vkCmdBindDescriptorSets() due to invalid remapped VkPipelineLayout.");
+ vktrace_LogError("Skipping vkCmdBindDescriptorSets() due to invalid remapped VkPipelineLayout.");
return;
}
VkPipelineLayout remappedLayout;
remappedLayout.handle = remappedLayoutHandle;
- VkDescriptorSet* pRemappedSets = (VkDescriptorSet *) glv_malloc(sizeof(VkDescriptorSet) * pPacket->setCount);
+ VkDescriptorSet* pRemappedSets = (VkDescriptorSet *) vktrace_malloc(sizeof(VkDescriptorSet) * pPacket->setCount);
if (pRemappedSets == NULL)
{
- glv_LogError("Replay of CmdBindDescriptorSets out of memory.");
+ vktrace_LogError("Replay of CmdBindDescriptorSets out of memory.");
return;
}
}
m_vkFuncs.real_vkCmdBindDescriptorSets(remappedCmdBuffer, pPacket->pipelineBindPoint, remappedLayout, pPacket->firstSet, pPacket->setCount, pRemappedSets, pPacket->dynamicOffsetCount, pPacket->pDynamicOffsets);
- glv_free(pRemappedSets);
+ vktrace_free(pRemappedSets);
return;
}
VkCmdBuffer remappedCmdBuffer = m_objMapper.remap_cmdbuffers(pPacket->cmdBuffer);
if (remappedCmdBuffer == VK_NULL_HANDLE)
{
- glv_LogError("Skipping vkCmdBindVertexBuffers() due to invalid remapped VkCmdBuffer.");
+ vktrace_LogError("Skipping vkCmdBindVertexBuffers() due to invalid remapped VkCmdBuffer.");
return;
}
- VkBuffer *pSaveBuff = GLV_NEW_ARRAY(VkBuffer, pPacket->bindingCount);
+ VkBuffer *pSaveBuff = VKTRACE_NEW_ARRAY(VkBuffer, pPacket->bindingCount);
if (pSaveBuff == NULL)
{
- glv_LogError("Replay of CmdBindVertexBuffers out of memory.");
+ vktrace_LogError("Replay of CmdBindVertexBuffers out of memory.");
}
uint32_t i = 0;
if (pPacket->pBuffers) {
VkBuffer *pBuff = (VkBuffer*) &(pPacket->pBuffers[k]);
*pBuff = pSaveBuff[k];
}
- GLV_DELETE(pSaveBuff);
+ VKTRACE_DELETE(pSaveBuff);
return;
}
// }
//
// // remap shaders from each stage
-// VkPipelineShaderStageCreateInfo* pRemappedStages = GLV_NEW_ARRAY(VkPipelineShaderStageCreateInfo, pPacket->pCreateInfo->stageCount);
+// VkPipelineShaderStageCreateInfo* pRemappedStages = VKTRACE_NEW_ARRAY(VkPipelineShaderStageCreateInfo, pPacket->pCreateInfo->stageCount);
// memcpy(pRemappedStages, pPacket->pCreateInfo->pStages, sizeof(VkPipelineShaderStageCreateInfo) * pPacket->pCreateInfo->stageCount);
// for (uint32_t i = 0; i < pPacket->pCreateInfo->stageCount; i++)
// {
// m_objMapper.add_to_map(pPacket->pPipeline, &pipeline);
// }
//
-// GLV_DELETE(pRemappedStages);
+// VKTRACE_DELETE(pRemappedStages);
//
// return replayResult;
//}
// VkPipeline local_basePipelineHandle;
// remap shaders from each stage
- VkPipelineShaderStageCreateInfo* pRemappedStages = GLV_NEW_ARRAY(VkPipelineShaderStageCreateInfo, pPacket->pCreateInfos->stageCount);
+ VkPipelineShaderStageCreateInfo* pRemappedStages = VKTRACE_NEW_ARRAY(VkPipelineShaderStageCreateInfo, pPacket->pCreateInfos->stageCount);
memcpy(pRemappedStages, pPacket->pCreateInfos->pStages, sizeof(VkPipelineShaderStageCreateInfo) * pPacket->pCreateInfos->stageCount);
- VkGraphicsPipelineCreateInfo* pLocalCIs = GLV_NEW_ARRAY(VkGraphicsPipelineCreateInfo, pPacket->count);
+ VkGraphicsPipelineCreateInfo* pLocalCIs = VKTRACE_NEW_ARRAY(VkGraphicsPipelineCreateInfo, pPacket->count);
uint32_t i, j;
uint64_t tmpHandle;
for (i=0; i<pPacket->count; i++) {
pipelineCache.handle = m_objMapper.remap_pipelinecaches(pPacket->pipelineCache.handle);
uint32_t count = pPacket->count;
- VkPipeline *local_pPipelines = GLV_NEW_ARRAY(VkPipeline, pPacket->count);
+ VkPipeline *local_pPipelines = VKTRACE_NEW_ARRAY(VkPipeline, pPacket->count);
replayResult = m_vkFuncs.real_vkCreateGraphicsPipelines(remappedDevice, pipelineCache, count, pLocalCIs, local_pPipelines);
}
}
- GLV_DELETE(pRemappedStages);
- GLV_DELETE(pLocalCIs);
- GLV_DELETE(local_pPipelines);
+ VKTRACE_DELETE(pRemappedStages);
+ VKTRACE_DELETE(pLocalCIs);
+ VKTRACE_DELETE(local_pPipelines);
return replayResult;
}
// array to store the original trace-time layouts, so that we can remap them inside the packet and then
// restore them after replaying the API call.
- VkDescriptorSetLayout* pSaveLayouts = (VkDescriptorSetLayout*) glv_malloc(sizeof(VkDescriptorSetLayout) * pPacket->pCreateInfo->descriptorSetCount);
+ VkDescriptorSetLayout* pSaveLayouts = (VkDescriptorSetLayout*) vktrace_malloc(sizeof(VkDescriptorSetLayout) * pPacket->pCreateInfo->descriptorSetCount);
if (!pSaveLayouts) {
- glv_LogError("Replay of CreatePipelineLayout out of memory.");
+ vktrace_LogError("Replay of CreatePipelineLayout out of memory.");
}
uint32_t i = 0;
for (i = 0; (i < pPacket->pCreateInfo->descriptorSetCount) && (pPacket->pCreateInfo->pSetLayouts != NULL); i++) {
VkDescriptorSetLayout* pSL = (VkDescriptorSetLayout*) &(pPacket->pCreateInfo->pSetLayouts[k]);
*pSL = pSaveLayouts[k];
}
- glv_free(pSaveLayouts);
+ vktrace_free(pSaveLayouts);
return replayResult;
}
VkCmdBuffer remappedCmdBuffer = m_objMapper.remap_cmdbuffers(pPacket->cmdBuffer);
if (remappedCmdBuffer == VK_NULL_HANDLE)
{
- glv_LogError("Skipping vkCmdWaitEvents() due to invalid remapped VkCmdBuffer.");
+ vktrace_LogError("Skipping vkCmdWaitEvents() due to invalid remapped VkCmdBuffer.");
return;
}
- VkEvent* saveEvent = GLV_NEW_ARRAY(VkEvent, pPacket->eventCount);
+ VkEvent* saveEvent = VKTRACE_NEW_ARRAY(VkEvent, pPacket->eventCount);
uint32_t idx = 0;
uint32_t numRemapBuf = 0;
uint32_t numRemapImg = 0;
pEvent->handle = m_objMapper.remap_events(pPacket->pEvents[idx].handle);
}
- VkBuffer* saveBuf = GLV_NEW_ARRAY(VkBuffer, pPacket->memBarrierCount);
- VkImage* saveImg = GLV_NEW_ARRAY(VkImage, pPacket->memBarrierCount);
+ VkBuffer* saveBuf = VKTRACE_NEW_ARRAY(VkBuffer, pPacket->memBarrierCount);
+ VkImage* saveImg = VKTRACE_NEW_ARRAY(VkImage, pPacket->memBarrierCount);
for (idx = 0; idx < pPacket->memBarrierCount; idx++)
{
VkMemoryBarrier *pNext = (VkMemoryBarrier *) pPacket->ppMemBarriers[idx];
VkEvent *pEvent = (VkEvent *) &(pPacket->pEvents[idx]);
*pEvent = saveEvent[idx];
}
- GLV_DELETE(saveEvent);
- GLV_DELETE(saveBuf);
- GLV_DELETE(saveImg);
+ VKTRACE_DELETE(saveEvent);
+ VKTRACE_DELETE(saveBuf);
+ VKTRACE_DELETE(saveImg);
return;
}
VkCmdBuffer remappedCmdBuffer = m_objMapper.remap_cmdbuffers(pPacket->cmdBuffer);
if (remappedCmdBuffer == VK_NULL_HANDLE)
{
- glv_LogError("Skipping vkCmdPipelineBarrier() due to invalid remapped VkCmdBuffer.");
+ vktrace_LogError("Skipping vkCmdPipelineBarrier() due to invalid remapped VkCmdBuffer.");
return;
}
uint32_t idx = 0;
uint32_t numRemapBuf = 0;
uint32_t numRemapImg = 0;
- VkBuffer* saveBuf = GLV_NEW_ARRAY(VkBuffer, pPacket->memBarrierCount);
- VkImage* saveImg = GLV_NEW_ARRAY(VkImage, pPacket->memBarrierCount);
+ VkBuffer* saveBuf = VKTRACE_NEW_ARRAY(VkBuffer, pPacket->memBarrierCount);
+ VkImage* saveImg = VKTRACE_NEW_ARRAY(VkImage, pPacket->memBarrierCount);
for (idx = 0; idx < pPacket->memBarrierCount; idx++)
{
VkMemoryBarrier *pNext = (VkMemoryBarrier *) pPacket->ppMemBarriers[idx];
pNextImg->image = saveImg[idx];
}
}
- GLV_DELETE(saveBuf);
- GLV_DELETE(saveImg);
+ VKTRACE_DELETE(saveBuf);
+ VKTRACE_DELETE(saveImg);
return;
}
if (pSavedAttachments != NULL)
{
allocatedAttachments = true;
- pAttachments = GLV_NEW_ARRAY(VkAttachmentView, pInfo->attachmentCount);
+ pAttachments = VKTRACE_NEW_ARRAY(VkAttachmentView, pInfo->attachmentCount);
memcpy(pAttachments, pSavedAttachments, sizeof(VkAttachmentView) * pInfo->attachmentCount);
for (uint32_t i = 0; i < pInfo->attachmentCount; i++)
{
}
if (allocatedAttachments)
{
- GLV_DELETE((void*)pAttachments);
+ VKTRACE_DELETE((void*)pAttachments);
}
return replayResult;
}
VkCmdBuffer remappedCmdBuffer = m_objMapper.remap_cmdbuffers(pPacket->cmdBuffer);
if (remappedCmdBuffer == VK_NULL_HANDLE)
{
- glv_LogError("Skipping vkCmdBeginRenderPass() due to invalid remapped VkCmdBuffer.");
+ vktrace_LogError("Skipping vkCmdBeginRenderPass() due to invalid remapped VkCmdBuffer.");
return;
}
VkRenderPassBeginInfo local_renderPassBeginInfo;
// if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
// {
// size = *pPacket->pDataSize;
-// pData = glv_malloc(*pPacket->pDataSize);
+// pData = vktrace_malloc(*pPacket->pDataSize);
// }
// replayResult = m_vkFuncs.real_vkStorePipeline(remappedDevice, remappedPipeline, &size, pData);
// if (replayResult == VK_SUCCESS)
// {
// if (size != *pPacket->pDataSize && pData != NULL)
// {
-// glv_LogWarning("vkStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes).", size, *pPacket->pDataSize);
+// vktrace_LogWarning("vkStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes).", size, *pPacket->pDataSize);
// }
// else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
// {
-// glv_LogWarning("vkStorePipeline returned differing data contents than the trace file contained.");
+// vktrace_LogWarning("vkStorePipeline returned differing data contents than the trace file contained.");
// }
// }
-// glv_free(pData);
+// vktrace_free(pData);
// return replayResult;
//}
if (remappedDevice == VK_NULL_HANDLE)
return VK_ERROR_UNKNOWN;
- VkFence *pFence = GLV_NEW_ARRAY(VkFence, pPacket->fenceCount);
+ VkFence *pFence = VKTRACE_NEW_ARRAY(VkFence, pPacket->fenceCount);
for (i = 0; i < pPacket->fenceCount; i++)
{
(*(pFence + i)).handle = m_objMapper.remap_fences((*(pPacket->pFences + i)).handle);
}
replayResult = m_vkFuncs.real_vkWaitForFences(remappedDevice, pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);
- GLV_DELETE(pFence);
+ VKTRACE_DELETE(pFence);
return replayResult;
}
{
if (local_mem.pGpuMem)
{
- unsigned char *pBuf = (unsigned char *) glv_malloc(local_mem.pGpuMem->getMemoryMapSize());
+ unsigned char *pBuf = (unsigned char *) vktrace_malloc(local_mem.pGpuMem->getMemoryMapSize());
if (!pBuf)
{
- glv_LogError("vkUnmapMemory() malloc failed.");
+ vktrace_LogError("vkUnmapMemory() malloc failed.");
}
local_mem.pGpuMem->setMemoryDataAddr(pBuf);
local_mem.pGpuMem->copyMappingData(pPacket->pData, true, 0, 0);
if (remappedDevice == VK_NULL_HANDLE)
return VK_ERROR_UNKNOWN;
- VkMappedMemoryRange* localRanges = GLV_NEW_ARRAY(VkMappedMemoryRange, pPacket->memRangeCount);
+ VkMappedMemoryRange* localRanges = VKTRACE_NEW_ARRAY(VkMappedMemoryRange, pPacket->memRangeCount);
memcpy(localRanges, pPacket->pMemRanges, sizeof(VkMappedMemoryRange) * (pPacket->memRangeCount));
- gpuMemObj* pLocalMems = GLV_NEW_ARRAY(gpuMemObj, pPacket->memRangeCount);
+ gpuMemObj* pLocalMems = VKTRACE_NEW_ARRAY(gpuMemObj, pPacket->memRangeCount);
for (uint32_t i = 0; i < pPacket->memRangeCount; i++)
{
pLocalMems[i] = m_objMapper.m_devicememorys.find(pPacket->pMemRanges[i].mem.handle)->second;
localRanges[i].mem.handle = m_objMapper.remap_devicememorys(pPacket->pMemRanges[i].mem.handle);
if (localRanges[i].mem.handle == 0 || pLocalMems[i].pGpuMem == NULL)
{
- GLV_DELETE(localRanges);
- GLV_DELETE(pLocalMems);
+ VKTRACE_DELETE(localRanges);
+ VKTRACE_DELETE(pLocalMems);
return VK_ERROR_UNKNOWN;
}
}
else
{
- unsigned char *pBuf = (unsigned char *) glv_malloc(pLocalMems[i].pGpuMem->getMemoryMapSize());
+ unsigned char *pBuf = (unsigned char *) vktrace_malloc(pLocalMems[i].pGpuMem->getMemoryMapSize());
if (!pBuf)
{
- glv_LogError("vkFlushMappedMemoryRanges() malloc failed.");
+ vktrace_LogError("vkFlushMappedMemoryRanges() malloc failed.");
}
pLocalMems[i].pGpuMem->setMemoryDataAddr(pBuf);
pLocalMems[i].pGpuMem->copyMappingData(pPacket->ppData[i], false, pPacket->pMemRanges[i].size, pPacket->pMemRanges[i].offset);
replayResult = m_vkFuncs.real_vkFlushMappedMemoryRanges(remappedDevice, pPacket->memRangeCount, localRanges);
- GLV_DELETE(localRanges);
- GLV_DELETE(pLocalMems);
+ VKTRACE_DELETE(localRanges);
+ VKTRACE_DELETE(pLocalMems);
return replayResult;
}
// if (pPacket->physicalDevice != VK_NULL_HANDLE && remappedphysicalDevice == VK_NULL_HANDLE)
// {
-// return glv_replay::GLV_REPLAY_ERROR;
+// return vktrace_replay::VKTRACE_REPLAY_ERROR;
// }
replayResult = m_vkFuncs.real_vkGetPhysicalDeviceSurfaceSupportWSI(remappedphysicalDevice, pPacket->queueFamilyIndex, (VkSurfaceDescriptionWSI *) m_display->get_surface_description(), pPacket->pSupported);
// if (pPacket->device != VK_NULL_HANDLE && remappeddevice == VK_NULL_HANDLE)
// {
-// return glv_replay::GLV_REPLAY_ERROR;
+// return vktrace_replay::VKTRACE_REPLAY_ERROR;
// }
save_oldSwapChain = pPacket->pCreateInfo->oldSwapChain;
(*pSC) = m_objMapper.remap_swapchainwsis(save_oldSwapChain.handle);
// if (pPacket->device != VK_NULL_HANDLE && remappeddevice == VK_NULL_HANDLE)
// {
-// return glv_replay::GLV_REPLAY_ERROR;
+// return vktrace_replay::VKTRACE_REPLAY_ERROR;
// }
VkSwapChainWSI remappedswapChain;
VkQueue remappedqueue = m_objMapper.remap_queues(pPacket->queue);
uint32_t i;
- VkSwapChainWSI* remappedswapChains = GLV_NEW_ARRAY(VkSwapChainWSI, pPacket->pPresentInfo->swapChainCount);
+ VkSwapChainWSI* remappedswapChains = VKTRACE_NEW_ARRAY(VkSwapChainWSI, pPacket->pPresentInfo->swapChainCount);
for (i=0; i<pPacket->pPresentInfo->swapChainCount; i++) {
remappedswapChains[i].handle = m_objMapper.remap_swapchainwsis(pPacket->pPresentInfo->swapChains[i].handle);
}
// if (pPacket->device != VK_NULL_HANDLE && remappeddevice == VK_NULL_HANDLE)
// {
-// return glv_replay::GLV_REPLAY_ERROR;
+// return vktrace_replay::VKTRACE_REPLAY_ERROR;
// }
VkCmdBuffer local_pCmdBuffer;
class vkReplay {
public:
~vkReplay();
- vkReplay(glvreplay_settings *pReplaySettings);
+ vkReplay(vkreplayer_settings *pReplaySettings);
- int init(glv_replay::Display & disp);
+ int init(vktrace_replay::Display & disp);
vkDisplay * get_display() {return m_display;}
- glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);
- glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const VkResult resCall, const VkResult resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);
+ vktrace_replay::VKTRACE_REPLAY_RESULT replay(vktrace_trace_packet_header *packet);
+ vktrace_replay::VKTRACE_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const VkResult resCall, const VkResult resTrace, const vktrace_replay::VKTRACE_REPLAY_RESULT resIn);
void push_validation_msg(VkFlags msgFlags, VkDbgObjectType objType, uint64_t srcObjectHandle, size_t location, int32_t msgCode, const char* pLayerPrefix, const char* pMsg, void* pUserData);
- glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();
+ vktrace_replay::VKTRACE_REPLAY_RESULT pop_validation_msgs();
int dump_validation_data();
private:
struct vkFuncs m_vkFuncs;
vkReplayObjMapper m_objMapper;
void (*m_pDSDump)(char*);
void (*m_pCBDump)(char*);
- //GLVSNAPSHOT_PRINT_OBJECTS m_pGlvSnapshotPrint;
+ //VKTRACESNAPSHOT_PRINT_OBJECTS m_pVktraceSnapshotPrint;
vkDisplay *m_display;
struct shaderPair {
include("${SRC_DIR}/build_options.cmake")
file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-trace-h vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-trace-c vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk.c)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-h vk_wsi_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_swapchain.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-c vk_wsi_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_swapchain.c)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-h vk_wsi_device_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_device_swapchain.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-c vk_wsi_device_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_device_swapchain.c)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-h vk_debug_report_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_report_lunarg.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-c vk_debug_report_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_report_lunarg.c)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-h vk_debug_marker_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_marker_lunarg.h)
-execute_process(COMMAND ${PYTHON_EXECUTABLE} ${GLV_VULKAN_DIR}/vktrace_generate.py glave-ext-trace-c vk_debug_marker_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_marker_lunarg.c)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-trace-h vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-trace-c vk_core OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk.c)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-h vk_wsi_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_swapchain.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-c vk_wsi_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_swapchain.c)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-h vk_wsi_device_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_device_swapchain.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-c vk_wsi_device_swapchain OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_wsi_device_swapchain.c)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-h vk_debug_report_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_report_lunarg.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-c vk_debug_report_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_report_lunarg.c)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-h vk_debug_marker_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_marker_lunarg.h)
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${VKTRACE_VULKAN_DIR}/vktrace_generate.py vktrace-ext-trace-c vk_debug_marker_lunarg OUTPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/codegen/vktrace_vk_vk_debug_marker_lunarg.c)
if (WIN32)
# Put vulkan_trace.dll in the same directory as vktrace.exe
codegen/vktrace_vk_vk_debug_marker_lunarg.h
codegen/vktrace_vk_vk_wsi_swapchain.h
codegen/vktrace_vk_vk_wsi_device_swapchain.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_packet_id.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_packets.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_debug_report_lunarg_packets.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_debug_marker_lunarg_packets.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_wsi_swapchain_packets.h
- ${CODEGEN_GLVVK_DIR}/vktrace_vk_vk_wsi_device_swapchain_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_packet_id.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_debug_report_lunarg_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_debug_marker_lunarg_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_wsi_swapchain_packets.h
+ ${CODEGEN_VKTRACE_DIR}/vktrace_vk_vk_wsi_device_swapchain_packets.h
${CMAKE_CURRENT_SOURCE_DIR}/../vulkan/codegen_utils/vk_struct_size_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/../vulkan/codegen_utils/vk_wsi_swapchain_struct_size_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/../vulkan/codegen_utils/vk_wsi_device_swapchain_struct_size_helper.h
${SRC_DIR}/vktrace_trace
${SRC_DIR}/thirdparty
${CMAKE_CURRENT_SOURCE_DIR}
- ${CODEGEN_GLVVK_DIR}
- ${GLV_VULKAN_INCLUDE_DIR}
+ ${CODEGEN_VKTRACE_DIR}
+ ${VKTRACE_VULKAN_INCLUDE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../vulkan/codegen_utils
)
target_link_libraries(${PROJECT_NAME}
vktrace_common
- ${GLV_VULKAN_LIB}
+ ${VKTRACE_VULKAN_LIB}
${OS_TRACER_LIBS}
)
#include "vktrace_interconnect.h"
#include "vktrace_vk_vk.h"
-// this is needed to be loaded by glvtrace
-GLVTRACER_EXPORT GLV_TRACER_ID GLVTRACER_CDECL GLV_GetTracerId(void)
+// this is needed to be loaded by vktrace
+VKTRACER_EXPORT VKTRACE_TRACER_ID VKTRACER_CDECL VKTRACE_GetTracerId(void)
{
- return GLV_TID_VULKAN;
+ return VKTRACE_TID_VULKAN;
}
-GLVTRACER_LEAVE _Unload(void);
+VKTRACER_LEAVE _Unload(void);
#ifdef PLATFORM_LINUX
-static void glv_sighandler(int signum, siginfo_t *info, void *ptr)
+static void vktrace_sighandler(int signum, siginfo_t *info, void *ptr)
{
- glv_LogVerbose("glvtrace_vk library handle signal %d.", signum);
+ vktrace_LogVerbose("vktrace_lib library handle signal %d.", signum);
_Unload();
kill(0, signum);
}
#endif
-GLVTRACER_EXIT TrapExit(void)
+VKTRACER_EXIT TrapExit(void)
{
- glv_LogVerbose("glvtrace_vk TrapExit.");
+ vktrace_LogVerbose("vktrace_lib TrapExit.");
}
-void loggingCallback(GlvLogLevel level, const char* pMessage)
+void loggingCallback(VktraceLogLevel level, const char* pMessage)
{
switch(level)
{
- case GLV_LOG_ALWAYS: printf("%s\n", pMessage); break;
- case GLV_LOG_DEBUG: printf("Debug: %s\n", pMessage); break;
- case GLV_LOG_ERROR: printf("Error: %s\n", pMessage); break;
- case GLV_LOG_WARNING: printf("Warning: %s\n", pMessage); break;
- case GLV_LOG_VERBOSE: printf("Verbose: %s\n", pMessage); break;
+ case VKTRACE_LOG_ALWAYS: printf("%s\n", pMessage); break;
+ case VKTRACE_LOG_DEBUG: printf("Debug: %s\n", pMessage); break;
+ case VKTRACE_LOG_ERROR: printf("Error: %s\n", pMessage); break;
+ case VKTRACE_LOG_WARNING: printf("Warning: %s\n", pMessage); break;
+ case VKTRACE_LOG_VERBOSE: printf("Verbose: %s\n", pMessage); break;
default:
printf("%s\n", pMessage); break;
}
- if (glv_trace_get_trace_file() != NULL)
+ if (vktrace_trace_get_trace_file() != NULL)
{
size_t requiredLength = strlen(pMessage) + 1;
- glv_trace_packet_header* pHeader = glv_create_trace_packet(GLV_GetTracerId(), GLV_TPI_MESSAGE, sizeof(glv_trace_packet_message), requiredLength);
- glv_trace_packet_message* pPacket = glv_interpret_body_as_trace_packet_message(pHeader);
+ vktrace_trace_packet_header* pHeader = vktrace_create_trace_packet(VKTRACE_GetTracerId(), VKTRACE_TPI_MESSAGE, sizeof(vktrace_trace_packet_message), requiredLength);
+ vktrace_trace_packet_message* pPacket = vktrace_interpret_body_as_trace_packet_message(pHeader);
pPacket->type = level;
pPacket->length = requiredLength;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&pPacket->message, requiredLength, pMessage);
- glv_finalize_buffer_address(pHeader, (void**)&pPacket->message);
- glv_set_packet_entrypoint_end_time(pHeader);
- glv_finalize_trace_packet(pHeader);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&pPacket->message, requiredLength, pMessage);
+ vktrace_finalize_buffer_address(pHeader, (void**)&pPacket->message);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
+ vktrace_finalize_trace_packet(pHeader);
- glv_write_trace_packet(pHeader, glv_trace_get_trace_file());
- glv_delete_trace_packet(&pHeader);
+ vktrace_write_trace_packet(pHeader, vktrace_trace_get_trace_file());
+ vktrace_delete_trace_packet(&pHeader);
}
#if defined(WIN32)
}
extern
-GLVTRACER_ENTRY _Load(void)
+VKTRACER_ENTRY _Load(void)
{
- // only do the hooking and networking if the tracer is NOT loaded by glvtrace
- if (glv_is_loaded_into_glvtrace() == FALSE)
+ // only do the hooking and networking if the tracer is NOT loaded by vktrace
+ if (vktrace_is_loaded_into_vktrace() == FALSE)
{
- glv_LogSetCallback(loggingCallback);
- glv_LogSetLevel(GLV_LOG_LEVEL_MAXIMUM);
+ vktrace_LogSetCallback(loggingCallback);
+ vktrace_LogSetLevel(VKTRACE_LOG_LEVEL_MAXIMUM);
- glv_LogVerbose("glvtrace_vk library loaded into PID %d", glv_get_pid());
+ vktrace_LogVerbose("vktrace_lib library loaded into PID %d", vktrace_get_pid());
atexit(TrapExit);
// If you need to debug startup, build with this set to true, then attach and change it to false.
#else
struct sigaction act;
memset(&act, 0 , sizeof(act));
- act.sa_sigaction = glv_sighandler;
+ act.sa_sigaction = vktrace_sighandler;
act.sa_flags = SA_SIGINFO | SA_RESETHAND;
sigaction(SIGINT, &act, NULL);
sigaction(SIGTERM, &act, NULL);
}
}
-GLVTRACER_LEAVE _Unload(void)
+VKTRACER_LEAVE _Unload(void)
{
- // only do the hooking and networking if the tracer is NOT loaded by glvtrace
- if (glv_is_loaded_into_glvtrace() == FALSE)
+ // only do the hooking and networking if the tracer is NOT loaded by vktrace
+ if (vktrace_is_loaded_into_vktrace() == FALSE)
{
DetachHooks();
- if (glv_trace_get_trace_file() != NULL) {
- glv_trace_packet_header* pHeader = glv_create_trace_packet(GLV_GetTracerId(), GLV_TPI_MARKER_TERMINATE_PROCESS, 0, 0);
- glv_finalize_trace_packet(pHeader);
- glv_write_trace_packet(pHeader, glv_trace_get_trace_file());
- glv_delete_trace_packet(&pHeader);
- glv_free(glv_trace_get_trace_file());
- glv_trace_set_trace_file(NULL);
+ if (vktrace_trace_get_trace_file() != NULL) {
+ vktrace_trace_packet_header* pHeader = vktrace_create_trace_packet(VKTRACE_GetTracerId(), VKTRACE_TPI_MARKER_TERMINATE_PROCESS, 0, 0);
+ vktrace_finalize_trace_packet(pHeader);
+ vktrace_write_trace_packet(pHeader, vktrace_trace_get_trace_file());
+ vktrace_delete_trace_packet(&pHeader);
+ vktrace_free(vktrace_trace_get_trace_file());
+ vktrace_trace_set_trace_file(NULL);
}
if (gMessageStream != NULL)
{
- glv_MessageStream_destroy(&gMessageStream);
+ vktrace_MessageStream_destroy(&gMessageStream);
}
- glv_LogVerbose("glvtrace_vk library unloaded from PID %d", glv_get_pid());
+ vktrace_LogVerbose("vktrace_lib library unloaded from PID %d", vktrace_get_pid());
}
}
// defined in manually written file: vktrace_vk_trace.c
extern VKMemInfo g_memInfo;
-extern GLV_CRITICAL_SECTION g_memInfoLock;
+extern VKTRACE_CRITICAL_SECTION g_memInfoLock;
static void init_mem_info_entrys(VKAllocInfo *ptr, const unsigned int num)
{
g_memInfo.capacity = 4096;
g_memInfo.pLastMapped = NULL;
- g_memInfo.pEntrys = GLV_NEW_ARRAY(VKAllocInfo, g_memInfo.capacity);
+ g_memInfo.pEntrys = VKTRACE_NEW_ARRAY(VKAllocInfo, g_memInfo.capacity);
if (g_memInfo.pEntrys == NULL)
- glv_LogError("init_mem_info() malloc failed.");
+ vktrace_LogError("init_mem_info() malloc failed.");
else
init_mem_info_entrys(g_memInfo.pEntrys, g_memInfo.capacity);
}
// caller must hold the g_memInfoLock
static void delete_mem_info()
{
- GLV_DELETE(g_memInfo.pEntrys);
+ VKTRACE_DELETE(g_memInfo.pEntrys);
g_memInfo.pEntrys = NULL;
g_memInfo.numEntrys = 0;
g_memInfo.capacity = 0;
VKAllocInfo *entry;
if (g_memInfo.numEntrys > g_memInfo.capacity)
{
- glv_LogError("get_mem_info_entry() bad internal state numEntrys %u.", g_memInfo.numEntrys);
+ vktrace_LogError("get_mem_info_entry() bad internal state numEntrys %u.", g_memInfo.numEntrys);
return NULL;
}
if (g_memInfo.numEntrys == g_memInfo.capacity)
{ // grow the array 2x
g_memInfo.capacity *= 2;
- g_memInfo.pEntrys = (VKAllocInfo *) GLV_REALLOC(g_memInfo.pEntrys, g_memInfo.capacity * sizeof(VKAllocInfo));
+ g_memInfo.pEntrys = (VKAllocInfo *) VKTRACE_REALLOC(g_memInfo.pEntrys, g_memInfo.capacity * sizeof(VKAllocInfo));
if (g_memInfo.pEntrys == NULL)
- glv_LogError("get_mem_info_entry() realloc failed.");
- //glv_LogDebug("realloc memInfo from %u to %", g_memInfo.capacity /2, g_memInfo.capacity);
+ vktrace_LogError("get_mem_info_entry() realloc failed.");
+ //vktrace_LogDebug("realloc memInfo from %u to %", g_memInfo.capacity /2, g_memInfo.capacity);
//init the newly added entrys
init_mem_info_entrys(g_memInfo.pEntrys + g_memInfo.capacity / 2, g_memInfo.capacity / 2);
}
static VKAllocInfo * find_mem_info_entry_lock(const VkDeviceMemory handle)
{
VKAllocInfo *res;
- glv_enter_critical_section(&g_memInfoLock);
+ vktrace_enter_critical_section(&g_memInfoLock);
res = find_mem_info_entry(handle);
- glv_leave_critical_section(&g_memInfoLock);
+ vktrace_leave_critical_section(&g_memInfoLock);
return res;
}
{
VKAllocInfo *entry;
- glv_enter_critical_section(&g_memInfoLock);
+ vktrace_enter_critical_section(&g_memInfoLock);
if (g_memInfo.capacity == 0)
init_mem_info();
entry->didFlush = FALSE;
entry->pData = pData; // NOTE: VKFreeMemory will free this mem, so no malloc()
}
- glv_leave_critical_section(&g_memInfoLock);
+ vktrace_leave_critical_section(&g_memInfoLock);
}
static void add_data_to_mem_info(const VkDeviceMemory handle, VkDeviceSize rangeSize, VkDeviceSize rangeOffset, void *pData)
{
VKAllocInfo *entry;
- glv_enter_critical_section(&g_memInfoLock);
+ vktrace_enter_critical_section(&g_memInfoLock);
entry = find_mem_info_entry(handle);
if (entry)
{
assert(entry->totalSize >= rangeSize + rangeOffset);
}
g_memInfo.pLastMapped = entry;
- glv_leave_critical_section(&g_memInfoLock);
+ vktrace_leave_critical_section(&g_memInfoLock);
}
static void rm_handle_from_mem_info(const VkDeviceMemory handle)
{
VKAllocInfo *entry;
- glv_enter_critical_section(&g_memInfoLock);
+ vktrace_enter_critical_section(&g_memInfoLock);
entry = find_mem_info_entry(handle);
if (entry)
{
if (g_memInfo.numEntrys == 0)
delete_mem_info();
}
- glv_leave_critical_section(&g_memInfoLock);
+ vktrace_leave_critical_section(&g_memInfoLock);
}
-static void add_alloc_memory_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)
+static void add_alloc_memory_to_trace_packet(vktrace_trace_packet_header* pHeader, void** ppOut, const void* pIn)
{
const VkMemoryAllocInfo* pInNow = pIn;
while (pInNow != NULL)
return siz;
}
-static void add_VkPipelineShaderStageCreateInfo_to_trace_packet(glv_trace_packet_header* pHeader, VkPipelineShaderStageCreateInfo* packetShader, const VkPipelineShaderStageCreateInfo* paramShader)
+static void add_VkPipelineShaderStageCreateInfo_to_trace_packet(vktrace_trace_packet_header* pHeader, VkPipelineShaderStageCreateInfo* packetShader, const VkPipelineShaderStageCreateInfo* paramShader)
{
// Specialization info
if (packetShader->pSpecializationInfo != NULL)
{
- glv_add_buffer_to_trace_packet(pHeader, (void**)&packetShader->pSpecializationInfo, sizeof(VkPipelineShaderStageCreateInfo), paramShader->pSpecializationInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&packetShader->pSpecializationInfo->pMap, sizeof(VkSpecializationMapEntry) * paramShader->pSpecializationInfo->mapEntryCount, paramShader->pSpecializationInfo->pMap);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&packetShader->pSpecializationInfo, sizeof(VkPipelineShaderStageCreateInfo), paramShader->pSpecializationInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&packetShader->pSpecializationInfo->pMap, sizeof(VkSpecializationMapEntry) * paramShader->pSpecializationInfo->mapEntryCount, paramShader->pSpecializationInfo->pMap);
// TODO: packetShader->pSpecializationInfo->pData is not yet supported because we don't know what size it is.
// We now have dataSize so fix this
- glv_LogError("VkSpecializationInfo is not yet supported because we don't know how many bytes it is.");
- glv_finalize_buffer_address(pHeader, (void**)&packetShader->pSpecializationInfo->pMap);
- glv_finalize_buffer_address(pHeader, (void**)&packetShader->pSpecializationInfo);
+ vktrace_LogError("VkSpecializationInfo is not yet supported because we don't know how many bytes it is.");
+ vktrace_finalize_buffer_address(pHeader, (void**)&packetShader->pSpecializationInfo->pMap);
+ vktrace_finalize_buffer_address(pHeader, (void**)&packetShader->pSpecializationInfo);
}
}
-static void add_create_ds_layout_to_trace_packet(glv_trace_packet_header* pHeader, const VkDescriptorSetLayoutCreateInfo** ppOut, const VkDescriptorSetLayoutCreateInfo* pIn)
+static void add_create_ds_layout_to_trace_packet(vktrace_trace_packet_header* pHeader, const VkDescriptorSetLayoutCreateInfo** ppOut, const VkDescriptorSetLayoutCreateInfo* pIn)
{
const VkDescriptorSetLayoutCreateInfo* pInNow = pIn;
VkDescriptorSetLayoutCreateInfo** ppOutNext = (VkDescriptorSetLayoutCreateInfo**)ppOut;
{
VkDescriptorSetLayoutCreateInfo** ppOutNow = ppOutNext;
ppOutNext = NULL;
- glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(VkDescriptorSetLayoutCreateInfo), pInNow);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(VkDescriptorSetLayoutCreateInfo), pInNow);
ppOutNext = (VkDescriptorSetLayoutCreateInfo**)&(*ppOutNow)->pNext;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppOutNow)->pBinding), sizeof(VkDescriptorSetLayoutBinding) * pInNow->count, pInNow->pBinding);
- glv_finalize_buffer_address(pHeader, (void**)&((*ppOutNow)->pBinding));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppOutNow)->pBinding), sizeof(VkDescriptorSetLayoutBinding) * pInNow->count, pInNow->pBinding);
+ vktrace_finalize_buffer_address(pHeader, (void**)&((*ppOutNow)->pBinding));
ppOutNext = (VkDescriptorSetLayoutCreateInfo**)&(*ppOutNow)->pNext;
pInNow = (VkDescriptorSetLayoutCreateInfo*)pInNow->pNext;
- glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));
+ vktrace_finalize_buffer_address(pHeader, (void**)(ppOutNow));
}
return;
}
-static void add_VkGraphicsPipelineCreateInfos_to_trace_packet(glv_trace_packet_header* pHeader, VkGraphicsPipelineCreateInfo* pPacket, const VkGraphicsPipelineCreateInfo* pParam, uint32_t count)
+static void add_VkGraphicsPipelineCreateInfos_to_trace_packet(vktrace_trace_packet_header* pHeader, VkGraphicsPipelineCreateInfo* pPacket, const VkGraphicsPipelineCreateInfo* pParam, uint32_t count)
{
if (pParam != NULL)
{
for (i = 0; i < count; i++) {
// shader stages array
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pStages), sizeof(VkPipelineShaderStageCreateInfo) * pParam[i].stageCount, pParam[i].pStages);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pStages), sizeof(VkPipelineShaderStageCreateInfo) * pParam[i].stageCount, pParam[i].pStages);
for (j = 0; j < pParam[i].stageCount; j++)
{
add_VkPipelineShaderStageCreateInfo_to_trace_packet(pHeader, (VkPipelineShaderStageCreateInfo*)&pPacket->pStages[j], &pParam->pStages[j]);
}
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pStages));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pStages));
// Vertex Input State
if (pParam[i].pVertexInputState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState), sizeof(VkPipelineVertexInputStateCreateInfo), pParam[i].pVertexInputState);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions), pParam[i].pVertexInputState->bindingCount * sizeof(VkVertexInputBindingDescription), pParam[i].pVertexInputState->pVertexBindingDescriptions);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions));
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions), pParam[i].pVertexInputState->attributeCount * sizeof(VkVertexInputAttributeDescription), pParam[i].pVertexInputState->pVertexAttributeDescriptions);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState), sizeof(VkPipelineVertexInputStateCreateInfo), pParam[i].pVertexInputState);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions), pParam[i].pVertexInputState->bindingCount * sizeof(VkVertexInputBindingDescription), pParam[i].pVertexInputState->pVertexBindingDescriptions);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions), pParam[i].pVertexInputState->attributeCount * sizeof(VkVertexInputAttributeDescription), pParam[i].pVertexInputState->pVertexAttributeDescriptions);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState));
}
// Input Assembly State
if (pParam[i].pInputAssemblyState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInputAssemblyState), sizeof(VkPipelineInputAssemblyStateCreateInfo), pParam[i].pInputAssemblyState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pInputAssemblyState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInputAssemblyState), sizeof(VkPipelineInputAssemblyStateCreateInfo), pParam[i].pInputAssemblyState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pInputAssemblyState));
}
// Tesselation State
if (pParam[i].pTessellationState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pTessellationState), sizeof(VkPipelineTessellationStateCreateInfo), pParam[i].pTessellationState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pTessellationState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pTessellationState), sizeof(VkPipelineTessellationStateCreateInfo), pParam[i].pTessellationState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pTessellationState));
}
// Viewport State
if (pParam[i].pViewportState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pViewportState), sizeof(VkPipelineViewportStateCreateInfo), pParam[i].pViewportState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pViewportState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pViewportState), sizeof(VkPipelineViewportStateCreateInfo), pParam[i].pViewportState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pViewportState));
}
// Raster State
if (pParam[i].pRasterState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRasterState), sizeof(VkPipelineRasterStateCreateInfo), pParam[i].pRasterState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRasterState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRasterState), sizeof(VkPipelineRasterStateCreateInfo), pParam[i].pRasterState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pRasterState));
}
// MultiSample State
if (pParam[i].pMultisampleState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMultisampleState), sizeof(VkPipelineMultisampleStateCreateInfo), pParam[i].pMultisampleState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMultisampleState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMultisampleState), sizeof(VkPipelineMultisampleStateCreateInfo), pParam[i].pMultisampleState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pMultisampleState));
}
// DepthStencil State
if (pParam[i].pDepthStencilState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDepthStencilState), sizeof(VkPipelineDepthStencilStateCreateInfo), pParam[i].pDepthStencilState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDepthStencilState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDepthStencilState), sizeof(VkPipelineDepthStencilStateCreateInfo), pParam[i].pDepthStencilState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDepthStencilState));
}
// ColorBlend State
if (pParam[i].pColorBlendState) {
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState), sizeof(VkPipelineColorBlendStateCreateInfo), pParam[i].pColorBlendState);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments), pParam[i].pColorBlendState->attachmentCount * sizeof(VkPipelineColorBlendAttachmentState), pParam[i].pColorBlendState->pAttachments);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState), sizeof(VkPipelineColorBlendStateCreateInfo), pParam[i].pColorBlendState);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments), pParam[i].pColorBlendState->attachmentCount * sizeof(VkPipelineColorBlendAttachmentState), pParam[i].pColorBlendState->pAttachments);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState));
}
}
}
return;
}
-static void add_VkComputePipelineCreateInfos_to_trace_packet(glv_trace_packet_header* pHeader, VkComputePipelineCreateInfo* pPacket, const VkComputePipelineCreateInfo* pParam, uint32_t count)
+static void add_VkComputePipelineCreateInfos_to_trace_packet(vktrace_trace_packet_header* pHeader, VkComputePipelineCreateInfo* pPacket, const VkComputePipelineCreateInfo* pParam, uint32_t count)
{
if (pParam != NULL)
{
for (i = 0; i < count; i++) {
// shader stage
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->cs), sizeof(VkPipelineShaderStageCreateInfo), &pParam[i].cs);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->cs), sizeof(VkPipelineShaderStageCreateInfo), &pParam[i].cs);
add_VkPipelineShaderStageCreateInfo_to_trace_packet(pHeader, (VkPipelineShaderStageCreateInfo*)&pPacket->cs, &pParam[i].cs);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->cs));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->cs));
/*
// Vertex Input State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState), sizeof(VkPipelineVertexInputStateCreateInfo), pParam[i]->pVertexInputState);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions), pParam[i]->pVertexInputState->bindingCount * sizeof(VkVertexInputBindingDescription), pParam[i]->pVertexInputState->pVertexBindingDescriptions);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions));
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions), pParam[i]->pVertexInputState->attributeCount * sizeof(VkVertexInputAttributeDescription), pParam[i]->pVertexInputState->pVertexAttributeDescriptions);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState), sizeof(VkPipelineVertexInputStateCreateInfo), pParam[i]->pVertexInputState);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions), pParam[i]->pVertexInputState->bindingCount * sizeof(VkVertexInputBindingDescription), pParam[i]->pVertexInputState->pVertexBindingDescriptions);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexBindingDescriptions));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions), pParam[i]->pVertexInputState->attributeCount * sizeof(VkVertexInputAttributeDescription), pParam[i]->pVertexInputState->pVertexAttributeDescriptions);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState->pVertexAttributeDescriptions));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexInputState));
// Input Assembly State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInputAssemblyState), sizeof(VkPipelineInputAssemblyStateCreateInfo), pParam[i]->pInputAssemblyState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pInputAssemblyState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInputAssemblyState), sizeof(VkPipelineInputAssemblyStateCreateInfo), pParam[i]->pInputAssemblyState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pInputAssemblyState));
// Tesselation State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pTessellationState), sizeof(VkPipelineTessellationStateCreateInfo), pParam[i]->pTessellationState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pTessellationState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pTessellationState), sizeof(VkPipelineTessellationStateCreateInfo), pParam[i]->pTessellationState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pTessellationState));
// Viewport State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pViewportState), sizeof(VkPipelineViewportStateCreateInfo), pParam[i]->pViewportState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pViewportState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pViewportState), sizeof(VkPipelineViewportStateCreateInfo), pParam[i]->pViewportState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pViewportState));
// Raster State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRasterState), sizeof(VkPipelineRasterStateCreateInfo), pParam[i]->pRasterState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRasterState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRasterState), sizeof(VkPipelineRasterStateCreateInfo), pParam[i]->pRasterState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pRasterState));
// MultiSample State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMultisampleState), sizeof(VkPipelineMultisampleStateCreateInfo), pParam[i]->pMultisampleState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMultisampleState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMultisampleState), sizeof(VkPipelineMultisampleStateCreateInfo), pParam[i]->pMultisampleState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pMultisampleState));
// DepthStencil State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDepthStencilState), sizeof(VkPipelineDepthStencilStateCreateInfo), pParam[i]->pDepthStencilState);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDepthStencilState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDepthStencilState), sizeof(VkPipelineDepthStencilStateCreateInfo), pParam[i]->pDepthStencilState);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDepthStencilState));
// ColorBlend State
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState), sizeof(VkPipelineColorBlendStateCreateInfo), pParam[i]->pColorBlendState);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments), pParam[i]->pColorBlendState->attachmentCount * sizeof(VkPipelineColorBlendAttachmentState), pParam[i]->pColorBlendState->pAttachments);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState), sizeof(VkPipelineColorBlendStateCreateInfo), pParam[i]->pColorBlendState);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments), pParam[i]->pColorBlendState->attachmentCount * sizeof(VkPipelineColorBlendAttachmentState), pParam[i]->pColorBlendState->pAttachments);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState->pAttachments));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorBlendState));
*/
}
}
#include <stdio.h>
// declared as extern in vktrace_lib_helpers.h
-GLV_CRITICAL_SECTION g_memInfoLock;
+VKTRACE_CRITICAL_SECTION g_memInfoLock;
VKMemInfo g_memInfo = {0, NULL, NULL, 0};
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkAllocMemory(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkAllocMemory(
VkDevice device,
const VkMemoryAllocInfo* pAllocInfo,
VkDeviceMemory* pMem)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkAllocMemory* pPacket = NULL;
CREATE_TRACE_PACKET(vkAllocMemory, get_struct_chain_size((void*)pAllocInfo) + sizeof(VkDeviceMemory));
result = real_vkAllocMemory(device, pAllocInfo, pMem);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkAllocMemory(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(VkMemoryAllocInfo), pAllocInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(VkMemoryAllocInfo), pAllocInfo);
add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(VkDeviceMemory), pMem);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(VkDeviceMemory), pMem);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
FINISH_TRACE_PACKET();
// begin custom code
add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkMapMemory(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkMapMemory(
VkDevice device,
VkDeviceMemory mem,
VkDeviceSize offset,
VkFlags flags,
void** ppData)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkMapMemory* pPacket = NULL;
CREATE_TRACE_PACKET(vkMapMemory, sizeof(void*));
result = real_vkMapMemory(device, mem, offset, size, flags, ppData);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkMapMemory(pHeader);
pPacket->device = device;
pPacket->mem = mem;
pPacket->flags = flags;
if (ppData != NULL)
{
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(void*), *ppData);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(void*), *ppData);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));
add_data_to_mem_info(mem, size, offset, *ppData);
}
pPacket->result = result;
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkUnmapMemory(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkUnmapMemory(
VkDevice device,
VkDeviceMemory mem)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkUnmapMemory* pPacket;
VKAllocInfo *entry;
size_t siz = 0, off = 0;
// insert into packet the data that was written by CPU between the vkMapMemory call and here
// Note must do this prior to the real vkUnMap() or else may get a FAULT
- glv_enter_critical_section(&g_memInfoLock);
+ vktrace_enter_critical_section(&g_memInfoLock);
entry = find_mem_info_entry(mem);
if (entry && entry->pData != NULL)
{
if (siz)
{
assert(entry->handle.handle == mem.handle);
- glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), siz, entry->pData + off);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), siz, entry->pData + off);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
entry->pData = NULL;
}
- glv_leave_critical_section(&g_memInfoLock);
+ vktrace_leave_critical_section(&g_memInfoLock);
result = real_vkUnmapMemory(device, mem);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket->device = device;
pPacket->mem = mem;
pPacket->result = result;
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkFreeMemory(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkFreeMemory(
VkDevice device,
VkDeviceMemory mem)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkFreeMemory* pPacket = NULL;
CREATE_TRACE_PACKET(vkFreeMemory, 0);
result = real_vkFreeMemory(device, mem);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkFreeMemory(pHeader);
pPacket->device = device;
pPacket->mem = mem;
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkFlushMappedMemoryRanges(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkFlushMappedMemoryRanges(
VkDevice device,
uint32_t memRangeCount,
const VkMappedMemoryRange* pMemRanges)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
size_t rangesSize = 0;
size_t dataSize = 0;
CREATE_TRACE_PACKET(vkFlushMappedMemoryRanges, rangesSize + sizeof(void*)*memRangeCount + dataSize);
pPacket = interpret_body_as_vkFlushMappedMemoryRanges(pHeader);
- glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pMemRanges), rangesSize, pMemRanges);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMemRanges));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pMemRanges), rangesSize, pMemRanges);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pMemRanges));
// insert into packet the data that was written by CPU between the vkMapMemory call and here
// create a temporary local ppData array and add it to the packet (to reserve the space for the array)
void** ppTmpData = malloc(memRangeCount * sizeof(void*));
- glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->ppData), sizeof(void*)*memRangeCount, ppTmpData);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->ppData), sizeof(void*)*memRangeCount, ppTmpData);
free(ppTmpData);
// now the actual memory
- glv_enter_critical_section(&g_memInfoLock);
+ vktrace_enter_critical_section(&g_memInfoLock);
for (iter = 0; iter < memRangeCount; iter++)
{
VkMappedMemoryRange* pRange = (VkMappedMemoryRange*)&pMemRanges[iter];
assert(pEntry->totalSize >= (pRange->size + pRange->offset));
assert(pEntry->totalSize >= pRange->size);
assert(pRange->offset >= pEntry->rangeOffset && (pRange->offset + pRange->size) <= (pEntry->rangeOffset + pEntry->rangeSize));
- glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->ppData[iter]), pRange->size, pEntry->pData + pRange->offset);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData[iter]));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->ppData[iter]), pRange->size, pEntry->pData + pRange->offset);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData[iter]));
pEntry->didFlush = TRUE;
}
else
{
- glv_LogError("Failed to copy app memory into trace packet (idx = %u) on vkFlushedMappedMemoryRanges", pHeader->global_packet_index);
+ vktrace_LogError("Failed to copy app memory into trace packet (idx = %u) on vkFlushedMappedMemoryRanges", pHeader->global_packet_index);
}
}
- glv_leave_critical_section(&g_memInfoLock);
+ vktrace_leave_critical_section(&g_memInfoLock);
// now finalize the ppData array since it is done being updated
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));
result = real_vkFlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket->device = device;
pPacket->memRangeCount = memRangeCount;
pPacket->result = result;
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDescriptorPool(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDescriptorPool(
VkDevice device,
VkDescriptorPoolUsage poolUsage,
uint32_t maxSets,
const VkDescriptorPoolCreateInfo* pCreateInfo,
VkDescriptorPool* pDescriptorPool)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateDescriptorPool* pPacket = NULL;
// begin custom code (needs to use get_struct_chain_size)
CREATE_TRACE_PACKET(vkCreateDescriptorPool, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDescriptorPool));
// end custom code
result = real_vkCreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateDescriptorPool(pHeader);
pPacket->device = device;
pPacket->poolUsage = poolUsage;
pPacket->maxSets = maxSets;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), pCreateInfo->count * sizeof(VkDescriptorTypeCount), pCreateInfo->pTypeCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorPool), sizeof(VkDescriptorPool), pDescriptorPool);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), pCreateInfo->count * sizeof(VkDescriptorTypeCount), pCreateInfo->pTypeCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorPool), sizeof(VkDescriptorPool), pDescriptorPool);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorPool));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorPool));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDevice(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
VkDevice* pDevice)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
uint32_t i, count;
const char strScreenShot[] = "ScreenShot";
- char *strScreenShotEnv = glv_get_global_var("_VK_SCREENSHOT");
+ char *strScreenShotEnv = vktrace_get_global_var("_VK_SCREENSHOT");
packet_vkCreateDevice* pPacket = NULL;
char **ppEnabledLayerNames = NULL, **saved_ppELN;
VkDeviceCreateInfo **ppCI;
{
// query to find if ScreenShot layer is available
real_vkGetPhysicalDeviceLayerProperties(physicalDevice, &count, NULL);
- VkLayerProperties *props = (VkLayerProperties *) glv_malloc(count * sizeof (VkLayerProperties));
+ VkLayerProperties *props = (VkLayerProperties *) vktrace_malloc(count * sizeof (VkLayerProperties));
if (props && count > 0)
real_vkGetPhysicalDeviceLayerProperties(physicalDevice, &count, props);
for (i = 0; i < count; i++) {
if (found_ss)
{
// screenshot layer is available so enable it
- ppEnabledLayerNames = (char **) glv_malloc((pCreateInfo->layerCount + 1) * sizeof (char *));
+ ppEnabledLayerNames = (char **) vktrace_malloc((pCreateInfo->layerCount + 1) * sizeof (char *));
for (i = 0; i < pCreateInfo->layerCount && ppEnabledLayerNames; i++) {
ppEnabledLayerNames[i] = (char *) pCreateInfo->ppEnabledLayerNames[i];
}
- ppEnabledLayerNames[pCreateInfo->layerCount] = (char *) glv_malloc(strlen(strScreenShot) + 1);
+ ppEnabledLayerNames[pCreateInfo->layerCount] = (char *) vktrace_malloc(strlen(strScreenShot) + 1);
ppCI = (VkDeviceCreateInfo **) &pCreateInfo;
strcpy(ppEnabledLayerNames[pCreateInfo->layerCount], strScreenShot);
(*ppCI)->layerCount = pCreateInfo->layerCount + 1;
saved_ppELN = (char **) pCreateInfo->ppEnabledLayerNames;
(*ppCI)->ppEnabledLayerNames = (const char*const*) ppEnabledLayerNames;
}
- glv_free(props);
+ vktrace_free(props);
}
}
CREATE_TRACE_PACKET(vkCreateDevice, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDevice));
result = real_vkCreateDevice(physicalDevice, pCreateInfo, pDevice);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateDevice(pHeader);
pPacket->physicalDevice = physicalDevice;
add_VkDeviceCreateInfo_to_packet(pHeader, (VkDeviceCreateInfo**) &(pPacket->pCreateInfo), pCreateInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDevice), sizeof(VkDevice), pDevice);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDevice), sizeof(VkDevice), pDevice);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDevice));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDevice));
if (ppEnabledLayerNames)
{
- glv_free(ppEnabledLayerNames[pCreateInfo->layerCount-1]);
- glv_free(ppEnabledLayerNames);
+ vktrace_free(ppEnabledLayerNames[pCreateInfo->layerCount-1]);
+ vktrace_free(ppEnabledLayerNames);
(*ppCI)->ppEnabledLayerNames = (const char*const*) saved_ppELN;
}
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDynamicViewportState(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDynamicViewportState(
VkDevice device,
const VkDynamicViewportStateCreateInfo* pCreateInfo,
VkDynamicViewportState* pState)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateDynamicViewportState* pPacket = NULL;
// begin custom code (needs to call get_struct_chain_size)
CREATE_TRACE_PACKET(vkCreateDynamicViewportState, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDynamicViewportState));
// end custom code
result = real_vkCreateDynamicViewportState(device, pCreateInfo, pState);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateDynamicViewportState(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDynamicViewportStateCreateInfo), pCreateInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(VkViewport), pCreateInfo->pViewports);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(VkRect2D), pCreateInfo->pScissors);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(VkDynamicViewportState), pState);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDynamicViewportStateCreateInfo), pCreateInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(VkViewport), pCreateInfo->pViewports);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(VkRect2D), pCreateInfo->pScissors);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(VkDynamicViewportState), pState);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateFramebuffer(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
VkFramebuffer* pFramebuffer)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateFramebuffer* pPacket = NULL;
// begin custom code
CREATE_TRACE_PACKET(vkCreateFramebuffer, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkFramebuffer));
// end custom code
result = real_vkCreateFramebuffer(device, pCreateInfo, pFramebuffer);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateFramebuffer(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments), attachmentCount * sizeof(VkAttachmentView), pCreateInfo->pAttachments);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pFramebuffer), sizeof(VkFramebuffer), pFramebuffer);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments), attachmentCount * sizeof(VkAttachmentView), pCreateInfo->pAttachments);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pFramebuffer), sizeof(VkFramebuffer), pFramebuffer);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pFramebuffer));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pFramebuffer));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateInstance(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
VkInstance* pInstance)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateInstance* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- glv_platform_thread_once(&gInitOnce, InitTracer);
+ uint64_t vktraceStartTime = vktrace_get_time();
+ vktrace_platform_thread_once(&gInitOnce, InitTracer);
SEND_ENTRYPOINT_ID(vkCreateInstance);
if (real_vkCreateInstance == vkCreateInstance)
{
- glv_platform_get_next_lib_sym((void **) &real_vkCreateInstance,"vkCreateInstance");
+ vktrace_platform_get_next_lib_sym((void **) &real_vkCreateInstance,"vkCreateInstance");
}
- startTime = glv_get_time();
+ startTime = vktrace_get_time();
result = real_vkCreateInstance(pCreateInfo, pInstance);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkCreateInstance, sizeof(VkInstance) + get_struct_chain_size((void*)pCreateInfo));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
if (isHooked == FALSE) {
pPacket = interpret_body_as_vkCreateInstance(pHeader);
add_VkInstanceCreateInfo_to_packet(pHeader, (VkInstanceCreateInfo**)&(pPacket->pCreateInfo), (VkInstanceCreateInfo*) pCreateInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInstance), sizeof(VkInstance), pInstance);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInstance), sizeof(VkInstance), pInstance);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pInstance));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pInstance));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateRenderPass(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
VkRenderPass* pRenderPass)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateRenderPass* pPacket = NULL;
// begin custom code (get_struct_chain_size)
CREATE_TRACE_PACKET(vkCreateRenderPass, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkRenderPass));
// end custom code
result = real_vkCreateRenderPass(device, pCreateInfo, pRenderPass);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateRenderPass(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkRenderPassCreateInfo), pCreateInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments), attachmentCount * sizeof(VkAttachmentDescription), pCreateInfo->pAttachments);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDependencies), sizeof(VkSubpassDependency), pCreateInfo->pDependencies);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSubpasses), sizeof(VkSubpassDescription), pCreateInfo->pSubpasses);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkRenderPassCreateInfo), pCreateInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments), attachmentCount * sizeof(VkAttachmentDescription), pCreateInfo->pAttachments);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDependencies), sizeof(VkSubpassDependency), pCreateInfo->pDependencies);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSubpasses), sizeof(VkSubpassDescription), pCreateInfo->pSubpasses);
uint32_t i;
for (i=0; i < pPacket->pCreateInfo->subpassCount; i++) {
VkSubpassDescription *pSubpass = (VkSubpassDescription *) &pPacket->pCreateInfo->pSubpasses[i];
const VkSubpassDescription *pSp = &pCreateInfo->pSubpasses[i];
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pInputAttachments), pSubpass->inputCount * sizeof(VkAttachmentReference), pSp->pInputAttachments);
- glv_finalize_buffer_address(pHeader, (void**)&(pSubpass->pInputAttachments));
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pColorAttachments), pSubpass->colorCount * sizeof(VkAttachmentReference), pSp->pColorAttachments);
- glv_finalize_buffer_address(pHeader, (void**)&(pSubpass->pColorAttachments));
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pResolveAttachments), pSubpass->colorCount * sizeof(VkAttachmentReference), pSp->pResolveAttachments);
- glv_finalize_buffer_address(pHeader, (void**)&(pSubpass->pResolveAttachments));
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pPreserveAttachments), pSubpass->preserveCount * sizeof(VkAttachmentReference), pSp->pPreserveAttachments);
- glv_finalize_buffer_address(pHeader, (void**)&(pSubpass->pPreserveAttachments));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pInputAttachments), pSubpass->inputCount * sizeof(VkAttachmentReference), pSp->pInputAttachments);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pSubpass->pInputAttachments));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pColorAttachments), pSubpass->colorCount * sizeof(VkAttachmentReference), pSp->pColorAttachments);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pSubpass->pColorAttachments));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pResolveAttachments), pSubpass->colorCount * sizeof(VkAttachmentReference), pSp->pResolveAttachments);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pSubpass->pResolveAttachments));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pPreserveAttachments), pSubpass->preserveCount * sizeof(VkAttachmentReference), pSp->pPreserveAttachments);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pSubpass->pPreserveAttachments));
}
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPass), sizeof(VkRenderPass), pRenderPass);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPass), sizeof(VkRenderPass), pRenderPass);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDependencies));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSubpasses));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPass));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDependencies));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSubpasses));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPass));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetGlobalExtensionProperties(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetGlobalExtensionProperties(
const char* pLayerName,
uint32_t* pCount,
VkExtensionProperties* pProperties)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkGetGlobalExtensionProperties* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- glv_platform_thread_once(&gInitOnce, InitTracer);
+ uint64_t vktraceStartTime = vktrace_get_time();
+ vktrace_platform_thread_once(&gInitOnce, InitTracer);
if (real_vkGetGlobalExtensionProperties == vkGetGlobalExtensionProperties) {
- glv_platform_get_next_lib_sym((void **) &real_vkGetGlobalExtensionProperties,"vkGetGlobalExtensionProperties");
+ vktrace_platform_get_next_lib_sym((void **) &real_vkGetGlobalExtensionProperties,"vkGetGlobalExtensionProperties");
}
- startTime = glv_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetGlobalExtensionProperties(pLayerName, pCount, pProperties);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkGetGlobalExtensionProperties, ((pLayerName != NULL) ? strlen(pLayerName) + 1 : 0) + sizeof(uint32_t) + (*pCount * sizeof(VkExtensionProperties)));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
if (isHooked == FALSE) {
}
pPacket = interpret_body_as_vkGetGlobalExtensionProperties(pHeader);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pLayerName), ((pLayerName != NULL) ? strlen(pLayerName) + 1 : 0), pLayerName);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkExtensionProperties), pProperties);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pLayerName), ((pLayerName != NULL) ? strlen(pLayerName) + 1 : 0), pLayerName);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkExtensionProperties), pProperties);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pLayerName));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pLayerName));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceExtensionProperties(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceExtensionProperties(
VkPhysicalDevice physicalDevice,
const char* pLayerName,
uint32_t* pCount,
VkExtensionProperties* pProperties)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkGetPhysicalDeviceExtensionProperties* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- startTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetPhysicalDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkGetPhysicalDeviceExtensionProperties, ((pLayerName != NULL) ? strlen(pLayerName) + 1 : 0) + sizeof(uint32_t) + (*pCount * sizeof(VkExtensionProperties)));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkGetPhysicalDeviceExtensionProperties(pHeader);
pPacket->physicalDevice = physicalDevice;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pLayerName), ((pLayerName != NULL) ? strlen(pLayerName) + 1 : 0), pLayerName);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkExtensionProperties), pProperties);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pLayerName), ((pLayerName != NULL) ? strlen(pLayerName) + 1 : 0), pLayerName);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkExtensionProperties), pProperties);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pLayerName));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pLayerName));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetGlobalLayerProperties(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetGlobalLayerProperties(
uint32_t* pCount,
VkLayerProperties* pProperties)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkGetGlobalLayerProperties* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- glv_platform_thread_once(&gInitOnce, InitTracer);
+ uint64_t vktraceStartTime = vktrace_get_time();
+ vktrace_platform_thread_once(&gInitOnce, InitTracer);
if (real_vkGetGlobalLayerProperties == vkGetGlobalLayerProperties) {
- glv_platform_get_next_lib_sym((void **) &real_vkGetGlobalLayerProperties,"vkGetGlobalLayerProperties");
+ vktrace_platform_get_next_lib_sym((void **) &real_vkGetGlobalLayerProperties,"vkGetGlobalLayerProperties");
}
- startTime = glv_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetGlobalLayerProperties(pCount, pProperties);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkGetGlobalLayerProperties, sizeof(uint32_t) + (*pCount * sizeof(VkLayerProperties)));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
if (isHooked == FALSE) {
}
pPacket = interpret_body_as_vkGetGlobalLayerProperties(pHeader);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkLayerProperties), pProperties);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkLayerProperties), pProperties);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceLayerProperties(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkLayerProperties* pProperties)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkGetPhysicalDeviceLayerProperties* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- startTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetPhysicalDeviceLayerProperties(physicalDevice, pCount, pProperties);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkGetPhysicalDeviceLayerProperties, sizeof(uint32_t) + (*pCount * sizeof(VkLayerProperties)));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkGetPhysicalDeviceLayerProperties(pHeader);
pPacket->physicalDevice = physicalDevice;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkLayerProperties), pProperties);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), *pCount * sizeof(VkLayerProperties), pProperties);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pProperties));
FINISH_TRACE_PACKET();
return result;
}
// TODO : This should be pretty easy to fit into codegen. Don't need to make the call prior to creating packet
// Just need to account for "count" number of queue properties
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceQueueFamilyProperties(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkQueueFamilyProperties* pQueueFamilyProperties)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkGetPhysicalDeviceQueueFamilyProperties* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- startTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t) + *pCount * sizeof(VkQueueFamilyProperties));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkGetPhysicalDeviceQueueFamilyProperties(pHeader);
pPacket->physicalDevice = physicalDevice;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pQueueFamilyProperties), *pCount * sizeof(VkQueueFamilyProperties), pQueueFamilyProperties);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pQueueFamilyProperties), *pCount * sizeof(VkQueueFamilyProperties), pQueueFamilyProperties);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pQueueFamilyProperties));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pQueueFamilyProperties));
FINISH_TRACE_PACKET();
return result;
}
/*
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetGlobalExtensionInfo(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetGlobalExtensionInfo(
VkExtensionInfoType infoType,
uint32_t extensionIndex,
size_t* pDataSize,
void* pData)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
size_t _dataSize;
packet_vkGetGlobalExtensionInfo* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- glv_platform_thread_once(&gInitOnce, InitTracer);
+ uint64_t vktraceStartTime = vktrace_get_time();
+ vktrace_platform_thread_once(&gInitOnce, InitTracer);
if (real_vkGetGlobalExtensionInfo == vkGetGlobalExtensionInfo)
{
- glv_platform_get_next_lib_sym((void **) &real_vkGetGlobalExtensionInfo,"vkGetGlobalExtensionInfo");
+ vktrace_platform_get_next_lib_sym((void **) &real_vkGetGlobalExtensionInfo,"vkGetGlobalExtensionInfo");
}
- startTime = glv_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetGlobalExtensionInfo(infoType, extensionIndex, pDataSize, pData);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkGetGlobalExtensionInfo, (((pDataSize != NULL) ? sizeof(size_t) : 0) + ((pDataSize != NULL && pData != NULL) ? *pDataSize : 0)));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
if (isHooked == FALSE) {
pPacket = interpret_body_as_vkGetGlobalExtensionInfo(pHeader);
pPacket->infoType = infoType;
pPacket->extensionIndex = extensionIndex;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
FINISH_TRACE_PACKET();
return result;
}
*/
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkEnumeratePhysicalDevices(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkEnumeratePhysicalDevices(
VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkEnumeratePhysicalDevices* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
//TODO make sure can handle being called twice with pPD == 0
SEND_ENTRYPOINT_ID(vkEnumeratePhysicalDevices);
- startTime = glv_get_time();
+ startTime = vktrace_get_time();
result = real_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkEnumeratePhysicalDevices, sizeof(uint32_t) + ((pPhysicalDevices && pPhysicalDeviceCount) ? *pPhysicalDeviceCount * sizeof(VkPhysicalDevice) : 0));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkEnumeratePhysicalDevices(pHeader);
pPacket->instance = instance;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPhysicalDeviceCount), sizeof(uint32_t), pPhysicalDeviceCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPhysicalDevices), *pPhysicalDeviceCount*sizeof(VkPhysicalDevice), pPhysicalDevices);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPhysicalDeviceCount), sizeof(uint32_t), pPhysicalDeviceCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPhysicalDevices), *pPhysicalDeviceCount*sizeof(VkPhysicalDevice), pPhysicalDevices);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPhysicalDeviceCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPhysicalDevices));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPhysicalDeviceCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPhysicalDevices));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetQueryPoolResults(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
uint32_t startQuery,
void* pData,
VkQueryResultFlags flags)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
size_t _dataSize;
packet_vkGetQueryPoolResults* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- startTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
_dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;
CREATE_TRACE_PACKET(vkGetQueryPoolResults, ((pDataSize != NULL) ? sizeof(size_t) : 0) + _dataSize);
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkGetQueryPoolResults(pHeader);
pPacket->startQuery = startQuery;
pPacket->queryCount = queryCount;
pPacket->flags = flags;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkAllocDescriptorSets(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkAllocDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorSetUsage setUsage,
const VkDescriptorSetLayout* pSetLayouts,
VkDescriptorSet* pDescriptorSets)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkAllocDescriptorSets* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
SEND_ENTRYPOINT_ID(vkAllocDescriptorSets);
- startTime = glv_get_time();
+ startTime = vktrace_get_time();
result = real_vkAllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
CREATE_TRACE_PACKET(vkAllocDescriptorSets, (count * sizeof(VkDescriptorSetLayout)) + (count * sizeof(VkDescriptorSet)));
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkAllocDescriptorSets(pHeader);
pPacket->descriptorPool = descriptorPool;
pPacket->setUsage = setUsage;
pPacket->count = count;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayouts), count * sizeof(VkDescriptorSetLayout), pSetLayouts);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), count * sizeof(VkDescriptorSet), pDescriptorSets);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayouts), count * sizeof(VkDescriptorSetLayout), pSetLayouts);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), count * sizeof(VkDescriptorSet), pDescriptorSets);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSetLayouts));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorSets));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSetLayouts));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorSets));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkUpdateDescriptorSets(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkUpdateDescriptorSets(
VkDevice device,
uint32_t writeCount,
const VkWriteDescriptorSet* pDescriptorWrites,
const VkCopyDescriptorSet* pDescriptorCopies);
// Manually written because it needs to use get_struct_chain_size and allocate some extra pointers (why?)
// Also since it needs to app the array of pointers and sub-buffers (see comments in function)
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkUpdateDescriptorSets(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkUpdateDescriptorSets(
VkDevice device,
uint32_t writeCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t copyCount,
const VkCopyDescriptorSet* pDescriptorCopies )
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkUpdateDescriptorSets* pPacket = NULL;
// begin custom code
CREATE_TRACE_PACKET(vkUpdateDescriptorSets, arrayByteCount);
// end custom code
result = real_vkUpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkUpdateDescriptorSets(pHeader);
pPacket->device = device;
pPacket->writeCount = writeCount;
// begin custom code
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorWrites), writeCount * sizeof(VkWriteDescriptorSet), pDescriptorWrites);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorWrites), writeCount * sizeof(VkWriteDescriptorSet), pDescriptorWrites);
for (i = 0; i < writeCount; i++)
{
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorWrites[i].pDescriptors), pDescriptorWrites[i].count * sizeof(VkDescriptorInfo), pDescriptorWrites[i].pDescriptors);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorWrites[i].pDescriptors));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorWrites[i].pDescriptors), pDescriptorWrites[i].count * sizeof(VkDescriptorInfo), pDescriptorWrites[i].pDescriptors);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorWrites[i].pDescriptors));
}
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorWrites));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorWrites));
pPacket->copyCount = copyCount;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorCopies), copyCount * sizeof(VkCopyDescriptorSet), pDescriptorCopies);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorCopies));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorCopies), copyCount * sizeof(VkCopyDescriptorSet), pDescriptorCopies);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorCopies));
// end custom code
pPacket->result = result;
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT void VKAPI __HOOKED_vkCmdWaitEvents(
+VKTRACER_EXPORT void VKAPI __HOOKED_vkCmdWaitEvents(
VkCmdBuffer cmdBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
uint32_t memBarrierCount,
const void* const* ppMemBarriers)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
packet_vkCmdWaitEvents* pPacket = NULL;
size_t customSize;
customSize = (eventCount * sizeof(VkEvent)) + memBarrierCount * sizeof(void*) + calculate_memory_barrier_size(memBarrierCount, ppMemBarriers);
CREATE_TRACE_PACKET(vkCmdWaitEvents, customSize);
real_vkCmdWaitEvents(cmdBuffer, eventCount, pEvents, srcStageMask, destStageMask, memBarrierCount, ppMemBarriers);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCmdWaitEvents(pHeader);
pPacket->cmdBuffer = cmdBuffer;
pPacket->eventCount = eventCount;
pPacket->srcStageMask = srcStageMask;
pPacket->destStageMask = destStageMask;
pPacket->memBarrierCount = memBarrierCount;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pEvents), eventCount * sizeof(VkEvent), pEvents);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pEvents));
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers), memBarrierCount * sizeof(void*), ppMemBarriers);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pEvents), eventCount * sizeof(VkEvent), pEvents);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pEvents));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers), memBarrierCount * sizeof(void*), ppMemBarriers);
uint32_t i, siz;
for (i = 0; i < memBarrierCount; i++) {
VkMemoryBarrier *pNext = (VkMemoryBarrier *) ppMemBarriers[i];
siz = 0;
break;
}
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers[i]), siz, ppMemBarriers[i]);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers[i]));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers[i]), siz, ppMemBarriers[i]);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers[i]));
}
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers));
FINISH_TRACE_PACKET();
}
-GLVTRACER_EXPORT void VKAPI __HOOKED_vkCmdPipelineBarrier(
+VKTRACER_EXPORT void VKAPI __HOOKED_vkCmdPipelineBarrier(
VkCmdBuffer cmdBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags destStageMask,
uint32_t memBarrierCount,
const void* const* ppMemBarriers)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
packet_vkCmdPipelineBarrier* pPacket = NULL;
size_t customSize;
customSize = (memBarrierCount * sizeof(void*)) + calculate_memory_barrier_size(memBarrierCount, ppMemBarriers);
CREATE_TRACE_PACKET(vkCmdPipelineBarrier, customSize);
real_vkCmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCmdPipelineBarrier(pHeader);
pPacket->cmdBuffer = cmdBuffer;
pPacket->srcStageMask = srcStageMask;
pPacket->destStageMask = destStageMask;
pPacket->byRegion = byRegion;
pPacket->memBarrierCount = memBarrierCount;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers), memBarrierCount * sizeof(void*), ppMemBarriers);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers), memBarrierCount * sizeof(void*), ppMemBarriers);
uint32_t i, siz;
for (i = 0; i < memBarrierCount; i++) {
VkMemoryBarrier *pNext = (VkMemoryBarrier *) ppMemBarriers[i];
siz = 0;
break;
}
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers[i]), siz, ppMemBarriers[i]);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers[i]));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppMemBarriers[i]), siz, ppMemBarriers[i]);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers[i]));
}
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->ppMemBarriers));
FINISH_TRACE_PACKET();
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateGraphicsPipelines(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateGraphicsPipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
VkPipeline* pPipelines)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateGraphicsPipelines* pPacket = NULL;
size_t total_size = 0;
}
CREATE_TRACE_PACKET(vkCreateGraphicsPipelines, total_size + count*sizeof(VkPipeline));
result = real_vkCreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateGraphicsPipelines(pHeader);
pPacket->device = device;
pPacket->pipelineCache = pipelineCache;
pPacket->count = count;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkGraphicsPipelineCreateInfo), pCreateInfos);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkGraphicsPipelineCreateInfo), pCreateInfos);
add_VkGraphicsPipelineCreateInfos_to_trace_packet(pHeader, (VkGraphicsPipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, count);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), count*sizeof(VkPipeline), pPipelines);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), count*sizeof(VkPipeline), pPipelines);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateComputePipelines(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t count,
const VkComputePipelineCreateInfo* pCreateInfos,
VkPipeline* pPipelines)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateComputePipelines* pPacket = NULL;
CREATE_TRACE_PACKET(vkCreateComputePipelines, count*sizeof(VkComputePipelineCreateInfo) + sizeof(VkPipeline));
result = real_vkCreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateComputePipelines(pHeader);
pPacket->device = device;
pPacket->pipelineCache = pipelineCache;
pPacket->count = count;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkComputePipelineCreateInfo), pCreateInfos);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkComputePipelineCreateInfo), pCreateInfos);
add_VkComputePipelineCreateInfos_to_trace_packet(pHeader, (VkComputePipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, count);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), count*sizeof(VkPipeline), pPipelines);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), count*sizeof(VkPipeline), pPipelines);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT void VKAPI __HOOKED_vkCmdBeginRenderPass(
+VKTRACER_EXPORT void VKAPI __HOOKED_vkCmdBeginRenderPass(
VkCmdBuffer cmdBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkRenderPassContents contents)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
packet_vkCmdBeginRenderPass* pPacket = NULL;
size_t clearValueSize = sizeof(VkClearValue) * pRenderPassBegin->clearValueCount;
CREATE_TRACE_PACKET(vkCmdBeginRenderPass, sizeof(VkRenderPassBeginInfo) + clearValueSize);
real_vkCmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCmdBeginRenderPass(pHeader);
pPacket->cmdBuffer = cmdBuffer;
pPacket->contents = contents;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPassBegin), sizeof(VkRenderPassBeginInfo), pRenderPassBegin);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPassBegin->pClearValues), clearValueSize, pRenderPassBegin->pClearValues);
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPassBegin->pClearValues));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPassBegin));
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPassBegin), sizeof(VkRenderPassBeginInfo), pRenderPassBegin);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPassBegin->pClearValues), clearValueSize, pRenderPassBegin->pClearValues);
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPassBegin->pClearValues));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPassBegin));
FINISH_TRACE_PACKET();
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkFreeDescriptorSets(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkFreeDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t count,
const VkDescriptorSet* pDescriptorSets)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkFreeDescriptorSets* pPacket = NULL;
CREATE_TRACE_PACKET(vkFreeDescriptorSets, count*sizeof(VkDescriptorSet));
result = real_vkFreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkFreeDescriptorSets(pHeader);
pPacket->device = device;
pPacket->descriptorPool = descriptorPool;
pPacket->count = count;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), count*sizeof(VkDescriptorSet), pDescriptorSets);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), count*sizeof(VkDescriptorSet), pDescriptorSets);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorSets));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorSets));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSurfacePropertiesWSI(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSurfacePropertiesWSI(
VkDevice device,
const VkSurfaceDescriptionWSI* pSurfaceDescription,
VkSurfacePropertiesWSI* pSurfaceProperties)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkGetSurfacePropertiesWSI* pPacket = NULL;
CREATE_TRACE_PACKET(vkGetSurfacePropertiesWSI, sizeof(VkSurfaceDescriptionWSI) + sizeof(VkSurfacePropertiesWSI));
result = real_vkGetSurfacePropertiesWSI(device, pSurfaceDescription, pSurfaceProperties);
pPacket = interpret_body_as_vkGetSurfacePropertiesWSI(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceProperties), sizeof(VkSurfacePropertiesWSI), pSurfaceProperties);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceProperties), sizeof(VkSurfacePropertiesWSI), pSurfaceProperties);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceProperties));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceProperties));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSurfaceFormatsWSI(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSurfaceFormatsWSI(
VkDevice device,
const VkSurfaceDescriptionWSI* pSurfaceDescription,
uint32_t* pCount,
VkSurfaceFormatWSI* pSurfaceFormats)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
size_t _dataSize;
packet_vkGetSurfaceFormatsWSI* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- startTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetSurfaceFormatsWSI(device, pSurfaceDescription, pCount, pSurfaceFormats);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
_dataSize = (pCount == NULL || pSurfaceFormats == NULL) ? 0 : (*pCount *sizeof(VkSurfaceFormatWSI));
CREATE_TRACE_PACKET(vkGetSurfaceFormatsWSI, sizeof(VkSurfaceDescriptionWSI) + sizeof(uint32_t) + _dataSize);
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkGetSurfaceFormatsWSI(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceFormats), _dataSize, pSurfaceFormats);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceFormats), _dataSize, pSurfaceFormats);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceFormats));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceFormats));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSurfacePresentModesWSI(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSurfacePresentModesWSI(
VkDevice device,
const VkSurfaceDescriptionWSI* pSurfaceDescription,
uint32_t* pCount,
VkPresentModeWSI* pPresentModes)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
size_t _dataSize;
packet_vkGetSurfacePresentModesWSI* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- startTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetSurfacePresentModesWSI(device, pSurfaceDescription, pCount, pPresentModes);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
_dataSize = (pCount == NULL || pPresentModes == NULL) ? 0 : (*pCount *sizeof(VkPresentModeWSI));
CREATE_TRACE_PACKET(vkGetSurfacePresentModesWSI, sizeof(VkSurfaceDescriptionWSI) + sizeof(uint32_t) + _dataSize);
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkGetSurfacePresentModesWSI(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentModes), _dataSize, pPresentModes);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentModes), _dataSize, pPresentModes);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentModes));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentModes));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateSwapChainWSI(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateSwapChainWSI(
VkDevice device,
const VkSwapChainCreateInfoWSI* pCreateInfo,
VkSwapChainWSI* pSwapChain)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateSwapChainWSI* pPacket = NULL;
CREATE_TRACE_PACKET(vkCreateSwapChainWSI, vk_wsi_device_swapchain_size_vkswapchaincreateinfowsi(pCreateInfo) + sizeof(VkSwapChainWSI));
result = real_vkCreateSwapChainWSI(device, pCreateInfo, pSwapChain);
pPacket = interpret_body_as_vkCreateSwapChainWSI(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkSwapChainCreateInfoWSI), pCreateInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pCreateInfo->pSurfaceDescription);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSwapChain), sizeof(VkSwapChainWSI), pSwapChain);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pQueueFamilyIndices), pCreateInfo->queueFamilyCount * sizeof(uint32_t), pCreateInfo->pQueueFamilyIndices);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkSwapChainCreateInfoWSI), pCreateInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pCreateInfo->pSurfaceDescription);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSwapChain), sizeof(VkSwapChainWSI), pSwapChain);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pQueueFamilyIndices), pCreateInfo->queueFamilyCount * sizeof(uint32_t), pCreateInfo->pQueueFamilyIndices);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pQueueFamilyIndices));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSwapChain));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pQueueFamilyIndices));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSwapChain));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSwapChainImagesWSI(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetSwapChainImagesWSI(
VkDevice device,
VkSwapChainWSI swapChain,
uint32_t* pCount,
VkImage* pSwapChainImages)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
size_t _dataSize;
packet_vkGetSwapChainImagesWSI* pPacket = NULL;
uint64_t startTime;
uint64_t endTime;
- uint64_t glvStartTime = glv_get_time();
- startTime = glv_get_time();
+ uint64_t vktraceStartTime = vktrace_get_time();
+ startTime = vktrace_get_time();
result = real_vkGetSwapChainImagesWSI(device, swapChain, pCount, pSwapChainImages);
- endTime = glv_get_time();
+ endTime = vktrace_get_time();
_dataSize = (pCount == NULL || pSwapChainImages == NULL) ? 0 : (*pCount *sizeof(VkImage));
CREATE_TRACE_PACKET(vkGetSwapChainImagesWSI, sizeof(uint32_t) + _dataSize);
- pHeader->glave_begin_time = glvStartTime;
+ pHeader->vktrace_begin_time = vktraceStartTime;
pHeader->entrypoint_begin_time = startTime;
pHeader->entrypoint_end_time = endTime;
pPacket = interpret_body_as_vkGetSwapChainImagesWSI(pHeader);
pPacket->device = device;
pPacket->swapChain = swapChain;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSwapChainImages), _dataSize, pSwapChainImages);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(uint32_t), pCount);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSwapChainImages), _dataSize, pSwapChainImages);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSwapChainImages));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSwapChainImages));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkQueuePresentWSI(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkQueuePresentWSI(
VkQueue queue,
VkPresentInfoWSI* pPresentInfo)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkQueuePresentWSI* pPacket = NULL;
size_t swapChainSize = pPresentInfo->swapChainCount*sizeof(VkSwapChainWSI);
size_t indexSize = pPresentInfo->swapChainCount*sizeof(uint32_t);
CREATE_TRACE_PACKET(vkQueuePresentWSI, sizeof(VkPresentInfoWSI)+swapChainSize+indexSize);
result = real_vkQueuePresentWSI(queue, pPresentInfo);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkQueuePresentWSI(pHeader);
pPacket->queue = queue;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentInfo), sizeof(VkPresentInfoWSI), pPresentInfo);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentInfo->swapChains), swapChainSize, pPresentInfo->swapChains);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentInfo->imageIndices), indexSize, pPresentInfo->imageIndices);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentInfo), sizeof(VkPresentInfoWSI), pPresentInfo);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentInfo->swapChains), swapChainSize, pPresentInfo->swapChains);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentInfo->imageIndices), indexSize, pPresentInfo->imageIndices);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentInfo->imageIndices));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentInfo->swapChains));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentInfo));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentInfo->imageIndices));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentInfo->swapChains));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentInfo));
FINISH_TRACE_PACKET();
return result;
}
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDynamicStencilState(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDynamicStencilState(
VkDevice device,
const VkDynamicStencilStateCreateInfo* pCreateInfoFront,
const VkDynamicStencilStateCreateInfo* pCreateInfoBack,
VkDynamicStencilState* pState)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkCreateDynamicStencilState* pPacket = NULL;
CREATE_TRACE_PACKET(vkCreateDynamicStencilState, createInfoMultiplier * sizeof(VkDynamicStencilStateCreateInfo) + sizeof(VkDynamicStencilState));
result = real_vkCreateDynamicStencilState(device, pCreateInfoFront, pCreateInfoBack, pState);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkCreateDynamicStencilState(pHeader);
pPacket->device = device;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfoFront), sizeof(VkDynamicStencilStateCreateInfo), pCreateInfoFront);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfoBack), sizeof(VkDynamicStencilStateCreateInfo), pLocalCreateInfoBack);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(VkDynamicStencilState), pState);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfoFront), sizeof(VkDynamicStencilStateCreateInfo), pCreateInfoFront);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfoBack), sizeof(VkDynamicStencilStateCreateInfo), pLocalCreateInfoBack);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(VkDynamicStencilState), pState);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfoFront));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfoBack));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfoFront));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfoBack));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
FINISH_TRACE_PACKET();
return result;
}
/* TODO: Probably want to make this manual to get the result of the boolean and then check it on replay
-GLVTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceSurfaceSupportWSI(
+VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkGetPhysicalDeviceSurfaceSupportWSI(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
const VkSurfaceDescriptionWSI* pSurfaceDescription,
VkBool32* pSupported)
{
- glv_trace_packet_header* pHeader;
+ vktrace_trace_packet_header* pHeader;
VkResult result;
packet_vkGetPhysicalDeviceSurfaceSupportWSI* pPacket = NULL;
CREATE_TRACE_PACKET(vkGetPhysicalDeviceSurfaceSupportWSI, sizeof(VkSurfaceDescriptionWSI) + sizeof(VkBool32));
result = real_vkGetPhysicalDeviceSurfaceSupportWSI(physicalDevice, queueFamilyIndex, pSurfaceDescription, pSupported);
- glv_set_packet_entrypoint_end_time(pHeader);
+ vktrace_set_packet_entrypoint_end_time(pHeader);
pPacket = interpret_body_as_vkGetPhysicalDeviceSurfaceSupportWSI(pHeader);
pPacket->physicalDevice = physicalDevice;
pPacket->queueFamilyIndex = queueFamilyIndex;
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
- glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSupported), sizeof(VkBool32), pSupported);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pSurfaceDescription);
+ vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSupported), sizeof(VkBool32), pSupported);
pPacket->result = result;
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
- glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSupported));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSurfaceDescription));
+ vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pSupported));
FINISH_TRACE_PACKET();
return result;
}
#include "vktrace_trace_packet_identifiers.h"
#include "vkreplay.h"
-namespace glv_replay {
+namespace vktrace_replay {
-glv_trace_packet_replay_library* ReplayFactory::Create(uint8_t tracerId)
+vktrace_trace_packet_replay_library* ReplayFactory::Create(uint8_t tracerId)
{
- glv_trace_packet_replay_library* pReplayer = NULL;
+ vktrace_trace_packet_replay_library* pReplayer = NULL;
void* pLibrary = NULL;
- const GLV_TRACER_REPLAYER_INFO* pReplayerInfo = &(gs_tracerReplayerInfo[tracerId]);
+ const VKTRACE_TRACER_REPLAYER_INFO* pReplayerInfo = &(gs_tracerReplayerInfo[tracerId]);
if (pReplayerInfo->tracerId != tracerId)
{
- glv_LogError("Replayer info for TracerId (%d) failed consistency check.", tracerId);
- assert(!"TracerId in GLV_TRACER_REPLAYER_INFO does not match the requested tracerId. The array needs to be corrected.");
+ vktrace_LogError("Replayer info for TracerId (%d) failed consistency check.", tracerId);
+ assert(!"TracerId in VKTRACE_TRACER_REPLAYER_INFO does not match the requested tracerId. The array needs to be corrected.");
}
// Vulkan library is built into replayer executable
- if (tracerId == GLV_TID_VULKAN) {
- pReplayer = GLV_NEW(glv_trace_packet_replay_library);
+ if (tracerId == VKTRACE_TID_VULKAN) {
+ pReplayer = VKTRACE_NEW(vktrace_trace_packet_replay_library);
if (pReplayer == NULL)
{
- glv_LogError("Failed to allocate replayer library.");
+ vktrace_LogError("Failed to allocate replayer library.");
}
else
{
} else if (pReplayerInfo->needsReplayer == TRUE)
{
- pLibrary = glv_platform_open_library(pReplayerInfo->replayerLibraryName);
+ pLibrary = vktrace_platform_open_library(pReplayerInfo->replayerLibraryName);
if (pLibrary == NULL)
{
- glv_LogError("Failed to load replayer '%s.", pReplayerInfo->replayerLibraryName);
+ vktrace_LogError("Failed to load replayer '%s.", pReplayerInfo->replayerLibraryName);
#if defined(PLATFORM_LINUX)
char* error = dlerror();
- glv_LogError(error);
+ vktrace_LogError(error);
#endif
}
}
else
{
- glv_LogError("A replayer was requested for TracerId (%d), but it does not require a replayer.", tracerId);
+ vktrace_LogError("A replayer was requested for TracerId (%d), but it does not require a replayer.", tracerId);
assert(!"Invalid TracerId supplied to ReplayFactory");
}
if (pLibrary != NULL)
{
- pReplayer = GLV_NEW(glv_trace_packet_replay_library);
+ pReplayer = VKTRACE_NEW(vktrace_trace_packet_replay_library);
if (pReplayer == NULL)
{
- glv_LogError("Failed to allocate replayer library.");
- glv_platform_close_library(pLibrary);
+ vktrace_LogError("Failed to allocate replayer library.");
+ vktrace_platform_close_library(pLibrary);
}
else
{
pReplayer->pLibrary = pLibrary;
- pReplayer->SetLogCallback = (funcptr_glvreplayer_setlogcallback)glv_platform_get_library_entrypoint(pLibrary, "SetLogCallback");
- pReplayer->SetLogLevel = (funcptr_glvreplayer_setloglevel)glv_platform_get_library_entrypoint(pLibrary, "SetLogLevel");
+ pReplayer->SetLogCallback = (funcptr_vkreplayer_setlogcallback)vktrace_platform_get_library_entrypoint(pLibrary, "SetLogCallback");
+ pReplayer->SetLogLevel = (funcptr_vkreplayer_setloglevel)vktrace_platform_get_library_entrypoint(pLibrary, "SetLogLevel");
- pReplayer->RegisterDbgMsgCallback = (funcptr_glvreplayer_registerdbgmsgcallback)glv_platform_get_library_entrypoint(pLibrary, "RegisterDbgMsgCallback");
- pReplayer->GetSettings = (funcptr_glvreplayer_getSettings)glv_platform_get_library_entrypoint(pLibrary, "GetSettings");
- pReplayer->UpdateFromSettings = (funcptr_glvreplayer_updatefromsettings)glv_platform_get_library_entrypoint(pLibrary, "UpdateFromSettings");
- pReplayer->Initialize = (funcptr_glvreplayer_initialize)glv_platform_get_library_entrypoint(pLibrary, "Initialize");
- pReplayer->Deinitialize = (funcptr_glvreplayer_deinitialize)glv_platform_get_library_entrypoint(pLibrary, "Deinitialize");
- pReplayer->Interpret = (funcptr_glvreplayer_interpret)glv_platform_get_library_entrypoint(pLibrary, "Interpret");
- pReplayer->Replay = (funcptr_glvreplayer_replay)glv_platform_get_library_entrypoint(pLibrary, "Replay");
- pReplayer->Dump = (funcptr_glvreplayer_dump)glv_platform_get_library_entrypoint(pLibrary, "Dump");
+ pReplayer->RegisterDbgMsgCallback = (funcptr_vkreplayer_registerdbgmsgcallback)vktrace_platform_get_library_entrypoint(pLibrary, "RegisterDbgMsgCallback");
+ pReplayer->GetSettings = (funcptr_vkreplayer_getSettings)vktrace_platform_get_library_entrypoint(pLibrary, "GetSettings");
+ pReplayer->UpdateFromSettings = (funcptr_vkreplayer_updatefromsettings)vktrace_platform_get_library_entrypoint(pLibrary, "UpdateFromSettings");
+ pReplayer->Initialize = (funcptr_vkreplayer_initialize)vktrace_platform_get_library_entrypoint(pLibrary, "Initialize");
+ pReplayer->Deinitialize = (funcptr_vkreplayer_deinitialize)vktrace_platform_get_library_entrypoint(pLibrary, "Deinitialize");
+ pReplayer->Interpret = (funcptr_vkreplayer_interpret)vktrace_platform_get_library_entrypoint(pLibrary, "Interpret");
+ pReplayer->Replay = (funcptr_vkreplayer_replay)vktrace_platform_get_library_entrypoint(pLibrary, "Replay");
+ pReplayer->Dump = (funcptr_vkreplayer_dump)vktrace_platform_get_library_entrypoint(pLibrary, "Dump");
if (pReplayer->SetLogCallback == NULL ||
pReplayer->SetLogLevel == NULL ||
pReplayer->Replay == NULL ||
pReplayer->Dump == NULL)
{
- GLV_DELETE(pReplayer);
- glv_platform_close_library(pLibrary);
+ VKTRACE_DELETE(pReplayer);
+ vktrace_platform_close_library(pLibrary);
pReplayer = NULL;
}
}
return pReplayer;
}
-void ReplayFactory::Destroy(glv_trace_packet_replay_library** ppReplayer)
+void ReplayFactory::Destroy(vktrace_trace_packet_replay_library** ppReplayer)
{
assert (ppReplayer != NULL);
assert (*ppReplayer != NULL);
if ((*ppReplayer)->pLibrary)
- glv_platform_close_library((*ppReplayer)->pLibrary);
- GLV_DELETE(*ppReplayer);
+ vktrace_platform_close_library((*ppReplayer)->pLibrary);
+ VKTRACE_DELETE(*ppReplayer);
*ppReplayer = NULL;
}
-} // namespace glv_replay
+} // namespace vktrace_replay
#include "vkreplay_window.h"
#include "vkreplay_main.h"
-namespace glv_replay {
+namespace vktrace_replay {
-enum GLV_REPLAY_RESULT
+enum VKTRACE_REPLAY_RESULT
{
- GLV_REPLAY_SUCCESS = 0,
- GLV_REPLAY_ERROR, // internal error unrelated to the specific packet
- GLV_REPLAY_INVALID_ID, // packet_id invalid
- GLV_REPLAY_BAD_RETURN, // replay return value != trace return value
- GLV_REPLAY_CALL_ERROR, // replaying call caused an error
- GLV_REPLAY_INVALID_PARAMS, // trace file parameters are invalid
- GLV_REPLAY_VALIDATION_ERROR // callback Msg error from validation layer
+ VKTRACE_REPLAY_SUCCESS = 0,
+ VKTRACE_REPLAY_ERROR, // internal error unrelated to the specific packet
+ VKTRACE_REPLAY_INVALID_ID, // packet_id invalid
+ VKTRACE_REPLAY_BAD_RETURN, // replay return value != trace return value
+ VKTRACE_REPLAY_CALL_ERROR, // replaying call caused an error
+ VKTRACE_REPLAY_INVALID_PARAMS, // trace file parameters are invalid
+ VKTRACE_REPLAY_VALIDATION_ERROR // callback Msg error from validation layer
};
-enum GLV_DBG_MSG_TYPE
+enum VKTRACE_DBG_MSG_TYPE
{
- GLV_DBG_MSG_INFO = 0,
- GLV_DBG_MSG_WARNING,
- GLV_DBG_MSG_ERROR
+ VKTRACE_DBG_MSG_INFO = 0,
+ VKTRACE_DBG_MSG_WARNING,
+ VKTRACE_DBG_MSG_ERROR
};
// callback signature
-typedef void (*GLV_DBG_MSG_CALLBACK_FUNCTION)(GLV_DBG_MSG_TYPE msgType, const char* pMsg);
+typedef void (*VKTRACE_DBG_MSG_CALLBACK_FUNCTION)(VKTRACE_DBG_MSG_TYPE msgType, const char* pMsg);
// entrypoints that must be exposed by each replayer library
extern "C"
{
// entrypoints
-typedef void (GLVTRACER_CDECL *funcptr_glvreplayer_setloglevel)(GlvLogLevel level);
-typedef void (GLVTRACER_CDECL *funcptr_glvreplayer_setlogcallback)(GLV_REPORT_CALLBACK_FUNCTION pCallback);
+typedef void (VKTRACER_CDECL *funcptr_vkreplayer_setloglevel)(VktraceLogLevel level);
+typedef void (VKTRACER_CDECL *funcptr_vkreplayer_setlogcallback)(VKTRACE_REPORT_CALLBACK_FUNCTION pCallback);
-typedef void (GLVTRACER_CDECL *funcptr_glvreplayer_registerdbgmsgcallback)(GLV_DBG_MSG_CALLBACK_FUNCTION pCallback);
-typedef glv_SettingGroup* (GLVTRACER_CDECL *funcptr_glvreplayer_getSettings)();
-typedef void (GLVTRACER_CDECL *funcptr_glvreplayer_updatefromsettings)(glv_SettingGroup* pSettingGroups, unsigned int numSettingGroups);
-typedef int (GLVTRACER_CDECL *funcptr_glvreplayer_initialize)(glv_replay::Display* pDisplay, glvreplay_settings* pReplaySettings);
-typedef void (GLVTRACER_CDECL *funcptr_glvreplayer_deinitialize)();
-typedef glv_trace_packet_header* (GLVTRACER_CDECL *funcptr_glvreplayer_interpret)(glv_trace_packet_header* pPacket);
-typedef glv_replay::GLV_REPLAY_RESULT (GLVTRACER_CDECL *funcptr_glvreplayer_replay)(glv_trace_packet_header* pPacket);
-typedef int (GLVTRACER_CDECL *funcptr_glvreplayer_dump)();
+typedef void (VKTRACER_CDECL *funcptr_vkreplayer_registerdbgmsgcallback)(VKTRACE_DBG_MSG_CALLBACK_FUNCTION pCallback);
+typedef vktrace_SettingGroup* (VKTRACER_CDECL *funcptr_vkreplayer_getSettings)();
+typedef void (VKTRACER_CDECL *funcptr_vkreplayer_updatefromsettings)(vktrace_SettingGroup* pSettingGroups, unsigned int numSettingGroups);
+typedef int (VKTRACER_CDECL *funcptr_vkreplayer_initialize)(vktrace_replay::Display* pDisplay, vkreplayer_settings* pReplaySettings);
+typedef void (VKTRACER_CDECL *funcptr_vkreplayer_deinitialize)();
+typedef vktrace_trace_packet_header* (VKTRACER_CDECL *funcptr_vkreplayer_interpret)(vktrace_trace_packet_header* pPacket);
+typedef vktrace_replay::VKTRACE_REPLAY_RESULT (VKTRACER_CDECL *funcptr_vkreplayer_replay)(vktrace_trace_packet_header* pPacket);
+typedef int (VKTRACER_CDECL *funcptr_vkreplayer_dump)();
}
-struct glv_trace_packet_replay_library
+struct vktrace_trace_packet_replay_library
{
void* pLibrary;
- funcptr_glvreplayer_setloglevel SetLogLevel;
- funcptr_glvreplayer_setlogcallback SetLogCallback;
+ funcptr_vkreplayer_setloglevel SetLogLevel;
+ funcptr_vkreplayer_setlogcallback SetLogCallback;
- funcptr_glvreplayer_registerdbgmsgcallback RegisterDbgMsgCallback;
- funcptr_glvreplayer_getSettings GetSettings;
- funcptr_glvreplayer_updatefromsettings UpdateFromSettings;
- funcptr_glvreplayer_initialize Initialize;
- funcptr_glvreplayer_deinitialize Deinitialize;
- funcptr_glvreplayer_interpret Interpret;
- funcptr_glvreplayer_replay Replay;
- funcptr_glvreplayer_dump Dump;
+ funcptr_vkreplayer_registerdbgmsgcallback RegisterDbgMsgCallback;
+ funcptr_vkreplayer_getSettings GetSettings;
+ funcptr_vkreplayer_updatefromsettings UpdateFromSettings;
+ funcptr_vkreplayer_initialize Initialize;
+ funcptr_vkreplayer_deinitialize Deinitialize;
+ funcptr_vkreplayer_interpret Interpret;
+ funcptr_vkreplayer_replay Replay;
+ funcptr_vkreplayer_dump Dump;
};
class ReplayFactory {
public:
- glv_trace_packet_replay_library *Create(uint8_t tracerId);
- void Destroy(glv_trace_packet_replay_library** ppReplayer);
+ vktrace_trace_packet_replay_library *Create(uint8_t tracerId);
+ void Destroy(vktrace_trace_packet_replay_library** ppReplayer);
};
-} // namespace glv_replay
+} // namespace vktrace_replay
#include "vkreplay_seq.h"
#include "vkreplay_window.h"
-glvreplay_settings replaySettings = { NULL, 1, NULL };
+vkreplayer_settings replaySettings = { NULL, 1, NULL };
-glv_SettingInfo g_settings_info[] =
+vktrace_SettingInfo g_settings_info[] =
{
- { "t", "TraceFile", GLV_SETTING_STRING, &replaySettings.pTraceFilePath, &replaySettings.pTraceFilePath, TRUE, "The trace file to replay."},
- { "l", "NumLoops", GLV_SETTING_UINT, &replaySettings.numLoops, &replaySettings.numLoops, TRUE, "The number of times to replay the trace file."},
- { "s", "Screenshot", GLV_SETTING_STRING, &replaySettings.screenshotList, &replaySettings.screenshotList, TRUE, "Comma separated list of frames to take a take snapshots of"},
+ { "t", "TraceFile", VKTRACE_SETTING_STRING, &replaySettings.pTraceFilePath, &replaySettings.pTraceFilePath, TRUE, "The trace file to replay."},
+ { "l", "NumLoops", VKTRACE_SETTING_UINT, &replaySettings.numLoops, &replaySettings.numLoops, TRUE, "The number of times to replay the trace file."},
+ { "s", "Screenshot", VKTRACE_SETTING_STRING, &replaySettings.screenshotList, &replaySettings.screenshotList, TRUE, "Comma separated list of frames to take a take snapshots of"},
};
-glv_SettingGroup g_replaySettingGroup =
+vktrace_SettingGroup g_replaySettingGroup =
{
- "glvreplay",
+ "vkreplay",
sizeof(g_settings_info) / sizeof(g_settings_info[0]),
&g_settings_info[0]
};
-namespace glv_replay {
-int main_loop(Sequencer &seq, glv_trace_packet_replay_library *replayerArray[], unsigned int numLoops)
+namespace vktrace_replay {
+int main_loop(Sequencer &seq, vktrace_trace_packet_replay_library *replayerArray[], unsigned int numLoops)
{
int err = 0;
- glv_trace_packet_header *packet;
+ vktrace_trace_packet_header *packet;
unsigned int res;
- glv_trace_packet_replay_library *replayer;
- glv_trace_packet_message* msgPacket;
+ vktrace_trace_packet_replay_library *replayer;
+ vktrace_trace_packet_message* msgPacket;
struct seqBookmark startingPacket;
// record the location of starting trace packet
while ((packet = seq.get_next_packet()) != NULL)
{
switch (packet->packet_id) {
- case GLV_TPI_MESSAGE:
- msgPacket = glv_interpret_body_as_trace_packet_message(packet);
- glv_LogAlways("Packet %lu: Traced Message (%s): %s", packet->global_packet_index, glv_LogLevelToShortString(msgPacket->type), msgPacket->message);
+ case VKTRACE_TPI_MESSAGE:
+ msgPacket = vktrace_interpret_body_as_trace_packet_message(packet);
+ vktrace_LogAlways("Packet %lu: Traced Message (%s): %s", packet->global_packet_index, vktrace_LogLevelToShortString(msgPacket->type), msgPacket->message);
break;
- case GLV_TPI_MARKER_CHECKPOINT:
+ case VKTRACE_TPI_MARKER_CHECKPOINT:
break;
- case GLV_TPI_MARKER_API_BOUNDARY:
+ case VKTRACE_TPI_MARKER_API_BOUNDARY:
break;
- case GLV_TPI_MARKER_API_GROUP_BEGIN:
+ case VKTRACE_TPI_MARKER_API_GROUP_BEGIN:
break;
- case GLV_TPI_MARKER_API_GROUP_END:
+ case VKTRACE_TPI_MARKER_API_GROUP_END:
break;
- case GLV_TPI_MARKER_TERMINATE_PROCESS:
+ case VKTRACE_TPI_MARKER_TERMINATE_PROCESS:
break;
//TODO processing code for all the above cases
default:
{
- if (packet->tracer_id >= GLV_MAX_TRACER_ID_ARRAY_SIZE || packet->tracer_id == GLV_TID_RESERVED) {
- glv_LogError("Tracer_id from packet num packet %d invalid.", packet->packet_id);
+ if (packet->tracer_id >= VKTRACE_MAX_TRACER_ID_ARRAY_SIZE || packet->tracer_id == VKTRACE_TID_RESERVED) {
+ vktrace_LogError("Tracer_id from packet num packet %d invalid.", packet->packet_id);
continue;
}
replayer = replayerArray[packet->tracer_id];
if (replayer == NULL) {
- glv_LogWarning("Tracer_id %d has no valid replayer.", packet->tracer_id);
+ vktrace_LogWarning("Tracer_id %d has no valid replayer.", packet->tracer_id);
continue;
}
- if (packet->packet_id >= GLV_TPI_BEGIN_API_HERE)
+ if (packet->packet_id >= VKTRACE_TPI_BEGIN_API_HERE)
{
// replay the API packet
res = replayer->Replay(replayer->Interpret(packet));
- if (res != GLV_REPLAY_SUCCESS)
+ if (res != VKTRACE_REPLAY_SUCCESS)
{
- glv_LogError("Failed to replay packet_id %d.",packet->packet_id);
+ vktrace_LogError("Failed to replay packet_id %d.",packet->packet_id);
return -1;
}
} else {
- glv_LogError("Bad packet type id=%d, index=%d.", packet->packet_id, packet->global_packet_index);
+ vktrace_LogError("Bad packet type id=%d, index=%d.", packet->packet_id, packet->global_packet_index);
return -1;
}
}
}
return err;
}
-} // namespace glv_replay
+} // namespace vktrace_replay
-using namespace glv_replay;
+using namespace vktrace_replay;
-void loggingCallback(GlvLogLevel level, const char* pMessage)
+void loggingCallback(VktraceLogLevel level, const char* pMessage)
{
switch(level)
{
- case GLV_LOG_ALWAYS: printf("%s\n", pMessage); break;
- case GLV_LOG_DEBUG: printf("Debug: %s\n", pMessage); break;
- case GLV_LOG_ERROR: printf("Error: %s\n", pMessage); break;
- case GLV_LOG_WARNING: printf("Warning: %s\n", pMessage); break;
- case GLV_LOG_VERBOSE: printf("Verbose: %s\n", pMessage); break;
+ case VKTRACE_LOG_ALWAYS: printf("%s\n", pMessage); break;
+ case VKTRACE_LOG_DEBUG: printf("Debug: %s\n", pMessage); break;
+ case VKTRACE_LOG_ERROR: printf("Error: %s\n", pMessage); break;
+ case VKTRACE_LOG_WARNING: printf("Warning: %s\n", pMessage); break;
+ case VKTRACE_LOG_VERBOSE: printf("Verbose: %s\n", pMessage); break;
default:
printf("%s\n", pMessage); break;
}
int main(int argc, char **argv)
{
int err = 0;
- glv_SettingGroup* pAllSettings = NULL;
+ vktrace_SettingGroup* pAllSettings = NULL;
unsigned int numAllSettings = 0;
- glv_LogSetCallback(loggingCallback);
- glv_LogSetLevel(GLV_LOG_LEVEL_MAXIMUM);
+ vktrace_LogSetCallback(loggingCallback);
+ vktrace_LogSetLevel(VKTRACE_LOG_LEVEL_MAXIMUM);
// apply settings from cmd-line args
- if (glv_SettingGroup_init_from_cmdline(&g_replaySettingGroup, argc, argv, &replaySettings.pTraceFilePath) != 0)
+ if (vktrace_SettingGroup_init_from_cmdline(&g_replaySettingGroup, argc, argv, &replaySettings.pTraceFilePath) != 0)
{
// invalid options specified
if (pAllSettings != NULL)
{
- glv_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
}
return err;
}
// merge settings so that new settings will get written into the settings file
- glv_SettingGroup_merge(&g_replaySettingGroup, &pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_merge(&g_replaySettingGroup, &pAllSettings, &numAllSettings);
// Set up environment for screenshot
if (replaySettings.screenshotList != NULL)
{
// Set env var that communicates list to ScreenShot layer
- glv_set_global_var("_VK_SCREENSHOT", replaySettings.screenshotList);
+ vktrace_set_global_var("_VK_SCREENSHOT", replaySettings.screenshotList);
}
else
{
- glv_set_global_var("_VK_SCREENSHOT","");
+ vktrace_set_global_var("_VK_SCREENSHOT","");
}
// open trace file and read in header
char* pTraceFile = replaySettings.pTraceFilePath;
- glv_trace_file_header fileHeader;
+ vktrace_trace_file_header fileHeader;
FILE *tracefp;
if (pTraceFile != NULL && strlen(pTraceFile) > 0)
tracefp = fopen(pTraceFile, "rb");
if (tracefp == NULL)
{
- glv_LogError("Cannot open trace file: '%s'.", pTraceFile);
+ vktrace_LogError("Cannot open trace file: '%s'.", pTraceFile);
return 1;
}
}
else
{
- glv_LogError("No trace file specified.");
- glv_SettingGroup_print(&g_replaySettingGroup);
+ vktrace_LogError("No trace file specified.");
+ vktrace_SettingGroup_print(&g_replaySettingGroup);
if (pAllSettings != NULL)
{
- glv_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
}
return 1;
}
- FileLike* traceFile = glv_FileLike_create_file(tracefp);
- if (glv_FileLike_ReadRaw(traceFile, &fileHeader, sizeof(fileHeader)) == false)
+ FileLike* traceFile = vktrace_FileLike_create_file(tracefp);
+ if (vktrace_FileLike_ReadRaw(traceFile, &fileHeader, sizeof(fileHeader)) == false)
{
- glv_LogError("Unable to read header from file.");
+ vktrace_LogError("Unable to read header from file.");
if (pAllSettings != NULL)
{
- glv_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
}
- GLV_DELETE(traceFile);
+ VKTRACE_DELETE(traceFile);
return 1;
}
// Make sure trace file version is supported
- if (fileHeader.trace_file_version < GLV_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE)
+ if (fileHeader.trace_file_version < VKTRACE_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE)
{
- glv_LogError("Trace file version %u is older than minimum compatible version (%u).\nYou'll need to make a new trace file, or use an older replayer.", fileHeader.trace_file_version, GLV_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE);
+ vktrace_LogError("Trace file version %u is older than minimum compatible version (%u).\nYou'll need to make a new trace file, or use an older replayer.", fileHeader.trace_file_version, VKTRACE_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE);
}
// load any API specific driver libraries and init replayer objects
- uint8_t tidApi = GLV_TID_RESERVED;
- glv_trace_packet_replay_library* replayer[GLV_MAX_TRACER_ID_ARRAY_SIZE];
+ uint8_t tidApi = VKTRACE_TID_RESERVED;
+ vktrace_trace_packet_replay_library* replayer[VKTRACE_MAX_TRACER_ID_ARRAY_SIZE];
ReplayFactory makeReplayer;
Display disp(1024, 768, 0, false);
- for (int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ for (int i = 0; i < VKTRACE_MAX_TRACER_ID_ARRAY_SIZE; i++)
{
replayer[i] = NULL;
}
uint8_t tracerId = fileHeader.tracer_id_array[i].id;
tidApi = tracerId;
- const GLV_TRACER_REPLAYER_INFO* pReplayerInfo = &(gs_tracerReplayerInfo[tracerId]);
+ const VKTRACE_TRACER_REPLAYER_INFO* pReplayerInfo = &(gs_tracerReplayerInfo[tracerId]);
if (pReplayerInfo->tracerId != tracerId)
{
- glv_LogError("Replayer info for TracerId (%d) failed consistency check.", tracerId);
- assert(!"TracerId in GLV_TRACER_REPLAYER_INFO does not match the requested tracerId. The array needs to be corrected.");
+ vktrace_LogError("Replayer info for TracerId (%d) failed consistency check.", tracerId);
+ assert(!"TracerId in VKTRACE_TRACER_REPLAYER_INFO does not match the requested tracerId. The array needs to be corrected.");
}
else if (pReplayerInfo->needsReplayer == TRUE)
{
// replayer failed to be created
if (pAllSettings != NULL)
{
- glv_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
}
return err;
}
// merge the replayer's settings into the list of all settings so that we can output a comprehensive settings file later on.
- glv_SettingGroup_merge(replayer[tracerId]->GetSettings(), &pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_merge(replayer[tracerId]->GetSettings(), &pAllSettings, &numAllSettings);
// update the replayer with the loaded settings
replayer[tracerId]->UpdateFromSettings(pAllSettings, numAllSettings);
replayer[tracerId]->SetLogCallback(loggingCallback);
- replayer[tracerId]->SetLogLevel(GLV_LOG_LEVEL_MAXIMUM);
+ replayer[tracerId]->SetLogLevel(VKTRACE_LOG_LEVEL_MAXIMUM);
// Initialize the replayer
err = replayer[tracerId]->Initialize(&disp, &replaySettings);
if (err) {
- glv_LogError("Couldn't Initialize replayer for TracerId %d.", tracerId);
+ vktrace_LogError("Couldn't Initialize replayer for TracerId %d.", tracerId);
if (pAllSettings != NULL)
{
- glv_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
}
return err;
}
}
}
- if (tidApi == GLV_TID_RESERVED) {
- glv_LogError("No API specified in tracefile for replaying.");
+ if (tidApi == VKTRACE_TID_RESERVED) {
+ vktrace_LogError("No API specified in tracefile for replaying.");
if (pAllSettings != NULL)
{
- glv_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
}
return -1;
}
// main loop
Sequencer sequencer(traceFile);
- err = glv_replay::main_loop(sequencer, replayer, replaySettings.numLoops);
+ err = vktrace_replay::main_loop(sequencer, replayer, replaySettings.numLoops);
- for (int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ for (int i = 0; i < VKTRACE_MAX_TRACER_ID_ARRAY_SIZE; i++)
{
if (replayer[i] != NULL)
{
if (pAllSettings != NULL)
{
- glv_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
+ vktrace_SettingGroup_Delete_Loaded(&pAllSettings, &numAllSettings);
}
return err;
}
-#ifndef GLVREPLAY_MAIN_H
-#define GLVREPLAY_MAIN_H
+#ifndef VKREPLAY__MAIN_H
+#define VKREPLAY__MAIN_H
-typedef struct glvreplay_settings
+typedef struct vkreplayer_settings
{
char* pTraceFilePath;
unsigned int numLoops;
char* screenshotList;
-} glvreplay_settings;
+} vkreplayer_settings;
-#endif // GLVREPLAY_MAIN_H
+#endif // VKREPLAY__MAIN_H
#include "vktrace_trace_packet_utils.h"
}
-namespace glv_replay {
+namespace vktrace_replay {
-glv_trace_packet_header * Sequencer::get_next_packet()
+vktrace_trace_packet_header * Sequencer::get_next_packet()
{
- glv_free(m_lastPacket);
+ vktrace_free(m_lastPacket);
if (!m_pFile)
return (NULL);
- m_lastPacket = glv_read_trace_packet(m_pFile);
+ m_lastPacket = vktrace_read_trace_packet(m_pFile);
return(m_lastPacket);
}
m_bookmark.file_offset = ftell(m_pFile->mFile);
}
-} /* namespace glv_replay */
+} /* namespace vktrace_replay */
/* Class to handle fetching and sequencing packets from a tracefile.
* Contains no knowledge of type of tracer needed to process packet.
* Requires low level file/stream reading/seeking support. */
-namespace glv_replay {
+namespace vktrace_replay {
struct seqBookmark
{
public:
virtual ~AbstractSequencer() {}
- virtual glv_trace_packet_header *get_next_packet() = 0;
+ virtual vktrace_trace_packet_header *get_next_packet() = 0;
virtual void get_bookmark(seqBookmark &bookmark) = 0;
virtual void set_bookmark(const seqBookmark &bookmark) = 0;
};
Sequencer(FileLike* pFile) : m_lastPacket(NULL), m_pFile(pFile) {}
~Sequencer() { delete m_lastPacket;}
- glv_trace_packet_header *get_next_packet();
+ vktrace_trace_packet_header *get_next_packet();
void get_bookmark(seqBookmark &bookmark);
void set_bookmark(const seqBookmark &bookmark);
void record_bookmark();
private:
- glv_trace_packet_header *m_lastPacket;
+ vktrace_trace_packet_header *m_lastPacket;
seqBookmark m_bookmark;
FileLike *m_pFile;
};
-} /* namespace glv_replay */
+} /* namespace vktrace_replay */
#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
#include <xcb/xcb.h>
-typedef xcb_window_t glv_window_handle;
+typedef xcb_window_t vktrace_window_handle;
#elif defined(WIN32)
-typedef HWND glv_window_handle;
+typedef HWND vktrace_window_handle;
#endif
/* classes to abstract the display and initialization of rendering API for presenting
* framebuffers for display into a window on the screen or else fullscreen.
* Uses Bridge design pattern.
*/
-namespace glv_replay {
+namespace vktrace_replay {
class DisplayImp {
public:
virtual ~DisplayImp() {}
virtual int init(const unsigned int gpu_idx) = 0;
- virtual int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height) = 0;
+ virtual int set_window(vktrace_window_handle hWindow, unsigned int width, unsigned int height) = 0;
virtual int create_window(const unsigned int width, const unsigned int height) = 0;
virtual void process_event() = 0;
};
{
}
- Display(glv_window_handle hWindow, unsigned int width, unsigned int height) :
+ Display(vktrace_window_handle hWindow, unsigned int width, unsigned int height) :
m_imp(NULL),
m_width(width),
m_height(height),
return m_height;
}
- glv_window_handle get_window_handle()
+ vktrace_window_handle get_window_handle()
{
return m_hWindow;
}
unsigned int m_height;
unsigned int m_gpu;
bool m_fullscreen;
- glv_window_handle m_hWindow;
+ vktrace_window_handle m_hWindow;
};
-} // namespace glv_replay
+} // namespace vktrace_replay
#include <sys/types.h>
#include <sys/stat.h>
-glvtrace_settings g_settings;
-glvtrace_settings g_default_settings;
+vktrace_settings g_settings;
+vktrace_settings g_default_settings;
-glv_SettingInfo g_settings_info[] =
+vktrace_SettingInfo g_settings_info[] =
{
// common command options
- { "p", "Program", GLV_SETTING_STRING, &g_settings.program, &g_default_settings.program, TRUE, "The program to trace."},
- { "a", "Arguments", GLV_SETTING_STRING, &g_settings.arguments, &g_default_settings.arguments, TRUE, "Cmd-line arguments to pass to trace program."},
- { "w", "WorkingDir", GLV_SETTING_STRING, &g_settings.working_dir, &g_default_settings.working_dir, TRUE, "The program's working directory."},
- { "o", "OutputTrace", GLV_SETTING_STRING, &g_settings.output_trace, &g_default_settings.output_trace, TRUE, "Path to the generated output trace file."},
- { "s", "ScreenShot", GLV_SETTING_STRING, &g_settings.screenshotList, &g_default_settings.screenshotList, TRUE, "Comma separated list of frame numbers on which to take a screen snapshot."},
- { "l0", "TraceLibrary0", GLV_SETTING_STRING, &g_settings.trace_library[0], &g_default_settings.trace_library[0], TRUE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l1", "TraceLibrary1", GLV_SETTING_STRING, &g_settings.trace_library[1], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l2", "TraceLibrary2", GLV_SETTING_STRING, &g_settings.trace_library[2], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l3", "TraceLibrary3", GLV_SETTING_STRING, &g_settings.trace_library[3], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l4", "TraceLibrary4", GLV_SETTING_STRING, &g_settings.trace_library[4], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l5", "TraceLibrary5", GLV_SETTING_STRING, &g_settings.trace_library[5], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l6", "TraceLibrary6", GLV_SETTING_STRING, &g_settings.trace_library[6], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l7", "TraceLibrary7", GLV_SETTING_STRING, &g_settings.trace_library[7], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l8", "TraceLibrary8", GLV_SETTING_STRING, &g_settings.trace_library[8], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l9", "TraceLibrary9", GLV_SETTING_STRING, &g_settings.trace_library[9], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l10", "TraceLibrary10", GLV_SETTING_STRING, &g_settings.trace_library[10], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l11", "TraceLibrary11", GLV_SETTING_STRING, &g_settings.trace_library[11], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l12", "TraceLibrary12", GLV_SETTING_STRING, &g_settings.trace_library[12], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l13", "TraceLibrary13", GLV_SETTING_STRING, &g_settings.trace_library[13], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l14", "TraceLibrary14", GLV_SETTING_STRING, &g_settings.trace_library[14], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "l15", "TraceLibrary15", GLV_SETTING_STRING, &g_settings.trace_library[15], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
- { "ptm", "PrintTraceMessages", GLV_SETTING_BOOL, &g_settings.print_trace_messages, &g_default_settings.print_trace_messages, TRUE, "Print trace messages to glvtrace console."},
-
- //{ "z", "pauze", GLV_SETTING_BOOL, &g_settings.pause, &g_default_settings.pause, TRUE, "Wait for a key at startup (so a debugger can be attached)" },
- //{ "q", "quiet", GLV_SETTING_BOOL, &g_settings.quiet, &g_default_settings.quiet, TRUE, "Disable warning, verbose, and debug output" },
- //{ "v", "verbose", GLV_SETTING_BOOL, &g_settings.verbose, &g_default_settings.verbose, TRUE, "Enable verbose output" },
- //{ "d", "debug", GLV_SETTING_BOOL, &g_settings.debug, &g_default_settings.debug, TRUE, "Enable verbose debug information" },
+ { "p", "Program", VKTRACE_SETTING_STRING, &g_settings.program, &g_default_settings.program, TRUE, "The program to trace."},
+ { "a", "Arguments", VKTRACE_SETTING_STRING, &g_settings.arguments, &g_default_settings.arguments, TRUE, "Cmd-line arguments to pass to trace program."},
+ { "w", "WorkingDir", VKTRACE_SETTING_STRING, &g_settings.working_dir, &g_default_settings.working_dir, TRUE, "The program's working directory."},
+ { "o", "OutputTrace", VKTRACE_SETTING_STRING, &g_settings.output_trace, &g_default_settings.output_trace, TRUE, "Path to the generated output trace file."},
+ { "s", "ScreenShot", VKTRACE_SETTING_STRING, &g_settings.screenshotList, &g_default_settings.screenshotList, TRUE, "Comma separated list of frame numbers on which to take a screen snapshot."},
+ { "l0", "TraceLibrary0", VKTRACE_SETTING_STRING, &g_settings.trace_library[0], &g_default_settings.trace_library[0], TRUE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l1", "TraceLibrary1", VKTRACE_SETTING_STRING, &g_settings.trace_library[1], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l2", "TraceLibrary2", VKTRACE_SETTING_STRING, &g_settings.trace_library[2], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l3", "TraceLibrary3", VKTRACE_SETTING_STRING, &g_settings.trace_library[3], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l4", "TraceLibrary4", VKTRACE_SETTING_STRING, &g_settings.trace_library[4], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l5", "TraceLibrary5", VKTRACE_SETTING_STRING, &g_settings.trace_library[5], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l6", "TraceLibrary6", VKTRACE_SETTING_STRING, &g_settings.trace_library[6], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l7", "TraceLibrary7", VKTRACE_SETTING_STRING, &g_settings.trace_library[7], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l8", "TraceLibrary8", VKTRACE_SETTING_STRING, &g_settings.trace_library[8], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l9", "TraceLibrary9", VKTRACE_SETTING_STRING, &g_settings.trace_library[9], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l10", "TraceLibrary10", VKTRACE_SETTING_STRING, &g_settings.trace_library[10], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l11", "TraceLibrary11", VKTRACE_SETTING_STRING, &g_settings.trace_library[11], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l12", "TraceLibrary12", VKTRACE_SETTING_STRING, &g_settings.trace_library[12], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l13", "TraceLibrary13", VKTRACE_SETTING_STRING, &g_settings.trace_library[13], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l14", "TraceLibrary14", VKTRACE_SETTING_STRING, &g_settings.trace_library[14], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l15", "TraceLibrary15", VKTRACE_SETTING_STRING, &g_settings.trace_library[15], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "ptm", "PrintTraceMessages", VKTRACE_SETTING_BOOL, &g_settings.print_trace_messages, &g_default_settings.print_trace_messages, TRUE, "Print trace messages to vktrace console."},
+
+ //{ "z", "pauze", VKTRACE_SETTING_BOOL, &g_settings.pause, &g_default_settings.pause, TRUE, "Wait for a key at startup (so a debugger can be attached)" },
+ //{ "q", "quiet", VKTRACE_SETTING_BOOL, &g_settings.quiet, &g_default_settings.quiet, TRUE, "Disable warning, verbose, and debug output" },
+ //{ "v", "verbose", VKTRACE_SETTING_BOOL, &g_settings.verbose, &g_default_settings.verbose, TRUE, "Enable verbose output" },
+ //{ "d", "debug", VKTRACE_SETTING_BOOL, &g_settings.debug, &g_default_settings.debug, TRUE, "Enable verbose debug information" },
};
-glv_SettingGroup g_settingGroup =
+vktrace_SettingGroup g_settingGroup =
{
- "glvtrace",
+ "vktrace",
sizeof(g_settings_info) / sizeof(g_settings_info[0]),
&g_settings_info[0]
};
}
else
{
- quit = (msg.message == GLV_WM_COMPLETE);
+ quit = (msg.message == VKTRACE_WM_COMPLETE);
}
}
}
#endif
// returns the number of tracers that need to be injected
-int PrepareTracers(glvtrace_settings* pSettings, glv_process_capture_trace_thread_info** ppTracerInfo)
+int PrepareTracers(vktrace_settings* pSettings, vktrace_process_capture_trace_thread_info** ppTracerInfo)
{
// determine number of tracers to load and inject
unsigned int num_tracers = 0;
- for (unsigned int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ for (unsigned int i = 0; i < VKTRACE_MAX_TRACER_ID_ARRAY_SIZE; i++)
{
if (g_settings.trace_library[i] != NULL)
{
}
assert(ppTracerInfo != NULL && *ppTracerInfo == NULL);
- *ppTracerInfo = GLV_NEW_ARRAY(glv_process_capture_trace_thread_info, num_tracers);
- memset(*ppTracerInfo, 0, sizeof(glv_process_capture_trace_thread_info) * num_tracers);
+ *ppTracerInfo = VKTRACE_NEW_ARRAY(vktrace_process_capture_trace_thread_info, num_tracers);
+ memset(*ppTracerInfo, 0, sizeof(vktrace_process_capture_trace_thread_info) * num_tracers);
// consolidate the list, but also reverse the order so that the entrypoints should be hooked in the expected order
unsigned int tmpTracerIndex = num_tracers;
- for (unsigned int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ for (unsigned int i = 0; i < VKTRACE_MAX_TRACER_ID_ARRAY_SIZE; i++)
{
if (g_settings.trace_library[i] != NULL)
{
- void* hLibrary = glv_platform_open_library(g_settings.trace_library[i]);
+ void* hLibrary = vktrace_platform_open_library(g_settings.trace_library[i]);
if (hLibrary == NULL)
{
- glv_LogError("Failed to load tracer: %s", g_settings.trace_library[i]);
+ vktrace_LogError("Failed to load tracer: %s", g_settings.trace_library[i]);
}
else
{
- funcptr_GLV_GetTracerId GLV_GetTracerId = NULL;
- GLV_GetTracerId = (funcptr_GLV_GetTracerId)glv_platform_get_library_entrypoint(hLibrary, "GLV_GetTracerId");
+ funcptr_VKTRACE_GetTracerId VKTRACE_GetTracerId = NULL;
+ VKTRACE_GetTracerId = (funcptr_VKTRACE_GetTracerId)vktrace_platform_get_library_entrypoint(hLibrary, "VKTRACE_GetTracerId");
- if (GLV_GetTracerId != NULL)
+ if (VKTRACE_GetTracerId != NULL)
{
--tmpTracerIndex;
(*ppTracerInfo)[tmpTracerIndex].tracerPath = g_settings.trace_library[i];
- (*ppTracerInfo)[tmpTracerIndex].tracerId = GLV_GetTracerId();
+ (*ppTracerInfo)[tmpTracerIndex].tracerId = VKTRACE_GetTracerId();
}
else
{
- glv_LogError("Missing entrypoint GLV_GetTracerId() from %s", g_settings.trace_library[i]);
+ vktrace_LogError("Missing entrypoint VKTRACE_GetTracerId() from %s", g_settings.trace_library[i]);
}
- glv_platform_close_library(hLibrary);
+ vktrace_platform_close_library(hLibrary);
}
}
}
if (tmpTracerIndex > 0)
{
- glv_LogError("One or more tracers could not be loaded. Please correct the issue and try again.");
- GLV_DELETE(*ppTracerInfo);
+ vktrace_LogError("One or more tracers could not be loaded. Please correct the issue and try again.");
+ VKTRACE_DELETE(*ppTracerInfo);
*ppTracerInfo = NULL;
return 0;
}
return num_tracers;
}
-bool InjectTracersIntoProcess(glv_process_info* pInfo)
+bool InjectTracersIntoProcess(vktrace_process_info* pInfo)
{
bool bRecordingThreadsCreated = true;
for (unsigned int i = 0; i < pInfo->tracerCount; i++)
{
// inject tracers
- if (glv_platform_remote_load_library(pInfo->hProcess, pInfo->pCaptureThreads[i].tracerPath, &pInfo->pCaptureThreads[i].tracingThread, &pInfo->processLDPreload))
+ if (vktrace_platform_remote_load_library(pInfo->hProcess, pInfo->pCaptureThreads[i].tracerPath, &pInfo->pCaptureThreads[i].tracingThread, &pInfo->processLDPreload))
{
// prepare data for capture threads
pInfo->pCaptureThreads[i].pProcessInfo = pInfo;
- pInfo->pCaptureThreads[i].recordingThread = GLV_NULL_THREAD;
+ pInfo->pCaptureThreads[i].recordingThread = VKTRACE_NULL_THREAD;
// create thread to record trace packets from the tracer
- pInfo->pCaptureThreads[i].recordingThread = glv_platform_create_thread(Process_RunRecordTraceThread, &(pInfo->pCaptureThreads[i]));
- if (pInfo->pCaptureThreads[i].recordingThread == GLV_NULL_THREAD)
+ pInfo->pCaptureThreads[i].recordingThread = vktrace_platform_create_thread(Process_RunRecordTraceThread, &(pInfo->pCaptureThreads[i]));
+ if (pInfo->pCaptureThreads[i].recordingThread == VKTRACE_NULL_THREAD)
{
- glv_LogError("Failed to create trace recording thread.");
+ vktrace_LogError("Failed to create trace recording thread.");
bRecordingThreadsCreated = false;
}
// wait for the hooking / tracing thread to complete now that its recording thread is listening
if (WaitForSingleObject(pInfo->pCaptureThreads[i].tracingThread, INFINITE) != WAIT_OBJECT_0)
{
- glv_LogError("Injected tracer's thread did not return successfully.");
+ vktrace_LogError("Injected tracer's thread did not return successfully.");
bRecordingThreadsCreated = false;
}
#endif
return bRecordingThreadsCreated;
}
-void loggingCallback(GlvLogLevel level, const char* pMessage)
+void loggingCallback(VktraceLogLevel level, const char* pMessage)
{
switch(level)
{
- case GLV_LOG_ALWAYS: printf("%s\n", pMessage); break;
- case GLV_LOG_DEBUG: printf("Debug: %s\n", pMessage); break;
- case GLV_LOG_ERROR: printf("Error: %s\n", pMessage); break;
- case GLV_LOG_WARNING: printf("Warning: %s\n", pMessage); break;
- case GLV_LOG_VERBOSE: printf("Verbose: %s\n", pMessage); break;
+ case VKTRACE_LOG_ALWAYS: printf("%s\n", pMessage); break;
+ case VKTRACE_LOG_DEBUG: printf("Debug: %s\n", pMessage); break;
+ case VKTRACE_LOG_ERROR: printf("Error: %s\n", pMessage); break;
+ case VKTRACE_LOG_WARNING: printf("Warning: %s\n", pMessage); break;
+ case VKTRACE_LOG_VERBOSE: printf("Verbose: %s\n", pMessage); break;
default:
printf("%s\n", pMessage); break;
}
// ------------------------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
- memset(&g_settings, 0, sizeof(glvtrace_settings));
+ memset(&g_settings, 0, sizeof(vktrace_settings));
- glv_LogSetCallback(loggingCallback);
- glv_LogSetLevel(GLV_LOG_LEVEL_MAXIMUM);
+ vktrace_LogSetCallback(loggingCallback);
+ vktrace_LogSetLevel(VKTRACE_LOG_LEVEL_MAXIMUM);
- // get glvtrace binary directory
- char* execDir = glv_platform_get_current_executable_directory();
+ // get vktrace binary directory
+ char* execDir = vktrace_platform_get_current_executable_directory();
// setup defaults
- memset(&g_default_settings, 0, sizeof(glvtrace_settings));
- g_default_settings.output_trace = glv_copy_and_append(execDir, GLV_PATH_SEPARATOR, "vktrace_out.vktrace");
+ memset(&g_default_settings, 0, sizeof(vktrace_settings));
+ g_default_settings.output_trace = vktrace_copy_and_append(execDir, VKTRACE_PATH_SEPARATOR, "vktrace_out.vktrace");
g_default_settings.print_trace_messages = FALSE;
g_default_settings.screenshotList = NULL;
#if defined(WIN32)
- g_default_settings.trace_library[0] = glv_copy_and_append(execDir, GLV_PATH_SEPARATOR, "vulkan_trace.dll");
+ g_default_settings.trace_library[0] = vktrace_copy_and_append(execDir, VKTRACE_PATH_SEPARATOR, "vulkan_trace.dll");
#elif defined(PLATFORM_LINUX)
- g_default_settings.trace_library[0] = glv_copy_and_append(execDir, GLV_PATH_SEPARATOR, "libvulkan_trace.so");
+ g_default_settings.trace_library[0] = vktrace_copy_and_append(execDir, VKTRACE_PATH_SEPARATOR, "libvulkan_trace.so");
#endif
// free binary directory string
- glv_free(execDir);
+ vktrace_free(execDir);
- if (glv_SettingGroup_init(&g_settingGroup, NULL, argc, argv, &g_settings.arguments) != 0)
+ if (vktrace_SettingGroup_init(&g_settingGroup, NULL, argc, argv, &g_settings.arguments) != 0)
{
// invalid cmd-line parameters
- glv_SettingGroup_delete(&g_settingGroup);
- glv_free(g_default_settings.output_trace);
- glv_free(g_default_settings.trace_library[0]);
+ vktrace_SettingGroup_delete(&g_settingGroup);
+ vktrace_free(g_default_settings.output_trace);
+ vktrace_free(g_default_settings.trace_library[0]);
return -1;
}
else
{
- // Validate glvtrace inputs
+ // Validate vktrace inputs
BOOL validArgs = TRUE;
if (g_settings.trace_library[0] == NULL)
{
- glv_LogError("Missing required -l0 parameter to specify the tracer library.");
+ vktrace_LogError("Missing required -l0 parameter to specify the tracer library.");
validArgs = FALSE;
}
if (!strcmp(g_settings.trace_library[0], g_default_settings.trace_library[0]))
{
// look for default trace library in CWD then system directories
void *handle;
- if ((handle = glv_platform_open_library(g_settings.trace_library[0])) == NULL)
+ if ((handle = vktrace_platform_open_library(g_settings.trace_library[0])) == NULL)
{
- char *filename = strrchr(g_settings.trace_library[0], GLV_PATH_SEPARATOR[0]);
- if (!filename || (handle = glv_platform_open_library(filename+1)) == NULL)
+ char *filename = strrchr(g_settings.trace_library[0], VKTRACE_PATH_SEPARATOR[0]);
+ if (!filename || (handle = vktrace_platform_open_library(filename+1)) == NULL)
{
- glv_LogError("No -l0 arg and default tracer library file can't be found.");
+ vktrace_LogError("No -l0 arg and default tracer library file can't be found.");
validArgs = FALSE;
}
else
{
g_settings.trace_library[0] = filename+1;
- glv_platform_close_library(handle);
+ vktrace_platform_close_library(handle);
}
}
else
{
- glv_platform_close_library(handle);
+ vktrace_platform_close_library(handle);
}
}
if (g_settings.output_trace == NULL || strlen (g_settings.output_trace) == 0)
{
- glv_LogError("No output trace file (-o) parameter found: Please specify a valid trace file to generate.");
+ vktrace_LogError("No output trace file (-o) parameter found: Please specify a valid trace file to generate.");
validArgs = FALSE;
}
else
if (strncmp(&g_settings.output_trace[len-8], ".vktrace", 8) != 0)
{
// output trace filename does not end in .vktrace
- glv_LogError("Output trace file specified with -o parameter must have a '.vktrace' extension.");
+ vktrace_LogError("Output trace file specified with -o parameter must have a '.vktrace' extension.");
validArgs = FALSE;
}
}
if (validArgs == FALSE)
{
- glv_SettingGroup_print(&g_settingGroup);
+ vktrace_SettingGroup_print(&g_settingGroup);
return -1;
}
if (g_settings.program == NULL || strlen(g_settings.program) == 0)
{
- glv_LogAlways("No program (-p) parameter found: Running glvtrace as server.");
+ vktrace_LogAlways("No program (-p) parameter found: Running vktrace as server.");
g_settings.arguments = NULL;
}
else
{
if (g_settings.working_dir == NULL || strlen(g_settings.working_dir) == 0)
{
- CHAR* buf = GLV_NEW_ARRAY(CHAR, 4096);
- glv_LogWarning("No working directory (-w) parameter found: Assuming executable's path as working directory.");
- glv_platform_full_path(g_settings.program, 4096, buf);
- g_settings.working_dir = glv_platform_extract_path(buf);
- GLV_DELETE(buf);
+ CHAR* buf = VKTRACE_NEW_ARRAY(CHAR, 4096);
+ vktrace_LogWarning("No working directory (-w) parameter found: Assuming executable's path as working directory.");
+ vktrace_platform_full_path(g_settings.program, 4096, buf);
+ g_settings.working_dir = vktrace_platform_extract_path(buf);
+ VKTRACE_DELETE(buf);
}
- glv_LogAlways("Running glvtrace as parent process will spawn child process: %s", g_settings.program);
+ vktrace_LogAlways("Running vktrace as parent process will spawn child process: %s", g_settings.program);
if (g_settings.arguments != NULL && strlen(g_settings.arguments) > 0)
{
- glv_LogAlways("Args to be passed to child process: '%s'", g_settings.arguments);
+ vktrace_LogAlways("Args to be passed to child process: '%s'", g_settings.arguments);
}
}
}
{
// Export list to screenshot layer
- glv_set_global_var("_VK_SCREENSHOT", g_settings.screenshotList);
+ vktrace_set_global_var("_VK_SCREENSHOT", g_settings.screenshotList);
}
else
{
- glv_set_global_var("_VK_SCREENSHOT","");
+ vktrace_set_global_var("_VK_SCREENSHOT","");
}
// Create and start the process or run in server mode
BOOL procStarted = TRUE;
- glv_process_info procInfo;
- memset(&procInfo, 0, sizeof(glv_process_info));
+ vktrace_process_info procInfo;
+ memset(&procInfo, 0, sizeof(vktrace_process_info));
if (g_settings.program != NULL)
{
- procInfo.exeName = glv_allocate_and_copy(g_settings.program);
- procInfo.processArgs = glv_allocate_and_copy(g_settings.arguments);
- procInfo.fullProcessCmdLine = glv_copy_and_append(g_settings.program, " ", g_settings.arguments);
- procInfo.workingDirectory = glv_allocate_and_copy(g_settings.working_dir);
- procInfo.traceFilename = glv_allocate_and_copy(g_settings.output_trace);
+ procInfo.exeName = vktrace_allocate_and_copy(g_settings.program);
+ procInfo.processArgs = vktrace_allocate_and_copy(g_settings.arguments);
+ procInfo.fullProcessCmdLine = vktrace_copy_and_append(g_settings.program, " ", g_settings.arguments);
+ procInfo.workingDirectory = vktrace_allocate_and_copy(g_settings.working_dir);
+ procInfo.traceFilename = vktrace_allocate_and_copy(g_settings.output_trace);
} else
{
char *pExtension = strrchr(g_settings.output_trace, '.');
- char *basename = glv_allocate_and_copy_n(g_settings.output_trace, (int) ((pExtension == NULL) ? strlen(g_settings.output_trace) : pExtension - g_settings.output_trace));
+ char *basename = vktrace_allocate_and_copy_n(g_settings.output_trace, (int) ((pExtension == NULL) ? strlen(g_settings.output_trace) : pExtension - g_settings.output_trace));
char num[16];
#ifdef PLATFORM_LINUX
snprintf(num, 16, "%u", serverIndex);
#elif defined(WIN32)
_snprintf_s(num, 16, _TRUNCATE, "%u", serverIndex);
#endif
- procInfo.traceFilename = glv_copy_and_append(basename, num, pExtension);
+ procInfo.traceFilename = vktrace_copy_and_append(basename, num, pExtension);
}
- procInfo.parentThreadId = glv_platform_get_thread_id();
+ procInfo.parentThreadId = vktrace_platform_get_thread_id();
// setup tracers
procInfo.tracerCount = PrepareTracers(&g_settings, &procInfo.pCaptureThreads);
if (procInfo.tracerCount == 0)
{
- glv_SettingGroup_print(&g_settingGroup);
- glv_process_info_delete(&procInfo);
+ vktrace_SettingGroup_print(&g_settingGroup);
+ vktrace_process_info_delete(&procInfo);
return -1;
}
#if defined(WIN32)
if (g_settings.program != NULL)
// call CreateProcess to launch the application
- procStarted = glv_process_spawn(&procInfo);
+ procStarted = vktrace_process_spawn(&procInfo);
#endif
if (procStarted == TRUE)
{
if (InjectTracersIntoProcess(&procInfo) == FALSE)
{
- glv_LogError("Failed to setup tracer communication threads.");
+ vktrace_LogError("Failed to setup tracer communication threads.");
return -1;
}
#if defined(PLATFORM_LINUX)
// in linux we want to spawn the process AFTER setting up LD_PRELOAD (which happens in the loop above)
if (g_settings.program != NULL)
- procStarted = glv_process_spawn(&procInfo);
+ procStarted = vktrace_process_spawn(&procInfo);
#endif
if (procStarted == FALSE)
{
- glv_LogError("Failed to setup remote process.");
+ vktrace_LogError("Failed to setup remote process.");
}
else
{
// create watchdog thread to monitor existence of remote process
if (g_settings.program != NULL)
- procInfo.watchdogThread = glv_platform_create_thread(Process_RunWatchdogThread, &procInfo);
+ procInfo.watchdogThread = vktrace_platform_create_thread(Process_RunWatchdogThread, &procInfo);
#if defined(PLATFORM_LINUX)
// Sync wait for local threads and remote process to complete.
for (unsigned int i = 0; i < procInfo.tracerCount; i++)
{
- glv_platform_sync_wait_for_thread(&(procInfo.pCaptureThreads[i].recordingThread));
+ vktrace_platform_sync_wait_for_thread(&(procInfo.pCaptureThreads[i].recordingThread));
}
if (g_settings.program != NULL)
- glv_platform_sync_wait_for_thread(&procInfo.watchdogThread);
+ vktrace_platform_sync_wait_for_thread(&procInfo.watchdogThread);
#else
- glv_platform_resume_thread(&procInfo.hThread);
+ vktrace_platform_resume_thread(&procInfo.hThread);
// Now into the main message loop, listen for hotkeys to send over.
MessageLoop();
#endif
}
- glv_process_info_delete(&procInfo);
+ vktrace_process_info_delete(&procInfo);
serverIndex++;
} while (g_settings.program == NULL);
- glv_SettingGroup_delete(&g_settingGroup);
- glv_free(g_default_settings.output_trace);
+ vktrace_SettingGroup_delete(&g_settingGroup);
+ vktrace_free(g_default_settings.output_trace);
return 0;
}
#if defined(WIN32)
-#define GLV_WM_COMPLETE (WM_USER + 0)
+#define VKTRACE_WM_COMPLETE (WM_USER + 0)
#endif
//----------------------------------------------------------------------------------------------------------------------
// globals
//----------------------------------------------------------------------------------------------------------------------
-typedef struct glvtrace_settings
+typedef struct vktrace_settings
{
char* program;
char* arguments;
char* trace_library[16];
BOOL print_trace_messages;
char* screenshotList;
-} glvtrace_settings;
+} vktrace_settings;
-extern glvtrace_settings g_settings;
+extern vktrace_settings g_settings;
#endif
// ------------------------------------------------------------------------------------------------
-GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunWatchdogThread(LPVOID _procInfoPtr)
+VKTRACE_THREAD_ROUTINE_RETURN_TYPE Process_RunWatchdogThread(LPVOID _procInfoPtr)
{
- glv_process_info* pProcInfo = (glv_process_info*)_procInfoPtr;
+ vktrace_process_info* pProcInfo = (vktrace_process_info*)_procInfoPtr;
#if defined(WIN32)
{
if (pProcInfo->serverRequestsTermination)
{
- glv_LogVerbose("GLVTrace has requested exit.");
+ vktrace_LogVerbose("Vktrace has requested exit.");
return 0;
}
}
- glv_LogVerbose("Child process has terminated.");
+ vktrace_LogVerbose("Child process has terminated.");
- PostThreadMessage(pProcInfo->parentThreadId, GLV_WM_COMPLETE, 0, 0);
+ PostThreadMessage(pProcInfo->parentThreadId, VKTRACE_WM_COMPLETE, 0, 0);
pProcInfo->serverRequestsTermination = TRUE;
#elif defined(PLATFORM_LINUX)
{
if (WIFEXITED(status))
{
- glv_LogVerbose("Child process exited.");
+ vktrace_LogVerbose("Child process exited.");
break;
}
else if (WCOREDUMP(status))
{
- glv_LogError("Child process crashed.");
+ vktrace_LogError("Child process crashed.");
break;
}
else if (WIFSIGNALED(status))
- glv_LogVerbose("Child process was signaled.");
+ vktrace_LogVerbose("Child process was signaled.");
else if (WIFSTOPPED(status))
- glv_LogVerbose("Child process was stopped.");
+ vktrace_LogVerbose("Child process was stopped.");
else if (WIFCONTINUED(status))
- glv_LogVerbose("Child process was continued.");
+ vktrace_LogVerbose("Child process was continued.");
}
#endif
return 0;
}
// ------------------------------------------------------------------------------------------------
-GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunRecordTraceThread(LPVOID _threadInfo)
+VKTRACE_THREAD_ROUTINE_RETURN_TYPE Process_RunRecordTraceThread(LPVOID _threadInfo)
{
- glv_process_capture_trace_thread_info* pInfo = (glv_process_capture_trace_thread_info*)_threadInfo;
+ vktrace_process_capture_trace_thread_info* pInfo = (vktrace_process_capture_trace_thread_info*)_threadInfo;
- MessageStream* pMessageStream = glv_MessageStream_create(TRUE, "", GLV_BASE_PORT + pInfo->tracerId);
+ MessageStream* pMessageStream = vktrace_MessageStream_create(TRUE, "", VKTRACE_BASE_PORT + pInfo->tracerId);
if (pMessageStream == NULL)
{
- glv_LogError("Thread_CaptureTrace() cannot create message stream.");
+ vktrace_LogError("Thread_CaptureTrace() cannot create message stream.");
return 1;
}
// create trace file
- pInfo->pProcessInfo->pTraceFile = glv_write_trace_file_header(pInfo->pProcessInfo);
+ pInfo->pProcessInfo->pTraceFile = vktrace_write_trace_file_header(pInfo->pProcessInfo);
if (pInfo->pProcessInfo->pTraceFile == NULL) {
// writing trace file generated an error, no sense in continuing.
- glv_LogError("Error cannot create trace file and write header.");
- glv_process_info_delete(pInfo->pProcessInfo);
+ vktrace_LogError("Error cannot create trace file and write header.");
+ vktrace_process_info_delete(pInfo->pProcessInfo);
return 1;
}
- FileLike* fileLikeSocket = glv_FileLike_create_msg(pMessageStream);
+ FileLike* fileLikeSocket = vktrace_FileLike_create_msg(pMessageStream);
unsigned int total_packet_count = 0;
- glv_trace_packet_header* pHeader = NULL;
+ vktrace_trace_packet_header* pHeader = NULL;
size_t bytes_written;
while (pInfo->pProcessInfo->serverRequestsTermination == FALSE)
{
// get a packet
- //glv_LogDebug("Waiting for a packet...");
+ //vktrace_LogDebug("Waiting for a packet...");
// read entire packet in
- pHeader = glv_read_trace_packet(fileLikeSocket);
+ pHeader = vktrace_read_trace_packet(fileLikeSocket);
++total_packet_count;
if (pHeader == NULL)
{
if (pMessageStream->mErrorNum == WSAECONNRESET)
{
- glv_LogError("Network Connection Reset");
+ vktrace_LogError("Network Connection Reset");
}
else
{
- glv_LogError("Network Connection Failed");
+ vktrace_LogError("Network Connection Failed");
}
break;
}
- //glv_LogDebug("Received packet id: %hu", pHeader->packet_id);
+ //vktrace_LogDebug("Received packet id: %hu", pHeader->packet_id);
if (pHeader->pBody == (uintptr_t) NULL)
{
- glv_LogWarning("Received empty packet body for id: %hu", pHeader->packet_id);
+ vktrace_LogWarning("Received empty packet body for id: %hu", pHeader->packet_id);
}
else
{
// handle special case packets
- if (pHeader->packet_id == GLV_TPI_MESSAGE)
+ if (pHeader->packet_id == VKTRACE_TPI_MESSAGE)
{
if (g_settings.print_trace_messages == TRUE)
{
- glv_trace_packet_message* pPacket = glv_interpret_body_as_trace_packet_message(pHeader);
- glv_LogAlways("Packet %lu: Traced Message (%s): %s", pHeader->global_packet_index, glv_LogLevelToShortString(pPacket->type), pPacket->message);
- glv_finalize_buffer_address(pHeader, (void **) &(pPacket->message));
+ vktrace_trace_packet_message* pPacket = vktrace_interpret_body_as_trace_packet_message(pHeader);
+ vktrace_LogAlways("Packet %lu: Traced Message (%s): %s", pHeader->global_packet_index, vktrace_LogLevelToShortString(pPacket->type), pPacket->message);
+ vktrace_finalize_buffer_address(pHeader, (void **) &(pPacket->message));
}
}
- if (pHeader->packet_id == GLV_TPI_MARKER_TERMINATE_PROCESS)
+ if (pHeader->packet_id == VKTRACE_TPI_MARKER_TERMINATE_PROCESS)
{
pInfo->pProcessInfo->serverRequestsTermination = true;
- glv_delete_trace_packet(&pHeader);
- glv_LogVerbose("Thread_CaptureTrace is exiting.");
+ vktrace_delete_trace_packet(&pHeader);
+ vktrace_LogVerbose("Thread_CaptureTrace is exiting.");
break;
}
if (pInfo->pProcessInfo->pTraceFile != NULL)
{
- glv_enter_critical_section(&pInfo->pProcessInfo->traceFileCriticalSection);
+ vktrace_enter_critical_section(&pInfo->pProcessInfo->traceFileCriticalSection);
bytes_written = fwrite(pHeader, 1, (size_t)pHeader->size, pInfo->pProcessInfo->pTraceFile);
fflush(pInfo->pProcessInfo->pTraceFile);
- glv_leave_critical_section(&pInfo->pProcessInfo->traceFileCriticalSection);
+ vktrace_leave_critical_section(&pInfo->pProcessInfo->traceFileCriticalSection);
if (bytes_written != pHeader->size)
{
- glv_LogError("Failed to write the packet for packet_id = %hu", pHeader->packet_id);
+ vktrace_LogError("Failed to write the packet for packet_id = %hu", pHeader->packet_id);
}
}
}
// clean up
- glv_delete_trace_packet(&pHeader);
+ vktrace_delete_trace_packet(&pHeader);
}
- GLV_DELETE(fileLikeSocket);
- glv_MessageStream_destroy(&pMessageStream);
+ VKTRACE_DELETE(fileLikeSocket);
+ vktrace_MessageStream_destroy(&pMessageStream);
return 0;
}
#include "vktrace_interconnect.h"
}
-GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunRecordTraceThread(LPVOID);
+VKTRACE_THREAD_ROUTINE_RETURN_TYPE Process_RunRecordTraceThread(LPVOID);
-GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunWatchdogThread(LPVOID);
+VKTRACE_THREAD_ROUTINE_RETURN_TYPE Process_RunWatchdogThread(LPVOID);
# add main repo directory so vulkan.py can be imported. This needs to be a complete path.
-glv_scripts_path = os.path.dirname(os.path.abspath(__file__))
-main_path = os.path.abspath(glv_scripts_path + "/../")
+vktrace_scripts_path = os.path.dirname(os.path.abspath(__file__))
+main_path = os.path.abspath(vktrace_scripts_path + "/../")
sys.path.append(main_path)
from source_line_info import sourcelineinfo
func_protos.append('// Hooked function prototypes\n')
for proto in self.protos:
if 'Dbg' not in proto.name and 'WSI' not in proto.name:
- func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
+ func_protos.append('VKTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
return "\n".join(func_protos)
for ext in vulkan.extensions_all:
if (extName.lower() == ext.name.lower()):
for proto in ext.protos:
- func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
+ func_protos.append('VKTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
return "\n".join(func_protos)
hook_operator = '&='
hooks_txt.append(' }\n')
hooks_txt.append(' if (!hookSuccess)\n {')
- hooks_txt.append(' glv_LogError("Failed to hook Vulkan.");\n }\n')
+ hooks_txt.append(' vktrace_LogError("Failed to hook Vulkan.");\n }\n')
hooks_txt.append(' Mhook_EndMultiOperation();\n')
hooks_txt.append('#elif defined(__linux__)')
hooks_txt.append(' if (real_vkCreateInstance == vkCreateInstance)')
- hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_vkCreateInstance,"vkCreateInstance");')
+ hooks_txt.append(' hookSuccess = vktrace_platform_get_next_lib_sym((PVOID*)&real_vkCreateInstance,"vkCreateInstance");')
hooks_txt.append(' isHooked = TRUE;')
for proto in self.protos:
if 'Dbg' not in proto.name and 'WSI' not in proto.name and 'CreateInstance' not in proto.name:
- hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_vk%s, "vk%s");' % (hook_operator, proto.name, proto.name))
+ hooks_txt.append(' hookSuccess %s vktrace_platform_get_next_lib_sym((PVOID*)&real_vk%s, "vk%s");' % (hook_operator, proto.name, proto.name))
hooks_txt.append(' if (!hookSuccess)\n {')
- hooks_txt.append(' glv_LogError("Failed to hook Vulkan.");\n }\n')
+ hooks_txt.append(' vktrace_LogError("Failed to hook Vulkan.");\n }\n')
hooks_txt.append('#endif\n}\n')
return "\n".join(hooks_txt)
hook_operator = '&='
hooks_txt.append(' }\n isHooked = FALSE;')
hooks_txt.append(' if (!unhookSuccess)\n {')
- hooks_txt.append(' glv_LogError("Failed to unhook Vulkan.");\n }')
+ hooks_txt.append(' vktrace_LogError("Failed to unhook Vulkan.");\n }')
hooks_txt.append('#endif\n}')
hooks_txt.append('#ifdef WIN32\nINIT_ONCE gInitOnce = INIT_ONCE_STATIC_INIT;\n#elif defined(PLATFORM_LINUX)\npthread_once_t gInitOnce = PTHREAD_ONCE_INIT;\n#endif\n')
return "\n".join(hooks_txt)
init_tracer = []
init_tracer.append('void send_vk_api_version_packet()\n{')
init_tracer.append(' packet_vkApiVersion* pPacket;')
- init_tracer.append(' glv_trace_packet_header* pHeader;')
- init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_VULKAN, GLV_TPI_VK_vkApiVersion, sizeof(packet_vkApiVersion), 0);')
+ init_tracer.append(' vktrace_trace_packet_header* pHeader;')
+ init_tracer.append(' pHeader = vktrace_create_trace_packet(VKTRACE_TID_VULKAN, VKTRACE_TPI_VK_vkApiVersion, sizeof(packet_vkApiVersion), 0);')
init_tracer.append(' pPacket = interpret_body_as_vkApiVersion(pHeader);')
init_tracer.append(' pPacket->version = VK_API_VERSION;')
- init_tracer.append(' glv_set_packet_entrypoint_end_time(pHeader);')
+ init_tracer.append(' vktrace_set_packet_entrypoint_end_time(pHeader);')
init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
- init_tracer.append('extern GLV_CRITICAL_SECTION g_memInfoLock;')
+ init_tracer.append('extern VKTRACE_CRITICAL_SECTION g_memInfoLock;')
init_tracer.append('void InitTracer(void)\n{')
- init_tracer.append(' const char *ipAddr = glv_get_global_var("GLVLIB_TRACE_IPADDR");')
+ init_tracer.append(' const char *ipAddr = vktrace_get_global_var("VKTRACE_LIB_IPADDR");')
init_tracer.append(' if (ipAddr == NULL)')
init_tracer.append(' ipAddr = "127.0.0.1";')
- init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, ipAddr, GLV_BASE_PORT + GLV_TID_VULKAN);')
- init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')
- init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_VULKAN);')
- init_tracer.append(' glv_create_critical_section(&g_memInfoLock);')
+ init_tracer.append(' gMessageStream = vktrace_MessageStream_create(FALSE, ipAddr, VKTRACE_BASE_PORT + VKTRACE_TID_VULKAN);')
+ init_tracer.append(' vktrace_trace_set_trace_file(vktrace_FileLike_create_msg(gMessageStream));')
+ init_tracer.append(' vktrace_tracelog_set_tracer_id(VKTRACE_TID_VULKAN);')
+ init_tracer.append(' vktrace_create_critical_section(&g_memInfoLock);')
init_tracer.append(' send_vk_api_version_packet();\n}\n')
return "\n".join(init_tracer)
'finalize_txt': ''},
'VkApplicationInfo': {'add_txt': 'add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&(pPacket->pAppInfo), pAppInfo)',
'finalize_txt': ''},
- 'VkPhysicalDevice': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), *pGpuCount*sizeof(VkPhysicalDevice), pGpus)',
+ 'VkPhysicalDevice': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), *pGpuCount*sizeof(VkPhysicalDevice), pGpus)',
'finalize_txt': 'default'},
- 'pDataSize': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize))'},
-# 'pData': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData)',
+ 'pDataSize': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize))'},
+# 'pData': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData)',
# 'finalize_txt': 'default'},
- 'pName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pName), ((pName != NULL) ? strlen(pName) + 1 : 0), pName)',
+ 'pName': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pName), ((pName != NULL) ? strlen(pName) + 1 : 0), pName)',
'finalize_txt': 'default'},
- 'pMarker': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMarker), ((pMarker != NULL) ? strlen(pMarker) + 1 : 0), pMarker)',
+ 'pMarker': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMarker), ((pMarker != NULL) ? strlen(pMarker) + 1 : 0), pMarker)',
'finalize_txt': 'default'},
- 'pExtName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), ((pExtName != NULL) ? strlen(pExtName) + 1 : 0), pExtName)',
+ 'pExtName': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), ((pExtName != NULL) ? strlen(pExtName) + 1 : 0), pExtName)',
'finalize_txt': 'default'},
- 'pDescriptorSets': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets)',
+ 'pDescriptorSets': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets)',
'finalize_txt': 'default'},
- 'pSparseMemoryRequirements': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSparseMemoryRequirements), (*pNumRequirements) * sizeof(VkSparseImageMemoryRequirements), pSparseMemoryRequirements)',
+ 'pSparseMemoryRequirements': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSparseMemoryRequirements), (*pNumRequirements) * sizeof(VkSparseImageMemoryRequirements), pSparseMemoryRequirements)',
'finalize_txt': 'default'},
- 'VkSparseImageFormatProperties': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), (*pNumProperties) * sizeof(VkSparseImageFormatProperties), pProperties)',
+ 'VkSparseImageFormatProperties': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), (*pNumProperties) * sizeof(VkSparseImageFormatProperties), pProperties)',
'finalize_txt': 'default'},
- 'VkSparseMemoryBindInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBindInfo), numBindings * sizeof(VkSparseMemoryBindInfo), pBindInfo)',
+ 'VkSparseMemoryBindInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBindInfo), numBindings * sizeof(VkSparseMemoryBindInfo), pBindInfo)',
'finalize_txt': 'default'},
- 'VkSparseImageMemoryBindInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBindInfo), numBindings * sizeof(VkSparseImageMemoryBindInfo), pBindInfo)',
+ 'VkSparseImageMemoryBindInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBindInfo), numBindings * sizeof(VkSparseImageMemoryBindInfo), pBindInfo)',
'finalize_txt': 'default'},
-# 'VkShaderCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderCreateInfo), pCreateInfo);\n'
-# ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), ((pCreateInfo != NULL) ? pCreateInfo->codeSize : 0), pCreateInfo->pCode)',
-# 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n'
-# ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
- 'VkFramebufferCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(VkColorAttachmentBindInfo), pCreateInfo->pColorAttachments);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
- 'VkRenderPassCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkRenderPassCreateInfo), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats), colorCount * sizeof(VkFormat), pCreateInfo->pColorFormats);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts), colorCount * sizeof(VkImageLayout), pCreateInfo->pColorLayouts);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(VkAttachmentLoadOp), pCreateInfo->pColorLoadOps);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(VkAttachmentStoreOp), pCreateInfo->pColorStoreOps);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(VkClearColor), pCreateInfo->pColorLoadClearValues)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
- 'VkPipelineLayoutCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkPipelineLayoutCreateInfo), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSetLayouts), pCreateInfo->descriptorSetCount * sizeof(VkDescriptorSetLayout), pCreateInfo->pSetLayouts);',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSetLayouts));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
- 'VkDynamicViewportStateCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDynamicViewportStateCreateInfo), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(VkViewport), pCreateInfo->pViewports);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(VkRect2D), pCreateInfo->pScissors)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
- 'VkMemoryAllocInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(VkMemoryAllocInfo), pAllocInfo);\n'
+# 'VkShaderCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderCreateInfo), pCreateInfo);\n'
+# ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), ((pCreateInfo != NULL) ? pCreateInfo->codeSize : 0), pCreateInfo->pCode)',
+# 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n'
+# ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkFramebufferCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(VkColorAttachmentBindInfo), pCreateInfo->pColorAttachments);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkRenderPassCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkRenderPassCreateInfo), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats), colorCount * sizeof(VkFormat), pCreateInfo->pColorFormats);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts), colorCount * sizeof(VkImageLayout), pCreateInfo->pColorLayouts);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(VkAttachmentLoadOp), pCreateInfo->pColorLoadOps);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(VkAttachmentStoreOp), pCreateInfo->pColorStoreOps);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(VkClearColor), pCreateInfo->pColorLoadClearValues)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkPipelineLayoutCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkPipelineLayoutCreateInfo), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSetLayouts), pCreateInfo->descriptorSetCount * sizeof(VkDescriptorSetLayout), pCreateInfo->pSetLayouts);',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSetLayouts));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkDynamicViewportStateCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDynamicViewportStateCreateInfo), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(VkViewport), pCreateInfo->pViewports);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(VkRect2D), pCreateInfo->pScissors)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkMemoryAllocInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(VkMemoryAllocInfo), pAllocInfo);\n'
' add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo))'},
-# 'VkGraphicsPipelineCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkGraphicsPipelineCreateInfo), pCreateInfos);\n'
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo))'},
+# 'VkGraphicsPipelineCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkGraphicsPipelineCreateInfo), pCreateInfos);\n'
# ' add_VkGraphicsPipelineCreateInfos_to_trace_packet(pHeader, (VkGraphicsPipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, count)',
-# 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos))'},
-# 'VkComputePipelineCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkComputePipelineCreateInfo), pCreateInfos);\n'
+# 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos))'},
+# 'VkComputePipelineCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkComputePipelineCreateInfo), pCreateInfos);\n'
# ' add_VkComputePipelineCreateInfos_to_trace_packet(pHeader, (VkComputePipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, count)',
-# 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos))'},
- 'VkDescriptorPoolCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), pCreateInfo->count * sizeof(VkDescriptorTypeCount), pCreateInfo->pTypeCount)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+# 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos))'},
+ 'VkDescriptorPoolCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), pCreateInfo->count * sizeof(VkDescriptorTypeCount), pCreateInfo->pTypeCount)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
'VkDescriptorSetLayoutCreateInfo': {'add_txt': 'add_create_ds_layout_to_trace_packet(pHeader, &pPacket->pCreateInfo, pCreateInfo)',
'finalize_txt': '// pCreateInfo finalized in add_create_ds_layout_to_trace_packet'},
- 'VkSwapChainCreateInfoWSI': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkSwapChainCreateInfoWSI), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pCreateInfo->pSurfaceDescription)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
- 'VkShaderModuleCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderModuleCreateInfo), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), pPacket->pCreateInfo->codeSize, pCreateInfo->pCode)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
- 'VkShaderCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderModuleCreateInfo), pCreateInfo);\n'
- ' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pName), strlen(pPacket->pCreateInfo->pName), pCreateInfo->pName)',
- 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pName));\n'
- ' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkSwapChainCreateInfoWSI': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkSwapChainCreateInfoWSI), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription), sizeof(VkSurfaceDescriptionWSI), pCreateInfo->pSurfaceDescription)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkShaderModuleCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderModuleCreateInfo), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), pPacket->pCreateInfo->codeSize, pCreateInfo->pCode)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
+ 'VkShaderCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderModuleCreateInfo), pCreateInfo);\n'
+ ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pName), strlen(pPacket->pCreateInfo->pName), pCreateInfo->pName)',
+ 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pName));\n'
+ ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
}
for p in params:
if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
# LUGMAL if 'const' in p.ty.lower() and 'count' in params[params.index(p)-1].name.lower() and p.name != 'pCreateInfos':
if 'const' in p.ty.lower() and 'count' in params[params.index(p)-1].name.lower():
- pp_dict['add_txt'] = 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s)' % (p.name, params[params.index(p)-1].name, p.ty.strip('*').replace('const ', ''), p.name)
+ pp_dict['add_txt'] = 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s)' % (p.name, params[params.index(p)-1].name, p.ty.strip('*').replace('const ', ''), p.name)
elif 'pOffsets' == p.name: # TODO : This is a custom case for BindVertexBuffers last param, need to clean this up
- pp_dict['add_txt'] = 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s)' % (p.name, params[params.index(p)-2].name, p.ty.strip('*').replace('const ', ''), p.name)
+ pp_dict['add_txt'] = 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s)' % (p.name, params[params.index(p)-2].name, p.ty.strip('*').replace('const ', ''), p.name)
elif p.ty.strip('*').replace('const ', '') in custom_ptr_dict:
pp_dict['add_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['add_txt']
pp_dict['finalize_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['finalize_txt']
if 'pData' == p.name and 'dataSize' == params[params.index(p)-1].name:
pp_dict['add_txt'] = pp_dict['add_txt'].replace('_dataSize', 'dataSize')
else:
- pp_dict['add_txt'] = 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s)' % (p.name, p.ty.strip('*').replace('const ', ''), p.name)
+ pp_dict['add_txt'] = 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s)' % (p.name, p.ty.strip('*').replace('const ', ''), p.name)
if 'finalize_txt' not in pp_dict or 'default' == pp_dict['finalize_txt']:
- pp_dict['finalize_txt'] = 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
+ pp_dict['finalize_txt'] = 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
pp_dict['index'] = params.index(p)
ptr_param_list.append(pp_dict)
return ptr_param_list
packet_size = []
in_data_size = False # flag when we need to capture local input size variable for in/out size
func_body.append('%s' % self.lineinfo.get())
- func_body.append('GLVTRACER_EXPORT %s VKAPI __HOOKED_vk%s(' % (proto.ret, proto.name))
+ func_body.append('VKTRACER_EXPORT %s VKAPI __HOOKED_vk%s(' % (proto.ret, proto.name))
for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 if NULL
func_body.append(' %s %s,' % (p.ty, p.name))
if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
ptr_packet_update_list = self._get_packet_ptr_param_list(proto.params)
func_body[-1] = func_body[-1].replace(',', ')')
# End of function declaration portion, begin function body
- func_body.append('{\n glv_trace_packet_header* pHeader;')
+ func_body.append('{\n vktrace_trace_packet_header* pHeader;')
if 'void' not in proto.ret or '*' in proto.ret:
func_body.append(' %s result;' % proto.ret)
return_txt = 'result = '
if 'Dbg' in iProto.name or 'GetPhysicalDeviceSurfaceSupportWSI' in iProto.name:
func_body.append(' if (strcmp(pName, "vk%s") == 0) {' % (iProto.name))
func_body.append(' real_vk%s = (PFN_vk%s)real_vkGetInstanceProcAddr(instance, pName);' % (iProto.name, iProto.name))
- func_body.append(' glv_set_packet_entrypoint_end_time(pHeader);')
+ func_body.append(' vktrace_set_packet_entrypoint_end_time(pHeader);')
func_body.append(' if (real_vk%s != NULL) {' % (iProto.name))
func_body.append(' result = (PFN_vkVoidFunction)__HOOKED_vk%s;' % (iProto.name))
func_body.append(' } else {')
if 'WSI' in dProto.name:
func_body.append(' if (strcmp(pName, "vk%s") == 0) {' % (dProto.name))
func_body.append(' real_vk%s = (PFN_vk%s)real_vkGetDeviceProcAddr(device, pName);' % (dProto.name, dProto.name))
- func_body.append(' glv_set_packet_entrypoint_end_time(pHeader);')
+ func_body.append(' vktrace_set_packet_entrypoint_end_time(pHeader);')
func_body.append(' if (real_vk%s != NULL) {' % (dProto.name))
func_body.append(' result = (PFN_vkVoidFunction)__HOOKED_vk%s;' % (dProto.name))
func_body.append(' } else {')
else:
# call real entrypoint and get return value (if there is one)
func_body.append(' %sreal_vk%s;' % (return_txt, proto.c_call()))
- func_body.append(' glv_set_packet_entrypoint_end_time(pHeader);')
+ func_body.append(' vktrace_set_packet_entrypoint_end_time(pHeader);')
if in_data_size:
func_body.append(' _dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;')
def _generate_packet_id_enum(self):
pid_enum = []
- pid_enum.append('enum GLV_TRACE_PACKET_ID_VK')
+ pid_enum.append('enum VKTRACE_TRACE_PACKET_ID_VK')
pid_enum.append('{')
first_func = True
for proto in self.protos:
if first_func:
first_func = False
- pid_enum.append(' GLV_TPI_VK_vkApiVersion = GLV_TPI_BEGIN_API_HERE,')
- pid_enum.append(' GLV_TPI_VK_vk%s,' % proto.name)
+ pid_enum.append(' VKTRACE_TPI_VK_vkApiVersion = VKTRACE_TPI_BEGIN_API_HERE,')
+ pid_enum.append(' VKTRACE_TPI_VK_vk%s,' % proto.name)
else:
- pid_enum.append(' GLV_TPI_VK_vk%s,' % proto.name)
+ pid_enum.append(' VKTRACE_TPI_VK_vk%s,' % proto.name)
pid_enum.append('};\n')
return "\n".join(pid_enum)
def _generate_packet_id_name_func(self):
func_body = []
- func_body.append('static const char *glv_vk_packet_id_name(const enum GLV_TRACE_PACKET_ID_VK id)')
+ func_body.append('static const char *vktrace_vk_packet_id_name(const enum VKTRACE_TRACE_PACKET_ID_VK id)')
func_body.append('{')
func_body.append(' switch(id) {')
- func_body.append(' case GLV_TPI_VK_vkApiVersion:')
+ func_body.append(' case VKTRACE_TPI_VK_vkApiVersion:')
func_body.append(' {')
func_body.append(' return "vkApiVersion";')
func_body.append(' }')
for proto in self.protos:
- func_body.append(' case GLV_TPI_VK_vk%s:' % proto.name)
+ func_body.append(' case VKTRACE_TPI_VK_vk%s:' % proto.name)
func_body.append(' {')
func_body.append(' return "vk%s";' % proto.name)
func_body.append(' }')
def _generate_interp_func(self):
interp_func_body = []
interp_func_body.append('%s' % self.lineinfo.get())
- interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_vk(glv_trace_packet_header* pHeader)')
+ interp_func_body.append('static vktrace_trace_packet_header* interpret_trace_packet_vk(vktrace_trace_packet_header* pHeader)')
interp_func_body.append('{')
interp_func_body.append(' if (pHeader == NULL)')
interp_func_body.append(' {')
interp_func_body.append(' }')
interp_func_body.append(' switch (pHeader->packet_id)')
interp_func_body.append(' {')
- interp_func_body.append(' case GLV_TPI_VK_vkApiVersion:')
+ interp_func_body.append(' case VKTRACE_TPI_VK_vkApiVersion:')
interp_func_body.append(' {')
interp_func_body.append(' return interpret_body_as_vkApiVersion(pHeader)->header;')
interp_func_body.append(' }')
for proto in self.protos:
- interp_func_body.append(' case GLV_TPI_VK_vk%s:\n {' % proto.name)
+ interp_func_body.append(' case VKTRACE_TPI_VK_vk%s:\n {' % proto.name)
header_prefix = 'h'
if 'WSI' in proto.name or 'Dbg' in proto.name:
header_prefix = 'pH'
pid_enum = []
pid_enum.append('%s' % lineinfo.get())
pid_enum.append('//=============================================================================')
- pid_enum.append('static void add_VkApplicationInfo_to_packet(glv_trace_packet_header* pHeader, VkApplicationInfo** ppStruct, const VkApplicationInfo *pInStruct)')
+ pid_enum.append('static void add_VkApplicationInfo_to_packet(vktrace_trace_packet_header* pHeader, VkApplicationInfo** ppStruct, const VkApplicationInfo *pInStruct)')
pid_enum.append('{')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkApplicationInfo), pInStruct);')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkApplicationInfo), pInStruct);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
pid_enum.append('};\n')
pid_enum.append('%s' % lineinfo.get())
- pid_enum.append('static void add_VkInstanceCreateInfo_to_packet(glv_trace_packet_header* pHeader, VkInstanceCreateInfo** ppStruct, VkInstanceCreateInfo *pInStruct)')
+ pid_enum.append('static void add_VkInstanceCreateInfo_to_packet(vktrace_trace_packet_header* pHeader, VkInstanceCreateInfo** ppStruct, VkInstanceCreateInfo *pInStruct)')
pid_enum.append('{')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkInstanceCreateInfo), pInStruct);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkInstanceCreateInfo), pInStruct);')
pid_enum.append(' add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&((*ppStruct)->pAppInfo), pInStruct->pAppInfo);')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAllocCb), sizeof(VkAllocCallbacks), pInStruct->pAllocCb);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAllocCb));')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAllocCb), sizeof(VkAllocCallbacks), pInStruct->pAllocCb);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAllocCb));')
# TODO138 : This is an initial pass at getting the extension/layer arrays correct, needs to be validated.
pid_enum.append(' uint32_t i, siz = 0;')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->layerCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->layerCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
pid_enum.append(' if (pInStruct->layerCount > 0) ')
pid_enum.append(' {')
pid_enum.append(' for (i = 0; i < pInStruct->layerCount; i++) {')
pid_enum.append(' siz = (1 + strlen(pInStruct->ppEnabledLayerNames[i]));')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledLayerNames[i]), siz, pInStruct->ppEnabledLayerNames[i]);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames[i]);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledLayerNames[i]), siz, pInStruct->ppEnabledLayerNames[i]);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames);')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char*), pInStruct->ppEnabledExtensionNames);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char*), pInStruct->ppEnabledExtensionNames);')
pid_enum.append(' if (pInStruct->extensionCount > 0) ')
pid_enum.append(' {')
pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++) {')
pid_enum.append(' siz = (1 + strlen(pInStruct->ppEnabledExtensionNames[i]));')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames[i]), siz, pInStruct->ppEnabledExtensionNames[i]);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames[i]);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames[i]), siz, pInStruct->ppEnabledExtensionNames[i]);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)ppStruct);')
pid_enum.append('}\n')
pid_enum.append('%s' % lineinfo.get())
- pid_enum.append('static void add_VkDeviceCreateInfo_to_packet(glv_trace_packet_header* pHeader, VkDeviceCreateInfo** ppStruct, const VkDeviceCreateInfo *pInStruct)')
+ pid_enum.append('static void add_VkDeviceCreateInfo_to_packet(vktrace_trace_packet_header* pHeader, VkDeviceCreateInfo** ppStruct, const VkDeviceCreateInfo *pInStruct)')
pid_enum.append('{')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkDeviceCreateInfo), pInStruct);')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(VkDeviceQueueCreateInfo), pInStruct->pRequestedQueues);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkDeviceCreateInfo), pInStruct);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(VkDeviceQueueCreateInfo), pInStruct->pRequestedQueues);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
# TODO138 : This is an initial pass at getting the extension/layer arrays correct, needs to be validated.
pid_enum.append(' uint32_t i, siz = 0;')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->layerCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->layerCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
pid_enum.append(' if (pInStruct->layerCount > 0) ')
pid_enum.append(' {')
pid_enum.append(' for (i = 0; i < pInStruct->layerCount; i++) {')
pid_enum.append(' siz = (1 + strlen(pInStruct->ppEnabledLayerNames[i]));')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledLayerNames[i]), siz, pInStruct->ppEnabledLayerNames[i]);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames[i]);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledLayerNames[i]), siz, pInStruct->ppEnabledLayerNames[i]);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames);')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char*), pInStruct->ppEnabledExtensionNames);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char*), pInStruct->ppEnabledExtensionNames);')
pid_enum.append(' if (pInStruct->extensionCount > 0) ')
pid_enum.append(' {')
pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++) {')
pid_enum.append(' siz = (1 + strlen(pInStruct->ppEnabledExtensionNames[i]));')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames[i]), siz, pInStruct->ppEnabledExtensionNames[i]);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames[i]);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames[i]), siz, pInStruct->ppEnabledExtensionNames[i]);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
- pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pEnabledFeatures, sizeof(VkPhysicalDeviceFeatures), pInStruct->pEnabledFeatures);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pEnabledFeatures);')
- pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
+ pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pEnabledFeatures, sizeof(VkPhysicalDeviceFeatures), pInStruct->pEnabledFeatures);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pEnabledFeatures);')
+ pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)ppStruct);')
pid_enum.append('}\n')
pid_enum.append('%s' % lineinfo.get())
pid_enum.append('//=============================================================================\n')
- pid_enum.append('static VkInstanceCreateInfo* interpret_VkInstanceCreateInfo(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
+ pid_enum.append('static VkInstanceCreateInfo* interpret_VkInstanceCreateInfo(vktrace_trace_packet_header* pHeader, intptr_t ptr_variable)')
pid_enum.append('{')
- pid_enum.append(' VkInstanceCreateInfo* pVkInstanceCreateInfo = (VkInstanceCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
+ pid_enum.append(' VkInstanceCreateInfo* pVkInstanceCreateInfo = (VkInstanceCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
pid_enum.append(' uint32_t i;')
pid_enum.append(' if (pVkInstanceCreateInfo != NULL)')
pid_enum.append(' {')
- pid_enum.append(' pVkInstanceCreateInfo->pAppInfo = (VkApplicationInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo);')
- pid_enum.append(' pVkInstanceCreateInfo->pAllocCb = (VkAllocCallbacks*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAllocCb);')
+ pid_enum.append(' pVkInstanceCreateInfo->pAppInfo = (VkApplicationInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo);')
+ pid_enum.append(' pVkInstanceCreateInfo->pAllocCb = (VkAllocCallbacks*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAllocCb);')
pid_enum.append(' VkApplicationInfo** ppAppInfo = (VkApplicationInfo**) &pVkInstanceCreateInfo->pAppInfo;')
- pid_enum.append(' (*ppAppInfo)->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pAppName);')
- pid_enum.append(' (*ppAppInfo)->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pEngineName);')
+ pid_enum.append(' (*ppAppInfo)->pAppName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pAppName);')
+ pid_enum.append(' (*ppAppInfo)->pEngineName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pEngineName);')
pid_enum.append(' if (pVkInstanceCreateInfo->layerCount > 0)')
pid_enum.append(' {')
- pid_enum.append(' pVkInstanceCreateInfo->ppEnabledLayerNames = (const char* const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledLayerNames);')
+ pid_enum.append(' pVkInstanceCreateInfo->ppEnabledLayerNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledLayerNames);')
pid_enum.append(' for (i = 0; i < pVkInstanceCreateInfo->layerCount; i++) {')
pid_enum.append(' char** ppTmp = (char**)&pVkInstanceCreateInfo->ppEnabledLayerNames[i];')
- pid_enum.append(' *ppTmp = (char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledLayerNames[i]);')
+ pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledLayerNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
pid_enum.append(' if (pVkInstanceCreateInfo->extensionCount > 0)')
pid_enum.append(' {')
- pid_enum.append(' pVkInstanceCreateInfo->ppEnabledExtensionNames = (const char* const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledExtensionNames);')
+ pid_enum.append(' pVkInstanceCreateInfo->ppEnabledExtensionNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledExtensionNames);')
pid_enum.append(' for (i = 0; i < pVkInstanceCreateInfo->extensionCount; i++) {')
pid_enum.append(' char** ppTmp = (char**)&pVkInstanceCreateInfo->ppEnabledExtensionNames[i];')
- pid_enum.append(' *ppTmp = (char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledExtensionNames[i]);')
+ pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledExtensionNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
pid_enum.append(' }\n')
pid_enum.append(' return pVkInstanceCreateInfo;')
pid_enum.append('}\n')
pid_enum.append('%s' % lineinfo.get())
- pid_enum.append('static VkDeviceCreateInfo* interpret_VkDeviceCreateInfo(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
+ pid_enum.append('static VkDeviceCreateInfo* interpret_VkDeviceCreateInfo(vktrace_trace_packet_header* pHeader, intptr_t ptr_variable)')
pid_enum.append('{')
- pid_enum.append(' VkDeviceCreateInfo* pVkDeviceCreateInfo = (VkDeviceCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
+ pid_enum.append(' VkDeviceCreateInfo* pVkDeviceCreateInfo = (VkDeviceCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
pid_enum.append(' uint32_t i;')
pid_enum.append(' if (pVkDeviceCreateInfo != NULL)')
pid_enum.append(' {')
- pid_enum.append(' pVkDeviceCreateInfo->pRequestedQueues = (const VkDeviceQueueCreateInfo *)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pRequestedQueues);\n')
+ pid_enum.append(' pVkDeviceCreateInfo->pRequestedQueues = (const VkDeviceQueueCreateInfo *)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pRequestedQueues);\n')
pid_enum.append(' if (pVkDeviceCreateInfo->layerCount > 0)')
pid_enum.append(' {')
- pid_enum.append(' pVkDeviceCreateInfo->ppEnabledLayerNames = (const char* const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledLayerNames);')
+ pid_enum.append(' pVkDeviceCreateInfo->ppEnabledLayerNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledLayerNames);')
pid_enum.append(' for (i = 0; i < pVkDeviceCreateInfo->layerCount; i++) {')
pid_enum.append(' char** ppTmp = (char**)&pVkDeviceCreateInfo->ppEnabledLayerNames[i];')
- pid_enum.append(' *ppTmp = (char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledLayerNames[i]);')
+ pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledLayerNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
pid_enum.append(' if (pVkDeviceCreateInfo->extensionCount > 0)')
pid_enum.append(' {')
- pid_enum.append(' pVkDeviceCreateInfo->ppEnabledExtensionNames = (const char* const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledExtensionNames);')
+ pid_enum.append(' pVkDeviceCreateInfo->ppEnabledExtensionNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledExtensionNames);')
pid_enum.append(' for (i = 0; i < pVkDeviceCreateInfo->extensionCount; i++) {')
pid_enum.append(' char** ppTmp = (char**)&pVkDeviceCreateInfo->ppEnabledExtensionNames[i];')
- pid_enum.append(' *ppTmp = (char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledExtensionNames[i]);')
+ pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledExtensionNames[i]);')
pid_enum.append(' }')
pid_enum.append(' }')
- pid_enum.append(' pVkDeviceCreateInfo->pEnabledFeatures = (const VkPhysicalDeviceFeatures*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pEnabledFeatures);\n')
+ pid_enum.append(' pVkDeviceCreateInfo->pEnabledFeatures = (const VkPhysicalDeviceFeatures*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pEnabledFeatures);\n')
pid_enum.append(' }\n')
pid_enum.append(' return pVkDeviceCreateInfo;')
pid_enum.append('}\n')
pid_enum.append('%s' % lineinfo.get())
- pid_enum.append('static void interpret_VkPipelineShaderStageCreateInfo(glv_trace_packet_header* pHeader, VkPipelineShaderStageCreateInfo* pShader)')
+ pid_enum.append('static void interpret_VkPipelineShaderStageCreateInfo(vktrace_trace_packet_header* pHeader, VkPipelineShaderStageCreateInfo* pShader)')
pid_enum.append('{')
pid_enum.append(' if (pShader != NULL)')
pid_enum.append(' {')
pid_enum.append(' // specialization info')
- pid_enum.append(' pShader->pSpecializationInfo = (const VkSpecializationInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo);')
+ pid_enum.append(' pShader->pSpecializationInfo = (const VkSpecializationInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo);')
pid_enum.append(' if (pShader->pSpecializationInfo != NULL)')
pid_enum.append(' {')
pid_enum.append(' VkSpecializationInfo* pInfo = (VkSpecializationInfo*)pShader->pSpecializationInfo;')
- pid_enum.append(' pInfo->pMap = (const VkSpecializationMapEntry*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo->pMap);')
- pid_enum.append(' pInfo->pData = (const void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo->pData);')
+ pid_enum.append(' pInfo->pMap = (const VkSpecializationMapEntry*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo->pMap);')
+ pid_enum.append(' pInfo->pData = (const void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo->pData);')
pid_enum.append(' }')
pid_enum.append(' }')
pid_enum.append('}\n')
mem_barrier_interp = ['uint32_t i = 0;\n',
'for (i = 0; i < pPacket->memBarrierCount; i++) {\n',
' void** ppMB = (void**)&(pPacket->ppMemBarriers[i]);\n',
- ' *ppMB = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->ppMemBarriers[i]);\n',
+ ' *ppMB = vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->ppMemBarriers[i]);\n',
' //VkMemoryBarrier* pBarr = (VkMemoryBarrier*)pPacket->ppMemBarriers[i];\n',
' // TODO : Could fix up the pNext ptrs here if they were finalized and if we cared by switching on Barrier type and remapping\n',
'}']
create_rp_interp = ['VkRenderPassCreateInfo* pInfo = (VkRenderPassCreateInfo*)pPacket->pCreateInfo;\n',
'uint32_t i = 0;\n',
'VkAttachmentDescription **ppAD = (VkAttachmentDescription **)&(pInfo->pAttachments);\n',
- '*ppAD = (VkAttachmentDescription*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pAttachments);\n',
+ '*ppAD = (VkAttachmentDescription*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pAttachments);\n',
'VkSubpassDescription** ppSP = (VkSubpassDescription**)&(pInfo->pSubpasses);\n',
- '*ppSP = (VkSubpassDescription*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses);\n',
+ '*ppSP = (VkSubpassDescription*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses);\n',
'for (i=0; i<pInfo->subpassCount; i++) {\n',
' VkAttachmentReference** pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pInputAttachments);\n',
- ' *pAR = (VkAttachmentReference*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pInputAttachments);\n',
+ ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pInputAttachments);\n',
' pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pColorAttachments);\n',
- ' *pAR = (VkAttachmentReference*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pColorAttachments);\n',
+ ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pColorAttachments);\n',
' pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pResolveAttachments);\n',
- ' *pAR = (VkAttachmentReference*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pResolveAttachments);\n',
+ ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pResolveAttachments);\n',
' pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pPreserveAttachments);\n',
- ' *pAR = (VkAttachmentReference*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pPreserveAttachments);\n',
+ ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pPreserveAttachments);\n',
'}\n',
'VkSubpassDependency** ppSD = (VkSubpassDependency**)&(pInfo->pDependencies);\n',
- '*ppSD = (VkSubpassDependency*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pDependencies);\n']
+ '*ppSD = (VkSubpassDependency*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pDependencies);\n']
create_gfx_pipe = ['uint32_t i;\n',
'uint32_t j;\n',
'for (i=0; i<pPacket->count; i++) {\n',
'// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
'VkGraphicsPipelineCreateInfo* pNonConst = (VkGraphicsPipelineCreateInfo*)&(pPacket->pCreateInfos[i]);\n',
'// shader stages array\n',
- 'pNonConst->pStages = (VkPipelineShaderStageCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pStages);\n',
+ 'pNonConst->pStages = (VkPipelineShaderStageCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pStages);\n',
'for (j = 0; j < pPacket->pCreateInfos[i].stageCount; j++)\n',
'{\n',
' interpret_VkPipelineShaderStageCreateInfo(pHeader, (VkPipelineShaderStageCreateInfo*)&pPacket->pCreateInfos[i].pStages[j]);\n',
'}\n',
'// Vertex Input State\n',
- 'pNonConst->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState);\n',
+ 'pNonConst->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState);\n',
'VkPipelineVertexInputStateCreateInfo* pNonConstVIState = (VkPipelineVertexInputStateCreateInfo*)pNonConst->pVertexInputState;\n',
'if (pNonConstVIState) {\n',
- ' pNonConstVIState->pVertexBindingDescriptions = (const VkVertexInputBindingDescription*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions);\n',
- ' pNonConstVIState->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions);\n',
+ ' pNonConstVIState->pVertexBindingDescriptions = (const VkVertexInputBindingDescription*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions);\n',
+ ' pNonConstVIState->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions);\n',
'}\n',
'// Input Assembly State\n',
- 'pNonConst->pInputAssemblyState = (const VkPipelineInputAssemblyStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pInputAssemblyState);\n',
+ 'pNonConst->pInputAssemblyState = (const VkPipelineInputAssemblyStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pInputAssemblyState);\n',
'// Tesselation State\n',
- 'pNonConst->pTessellationState = (const VkPipelineTessellationStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pTessellationState);\n',
+ 'pNonConst->pTessellationState = (const VkPipelineTessellationStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pTessellationState);\n',
'// Viewport State\n',
- 'pNonConst->pViewportState = (const VkPipelineViewportStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pViewportState);\n',
+ 'pNonConst->pViewportState = (const VkPipelineViewportStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pViewportState);\n',
'// Raster State\n',
- 'pNonConst->pRasterState = (const VkPipelineRasterStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pRasterState);\n',
+ 'pNonConst->pRasterState = (const VkPipelineRasterStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pRasterState);\n',
'// MultiSample State\n',
- 'pNonConst->pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pMultisampleState);\n',
+ 'pNonConst->pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pMultisampleState);\n',
'// DepthStencil State\n',
- 'pNonConst->pDepthStencilState = (const VkPipelineDepthStencilStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pDepthStencilState);\n',
+ 'pNonConst->pDepthStencilState = (const VkPipelineDepthStencilStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pDepthStencilState);\n',
'// ColorBuffer State\n',
- 'pNonConst->pColorBlendState = (const VkPipelineColorBlendStateCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pColorBlendState);\n',
+ 'pNonConst->pColorBlendState = (const VkPipelineColorBlendStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pColorBlendState);\n',
'VkPipelineColorBlendStateCreateInfo* pNonConstCbState = (VkPipelineColorBlendStateCreateInfo*)pNonConst->pColorBlendState;\n',
'if (pNonConstCbState)\n',
- ' pNonConstCbState->pAttachments = (const VkPipelineColorBlendAttachmentState*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pColorBlendState->pAttachments);\n',
+ ' pNonConstCbState->pAttachments = (const VkPipelineColorBlendAttachmentState*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pColorBlendState->pAttachments);\n',
'} else {\n',
' // This is unexpected.\n',
- ' glv_LogError("CreateGraphicsPipelines must have CreateInfo stype of VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.");\n',
+ ' vktrace_LogError("CreateGraphicsPipelines must have CreateInfo stype of VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.");\n',
' pPacket->header = NULL;\n',
'}\n',
'}\n']
# TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically
# TODO138 : Just ripped out a bunch of custom code here that was out of date. Need to scrub these function and verify they're correct
custom_case_dict = { #'CreateShader' : {'param': 'pCreateInfo', 'txt': ['VkShaderCreateInfo* pInfo = (VkShaderCreateInfo*)pPacket->pCreateInfo;\n',
- # 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
+ # 'pInfo->pCode = vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
'CreateDynamicViewportState' : {'param': 'pCreateInfo', 'txt': ['VkDynamicViewportStateCreateInfo* pInfo = (VkDynamicViewportStateCreateInfo*)pPacket->pCreateInfo;\n',
- 'pInfo->pViewports = (VkViewport*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',
- 'pInfo->pScissors = (VkRect2D*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pScissors);']},
+ 'pInfo->pViewports = (VkViewport*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',
+ 'pInfo->pScissors = (VkRect2D*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pScissors);']},
#'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['VkFramebufferCreateInfo* pInfo = (VkFramebufferCreateInfo*)pPacket->pCreateInfo;\n',
- # 'pInfo->pColorAttachments = (VkColorAttachmentBindInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
- # 'pInfo->pDepthStencilAttachment = (VkDepthStencilBindInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
+ # 'pInfo->pColorAttachments = (VkColorAttachmentBindInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
+ # 'pInfo->pDepthStencilAttachment = (VkDepthStencilBindInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': create_rp_interp},
'CreatePipelineLayout' : {'param': 'pCreateInfo', 'txt': ['VkPipelineLayoutCreateInfo* pInfo = (VkPipelineLayoutCreateInfo*)pPacket->pCreateInfo;\n',
- 'pInfo->pSetLayouts = (VkDescriptorSetLayout*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pSetLayouts);\n']},
+ 'pInfo->pSetLayouts = (VkDescriptorSetLayout*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pSetLayouts);\n']},
'CreateDescriptorPool' : {'param': 'pCreateInfo', 'txt': ['VkDescriptorPoolCreateInfo* pInfo = (VkDescriptorPoolCreateInfo*)pPacket->pCreateInfo;\n',
- 'pInfo->pTypeCount = (VkDescriptorTypeCount*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pTypeCount);\n']},
+ 'pInfo->pTypeCount = (VkDescriptorTypeCount*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pTypeCount);\n']},
'CmdWaitEvents' : {'param': 'ppMemBarriers', 'txt': mem_barrier_interp},
'CmdPipelineBarrier' : {'param': 'ppMemBarriers', 'txt': mem_barrier_interp},
'CreateDescriptorSetLayout' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) {\n',
' do\n',' {\n',
' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
' void** ppNextVoidPtr = (void**)&(pNext->pNext);\n',
- ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
+ ' *ppNextVoidPtr = (void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
' switch(pNext->sType)\n', ' {\n',
' case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',
' {\n' ,
' unsigned int i = 0;\n',
- ' pNext->pBinding = (VkDescriptorSetLayoutBinding*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pBinding);\n',
+ ' pNext->pBinding = (VkDescriptorSetLayoutBinding*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pBinding);\n',
' for (i = 0; i < pNext->count; i++)\n',' {\n',
' VkSampler** ppSamplers = (VkSampler**)&(pNext->pBinding[i].pImmutableSamplers);\n',
- ' *ppSamplers = (VkSampler*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pBinding[i].pImmutableSamplers);\n',
+ ' *ppSamplers = (VkSampler*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pBinding[i].pImmutableSamplers);\n',
' }\n',
' break;\n',
' }\n',
' default:\n',
' {\n',
- ' glv_LogError("Encountered an unexpected type in descriptor set layout create list.");\n',
+ ' vktrace_LogError("Encountered an unexpected type in descriptor set layout create list.");\n',
' pPacket->header = NULL;\n',
' pNext->pNext = NULL;\n',
' }\n',
' } while (NULL != pNext);\n',
'} else {\n',
' // This is unexpected.\n',
- ' glv_LogError("CreateDescriptorSetLayout must have pCreateInfo->stype of VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO.");\n',
+ ' vktrace_LogError("CreateDescriptorSetLayout must have pCreateInfo->stype of VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO.");\n',
' pPacket->header = NULL;\n',
'}']},
# 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['if (pPacket->pBeginInfo->sType == VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO) {\n',
# ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
# ' VkCmdBufferGraphicsBeginInfo** ppNext = (VkCmdBufferGraphicsBeginInfo**)&(pPacket->pBeginInfo->pNext);\n',
-# ' *ppNext = (VkCmdBufferGraphicsBeginInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
+# ' *ppNext = (VkCmdBufferGraphicsBeginInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
# ' VkCmdBufferGraphicsBeginInfo* pNext = *ppNext;\n',
# ' while (NULL != pNext)\n', ' {\n',
# ' switch(pNext->sType)\n', ' {\n',
# ' case VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',
# ' {\n',
# ' ppNext = (VkCmdBufferGraphicsBeginInfo**) &pNext->pNext;\n',
-# ' *ppNext = (VkCmdBufferGraphicsBeginInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
+# ' *ppNext = (VkCmdBufferGraphicsBeginInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
# ' break;\n',
# ' }\n',
# ' default:\n',
# ' {\n',
-# ' glv_LogError("Encountered an unexpected type in begin command buffer list.");\n',
+# ' vktrace_LogError("Encountered an unexpected type in begin command buffer list.");\n',
# ' pPacket->header = NULL;\n',
# ' pNext->pNext = NULL;\n',
# ' }\n',
# ' }\n',
# '} else {\n',
# ' // This is unexpected.\n',
-# ' glv_LogError("BeginCommandBuffer must have BeginInfo stype of VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO.");\n',
+# ' vktrace_LogError("BeginCommandBuffer must have BeginInfo stype of VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO.");\n',
# ' pPacket->header = NULL;\n',
# '}']},
'AllocMemory' : {'param': 'pAllocInfo', 'txt': ['if (pPacket->pAllocInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO) {\n',
' VkMemoryAllocInfo** ppNext = (VkMemoryAllocInfo**) &(pPacket->pAllocInfo->pNext);\n',
- ' *ppNext = (VkMemoryAllocInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo->pNext);\n',
+ ' *ppNext = (VkMemoryAllocInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo->pNext);\n',
' VkMemoryAllocInfo* pNext = (VkMemoryAllocInfo*) *ppNext;\n',
' while (NULL != pNext)\n', ' {\n',
' switch(pNext->sType)\n', ' {\n',
' default:\n',
' {\n',
- ' glv_LogError("Encountered an unexpected type alloc memory list.");\n',
+ ' vktrace_LogError("Encountered an unexpected type alloc memory list.");\n',
' pPacket->header = NULL;\n',
' pNext->pNext = NULL;\n',
' }\n',
' }\n',
'} else {\n',
' // This is unexpected.\n',
- ' glv_LogError("AllocMemory must have AllocInfo stype of VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO.");\n',
+ ' vktrace_LogError("AllocMemory must have AllocInfo stype of VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO.");\n',
' pPacket->header = NULL;\n',
'}']},
'UpdateDescriptorSets' : {'param': 'pDescriptorWrites', 'txt':
[ 'uint32_t i;\n',
'for (i = 0; i < pPacket->writeCount; i++) {\n',
' VkDescriptorInfo** ppDescriptors = (VkDescriptorInfo**)&pPacket->pDescriptorWrites[i].pDescriptors;\n',
- ' *ppDescriptors = (VkDescriptorInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDescriptorWrites[i].pDescriptors);\n',
+ ' *ppDescriptors = (VkDescriptorInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDescriptorWrites[i].pDescriptors);\n',
'}'
]},
'CreateGraphicsPipelines' : {'param': 'pCreateInfos', 'txt': create_gfx_pipe},
'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_VkPipelineShaderStageCreateInfo(pHeader, (VkPipelineShaderStageCreateInfo*)(&pPacket->pCreateInfo->cs));']},
'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['VkAttachmentView** ppAV = (VkAttachmentView**)&(pPacket->pCreateInfo->pAttachments);\n',
- '*ppAV = (VkAttachmentView*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pAttachments));']},
+ '*ppAV = (VkAttachmentView*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pAttachments));']},
'CmdBeginRenderPass' : {'param': 'pRenderPassBegin', 'txt': ['VkClearValue** ppCV = (VkClearValue**)&(pPacket->pRenderPassBegin->pClearValues);\n',
- '*ppCV = (VkClearValue*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pRenderPassBegin->pClearValues));']},
+ '*ppCV = (VkClearValue*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pRenderPassBegin->pClearValues));']},
'CreateShaderModule' : {'param': 'pCreateInfo', 'txt': ['void** ppCode = (void**)&(pPacket->pCreateInfo->pCode);\n',
- '*ppCode = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
+ '*ppCode = (void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
'CreateShader' : {'param': 'pCreateInfo', 'txt': ['void** ppName = (void**)&(pPacket->pCreateInfo->pName);\n',
- '*ppName = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pName);']},
+ '*ppName = (void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pName);']},
'FlushMappedMemoryRanges' : {'param': 'ppData', 'txt': ['uint32_t i = 0;\n',
'for (i = 0; i < pPacket->memRangeCount; i++)\n',
'{\n',
- ' pPacket->ppData[i] = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->ppData[i]);\n',
+ ' pPacket->ppData[i] = (void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->ppData[i]);\n',
'}']}}
if_body = []
if_body.append('typedef struct packet_vkApiVersion {')
- if_body.append(' glv_trace_packet_header* header;')
+ if_body.append(' vktrace_trace_packet_header* header;')
if_body.append(' uint32_t version;')
if_body.append('} packet_vkApiVersion;\n')
- if_body.append('static packet_vkApiVersion* interpret_body_as_vkApiVersion(glv_trace_packet_header* pHeader)')
+ if_body.append('static packet_vkApiVersion* interpret_body_as_vkApiVersion(vktrace_trace_packet_header* pHeader)')
if_body.append('{')
if_body.append(' packet_vkApiVersion* pPacket = (packet_vkApiVersion*)pHeader->pBody;')
if_body.append(' pPacket->header = pHeader;')
proto.params.append(vulkan.Param("void**", "ppData"))
if_body.append('%s' % self.lineinfo.get())
if_body.append('typedef struct packet_vk%s {' % proto.name)
- if_body.append(' glv_trace_packet_header* header;')
+ if_body.append(' vktrace_trace_packet_header* header;')
for p in proto.params:
if_body.append(' %s %s;' % (p.ty, p.name))
if 'void' != proto.ret:
if_body.append(' %s result;' % proto.ret)
if_body.append('} packet_vk%s;\n' % proto.name)
- if_body.append('static packet_vk%s* interpret_body_as_vk%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
+ if_body.append('static packet_vk%s* interpret_body_as_vk%s(vktrace_trace_packet_header* pHeader)' % (proto.name, proto.name))
if_body.append('{')
if_body.append(' packet_vk%s* pPacket = (packet_vk%s*)pHeader->pBody;' % (proto.name, proto.name))
if_body.append(' pPacket->header = pHeader;')
elif 'InstanceCreateInfo' in p.ty:
if_body.append(' pPacket->%s = interpret_VkInstanceCreateInfo(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
else:
- if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
+ if_body.append(' pPacket->%s = (%s)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
# TODO : Generalize this custom code to kill dict data struct above.
# Really the point of this block is to catch params w/ embedded ptrs to structs and chains of structs
if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
def _generate_interp_funcs_ext(self, extName):
if_body = []
- custom_case_dict = { 'QueuePresentWSI' : {'param': 'pPresentInfo', 'txt': ['pPacket->pPresentInfo->swapChains = (VkSwapChainWSI*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pPresentInfo->swapChains));\n',
- 'pPacket->pPresentInfo->imageIndices = (uint32_t*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pPresentInfo->imageIndices));']},
+ custom_case_dict = { 'QueuePresentWSI' : {'param': 'pPresentInfo', 'txt': ['pPacket->pPresentInfo->swapChains = (VkSwapChainWSI*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pPresentInfo->swapChains));\n',
+ 'pPacket->pPresentInfo->imageIndices = (uint32_t*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pPresentInfo->imageIndices));']},
'CreateSwapChainWSI' : {'param': 'pCreateInfo', 'txt': ['VkSurfaceDescriptionWSI **ppSurfDescp = (VkSurfaceDescriptionWSI**)&pPacket->pCreateInfo->pSurfaceDescription;\n',
'uint32_t **ppQFI = (uint32_t**)&pPacket->pCreateInfo->pQueueFamilyIndices;\n',
- '(*ppSurfDescp) = (VkSurfaceDescriptionWSI*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pSurfaceDescription));\n',
- '(*ppQFI) = (uint32_t*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pQueueFamilyIndices));']},
+ '(*ppSurfDescp) = (VkSurfaceDescriptionWSI*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pSurfaceDescription));\n',
+ '(*ppQFI) = (uint32_t*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pQueueFamilyIndices));']},
}
for ext in vulkan.extensions_all:
if ext.name.lower() == extName.lower():
for proto in ext.protos:
if_body.append('typedef struct packet_vk%s {' % proto.name)
- if_body.append(' glv_trace_packet_header* pHeader;')
+ if_body.append(' vktrace_trace_packet_header* pHeader;')
for p in proto.params:
if_body.append(' %s %s;' % (p.ty, p.name))
if 'void' != proto.ret:
if_body.append(' %s result;' % proto.ret)
if_body.append('} packet_vk%s;\n' % proto.name)
- if_body.append('static packet_vk%s* interpret_body_as_vk%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
+ if_body.append('static packet_vk%s* interpret_body_as_vk%s(vktrace_trace_packet_header* pHeader)' % (proto.name, proto.name))
if_body.append('{')
if_body.append(' packet_vk%s* pPacket = (packet_vk%s*)pHeader->pBody;' % (proto.name, proto.name))
if_body.append(' pPacket->pHeader = pHeader;')
for p in proto.params:
if '*' in p.ty:
- if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
+ if_body.append(' pPacket->%s = (%s)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
# TODO : Generalize this custom code to kill dict data struct above.
# Really the point of this block is to catch params w/ embedded ptrs to structs and chains of structs
if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
txt = ' %s remap_%s(const %s& value)\n {\n' % (ty, name[2:], ty)
txt += ' if (value == 0) { return 0; }\n'
txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
- txt += ' if (q == %s.end()) { glv_LogError("Failed to remap %s."); return value; }\n' % (name, ty)
+ txt += ' if (q == %s.end()) { vktrace_LogError("Failed to remap %s."); return value; }\n' % (name, ty)
txt += ' return q->second;\n }\n'
return txt
rof_body.append(' {')
rof_body.append(' if (m_mapRange.empty())')
rof_body.append(' {')
- rof_body.append(' glv_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty.");')
+ rof_body.append(' vktrace_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty.");')
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_LogWarning("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping.");')
+ rof_body.append(' vktrace_LogWarning("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping.");')
rof_body.append(' else if (pBuf == NULL)')
- rof_body.append(' glv_LogWarning("gpuMemory::setMemoryDataAddr() adding NULL pointer.");')
+ rof_body.append(' vktrace_LogWarning("gpuMemory::setMemoryDataAddr() adding NULL pointer.");')
rof_body.append(' mr.pData = (uint8_t *) pBuf;')
rof_body.append(' }')
rof_body.append('')
rof_body.append(' {')
rof_body.append(' if (m_mapRange.empty())')
rof_body.append(' {')
- rof_body.append(' glv_LogError("gpuMemory::copyMappingData() m_mapRange is empty.");')
+ rof_body.append(' vktrace_LogError("gpuMemory::copyMappingData() m_mapRange is empty.");')
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.");')
+ rof_body.append(' vktrace_LogError("gpuMemory::copyMappingData() null src pointer.");')
rof_body.append(' else')
- rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null dest pointer totalSize=%u.", m_allocInfo.allocationSize);')
+ rof_body.append(' vktrace_LogError("gpuMemory::copyMappingData() null dest pointer totalSize=%u.", m_allocInfo.allocationSize);')
rof_body.append(' m_mapRange.pop_back();')
rof_body.append(' return;')
rof_body.append(' }')
mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
obj_map_dict[mem_var] = obj
rc_body = []
- rc_body.append('#define GLV_VK_OBJECT_TYPE_UNKNOWN (VkObjectType)-1')
+ rc_body.append('#define VKTRACE_VK_OBJECT_TYPE_UNKNOWN (VkObjectType)-1')
rc_body.append('')
rc_body.append('typedef struct _VKAllocInfo {')
rc_body.append(' VkDeviceSize size;')
rc_body.append(' void setReqs(const VkMemoryRequirements *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(' vktrace_LogError("objMemory::setReqs, internal mismatch on number of allocations.");')
rc_body.append(' if (m_pMemReqs == NULL && pReqs != NULL)')
rc_body.append(' {')
- rc_body.append(' m_pMemReqs = (VkMemoryRequirements *) glv_malloc(num * sizeof(VkMemoryRequirements));')
+ rc_body.append(' m_pMemReqs = (VkMemoryRequirements *) vktrace_malloc(num * sizeof(VkMemoryRequirements));')
rc_body.append(' if (m_pMemReqs == NULL)')
rc_body.append(' {')
- rc_body.append(' glv_LogError("objMemory::setReqs out of memory.");')
+ rc_body.append(' vktrace_LogError("objMemory::setReqs out of memory.");')
rc_body.append(' return;')
rc_body.append(' }')
rc_body.append(' memcpy(m_pMemReqs, pReqs, num * sizeof(VkMemoryRequirements));')
rc_body.append(' if (value == 0) { return 0; }')
rc_body.append('')
rc_body.append(' std::map<uint64_t, imageObj>::const_iterator q = m_images.find(value);')
- rc_body.append(' if (q == m_images.end()) { glv_LogError("Failed to remap VkImage."); return value; }\n')
+ rc_body.append(' if (q == m_images.end()) { vktrace_LogError("Failed to remap VkImage."); return value; }\n')
rc_body.append(' return q->second.replayImage.handle;')
rc_body.append(' }\n')
elif obj_map_dict[var] == 'VkBuffer':
rc_body.append(' if (value == 0) { return 0; }')
rc_body.append('')
rc_body.append(' std::map<uint64_t, bufferObj>::const_iterator q = m_buffers.find(value);')
- rc_body.append(' if (q == m_buffers.end()) { glv_LogError("Failed to remap VkBuffer."); return value; }\n')
+ rc_body.append(' if (q == m_buffers.end()) { vktrace_LogError("Failed to remap VkBuffer."); return value; }\n')
rc_body.append(' return q->second.replayBuffer.handle;')
rc_body.append(' }\n')
elif obj_map_dict[var] == 'VkDeviceMemory':
rc_body.append(' if (value == 0) { return 0; }')
rc_body.append('')
rc_body.append(' std::map<uint64_t, gpuMemObj>::const_iterator q = m_devicememorys.find(value);')
- rc_body.append(' if (q == m_devicememorys.end()) { glv_LogError("Failed to remap VkDeviceMemory."); return value; }')
+ rc_body.append(' if (q == m_devicememorys.end()) { vktrace_LogError("Failed to remap VkDeviceMemory."); return value; }')
rc_body.append(' return q->second.replayGpuMem.handle;')
rc_body.append(' }\n')
else:
# for obj in state_obj_remap_types:
# rc_body.append('// if ((obj = remap(static_cast <%s> (state))) != VK_NULL_HANDLE)' % obj.type)
# rc_body.append('// return obj;')
-# rc_body.append(' glv_LogWarning("Failed to remap VkDynamicStateObject.");')
+# rc_body.append(' vktrace_LogWarning("Failed to remap VkDynamicStateObject.");')
# rc_body.append(' return VK_NULL_HANDLE;\n }')
# rc_body.append(' void rm_from_map(const VkDynamicStateObject& state)\n {')
# for obj in state_obj_remap_types:
# rc_body.append(' case %s:' % obj.enum)
# rc_body.append(' obj = remap(static_cast <%s> (object));' % obj.type)
# rc_body.append(' break;')
-# rc_body.append(' case GLV_VK_OBJECT_TYPE_UNKNOWN:')
+# rc_body.append(' case VKTRACE_VK_OBJECT_TYPE_UNKNOWN:')
# rc_body.append(' default:')
# rc_body.append(' obj = VK_NULL_HANDLE;')
# rc_body.append(' break;')
# for obj in obj_remap_types:
# if obj.type not in vulkan.object_parent_list:
# rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != VK_NULL_HANDLE) return obj;' % obj.type)
-# rc_body.append(' glv_LogError("Failed to remap VkObject.");')
+# rc_body.append(' vktrace_LogError("Failed to remap VkObject.");')
# rc_body.append(' }')
# rc_body.append(' return obj;')
# rc_body.append(' }')
rif_body.append('void vkFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
for proto in self.protos:
if 'WSI' not in proto.name and 'Dbg' not in proto.name:
- rif_body.append(' real_vk%s = (type_vk%s)(glv_platform_get_library_entrypoint(handle, "vk%s"));' % (proto.name, proto.name, proto.name))
+ rif_body.append(' real_vk%s = (type_vk%s)(vktrace_platform_get_library_entrypoint(handle, "vk%s"));' % (proto.name, proto.name, proto.name))
else: # These func ptrs get assigned at GetProcAddr time
rif_body.append(' real_vk%s = (type_vk%s)NULL;' % (proto.name, proto.name))
rif_body.append('}')
objectTypeRemapParam = ', pPacket->stateBindPoint'
elif 'object' == paramName:
if 'DbgSetObjectTag' == funcName:
- objectTypeRemapParam = ', GLV_VK_OBJECT_TYPE_UNKNOWN'
+ objectTypeRemapParam = ', VKTRACE_VK_OBJECT_TYPE_UNKNOWN'
else:
objectTypeRemapParam = ', pPacket->objType'
elif 'srcObject' == paramName and 'Callback' in funcName:
result = ' %s remapped%s = m_objMapper.remap_%ss(*pPacket->%s%s);\n' % (cleanParamType, paramName, paramName.lower(), paramName, objectTypeRemapParam)
result += ' if (pPacket->%s != VK_NULL_HANDLE && remapped%s == VK_NULL_HANDLE)\n' % (paramName, paramName)
result += ' {\n'
- result += ' return glv_replay::GLV_REPLAY_ERROR;\n'
+ result += ' return vktrace_replay::VKTRACE_REPLAY_ERROR;\n'
result += ' }\n'
return result
else: # TODO : Don't remap array ptrs?
result += '%s\n' % self.lineinfo.get()
result += ' if (pPacket->%s.handle != 0 && remapped%s.handle == 0)\n' % (paramName, paramName)
result += ' {\n'
- result += ' return glv_replay::GLV_REPLAY_ERROR;\n'
+ result += ' return vktrace_replay::VKTRACE_REPLAY_ERROR;\n'
result += ' }\n'
else:
result = ' %s remapped%s = m_objMapper.remap_%ss(pPacket->%s%s);\n' % (paramType, paramName, cleanParamType.lower()[2:], paramName, objectTypeRemapParam)
result += '%s\n' % self.lineinfo.get()
result += ' if (pPacket->%s != VK_NULL_HANDLE && remapped%s == VK_NULL_HANDLE)\n' % (paramName, paramName)
result += ' {\n'
- result += ' return glv_replay::GLV_REPLAY_ERROR;\n'
+ result += ' return vktrace_replay::VKTRACE_REPLAY_ERROR;\n'
result += ' }\n'
return result
return ' // No need to remap %s' % (paramName)
objectTypeRemapParam = ''
if 'object' == paramName:
if 'DbgSetObjectTag' == funcName:
- objectTypeRemapParam = ', GLV_VK_OBJECT_TYPE_UNKNOWN'
+ objectTypeRemapParam = ', VKTRACE_VK_OBJECT_TYPE_UNKNOWN'
else:
objectTypeRemapParam = ', pPacket->objType'
if '*' in paramType:
ci_body.append(' VkDevice remappedDevice = m_objMapper.remap_devices(pPacket->device);')
ci_body.append(' if (remappedDevice == VK_NULL_HANDLE)')
ci_body.append(' {')
- ci_body.append(' return glv_replay::GLV_REPLAY_ERROR;')
+ ci_body.append(' return vktrace_replay::VKTRACE_REPLAY_ERROR;')
ci_body.append(' }')
ci_body.append(' replayResult = m_vkFuncs.real_vkCreateImage(remappedDevice, pPacket->pCreateInfo, &local_imageObj.replayImage);')
ci_body.append(' if (replayResult == VK_SUCCESS)')
cb_body.append(' VkDevice remappedDevice = m_objMapper.remap_devices(pPacket->device);')
cb_body.append(' if (remappedDevice == VK_NULL_HANDLE)')
cb_body.append(' {')
- cb_body.append(' return glv_replay::GLV_REPLAY_ERROR;')
+ cb_body.append(' return vktrace_replay::VKTRACE_REPLAY_ERROR;')
cb_body.append(' }')
cb_body.append(' replayResult = m_vkFuncs.real_vkCreateBuffer(remappedDevice, pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
cb_body.append(' if (replayResult == VK_SUCCESS)')
do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result && pPacket->result == VK_SUCCESS', 'GetEventStatus': '(pPacket->result == VK_EVENT_SET || pPacket->result == VK_EVENT_RESET) && replayResult != pPacket->result'}
rbody = []
rbody.append('%s' % self.lineinfo.get())
- rbody.append('glv_replay::GLV_REPLAY_RESULT vkReplay::replay(glv_trace_packet_header *packet)')
+ rbody.append('vktrace_replay::VKTRACE_REPLAY_RESULT vkReplay::replay(vktrace_trace_packet_header *packet)')
rbody.append('{')
- rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
+ rbody.append(' vktrace_replay::VKTRACE_REPLAY_RESULT returnValue = vktrace_replay::VKTRACE_REPLAY_SUCCESS;')
rbody.append(' VkResult replayResult = VK_ERROR_UNKNOWN;')
rbody.append(' switch (packet->packet_id)')
rbody.append(' {')
- rbody.append(' case GLV_TPI_VK_vkApiVersion:')
+ rbody.append(' case VKTRACE_TPI_VK_vkApiVersion:')
rbody.append(' {')
rbody.append(' packet_vkApiVersion* pPacket = (packet_vkApiVersion*)(packet->pBody);')
rbody.append(' if (pPacket->version != VK_API_VERSION)')
rbody.append(' {')
- rbody.append(' glv_LogError("Trace file is from Vulkan version 0x%x (%u.%u.%u), but the glave plugin only supports version 0x%x (%u.%u.%u).", pPacket->version, (pPacket->version & 0xFFC00000) >> 22, (pPacket->version & 0x003FF000) >> 12, (pPacket->version & 0x00000FFF), VK_API_VERSION, (VK_API_VERSION & 0xFFC00000) >> 22, (VK_API_VERSION & 0x003FF000) >> 12, (VK_API_VERSION & 0x00000FFF));')
- rbody.append(' returnValue = glv_replay::GLV_REPLAY_ERROR;')
+ rbody.append(' vktrace_LogError("Trace file is from Vulkan version 0x%x (%u.%u.%u), but the vktrace plugin only supports version 0x%x (%u.%u.%u).", pPacket->version, (pPacket->version & 0xFFC00000) >> 22, (pPacket->version & 0x003FF000) >> 12, (pPacket->version & 0x00000FFF), VK_API_VERSION, (VK_API_VERSION & 0xFFC00000) >> 22, (VK_API_VERSION & 0x003FF000) >> 12, (VK_API_VERSION & 0x00000FFF));')
+ rbody.append(' returnValue = vktrace_replay::VKTRACE_REPLAY_ERROR;')
rbody.append(' }')
rbody.append(' break;')
rbody.append(' }')
create_view = True
elif 'Create' in proto.name or proto.name in special_create_list:
create_func = True
- rbody.append(' case GLV_TPI_VK_vk%s:' % proto.name)
+ rbody.append(' case VKTRACE_TPI_VK_vk%s:' % proto.name)
rbody.append(' {')
rbody.append(' packet_vk%s* pPacket = (packet_vk%s*)(packet->pBody);' % (proto.name, proto.name))
if proto.name in manually_replay_funcs:
else:
rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
elif proto.name == 'ResetFences':
- rbody.append(' VkFence* fences = GLV_NEW_ARRAY(VkFence, pPacket->fenceCount);')
+ rbody.append(' VkFence* fences = VKTRACE_NEW_ARRAY(VkFence, pPacket->fenceCount);')
rbody.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
rbody.append(' {')
rbody.append(' fences[i].handle = m_objMapper.remap_fences(pPacket->%s[i].handle);' % (proto.params[-1].name))
rbody.append(' m_pCBDump = NULL;')
rbody.append(' m_pDSDump = NULL;')
#TODO138 : disabling snapshot
- #rbody.append(' m_pGlvSnapshotPrint = NULL;')
+ #rbody.append(' m_pVktraceSnapshotPrint = NULL;')
rbody.append(' m_objMapper.rm_from_devices_map(pPacket->device);')
rbody.append(' m_display->m_initedVK = false;')
rbody.append(' }')
rbody.append(' free(local_pSetLayouts);')
rbody.append(' free(local_pDescriptorSets);')
elif proto.name == 'ResetFences':
- rbody.append(' GLV_DELETE(fences);')
+ rbody.append(' VKTRACE_DELETE(fences);')
elif create_func: # save handle mapping if create successful
rbody.append(' if (replayResult == VK_SUCCESS)')
rbody.append(' {')
rbody.append(' break;')
rbody.append(' }')
rbody.append(' default:')
- rbody.append(' glv_LogWarning("Unrecognized packet_id %u, skipping.", packet->packet_id);')
- rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')
+ rbody.append(' vktrace_LogWarning("Unrecognized packet_id %u, skipping.", packet->packet_id);')
+ rbody.append(' returnValue = vktrace_replay::VKTRACE_REPLAY_INVALID_ID;')
rbody.append(' break;')
rbody.append(' }')
rbody.append(' return returnValue;')
rbody.append('}')
return "\n".join(rbody)
-class GlaveTraceHeader(Subcommand):
+class VktraceTraceHeader(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#include "vktrace_vk_vk_packets.h"')
return "\n".join(body)
-class GlaveTraceC(Subcommand):
+class VktraceTraceC(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#include "vktrace_platform.h"')
return "\n".join(body)
-class GlavePacketID(Subcommand):
+class VktracePacketID(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#pragma once\n')
header_txt.append('#define snprintf _snprintf')
header_txt.append('#endif')
header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
- header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint);\n')
+ header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) vktrace_TraceInfo(#entrypoint);\n')
header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
- header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')
+ header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) vktrace_TraceInfo(entrypoint, __VA_ARGS__);\n')
header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
- header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_VULKAN, GLV_TPI_VK_##entrypoint, sizeof(packet_##entrypoint), buffer_bytes_needed);\n')
+ header_txt.append(' pHeader = vktrace_create_trace_packet(VKTRACE_TID_VULKAN, VKTRACE_TPI_VK_##entrypoint, sizeof(packet_##entrypoint), buffer_bytes_needed);\n')
header_txt.append('#define FINISH_TRACE_PACKET() \\')
- header_txt.append(' glv_finalize_trace_packet(pHeader); \\')
- header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')
- header_txt.append(' glv_delete_trace_packet(&pHeader);')
+ header_txt.append(' vktrace_finalize_trace_packet(pHeader); \\')
+ header_txt.append(' vktrace_write_trace_packet(pHeader, vktrace_trace_get_trace_file()); \\')
+ header_txt.append(' vktrace_delete_trace_packet(&pHeader);')
return "\n".join(header_txt)
def generate_body(self):
return "\n".join(body)
-class GlaveCoreTracePackets(Subcommand):
+class VktraceCoreTracePackets(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#pragma once\n')
return "\n".join(body)
-class GlaveExtTraceHeader(Subcommand):
+class VktraceExtTraceHeader(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#pragma once\n')
return "\n".join(body)
-class GlaveExtTraceC(Subcommand):
+class VktraceExtTraceC(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#include "vktrace_platform.h"')
return "\n".join(body)
-class GlaveExtTracePackets(Subcommand):
+class VktraceExtTracePackets(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#pragma once\n')
return "\n".join(body)
-class GlaveReplayVkFuncPtrs(Subcommand):
+class VktraceReplayVkFuncPtrs(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#pragma once\n')
body = [self._generate_replay_func_ptrs()]
return "\n".join(body)
-class GlaveReplayObjMapperHeader(Subcommand):
+class VktraceReplayObjMapperHeader(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#pragma once\n')
body = [self._generate_replay_objmapper_class()]
return "\n".join(body)
-class GlaveReplayC(Subcommand):
+class VktraceReplayC(Subcommand):
def generate_header(self, extName):
header_txt = []
header_txt.append('#include "vkreplay_vkreplay.h"\n')
def main():
subcommands = {
- "glave-trace-h" : GlaveTraceHeader,
- "glave-trace-c" : GlaveTraceC,
- "glave-packet-id" : GlavePacketID,
- "glave-core-trace-packets" : GlaveCoreTracePackets,
- "glave-ext-trace-h" : GlaveExtTraceHeader,
- "glave-ext-trace-c" : GlaveExtTraceC,
- "glave-ext-trace-packets" : GlaveExtTracePackets,
- "glave-replay-vk-funcs" : GlaveReplayVkFuncPtrs,
- "glave-replay-obj-mapper-h" : GlaveReplayObjMapperHeader,
- "glave-replay-c" : GlaveReplayC,
+ "vktrace-trace-h" : VktraceTraceHeader,
+ "vktrace-trace-c" : VktraceTraceC,
+ "vktrace-packet-id" : VktracePacketID,
+ "vktrace-core-trace-packets" : VktraceCoreTracePackets,
+ "vktrace-ext-trace-h" : VktraceExtTraceHeader,
+ "vktrace-ext-trace-c" : VktraceExtTraceC,
+ "vktrace-ext-trace-packets" : VktraceExtTracePackets,
+ "vktrace-replay-vk-funcs" : VktraceReplayVkFuncPtrs,
+ "vktrace-replay-obj-mapper-h" : VktraceReplayObjMapperHeader,
+ "vktrace-replay-c" : VktraceReplayC,
}
if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
projects / platform / upstream / Vulkan-LoaderAndValidationLayers.git / commitdiff