TraceStructures.hpp

Go to the documentation of this file.

 
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA CORPORATION & AFFILIATES assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA CORPORATION & AFFILIATES. No third party distribution is allowed unless
// expressly authorized by NVIDIA. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA CORPORATION & AFFILIATES products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA CORPORATION & AFFILIATES.
//
// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.
//
 
#ifndef DWTRACE_TRACE_STRUCTURES_HPP_
#define DWTRACE_TRACE_STRUCTURES_HPP_
 
#include <dwtrace/dw/trace/TraceTypes.hpp>
 
namespace dw
{
namespace trace
{
 
enum class TraceHeaderType
{
    NONE = 0,
    MARKER,
    RANGE_BEGIN,
    RANGE_END,
    ASYNC_RANGE_BEGIN,
    ASYNC_RANGE_END,
    CUDA_BEGIN,
    CUDA_END,
    SCOPE
};
 
enum class TraceChannel
{
    DEFAULT = 0,
    LATENCY,
    CAMERA,
    PIPELINE,
    COMM,
    RENDER,
    RADAR,
    STARTUP,
    DATA_LATENCY,
    ROADCAST,
    VDC,
    DW,
    PROFILING,
    SHUTDOWN,
    MAX_CHANNEL
};
 
enum class Level
{
    NONE      = 0,
    LEVEL_10  = 10,
    LEVEL_20  = 20,
    LEVEL_30  = 30,
    LEVEL_50  = 50,
    LEVEL_70  = 70,
    LEVEL_100 = 100,
};
 
static constexpr size_t NUM_LEVELS{static_cast<size_t>(Level::LEVEL_100) + 1UL};
 
static constexpr Level DW_TRACE_LEVEL_DEFAULT{Level::LEVEL_30};
 
enum class Backend
{
    FILEBASED = 0,
    IBACKEND,
    NVTX = IBACKEND,
    FTRACE,
    MAX_BACKEND
};
 
static const dw::core::StaticHashMap<sv, Level, NUM_LEVELS> nameToLevelMap{
    {sv{"NONE"}, Level::NONE},
    {sv{"LEVEL_10"}, Level::LEVEL_10},
    {sv{"LEVEL_20"}, Level::LEVEL_20},
    {sv{"LEVEL_30"}, Level::LEVEL_30},
    {sv{"LEVEL_50"}, Level::LEVEL_50},
    {sv{"LEVEL_70"}, Level::LEVEL_70},
    {sv{"LEVEL_100"}, Level::LEVEL_100},
};
 
struct TracerConfig
{
    // Enable tracing.
    bool enabled = false;
    // File path where Trace*.txt will be stored if fileBackend is enabled.
    dwtStringFilepath_t filePath = {};
    // DWTrace supports total 32 channels. Following mask allows to enable/
    // disable specific channels.
    uint64_t channelMask = 0;
    // Enable filebased backend. For this backend post processing
    // script dwTrace.py is needed to infer results.
    bool fileBackendEnabled = false;
    // Max file size of generated filebackend based dwtrace.
    // After this file limit reached log rotation will start.
    uint32_t maxFileSizeMB = 0;
    // Enable NVTx backend.
    bool nvtxBackendEnabled = false;
    // Global tracing level, any trace which has level greater than this
    // level will be ignored.
    Level tracingLevel = Level::NONE;
    // Number of frames after which flusing to backend will be called.
    uint32_t flushInterval = 0;
    // Enable ftrace backend.
    bool ftraceBackendEnabled = false;
    // Enable memory usage trace
    bool memTraceEnabled = false;
    // Enable memory usage trace outside of STARTUP channel
    bool fullMemUsage = false;
    // Enable disk io usage(read/write bytes, io delay total) trace. Disk IO operation
    // mainly happens when running application after boot. After that data is cached(Depends upon OS and System memory)
    // For now this info will be dumped for STARTUP channels BEGIN/END, as it is expected that major IO operation happens during program init phase.
    bool diskIOStatsEnabled = false;
    // Start time of roadrunner
    dwtFixedString_t startTime = {};
    // Create Cuda Events
    bool createCudaEvents = true;
 
