nvtx3.hpp

Go to the documentation of this file.

/*
 *  Copyright 2019 Jacob Hemstad
 *
 *  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.
 */
#pragma once

#if defined(NVTX3_MINOR_VERSION) and NVTX3_MINOR_VERSION < 0
#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

#define NVTX3_MINOR_VERSION 0

#include <nvToolsExt.h>

#include <string>

#if __cpp_constexpr >= 201304L
#define NVTX3_RELAXED_CONSTEXPR constexpr
#else
#define NVTX3_RELAXED_CONSTEXPR
#endif

namespace nvtx3 {
namespace detail {

template <typename T>
constexpr auto has_name_member() noexcept -> decltype(T::name, bool()) {
  return (std::is_same<char const*,
                       typename std::decay<decltype(T::name)>::type>::value or
          std::is_same<wchar_t const*,
                       typename std::decay<decltype(T::name)>::type>::value);
}
}  // namespace detail

class domain {
 public:
  domain(domain const&) = delete;
  domain& operator=(domain const&) = delete;
  domain(domain&&) = delete;
  domain& operator=(domain&&) = delete;

  template <typename DomainName>
  static domain const& get() {
    static_assert(detail::has_name_member<DomainName>(),
                  "Type used to identify a domain must contain a name member of"
                  "type const char* or const wchar_t*");
    static domain const d{DomainName::name};
    return d;
  }

  operator nvtxDomainHandle_t() const noexcept { return _domain; }

  struct global {};

 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()} {}

  domain() = default;

  ~domain() noexcept { nvtxDomainDestroy(_domain); }

 private:
  nvtxDomainHandle_t const _domain{};  
};

template <>
inline domain const& domain::get<domain::global>() {
  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 const red{};    
  component_type const green{};  
  component_type const 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 const 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 const _value{};                     
  nvtxColorType_t const _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 const id_{};  
};

template <typename D = domain::global>
class named_category final : public category {
 public:
  template <typename C>
  static named_category<D> const& get() noexcept {
    static_assert(detail::has_name_member<C>(),
                  "Type used to name a category must contain a name member.");
    static named_category<D> const category{C::id, C::name};
    return category;
  }
  named_category(id_type id, char const* name) noexcept : category{id} {
    nvtxDomainNameCategoryA(domain::get<D>(), get_id(), name);
  };

  named_category(id_type id, wchar_t const* name) noexcept : category{id} {
    nvtxDomainNameCategoryW(domain::get<D>(), get_id(), name);
  };
};

template <typename D = domain::global>
class registered_message {
 public:
  template <typename M>
  static registered_message<D> const& get() noexcept {
    static registered_message<D> const registered_message{M::message};
    return registered_message;
  }

  explicit registered_message(char const* msg) noexcept
      : handle_{nvtxDomainRegisterStringA(domain::get<D>(), msg)} {}

  explicit registered_message(std::string const& msg) noexcept
      : registered_message{msg.c_str()} {}

  explicit registered_message(wchar_t const* msg) noexcept
      : handle_{nvtxDomainRegisterStringW(domain::get<D>(), msg)} {}

  explicit registered_message(std::wstring const& msg) noexcept
      : registered_message{msg.c_str()} {}

  nvtxStringHandle_t get_handle() const noexcept { return handle_; }

  registered_message() = delete;
  ~registered_message() = default;
  registered_message(registered_message const&) = default;
  registered_message& operator=(registered_message const&) = default;
  registered_message(registered_message&&) = default;
  registered_message& operator=(registered_message&&) = default;

 private:
  nvtxStringHandle_t const handle_{};  
};

class message {
 public:
  using value_type = nvtxMessageValue_t;

  NVTX3_RELAXED_CONSTEXPR message(char const* msg) noexcept
      : type_{NVTX_MESSAGE_TYPE_ASCII} {
    value_.ascii = msg;
  }

  message(std::string const& msg) noexcept : message{msg.c_str()} {}

  message(std::string&&) = delete;

  NVTX3_RELAXED_CONSTEXPR message(wchar_t const* msg) noexcept
      : type_{NVTX_MESSAGE_TYPE_UNICODE} {
    value_.unicode = msg;
  }

  message(std::wstring const& msg) noexcept : message{msg.c_str()} {}

  message(std::wstring&&) = delete;

  template <typename D>
  NVTX3_RELAXED_CONSTEXPR message(registered_message<D> const& msg) noexcept
      : type_{NVTX_MESSAGE_TYPE_REGISTERED} {
    value_.registered = msg.get_handle();
  }

  NVTX3_RELAXED_CONSTEXPR value_type get_value() const noexcept {
    return value_;
  }

  NVTX3_RELAXED_CONSTEXPR nvtxMessageType_t get_type() const noexcept {
    return type_;
  }

 private:
  nvtxMessageType_t const type_{};  
  nvtxMessageValue_t value_{};      
};

class payload {
 public:
  using value_type = typename nvtxEventAttributes_v2::payload_t;

