nvtx3.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2020-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.
 */
 
#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
 
/* Temporary helper #defines, #undef'ed at end of header */
#define NVTX3_CPP_VERSION_MAJOR 1
#define NVTX3_CPP_VERSION_MINOR 1
 
/* This section handles the decision of whether to provide unversioned symbols.
 * If NVTX3_CPP_REQUIRE_EXPLICIT_VERSION is #defined, unversioned symbols are
 * not provided, and explicit-version symbols such as nvtx3::v1::scoped_range
 * and NVTX3_V1_FUNC_RANGE must be used.  By default, the first #include of this
 * header will define the unversioned symbols such as nvtx3::scoped_range and
 * NVTX3_FUNC_RANGE.  Subsequently including a different major version of this
 * header without #defining NVTX3_CPP_REQUIRE_EXPLICIT_VERSION triggers an error
 * since the symbols would conflict.  Subsequently including of a different
 * minor version within the same major version is allowed. Functionality of
 * minor versions is cumulative, regardless of include order.
 *
 * Since NVTX3_CPP_REQUIRE_EXPLICIT_VERSION allows all combinations of versions
 * to coexist without problems within a translation unit, the recommended best
 * practice for instrumenting header-based libraries with NVTX C++ Wrappers is
 * is to #define NVTX3_CPP_REQUIRE_EXPLICIT_VERSION before including nvtx3.hpp,
 * #undef it afterward, and only use explicit-version symbols.  This is not
 * necessary in common cases, such as instrumenting a standalone application, or
 * static/shared libraries in .cpp files or headers private to those projects.
 */
/* clang-format off */
#if !defined(NVTX3_CPP_REQUIRE_EXPLICIT_VERSION)
  /* Define macro used by all definitions in this header to indicate the
   * unversioned symbols should be defined in addition to the versioned ones.
   */
  #define NVTX3_INLINE_THIS_VERSION
 
  #if !defined(NVTX3_CPP_INLINED_VERSION_MAJOR)
    /* First occurrence of this header in the translation unit.  Define macros
     * indicating which version shall be used for unversioned symbols.
     */
 
    #define NVTX3_CPP_INLINED_VERSION_MAJOR 1  // NVTX3_CPP_VERSION_MAJOR
 
    #define NVTX3_CPP_INLINED_VERSION_MINOR 1  // NVTX3_CPP_VERSION_MINOR
  #elif NVTX3_CPP_INLINED_VERSION_MAJOR != NVTX3_CPP_VERSION_MAJOR
    /* Unsupported case -- cannot define unversioned symbols for different major versions
     * in the same translation unit.
     */
    #error \
      "Two different major versions of the NVTX C++ Wrappers are being included in a single .cpp file, with unversioned symbols enabled in both.  Only one major version can enable unversioned symbols in a .cpp file.  To disable unversioned symbols, #define NVTX3_CPP_REQUIRE_EXPLICIT_VERSION before #including nvtx3.hpp, and use the explicit-version symbols instead -- this is the preferred way to use nvtx3.hpp from a header file."
  #elif (NVTX3_CPP_INLINED_VERSION_MAJOR == NVTX3_CPP_VERSION_MAJOR) && \
    (NVTX3_CPP_INLINED_VERSION_MINOR < NVTX3_CPP_VERSION_MINOR)
    /* An older minor version of the same major version already defined unversioned
     * symbols.  The new features provided in this header will be inlined
     * redefine the minor version macro to this header's version.
     */
    #undef NVTX3_CPP_INLINED_VERSION_MINOR
    #define NVTX3_CPP_INLINED_VERSION_MINOR 1  // NVTX3_CPP_VERSION_MINOR
    // else, already have this version or newer, nothing to do
  #endif
#endif
/* clang-format on */
 
/* Temporary helper #defines, removed with #undef at end of header */
 
/* Some compilers do not correctly support SFINAE, which is used in this API
 * to detect common usage errors and provide clearer error messages (by using
 * static_assert) than the compiler would produce otherwise.  These compilers
 * will generate errors while compiling this file such as:
 *
 *  error: 'name' is not a member of 'nvtx3::v1::domain::global'
 *
 * The following compiler versions are known to have this problem, and so are
 * set by default to disable the SFINAE-based checks:
 *
 * - All MSVC versions prior to VS2017 Update 7 (15.7)
 * - GCC 8.1-8.3 (the problem was fixed in GCC 8.4)
 *
 * If you find your compiler hits this problem, you can work around it by
 * defining NVTX3_USE_CHECKED_OVERLOADS_FOR_GET to 0 before including this
 * header, or you can add a check for your compiler version to this #if.
 * Also, please report the issue on the NVTX GitHub page.
 */
#if !defined(NVTX3_USE_CHECKED_OVERLOADS_FOR_GET)
#if defined(_MSC_VER) && _MSC_VER < 1914 \
  || defined(__GNUC__) && __GNUC__ == 8 && __GNUC_MINOR__ < 4
#define NVTX3_USE_CHECKED_OVERLOADS_FOR_GET 0
#else
#define NVTX3_USE_CHECKED_OVERLOADS_FOR_GET 1
#endif
#define NVTX3_USE_CHECKED_OVERLOADS_FOR_GET_DEFINED_HERE
#endif
 
/* Within this header, nvtx3::NVTX3_VERSION_NAMESPACE resolves to nvtx3::vX,
 * where "X" is the major version number. */
#define NVTX3_CONCAT(A, B) A##B
#define NVTX3_NAMESPACE_FOR(VERSION) NVTX3_CONCAT(v, VERSION)
#define NVTX3_VERSION_NAMESPACE NVTX3_NAMESPACE_FOR(NVTX3_CPP_VERSION_MAJOR)
/* We use a different prefix to avoid ambiguity with the version namespace */
#define NVTX3_MINOR_NAMESPACE_FOR(VERSION) NVTX3_CONCAT(mv, VERSION)
#define NVTX3_MINOR_VERSION_NAMESPACE NVTX3_MINOR_NAMESPACE_FOR(NVTX3_CPP_VERSION_MINOR)
 
