CUDA-MEMCHECK is a functional correctness checking suite included in the CUDA toolkit. This suite contains multiple tools that can perform different types of checks. The memcheck tool is capable of precisely detecting and attributing out of bounds and misaligned memory access errors in CUDA applications. The tool also reports hardware exceptions encountered by the GPU. The racecheck tool can report shared memory data access hazards that can cause data races. The initcheck tool can report cases where the GPU performs uninitialized accesses to global memory. The synccheck tool can report cases where the application is attempting invalid usages of synchronization primitives. This document describes the usage of these tools.

CUDA-MEMCHECK can be run in standalone mode where the user's application is started under CUDA-MEMCHECK. The memcheck tool can also be enabled in integrated mode inside CUDA-GDB.

CUDA-MEMCHECK is installed as part of the CUDA toolkit.

Command line options can be specified to cuda-memcheck. With some exceptions, the options to memcheck are usually of the form --option value. The option list can be terminated by specifying --. All subsequent words on the command line are treated as the application being run and its arguments.

The table below describes the supported options in detail. The first column is the option name as passed to CUDA-MEMCHECK. Some options have a one character short form, which is given in parentheses. These options can be invoked using a single hyphen. For example, the help option can be invoked as -h. The options that have a short form do not take a value.

The second column contains the permissible values for the option. In case the value is user defined, this is shown below in braces {}. An option that can accept any numerical value is represented as {number} .

The third column contains the default value of the option. Some options have different default values depending on the architecture they are being run on.

The standalone CUDA-MEMCHECK binary is supported on all CUDA supported platforms i.e. Windows, Mac OS X, supported Linux distributions and Android. CUDA-MEMCHECK can interoperate with CUDA-GDB on Android, Linux and Mac OS X.

The CUDA-MEMCHECK tool suite is supported on all CUDA capable GPUs with SM versions 3.0 and above. Individual tools may support a different subset of GPUs. The table below contains the list of current tools and their supported GPUs

The CUDA-MEMCHECK tools do not need any special compilation flags to function.

The output displayed by the CUDA-MEMCHECK tools is more useful with some extra compiler flags. The -G option to nvcc forces the compiler to generate debug information for the CUDA application. To generate line number information for applications without affecting the optimization level of the output, the -lineinfo option to nvcc can be used. The CUDA-MEMCHECK tools fully support both of these options and can display source attribution of errors for applications compiled with line information.

The stack backtrace feature of the CUDA-MEMCHECK tools is more useful when the application contains function symbol names. For the host backtrace, this varies based on the host OS. On Linux, the host compiler must be given the -rdynamic option to retain function symbols. On Windows, the application must be compiled for debugging, i.e. the /Zi option. When using nvcc, flags to the host compiler can be specified using the -Xcompiler option. For the device backtrace, the full frame information is only available when the application is compiled with device debug information. The compiler can skip generation of frame information when building with optimizations.

nvcc -Xcompiler -rdynamic -lineinfo  -o out in.cu

The memcheck tool is a run time error detection tool for CUDA applications. The tool can precisely detect and report out of bounds and misaligned memory accesses to global, local, shared and global atomic instructions in CUDA applications. It can also detect and report hardware reported error information. In addition, the memcheck tool can detect and report memory leaks in the user application.

The errors that can be reported by the memcheck tool are summarized in the table below. The location column indicates whether the report originates from the host or from the device. The precision of an error is explained in the paragraph below.

The memcheck tool reports two classes of errors precise and imprecise.

Precise errors in memcheck are those that the tool can uniquely identify and gather all information for. For these errors, memcheck can report the block and thread coordinates of the thread causing the failure, the program counter (PC) of the instruction performing the access, as well as the address being accessed and its size and type. If the CUDA application contains line number information (by either being compiled with device side debugging information, or with line information), then the tool will also print the source file and line number of the erroneous access.

Imprecise errors are errors reported by the hardware error reporting mechanism that could not be precisely attributed to a particular thread. The precision of the error varies based on the type of the error and in many cases, memcheck may not be able to attribute the cause of the error back to the source file and line.

cuda-memcheck [memcheck_options] app_name [app_options]

When run in this way, the memcheck tool will look for precise, imprecise, malloc/free and CUDA API errors. The reporting of device leaks must be explictly enabled. Errors identified by the memcheck tool are displayed on the screen after the application has completed execution. See Understanding Memcheck Errors for more information about how to interpret the messages printed by the tool.

