Crash Diagnostic Layer

The Crash Diagnostic Layer (CDL) is a Vulkan layer to help track down and identify the cause of GPU hangs and crashes. It works by instrumenting command buffers with completion checkpoints. When an error is detected a dump file containing incomplete command buffers is written. Often the last complete or incomplete commands are responsible for the crash. The name of the layer is VK_LAYER_LUNARG_crash_diagnostic.

Building

See the associated BUILD.md file for details on how to build the Crash Diagnostic Layer for various platforms.

Runtime requirements

CDL uses the following extensions. If an extension is not present, some functionality might be disabled.

VK_KHR_timeline_semaphore (or Vulkan 1.2) - used to track forward progress of queue submissions
VK_NV_device_diagnostic_commands - used to track forward progress within command buffers
VK_AMD_buffer_marker - used to track forward progress within command buffers (if the NV extension is not present) and the state of binary semaphores.
VK_AMD_device_coherent_memory - improves the accuracy of VK_AMD_buffer_marker tracking
VK_EXT_device_fault - allows drivers to report data related to a VK_ERROR_DEVICE_LOST, such as invalid device addresses.
VK_EXT_device_address_binding_report - allows drivers to report lifecycle information about device address assignments, which can help identify the source of device faults.

Running

CDL can be used as an explicit or implicit layer. The loader's documentation describes the difference between implicit and explicit layers, but the relevant bit here is that implicit layers are meant to be available to all applications on the system, even if the application doesn't explicitly enable the layer. On the other hand, explicit layers are easier to use when doing application development.

Explicit Layer

To use CDL as an explicit layer, enable it with vkconfig or do the following:

The directory containing the file VkLayer_crash_diagnostic.json is included in the layer search path, by including it in either the VK_LAYER_PATH or VK_ADD_LAYER_PATH environment variable or by using vkconfig.
Include the layer name in the VK_INSTANCE_LAYERS environment variable or the ppEnabledLayerNames field of VkInstanceCreateInfo.

Implicit Layer

When using CDL as an implicit layer, it is disabled by default. To enable the layer's functionality, set the CDL_ENABLE environment variable to 1.

Registering the Layer

In order to be discovered by the Vulkan loader at runtime, implicit layers must be registered. The registration process is platform-specific and is discussed in detail in the Vulkan-Loader documentation. In all cases, it is the layer manifest (the .json file) that is registered; the manifest contains a relative path to the layer library, which can be in a separate directory.

Basic Usage

Once the layer is enabled, if vkQueueSubmit() or other Vulkan functions returns a fatal error code (usually VK_ERROR_DEVICE_LOST), a dump file of the command buffers (and other state) that failed to execute are written to disk.

Logging

CDL outputs messages at runtime to indicate it is enabled, to trace certain commands, and to report when a gpu crash has occurred. The message_severity, log_file, trace_on and trace_all_semaphores configuration settings control which messages are output and where they are sent.

VK_EXT_debug_utils and VK_EXT_debug_report extensions can also be used to receive log messages directly in the application.

Dump files

A unique log file directory is created every time an application is run with CDL enabled. The log file directories are named with the timestamp of the format YYYY-MM-DD-HHMMSS. This prevents subsequent runs from overwriting old data, in case the application is non-deterministic and producing different crashes on each run. The location of these files is platform-specific:

Linux: ${HOME}/cdl/
Windows: %USERPROFILE%\cdl\
Android: '/sdcard/data/Android//cdl'

The output directory for dump files can be changed using the output_path configuration setting, described below.

The name of the dump file is cdl_dump.yaml, since the file is in the YAML format. Other files, such as dumped shaders, may be present in the dump directory.

Configuration

This layer implements the VK_EXT_layer_settings extension, so it can be configured with vkconfig, programmatically, or with environment variables. See the manifest for this layer and the layer manifest schema for full details. The discussion below uses the key field to identify each setting, the env field defines the corresponding environment variable, and the label field defines the text you will see when using vkconfig.