    TracerConfig() = default;
    TracerConfig(bool const enabledFlag, char8_t const* const fileLoc, uint64_t const chanMask,
                 bool const fileBackendFlag, uint32_t const fileSize, bool const nvtxBackendFlag,
                 uint32_t const traceLevel, uint32_t const flushEpoch, bool const ftraceFlag,
                 bool const memTraceFlag, bool const fullMemUse, bool const diskIOStats,
                 char8_t const* const start = nullptr, bool const& createCudaEventsFlag = true)
        : enabled(enabledFlag), filePath(fileLoc), channelMask(chanMask), fileBackendEnabled(fileBackendFlag), maxFileSizeMB(fileSize), nvtxBackendEnabled(nvtxBackendFlag), tracingLevel(static_cast<Level>(traceLevel)), flushInterval((flushEpoch > DW_TRACE_MAX_NUM_EVENTS_PER_CHAN) ? DW_TRACE_MAX_NUM_EVENTS_PER_CHAN : flushEpoch), ftraceBackendEnabled(ftraceFlag), memTraceEnabled(memTraceFlag), fullMemUsage(fullMemUse), diskIOStatsEnabled(diskIOStats), startTime(start), createCudaEvents(createCudaEventsFlag)
    {
    }
};
 
struct dwtEvent_t // clang-tidy NOLINT(readability-identifier-naming)
{
    Level level;              // level of events
    TraceChannel channel;     // synchronized event channel, suggest one per thread
    TraceHeaderType type;     // event type, marker or range
    dwtFixedString_t tag;     // event tag
    float32_t duration;       // duration of particular event
    dwtFixedString_t payload; // event payload
 
    const char* func;            // function name of where event comes from.
    const char* deviceName;      // Name of device on which task is running.
    size_t const deviceMemFree;  // Usage of device memory at runtime
    const int32_t hostMemUsed;   // Usage of host memory at runtime (32-bit signed int, converted to size_t during post-processing)
    uint64_t const nvMapMemUsed; // Usage of nvMap memory at runtime
    uint64_t const readBytes;    // disk i/o readBytes
    uint64_t const writeBytes;   // disk i/o writeBytes
    uint64_t const ioWaitTime;   // Time spent in io wait in nanoseconds
 
    dwtTime_t stamp;     // time stamp
    std::thread::id tid; // thread id
    dwtEvent_t(Level const evtLevel, TraceChannel const evtChannel, TraceHeaderType const evtType,
               dwtFixedString_t const& evtTag, float32_t const evtDuration,
               dwtFixedString_t const& evtPayload, const char* const evtFunc, const char* const evtDeviceName,
               size_t const evtDeviceMemFree, const int32_t evtHostMemUsed, uint64_t const evtNvMapMemUsed, uint64_t const evtReadBytes, uint64_t const evtWriteBytes, uint64_t const evtIOWaitTime, dwtTime_t const evtStamp)
        : level(evtLevel), channel(evtChannel), type(evtType), tag(evtTag.c_str()), duration(evtDuration), payload(evtPayload.c_str()), func(evtFunc), deviceName(evtDeviceName), deviceMemFree(evtDeviceMemFree), hostMemUsed(evtHostMemUsed), nvMapMemUsed(evtNvMapMemUsed), readBytes(evtReadBytes), writeBytes(evtWriteBytes), ioWaitTime(evtIOWaitTime), stamp(evtStamp)
    {
    }
};
 
struct CudaTraceEvent
{
    cudaStream_t streamId;
    cudaEvent_t event;
};
 
} // namespace trace
} // namespace dw
 
#endif // DWTRACE_TRACE_STRUCTURES_HPP_