The memcheck tool can produce a variety of different errors. This is a short guide showing some samples of errors and explaining how the information in each error report can be interpreted.

1. Memory access error: Memory access errors are generated for errors that the memcheck tool can correctly attribute and identify the erroneous instruction. Below is an example of a precise memory access error

   ========= Invalid __global__ write of size 4
   =========     at 0x00000060 in memcheck_demo.cu:6:unaligned_kernel(void)
   =========     by thread (0,0,0) in block (0,0,0)
   =========     Address 0x400100001 is misaligned
   

   Let us examine this error line by line :

   Invalid __global__ write of size 4

   The first line shows the memory segment, type and size being accessed. The memory segment is one of :

   • __global__ : for device global memory
   • __shared__ : for per block shared memory
   • __local__ : for per thread local memory

   In this case, the access was to device global memory. The next field contains information about the type of access, whether it was a read or a write. In this case, the access is a write. Finally, the last item is the size of the access in bytes. In this example, the access was 4 bytes in size.

   at 0x00000060 in memcheck_demo.cu:6:unaligned_kernel(void)

   The second line contains the PC of the instruction, the source file and line number (if available) and the CUDA kernel name. In this example, the instruction causing the access was at PC 0x60 inside the unaligned_kernel CUDA kernel. Additionally, since the application was compiled with line number information, this instruction corresponds to line 6 in the memcheck_demo.cu source file.

   by thread (0,0,0) in block (0,0,0)

   The third line contains the thread indices and block indices of the thread on which the error was hit. In this example, the thread doing the erroneous access belonged to the first thread in the first block.

   Address 0x400100001 is misaligned

   The fourth line contains the memory address being accessed and the type of of access error. The type of access error can either be out of bounds access or misaligned access. In this example, the access was to address 0x400100001 and the access error was because this address was not aligned correctly.

2. Hardware exception: Imprecise errors are generated for errors that the hardware reports to the memcheck tool. Hardware exceptions have a variety of formats and messages. Typically, the first line will provide some information about the type of error encountered.

3. Malloc/free error: Malloc/free errors refer to the errors in the invocation of device side malloc()/free() in CUDA kernels. An example of a malloc/free error :

   ========= Malloc/Free error encountered : Double free
   =========     at 0x000079d8
   =========     by thread (0,0,0) in block (0,0,0)
   =========     Address 0x400aff920
   

   We can examine this line by line.

   Malloc/Free error encountered : Double free

   The first line indicates that this is a malloc/free error, and contains the type of error. This type can be :

   • Double free : This indicates that the thread called free() on an allocation that has already been freed.
   • Invalid pointer to free : This indicates that free was called on a pointer that was not returned by malloc()
   • Heap corruption : This indicates generalized heap corruption, or cases where the state of the heap was modified in a way that memcheck did not expect

   In this example, the error is due to calling free() on a pointer which had already been freed.

   at 0x000079d8

   The second line gives the PC on GPU where the error was reported. This PC is usually inside of system code, and is not interesting to the user. The device frame backtrace will contain the location in user code where the malloc()/free() call was made.

   by thread (0,0,0) in block (0,0,0)

   The third line contains the thread and block indices of the thread that caused this error. In this example, the thread has threadIdx = (0,0,0) and blockIdx = (0,0,0)

   Address 0x400aff920

   This line contains the value of the pointer passed to free() or returned by malloc()

4. Leak errors: Errors are reported for allocations created using cudaMalloc and for allocations on the device heap that were not freed when the CUDA context was destroyed. An example of a cudaMalloc allocation leak report follows :

   ========= Leaked 64 bytes at 0x400200200
   

   The error message reports information about the size of the allocation that was leaked as well as the address of the allocation on the device.
   A device heap leak message will be explicitly identified as such:

   ========= Leaked 16 bytes at 0x4012ffff6 on the device heap
   

5. CUDA API error: CUDA API errors are reported for CUDA API calls that return an error value. An example of a CUDA API error:

   ========= Program hit error 11 on CUDA API call to cudaMemset
   

   The message contains the returned value of the CUDA API call, as well as the name of the API function that was called.

(cuda-gdb) set cuda memcheck on

In integrated mode, the memcheck tool improves the precision of error reporting by CUDA-GDB. The memory access checks are enabled, allowing identification of the thread that may be causing a warp or device level exception.