watchdog_timeout_mscan be set to enable a watchdog thread that monitors the time between queue submissions. If this timeout value (specified in milliseconds) is hit without a queue submission, the gpu is assumed to be crashed and a dump file is created.
Dump files
- output_path can be set to override the directory where log files and shader binaries are written. This can be a full path (starting with / or a drive letter) or a path relative to the application current working directory.
- dump_queue_submissions controls which queue submissions are dumped. running causes only the submission currently executing to be dumped. pending will also dump any submissions that have not started execution.
- dump_command_buffers controls which command buffers are dumped. running causes only the command buffer currently executing to be dumped. pending will also dump any command buffers that have not started execution. all will dump all known command buffers.
- dump_commands controls which commands are dumped. running causes only the commands currently executing to be dumped. pending will also dump any commands that have not started execution. all will dump all commands in the command buffer.
- dump_shaders controls if shaders are included in the dump directory. Possible values for this setting are: off - no output, on_crash - only dump the shaders that are bound at the time of a gpu crash, on_bind - dump shaders only when they are bound, and all - dump all shaders as soon as they are created.
Logging
- message_severity can be set to a comma-separated list of the types of messages CDL should output to the default logger. Application defined loggers should control which messages they want to recieve with the options available in the VK_EXT_debug_utils or VK_EXT_debug_report extensions.
- log_file can be set to control where log messages are sent by the default logger. There are several special values. stderr and stdout send messages to the application console. none disables the default logger. Any other value is assumed to be an absolute or relative path to the log file.
- trace_on can be enabled to cause important commands, such as vkQueueSubmit to be logged as they occur.
- trace_all_semaphores enables logging messages about every vulkan command that uses semaphores.
State tracking
- sync_after_commands adds a pipeline barrier after every instrumented vulkan command. This will reduce performance and may cause some hangs to go away. This option currently only works when using VK_KHR_dynamic_rendering
- instrument_all_commands can be enabled to include completion markers around every vulkan command. This may allow more accuratute fault locations at the expense of larger command buffers and reduced performance.
- track_semaphores enables detailed semaphore state reporting in runtime logging and dump files. VK_AMD_buffer_marker is required for this feature.

Layer Properties

API Version: 1.4.321
Implementation Version: 1
Layer Manifest: VkLayer_crash_diagnostic.json
- File Format: 1.2.0
- Layer Binary: libVkLayer_crash_diagnostic.so
Variables:
- vk_layer_settings.txt namespace: lunarg_crash_diagnostic
- Environment Variable prefix: VK_LUNARG_CRASH_DIAGNOSTIC_
- Android system property prefix: adb setprop debug.vulkan.lunarg_crash_diagnostic.
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, ANDROID
Status: BETA
Number of Layer Settings: 16

Layer Settings Overview

Label	Variables Key	Type	Default Value	Platforms
Watchdog timeout (ms)	`watchdog_timeout_ms`	`INT`	`30000`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Dump files	`dump`	`GROUP`	``	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `ANDROID`
Output Path	`output_path`	`STRING`	``	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Dump queue submissions	`dump_queue_submits`	`ENUM`	`running`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Dump command buffers	`dump_command_buffers`	`ENUM`	`running`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Dump commands	`dump_commands`	`ENUM`	`running`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Dump shaders	`dump_shaders`	`ENUM`	`off`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Logging	`logging`	`GROUP`	``	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `ANDROID`
Message Severity	`message_severity`	`FLAGS`	`error`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Log file name	`log_file`	`STRING`	`stderr`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`
Enable Tracing	`trace_on`	`BOOL`	`false`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Enable semaphore log tracing.	`trace_all_semaphores`	`BOOL`	`false`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
State Tracking	`state`	`GROUP`	``	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `ANDROID`
Synchronize commands	`sync_after_commands`	`BOOL`	`false`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Instrument all commands	`instrument_all_commands`	`BOOL`	`false`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
Track semaphores	`track_semaphores`	`BOOL`	`true`	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`