/* Avoid duplicating #if defined(NVTX3_INLINE_THIS_VERSION) for namespaces
 * in each minor version by making a macro to use unconditionally, which
 * resolves to "inline" or nothing as appropriate. */
#if defined(NVTX3_INLINE_THIS_VERSION)
#define NVTX3_INLINE_IF_REQUESTED inline
#else
#define NVTX3_INLINE_IF_REQUESTED
#endif
 
/* Enables the use of constexpr when support for C++14 constexpr is present.
 *
 * Initialization of a class member that is a union to a specific union member
 * can only be done in the body of a constructor, not in a member initializer
 * list.  A constexpr constructor must have an empty body until C++14, so there
 * is no way to make an initializer of a member union constexpr in C++11.  This
 * macro allows making functions constexpr in C++14 or newer, but non-constexpr
 * in C++11 compilation.  It is used here on constructors that initialize their
 * member unions.
 */
#if __cpp_constexpr >= 201304L
#define NVTX3_CONSTEXPR_IF_CPP14 constexpr
#else
#define NVTX3_CONSTEXPR_IF_CPP14
#endif
 
/* Enables the use of constexpr when support for C++20 constexpr is present.
 */
#if __cplusplus >= 202002L
#define NVTX3_CONSTEXPR_IF_CPP20 constexpr
#else
#define NVTX3_CONSTEXPR_IF_CPP20
#endif
 
// Macro wrappers for C++ attributes
#if !defined(__has_cpp_attribute)
#define __has_cpp_attribute(x) 0
#endif
#if __has_cpp_attribute(maybe_unused)
#define NVTX3_MAYBE_UNUSED [[maybe_unused]]
#else
#define NVTX3_MAYBE_UNUSED
#endif
#if __has_cpp_attribute(nodiscard)
#define NVTX3_NO_DISCARD [[nodiscard]]
#else
#define NVTX3_NO_DISCARD
#endif
 
 /* Use a macro for static asserts, which defaults to static_assert, but that
  * testing tools can replace with a logging function.  For example:
  * #define NVTX3_STATIC_ASSERT(c, m) \
  *   do { if (!(c)) printf("static_assert would fail: %s\n", m); } while (0)
  */
#if !defined(NVTX3_STATIC_ASSERT)
#define NVTX3_STATIC_ASSERT(condition, message) static_assert(condition, message)
#define NVTX3_STATIC_ASSERT_DEFINED_HERE
#endif
 
/* Implementation sections, enclosed in guard macros for each minor version */
 
#ifndef NVTX3_CPP_DEFINITIONS_V1_0
#define NVTX3_CPP_DEFINITIONS_V1_0
 
#include "nvToolsExt.h"
#include "nvToolsExtPayload.h"
#include "nvToolsExtPayloadHelper.h"
 
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <cstddef>
#include <cstdint>
 