The memcheck tool supports reporting an error if a CUDA API call made by the user program returned an error. The tool supports this detection for both CUDA run time and CUDA driver API calls. In all cases, if the API function call has a nonzero return value, CUDA-MEMCHECK will print an error message containing the name of the API call that failed and the return value of the API call.

CUDA API error reports do not terminate the application, they merely provide extra information. It is up to the application to check the return status of CUDA API calls and handle error conditions appropriately.

The memcheck tool checks accesses to allocations in the device heap.

These allocations are created by calling malloc() inside a kernel. This feature is implicitly enabled and can be disabled by specifying the --check-device-heap no option. This feature is only activated for kernels in the application that call malloc().

The current implementation does not require space on the device heap, and so the heap allocation behavior of the program with and without memcheck should remain similar. The memcheck tool does require space in device global memory to track these heap allocations and will print an internal error message if it is not able to allocate this space in device global memory.

The memcheck tool can detect leaks of allocated memory.

Memory leaks are device side allocations that have not been freed by the time the context is destroyed. The memcheck tool tracks device memory allocations created using the CUDA driver or runtime APIs. Starting in CUDA 5, allocations that are created dynamically on the device heap by calling malloc() inside a kernel are also tracked.

For an accurate leak checking summary to be generated, the application's CUDA context must be destroyed at the end. This can be done explicitly by calling cuCtxDestroy() in applications using the CUDA driver API, or by calling cudaDeviceReset() in applications programmed against the CUDA run time API.

The --leak-check full option must be specified to enable leak checking.

The racecheck tool is a run time shared memory data access hazard detector. The primary use of this tool is to help identify memory access race conditions in CUDA applications that use shared memory.

In CUDA applications, storage declared with the __shared__ qualifier is placed in on chip shared memory. All threads in a thread block can access this per block shared memory. Shared memory goes out of scope when the thread block completes execution. As shared memory is on chip, it is frequently used for inter thread communication and as a temporary buffer to hold data being processed. As this data is being accessed by multiple threads in parallel, incorrect program assumptions may result in data races. Racecheck is a tool built to identify these hazards and help users write programs free of shared memory races.

Currently, this tool only supports detecting accesses to on-chip shared memory. For supported architectures, see Supported Devices.

A data access hazard is a case where two threads attempt to access the same location in memory resulting in nondeterministic behavior, based on the relative order of the two accesses. These hazards cause data races where the behavior or the output of the application depends on the order in which all parallel threads are executed by the hardware. Race conditions manifest as intermittent application failures or as failures when attempting to run a working application on a different GPU.

cuda-memcheck --tool racecheck [memcheck_options] app_name [app_options]

Once racecheck has identified a hazard, the user can make program modifications to ensure this hazard is no longer present. In the case of Write-After-Write hazards, the program should be modified so that multiple writes are not happening to the same location. In the case of Read-After-Write and Write-After-Read hazards, the reading and writing locations should be deterministically ordered. In CUDA kernels, this can be achieved by inserting a __syncthreads() call between the two accesses. To avoid races between threads within a single warp, __syncwarp() can be used.

In analysis reports, the racecheck tool produces a series of high level messages that identify the source locations of a particular race, based on observed hazards and other machine state

========= ERROR: Race reported between Write access at 0x00000050 in raceGroupBasic.cu:53:WAW(void)
=========     and Write access at 0x00000050 in raceGroupBasic.cu:53:WAW(void)

The analysis record contains high level information about the hazard that is conveyed to the end user. Each line contains information about a unique location in the application which is participating in the race.

The first word on the first line indicates the severity of this report. In this case, the message is at the ERROR level of severity. For more information on the different severity levels, see Racecheck Severity Levels. Analysis reports are composed of one or more racecheck hazards, and the severity level of the report is that of the hazard with the highest severity.

A given analysis report will always contain at least one line which is performing a write access. A common strategy to eliminate races which contain only write accesses is to ensure that the write access is performed by only one thread. In the case of races with multiple readers and one writer, introducing explicit program ordering via a __syncthreads() call can avoid the race condition. For races between threads within the same warp, the __syncwarp() intrinsic can be used to avoid the hazard.

In hazard reporting mode, the racecheck tool produces a series of messages detailing information about hazards in the application. The tool is byte accurate and produces a message for each byte on which a hazard was detected. Additionally, when enabled, the host backtrace for the launch of the kernel will also be displayed.