Layer Settings Details

Watchdog timeout (ms)

If set to a non-zero number, a watchdog thread will be created. This will trigger if the application fails to submit new commands within a set time (in milliseconds) and a log will be created as if the a lost device error was encountered.

Key: watchdog_timeout_ms
Type: INT
Default Value: 30000
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Methods:
`VK_EXT_layer_settings`:	int32_t data[] = { 30000 }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "watchdog_timeout_ms", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.watchdog_timeout_ms = 30000
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_WATCHDOG_TIMEOUT_MS=30000 export VK_CRASH_DIAGNOSTIC_WATCHDOG_TIMEOUT_MS=30000 export VK_WATCHDOG_TIMEOUT_MS=30000 export CDL_WATCHDOG_TIMEOUT_MS=30000
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.watchdog_timeout_ms 30000 adb setprop debug.vulkan.crash_diagnostic.watchdog_timeout_ms 30000 adb setprop debug.vulkan.watchdog_timeout_ms 30000

Dump files

Control of dump files.

Sub-settings: Output Path, Dump queue submissions, Dump command buffers, Dump commands, and Dump shaders.

Key: dump
Type: GROUP
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, ANDROID

Output Path

The directory where dump files and shader binaries are written.

Key: output_path
Type: STRING
Default Value:
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Methods:
`VK_EXT_layer_settings`:	const char* data[] = { "" }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "output_path", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.output_path =
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_OUTPUT_PATH= export VK_CRASH_DIAGNOSTIC_OUTPUT_PATH= export VK_OUTPUT_PATH= export CDL_OUTPUT_PATH=
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.output_path adb setprop debug.vulkan.crash_diagnostic.output_path adb setprop debug.vulkan.output_path

Dump queue submissions

Control which queue submissions are included in the dump.

Key: dump_queue_submits
Type: ENUM
Default Value: running
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Enum Value	Label	Description	Platforms
`running`	Running	Submissions that were executing at the time of the dump.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`pending`	Pending	Submissions executing or pending at the time of the dump.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`

Methods:
`VK_EXT_layer_settings`:	const char* data[] = { "running" }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "dump_queue_submits", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.dump_queue_submits = running
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_DUMP_QUEUE_SUBMITS=running export VK_CRASH_DIAGNOSTIC_DUMP_QUEUE_SUBMITS=running export VK_DUMP_QUEUE_SUBMITS=running export CDL_DUMP_QUEUE_SUBMITS=running
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.dump_queue_submits running adb setprop debug.vulkan.crash_diagnostic.dump_queue_submits running adb setprop debug.vulkan.dump_queue_submits running

Dump command buffers

Control which command buffers are included in the dump.

Key: dump_command_buffers
Type: ENUM
Default Value: running
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Enum Value	Label	Description	Platforms
`running`	Running	Command Buffers that were executing at the time of the dump.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`pending`	Pending	Command Buffers executing or pending at the time of the dump.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`all`	All	All known Command Buffers.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`

Methods:
`VK_EXT_layer_settings`:	const char* data[] = { "running" }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "dump_command_buffers", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.dump_command_buffers = running
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_DUMP_COMMAND_BUFFERS=running export VK_CRASH_DIAGNOSTIC_DUMP_COMMAND_BUFFERS=running export VK_DUMP_COMMAND_BUFFERS=running export CDL_DUMP_COMMAND_BUFFERS=running
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.dump_command_buffers running adb setprop debug.vulkan.crash_diagnostic.dump_command_buffers running adb setprop debug.vulkan.dump_command_buffers running

Dump commands

Control which commands are included in the dump.