namespace nvtx3 {
 
NVTX3_INLINE_IF_REQUESTED namespace NVTX3_VERSION_NAMESPACE
{
inline namespace NVTX3_MINOR_VERSION_NAMESPACE
{
 
namespace detail {
 
template <typename Unused>
struct always_false : std::false_type {};
 
template <typename T, typename = void>
struct has_name : std::false_type {};
template <typename T>
struct has_name<T, decltype((void)T::name, void())> : std::true_type {};
 
template <typename T, typename = void>
struct has_id : std::false_type {};
template <typename T>
struct has_id<T, decltype((void)T::id, void())> : std::true_type {};
 
template <typename T, typename = void>
struct has_message : std::false_type {};
template <typename T>
struct has_message<T, decltype((void)T::message, void())> : std::true_type {};
 
template <typename T, typename = void>
struct is_c_string : std::false_type {};
template <typename T>
struct is_c_string<T, typename std::enable_if<
  std::is_convertible<T, char const*   >::value ||
  std::is_convertible<T, wchar_t const*>::value
>::type> : std::true_type {};
 
template <typename T>
using is_uint32 = std::is_same<typename std::decay<T>::type, uint32_t>;
 
template <typename... Args>
static inline void silence_unused(Args const&...) noexcept {}
 
// Type trait to check for a .data() member returning T* or const T*
// Some day, we can just use std::span
template <typename T, typename TD>
struct has_data_member
{
private:
    template <typename U>
    static auto test_data(int) -> decltype(std::declval<const U>().data());
    template <typename>
    static auto test_data(...) -> void;
    using return_type = decltype(test_data<T>(0));
 
public:
    static constexpr bool value =
        std::is_same<return_type, TD*>::value || std::is_same<return_type, TD const*>::value;
};
 
// Type trait to check for a .size() member returning something convertible to size_t
template <typename T>
struct has_size_member
{
private:
    template <typename U>
    static auto test_size(int) -> decltype(std::declval<const U>().size());
    template <typename>
    static auto test_size(...) -> void;
    using return_type = decltype(test_size<T>(0));
 
public:
    static constexpr bool value = !std::is_same<return_type, void>::value &&
                                    std::is_convertible<return_type, size_t>::value;
};
 
template <typename W, typename U, typename = void>
struct is_safe_wrapper_of : std::false_type
{
};
 
template <typename W, typename U>
struct is_safe_wrapper_of<
    W,
    U,
    typename std::enable_if<
        std::is_standard_layout<W>::value && std::is_standard_layout<U>::value &&
        std::is_trivially_copyable<W>::value && std::is_trivially_copyable<U>::value &&
        sizeof(W) == sizeof(U)>::type> : std::true_type
{
};
} // namespace detail
 
class domain {
 public:
  domain(domain const&) = delete;
  domain& operator=(domain const&) = delete;
  domain(domain&&) = delete;
  domain& operator=(domain&&) = delete;
 
  struct global {
  };
 
#if NVTX3_USE_CHECKED_OVERLOADS_FOR_GET
  template <typename D = global,
    typename std::enable_if<
      detail::is_c_string<decltype(D::name)>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static domain const& get() noexcept
  {
    static domain const d(D::name);
    return d;
  }
 
  template <typename D = global,
    typename std::enable_if<
      !detail::is_c_string<decltype(D::name)>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static domain const& get() noexcept
  {
    NVTX3_STATIC_ASSERT(detail::always_false<D>::value,
      "Type used to identify an NVTX domain must contain a static constexpr member "
      "called 'name' of type const char* or const wchar_t* -- 'name' member is not "
      "convertible to either of those types");
    static domain const unused;
    return unused;  // Function must compile for static_assert to be triggered
  }
 
  template <typename D = global,
    typename std::enable_if<
      !detail::has_name<D>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static domain const& get() noexcept
  {
    NVTX3_STATIC_ASSERT(detail::always_false<D>::value,
      "Type used to identify an NVTX domain must contain a static constexpr member "
      "called 'name' of type const char* or const wchar_t* -- 'name' member is missing");
    static domain const unused;
    return unused;  // Function must compile for static_assert to be triggered
  }
#else
  template <typename D = global>
  NVTX3_NO_DISCARD static domain const& get() noexcept
  {
    static domain const d(D::name);
    return d;
  }
#endif
 
  operator nvtxDomainHandle_t() const noexcept { return _domain; }
 
 private:
  explicit domain(char const* name) noexcept : _domain{nvtxDomainCreateA(name)} {}
 
  explicit domain(wchar_t const* name) noexcept : _domain{nvtxDomainCreateW(name)} {}
 
  explicit domain(std::string const& name) noexcept : domain{name.c_str()} {}
 
  explicit domain(std::wstring const& name) noexcept : domain{name.c_str()} {}
 
  constexpr domain() noexcept {}
 
  ~domain() = default;
 
 private:
  nvtxDomainHandle_t const _domain{};  
};
 
template <>
NVTX3_NO_DISCARD inline domain const& domain::get<domain::global>() noexcept
{
  static domain const d{};
  return d;
}
 
struct rgb {
  using component_type = uint8_t;
 
  constexpr rgb(
    component_type red_,
    component_type green_,
    component_type blue_) noexcept
    : red{red_}, green{green_}, blue{blue_}
  {
  }
 
  component_type red{};    
  component_type green{};  
  component_type blue{};   
};
 
struct argb final : rgb {
  constexpr argb(
    component_type alpha_,
    component_type red_,
    component_type green_,
    component_type blue_) noexcept
    : rgb{red_, green_, blue_}, alpha{alpha_}
  {
  }
 
  component_type alpha{};  
};
 
class color {
 public:
  using value_type = uint32_t;
 
  constexpr explicit color(value_type hex_code) noexcept : _value{hex_code} {}
 
  constexpr color(argb argb_) noexcept
    : color{from_bytes_msb_to_lsb(argb_.alpha, argb_.red, argb_.green, argb_.blue)}
  {
  }
 
  constexpr color(rgb rgb_) noexcept
    : color{from_bytes_msb_to_lsb(0xFF, rgb_.red, rgb_.green, rgb_.blue)}
  {
  }
 
  constexpr value_type get_value() const noexcept { return _value; }
 
  constexpr nvtxColorType_t get_type() const noexcept { return _type; }
 
  color() = delete;
  ~color() = default;
  color(color const&) = default;
  color& operator=(color const&) = default;
  color(color&&) = default;
  color& operator=(color&&) = default;
 
 private:
  constexpr static value_type from_bytes_msb_to_lsb(
    uint8_t byte3,
    uint8_t byte2,
    uint8_t byte1,
    uint8_t byte0) noexcept
  {
    return uint32_t{byte3} << 24 | uint32_t{byte2} << 16 | uint32_t{byte1} << 8 | uint32_t{byte0};
  }
 
  value_type _value{};                     
  nvtxColorType_t _type{NVTX_COLOR_ARGB};  
};
 
class category {
 public:
  using id_type = uint32_t;
 
  constexpr explicit category(id_type id) noexcept : id_{id} {}
 
  constexpr id_type get_id() const noexcept { return id_; }
 
  category() = delete;
  ~category() = default;
  category(category const&) = default;
  category& operator=(category const&) = default;
  category(category&&) = default;
  category& operator=(category&&) = default;
 
 private:
  id_type id_{};  
};
 
template <typename D = domain::global>
class named_category_in final : public category {
 public:
#if NVTX3_USE_CHECKED_OVERLOADS_FOR_GET
  template <typename C,
    typename std::enable_if<
      detail::is_c_string<decltype(C::name)>::value &&
      detail::is_uint32<decltype(C::id)>::value
    , int>::type = 0>
  static named_category_in const& get() noexcept
  {
    static named_category_in const cat(C::id, C::name);
    return cat;
  }
 
  template <typename C,
    typename std::enable_if<
      !detail::is_c_string<decltype(C::name)>::value ||
      !detail::is_uint32<decltype(C::id)>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static named_category_in const& get() noexcept
  {
    NVTX3_STATIC_ASSERT(detail::is_c_string<decltype(C::name)>::value,
      "Type used to name an NVTX category must contain a static constexpr member "
      "called 'name' of type const char* or const wchar_t* -- 'name' member is not "
      "convertible to either of those types");
    NVTX3_STATIC_ASSERT(detail::is_uint32<decltype(C::id)>::value,
      "Type used to name an NVTX category must contain a static constexpr member "
      "called 'id' of type uint32_t -- 'id' member is the wrong type");
    static named_category_in const unused;
    return unused;  // Function must compile for static_assert to be triggered
  }
 
  template <typename C,
    typename std::enable_if<
      !detail::has_name<C>::value ||
      !detail::has_id<C>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static named_category_in const& get() noexcept
  {
    NVTX3_STATIC_ASSERT(detail::has_name<C>::value,
      "Type used to name an NVTX category must contain a static constexpr member "
      "called 'name' of type const char* or const wchar_t* -- 'name' member is missing");
    NVTX3_STATIC_ASSERT(detail::has_id<C>::value,
      "Type used to name an NVTX category must contain a static constexpr member "
      "called 'id' of type uint32_t -- 'id' member is missing");
    static named_category_in const unused;
    return unused;  // Function must compile for static_assert to be triggered
  }
#else
  template <typename C>
  NVTX3_NO_DISCARD static named_category_in const& get() noexcept
  {
    static named_category_in const cat(C::id, C::name);
    return cat;
  }
#endif
 
 private:
  // Default constructor is only used internally for static_assert(false) cases.
  named_category_in() noexcept : category{0} {}
 
 public:
  named_category_in(id_type id, char const* name) noexcept : category{id}
  {
#ifndef NVTX_DISABLE
    nvtxDomainNameCategoryA(domain::get<D>(), get_id(), name);
#else
    (void)id;
    (void)name;
#endif
  }
 
  named_category_in(id_type id, wchar_t const* name) noexcept : category{id}
  {
#ifndef NVTX_DISABLE
    nvtxDomainNameCategoryW(domain::get<D>(), get_id(), name);
#else
    (void)id;
    (void)name;
#endif
  }
};
 
using named_category = named_category_in<domain::global>;
 
template <typename D = domain::global>
class registered_string_in {
 public:
#if NVTX3_USE_CHECKED_OVERLOADS_FOR_GET
  template <typename M,
    typename std::enable_if<
      detail::is_c_string<decltype(M::message)>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static registered_string_in const& get() noexcept
  {
    static registered_string_in const regstr(M::message);
    return regstr;
  }
 
  template <typename M,
    typename std::enable_if<
      !detail::is_c_string<decltype(M::message)>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static registered_string_in const& get() noexcept
  {
    NVTX3_STATIC_ASSERT(detail::always_false<M>::value,
      "Type used to register an NVTX string must contain a static constexpr member "
      "called 'message' of type const char* or const wchar_t* -- 'message' member is "
      "not convertible to either of those types");
    static registered_string_in const unused;
    return unused;  // Function must compile for static_assert to be triggered
  }
 
  template <typename M,
    typename std::enable_if<
      !detail::has_message<M>::value
    , int>::type = 0>
  NVTX3_NO_DISCARD static registered_string_in const& get() noexcept
  {
    NVTX3_STATIC_ASSERT(detail::always_false<M>::value,
      "Type used to register an NVTX string must contain a static constexpr member "
      "called 'message' of type const char* or const wchar_t* -- 'message' member "
      "is missing");
    static registered_string_in const unused;
    return unused;  // Function must compile for static_assert to be triggered
  }
#else
  template <typename M>
  NVTX3_NO_DISCARD static registered_string_in const& get() noexcept
  {
    static registered_string_in const regstr(M::message);
    return regstr;
  }
#endif
 
  explicit registered_string_in(char const* msg) noexcept
    : handle_{nvtxDomainRegisterStringA(domain::get<D>(), msg)}
  {
  }
 
  explicit registered_string_in(std::string const& msg) noexcept
    : registered_string_in{msg.c_str()} {}
 
  explicit registered_string_in(wchar_t const* msg) noexcept
    : handle_{nvtxDomainRegisterStringW(domain::get<D>(), msg)}
  {
  }
 
  explicit registered_string_in(std::wstring const& msg) noexcept
    : registered_string_in{msg.c_str()} {}
 
  nvtxStringHandle_t get_handle() const noexcept
  {
    // We want to ensure that we can use the registered_string in place of a handle
    // in a payload data struct.
    NVTX3_STATIC_ASSERT(
      (detail::is_safe_wrapper_of<registered_string_in<D>, nvtxStringHandle_t>::value),
      "Internal error! registered_string_in is potentially unsafe.");
    return handle_;
  }
 
private:
  // Default constructor is only used internally for static_assert(false) cases.
  registered_string_in() noexcept {}
public:
  ~registered_string_in() = default;
  registered_string_in(registered_string_in const&) = default;
  registered_string_in& operator=(registered_string_in const&) = default;
  registered_string_in(registered_string_in&&) = default;
  registered_string_in& operator=(registered_string_in&&) = default;
 
 private:
  nvtxStringHandle_t handle_{};  
};
 
using registered_string = registered_string_in<domain::global>;
 
class message {
 public:
  using value_type = nvtxMessageValue_t;
 
  NVTX3_CONSTEXPR_IF_CPP14 message(char const* msg) noexcept : type_{NVTX_MESSAGE_TYPE_ASCII}
  {
    value_.ascii = msg;
  }
 
  message(std::string const& msg) noexcept : message{msg.c_str()} {}
 
#ifndef NVTX3_ALLOW_RVALUE_CONSTRUCTORS
  message(std::string&&) = delete;
#endif
 
  NVTX3_CONSTEXPR_IF_CPP14 message(wchar_t const* msg) noexcept : type_{NVTX_MESSAGE_TYPE_UNICODE}
  {
    value_.unicode = msg;
  }
 
  message(std::wstring const& msg) noexcept : message{msg.c_str()} {}
 
#ifndef NVTX3_ALLOW_RVALUE_CONSTRUCTORS
  message(std::wstring&&) = delete;
#endif
 
  template <typename D>
  NVTX3_CONSTEXPR_IF_CPP14 message(registered_string_in<D> const& msg) noexcept
    : type_{NVTX_MESSAGE_TYPE_REGISTERED}
  {
    value_.registered = msg.get_handle();
  }
 
  constexpr message(
    nvtxMessageType_t const& type,
    nvtxMessageValue_t const& value) noexcept
    : type_{type}, value_(value)
  {
  }
 
  NVTX3_CONSTEXPR_IF_CPP14 message(nvtxStringHandle_t handle) noexcept
    : type_{NVTX_MESSAGE_TYPE_REGISTERED}
  {
    value_.registered = handle;
  }
 
  constexpr value_type get_value() const noexcept { return value_; }
 
  constexpr nvtxMessageType_t get_type() const noexcept { return type_; }
 
 private:
  nvtxMessageType_t type_{};    
  nvtxMessageValue_t value_{};  
};
 
class payload {
 public:
  using value_type = typename nvtxEventAttributes_v2::payload_t;
 
  NVTX3_CONSTEXPR_IF_CPP14 explicit payload(int64_t value) noexcept
    : type_{NVTX_PAYLOAD_TYPE_INT64}, value_{}
  {
    value_.llValue = value;
  }
 
  NVTX3_CONSTEXPR_IF_CPP14 explicit payload(int32_t value) noexcept
    : type_{NVTX_PAYLOAD_TYPE_INT32}, value_{}
  {
    value_.iValue = value;
  }
 
  NVTX3_CONSTEXPR_IF_CPP14 explicit payload(uint64_t value) noexcept
    : type_{NVTX_PAYLOAD_TYPE_UNSIGNED_INT64}, value_{}
  {
    value_.ullValue = value;
  }
 
  NVTX3_CONSTEXPR_IF_CPP14 explicit payload(uint32_t value) noexcept
    : type_{NVTX_PAYLOAD_TYPE_UNSIGNED_INT32}, value_{}
  {
    value_.uiValue = value;
  }
 
  NVTX3_CONSTEXPR_IF_CPP14 explicit payload(float value) noexcept
    : type_{NVTX_PAYLOAD_TYPE_FLOAT}, value_{}
  {
    value_.fValue = value;
  }
 
  NVTX3_CONSTEXPR_IF_CPP14 explicit payload(double value) noexcept
    : type_{NVTX_PAYLOAD_TYPE_DOUBLE}, value_{}
  {
    value_.dValue = value;
  }
 
  constexpr payload(
    nvtxPayloadType_t const& type,
    value_type const& value) noexcept
    : type_{type}, value_(value)
  {
  }
 
  constexpr value_type get_value() const noexcept { return value_; }
 
  constexpr nvtxPayloadType_t get_type() const noexcept { return type_; }
 
 private:
  nvtxPayloadType_t type_;  
  value_type value_;        
};
 
class schema
{
private:
  schema()
      : _schema_id{0}
  {}
 
  public:
  schema(schema const&) = delete;
  schema& operator=(schema const&) = delete;
  schema(schema&&) = delete;
  schema& operator=(schema&&) = delete;
 
  explicit schema(uint64_t id)
      : _schema_id{id}
  {}
 
  template <typename T>
  NVTX3_NO_DISCARD static schema const& get() noexcept
  {
    NVTX3_STATIC_ASSERT(
        detail::always_false<T>::value,
        "payload_data schema deduction requires a template specialization. Use the macro "
        "NVTX3_DEFINE_SCHEMA_GET to generate this specialization.");
    static schema unused;
    return unused;
  }
 
  uint64_t get_handle() const noexcept
  {
    return _schema_id;
  }
 
private:
  uint64_t const _schema_id;
};
 
class payload_data
{
public:
  explicit payload_data(nvtxPayloadData_t const& pd)
      : data_(pd)
  {}
 
  // We cannot simply delete the rvalue constructor here because with a template
  // parameter that would be a forwarding reference. Thus, we have this one
  // ctor with a forwarding reference and use a static assert for the rvalue check.
  // Disable this for the C-style nvtxPayloadData_t to prefer above ctor for non-const.
  template <
      typename R,
      typename T = typename std::remove_cv<typename std::remove_reference<R>::type>::type,
      typename = typename std::enable_if<!std::is_same<T, nvtxPayloadData_t>::value>::type>
  explicit payload_data(R&& t)
      : data_{schema::get<T>().get_handle(), sizeof(T), &t}
  {
#ifndef NVTX3_ALLOW_RVALUE_CONSTRUCTORS
    NVTX3_STATIC_ASSERT(
        std::is_lvalue_reference<R>::value,
        "payload_data requires an lvalue reference to the underlying data. Constructing "
        "from an rvalue is potentially unsafe and therefore forbidden.");
#endif
    NVTX3_STATIC_ASSERT(
        std::is_standard_layout<T>::value && std::is_trivially_copyable<T>::value,
        "structs used for NVTX3 payload schema must be standard layout and trivially copyable");
  }
 
  template <typename T>
  explicit payload_data(T const& t, schema s)
      : data_{s.get_handle(), sizeof(T), &t}
  {
    NVTX3_STATIC_ASSERT(
        std::is_standard_layout<T>::value && std::is_trivially_copyable<T>::value,
        "structs used for NVTX3 payload schema must be standard layout and trivially copyable");
  }
 
  uint64_t as_ull_value() const noexcept
  {
    NVTX3_STATIC_ASSERT(
        (detail::is_safe_wrapper_of<payload_data, nvtxPayloadData_t>::value),
        "Internal error! payload_data is potentially unsafe.");
    return NVTX_POINTER_AS_PAYLOAD_ULLVALUE(&data_);
  }
 
private:
  nvtxPayloadData_t data_;
};
 
class event_attributes {
 public:
  using value_type = nvtxEventAttributes_t;
 
  constexpr event_attributes() noexcept
    : attributes_{
        NVTX_VERSION,                   // version
        sizeof(nvtxEventAttributes_t),  // size
        0,                              // category
        NVTX_COLOR_UNKNOWN,             // color type
        0,                              // color value
        NVTX_PAYLOAD_UNKNOWN,           // payload type
        0,                              // reserved 4B
        {0},                            // payload value (union)
        NVTX_MESSAGE_UNKNOWN,           // message type
        {nullptr}                       // message value (union)
      }
  {
  }
 
  template <typename... Args>
  NVTX3_CONSTEXPR_IF_CPP14 explicit event_attributes(category const& c, Args const&... args) noexcept
    : event_attributes(args...)
  {
    attributes_.category = c.get_id();
  }
 
  template <typename... Args>
  NVTX3_CONSTEXPR_IF_CPP14 explicit event_attributes(color const& c, Args const&... args) noexcept
    : event_attributes(args...)
  {
    attributes_.color     = c.get_value();
    attributes_.colorType = c.get_type();
  }
 
  template <typename... Args>
  NVTX3_CONSTEXPR_IF_CPP14 explicit event_attributes(payload const& p, Args const&... args) noexcept
    : event_attributes(args...)
  {
    attributes_.payload     = p.get_value();
    attributes_.payloadType = p.get_type();
  }
 
  template <typename... Args>
  NVTX3_CONSTEXPR_IF_CPP14 explicit event_attributes(payload_data const& pd, Args const&... args) noexcept
      : event_attributes(args...)
  {
    attributes_.payloadType = NVTX_PAYLOAD_TYPE_EXT;
    attributes_.reserved0 = 1;
    attributes_.payload.ullValue = pd.as_ull_value();
  }
 
#ifndef NVTX3_ALLOW_RVALUE_CONSTRUCTORS
  template <typename... Args>
  NVTX3_CONSTEXPR_IF_CPP14 explicit event_attributes(payload_data&& pd, Args const&... args) = delete;
#endif
 
  template <
      typename T,
      typename... Args,
      typename = typename std::enable_if<
          detail::has_data_member<T, payload_data>::value && detail::has_size_member<T>::value>::type>
  NVTX3_CONSTEXPR_IF_CPP20 explicit event_attributes(T&& pdc, Args const&... args) noexcept
      : event_attributes(args...)
  {
    NVTX3_STATIC_ASSERT(
        std::is_lvalue_reference<T>::value,
        "event_attributes requires an lvalue reference to the underlying data. "
        "Constructing from an rvalue is potentially unsafe and therefore forbidden.");
    attributes_.payloadType = NVTX_PAYLOAD_TYPE_EXT;
    attributes_.reserved0 = static_cast<int32_t>(pdc.size()); // Cast size to int32_t
    attributes_.payload.ullValue = pdc.data()->as_ull_value();
  }
 
  template <typename... Args>
  NVTX3_CONSTEXPR_IF_CPP14 explicit event_attributes(message const& m, Args const&... args) noexcept
    : event_attributes(args...)
  {
    attributes_.message     = m.get_value();
    attributes_.messageType = m.get_type();
  }
 
  ~event_attributes() = default;
  event_attributes(event_attributes const&) = default;
  event_attributes& operator=(event_attributes const&) = default;
  event_attributes(event_attributes&&) = default;
  event_attributes& operator=(event_attributes&&) = default;
 
  constexpr value_type const* get() const noexcept { return &attributes_; }
 
 private:
  value_type attributes_{};  
};
 
template <class D = domain::global>
class NVTX3_MAYBE_UNUSED scoped_range_in {
 public:
  explicit scoped_range_in(event_attributes const& attr) noexcept
  {
#ifndef NVTX_DISABLE
    nvtxDomainRangePushEx(domain::get<D>(), attr.get());
#else
    (void)attr;
#endif
  }
 
  template <typename... Args>
  explicit scoped_range_in(Args const&... args) noexcept
    : scoped_range_in{event_attributes{args...}}
  {
  }
 
  scoped_range_in() noexcept : scoped_range_in{event_attributes{}} {}
 
  void* operator new(std::size_t) = delete;
 
  scoped_range_in(scoped_range_in const&) = delete;
  scoped_range_in& operator=(scoped_range_in const&) = delete;
  scoped_range_in(scoped_range_in&&) = delete;
  scoped_range_in& operator=(scoped_range_in&&) = delete;
 
  ~scoped_range_in() noexcept
  {
#ifndef NVTX_DISABLE
    nvtxDomainRangePop(domain::get<D>());
#endif
  }
};
 
using scoped_range = scoped_range_in<domain::global>;
 
namespace detail {
 
template <typename D = domain::global>
class NVTX3_MAYBE_UNUSED optional_scoped_range_in
{
public:
  optional_scoped_range_in() = default;
 
  void begin(event_attributes const& attr) noexcept
  {
#ifndef NVTX_DISABLE
    // This class is not meant to be part of the public NVTX C++ API and should
    // only be used in the `NVTX3_FUNC_RANGE_IF` and `NVTX3_FUNC_RANGE_IF_IN`
    // macros. However, to prevent developers from misusing this class, make
    // sure to not start multiple ranges.
    if (initialized) { return; }
 
    nvtxDomainRangePushEx(domain::get<D>(), attr.get());
    initialized = true;
#else
    (void)attr;
#endif
  }
 
  ~optional_scoped_range_in() noexcept
  {
#ifndef NVTX_DISABLE
    if (initialized) { nvtxDomainRangePop(domain::get<D>()); }
#endif
  }
 
  void* operator new(std::size_t) = delete;
  optional_scoped_range_in(optional_scoped_range_in const&) = delete;
  optional_scoped_range_in& operator=(optional_scoped_range_in const&) = delete;
  optional_scoped_range_in(optional_scoped_range_in&&) = delete;
  optional_scoped_range_in& operator=(optional_scoped_range_in&&) = delete;
 
private:
#ifndef NVTX_DISABLE
  bool initialized = false;
#endif
};
 
} // namespace detail
 
struct range_handle {
  using value_type = nvtxRangeId_t;
 
 
  constexpr explicit range_handle(value_type id) noexcept : _range_id{id} {}
 
  constexpr range_handle() noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return get_value() != null_range_id; }
 
  constexpr range_handle(std::nullptr_t) noexcept {}
 
  constexpr value_type get_value() const noexcept { return _range_id; }
 
 private:
  static constexpr value_type null_range_id = nvtxRangeId_t{0};
 
  value_type _range_id{null_range_id};  
};
 
inline constexpr bool operator==(range_handle lhs, range_handle rhs) noexcept
{
  return lhs.get_value() == rhs.get_value();
}
 
inline constexpr bool operator!=(range_handle lhs, range_handle rhs) noexcept { return !(lhs == rhs); }
 
template <typename D = domain::global>
NVTX3_NO_DISCARD inline range_handle start_range_in(event_attributes const& attr) noexcept
{
#ifndef NVTX_DISABLE
  return range_handle{nvtxDomainRangeStartEx(domain::get<D>(), attr.get())};
#else
  (void)attr;
  return {};
#endif
}
 
template <typename D = domain::global, typename... Args>
NVTX3_NO_DISCARD inline range_handle start_range_in(Args const&... args) noexcept
{
#ifndef NVTX_DISABLE
  return start_range_in<D>(event_attributes{args...});
#else
  detail::silence_unused(args...);
  return {};
#endif
}
 
NVTX3_NO_DISCARD inline range_handle start_range(event_attributes const& attr) noexcept
{
#ifndef NVTX_DISABLE
  return start_range_in<domain::global>(attr);
#else
  (void)attr;
  return {};
#endif
}
 
template <typename... Args>
NVTX3_NO_DISCARD inline range_handle start_range(Args const&... args) noexcept
{
#ifndef NVTX_DISABLE
  return start_range_in<domain::global>(args...);
#else
  detail::silence_unused(args...);
  return {};
#endif
}
 
template <typename D = domain::global>
inline void end_range_in(range_handle r) noexcept
{
#ifndef NVTX_DISABLE
  nvtxDomainRangeEnd(domain::get<D>(), r.get_value());
#else
  (void)r;
#endif
}
 
inline void end_range(range_handle r) noexcept
{
#ifndef NVTX_DISABLE
  end_range_in<domain::global>(r);
#else
  (void)r;
#endif
}
 
template <typename D = domain::global>
class NVTX3_MAYBE_UNUSED unique_range_in {
 public:
  explicit unique_range_in(event_attributes const& attr) noexcept
    : handle_{start_range_in<D>(attr)}
  {
  }
 
  template <typename... Args>
  explicit unique_range_in(Args const&... args) noexcept
    : unique_range_in{event_attributes{args...}}
  {
  }
 
  constexpr unique_range_in() noexcept : unique_range_in{event_attributes{}} {}
 
  ~unique_range_in() noexcept = default;
 
  unique_range_in(unique_range_in&& other) noexcept = default;
 
  unique_range_in& operator=(unique_range_in&& other) noexcept = default;
 
  unique_range_in(unique_range_in const&) = delete;
 
  unique_range_in& operator=(unique_range_in const&) = delete;
 
 private:
 
  struct end_range_handle {
    using pointer = range_handle;  
    void operator()(range_handle h) const noexcept { end_range_in<D>(h); }
  };
 
  std::unique_ptr<range_handle, end_range_handle> handle_;
};
 
using unique_range = unique_range_in<domain::global>;
 
template <typename D = domain::global>
inline void mark_in(event_attributes const& attr) noexcept
{
#ifndef NVTX_DISABLE
  nvtxDomainMarkEx(domain::get<D>(), attr.get());
#else
  (void)(attr);
#endif
}
 
template <typename D = domain::global, typename... Args>
inline void mark_in(Args const&... args) noexcept
{
#ifndef NVTX_DISABLE
  mark_in<D>(event_attributes{args...});
#else
  detail::silence_unused(args...);
#endif
}
 
inline void mark(event_attributes const& attr) noexcept
{
#ifndef NVTX_DISABLE
  mark_in<domain::global>(attr);
#else
  (void)attr;
#endif
}
 
template <typename... Args>
inline void mark(Args const&... args) noexcept
{
#ifndef NVTX_DISABLE
  mark_in<domain::global>(args...);
#else
  detail::silence_unused(args...);
#endif
}
 
}  // namespace NVTX3_MINOR_VERSION_NAMESPACE
}  // namespace NVTX3_VERSION_NAMESPACE
} // namespace nvtx3
 