========= ERROR: Potential WAW hazard detected at __shared__ 0x0 in block (0, 0, 0) :
=========     Write Thread (0, 0, 0) at 0x00000088 in raceWAW.cu:18:WAW(void)
=========     Write Thread (1, 0, 0) at 0x00000088 in raceWAW.cu:18:WAW(void)
=========     Current Value : 0, Incoming Value : 2

The hazard records are dense and capture a lot of interesting information. In general terms, the first line contains information about the hazard severity, type and address, as well as information about the thread block where it occurred. The next 2 lines contain detailed information about the two threads that were in contention. These two lines are ordered chronologically, so the first entry is for the access that occurred earlier and the second for the access that occurred later. The final line is printed for some hazard types and captures the actual data that was being written.

ERROR: Potential WAW hazard detected at __shared__ 0x0 in block (0, 0, 0)

The first word on this line indicates the severity of this hazard. In this case, the message is at the ERROR level of severity. For more information on the different severity levels, see Racecheck Severity Levels.

The next piece of information is the address in shared memory that was being accessed. This is the offset in per block shared memory that was being accessed by both threads. Since the racecheck tool is byte accurate, the message is only for the byte of memory at given address. In this example, the byte being accessed is byte 0x0 in shared memory.

Finally, the first line contains the block index of the thread block to which the two racing threads belong.

Write Thread (0, 0, 0) at 0x00000088 in raceWAW.cu:18:WAW(void)

The third line contains similar information about the second thread which was causing this hazard. This line has an identical format to the previous line.

Current Value : 0, Incoming Value : 2

Problems reported by racecheck can be of different severity levels. Depending on the level, different actions are required from developers. By default, only issues of severity level WARNING and ERROR are shown. The command line option --print-level can be used to set the lowest severity level that should be reprted.

The initcheck tool is a run time uninitialized device global memory access detector. This tool can identify when device global memory is accessed without it being initialized via device side writes, or via CUDA memcpy and memset API calls.

Currently, this tool only supports detecting accesses to device global memory. For supported architectures, see Supported Devices.

The synccheck tool is a runtime tool that can identify whether a CUDA application is correctly using synchronization primitives, specifically __syncthreads() and __syncwarp() intrinsics and their Cooperative Groups API counterparts.

For supported architectures, see Supported Devices.

For each violation, the synccheck tool produces a report message that identifies the source location of the violation and its classification.

========= Barrier error detected. Divergent thread(s) in block
=========     at 0x00000130 in divergence.cu:61:threadDivergence(int*)
=========     by thread (37,0,0) in block (0,0,0)
=========
========= ERROR SUMMARY: 1 error

The next line states the PC of the location where the access happened. In this case, the PC is 0x130. If the application was compiled with line number information, this line would also contain the file name and line number of the access, followed by the name of the kernel issuing the access.

The third line contains information on the thread and block for which this violation was detected. In this case, it is thread 37 in block 0.

By default, the standalone CUDA-MEMCHECK tool will launch kernels in nonblocking mode. This allows the tool to support error reporting in applications running concurrent kernels

To force kernels to execute serially, a user can use the --force-blocking-launches yes option. One side effect is that when in blocking mode, only the first thread to hit an error in a kernel will be reported.

In standalone mode, CUDA-MEMCHECK can generate backtraces when given --show-backtrace option. Backtraces usually consist of two sections - a saved host backtrace that leads upto the CUDA driver call site, and a device backtrace at the time of the error. Each backtrace contains a list of frames showing the state of the stack at the time the backtrace was created.

To get function names in the host backtraces, the user application must be built with support for symbol information in the host application. For more information, see Compilation Options

=========     Device Frame:<1 frames were hidden>
           

Backtraces are printed for most CUDA-MEMCHECK tool outputs, and the information generated varies depending on the type of output. The table below explains the kind of host and device backtrace seen under different conditions.

The CUDA-MEMCHECK suite now supports displaying mangled and demangled names for CUDA kernels and CUDA device functions. By default, tools display the fully demangled name, which contains the name of the kernel as well as its prototype information. In the simple demangle mode, the tools will only display the first part of the name. If demangling is disabled, tools will display the complete mangled name of the kernel.

