EIC code displayed by LXR master/​include/​nvtx3/​nvToolsExt.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:45:13

 /*
  * SPDX-FileCopyrightText: Copyright (c) 2009-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  * Licensed under the Apache License v2.0 with LLVM Exceptions.
  * See https://nvidia.github.io/NVTX/LICENSE.txt for license information.
  */
 
 /** \file nvToolsExt.h
  */
 
 /* ========================================================================= */
 /** \mainpage
  * \tableofcontents
  * \section INTRODUCTION Introduction
  *
  * The NVIDIA Tools Extension library is a set of functions that a
  * developer can use to provide additional information to tools.
  * The additional information is used by the tool to improve
  * analysis and visualization of data.
  *
  * The library introduces close to zero overhead if no tool is
  * attached to the application.  The overhead when a tool is
  * attached is specific to the tool.
  *
  * \section INITIALIZATION Initialization
  *
  * Typically the tool's library that plugs into NVTX is indirectly
  * loaded via environmental properties that are platform specific.
  * For some platform or special cases, the user may be required
  * to instead explicitly initialize instead though.   This can also
  * be helpful to control when the API loads a tool's library instead
  * of what would typically be the first function call to emit info.
  * For these rare case, see \ref INITIALIZATION for additional information.
  *
  * \section MARKERS_AND_RANGES Markers and Ranges
  *
  * Markers and ranges are used to describe events at a specific time (markers)
  * or over a time span (ranges) during the execution of the application
  * respectively.
  *
  * \subsection MARKERS Markers
  *
  * Markers denote specific moments in time.
  *
  *
  * See \ref DOMAINS and \ref EVENT_ATTRIBUTES for additional information on
  * how to specify the domain.
  *
  * \subsection THREAD_RANGES Thread Ranges
  *
  * Thread ranges denote nested time ranges. Nesting is maintained per thread
  * per domain and does not require any additional correlation mechanism. The
  * duration of a thread range is defined by the corresponding pair of
  * nvtxRangePush* to nvtxRangePop API calls.
  *
  * See \ref DOMAINS and \ref EVENT_ATTRIBUTES for additional information on
  * how to specify the domain.
  *
  * \subsection PROCESS_RANGES Process Ranges
  *
  * Process ranges denote a time span that can expose arbitrary concurrency, as
  * opposed to thread ranges that only support nesting. In addition the range
  * start event can happen on a different thread than the end marker. For the
  * correlation of a start/end pair an unique correlation ID is used that is
  * returned from the start API call and needs to be passed into the end API
  * call.
  *
  * \subsection EVENT_ATTRIBUTES Event Attributes
  *
  * \ref MARKERS_AND_RANGES can be annotated with various attributes to provide
  * additional information for an event or to guide the tool's visualization of
  * the data. Each of the attributes is optional and if left unused the
  * attributes fall back to a default value. The attributes include:
  * - color
  * - category
  *
  * To specify any attribute other than the text message, the \ref
  * EVENT_ATTRIBUTE_STRUCTURE "Event Attribute Structure" must be used.
  *
  * \section DOMAINS Domains
  *
  * Domains enable developers to scope annotations. By default all events and
  * annotations are in the default domain. Additional domains can be registered.
  * This allows developers to scope markers, ranges, and resources names to
  * avoid conflicts.
  *
  * The function ::nvtxDomainCreateA or ::nvtxDomainCreateW is used to create
  * a named domain.
  *
  * Each domain maintains its own
  * - categories
  * - thread range stacks
  * - registered strings
  *
  * The function ::nvtxDomainDestroy marks the end of the domain. Destroying
  * a domain unregisters and destroys all objects associated with it such as
  * registered strings, resource objects, named categories, and started ranges.
  *
  * \section RESOURCE_NAMING Resource Naming
  *
  * This section covers calls that allow to annotate objects with user-provided
  * names in order to allow for a better analysis of complex trace data. All of
  * the functions take the handle or the ID of the object to name and the name.
  * The functions can be called multiple times during the execution of an
  * application, however, in that case it is implementation dependent which
  * name will be reported by the tool.
  *
  * \subsection CATEGORY_NAMING Category Naming
  *
  * Some function in this library support associating an integer category
  * to enable filtering and sorting.  The category naming functions allow
  * the application to associate a user friendly name with the integer
  * category.  Support for domains have been added in NVTX_VERSION_2 to
  * avoid collisions when domains are developed independently.
  *
  * \subsection RESOURCE_OBJECTS Resource Objects
  *
  * Resource objects are a generic mechanism for attaching data to an application
  * resource.  The identifier field makes the association to a pointer or handle,
  * while the type field helps provide deeper understanding of the identifier as
  * well as enabling differentiation in cases where handles generated by different
  * APIs may collide.  The resource object may also have an associated message to
  * associate with the application resource, enabling further annotation of this
  * object and how it is used.
  *
  * The resource object was introduced in NVTX_VERSION_2 to supersede existing naming
  * functions and allow the application resource identified by those functions to be
  * associated to a domain.  The other naming functions are still supported for backward
  * compatibility but will be associated only to the default domain.
  *
  * \subsection RESOURCE_NAMING_OS Resource Naming
  *
  * Some operating system resources creation APIs do not support providing a user friendly
  * name, such as some OS thread creation APIs.  This API support resource naming though
  * both through resource objects and functions following the pattern
  * nvtxName[RESOURCE_TYPE][A|W](identifier, name).  Resource objects introduced in NVTX_VERSION 2
  * supersede the other functions with a a more general method of assigning names to OS resources,
  * along with associating them to domains too.  The older nvtxName* functions are only associated
  * with the default domain.
  * \section EXTENSIONS Optional Extensions
  * Optional extensions will either appear within the existing sections the extend or appear
  * in the "Related Pages" when they introduce new concepts.
  */
 
  /**
  * Tools Extension API version
  */
 #if defined(NVTX_VERSION) && NVTX_VERSION < 3
 #error "Trying to #include NVTX version 3 in a source file where an older NVTX version has already been included.  If you are not directly using NVTX (the NVIDIA Tools Extension library), you are getting this error because libraries you are using have included different versions of NVTX.  Suggested solutions are: (1) reorder #includes so the newest NVTX version is included first, (2) avoid using the conflicting libraries in the same .c/.cpp file, or (3) update the library using the older NVTX version to use the newer version instead."
 #endif
 
 #if defined(NVTX_AS_SYSTEM_HEADER)
 #if defined(__clang__)
 #pragma clang system_header
 #elif defined(__GNUC__) || defined(__NVCOMPILER)
 #pragma GCC system_header
 #elif defined(_MSC_VER)
 #pragma system_header
 #endif
 #endif
 
 /* Header guard */
 #if !defined(NVTX_VERSION)
 #define NVTX_VERSION 3
 
 /* Platform-dependent defines:
  *
  * - NVTX_API - Calling conventions (only used on Windows, and only effects
  *   32-bit x86 builds, i.e. callee pops stack instead of caller)
  *
  * - NVTX_DYNAMIC_EXPORT - Make function an exported entry point from a
  *   dynamic library or shared object.
  *
  * - NVTX_EXPORT_UNMANGLED_FUNCTION_NAME - When used inside the body of a
  *   function declared with NVTX_DYNAMIC_EXPORT, ensures the symbol exported
  *   for the function is the exact string of the function's name as written
  *   in the code.  Name-mangling or name-decoration is disabled.  Note that
  *   on many platforms this is not necessary, since either the function name
  *   is already exported verbatim, or the dynamic loader also checks for
  *   functions with the mangling applied.  Forcing the exports to avoid any
  *   mangling simplifies usage across platforms and from other languages.
  */
 #if defined(_WIN32)
 
 #define NVTX_API __stdcall
 
 #if defined(_MSC_VER)
 #define NVTX_DYNAMIC_EXPORT __declspec(dllexport)
 #else
 #define NVTX_DYNAMIC_EXPORT __attribute__((visibility("default"))) __declspec(dllexport)
 #endif
 
 #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_ARM64EC))
 #define NVTX_EXPORT_UNMANGLED_FUNCTION_NAME _Pragma("comment(linker, \"/EXPORT:\" __FUNCTION__ \"=\" __FUNCDNAME__)")
 #else
 #define NVTX_EXPORT_UNMANGLED_FUNCTION_NAME
 #endif
 
 #else /* POSIX-like platform */
 
 #define NVTX_API
 
 #define NVTX_DYNAMIC_EXPORT __attribute__((visibility("default")))
 
 #define NVTX_EXPORT_UNMANGLED_FUNCTION_NAME
 
 #endif /* Platform-dependent defines */
 
 /* Compiler-dependent defines:
  *
  * - NVTX_INLINE_STATIC - Ensure function has internal linkage, and suggest
  *   avoiding code-gen of the function.  Without this, function has external
  *   linkage with a strong symbol, so linker expects only one definition.
  */
 #if defined(_MSC_VER)
 
 #define NVTX_INLINE_STATIC __inline static
 
 #else /* GCC-like compiler */
 
 #if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
 #define NVTX_INLINE_STATIC inline static
 #else
 #define NVTX_INLINE_STATIC __inline__ static
 #endif
 
 #endif /* Compiler-dependent defines */
 
 #if !defined(NVTX_NULLPTR)
 #if defined(__cplusplus) && __cplusplus >= 201103L
 #define NVTX_NULLPTR nullptr
 #else
 #define NVTX_NULLPTR NULL
 #endif
 #endif
 
 #if defined(__cplusplus)
 #define NVTX_STATIC_CAST(type, value)      (static_cast<type>(value))
 #define NVTX_REINTERPRET_CAST(type, value) (reinterpret_cast<type>(value))
 #else
 #define NVTX_STATIC_CAST(type, value)      ((type)(value))
 #define NVTX_REINTERPRET_CAST(type, value) ((type)(value))
 #endif
 
 
 /* API linkage/export options:
  *
  * - By default, the NVTX API functions are declared as "inline", with the
  *   implementations provided in the headers.  This allows multiple .c/.cpp
  *   files in the same project to include NVTX headers without duplicate-
  *   definition linker errors.  An optimizing compiler should inline these
  *   implementations, ensuring that the overhead of making an NVTX call is as
  *   low as possible, even without enabling link-time optimizations.
  *
  * - NVTX_NO_IMPL - Use when writing NVTX tools.  If this macro is defined,
  *   the NVTX headers will provide all the typedefs, macros, and declarations
  *   of API functions (not marked inline), but no function implementations.
  *
  * - NVTX_EXPORT_API - NVTX is normally used in C/C++ applications by simply
  *   including the headers.  There is no need to link with a static library,
  *   or to ship a dynamic library with the application (this was changed in
  *   NVTX v3).  For other languages, it's not convenient to use a header-only
  *   C library.  The best way to provide an idiomatic NVTX API for another
  *   language is a .c file that includes the NVTX headers and implements
  *   functions for that language using its native calling conventions and
  *   datatypes -- this method can allow static linking to avoid depending on
  *   a separate dynamic library.  Alternatively, other languages may support
  *   using C calling conventions to directly call C functions exported from a
  *   dynamic library.  To build such a library, write a .c file that defines
  *   NVTX_EXPORT_API and includes any/all of the NVTX headers.  Compile this
  *   file as a dynamic library, and the NVTX API functions from the included
  *   headers will be exported with no name-mangling or decoration.  Defining
  *   ABI-compatible NVTX struct and enum types in the other language is the
  *   responsibility of the user of this dynamic library.
  *
  * Whichever of the above modes is chosen, the following macros are defined
  * appropriately below to implement that mode.  These macros are only defined
  * if not already defined by the user, so they may be overridden by users to
  * handle advanced cases.
  *
  * - NVTX_DECLSPEC - Specify linkage for NVTX API functions.
  *
  * - NVTX_SET_NAME_MANGLING_OPTIONS - If necessary for the platform, will use
  *   platform-dependent syntax for ensuring function name is exported with no
  *   name-mangling or decoration.  Certain compiler and calling-convention
  *   combinations will add name-mangling or decorations when exporting NVTX
  *   function name symbols, which makes it much harder for other languages
  *   to access these functions.  This macro must be used inside a function's
  *   body because it uses built-in macros to get the current function's name.
  */
 #if defined(NVTX_NO_IMPL)
 
 /* When omitting implementation, avoid declaring functions inline
  * without definitions, since this causes compiler warnings. */
 #if !defined(NVTX_DECLSPEC)
 #define NVTX_DECLSPEC
 #endif
 #if !defined(NVTX_SET_NAME_MANGLING_OPTIONS)
 #define NVTX_SET_NAME_MANGLING_OPTIONS
 #endif
 
 #elif defined(NVTX_EXPORT_API)
 
 /* Add platform-dependent declaration syntax to ensure NVTX API functions are
  * exported when compiling as a dynamic library/shared object, and ensure the
  * exported names are not mangled/decorated. */
 #if !defined(NVTX_DECLSPEC)
 #define NVTX_DECLSPEC NVTX_DYNAMIC_EXPORT
 #endif
 #if !defined(NVTX_SET_NAME_MANGLING_OPTIONS)
 #define NVTX_SET_NAME_MANGLING_OPTIONS NVTX_EXPORT_UNMANGLED_FUNCTION_NAME
 #endif
 
 #else /* Normal NVTX usage */
 
 /* Functions definitions are provided, and functions are declared inline to
  * avoid duplicate-definition linker errors when using multiple source files. */
 #if !defined(NVTX_DECLSPEC)
 #define NVTX_DECLSPEC NVTX_INLINE_STATIC
 #endif
 #if !defined(NVTX_SET_NAME_MANGLING_OPTIONS)
 #define NVTX_SET_NAME_MANGLING_OPTIONS
 #endif
 
 #endif
 
 /* Platform-dependent helpers for defining global variables in header files.
  * Ensures the linker uses only one instance when multiple source files include
  * the headers, avoiding duplicate-definition linker errors. */
 #include "nvtxDetail/nvtxLinkOnce.h"
 
 /* Macros for applying major-version-specific suffix to NVTX global symbols, so
  * usage of different versions in different source files is supported without
  * violating the one-definition rule. */
 #define NVTX_VERSIONED_IDENTIFIER_L3(NAME, VERSION) NAME##_v##VERSION
 #define NVTX_VERSIONED_IDENTIFIER_L2(NAME, VERSION) NVTX_VERSIONED_IDENTIFIER_L3(NAME, VERSION)
 #define NVTX_VERSIONED_IDENTIFIER(NAME) NVTX_VERSIONED_IDENTIFIER_L2(NAME, NVTX_VERSION)
 
 /**
  * The NVTX library depends on stdint.h.  If the build tool chain in use
  * does not include stdint.h, then define NVTX_STDINT_TYPES_ALREADY_DEFINED
  * and define the following types:
  * <ul>
  *   <li>uint8_t
  *   <li>int8_t
  *   <li>uint16_t
  *   <li>int16_t
  *   <li>uint32_t
  *   <li>int32_t
  *   <li>uint64_t
  *   <li>int64_t
  *   <li>uintptr_t
  *   <li>intptr_t
  * </ul>
  * Be sure to define NVTX_STDINT_TYPES_ALREADY_DEFINED if you are using your
  * own definitions instead of stdint.h.
  */
 #ifndef NVTX_STDINT_TYPES_ALREADY_DEFINED
 #include <stdint.h>
 #endif
 
 #include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
 /**
 * Result Codes used for the NVTX tool loader.
 */
 #define NVTX_SUCCESS 0
 #define NVTX_FAIL 1
 #define NVTX_ERR_INIT_LOAD_PROPERTY 2
 #define NVTX_ERR_INIT_ACCESS_LIBRARY 3
 #define NVTX_ERR_INIT_LOAD_LIBRARY 4
 #define NVTX_ERR_INIT_MISSING_LIBRARY_ENTRY_POINT 5
 #define NVTX_ERR_INIT_FAILED_LIBRARY_ENTRY_POINT 6
 #define NVTX_ERR_NO_INJECTION_LIBRARY_AVAILABLE 7
 
 /**
  * Size of the nvtxEventAttributes_t structure.
  */
 #define NVTX_EVENT_ATTRIB_STRUCT_SIZE (NVTX_STATIC_CAST(uint16_t, sizeof(nvtxEventAttributes_t)))
 
 #define NVTX_NO_PUSH_POP_TRACKING (NVTX_STATIC_CAST(int, -2))
 
 typedef uint64_t nvtxRangeId_t;
 
 /* Forward declaration of opaque domain registration structure */
 struct nvtxDomainRegistration_st;
 typedef struct nvtxDomainRegistration_st nvtxDomainRegistration;
 
 /* \brief Domain Handle Structure.
 * \anchor DOMAIN_HANDLE_STRUCTURE
 *
 * This structure is opaque to the user and is used as a handle to reference
 * a domain.  This type is returned from tools when using the NVTX API to
 * create a domain.
 *
 */
 typedef nvtxDomainRegistration* nvtxDomainHandle_t;
 
 /* Forward declaration of opaque string registration structure */
 struct nvtxStringRegistration_st;
 typedef struct nvtxStringRegistration_st nvtxStringRegistration;
 
 /* \brief Registered String Handle Structure.
 * \anchor REGISTERED_STRING_HANDLE_STRUCTURE
 *
 * This structure is opaque to the user and is used as a handle to reference
 * a registered string.  This type is returned from tools when using the NVTX
 * API to create a registered string.
 *
 */
 typedef nvtxStringRegistration* nvtxStringHandle_t;
 
 /* ========================================================================= */
 /** \defgroup GENERAL General
  * @{
  */
 
 /** ---------------------------------------------------------------------------
  * Color Types
  * ------------------------------------------------------------------------- */
 typedef enum nvtxColorType_t
 {
     NVTX_COLOR_UNKNOWN  = 0,                 /**< Color attribute is unused. */
     NVTX_COLOR_ARGB     = 1                  /**< An ARGB color is provided. */
 } nvtxColorType_t;
 
 /** ---------------------------------------------------------------------------
  * Message Types
  * ------------------------------------------------------------------------- */
 typedef enum nvtxMessageType_t
 {
     NVTX_MESSAGE_UNKNOWN          = 0,    /**< Message attribute is unused. */
     NVTX_MESSAGE_TYPE_ASCII       = 1,    /**< A character sequence is used as payload. */
     NVTX_MESSAGE_TYPE_UNICODE     = 2,     /**< A wide character sequence is used as payload. */
     /* NVTX_VERSION_2 */
     NVTX_MESSAGE_TYPE_REGISTERED  = 3     /**< A unique string handle that was registered
                                                 with \ref nvtxDomainRegisterStringA() or
                                                 \ref nvtxDomainRegisterStringW(). */
 } nvtxMessageType_t;
 
 typedef union nvtxMessageValue_t
 {
     const char* ascii;
     const wchar_t* unicode;
     /* NVTX_VERSION_2 */
     nvtxStringHandle_t registered;
 } nvtxMessageValue_t;
 
 
 /* ------------------------------------------------------------------------- */
 /** \brief Force initialization (optional)
  * \anchor FORCE_INITIALIZATION
 *
 * Force NVTX library to initialize.  The first call to any NVTX API function
 * will automatically initialize the entire API.  This can make the first call
 * much slower than subsequent calls.  In applications where the first call to
 * NVTX may be in a performance-critical section, calling nvtxInitialize before
 * any performance-critical sections will ensure NVTX initialization occurs at
 * an acceptable time.  Since nvtxInitialize takes no parameters and has no
 * expected behavior besides initialization, it is convenient to add a call to
 * nvtxInitialize in NVTX-instrumented applications that need to force earlier
 * initialization without changing any other code.  For example, if an app's
 * first NVTX call is nvtxDomainCreate, and it is difficult to move that call
 * earlier because the domain handle must be stored in an object only created
 * at that point, adding a call to nvtxInitialize at the top of main() will
 * ensure the later call to nvtxDomainCreate is as fast as possible.
 *
 * \version NVTX_VERSION_3
 *
 * \param reserved - must be zero or NULL.
 *
 * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxInitialize(const void* reserved);
 /** @} */
 
 
 /** @} */ /*END defgroup*/
 
 /* ========================================================================= */
 /** \defgroup EVENT_ATTRIBUTES Event Attributes
 * @{
 */
 
 /** ---------------------------------------------------------------------------
 * Payload Types
 * ------------------------------------------------------------------------- */
 typedef enum nvtxPayloadType_t
 {
     NVTX_PAYLOAD_UNKNOWN = 0,   /**< Payload attribute is unused. */
     NVTX_PAYLOAD_TYPE_UNSIGNED_INT64 = 1,   /**< A 64 bit unsigned integer value is used as payload. */
     NVTX_PAYLOAD_TYPE_INT64 = 2,   /**< A 64 bit signed integer value is used as payload. */
     NVTX_PAYLOAD_TYPE_DOUBLE = 3,   /**< A 64 bit floating point value is used as payload. */
     /* NVTX_VERSION_2 */
     NVTX_PAYLOAD_TYPE_UNSIGNED_INT32 = 4,   /**< A 32 bit floating point value is used as payload. */
     NVTX_PAYLOAD_TYPE_INT32 = 5,   /**< A 32 bit floating point value is used as payload. */
     NVTX_PAYLOAD_TYPE_FLOAT = 6    /**< A 32 bit floating point value is used as payload. */
 } nvtxPayloadType_t;
 
 /** \brief Event Attribute Structure.
  * \anchor EVENT_ATTRIBUTE_STRUCTURE
  *
  * This structure is used to describe the attributes of an event. The layout of
  * the structure is defined by a specific version of the tools extension
  * library and can change between different versions of the Tools Extension
  * library.
  *
  * \par Guidelines
  * The caller should always perform the following three tasks when using
  * attributes:
  * <ul>
  *    <li>Zero the structure
  *    <li>Set the version field
  *    <li>Set the size field
  * </ul>
  *
  * Zeroing the structure sets all the event attributes types and values
  * to the default value.
  *
  * The version and size field are used by the Tools Extension
  * implementation to handle multiple versions of the attributes structure.
  *
  * It is recommended that the caller use one of the following to methods
  * to initialize the event attributes structure:
  *
  * \par Method 1
  * Initializing nvtxEventAttributes for future compatibility:
  * \code
  * nvtxEventAttributes_t eventAttrib = {0};
  * eventAttrib.version = NVTX_VERSION;
  * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
  * \endcode
  *
  * \par Method 2
  * Initializing nvtxEventAttributes for a specific version:
  * \code
  * nvtxEventAttributes_t eventAttrib = {0};
  * eventAttrib.version = 1;
  * eventAttrib.size = (uint16_t)(sizeof(nvtxEventAttributes_v1));
  * \endcode
  *
  * If the caller uses Method 1 it is critical that the entire binary
  * layout of the structure be configured to 0 so that all fields
  * are initialized to the default value.
  *
  * The caller should either use both NVTX_VERSION and
  * NVTX_EVENT_ATTRIB_STRUCT_SIZE (Method 1) or use explicit values
  * and a versioned type (Method 2).  Using a mix of the two methods
  * will likely cause either source level incompatibility or binary
  * incompatibility in the future.
  *
  * \par Example
  * Populate an attributes structure:
  * \code
  * // Initialize
  * nvtxEventAttributes_t eventAttrib = {0};
  * eventAttrib.version = NVTX_VERSION;
  * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
  *
  * // Configure the Attributes
  * eventAttrib.colorType = NVTX_COLOR_ARGB;
  * eventAttrib.color = 0xFF880000;
  * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
  * eventAttrib.message.ascii = "Example";
  * \endcode
  *
  * In the example the caller does not have to set the value of
  * \ref ::nvtxEventAttributes_v2::category or
  * \ref ::nvtxEventAttributes_v2::payload as these fields were set to
  * the default value by {0}.
  * \sa
  * ::nvtxDomainMarkEx
  * ::nvtxDomainRangeStartEx
  * ::nvtxDomainRangePushEx
  */
 typedef struct nvtxEventAttributes_v2
 {
     /**
     * \brief Version flag of the structure.
     *
     * Needs to be set to NVTX_VERSION to indicate the version of NVTX APIs
     * supported in this header file. This can optionally be overridden to
     * another version of the tools extension library.
     */
     uint16_t version;
 
     /**
     * \brief Size of the structure.
     *
     * Needs to be set to the size in bytes of the event attribute
     * structure used to specify the event.
     */
     uint16_t size;
 
     /**
      * \brief ID of the category the event is assigned to.
      *
      * A category is a user-controlled ID that can be used to group
      * events.  The tool may use category IDs to improve filtering or
      * enable grouping of events in the same category. The functions
      * \ref ::nvtxNameCategoryA or \ref ::nvtxNameCategoryW can be used
      * to name a category.
      *
      * Default Value is 0
      */
     uint32_t category;
 
     /** \brief Color type specified in this attribute structure.
      *
      * Defines the color format of the attribute structure's \ref COLOR_FIELD
      * "color" field.
      *
      * Default Value is NVTX_COLOR_UNKNOWN
      */
     int32_t colorType;              /* nvtxColorType_t */
 
     /** \brief Color assigned to this event. \anchor COLOR_FIELD
      *
      * The color that the tool should use to visualize the event.
      */
     uint32_t color;
 
     /**
      * \brief Payload type specified in this attribute structure.
      *
      * Defines the payload format of the attribute structure's \ref PAYLOAD_FIELD
      * "payload" field.
      *
      * Default Value is NVTX_PAYLOAD_UNKNOWN
      */
     int32_t payloadType;            /* nvtxPayloadType_t */
 
     int32_t reserved0;
 
     /**
      * \brief Payload assigned to this event. \anchor PAYLOAD_FIELD
      *
      * A numerical value that can be used to annotate an event. The tool could
      * use the payload data to reconstruct graphs and diagrams.
      */
     union payload_t
     {
         uint64_t ullValue;
         int64_t llValue;
         double dValue;
         /* NVTX_VERSION_2 */
         uint32_t uiValue;
         int32_t iValue;
         float fValue;
     } payload;
 
     /** \brief Message type specified in this attribute structure.
      *
      * Defines the message format of the attribute structure's \ref MESSAGE_FIELD
      * "message" field.
      *
      * Default Value is NVTX_MESSAGE_UNKNOWN
      */
     int32_t messageType;            /* nvtxMessageType_t */
 
     /** \brief Message assigned to this attribute structure. \anchor MESSAGE_FIELD
      *
      * The text message that is attached to an event.
      */
     nvtxMessageValue_t message;
 
 } nvtxEventAttributes_v2;
 
 typedef struct nvtxEventAttributes_v2 nvtxEventAttributes_t;
 
 /** @} */ /*END defgroup*/
 /* ========================================================================= */
 /** \defgroup MARKERS_AND_RANGES Markers and Ranges
  *
  * See \ref MARKERS_AND_RANGES for more details
  *
  * @{
  */
 
 /** \name Marker */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Marks an instantaneous event in the application.
 *
 * A marker can contain a text message or specify additional information
 * using the event attributes structure.  These attributes include a text
 * message, color, category, and a payload. Each of the attributes is optional
 * and can only be sent out using the \ref nvtxDomainMarkEx function.
 *
 * nvtxDomainMarkEx(NULL, event) is equivalent to calling
 * nvtxMarkEx(event).
 *
 * \param domain    - The domain of scoping the category.
 * \param eventAttrib - The event attribute structure defining the marker's
 * attribute types and attribute values.
 *
 * \sa
 * ::nvtxMarkEx
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxDomainMarkEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Marks an instantaneous event in the application.
  *
  * A marker can contain a text message or specify additional information
  * using the event attributes structure.  These attributes include a text
  * message, color, category, and a payload. Each of the attributes is optional
  * and can only be sent out using the \ref nvtxMarkEx function.
  * If \ref nvtxMarkA or \ref nvtxMarkW are used to specify the marker
  * or if an attribute is unspecified then a default value will be used.
  *
  * \param eventAttrib - The event attribute structure defining the marker's
  * attribute types and attribute values.
  *
  * \par Example
  * Place a mark with attributes:
  * \code
  * // zero the structure
  * nvtxEventAttributes_t eventAttrib = {0};
  * // set the version and the size information
  * eventAttrib.version = NVTX_VERSION;
  * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
  * // configure the attributes.  0 is the default for all attributes.
  * eventAttrib.colorType = NVTX_COLOR_ARGB;
  * eventAttrib.color = 0xFF880000;
  * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
  * eventAttrib.message.ascii = "Example nvtxMarkEx";
  * nvtxMarkEx(&eventAttrib);
  * \endcode
  *
  * \sa
  * ::nvtxDomainMarkEx
  *
  * \version NVTX_VERSION_1
  * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxMarkEx(const nvtxEventAttributes_t* eventAttrib);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Marks an instantaneous event in the application.
  *
  * A marker created using \ref nvtxMarkA or \ref nvtxMarkW contains only a
  * text message.
  *
  * \param message     - The message associated to this marker event.
  *
  * \par Example
  * Place a mark:
  * \code
  * nvtxMarkA("Example nvtxMarkA");
  * nvtxMarkW(L"Example nvtxMarkW");
  * \endcode
  *
  * \sa
  * ::nvtxDomainMarkEx
  * ::nvtxMarkEx
  *
  * \version NVTX_VERSION_0
  * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxMarkA(const char* message);
 NVTX_DECLSPEC void NVTX_API nvtxMarkW(const wchar_t* message);
 /** @} */
 
 
 /** \name Process Ranges */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Starts a process range in a domain.
 *
 * \param domain    - The domain of scoping the category.
 * \param eventAttrib - The event attribute structure defining the range's
 * attribute types and attribute values.
 *
 * \return The unique ID used to correlate a pair of Start and End events.
 *
 * \remarks Ranges defined by Start/End can overlap.
 *
 * \par Example
 * Start a range with attributes for a domain:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("my domain");
 * nvtxEventAttributes_t eventAttrib = {0};
 * eventAttrib.version = NVTX_VERSION;
 * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
 * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
 * eventAttrib.message.ascii = "my range";
 * nvtxRangeId_t rangeId = nvtxDomainRangeStartEx(domain, &eventAttrib);
 * // ...
 * nvtxDomainRangeEnd(domain, rangeId);
 * \endcode
 *
 * \sa
 * ::nvtxDomainRangeEnd
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxDomainRangeStartEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Starts a process range.
  *
  * \param eventAttrib - The event attribute structure defining the range's
  * attribute types and attribute values.
  *
  * \return The unique ID used to correlate a pair of Start and End events.
  *
  * \remarks Ranges defined by Start/End can overlap.
  *
  * \par Example
  * Start a range with attributes:
  * \code
  * nvtxEventAttributes_t eventAttrib = {0};
  * eventAttrib.version = NVTX_VERSION;
  * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
  * eventAttrib.category = 3;
  * eventAttrib.colorType = NVTX_COLOR_ARGB;
  * eventAttrib.color = 0xFF0088FF;
  * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
  * eventAttrib.message.ascii = "Example Range";
  * nvtxRangeId_t rangeId = nvtxRangeStartEx(&eventAttrib);
  * // ...
  * nvtxRangeEnd(rangeId);
  * \endcode
  *
  * \sa
  * ::nvtxRangeEnd
  * ::nvtxDomainRangeStartEx
  *
  * \version NVTX_VERSION_1
  * @{ */
 NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartEx(const nvtxEventAttributes_t* eventAttrib);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Starts a process range.
  *
  * \param message     - The event message associated to this range event.
  *
  * \return The unique ID used to correlate a pair of Start and End events.
  *
  * \remarks Ranges defined by Start/End can overlap.
  *
  * \par Example
  * Start a range:
  * \code
  * nvtxRangeId_t r1 = nvtxRangeStartA("Range 1");
  * nvtxRangeId_t r2 = nvtxRangeStartW(L"Range 2");
  * nvtxRangeEnd(r1);
  * nvtxRangeEnd(r2);
  * \endcode
  *
  * \sa
  * ::nvtxRangeEnd
  * ::nvtxRangeStartEx
  * ::nvtxDomainRangeStartEx
  *
  * \version NVTX_VERSION_0
  * @{ */
 NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartA(const char* message);
 NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartW(const wchar_t* message);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Ends a process range.
 *
 * \param domain - The domain
 * \param id - The correlation ID returned from a nvtxRangeStart call.
 *
 * \remarks This function is offered completeness but is an alias for ::nvtxRangeEnd.
 * It does not need a domain param since that is associated with the range ID at ::nvtxDomainRangeStartEx
 *
 * \par Example
 * End a range for a domain:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("my domain");
 * nvtxEventAttributes_t eventAttrib = {0};
 * eventAttrib.version = NVTX_VERSION;
 * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
 * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
 * eventAttrib.message.ascii = "my range";
 * nvtxRangeId_t rangeId = nvtxDomainRangeStartEx(domain, &eventAttrib);
 * // ...
 * nvtxDomainRangeEnd(domain, rangeId);
 * \endcode
 *
 * \sa
 * ::nvtxDomainRangeStartEx
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxDomainRangeEnd(nvtxDomainHandle_t domain, nvtxRangeId_t id);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Ends a process range.
  *
  * \param id - The correlation ID returned from an nvtxRangeStart call.
  *
  * \sa
  * ::nvtxDomainRangeStartEx
  * ::nvtxRangeStartEx
  * ::nvtxRangeStartA
  * ::nvtxRangeStartW
  *
  * \version NVTX_VERSION_0
  * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxRangeEnd(nvtxRangeId_t id);
 /** @} */
 
 /** \name Thread Ranges */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Starts a nested thread range.
 *
 * \param domain    - The domain of scoping.
 * \param eventAttrib - The event attribute structure defining the range's
 * attribute types and attribute values.
 *
 * \return The 0 based level of range being started. This value is scoped to the domain.
 * If an error occurs, a negative value is returned.
 *
 * \par Example
 * Push a range with attributes for a domain:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
 * nvtxEventAttributes_t eventAttrib = {0};
 * eventAttrib.version = NVTX_VERSION;
 * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
 * eventAttrib.colorType = NVTX_COLOR_ARGB;
 * eventAttrib.color = 0xFFFF0000;
 * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
 * eventAttrib.message.ascii = "Level 0";
 * nvtxDomainRangePushEx(domain, &eventAttrib);
 *
 * // Re-use eventAttrib
 * eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE;
 * eventAttrib.message.unicode = L"Level 1";
 * nvtxDomainRangePushEx(domain, &eventAttrib);
 *
 * nvtxDomainRangePop(domain); // Level 1
 * nvtxDomainRangePop(domain); // Level 0
 * \endcode
 *
 * \sa
 * ::nvtxDomainRangePop
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC int NVTX_API nvtxDomainRangePushEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Starts a nested thread range.
  *
  * \param eventAttrib - The event attribute structure defining the range's
  * attribute types and attribute values.
  *
  * \return The 0 based level of range being started. This level is per domain.
  * If an error occurs a negative value is returned.
  *
  * \par Example
  * Push a range with attributes:
  * \code
  * nvtxEventAttributes_t eventAttrib = {0};
  * eventAttrib.version = NVTX_VERSION;
  * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
  * eventAttrib.colorType = NVTX_COLOR_ARGB;
  * eventAttrib.color = 0xFFFF0000;
  * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
  * eventAttrib.message.ascii = "Level 0";
  * nvtxRangePushEx(&eventAttrib);
  *
  * // Re-use eventAttrib
  * eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE;
  * eventAttrib.message.unicode = L"Level 1";
  * nvtxRangePushEx(&eventAttrib);
  *
  * nvtxRangePop(); // Level 1
  * nvtxRangePop(); // Level 0
  * \endcode
  *
  * \sa
  * ::nvtxDomainRangePushEx
  * ::nvtxRangePop
  *
  * \version NVTX_VERSION_1
  * @{ */
 NVTX_DECLSPEC int NVTX_API nvtxRangePushEx(const nvtxEventAttributes_t* eventAttrib);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Starts a nested thread range.
  *
  * \param message     - The event message associated to this range event.
  *
  * \return The 0 based level of range being started.  If an error occurs a
  * negative value is returned.
  *
  * \par Example
  * Push a range:
  * \code
  * nvtxRangePushA("Level 0");
  * nvtxRangePushW(L"Level 1");
  * nvtxRangePop(); // Level 1
  * nvtxRangePop(); // Level 0
  * \endcode
  *
  * \sa
  * ::nvtxDomainRangePushEx
  * ::nvtxRangePop
  *
  * \version NVTX_VERSION_0
  * @{ */
 NVTX_DECLSPEC int NVTX_API nvtxRangePushA(const char* message);
 NVTX_DECLSPEC int NVTX_API nvtxRangePushW(const wchar_t* message);
 /** @} */
 
 
 /* ------------------------------------------------------------------------- */
 /** \brief Ends a nested thread range.
 *
 * \return The level of the range being ended. If an error occurs a negative
 * value is returned on the current thread.
 *
 * \par Example
 * Pop a range for a domain:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
 * nvtxEventAttributes_t eventAttrib = {0};
 * eventAttrib.version = NVTX_VERSION;
 * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
 * eventAttrib.colorType = NVTX_COLOR_ARGB;
 * eventAttrib.color = 0xFFFF0000;
 * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
 * eventAttrib.message.ascii = "Level 0";
 * nvtxDomainRangePushEx(domain, &eventAttrib);
 *
 * // Re-use eventAttrib
 * eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE;
 * eventAttrib.message.unicode = L"Level 1";
 * nvtxDomainRangePushEx(domain, &eventAttrib);
 *
 * nvtxDomainRangePop(domain); // Level 1
 * nvtxDomainRangePop(domain); // Level 0
 * \endcode
 *
 * \sa
 * ::nvtxRangePushEx
 * ::nvtxRangePushA
 * ::nvtxRangePushW
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC int NVTX_API nvtxDomainRangePop(nvtxDomainHandle_t domain);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Ends a nested thread range.
  *
  * \return The level of the range being ended. If an error occurs a negative
  * value is returned on the current thread.
  *
  * \par Example
  * Pop a range:
  * \code
  * nvtxRangePushA("Level 0");
  * nvtxRangePushW(L"Level 1");
  * nvtxRangePop(); // Level 1
  * nvtxRangePop(); // Level 0
  * \endcode
  *
  * \sa
  * ::nvtxRangePushEx
  * ::nvtxRangePushA
  * ::nvtxRangePushW
  *
  * \version NVTX_VERSION_0
  * @{ */
 NVTX_DECLSPEC int NVTX_API nvtxRangePop(void);
 /** @} */
 
 
 /** @} */ /*END defgroup*/
 /* ========================================================================= */
 /** \defgroup RESOURCE_NAMING Resource Naming
  *
  * See \ref RESOURCE_NAMING for more details
  *
  * @{
  */
 
 
 /*  ------------------------------------------------------------------------- */
 /** \name Functions for Generic Resource Naming*/
 /*  ------------------------------------------------------------------------- */
 
 /*  ------------------------------------------------------------------------- */
 /** \cond SHOW_HIDDEN
 * \brief Resource typing helpers.
 *
 * Classes are used to make it easy to create a series of resource types
 * per API without collisions
 */
 #define NVTX_RESOURCE_MAKE_TYPE(CLASS, INDEX) (((NVTX_STATIC_CAST(uint32_t, NVTX_RESOURCE_CLASS_ ## CLASS))<<16)|(NVTX_STATIC_CAST(uint32_t, INDEX)))
 #define NVTX_RESOURCE_CLASS_GENERIC 1
 /** \endcond */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Generic resource type for when a resource class is not available.
 *
 * \sa
 * ::nvtxDomainResourceCreate
 *
 * \version NVTX_VERSION_2
 */
 typedef enum nvtxResourceGenericType_t
 {
     NVTX_RESOURCE_TYPE_UNKNOWN = 0,
     NVTX_RESOURCE_TYPE_GENERIC_POINTER = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 1), /**< Generic pointer assumed to have no collisions with other pointers. */
     NVTX_RESOURCE_TYPE_GENERIC_HANDLE = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 2), /**< Generic handle assumed to have no collisions with other handles. */
     NVTX_RESOURCE_TYPE_GENERIC_THREAD_NATIVE = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 3), /**< OS native thread identifier. */
     NVTX_RESOURCE_TYPE_GENERIC_THREAD_POSIX = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 4) /**< POSIX pthread identifier. */
 } nvtxResourceGenericType_t;
 
 
 
 /** \brief Resource Attribute Structure.
 * \anchor RESOURCE_ATTRIBUTE_STRUCTURE
 *
 * This structure is used to describe the attributes of a resource. The layout of
 * the structure is defined by a specific version of the tools extension
 * library and can change between different versions of the Tools Extension
 * library.
 *
 * \par Guidelines
 * The caller should always perform the following three tasks when using
 * attributes:
 * <ul>
 *    <li>Zero the structure
 *    <li>Set the version field
 *    <li>Set the size field
 * </ul>
 *
 * Zeroing the structure sets all the resource attributes types and values
 * to the default value.
 *
 * The version and size field are used by the Tools Extension
 * implementation to handle multiple versions of the attributes structure.
 *
 * It is recommended that the caller use one of the following to methods
 * to initialize the event attributes structure:
 *
 * \par Method 1
 * Initializing nvtxEventAttributes for future compatibility:
 * \code
 * nvtxResourceAttributes_t attribs = {0};
 * attribs.version = NVTX_VERSION;
 * attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
 * \endcode
 *
 * \par Method 2
 * Initializing nvtxEventAttributes for a specific version:
 * \code
 * nvtxResourceAttributes_v0 attribs = {0};
 * attribs.version = 2;
 * attribs.size = (uint16_t)(sizeof(nvtxResourceAttributes_v0));
 * \endcode
 *
 * If the caller uses Method 1 it is critical that the entire binary
 * layout of the structure be configured to 0 so that all fields
 * are initialized to the default value.
 *
 * The caller should either use both NVTX_VERSION and
 * NVTX_RESOURCE_ATTRIB_STRUCT_SIZE (Method 1) or use explicit values
 * and a versioned type (Method 2).  Using a mix of the two methods
 * will likely cause either source level incompatibility or binary
 * incompatibility in the future.
 *
 * \par Example
 * Register a resource and populate its attributes:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
 *
 * // Initialize
 * nvtxResourceAttributes_t attribs = {0};
 * attribs.version = NVTX_VERSION;
 * attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
 *
 * // Configure the Attributes
 * attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER;
 * attribs.identifier.pValue = (const void*)pMutex;
 * attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
 * attribs.message.ascii = "Single thread access to database.";
 *
 * nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, &attribs);
 * \endcode
 *
 * \sa
 * ::nvtxDomainResourceCreate
 */
 typedef struct nvtxResourceAttributes_v0
 {
     /**
     * \brief Version flag of the structure.
     *
     * Needs to be set to NVTX_VERSION to indicate the version of NVTX APIs
     * supported in this header file. This can optionally be overridden to
     * another version of the tools extension library.
     */
     uint16_t version;
 
     /**
     * \brief Size of the structure.
     *
     * Needs to be set to the size in bytes of this attribute
     * structure.
     */
     uint16_t size;
 
     /**
     * \brief Identifier type specifies how to interpret the identifier field
     *
     * Defines the identifier format of the attribute structure's \ref RESOURCE_IDENTIFIER_FIELD
     * "identifier" field.
     *
     * Default Value is NVTX_RESOURCE_TYPE_UNKNOWN
     */
     int32_t identifierType;            /* values from enums following the pattern nvtxResource[name]Type_t */
 
     /**
     * \brief Identifier for the resource.
     * \anchor RESOURCE_IDENTIFIER_FIELD
     *
     * An identifier may be a pointer or a handle to an OS or middleware API object.
     * The resource type will assist in avoiding collisions where handles values may collide.
     */
     union identifier_t
     {
         const void* pValue;
         uint64_t ullValue;
     } identifier;
 
     /** \brief Message type specified in this attribute structure.
     *
     * Defines the message format of the attribute structure's \ref RESOURCE_MESSAGE_FIELD
     * "message" field.
     *
     * Default Value is NVTX_MESSAGE_UNKNOWN
     */
     int32_t messageType;            /* nvtxMessageType_t */
 
     /** \brief Message assigned to this attribute structure. \anchor RESOURCE_MESSAGE_FIELD
     *
     * The text message that is attached to a resource.
     */
     nvtxMessageValue_t message;
 
 } nvtxResourceAttributes_v0;
 
 typedef struct nvtxResourceAttributes_v0 nvtxResourceAttributes_t;
 
 /* \cond SHOW_HIDDEN
 * \version NVTX_VERSION_2
 */
 #define NVTX_RESOURCE_ATTRIB_STRUCT_SIZE (NVTX_STATIC_CAST(uint16_t, sizeof(nvtxResourceAttributes_v0)))
 typedef struct nvtxResourceHandle* nvtxResourceHandle_t;
 /** \endcond */
 
 
 
 /* ------------------------------------------------------------------------- */
 /** \brief Create a resource object to track and associate data with OS and middleware objects
 *
 * Allows users to associate an API handle or pointer with a user-provided name.
 *
 *
 * \param domain - Domain to own the resource object
 * \param attribs - Attributes to be associated with the resource
 *
 * \return A handle that represents the newly created resource object.
 *
 * \par Example
 * Register a resource:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
 * nvtxResourceAttributes_t attribs = {0};
 * attribs.version = NVTX_VERSION;
 * attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
 * attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER;
 * attribs.identifier.pValue = (const void*)pMutex;
 * attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
 * attribs.message.ascii = "Single thread access to database.";
 * nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, &attribs);
 * \endcode
 *
 * \sa
 * ::nvtxResourceAttributes_t
 * ::nvtxDomainResourceDestroy
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC nvtxResourceHandle_t NVTX_API nvtxDomainResourceCreate(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Destroy a resource object to track and associate data with OS and middleware objects
 *
 * Allows users to associate an API handle or pointer with a user-provided name.
 *
 * \param resource - Handle to the resource in which to operate.
 *
 * \par Example
 * Unregister a resource:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
 * nvtxResourceAttributes_t attribs = {0};
 * attribs.version = NVTX_VERSION;
 * attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
 * attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER;
 * attribs.identifier.pValue = (const void*)pMutex;
 * attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
 * attribs.message.ascii = "Single thread access to database.";
 * nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, &attribs);
 * // ...
 * nvtxDomainResourceDestroy(handle);
 * \endcode
 *
 * \sa
 * ::nvtxDomainResourceCreate
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxDomainResourceDestroy(nvtxResourceHandle_t resource);
 /** @} */
 
 
 /** \name Functions for NVTX Category Naming*/
 
 /* ------------------------------------------------------------------------- */
 /**
 * \brief Annotate an NVTX category used within a domain.
 *
 * Categories are used to group sets of events. Each category is identified
 * through a unique ID and that ID is passed into any of the marker/range
 * events to assign that event to a specific category. The nvtxDomainNameCategory
 * function calls allow the user to assign a name to a category ID that is
 * specific to the domain.
 *
 * nvtxDomainNameCategory(NULL, category, name) is equivalent to calling
 * nvtxNameCategory(category, name).
 *
 * \param domain    - The domain of scoping the category.
 * \param category  - The category ID to name.
 * \param name      - The name of the category.
 *
 * \remarks The category names are tracked per domain.
 *
 * \par Example
 * Assign names to categories in a domain:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("example");
 * nvtxDomainNameCategoryA(domain, 1, "Memory Allocation");
 * nvtxDomainNameCategoryW(domain, 2, L"Memory Transfer");
 * \endcode
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryA(nvtxDomainHandle_t domain, uint32_t category, const char* name);
 NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryW(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name);
 /** @} */
 
 /** \brief Annotate an NVTX category.
  *
  * Categories are used to group sets of events. Each category is identified
  * through a unique ID and that ID is passed into any of the marker/range
  * events to assign that event to a specific category. The nvtxNameCategory
  * function calls allow the user to assign a name to a category ID.
  *
  * \param category - The category ID to name.
  * \param name     - The name of the category.
  *
  * \remarks The category names are tracked per process.
  *
  * \par Example
  * Assign names to categories:
  * \code
  * nvtxNameCategory(1, "Memory Allocation");
  * nvtxNameCategory(2, "Memory Transfer");
  * nvtxNameCategory(3, "Memory Object Lifetime");
  * \endcode
  *
  * \version NVTX_VERSION_1
  * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxNameCategoryA(uint32_t category, const char* name);
 NVTX_DECLSPEC void NVTX_API nvtxNameCategoryW(uint32_t category, const wchar_t* name);
 /** @} */
 
 /** \name Functions for OS Threads Naming*/
 
 /* ------------------------------------------------------------------------- */
 /** \brief Annotate an OS thread.
  *
  * Allows the user to name an active thread of the current process. If an
  * invalid thread ID is provided or a thread ID from a different process is
  * used the behavior of the tool is implementation dependent.
  *
  * Tools expect thread ID to be a number that uniquely identifies the thread
  * at the time of the call. Note that a thread's ID can be reused after
  * it is destroyed. Tools may choose how to handle aliasing of thread IDs.
  *
  * POSIX pthread_t type returned by pthread_self() may not comply with these
  * expectations. Please use OS-specific thread ID instead of pthread_t.
  *
  * The thread name is associated to the default domain.  To support domains
  * use resource objects via ::nvtxDomainResourceCreate.
  *
  * \param threadId - The ID of the thread to name.
  * \param name     - The name of the thread.
  *
  * \par Examples
  * Name a thread based on the given operating system:
  *
  * Windows:
  * \code
  * #include <windows.h>
  * nvtxNameOsThread(GetCurrentThreadId(), "Current thread");
  * nvtxNameOsThread(GetThreadId(SomeThreadHandle), "Other thread");
  * \endcode
  *
  * Android:
  * \code
  * #include <unistd.h>
  * nvtxNameOsThreadA(gettid(), "Current thread");
  * nvtxNameOsThreadA(getpid(), "Main thread");
  * \endcode
  *
  * Linux:
  * \code
  * #include <sys/syscall.h>
  * nvtxNameOsThreadA(syscall(SYS_gettid), "Current thread");
  * \endcode
  * \code
  * #include <unistd.h>
  * nvtxNameOsThreadA(getpid(), "Main thread");
  * \endcode
  *
  * macOS:
  * \code
  * #include <sys/syscall.h>
  * nvtxNameOsThreadA(syscall(SYS_thread_selfid), "Current thread");
  * \endcode
  * \code
  * #include <pthread.h>
  * __uint64_t id;
  * pthread_threadid_np(pthread_self(), &id);
  * nvtxNameOsThreadA(id, "Current thread");
  * pthread_threadid_np(somePThreadId, &id);
  * nvtxNameOsThreadA(id, "Other thread");
  * \endcode
  *
  * \version NVTX_VERSION_1
  * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadA(uint32_t threadId, const char* name);
 NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadW(uint32_t threadId, const wchar_t* name);
 /** @} */
 
 
 /** @} */ /*END defgroup*/
 /* ========================================================================= */
 /** \defgroup STRING_REGISTRATION String Registration
 *
 * Registered strings are intended to increase performance by lowering instrumentation
 * overhead.  String may be registered once and the handle may be passed in place of
 * a string where an the APIs may allow.
 *
 * See \ref STRING_REGISTRATION for more details
 *
 * @{
 */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Register a string.
 
 * Registers an immutable string with NVTX. Once registered the pointer used
 * to register the domain name can be used in nvtxEventAttributes_t
 * \ref MESSAGE_FIELD. This allows NVTX implementation to skip copying the
 * contents of the message on each event invocation.
 *
 * String registration is an optimization. It is recommended to use string
 * registration if the string will be passed to an event many times.
 *
 * String are not unregistered, except that by unregistering the entire domain
 *
 * \param domain  - Domain handle. If NULL then the global domain is used.
 * \param string    - A unique pointer to a sequence of characters.
 *
 * \return A handle representing the registered string.
 *
 * \par Example
 * Register a string:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example");
 * nvtxStringHandle_t message = nvtxDomainRegisterStringA(domain, "registered string");
 * nvtxEventAttributes_t eventAttrib = {0};
 * eventAttrib.version = NVTX_VERSION;
 * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
 * eventAttrib.messageType = NVTX_MESSAGE_TYPE_REGISTERED;
 * eventAttrib.message.registered = message;
 * \endcode
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringA(nvtxDomainHandle_t domain, const char* string);
 NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringW(nvtxDomainHandle_t domain, const wchar_t* string);
 /** @} */
 
 /** @} */ /*END defgroup*/
 /* ========================================================================= */
 /** \defgroup DOMAINS Domains
 *
 * Domains are used to group events to a developer defined scope. Middleware
 * vendors may also scope their own events to avoid collisions with the
 * the application developer's events, so that the application developer may
 * inspect both parts and easily differentiate or filter them.  By default
 * all events are scoped to a global domain where NULL is provided or when
 * using APIs provided b versions of NVTX below v2
 *
 * Domains are intended to be typically long lived objects with the intention
 * of logically separating events of large modules from each other such as
 * middleware libraries from each other and the main application.
 *
 * See \ref DOMAINS for more details
 *
 * @{
 */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Register a NVTX domain.
 *
 * Domains are used to scope annotations. All NVTX_VERSION_0 and NVTX_VERSION_1
 * annotations are scoped to the global domain. The function nvtxDomainCreate
 * creates a new named domain.
 *
 * Each domain maintains its own nvtxRangePush and nvtxRangePop stack.
 *
 * \param name - A unique string representing the domain.
 *
 * \return A handle representing the domain.
 *
 * \par Example
 * Create a domain:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example");
 *
 * nvtxMarkA("nvtxMarkA to global domain");
 *
 * nvtxEventAttributes_t eventAttrib1 = {0};
 * eventAttrib1.version = NVTX_VERSION;
 * eventAttrib1.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
 * eventAttrib1.message.ascii = "nvtxDomainMarkEx to global domain";
 * nvtxDomainMarkEx(NULL, &eventAttrib1);
 *
 * nvtxEventAttributes_t eventAttrib2 = {0};
 * eventAttrib2.version = NVTX_VERSION;
 * eventAttrib2.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
 * eventAttrib2.message.ascii = "nvtxDomainMarkEx to com.nvidia.nvtx.example";
 * nvtxDomainMarkEx(domain, &eventAttrib2);
 *
 * nvtxDomainDestroy(domain);
 * \endcode
 *
 * \sa
 * ::nvtxDomainDestroy
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateA(const char* name);
 NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateW(const wchar_t* name);
 /** @} */
 
 /* ------------------------------------------------------------------------- */
 /** \brief Unregister a NVTX domain.
 *
 * Unregisters the domain handle and frees all domain specific resources.
 *
 * \param domain    - the domain handle
 *
 * \par Example
 * Destroy a domain:
 * \code
 * nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example");
 * // ...
 * nvtxDomainDestroy(domain);
 * \endcode
 *
 * \sa
 * ::nvtxDomainCreateA
 * ::nvtxDomainCreateW
 *
 * \version NVTX_VERSION_2
 * @{ */
 NVTX_DECLSPEC void NVTX_API nvtxDomainDestroy(nvtxDomainHandle_t domain);
 /** @} */
 
 
 /** @} */ /*END defgroup*/
 /* ========================================================================= */
 /** \cond SHOW_HIDDEN */
 
 #ifdef UNICODE
     #define nvtxMark            nvtxMarkW
     #define nvtxRangeStart      nvtxRangeStartW
     #define nvtxRangePush       nvtxRangePushW
     #define nvtxNameCategory    nvtxNameCategoryW
     #define nvtxNameOsThread    nvtxNameOsThreadW
     /* NVTX_VERSION_2 */
     #define nvtxDomainCreate         nvtxDomainCreateW
     #define nvtxDomainRegisterString nvtxDomainRegisterStringW
     #define nvtxDomainNameCategory   nvtxDomainNameCategoryW
 #else
     #define nvtxMark            nvtxMarkA
     #define nvtxRangeStart      nvtxRangeStartA
     #define nvtxRangePush       nvtxRangePushA
     #define nvtxNameCategory    nvtxNameCategoryA
     #define nvtxNameOsThread    nvtxNameOsThreadA
     /* NVTX_VERSION_2 */
     #define nvtxDomainCreate         nvtxDomainCreateA
     #define nvtxDomainRegisterString nvtxDomainRegisterStringA
     #define nvtxDomainNameCategory   nvtxDomainNameCategoryA
 #endif
 
 /** \endcond */
 
 #ifdef __cplusplus
 } /* extern "C" */
 #endif /* __cplusplus */
 
 #define NVTX_IMPL_GUARD /* Ensure other headers cannot be included directly */
 
 #include "nvtxDetail/nvtxTypes.h"
 
 #ifndef NVTX_NO_IMPL
 #include "nvtxDetail/nvtxImpl.h"
 #endif /*NVTX_NO_IMPL*/
 
 #undef NVTX_IMPL_GUARD
 
 #endif /* !defined(NVTX_VERSION) */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team