#ifndef NVTX_DISABLE
#define NVTX3_V1_FUNC_RANGE_IN(D)                                                  \
  static ::nvtx3::v1::registered_string_in<D> const nvtx3_func_name__{__func__};   \
  static ::nvtx3::v1::event_attributes const nvtx3_func_attr__{nvtx3_func_name__}; \
  ::nvtx3::v1::scoped_range_in<D> const nvtx3_range__{nvtx3_func_attr__}
 
#define NVTX3_V1_FUNC_RANGE_IF_IN(D, C) \
  ::nvtx3::v1::detail::optional_scoped_range_in<D> optional_nvtx3_range__;           \
  if (C) {                                                                           \
    static ::nvtx3::v1::registered_string_in<D> const nvtx3_func_name__{__func__};   \
    static ::nvtx3::v1::event_attributes const nvtx3_func_attr__{nvtx3_func_name__}; \
    optional_nvtx3_range__.begin(nvtx3_func_attr__);                                 \
  } (void)0
#else /* NVTX_DISABLE */
#define NVTX3_V1_FUNC_RANGE_IN(D) (void)0
#define NVTX3_V1_FUNC_RANGE_IF_IN(D, C) (void)(C)
#endif /* NVTX_DISABLE */
 
#define NVTX3_V1_FUNC_RANGE() NVTX3_V1_FUNC_RANGE_IN(::nvtx3::v1::domain::global)
 