Key: dump_commands
Type: ENUM
Default Value: running
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Enum Value	Label	Description	Platforms
`running`	Running	Command Buffers that were executing at the time of the dump.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`pending`	Pending	Commands executing or pending at the time of the dump.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`all`	All	All known Commands.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`

Methods:
`VK_EXT_layer_settings`:	const char* data[] = { "running" }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "dump_commands", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.dump_commands = running
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_DUMP_COMMANDS=running export VK_CRASH_DIAGNOSTIC_DUMP_COMMANDS=running export VK_DUMP_COMMANDS=running export CDL_DUMP_COMMANDS=running
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.dump_commands running adb setprop debug.vulkan.crash_diagnostic.dump_commands running adb setprop debug.vulkan.dump_commands running

Dump shaders

Control of shader dumping.

Key: dump_shaders
Type: ENUM
Default Value: off
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Enum Value	Label	Description	Platforms
`off`	Off	Never dump shaders.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`on_crash`	On Crash	Dump currently bound shaders after a crash is detected.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`on_bind`	On Bind	Dump only bound shaders.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`all`	All	Dump all shaders.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`

Methods:
`VK_EXT_layer_settings`:	const char* data[] = { "off" }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "dump_shaders", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.dump_shaders = off
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_DUMP_SHADERS=off export VK_CRASH_DIAGNOSTIC_DUMP_SHADERS=off export VK_DUMP_SHADERS=off export CDL_DUMP_SHADERS=off
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.dump_shaders off adb setprop debug.vulkan.crash_diagnostic.dump_shaders off adb setprop debug.vulkan.dump_shaders off

Logging

Control of logging.

Sub-settings: Message Severity, Log file name, Enable Tracing, and Enable semaphore log tracing..

Key: logging
Type: GROUP
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, ANDROID

Message Severity

Comma-delineated list of options specifying the types of log messages to be reported.

