| // Copyright 2024 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // IWYU pragma: private, include "src/storage/lib/trace/trace.h" | |
| #ifndef SRC_STORAGE_LIB_TRACE_TRACE_DISABLED_H_ | |
| #define SRC_STORAGE_LIB_TRACE_TRACE_DISABLED_H_ | |
| #include <cstddef> | |
| #include <cstdint> | |
| #include <type_traits> | |
| #include <fbl/string_traits.h> | |
| namespace storage::trace { | |
| namespace internal { | |
| template <typename T> | |
| inline constexpr bool is_bool_v = std::is_same_v<T, bool>; | |
| template <typename T, typename Enable = void> | |
| struct TraceArg; | |
| template <> | |
| struct TraceArg<std::nullptr_t> { | |
| static void Accept(std::nullptr_t arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg<T, typename std::enable_if_t<is_bool_v<T>>> { | |
| static void Accept(bool arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg<T, typename std::enable_if_t<std::is_signed_v<T> && std::is_integral_v<T> && | |
| (sizeof(T) <= sizeof(int32_t))>> { | |
| static void Accept(int32_t arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg<T, | |
| typename std::enable_if_t<!is_bool_v<T> && std::is_unsigned_v<T> && | |
| !std::is_enum_v<T> && (sizeof(T) <= sizeof(uint32_t))>> { | |
| static void Accept(uint32_t arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg< | |
| T, typename std::enable_if_t<std::is_signed_v<T> && std::is_integral_v<T> && | |
| (sizeof(T) > sizeof(int32_t)) && (sizeof(T) <= sizeof(int64_t))>> { | |
| static void Accept(int64_t arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg<T, typename std::enable_if_t<std::is_unsigned_v<T> && !std::is_enum_v<T> && | |
| (sizeof(T) > sizeof(uint32_t)) && | |
| (sizeof(T) <= sizeof(uint64_t))>> { | |
| static void Accept(uint64_t arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg<T, typename std::enable_if_t<std::is_enum_v<T>>> { | |
| using UnderlyingType = std::underlying_type_t<T>; | |
| static void Accept(UnderlyingType arg) { TraceArg<UnderlyingType>::Accept(arg); } | |
| }; | |
| template <typename T> | |
| struct TraceArg<T, typename std::enable_if_t<std::is_floating_point_v<T>>> { | |
| static void Accept(double arg) {} | |
| }; | |
| template <size_t ArgSize> | |
| struct TraceArg<char[ArgSize]> { | |
| static void Accept(const char* arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg<T, typename std::enable_if_t<fbl::is_string_like_v<T>>> { | |
| static void Accept(const T& arg) {} | |
| }; | |
| template <typename T> | |
| struct TraceArg<T*> { | |
| static void Accept(const T* arg) {} | |
| }; | |
| // Base case for the recursive variadic template expansion. | |
| inline void TraceArgs() {} | |
| // Ensures that all of the argument names are string literals and all of the argument types will be | |
| // accepted by the real tracing library. | |
| template <size_t NameSize, typename Arg, typename... Args> | |
| inline void TraceArgs(const char (&name)[NameSize], const Arg& arg, Args&&... args) { | |
| TraceArg<Arg>::Accept(arg); | |
| TraceArgs(std::forward<Args>(args)...); | |
| } | |
| // Mimics the type checking done on the real duration macros to ensure that code written without | |
| // tracing enabled will compile when tracing is enabled. | |
| template <size_t CategorySize, size_t NameSize, typename... Args> | |
| inline void TraceDuration(const char (&category)[CategorySize], const char (&name)[NameSize], | |
| Args&&... args) { | |
| TraceArgs(std::forward<Args>(args)...); | |
| } | |
| // Mimics the type checking done on the real flow macros to ensure that code written without tracing | |
| // enabled will compile when tracing is enabled. | |
| template <size_t CategorySize, size_t NameSize, typename... Args> | |
| inline void TraceFlow(const char (&category)[CategorySize], const char (&name)[NameSize], | |
| uint64_t flow_id, Args&&... args) { | |
| TraceArgs(std::forward<Args>(args)...); | |
| } | |
| } // namespace internal | |
| // Generates a trace ID that will be unique across the system (barring overflow of the per-process | |
| // nonce, reuse of a zx_handle_t for two processes, or some other code in this process which uses | |
| // the same procedure to generate IDs). | |
| // | |
| // We use this instead of the standard TRACE_NONCE because TRACE_NONCE is only unique within a | |
| // process; we need IDs that are unique across all processes. | |
| inline uint64_t GenerateTraceId() { return 0; } | |
| } // namespace storage::trace | |
| #define TRACE_DURATION(category, name, ...) \ | |
| ::storage::trace::internal::TraceDuration(category, name, ##__VA_ARGS__) | |
| #define TRACE_DURATION_BEGIN(category, name, ...) \ | |
| ::storage::trace::internal::TraceDuration(category, name, ##__VA_ARGS__) | |
| #define TRACE_DURATION_END(category, name, ...) \ | |
| ::storage::trace::internal::TraceDuration(category, name, ##__VA_ARGS__) | |
| #define TRACE_FLOW_BEGIN(category, name, flow_id, ...) \ | |
| ::storage::trace::internal::TraceFlow(category, name, flow_id, ##__VA_ARGS__) | |
| #define TRACE_FLOW_STEP(category, name, flow_id, ...) \ | |
| ::storage::trace::internal::TraceFlow(category, name, flow_id, ##__VA_ARGS__) | |
| #define TRACE_FLOW_END(category, name, flow_id, ...) \ | |
| ::storage::trace::internal::TraceFlow(category, name, flow_id, ##__VA_ARGS__) | |
| #define TRACE_NONCE() 0 | |
| inline uint64_t GenerateTraceId() { return 0; } | |
| #endif // SRC_STORAGE_LIB_TRACE_TRACE_DISABLED_H_ |