#define NVTX3_V1_FUNC_RANGE_IF(C) NVTX3_V1_FUNC_RANGE_IF_IN(::nvtx3::v1::domain::global, C)
 
// We need another helper macro because the other one will get undefined
#if __has_cpp_attribute(nodiscard)
#define NVTX3_V1_NO_DISCARD [[nodiscard]]
#else
#define NVTX3_V1_NO_DISCARD
#endif
#define NVTX3_V1_DEFINE_SCHEMA_GET(dom, struct_id, schema_name, entries)                               \
    template <>                                                                                        \
    NVTX3_V1_NO_DISCARD inline nvtx3::v1::schema const& nvtx3::v1::schema::get<struct_id>() noexcept   \
    {                                                                                                  \
        static_assert(                                                                                 \
            std::is_standard_layout<struct_id>::value,                                                 \
            "structs used for NVTX3 payload schema must be standard layout");                          \
        static_assert(                                                                                 \
            std::is_trivially_copyable<struct_id>::value,                                              \
            "structs used for NVTX3 payload schema must be trivially copyable");                       \
        using nvtx_struct_id = struct_id; /* avoids issues with namespaced struct_id */                \
        _NVTX_DEFINE_SCHEMA_FOR_STRUCT(nvtx_struct_id, schema_name, static constexpr, entries)         \
        static const schema s{                                                                         \
            nvtxPayloadSchemaRegister(nvtx3::v1::domain::get<dom>(), &nvtx_struct_id##Attr)};          \
        return s;                                                                                      \
    }
 
/* When inlining this version, versioned macros must have unversioned aliases.
 * For each NVTX3_Vx_ #define, make an NVTX3_ alias of it here.*/
#if defined(NVTX3_INLINE_THIS_VERSION)
/* clang format off */
#define NVTX3_FUNC_RANGE        NVTX3_V1_FUNC_RANGE
#define NVTX3_FUNC_RANGE_IF     NVTX3_V1_FUNC_RANGE_IF
#define NVTX3_FUNC_RANGE_IN     NVTX3_V1_FUNC_RANGE_IN
#define NVTX3_FUNC_RANGE_IF_IN  NVTX3_V1_FUNC_RANGE_IF_IN
#define NVTX3_DEFINE_SCHEMA_GET NVTX3_V1_DEFINE_SCHEMA_GET
/* clang format on */
#endif
 
#endif  // NVTX3_CPP_DEFINITIONS_V1_0
 
/* Add functionality for new minor versions here, by copying the above section enclosed
 * in #ifndef NVTX3_CPP_DEFINITIONS_Vx_y, and incrementing the minor version.  This code
 * is an example of how additions for version 1.2 would look, indented for clarity.  Note
 * that the versioned symbols and macros are always provided, and the unversioned symbols
 * are only provided if NVTX3_INLINE_THIS_VERSION was defined at the top of this header.
 *
 * \code{.cpp}
 * #ifndef NVTX3_CPP_DEFINITIONS_V1_2
 * #define NVTX3_CPP_DEFINITIONS_V1_2
 *     namespace nvtx3 {
 *         NVTX3_INLINE_IF_REQUESTED namespace NVTX3_VERSION_NAMESPACE {
 *             class new_class {};
 *             inline void new_function() {}
 *         }
 *     }
 *
 *     // Macros must have the major version in their names:
 *     #define NVTX3_V1_NEW_MACRO_A() ...
 *     #define NVTX3_V1_NEW_MACRO_B() ...
 *
 *     // If inlining, make aliases for the macros with the version number omitted
 *     #if defined(NVTX3_INLINE_THIS_VERSION)
 *         #define NVTX3_NEW_MACRO_A NVTX3_V1_NEW_MACRO_A
 *         #define NVTX3_NEW_MACRO_B NVTX3_V1_NEW_MACRO_B
 *     #endif
 * #endif // NVTX3_CPP_DEFINITIONS_V1_2
 * \endcode
 */
 
/* Undefine all temporarily-defined unversioned macros, which would conflict with
 * subsequent includes of different versions of this header. */
#undef NVTX3_CPP_VERSION_MAJOR
#undef NVTX3_CPP_VERSION_MINOR
#undef NVTX3_CONCAT
#undef NVTX3_NAMESPACE_FOR
#undef NVTX3_VERSION_NAMESPACE
#undef NVTX3_MINOR_NAMESPACE_FOR
#undef NVTX3_MINOR_VERSION_NAMESPACE
#undef NVTX3_INLINE_IF_REQUESTED
#undef NVTX3_CONSTEXPR_IF_CPP14
#undef NVTX3_MAYBE_UNUSED
#undef NVTX3_NO_DISCARD
 
#if defined(NVTX3_INLINE_THIS_VERSION)
#undef NVTX3_INLINE_THIS_VERSION
#endif
 
#if defined(NVTX3_USE_CHECKED_OVERLOADS_FOR_GET_DEFINED_HERE)
#undef NVTX3_USE_CHECKED_OVERLOADS_FOR_GET_DEFINED_HERE
#undef NVTX3_USE_CHECKED_OVERLOADS_FOR_GET
#endif
 
#if defined(NVTX3_STATIC_ASSERT_DEFINED_HERE)
#undef NVTX3_STATIC_ASSERT_DEFINED_HERE
#undef NVTX3_STATIC_ASSERT
#endif