  NVTX3_RELAXED_CONSTEXPR explicit payload(int64_t value) noexcept
      : type_{NVTX_PAYLOAD_TYPE_INT64}, value_{} {
    value_.llValue = value;
  }

  NVTX3_RELAXED_CONSTEXPR explicit payload(int32_t value) noexcept
      : type_{NVTX_PAYLOAD_TYPE_INT32}, value_{} {
    value_.iValue = value;
  }

  NVTX3_RELAXED_CONSTEXPR explicit payload(uint64_t value) noexcept
      : type_{NVTX_PAYLOAD_TYPE_UNSIGNED_INT64}, value_{} {
    value_.ullValue = value;
  }

  NVTX3_RELAXED_CONSTEXPR explicit payload(uint32_t value) noexcept
      : type_{NVTX_PAYLOAD_TYPE_UNSIGNED_INT32}, value_{} {
    value_.uiValue = value;
  }

  NVTX3_RELAXED_CONSTEXPR explicit payload(float value) noexcept
      : type_{NVTX_PAYLOAD_TYPE_FLOAT}, value_{} {
    value_.fValue = value;
  }

  NVTX3_RELAXED_CONSTEXPR explicit payload(double value) noexcept
      : type_{NVTX_PAYLOAD_TYPE_DOUBLE}, value_{} {
    value_.dValue = value;
  }

  NVTX3_RELAXED_CONSTEXPR value_type get_value() const noexcept {
    return value_;
  }

  NVTX3_RELAXED_CONSTEXPR nvtxPayloadType_t get_type() const noexcept {
    return type_;
  }

 private:
  nvtxPayloadType_t const type_;  
  value_type value_;              
};

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
            {},                             // payload value (union)
            NVTX_MESSAGE_UNKNOWN,           // message type
            {}                              // message value (union)
        } {}

  template <typename... Args>
  NVTX3_RELAXED_CONSTEXPR explicit event_attributes(
      category const& c, Args const&... args) noexcept
      : event_attributes(args...) {
    attributes_.category = c.get_id();
  }

  template <typename... Args>
  NVTX3_RELAXED_CONSTEXPR 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_RELAXED_CONSTEXPR 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_RELAXED_CONSTEXPR 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 domain_thread_range {
 public:
  explicit domain_thread_range(event_attributes const& attr) noexcept {
    nvtxDomainRangePushEx(domain::get<D>(), attr.get());
  }

  template <typename First, typename... Args,
            typename = typename std::enable_if<not std::is_same<
                event_attributes, typename std::decay<First>>::value>>
  explicit domain_thread_range(First const& first, Args const&... args) noexcept
      : domain_thread_range{event_attributes{first, args...}} {}

  domain_thread_range() : domain_thread_range{event_attributes{}} {}

  domain_thread_range(domain_thread_range const&) = delete;
  domain_thread_range& operator=(domain_thread_range const&) = delete;
  domain_thread_range(domain_thread_range&&) = delete;
  domain_thread_range& operator=(domain_thread_range&&) = delete;

  ~domain_thread_range() noexcept { nvtxDomainRangePop(domain::get<D>()); }
};

using thread_range = domain_thread_range<>;

template <typename D = domain::global>
class domain_process_range {
 public:
  explicit domain_process_range(event_attributes const& attr) noexcept
      : range_id_{nvtxDomainRangeStartEx(domain::get<D>(), attr.get())} {}

  template <typename First, typename... Args,
            typename = typename std::enable_if<not std::is_same<
                event_attributes, typename std::decay<First>>::value>>
  explicit domain_process_range(First const& first,
                                Args const&... args) noexcept
      : domain_process_range{event_attributes{first, args...}} {}

  constexpr domain_process_range() noexcept
      : domain_process_range{event_attributes{}} {}

  ~domain_process_range() noexcept {
    if (not moved_from_) {
      nvtxRangeEnd(range_id_);
    }
  }

  domain_process_range(domain_process_range const&) = delete;
  domain_process_range& operator=(domain_process_range const&) = delete;

  domain_process_range(domain_process_range&& other) noexcept
      : range_id_{other.range_id_} {
    other.moved_from_ = true;
  }

  domain_process_range& operator=(domain_process_range&& other) noexcept {
    range_id_ = other.range_id_;
    other.moved_from_ = true;
  }

 private:
  nvtxRangeId_t range_id_;  
  bool moved_from_{false};  
};

using process_range = domain_process_range<>;

template <typename D = nvtx3::domain::global>
inline void mark(event_attributes const& attr) noexcept {
  nvtxDomainMarkEx(domain::get<D>(), attr.get());
}

}  // namespace nvtx3

#define NVTX3_FUNC_RANGE_IN(D)                                                 \
  static ::nvtx3::registered_message<D> const nvtx3_func_name__{__func__};     \
  static ::nvtx3::event_attributes const nvtx3_func_attr__{nvtx3_func_name__}; \
  ::nvtx3::domain_thread_range<D> const nvtx3_range__{nvtx3_func_attr__};

#define NVTX3_FUNC_RANGE() NVTX3_FUNC_RANGE_IN(::nvtx3::domain::global)