The CUDA-MEMCHECK tool suite supports dynamic parallelism. The memcheck tool supports precise error reporting of out of bounds and misaligned accesses on global, local and shared memory accesses as well as on global atomic instructions for applications using dynamic parallelism. In addition, the imprecise hardware exception reporting mechanism is also fully supported. Error detection on applications using dynamic parallelism requires significantly more memory on the device and as a result, in memory constrained environments, memcheck may fail to initialize with an internal out of memory error.

For limitations, see Known Issues.

On encountering an error, CUDA-MEMCHECK behavior depends on the type of error. The default behavior of CUDA-MEMCHECK is to continue execution on purely host side errors. Hardware exceptions detected by the memcheck tool cause the CUDA context to be destroyed. Precise errors (such as memory access and malloc/free errors) detected by the memcheck tool cause the kernel to be terminated. This terminates the kernel without running any subsequent instructions and the application continues launching other kernels in the CUDA context. The handling of memory access and malloc/free errors detected by the memcheck tool can be changed using the --destroy-on-device-error option.

For racecheck detected hazards, the hazard is reported, but execution is not affected.

CUDA-MEMCHECK tools support filtering the choice of kernels which should be checked. When a filter is specified, only kernels matching the filter will be checked. Filters are specified using the --filter option. By default, CUDA-MEMCHECK tools will check all kernels in the application.

The --filter option can be specified multiple times. If a kernel satisfies any filter, it will be checked by the running CUDA-MEMCHECK tool.

The --filter takes a filter specification consisting of a list of comma separated key value pairs, specified as key=value. In order for a filter to be matched, all components of the filter specification must be satisfied. If a filter is incorrectly specified in any component, the entire filter is ignored. For a full summary of valid key values, see the table below. If a key has multiple strings, any of the strings can be used to specify that filter component.

When using the kernel_name or kernel_substring filters, CUDA-MEMCHECK tools will check all device function calls made by the kernel. When using CUDA Dynamic Parallelism (CDP), CUDA-MEMCHECK tools will not check child kernels launched from a checked kernel unless the child kernel matches a filter. If a GPU launched kernel that does not match a filter calls a device function that is reachable from a kernel that does match a filter, the device function will behave as though it was checked. In the case of some tools, this can result in undefined behavior.

• Timeout Detection and Recovery (TDR)

  On Windows Vista and above, GPUs have a timeout associated with them. GPU applications that take longer than the threshold (default of 2 seconds) will be killed by the operating system. Since CUDA-MEMCHECK tools increase the runtime of kernels, it is possible for a CUDA kernel to exceed the timeout and therefore be terminated due to the TDR mechanism.

  For the purposes of debugging, the number of seconds before which the timeout is hit can be modified by setting the the timeout value in seconds in the DWORD registry key TdrDelay at HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\GraphicsDrivers

  More information about the registry keys to control the Timeout Detection and Recovery mechanism is available from MSDN at http://msdn.microsoft.com/en-us/library/windows/hardware/ff569918%28v=vs.85%29.aspx

• TMPDIR environment variable

  On Android, CUDA-MEMCHECK requires that the user specify a path to a directory that is readable and writable by the current user in the TMPDIR environment variable

• Host stack backtraces

  Host side function call stack backtraces are disabled on Android.

• Andoid GUI

  To ensure the GPU kernel is not terminated unexpectedly, the Android UI can be stopped by using the "stop" command in the adb shell.

• CUDA-MEMCHECK tool cannot be used with APK binaries.

• By default, error reports printed by CUDA-MEMCHECK contain 0-based C style values for thread index (threadIdx) and block index (blockIdx). For CUDA-MEMCHECK tools to use Fortran style 1-based offsets, use the --language fortran option.
• The CUDA Fortran compiler may insert extra padding in shared memory. Accesses hitting this extra padding may not be reported as an error.

This example shows how to enable CUDA-MEMCHECK from within CUDA-GDB and how to detect errors within the debugger so you can access the line number information and check the state of the variables

In this example the unaligned kernel has a misaligned memory access in block 1 lane 1, which gets trapped as an illegal lane address at line 6 from within CUDA-GDB. Note that CUDA-GDB displays the address and that caused the bad access.

(cuda-gdb) set cuda memcheck on
(cuda-gdb) run
Starting program: memcheck_demo 
[Thread debugging using libthread_db enabled]
Mallocing memory
[New Thread 0x7ffff6fe1710 (LWP 7783)]
[Context Create of context 0x6218a0 on Device 0]
[Launch of CUDA Kernel 0 (memset32_post<<<(1,1,1),(64,1,1)>>>) on Device 0]
Running unaligned_kernel
[Launch of CUDA Kernel 1 (unaligned_kernel<<<(1,1,1),(1,1,1)>>>) on Device 0]
Memcheck detected an illegal access to address (@global)0x400100001