Key: message_severity
Type: FLAGS
Default Value: error
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Flags	Label	Description	Platforms
`error`	Error	Report errors such as device lost or setup problems in the layer.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`warn`	Warning	Report non-fatal problems that may interfere with operation of the layer	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`
`info`	Info	Report informational messages.	`WINDOWS_X86`, `WINDOWS_ARM`, `LINUX`, `MACOS`, `ANDROID`

Methods:
`VK_EXT_layer_settings`:	const char* data[] = { "error" }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "message_severity", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.message_severity = error
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_MESSAGE_SEVERITY=error export VK_CRASH_DIAGNOSTIC_MESSAGE_SEVERITY=error export VK_MESSAGE_SEVERITY=error
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.message_severity error adb setprop debug.vulkan.crash_diagnostic.message_severity error adb setprop debug.vulkan.message_severity error

Log file name

none = no logging, stderr or stdout = to the console, otherwise an absolute or relative path.

Key: log_file
Type: STRING
Default Value: stderr
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS

Methods:

Methods:
`VK_EXT_layer_settings`:	const char* data[] = { "stderr" }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "log_file", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.log_file = stderr
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_LOG_FILE=stderr export VK_CRASH_DIAGNOSTIC_LOG_FILE=stderr export VK_LOG_FILE=stderr export CDL_LOG_FILE=stderr

VK_EXT_layer_settings:

const char* data[] = { "stderr" };
VkLayerSettingEXT setting {
 "VK_LAYER_LUNARG_crash_diagnostic", "log_file", VK_LAYER_SETTING_TYPE_STRING_EXT,
 static_cast<uint32_t>(std::size(data)), data };

vk_layer_settings.txt:

lunarg_crash_diagnostic.log_file = stderr

Environment variables:

export VK_LUNARG_CRASH_DIAGNOSTIC_LOG_FILE=stderr
export VK_CRASH_DIAGNOSTIC_LOG_FILE=stderr
export VK_LOG_FILE=stderr
export CDL_LOG_FILE=stderr

Enable Tracing

All Vulkan API calls intercepted by the layer will be logged to the console.

Key: trace_on
Type: BOOL
Default Value: false
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Methods:
`VK_EXT_layer_settings`:	VkBool32 data[] = { VK_FALSE }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "trace_on", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.trace_on = false
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_TRACE_ON=false export VK_CRASH_DIAGNOSTIC_TRACE_ON=false export VK_TRACE_ON=false export CDL_TRACE_ON=false
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.trace_on false adb setprop debug.vulkan.crash_diagnostic.trace_on false adb setprop debug.vulkan.trace_on false

Enable semaphore log tracing.

Semaphore events will be logged to console.

Key: trace_all_semaphores
Type: BOOL
Default Value: false
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Methods:
`VK_EXT_layer_settings`:	VkBool32 data[] = { VK_FALSE }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "trace_all_semaphores", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.trace_all_semaphores = false
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_TRACE_ALL_SEMAPHORES=false export VK_CRASH_DIAGNOSTIC_TRACE_ALL_SEMAPHORES=false export VK_TRACE_ALL_SEMAPHORES=false export CDL_TRACE_ALL_SEMAPHORES=false
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.trace_all_semaphores false adb setprop debug.vulkan.crash_diagnostic.trace_all_semaphores false adb setprop debug.vulkan.trace_all_semaphores false

State Tracking

Control of state tracking.

Sub-settings: Synchronize commands, Instrument all commands, and Track semaphores.

Key: state
Type: GROUP
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, ANDROID

Synchronize commands

Add pipeline barriers after instrumented commands.

Key: sync_after_commands
Type: BOOL
Default Value: false
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Methods:
`VK_EXT_layer_settings`:	VkBool32 data[] = { VK_FALSE }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "sync_after_commands", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.sync_after_commands = false
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_SYNC_AFTER_COMMANDS=false export VK_CRASH_DIAGNOSTIC_SYNC_AFTER_COMMANDS=false export VK_SYNC_AFTER_COMMANDS=false export CDL_SYNC_AFTER_COMMANDS=false
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.sync_after_commands false adb setprop debug.vulkan.crash_diagnostic.sync_after_commands false adb setprop debug.vulkan.sync_after_commands false

Instrument all commands

All commands will be instrumented.

Key: instrument_all_commands
Type: BOOL
Default Value: false
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Methods:
`VK_EXT_layer_settings`:	VkBool32 data[] = { VK_FALSE }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "instrument_all_commands", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.instrument_all_commands = false
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_INSTRUMENT_ALL_COMMANDS=false export VK_CRASH_DIAGNOSTIC_INSTRUMENT_ALL_COMMANDS=false export VK_INSTRUMENT_ALL_COMMANDS=false export CDL_INSTRUMENT_ALL_COMMANDS=false
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.instrument_all_commands false adb setprop debug.vulkan.crash_diagnostic.instrument_all_commands false adb setprop debug.vulkan.instrument_all_commands false

Track semaphores

Enable semaphore tracking.

Key: track_semaphores
Type: BOOL
Default Value: true
Platforms: WINDOWS_X86, WINDOWS_ARM, LINUX, MACOS, ANDROID

Methods:
`VK_EXT_layer_settings`:	VkBool32 data[] = { VK_TRUE }; VkLayerSettingEXT setting { "VK_LAYER_LUNARG_crash_diagnostic", "track_semaphores", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(std::size(data)), data };
`vk_layer_settings.txt`:	lunarg_crash_diagnostic.track_semaphores = true
Environment variables:	export VK_LUNARG_CRASH_DIAGNOSTIC_TRACK_SEMAPHORES=true export VK_CRASH_DIAGNOSTIC_TRACK_SEMAPHORES=true export VK_TRACK_SEMAPHORES=true export CDL_TRACK_SEMAPHORES=true
Android system properties:	adb setprop debug.vulkan.lunarg_crash_diagnostic.track_semaphores true adb setprop debug.vulkan.crash_diagnostic.track_semaphores true adb setprop debug.vulkan.track_semaphores true