Program received signal CUDA_EXCEPTION_1, Lane Illegal Address.
[Switching focus to CUDA kernel 1, grid 2, block (0,0,0), thread (0,0,0), device 0, sm 0, warp 0, lane 0]
0x000000000078b8b0 in unaligned_kernel<<<(1,1,1),(1,1,1)>>> () at memcheck_demo.cu:6
6           *(int*) ((char*)&x + 1) = 42;
(cuda-gdb) print &x
$1 = (@global int *) 0x400100000
(cuda-gdb) continue
Continuing.
[Termination of CUDA Kernel 1 (unaligned_kernel<<<(1,1,1),(1,1,1)>>>) on Device 0]
[Termination of CUDA Kernel 0 (memset32_post<<<(1,1,1),(64,1,1)>>>) on Device 0]

Program terminated with signal CUDA_EXCEPTION_1, Lane Illegal Address.
The program no longer exists.
(cuda-gdb)

• Support for host API functions with pitch parameter. For more information see Initcheck Tool.
• Initial support for the Cooperative Groups programming model.
• Support for shared memory atomic instructions. For more information see Memcheck Tool.
• Support for detecting invalid accesses to global memory on Pascal and later architectures that extend beyond the end of an allocation. For more information see Memcheck Tool.
• Support for limiting the numbers of errors printed by cuda-memcheck. For more information see Command Line Options.
• Racecheck analysis reports are assigned a severity level. For more information see Understanding Racecheck Analysis Reports.
• Default print level changed from INFO to WARN. For more information see Command Line Options.
• Support for SM 7.x

• Support for non-migratable system-scoped atomics checking on SM 6.x. For more information see Memcheck Tool.
• Support for reporting fatal CPU-side faults when Unified Memory is enabled. For more information see Memcheck Tool.
• Support for correctly determining the expected set of threads at a barrier in the presence of exited threads in Synccheck Tool.
• Support for SM 6.x

• Support for uninitialized global memory access checking. For more information see Initcheck Tool.
• Support for divergent block synchronization checking. For more information see Synccheck Tool.
• Support for SM 5.2

• More information printed for API errors
• Support for escape sequences in file name to --log-file and --save.
• Support for controlling which kernels are checked using --filter. For more information see Specifying Filters.

• Support for Unified Memory
• Support for CUDA Multi Process Service (MPS)
• Support for additional error detection with cudaMemcpy and cudaMemset

• Analysis mode in racecheck tool. For more information, see Racecheck Tool
• Support for racecheck on SM 3.5 GPUs.

• Reporting of data access hazards in shared memory accesses. This is supported on Fermi SM 2.x and Kepler SM 3.0 GPUs. This functionality is not supported on Windows XP. For more information, see Racecheck Tool.
• Support for SM 3.0 and SM 3.5 GPUs. For more information, see Supported Devices.
• Support for dynamic parallelism. All memory access error detection is supported for applications using dynamic parallelism. For more information, see Dynamic Parallelism.
• Precise error detection for local loads/stores, shared loads/stores, global atomics/reductions. On SM 3.5, added precise memory access error detection for noncoherent global loads through the texture unit. For more information, see Memory Access Error Reporting.
• Error detection in device side malloc()/free(), such as double free() or invalid free() on the GPU. For more information, see Device Side Allocation Checking.
• Leak checking for allocations on the device heap. For more information, see Leak Checking.
• Display of a saved stack backtrace on the host and captured backtrace on the device for different errors. For more information, see Stack Backtraces.
• Reporting of CUDA API errors in the user's application. For more information, see CUDA API Error Checking.
• Added display of mangled, demangled, and full prototype of the kernel. For more information, see Name Demangling.
• Increased functionality in integrated mode with CUDA-GDB. Added reporting of the address and address space being accessed that caused a precise exception. Added checking of device side malloc() and free() when in integrated mode. For more information, see Integrated Mode.
• Support for applications compiled separately that use the device side linker.
• Support for applications compiled with the -lineinfo flag.
• New style of command line options. For more information, see Command Line Options.
• Changed default behavior. CUDA-MEMCHECK will display backtraces by default and will report API errors by default. For more information, see Command Line Options.