singe-cupti 0.1.0-alpha.5

use std::{
    fmt::{self, Display, Formatter},
    mem::size_of,
};

use bitflags::bitflags;
use num_enum::{IntoPrimitive, TryFromPrimitive};
use singe_core::impl_enum_conversion;
use singe_cupti_sys as sys;

pub(crate) type SubscriberHandle = sys::CUpti_SubscriberHandle;

macro_rules! id_newtype {
    ($name:ident, $raw:ty) => {
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
        #[repr(transparent)]
        pub struct $name($raw);

        impl $name {
            pub const fn get(self) -> $raw {
                self.0
            }

            pub(crate) const fn as_raw(self) -> $raw {
                self.0
            }
        }

        impl From<$raw> for $name {
            fn from(value: $raw) -> Self {
                Self(value)
            }
        }

        impl From<$name> for $raw {
            fn from(value: $name) -> Self {
                value.as_raw()
            }
        }
    };
}

id_newtype!(ContextId, u32);
id_newtype!(DeviceId, u32);
id_newtype!(GraphId, u32);
id_newtype!(GraphExecId, u32);
id_newtype!(GraphNodeId, u64);
id_newtype!(StreamId, u64);
id_newtype!(ChannelId, u32);
id_newtype!(CorrelationId, u32);
id_newtype!(ExternalCorrelationId, u64);
id_newtype!(CudaEventId, u32);
id_newtype!(CudaEventSyncId, u64);
id_newtype!(ActivityMarkerId, u32);
id_newtype!(SourceLocatorId, u32);
id_newtype!(FunctionId, u32);
id_newtype!(ModuleId, u32);
id_newtype!(GridId, i64);
id_newtype!(ProcessId, u64);
id_newtype!(ThreadId, u32);
id_newtype!(CuptiDomainId, u32);
id_newtype!(UnifiedMemoryProcessorId, u32);
id_newtype!(GpuInstanceId, u32);
id_newtype!(ComputeInstanceId, u32);
id_newtype!(NumaId, u32);
id_newtype!(NpuDomainId, u32);
id_newtype!(JitOperationCorrelationId, u64);
id_newtype!(PcieBridgeId, u32);
id_newtype!(PcieBusId, u16);
id_newtype!(PcieHardwareDeviceId, u16);
id_newtype!(PcieVendorId, u16);
id_newtype!(PcieDomainId, u32);
id_newtype!(OpenAccDeviceTypeId, u32);
id_newtype!(OpenAccDeviceNumber, u32);
id_newtype!(OpenAccAsyncId, u64);

impl From<u32> for StreamId {
    fn from(value: u32) -> Self {
        Self(u64::from(value))
    }
}

impl From<u16> for StreamId {
    fn from(value: u16) -> Self {
        Self(u64::from(value))
    }
}

impl From<u32> for ProcessId {
    fn from(value: u32) -> Self {
        Self(u64::from(value))
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(transparent)]
pub struct CudaDevice(i32);

impl CudaDevice {
    pub const fn get(self) -> i32 {
        self.0
    }

    pub(crate) const fn as_raw(self) -> sys::CUdevice {
        self.0
    }
}

impl From<sys::CUdevice> for CudaDevice {
    fn from(value: sys::CUdevice) -> Self {
        Self(value)
    }
}

impl From<CudaDevice> for sys::CUdevice {
    fn from(value: CudaDevice) -> Self {
        value.as_raw()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ApiCallbackSite {
    Enter = sys::CUpti_ApiCallbackSite::CUPTI_API_ENTER as _,
    Exit = sys::CUpti_ApiCallbackSite::CUPTI_API_EXIT as _,
    ForceInt = sys::CUpti_ApiCallbackSite::CUPTI_API_CBSITE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ApiCallbackSite, ApiCallbackSite);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(transparent)]
pub struct EventId(u32);

impl EventId {
    pub const fn get(self) -> u32 {
        self.0
    }

    pub(crate) const fn as_raw(self) -> sys::CUpti_EventID {
        self.0
    }
}

impl From<sys::CUpti_EventID> for EventId {
    fn from(value: sys::CUpti_EventID) -> Self {
        Self(value)
    }
}

impl From<EventId> for sys::CUpti_EventID {
    fn from(value: EventId) -> Self {
        value.as_raw()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(transparent)]
pub struct EventDomainId(u32);

impl EventDomainId {
    pub const fn get(self) -> u32 {
        self.0
    }

    pub(crate) const fn as_raw(self) -> sys::CUpti_EventDomainID {
        self.0
    }
}

impl From<sys::CUpti_EventDomainID> for EventDomainId {
    fn from(value: sys::CUpti_EventDomainID) -> Self {
        Self(value)
    }
}

impl From<EventDomainId> for sys::CUpti_EventDomainID {
    fn from(value: EventDomainId) -> Self {
        value.as_raw()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(transparent)]
pub struct MetricId(u32);

impl MetricId {
    pub const fn get(self) -> u32 {
        self.0
    }

    pub(crate) const fn as_raw(self) -> sys::CUpti_MetricID {
        self.0
    }
}

impl From<sys::CUpti_MetricID> for MetricId {
    fn from(value: sys::CUpti_MetricID) -> Self {
        Self(value)
    }
}

impl From<MetricId> for sys::CUpti_MetricID {
    fn from(value: MetricId) -> Self {
        value.as_raw()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum DeviceAttributeDeviceClass {
    Tesla = sys::CUpti_DeviceAttributeDeviceClass::CUPTI_DEVICE_ATTR_DEVICE_CLASS_TESLA as _,
    Quadro = sys::CUpti_DeviceAttributeDeviceClass::CUPTI_DEVICE_ATTR_DEVICE_CLASS_QUADRO as _,
    Geforce = sys::CUpti_DeviceAttributeDeviceClass::CUPTI_DEVICE_ATTR_DEVICE_CLASS_GEFORCE as _,
    Tegra = sys::CUpti_DeviceAttributeDeviceClass::CUPTI_DEVICE_ATTR_DEVICE_CLASS_TEGRA as _,
}

impl_enum_conversion!(
    sys::CUpti_DeviceAttributeDeviceClass,
    DeviceAttributeDeviceClass
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum DeviceAttribute {
    MaxEventId = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_MAX_EVENT_ID as _,
    MaxEventDomainId = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_MAX_EVENT_DOMAIN_ID as _,
    GlobalMemoryBandwidth =
        sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_GLOBAL_MEMORY_BANDWIDTH as _,
    InstructionPerCycle = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_INSTRUCTION_PER_CYCLE as _,
    InstructionThroughputSinglePrecision =
        sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_INSTRUCTION_THROUGHPUT_SINGLE_PRECISION as _,
    MaxFrameBuffers = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_MAX_FRAME_BUFFERS as _,
    PcieLinkRate = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_PCIE_LINK_RATE as _,
    PcieLinkWidth = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_PCIE_LINK_WIDTH as _,
    PcieGen = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_PCIE_GEN as _,
    DeviceClass = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_DEVICE_CLASS as _,
    FlopSpPerCycle = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_FLOP_SP_PER_CYCLE as _,
    FlopDpPerCycle = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_FLOP_DP_PER_CYCLE as _,
    MaxL2Units = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_MAX_L2_UNITS as _,
    MaxSharedMemoryCacheConfigPreferShared =
        sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_MAX_SHARED_MEMORY_CACHE_CONFIG_PREFER_SHARED
            as _,
    MaxSharedMemoryCacheConfigPreferL1 =
        sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_MAX_SHARED_MEMORY_CACHE_CONFIG_PREFER_L1 as _,
    MaxSharedMemoryCacheConfigPreferEqual =
        sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_MAX_SHARED_MEMORY_CACHE_CONFIG_PREFER_EQUAL
            as _,
    FlopHpPerCycle = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_FLOP_HP_PER_CYCLE as _,
    NvlinkPresent = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_NVLINK_PRESENT as _,
    GpuCpuNvlinkBw = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_GPU_CPU_NVLINK_BW as _,
    NvswitchPresent = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_NVSWITCH_PRESENT as _,
    ForceInt = sys::CUpti_DeviceAttribute::CUPTI_DEVICE_ATTR_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_DeviceAttribute, DeviceAttribute);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DeviceAttributeValue {
    U32(u32),
    DeviceClass(DeviceAttributeDeviceClass),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(transparent)]
pub struct CudaDeviceAttribute(u32);

impl CudaDeviceAttribute {
    pub const fn get(self) -> u32 {
        self.0
    }
}

impl From<sys::CUdevice_attribute> for CudaDeviceAttribute {
    fn from(value: sys::CUdevice_attribute) -> Self {
        Self(value as u32)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum EventDomainAttribute {
    Name = sys::CUpti_EventDomainAttribute::CUPTI_EVENT_DOMAIN_ATTR_NAME as _,
    InstanceCount = sys::CUpti_EventDomainAttribute::CUPTI_EVENT_DOMAIN_ATTR_INSTANCE_COUNT as _,
    TotalInstanceCount =
        sys::CUpti_EventDomainAttribute::CUPTI_EVENT_DOMAIN_ATTR_TOTAL_INSTANCE_COUNT as _,
    CollectionMethod =
        sys::CUpti_EventDomainAttribute::CUPTI_EVENT_DOMAIN_ATTR_COLLECTION_METHOD as _,
    ForceInt = sys::CUpti_EventDomainAttribute::CUPTI_EVENT_DOMAIN_ATTR_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_EventDomainAttribute, EventDomainAttribute);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum EventDomainAttributeValue {
    Name(String),
    U32(u32),
    CollectionMethod(EventCollectionMethod),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum EventCollectionMethod {
    Pm = sys::CUpti_EventCollectionMethod::CUPTI_EVENT_COLLECTION_METHOD_PM as _,
    Sm = sys::CUpti_EventCollectionMethod::CUPTI_EVENT_COLLECTION_METHOD_SM as _,
    Instrumented =
        sys::CUpti_EventCollectionMethod::CUPTI_EVENT_COLLECTION_METHOD_INSTRUMENTED as _,
    NvlinkTc = sys::CUpti_EventCollectionMethod::CUPTI_EVENT_COLLECTION_METHOD_NVLINK_TC as _,
    ForceInt = sys::CUpti_EventCollectionMethod::CUPTI_EVENT_COLLECTION_METHOD_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_EventCollectionMethod, EventCollectionMethod);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum EventGroupAttribute {
    EventDomainId = sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_EVENT_DOMAIN_ID as _,
    ProfileAllDomainInstances =
        sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_PROFILE_ALL_DOMAIN_INSTANCES as _,
    UserData = sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_USER_DATA as _,
    NumEvents = sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_NUM_EVENTS as _,
    Events = sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_EVENTS as _,
    InstanceCount = sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_INSTANCE_COUNT as _,
    ProfilingScope = sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_PROFILING_SCOPE as _,
    ForceInt = sys::CUpti_EventGroupAttribute::CUPTI_EVENT_GROUP_ATTR_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_EventGroupAttribute, EventGroupAttribute);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum EventGroupAttributeValue {
    EventDomainId(EventDomainId),
    ProfileAllDomainInstances(bool),
    NumEvents(u32),
    Events(Vec<EventId>),
    InstanceCount(u32),
    ProfilingScope(EventProfilingScope),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum EventGroupAttributeSetting {
    ProfileAllDomainInstances(bool),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum EventProfilingScope {
    Context = sys::CUpti_EventProfilingScope::CUPTI_EVENT_PROFILING_SCOPE_CONTEXT as _,
    Device = sys::CUpti_EventProfilingScope::CUPTI_EVENT_PROFILING_SCOPE_DEVICE as _,
    Both = sys::CUpti_EventProfilingScope::CUPTI_EVENT_PROFILING_SCOPE_BOTH as _,
    ForceInt = sys::CUpti_EventProfilingScope::CUPTI_EVENT_PROFILING_SCOPE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_EventProfilingScope, EventProfilingScope);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum EventAttribute {
    Name = sys::CUpti_EventAttribute::CUPTI_EVENT_ATTR_NAME as _,
    ShortDescription = sys::CUpti_EventAttribute::CUPTI_EVENT_ATTR_SHORT_DESCRIPTION as _,
    LongDescription = sys::CUpti_EventAttribute::CUPTI_EVENT_ATTR_LONG_DESCRIPTION as _,
    Category = sys::CUpti_EventAttribute::CUPTI_EVENT_ATTR_CATEGORY as _,
    ProfilingScope = sys::CUpti_EventAttribute::CUPTI_EVENT_ATTR_PROFILING_SCOPE as _,
    ForceInt = sys::CUpti_EventAttribute::CUPTI_EVENT_ATTR_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_EventAttribute, EventAttribute);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum EventCategory {
    Instruction = sys::CUpti_EventCategory::CUPTI_EVENT_CATEGORY_INSTRUCTION as _,
    Memory = sys::CUpti_EventCategory::CUPTI_EVENT_CATEGORY_MEMORY as _,
    Cache = sys::CUpti_EventCategory::CUPTI_EVENT_CATEGORY_CACHE as _,
    ProfileTrigger = sys::CUpti_EventCategory::CUPTI_EVENT_CATEGORY_PROFILE_TRIGGER as _,
    System = sys::CUpti_EventCategory::CUPTI_EVENT_CATEGORY_SYSTEM as _,
    ForceInt = sys::CUpti_EventCategory::CUPTI_EVENT_CATEGORY_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_EventCategory, EventCategory);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum EventAttributeValue {
    Name(String),
    ShortDescription(String),
    LongDescription(String),
    Category(EventCategory),
    ProfilingScope(EventProfilingScope),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum EventCollectionMode {
    Continuous = sys::CUpti_EventCollectionMode::CUPTI_EVENT_COLLECTION_MODE_CONTINUOUS as _,
    Kernel = sys::CUpti_EventCollectionMode::CUPTI_EVENT_COLLECTION_MODE_KERNEL as _,
    ForceInt = sys::CUpti_EventCollectionMode::CUPTI_EVENT_COLLECTION_MODE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_EventCollectionMode, EventCollectionMode);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ReadEventFlags {
    None = sys::CUpti_ReadEventFlags::CUPTI_EVENT_READ_FLAG_NONE as _,
    ForceInt = sys::CUpti_ReadEventFlags::CUPTI_EVENT_READ_FLAG_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ReadEventFlags, ReadEventFlags);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum CallbackDomain {
    Invalid = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_INVALID as _,
    DriverApi = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_DRIVER_API as _,
    RuntimeApi = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_RUNTIME_API as _,
    Resource = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_RESOURCE as _,
    Synchronize = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_SYNCHRONIZE as _,
    Nvtx = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_NVTX as _,
    State = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_STATE as _,
    Size = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_SIZE as _,
    ForceInt = sys::CUpti_CallbackDomain::CUPTI_CB_DOMAIN_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_CallbackDomain, CallbackDomain);

impl Display for CallbackDomain {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_CB_DOMAIN_INVALID"),
            Self::DriverApi => write!(f, "CUPTI_CB_DOMAIN_DRIVER_API"),
            Self::RuntimeApi => write!(f, "CUPTI_CB_DOMAIN_RUNTIME_API"),
            Self::Resource => write!(f, "CUPTI_CB_DOMAIN_RESOURCE"),
            Self::Synchronize => write!(f, "CUPTI_CB_DOMAIN_SYNCHRONIZE"),
            Self::Nvtx => write!(f, "CUPTI_CB_DOMAIN_NVTX"),
            Self::State => write!(f, "CUPTI_CB_DOMAIN_STATE"),
            Self::Size => write!(f, "CUPTI_CB_DOMAIN_SIZE"),
            Self::ForceInt => write!(f, "CUPTI_CB_DOMAIN_FORCE_INT"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ActivityFlushFlag {
    Default,
    Forced,
}

impl From<ActivityFlushFlag> for u32 {
    fn from(value: ActivityFlushFlag) -> Self {
        match value {
            ActivityFlushFlag::Default => 0,
            ActivityFlushFlag::Forced => {
                sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_FLUSH_FORCED as u32
            }
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct CallbackId(u32);

impl CallbackId {
    pub const fn get(self) -> u32 {
        self.0
    }

    pub(crate) const fn as_raw(self) -> sys::CUpti_CallbackId {
        self.0
    }
}

impl From<sys::CUpti_CallbackId> for CallbackId {
    fn from(value: sys::CUpti_CallbackId) -> Self {
        Self(value)
    }
}

impl From<CallbackIdResource> for CallbackId {
    fn from(value: CallbackIdResource) -> Self {
        Self(value.into())
    }
}

impl From<CallbackIdSync> for CallbackId {
    fn from(value: CallbackIdSync) -> Self {
        Self(value.into())
    }
}

impl From<CallbackIdState> for CallbackId {
    fn from(value: CallbackIdState) -> Self {
        Self(value.into())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum CallbackIdResource {
    Invalid = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_INVALID as _,
    ContextCreated = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_CONTEXT_CREATED as _,
    ContextDestroyStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_CONTEXT_DESTROY_STARTING as _,
    StreamCreated = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_STREAM_CREATED as _,
    StreamDestroyStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_STREAM_DESTROY_STARTING as _,
    CuInitFinished = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_CU_INIT_FINISHED as _,
    ModuleLoaded = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_MODULE_LOADED as _,
    ModuleUnloadStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_MODULE_UNLOAD_STARTING as _,
    ModuleProfiled = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_MODULE_PROFILED as _,
    GraphCreated = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPH_CREATED as _,
    GraphDestroyStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPH_DESTROY_STARTING as _,
    GraphCloned = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPH_CLONED as _,
    GraphNodeCreateStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHNODE_CREATE_STARTING as _,
    GraphNodeCreated = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHNODE_CREATED as _,
    GraphNodeDestroyStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHNODE_DESTROY_STARTING as _,
    GraphNodeDependencyCreated =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHNODE_DEPENDENCY_CREATED as _,
    GraphNodeDependencyDestroyStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHNODE_DEPENDENCY_DESTROY_STARTING
            as _,
    GraphExecCreateStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHEXEC_CREATE_STARTING as _,
    GraphExecCreated = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHEXEC_CREATED as _,
    GraphExecDestroyStarting =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHEXEC_DESTROY_STARTING as _,
    GraphNodeCloned = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPHNODE_CLONED as _,
    StreamAttributeChanged =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_STREAM_ATTRIBUTE_CHANGED as _,
    GraphNodeUpdated = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPH_NODE_UPDATED as _,
    GraphNodeSetParams =
        sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_GRAPH_NODE_SET_PARAMS as _,
    Size = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_SIZE as _,
    ForceInt = sys::CUpti_CallbackIdResource::CUPTI_CBID_RESOURCE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_CallbackIdResource, CallbackIdResource);

impl Display for CallbackIdResource {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_CBID_RESOURCE_INVALID"),
            Self::ContextCreated => write!(f, "CUPTI_CBID_RESOURCE_CONTEXT_CREATED"),
            Self::ContextDestroyStarting => {
                write!(f, "CUPTI_CBID_RESOURCE_CONTEXT_DESTROY_STARTING")
            }
            Self::StreamCreated => write!(f, "CUPTI_CBID_RESOURCE_STREAM_CREATED"),
            Self::StreamDestroyStarting => {
                write!(f, "CUPTI_CBID_RESOURCE_STREAM_DESTROY_STARTING")
            }
            Self::CuInitFinished => write!(f, "CUPTI_CBID_RESOURCE_CU_INIT_FINISHED"),
            Self::ModuleLoaded => write!(f, "CUPTI_CBID_RESOURCE_MODULE_LOADED"),
            Self::ModuleUnloadStarting => write!(f, "CUPTI_CBID_RESOURCE_MODULE_UNLOAD_STARTING"),
            Self::ModuleProfiled => write!(f, "CUPTI_CBID_RESOURCE_MODULE_PROFILED"),
            Self::GraphCreated => write!(f, "CUPTI_CBID_RESOURCE_GRAPH_CREATED"),
            Self::GraphDestroyStarting => write!(f, "CUPTI_CBID_RESOURCE_GRAPH_DESTROY_STARTING"),
            Self::GraphCloned => write!(f, "CUPTI_CBID_RESOURCE_GRAPH_CLONED"),
            Self::GraphNodeCreateStarting => {
                write!(f, "CUPTI_CBID_RESOURCE_GRAPHNODE_CREATE_STARTING")
            }
            Self::GraphNodeCreated => write!(f, "CUPTI_CBID_RESOURCE_GRAPHNODE_CREATED"),
            Self::GraphNodeDestroyStarting => {
                write!(f, "CUPTI_CBID_RESOURCE_GRAPHNODE_DESTROY_STARTING")
            }
            Self::GraphNodeDependencyCreated => {
                write!(f, "CUPTI_CBID_RESOURCE_GRAPHNODE_DEPENDENCY_CREATED")
            }
            Self::GraphNodeDependencyDestroyStarting => {
                write!(
                    f,
                    "CUPTI_CBID_RESOURCE_GRAPHNODE_DEPENDENCY_DESTROY_STARTING"
                )
            }
            Self::GraphExecCreateStarting => {
                write!(f, "CUPTI_CBID_RESOURCE_GRAPHEXEC_CREATE_STARTING")
            }
            Self::GraphExecCreated => write!(f, "CUPTI_CBID_RESOURCE_GRAPHEXEC_CREATED"),
            Self::GraphExecDestroyStarting => {
                write!(f, "CUPTI_CBID_RESOURCE_GRAPHEXEC_DESTROY_STARTING")
            }
            Self::GraphNodeCloned => write!(f, "CUPTI_CBID_RESOURCE_GRAPHNODE_CLONED"),
            Self::StreamAttributeChanged => {
                write!(f, "CUPTI_CBID_RESOURCE_STREAM_ATTRIBUTE_CHANGED")
            }
            Self::GraphNodeUpdated => write!(f, "CUPTI_CBID_RESOURCE_GRAPH_NODE_UPDATED"),
            Self::GraphNodeSetParams => write!(f, "CUPTI_CBID_RESOURCE_GRAPH_NODE_SET_PARAMS"),
            Self::Size => write!(f, "CUPTI_CBID_RESOURCE_SIZE"),
            Self::ForceInt => write!(f, "CUPTI_CBID_RESOURCE_FORCE_INT"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum CallbackIdSync {
    Invalid = sys::CUpti_CallbackIdSync::CUPTI_CBID_SYNCHRONIZE_INVALID as _,
    StreamSynchronized = sys::CUpti_CallbackIdSync::CUPTI_CBID_SYNCHRONIZE_STREAM_SYNCHRONIZED as _,
    ContextSynchronized =
        sys::CUpti_CallbackIdSync::CUPTI_CBID_SYNCHRONIZE_CONTEXT_SYNCHRONIZED as _,
    Size = sys::CUpti_CallbackIdSync::CUPTI_CBID_SYNCHRONIZE_SIZE as _,
    ForceInt = sys::CUpti_CallbackIdSync::CUPTI_CBID_SYNCHRONIZE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_CallbackIdSync, CallbackIdSync);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum CallbackIdState {
    Invalid = sys::CUpti_CallbackIdState::CUPTI_CBID_STATE_INVALID as _,
    FatalError = sys::CUpti_CallbackIdState::CUPTI_CBID_STATE_FATAL_ERROR as _,
    Error = sys::CUpti_CallbackIdState::CUPTI_CBID_STATE_ERROR as _,
    Warning = sys::CUpti_CallbackIdState::CUPTI_CBID_STATE_WARNING as _,
    Size = sys::CUpti_CallbackIdState::CUPTI_CBID_STATE_SIZE as _,
    ForceInt = sys::CUpti_CallbackIdState::CUPTI_CBID_STATE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_CallbackIdState, CallbackIdState);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityKind {
    Invalid = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INVALID as _,
    Memcpy = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MEMCPY as _,
    Memset = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MEMSET as _,
    Kernel = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_KERNEL as _,
    Driver = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_DRIVER as _,
    Runtime = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_RUNTIME as _,
    Event = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_EVENT as _,
    Metric = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_METRIC as _,
    Device = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_DEVICE as _,
    Context = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_CONTEXT as _,
    ConcurrentKernel = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_CONCURRENT_KERNEL as _,
    Name = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_NAME as _,
    Marker = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MARKER as _,
    MarkerData = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MARKER_DATA as _,
    SourceLocator = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_SOURCE_LOCATOR as _,
    GlobalAccess = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_GLOBAL_ACCESS as _,
    Branch = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_BRANCH as _,
    Overhead = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_OVERHEAD as _,
    CdpKernel = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_CDP_KERNEL as _,
    Preemption = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_PREEMPTION as _,
    Environment = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_ENVIRONMENT as _,
    EventInstance = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_EVENT_INSTANCE as _,
    Memcpy2 = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MEMCPY2 as _,
    MetricInstance = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_METRIC_INSTANCE as _,
    InstructionExecution = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INSTRUCTION_EXECUTION as _,
    UnifiedMemoryCounter = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_UNIFIED_MEMORY_COUNTER as _,
    Function = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_FUNCTION as _,
    Module = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MODULE as _,
    DeviceAttribute = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_DEVICE_ATTRIBUTE as _,
    SharedAccess = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_SHARED_ACCESS as _,
    PcSampling = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_PC_SAMPLING as _,
    PcSamplingRecordInfo =
        sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_PC_SAMPLING_RECORD_INFO as _,
    InstructionCorrelation =
        sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INSTRUCTION_CORRELATION as _,
    OpenAccData = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_OPENACC_DATA as _,
    OpenAccLaunch = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_OPENACC_LAUNCH as _,
    OpenAccOther = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_OPENACC_OTHER as _,
    CudaEvent = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_CUDA_EVENT as _,
    Stream = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_STREAM as _,
    Synchronization = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_SYNCHRONIZATION as _,
    ExternalCorrelation = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_EXTERNAL_CORRELATION as _,
    NvLink = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_NVLINK as _,
    InstantaneousEvent = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INSTANTANEOUS_EVENT as _,
    InstantaneousEventInstance =
        sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INSTANTANEOUS_EVENT_INSTANCE as _,
    InstantaneousMetric = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INSTANTANEOUS_METRIC as _,
    InstantaneousMetricInstance =
        sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INSTANTANEOUS_METRIC_INSTANCE as _,
    Memory = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MEMORY as _,
    Pcie = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_PCIE as _,
    OpenMp = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_OPENMP as _,
    InternalLaunchApi = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_INTERNAL_LAUNCH_API as _,
    Memory2 = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MEMORY2 as _,
    MemoryPool = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MEMORY_POOL as _,
    GraphTrace = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_GRAPH_TRACE as _,
    Jit = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_JIT as _,
    DeviceGraphTrace = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_DEVICE_GRAPH_TRACE as _,
    MemDecompress = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_MEM_DECOMPRESS as _,
    ConfidentialComputeRotation =
        sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_CONFIDENTIAL_COMPUTE_ROTATION as _,
    GraphHostNode = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_GRAPH_HOST_NODE as _,
    ComputeEngineCtxSwitch =
        sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_COMPUTE_ENGINE_CTX_SWITCH as _,
    HostLaunch = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_HOST_LAUNCH as _,
    GreenContext = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_GREEN_CONTEXT as _,
    Count = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_COUNT as _,
    ForceInt = sys::CUpti_ActivityKind::CUPTI_ACTIVITY_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityKind, ActivityKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ChannelType {
    Invalid = sys::CUpti_ChannelType::CUPTI_CHANNEL_TYPE_INVALID as _,
    Compute = sys::CUpti_ChannelType::CUPTI_CHANNEL_TYPE_COMPUTE as _,
    AsyncMemcpy = sys::CUpti_ChannelType::CUPTI_CHANNEL_TYPE_ASYNC_MEMCPY as _,
    Decompress = sys::CUpti_ChannelType::CUPTI_CHANNEL_TYPE_DECOMP as _,
    ForceInt = sys::CUpti_ChannelType::CUPTI_CHANNEL_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ChannelType, ChannelType);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityMemcpyKind {
    Unknown = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_UNKNOWN as _,
    HostToDevice = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_HTOD as _,
    DeviceToHost = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_DTOH as _,
    HostToArray = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_HTOA as _,
    ArrayToHost = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_ATOH as _,
    ArrayToArray = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_ATOA as _,
    ArrayToDevice = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_ATOD as _,
    DeviceToArray = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_DTOA as _,
    DeviceToDevice = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_DTOD as _,
    HostToHost = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_HTOH as _,
    PeerToPeer = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_PTOP as _,
    ForceInt = sys::CUpti_ActivityMemcpyKind::CUPTI_ACTIVITY_MEMCPY_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityMemcpyKind, ActivityMemcpyKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityMemoryKind {
    Unknown = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_UNKNOWN as _,
    Pageable = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_PAGEABLE as _,
    Pinned = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_PINNED as _,
    Device = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_DEVICE as _,
    Array = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_ARRAY as _,
    Managed = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_MANAGED as _,
    DeviceStatic = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_DEVICE_STATIC as _,
    ManagedStatic = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_MANAGED_STATIC as _,
    ForceInt = sys::CUpti_ActivityMemoryKind::CUPTI_ACTIVITY_MEMORY_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityMemoryKind, ActivityMemoryKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityMemoryOperationType {
    Invalid =
        sys::CUpti_ActivityMemoryOperationType::CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_INVALID as _,
    Allocation =
        sys::CUpti_ActivityMemoryOperationType::CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_ALLOCATION
            as _,
    Release =
        sys::CUpti_ActivityMemoryOperationType::CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_RELEASE as _,
    ForceInt =
        sys::CUpti_ActivityMemoryOperationType::CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityMemoryOperationType,
    ActivityMemoryOperationType
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityMemoryPoolType {
    Invalid = sys::CUpti_ActivityMemoryPoolType::CUPTI_ACTIVITY_MEMORY_POOL_TYPE_INVALID as _,
    Local = sys::CUpti_ActivityMemoryPoolType::CUPTI_ACTIVITY_MEMORY_POOL_TYPE_LOCAL as _,
    Imported = sys::CUpti_ActivityMemoryPoolType::CUPTI_ACTIVITY_MEMORY_POOL_TYPE_IMPORTED as _,
    ForceInt = sys::CUpti_ActivityMemoryPoolType::CUPTI_ACTIVITY_MEMORY_POOL_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityMemoryPoolType, ActivityMemoryPoolType);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityMemoryPoolOperationType {
    Invalid =
        sys::CUpti_ActivityMemoryPoolOperationType::CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_INVALID
            as _,
    Created =
        sys::CUpti_ActivityMemoryPoolOperationType::CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_CREATED
            as _,
    Destroyed =
        sys::CUpti_ActivityMemoryPoolOperationType::CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_DESTROYED
            as _,
    Trimmed =
        sys::CUpti_ActivityMemoryPoolOperationType::CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_TRIMMED
            as _,
    ForceInt =
        sys::CUpti_ActivityMemoryPoolOperationType::CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_FORCE_INT
            as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityMemoryPoolOperationType,
    ActivityMemoryPoolOperationType
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum DeviceGraphLaunchMode {
    Invalid = sys::CUpti_DeviceGraphLaunchMode::CUPTI_DEVICE_GRAPH_LAUNCH_MODE_INVALID as _,
    FireAndForget =
        sys::CUpti_DeviceGraphLaunchMode::CUPTI_DEVICE_GRAPH_LAUNCH_MODE_FIRE_AND_FORGET as _,
    Tail = sys::CUpti_DeviceGraphLaunchMode::CUPTI_DEVICE_GRAPH_LAUNCH_MODE_TAIL as _,
    FireAndForgetAsSibling =
        sys::CUpti_DeviceGraphLaunchMode::CUPTI_DEVICE_GRAPH_LAUNCH_MODE_FIRE_AND_FORGET_AS_SIBLING
            as _,
}

impl_enum_conversion!(sys::CUpti_DeviceGraphLaunchMode, DeviceGraphLaunchMode);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityComputeApiKind {
    Unknown = sys::CUpti_ActivityComputeApiKind::CUPTI_ACTIVITY_COMPUTE_API_UNKNOWN as _,
    Cuda = sys::CUpti_ActivityComputeApiKind::CUPTI_ACTIVITY_COMPUTE_API_CUDA as _,
    CudaMps = sys::CUpti_ActivityComputeApiKind::CUPTI_ACTIVITY_COMPUTE_API_CUDA_MPS as _,
    ForceInt = sys::CUpti_ActivityComputeApiKind::CUPTI_ACTIVITY_COMPUTE_API_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityComputeApiKind, ActivityComputeApiKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ContextCigMode {
    None = sys::CUpti_ContextCigMode::CUPTI_CONTEXT_CIG_MODE_NONE as _,
    Cig = sys::CUpti_ContextCigMode::CUPTI_CONTEXT_CIG_MODE_CIG as _,
    CigFallback = sys::CUpti_ContextCigMode::CUPTI_CONTEXT_CIG_MODE_CIG_FALLBACK as _,
    ForceInt = sys::CUpti_ContextCigMode::CUPTI_CONTEXT_CIG_MODE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ContextCigMode, ContextCigMode);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ComputeEngineContextSwitchOperationType {
    Invalid =
        sys::CUpti_ComputeEngineCtxSwitchOperationType::CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_INVALID
            as _,
    Start =
        sys::CUpti_ComputeEngineCtxSwitchOperationType::CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_START
            as _,
    End =
        sys::CUpti_ComputeEngineCtxSwitchOperationType::CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_END
            as _,
    Count =
        sys::CUpti_ComputeEngineCtxSwitchOperationType::CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_COUNT
            as _,
}

impl_enum_conversion!(
    sys::CUpti_ComputeEngineCtxSwitchOperationType,
    ComputeEngineContextSwitchOperationType
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivitySynchronizationType {
    Unknown =
        sys::CUpti_ActivitySynchronizationType::CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_UNKNOWN as _,
    EventSynchronize =
        sys::CUpti_ActivitySynchronizationType::CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_EVENT_SYNCHRONIZE as _,
    StreamWaitEvent =
        sys::CUpti_ActivitySynchronizationType::CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_STREAM_WAIT_EVENT as _,
    StreamSynchronize =
        sys::CUpti_ActivitySynchronizationType::CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_STREAM_SYNCHRONIZE as _,
    ContextSynchronize =
        sys::CUpti_ActivitySynchronizationType::CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_CONTEXT_SYNCHRONIZE as _,
    ForceInt =
        sys::CUpti_ActivitySynchronizationType::CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivitySynchronizationType,
    ActivitySynchronizationType
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityStreamFlag {
    Unknown = sys::CUpti_ActivityStreamFlag::CUPTI_ACTIVITY_STREAM_CREATE_FLAG_UNKNOWN as _,
    Default = sys::CUpti_ActivityStreamFlag::CUPTI_ACTIVITY_STREAM_CREATE_FLAG_DEFAULT as _,
    NonBlocking =
        sys::CUpti_ActivityStreamFlag::CUPTI_ACTIVITY_STREAM_CREATE_FLAG_NON_BLOCKING as _,
    Null = sys::CUpti_ActivityStreamFlag::CUPTI_ACTIVITY_STREAM_CREATE_FLAG_NULL as _,
    Mask = sys::CUpti_ActivityStreamFlag::CUPTI_ACTIVITY_STREAM_CREATE_MASK as _,
    ForceInt = sys::CUpti_ActivityStreamFlag::CUPTI_ACTIVITY_STREAM_CREATE_FLAG_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityStreamFlag, ActivityStreamFlag);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityPartitionedGlobalCacheConfig {
    Unknown = sys::CUpti_ActivityPartitionedGlobalCacheConfig::CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_UNKNOWN as _,
    NotSupported = sys::CUpti_ActivityPartitionedGlobalCacheConfig::CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_NOT_SUPPORTED as _,
    Off = sys::CUpti_ActivityPartitionedGlobalCacheConfig::CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_OFF as _,
    On = sys::CUpti_ActivityPartitionedGlobalCacheConfig::CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_ON as _,
    ForceInt = sys::CUpti_ActivityPartitionedGlobalCacheConfig::CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityPartitionedGlobalCacheConfig,
    ActivityPartitionedGlobalCacheConfig
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityLaunchType {
    Regular = sys::CUpti_ActivityLaunchType::CUPTI_ACTIVITY_LAUNCH_TYPE_REGULAR as _,
    CooperativeSingleDevice =
        sys::CUpti_ActivityLaunchType::CUPTI_ACTIVITY_LAUNCH_TYPE_COOPERATIVE_SINGLE_DEVICE as _,
    CooperativeMultiDevice =
        sys::CUpti_ActivityLaunchType::CUPTI_ACTIVITY_LAUNCH_TYPE_COOPERATIVE_MULTI_DEVICE as _,
    CblCommandlist = sys::CUpti_ActivityLaunchType::CUPTI_ACTIVITY_LAUNCH_TYPE_CBL_COMMANDLIST as _,
}

impl_enum_conversion!(sys::CUpti_ActivityLaunchType, ActivityLaunchType);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum FunctionSharedMemoryLimitConfig {
    Default = sys::CUpti_FuncShmemLimitConfig::CUPTI_FUNC_SHMEM_LIMIT_DEFAULT as _,
    OptIn = sys::CUpti_FuncShmemLimitConfig::CUPTI_FUNC_SHMEM_LIMIT_OPTIN as _,
    ForceInt = sys::CUpti_FuncShmemLimitConfig::CUPTI_FUNC_SHMEM_LIMIT_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_FuncShmemLimitConfig,
    FunctionSharedMemoryLimitConfig
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityObjectKind {
    Unknown = sys::CUpti_ActivityObjectKind::CUPTI_ACTIVITY_OBJECT_UNKNOWN as _,
    Process = sys::CUpti_ActivityObjectKind::CUPTI_ACTIVITY_OBJECT_PROCESS as _,
    Thread = sys::CUpti_ActivityObjectKind::CUPTI_ACTIVITY_OBJECT_THREAD as _,
    Device = sys::CUpti_ActivityObjectKind::CUPTI_ACTIVITY_OBJECT_DEVICE as _,
    Context = sys::CUpti_ActivityObjectKind::CUPTI_ACTIVITY_OBJECT_CONTEXT as _,
    Stream = sys::CUpti_ActivityObjectKind::CUPTI_ACTIVITY_OBJECT_STREAM as _,
    ForceInt = sys::CUpti_ActivityObjectKind::CUPTI_ACTIVITY_OBJECT_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityObjectKind, ActivityObjectKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityOverheadKind {
    Unknown = sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_UNKNOWN as _,
    DriverCompiler = sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_DRIVER_COMPILER as _,
    BufferFlush = sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_CUPTI_BUFFER_FLUSH as _,
    Instrumentation =
        sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_CUPTI_INSTRUMENTATION as _,
    Resource = sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_CUPTI_RESOURCE as _,
    RuntimeTriggeredModuleLoading =
        sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_RUNTIME_TRIGGERED_MODULE_LOADING
            as _,
    LazyFunctionLoading =
        sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_LAZY_FUNCTION_LOADING as _,
    CommandBufferFull =
        sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_COMMAND_BUFFER_FULL as _,
    ActivityBufferRequest =
        sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_ACTIVITY_BUFFER_REQUEST as _,
    UvmActivityInit =
        sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_UVM_ACTIVITY_INIT as _,
    ForceInt = sys::CUpti_ActivityOverheadKind::CUPTI_ACTIVITY_OVERHEAD_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityOverheadKind, ActivityOverheadKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum DeviceVirtualizationMode {
    None = sys::CUpti_DeviceVirtualizationMode::CUPTI_DEVICE_VIRTUALIZATION_MODE_NONE as _,
    PassThrough =
        sys::CUpti_DeviceVirtualizationMode::CUPTI_DEVICE_VIRTUALIZATION_MODE_PASS_THROUGH as _,
    VirtualGpu =
        sys::CUpti_DeviceVirtualizationMode::CUPTI_DEVICE_VIRTUALIZATION_MODE_VIRTUAL_GPU as _,
    ForceInt = sys::CUpti_DeviceVirtualizationMode::CUPTI_DEVICE_VIRTUALIZATION_MODE_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_DeviceVirtualizationMode,
    DeviceVirtualizationMode
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ExternalCorrelationKind {
    Invalid = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_INVALID as _,
    Unknown = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_UNKNOWN as _,
    OpenAcc = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_OPENACC as _,
    Custom0 = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_CUSTOM0 as _,
    Custom1 = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_CUSTOM1 as _,
    Custom2 = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_CUSTOM2 as _,
    Size = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_SIZE as _,
    ForceInt = sys::CUpti_ExternalCorrelationKind::CUPTI_EXTERNAL_CORRELATION_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ExternalCorrelationKind, ExternalCorrelationKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityAttribute {
    DeviceBufferSize = sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_SIZE as _,
    DeviceBufferSizeCdp =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_SIZE_CDP as _,
    DeviceBufferPoolLimit =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_POOL_LIMIT as _,
    ProfilingSemaphorePoolSize =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_PROFILING_SEMAPHORE_POOL_SIZE as _,
    ProfilingSemaphorePoolLimit =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_PROFILING_SEMAPHORE_POOL_LIMIT as _,
    ZeroedOutActivityBuffer =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ZEROED_OUT_ACTIVITY_BUFFER as _,
    DeviceBufferPreAllocateValue =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_PRE_ALLOCATE_VALUE as _,
    ProfilingSemaphorePreAllocateValue =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_PROFILING_SEMAPHORE_PRE_ALLOCATE_VALUE
            as _,
    MemAllocationTypeHostPinned =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_MEM_ALLOCATION_TYPE_HOST_PINNED as _,
    PerThreadActivityBuffer =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_PER_THREAD_ACTIVITY_BUFFER as _,
    DeviceBufferSizeDeviceGraphs =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_SIZE_DEVICE_GRAPHS as _,
    UserDefinedRecords =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_USER_DEFINED_RECORDS as _,
    MultipleSubscriberState =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_MULTIPLE_SUBSCRIBER_STATE as _,
    EnableHes = sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_HES as _,
    EnableAllocationSourceTracking =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_ALLOCATION_SOURCE_TRACKING as _,
    EnableKernelLatencyTimestamps =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_KERNEL_LATENCY_TIMESTAMPS as _,
    EnableAllSyncRecords =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_ALL_SYNC_RECORDS as _,
    EnableCudaEventDeviceTimestamps =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_CUDA_EVENT_DEVICE_TIMESTAMPS as _,
    EnableKernelLaunchAttributes =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_KERNEL_LAUNCH_ATTRIBUTES as _,
    EnableDeviceGraphTrace =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_DEVICE_GRAPH_TRACE as _,
    EnableMultiSubscriberGraphLevelTrace =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_ENABLE_MULTI_SUBSCRIBER_GRAPH_LEVEL_TRACE
            as _,
    ThreadIdType = sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_THREAD_ID_TYPE as _,
    TimestampCallback = sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_TIMESTAMP_CALLBACK as _,
    CigMode = sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_CIG_MODE as _,
    DeviceBufferForceInt =
        sys::CUpti_ActivityAttribute::CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityAttribute, ActivityAttribute);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MultipleSubscriberState {
    Disabled,
    Enabled,
    Unset,
    Unknown(u8),
}

impl From<u8> for MultipleSubscriberState {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::Disabled,
            1 => Self::Enabled,
            2 => Self::Unset,
            value => Self::Unknown(value),
        }
    }
}

impl From<MultipleSubscriberState> for u8 {
    fn from(value: MultipleSubscriberState) -> Self {
        match value {
            MultipleSubscriberState::Disabled => 0,
            MultipleSubscriberState::Enabled => 1,
            MultipleSubscriberState::Unset => 2,
            MultipleSubscriberState::Unknown(value) => value,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ActivityAttributeValue {
    Bytes(usize),
    Count(usize),
    Enabled(bool),
    MultipleSubscriberState(MultipleSubscriberState),
    ThreadIdType(ActivityThreadIdType),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ActivityAttributeSetting {
    Bytes(usize),
    Count(usize),
    Enabled(bool),
    ThreadIdType(ActivityThreadIdType),
}

macro_rules! activity_field_enum {
    ($name:ident, $raw:ty, { $($variant:ident = $value:ident,)+ }) => {
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
        #[repr(u32)]
        pub enum $name {
            $($variant = <$raw>::$value as _,)+
        }

        impl_enum_conversion!($raw, $name);

        impl From<$name> for ActivityFieldId {
            fn from(value: $name) -> Self {
                let raw: u32 = value.into();
                ActivityFieldId(raw as i32)
            }
        }

        impl Display for $name {
            fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
                match self {
                    $(Self::$variant => write!(f, stringify!($value)),)+
                }
            }
        }
    };
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ActivityFieldId(i32);

impl ActivityFieldId {
    pub const fn get(self) -> i32 {
        self.0
    }

    pub(crate) const fn as_raw(self) -> i32 {
        self.0
    }
}

impl Display for ActivityFieldId {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

activity_field_enum!(ActivityApiField, sys::CUpti_ActivityApiFieldIds, {
    Kind = API_FIELD_KIND,
    CallbackId = API_FIELD_CBID,
    Start = API_FIELD_START,
    End = API_FIELD_END,
    ProcessId = API_FIELD_PROCESS_ID,
    ThreadId = API_FIELD_THREAD_ID,
    CorrelationId = API_FIELD_CORRELATION_ID,
    ReturnValue = API_FIELD_RETURN_VALUE,
});

activity_field_enum!(ActivityDeviceField, sys::CUpti_ActivityDeviceFieldIds, {
    Kind = DEVICE_FIELD_KIND,
    Flags = DEVICE_FIELD_FLAGS,
    GlobalMemoryBandwidth = DEVICE_FIELD_GLOBAL_MEMORY_BANDWIDTH,
    GlobalMemorySize = DEVICE_FIELD_GLOBAL_MEMORY_SIZE,
    ConstantMemorySize = DEVICE_FIELD_CONSTANT_MEMORY_SIZE,
    L2CacheSize = DEVICE_FIELD_L2_CACHE_SIZE,
    NumThreadsPerWarp = DEVICE_FIELD_NUM_THREADS_PER_WARP,
    CoreClockRate = DEVICE_FIELD_CORE_CLOCK_RATE,
    NumMemcpyEngines = DEVICE_FIELD_NUM_MEMCPY_ENGINES,
    NumMultiprocessors = DEVICE_FIELD_NUM_MULTIPROCESSORS,
    MaxIpc = DEVICE_FIELD_MAX_IPC,
    MaxWarpsPerMultiprocessor = DEVICE_FIELD_MAX_WARPS_PER_MULTIPROCESSOR,
    MaxBlocksPerMultiprocessor = DEVICE_FIELD_MAX_BLOCKS_PER_MULTIPROCESSOR,
    MaxSharedMemoryPerMultiprocessor = DEVICE_FIELD_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR,
    MaxRegistersPerMultiprocessor = DEVICE_FIELD_MAX_REGISTERS_PER_MULTIPROCESSOR,
    MaxRegistersPerBlock = DEVICE_FIELD_MAX_REGISTERS_PER_BLOCK,
    MaxSharedMemoryPerBlock = DEVICE_FIELD_MAX_SHARED_MEMORY_PER_BLOCK,
    MaxThreadsPerBlock = DEVICE_FIELD_MAX_THREADS_PER_BLOCK,
    MaxBlockDimX = DEVICE_FIELD_MAX_BLOCK_DIM_X,
    MaxBlockDimY = DEVICE_FIELD_MAX_BLOCK_DIM_Y,
    MaxBlockDimZ = DEVICE_FIELD_MAX_BLOCK_DIM_Z,
    MaxGridDimX = DEVICE_FIELD_MAX_GRID_DIM_X,
    MaxGridDimY = DEVICE_FIELD_MAX_GRID_DIM_Y,
    MaxGridDimZ = DEVICE_FIELD_MAX_GRID_DIM_Z,
    ComputeCapabilityMajor = DEVICE_FIELD_COMPUTE_CAPABILITY_MAJOR,
    ComputeCapabilityMinor = DEVICE_FIELD_COMPUTE_CAPABILITY_MINOR,
    Id = DEVICE_FIELD_ID,
    EccEnabled = DEVICE_FIELD_ECC_ENABLED,
    Uuid = DEVICE_FIELD_UUID,
    Name = DEVICE_FIELD_NAME,
    IsCudaVisible = DEVICE_FIELD_IS_CUDA_VISIBLE,
    IsMigEnabled = DEVICE_FIELD_IS_MIG_ENABLED,
    GpuInstanceId = DEVICE_FIELD_GPU_INSTANCE_ID,
    ComputeInstanceId = DEVICE_FIELD_COMPUTE_INSTANCE_ID,
    MigUuid = DEVICE_FIELD_MIG_UUID,
    IsNumaNode = DEVICE_FIELD_IS_NUMA_NODE,
    NumaId = DEVICE_FIELD_NUMA_ID,
    NumTpcs = DEVICE_FIELD_NUM_TPCS,
    Max = DEVICE_FIELD_MAX,
});

activity_field_enum!(ActivityMemcpyField, sys::CUpti_ActivityMemcpyFieldIds, {
    Kind = MEMCPY_FIELD_KIND,
    CopyKind = MEMCPY_FIELD_COPY_KIND,
    SourceKind = MEMCPY_FIELD_SRC_KIND,
    DestinationKind = MEMCPY_FIELD_DST_KIND,
    Flags = MEMCPY_FIELD_FLAGS,
    Bytes = MEMCPY_FIELD_BYTES,
    Start = MEMCPY_FIELD_START,
    End = MEMCPY_FIELD_END,
    DeviceId = MEMCPY_FIELD_DEVICE_ID,
    ContextId = MEMCPY_FIELD_CONTEXT_ID,
    StreamId = MEMCPY_FIELD_STREAM_ID,
    CorrelationId = MEMCPY_FIELD_CORRELATION_ID,
    GraphNodeId = MEMCPY_FIELD_GRAPH_NODE_ID,
    GraphId = MEMCPY_FIELD_GRAPH_ID,
    ChannelId = MEMCPY_FIELD_CHANNEL_ID,
    ChannelType = MEMCPY_FIELD_CHANNEL_TYPE,
    IsDeviceLaunched = MEMCPY_FIELD_IS_DEVICE_LAUNCHED,
    CopyCount = MEMCPY_FIELD_COPY_COUNT,
});

activity_field_enum!(ActivityMemcpy2Field, sys::CUpti_ActivityMemcpy2FieldIds, {
    Kind = MEMCPY2_FIELD_KIND,
    CopyKind = MEMCPY2_FIELD_COPY_KIND,
    SourceKind = MEMCPY2_FIELD_SRC_KIND,
    DestinationKind = MEMCPY2_FIELD_DST_KIND,
    Flags = MEMCPY2_FIELD_FLAGS,
    Bytes = MEMCPY2_FIELD_BYTES,
    Start = MEMCPY2_FIELD_START,
    End = MEMCPY2_FIELD_END,
    DeviceId = MEMCPY2_FIELD_DEVICE_ID,
    ContextId = MEMCPY2_FIELD_CONTEXT_ID,
    StreamId = MEMCPY2_FIELD_STREAM_ID,
    SourceDeviceId = MEMCPY2_FIELD_SRC_DEVICE_ID,
    SourceContextId = MEMCPY2_FIELD_SRC_CONTEXT_ID,
    DestinationDeviceId = MEMCPY2_FIELD_DST_DEVICE_ID,
    DestinationContextId = MEMCPY2_FIELD_DST_CONTEXT_ID,
    CorrelationId = MEMCPY2_FIELD_CORRELATION_ID,
    GraphNodeId = MEMCPY2_FIELD_GRAPH_NODE_ID,
    GraphId = MEMCPY2_FIELD_GRAPH_ID,
    ChannelId = MEMCPY2_FIELD_CHANNEL_ID,
    ChannelType = MEMCPY2_FIELD_CHANNEL_TYPE,
    Max = MEMCPY2_FIELD_MAX,
});

activity_field_enum!(ActivityMemsetField, sys::CUpti_ActivityMemsetFieldIds, {
    Kind = MEMSET_FIELD_KIND,
    Value = MEMSET_FIELD_VALUE,
    Bytes = MEMSET_FIELD_BYTES,
    Start = MEMSET_FIELD_START,
    End = MEMSET_FIELD_END,
    DeviceId = MEMSET_FIELD_DEVICE_ID,
    ContextId = MEMSET_FIELD_CONTEXT_ID,
    StreamId = MEMSET_FIELD_STREAM_ID,
    CorrelationId = MEMSET_FIELD_CORRELATION_ID,
    Flags = MEMSET_FIELD_FLAGS,
    MemoryKind = MEMSET_FIELD_MEMORY_KIND,
    GraphNodeId = MEMSET_FIELD_GRAPH_NODE_ID,
    GraphId = MEMSET_FIELD_GRAPH_ID,
    ChannelId = MEMSET_FIELD_CHANNEL_ID,
    ChannelType = MEMSET_FIELD_CHANNEL_TYPE,
    IsDeviceLaunched = MEMSET_FIELD_IS_DEVICE_LAUNCHED,
});

activity_field_enum!(ActivityMemoryField, sys::CUpti_ActivityMemoryFieldIds, {
    Kind = MEMORY_FIELD_KIND,
    OperationType = MEMORY_FIELD_OPERATION_TYPE,
    MemoryKind = MEMORY_FIELD_MEMORY_KIND,
    CorrelationId = MEMORY_FIELD_CORRELATION_ID,
    Address = MEMORY_FIELD_ADDRESS,
    Bytes = MEMORY_FIELD_BYTES,
    Timestamp = MEMORY_FIELD_TIMESTAMP,
    ProcessId = MEMORY_FIELD_PROCESS_ID,
    DeviceId = MEMORY_FIELD_DEVICE_ID,
    ContextId = MEMORY_FIELD_CONTEXT_ID,
    StreamId = MEMORY_FIELD_STREAM_ID,
    IsAsync = MEMORY_FIELD_IS_ASYNC,
    PoolType = MEMORY_FIELD_POOL_TYPE,
    PoolAddress = MEMORY_FIELD_POOL_ADDRESS,
    PoolReleaseThreshold = MEMORY_FIELD_POOL_RELEASE_THRESHOLD,
    PoolSize = MEMORY_FIELD_POOL_SIZE,
    PoolProcessId = MEMORY_FIELD_POOL_PROCESS_ID,
    PoolUtilizedSize = MEMORY_FIELD_POOL_UTILIZED_SIZE,
    Source = MEMORY_FIELD_SOURCE,
});

activity_field_enum!(
    ActivityMemoryPoolField,
    sys::CUpti_ActivityMemoryPoolFieldIds,
    {
        Kind = MEMORY_POOL_FIELD_KIND,
        OperationType = MEMORY_POOL_FIELD_OPERATION_TYPE,
        PoolType = MEMORY_POOL_FIELD_POOL_TYPE,
        CorrelationId = MEMORY_POOL_FIELD_CORRELATION_ID,
        ProcessId = MEMORY_POOL_FIELD_PROCESS_ID,
        DeviceId = MEMORY_POOL_FIELD_DEVICE_ID,
        MinBytesToKeep = MEMORY_POOL_FIELD_MIN_BYTES_TO_KEEP,
        Address = MEMORY_POOL_FIELD_ADDRESS,
        Size = MEMORY_POOL_FIELD_SIZE,
        ReleaseThreshold = MEMORY_POOL_FIELD_RELEASE_THRESHOLD,
        Timestamp = MEMORY_POOL_FIELD_TIMESTAMP,
        UtilizedSize = MEMORY_POOL_FIELD_UTILIZED_SIZE,
        IsManagedPool = MEMORY_POOL_FIELD_IS_MANAGED_POOL,
    }
);

activity_field_enum!(ActivityGraphTraceField, sys::CUpti_ActivityGraphTraceFieldIds, {
    Kind = GRAPH_TRACE_FIELD_KIND,
    CorrelationId = GRAPH_TRACE_FIELD_CORRELATION_ID,
    Start = GRAPH_TRACE_FIELD_START,
    End = GRAPH_TRACE_FIELD_END,
    DeviceId = GRAPH_TRACE_FIELD_DEVICE_ID,
    GraphId = GRAPH_TRACE_FIELD_GRAPH_ID,
    ContextId = GRAPH_TRACE_FIELD_CONTEXT_ID,
    StreamId = GRAPH_TRACE_FIELD_STREAM_ID,
    EndDeviceId = GRAPH_TRACE_FIELD_END_DEVICE_ID,
    EndContextId = GRAPH_TRACE_FIELD_END_CONTEXT_ID,
});

activity_field_enum!(
    ActivityDeviceGraphTraceField,
    sys::CUpti_ActivityDeviceGraphTraceFieldIds,
    {
        Kind = DEVICE_GRAPH_TRACE_FIELD_KIND,
        DeviceId = DEVICE_GRAPH_TRACE_FIELD_DEVICE_ID,
        Start = DEVICE_GRAPH_TRACE_FIELD_START,
        End = DEVICE_GRAPH_TRACE_FIELD_END,
        GraphId = DEVICE_GRAPH_TRACE_FIELD_GRAPH_ID,
        LauncherGraphId = DEVICE_GRAPH_TRACE_FIELD_LAUNCHER_GRAPH_ID,
        DeviceLaunchMode = DEVICE_GRAPH_TRACE_FIELD_DEVICE_LAUNCH_MODE,
        ContextId = DEVICE_GRAPH_TRACE_FIELD_CONTEXT_ID,
        StreamId = DEVICE_GRAPH_TRACE_FIELD_STREAM_ID,
    }
);

activity_field_enum!(
    ActivityGraphHostNodeField,
    sys::CUpti_ActivityGraphHostNodeFieldIds,
    {
        Kind = GRAPH_HOST_NODE_FIELD_KIND,
        StreamId = GRAPH_HOST_NODE_FIELD_STREAM_ID,
        ContextId = GRAPH_HOST_NODE_FIELD_CONTEXT_ID,
        DeviceId = GRAPH_HOST_NODE_FIELD_DEVICE_ID,
        CorrelationId = GRAPH_HOST_NODE_FIELD_CORRELATION_ID,
        GraphId = GRAPH_HOST_NODE_FIELD_GRAPH_ID,
        GraphNodeId = GRAPH_HOST_NODE_FIELD_GRAPH_NODE_ID,
        ProcessId = GRAPH_HOST_NODE_FIELD_PROCESS_ID,
        ThreadId = GRAPH_HOST_NODE_FIELD_THREAD_ID,
        Start = GRAPH_HOST_NODE_FIELD_START,
        End = GRAPH_HOST_NODE_FIELD_END,
    }
);

activity_field_enum!(ActivityHostLaunchField, sys::CUpti_ActivityHostLaunchFieldIds, {
    Kind = HOST_LAUNCH_FIELD_KIND,
    StreamId = HOST_LAUNCH_FIELD_STREAM_ID,
    ContextId = HOST_LAUNCH_FIELD_CONTEXT_ID,
    DeviceId = HOST_LAUNCH_FIELD_DEVICE_ID,
    CorrelationId = HOST_LAUNCH_FIELD_CORRELATION_ID,
    ProcessId = HOST_LAUNCH_FIELD_PROCESS_ID,
    ThreadId = HOST_LAUNCH_FIELD_THREAD_ID,
    Start = HOST_LAUNCH_FIELD_START,
    End = HOST_LAUNCH_FIELD_END,
});

activity_field_enum!(
    ActivityComputeEngineContextSwitchField,
    sys::CUpti_ActivityComputeEngineCtxSwitchFieldIds,
    {
        Kind = COMPUTE_ENGINE_CTX_SWITCH_FIELD_KIND,
        ContextId = COMPUTE_ENGINE_CTX_SWITCH_FIELD_CONTEXT_ID,
        Timestamp = COMPUTE_ENGINE_CTX_SWITCH_FIELD_TIMESTAMP,
        OperationType = COMPUTE_ENGINE_CTX_SWITCH_FIELD_OPERATION_TYPE,
    }
);

activity_field_enum!(
    ActivityGreenContextField,
    sys::CUpti_ActivityGreenContextFieldIds,
    {
        Kind = GREEN_CONTEXT_FIELD_KIND,
        ContextId = GREEN_CONTEXT_FIELD_CONTEXT_ID,
        ParentContextId = GREEN_CONTEXT_FIELD_PARENT_CONTEXT_ID,
        DeviceId = GREEN_CONTEXT_FIELD_DEVICE_ID,
        NumMultiprocessors = GREEN_CONTEXT_FIELD_NUM_MULTIPROCESSORS,
        NumTpcs = GREEN_CONTEXT_FIELD_NUM_TPCS,
        LogicalTpcMaskSize = GREEN_CONTEXT_FIELD_LOGICAL_TPC_MASK_SIZE,
        LogicalTpcMask = GREEN_CONTEXT_FIELD_LOGICAL_TPC_MASK,
    }
);

activity_field_enum!(ActivityNameField, sys::CUpti_ActivityNameFieldIds, {
    Kind = NAME_FIELD_KIND,
    ObjectKind = NAME_FIELD_OBJECT_KIND,
    ObjectId = NAME_FIELD_OBJECT_ID,
    Name = NAME_FIELD_NAME,
});

activity_field_enum!(ActivityMarkerField, sys::CUpti_ActivityMarkerFieldIds, {
    Kind = MARKER_FIELD_KIND,
    Flags = MARKER_FIELD_FLAGS,
    Timestamp = MARKER_FIELD_TIMESTAMP,
    Id = MARKER_FIELD_ID,
    ProcessId = MARKER_FIELD_PROCESS_ID,
    ThreadId = MARKER_FIELD_THREAD_ID,
    Name = MARKER_FIELD_NAME,
    Domain = MARKER_FIELD_DOMAIN,
});

activity_field_enum!(
    ActivityMarkerDataField,
    sys::CUpti_ActivityMarkerDataFieldIds,
    {
        Kind = MARKER_DATA_FIELD_KIND,
        Flags = MARKER_DATA_FIELD_FLAGS,
        Id = MARKER_DATA_FIELD_ID,
        PayloadKind = MARKER_DATA_FIELD_PAYLOAD_KIND,
        Payload = MARKER_DATA_FIELD_PAYLOAD,
        Color = MARKER_DATA_FIELD_COLOR,
        Category = MARKER_DATA_FIELD_CATEGORY,
        CuptiDomainId = MARKER_DATA_FIELD_CUPTI_DOMAIN_ID,
    }
);

activity_field_enum!(
    ActivityExternalCorrelationField,
    sys::CUpti_ActivityExternalCorrelationFieldIds,
    {
        Kind = EXTERNAL_CORRELATION_FIELD_KIND,
        ExternalKind = EXTERNAL_CORRELATION_FIELD_EXTERNAL_KIND,
        ExternalId = EXTERNAL_CORRELATION_FIELD_EXTERNAL_ID,
        CorrelationId = EXTERNAL_CORRELATION_FIELD_CORRELATION_ID,
    }
);

activity_field_enum!(ActivityCudaEventField, sys::CUpti_ActivityCudaEventFieldIds, {
    Kind = CUDA_EVENT_FIELD_KIND,
    CorrelationId = CUDA_EVENT_FIELD_CORRELATION_ID,
    ContextId = CUDA_EVENT_FIELD_CONTEXT_ID,
    StreamId = CUDA_EVENT_FIELD_STREAM_ID,
    EventId = CUDA_EVENT_FIELD_EVENT_ID,
    DeviceId = CUDA_EVENT_FIELD_DEVICE_ID,
    DeviceTimestamp = CUDA_EVENT_FIELD_DEVICE_TIMESTAMP,
    CudaEventSyncId = CUDA_EVENT_FIELD_CUDA_EVENT_SYNC_ID,
});

activity_field_enum!(ActivityOverheadField, sys::CUpti_ActivityOverheadFieldIds, {
    Kind = OVERHEAD_FIELD_KIND,
    OverheadKind = OVERHEAD_FIELD_OVERHEAD_KIND,
    ProcessId = OVERHEAD_FIELD_PROCESS_ID,
    ThreadId = OVERHEAD_FIELD_THREAD_ID,
    Start = OVERHEAD_FIELD_START,
    End = OVERHEAD_FIELD_END,
    CorrelationId = OVERHEAD_FIELD_CORRELATION_ID,
    OverheadData = OVERHEAD_FIELD_OVERHEAD_DATA,
});

activity_field_enum!(ActivityUvmCounterField, sys::CUpti_ActivityUvmCounterFieldIds, {
    Kind = UVM_COUNTER_FIELD_KIND,
    CounterKind = UVM_COUNTER_FIELD_COUNTER_KIND,
    Value = UVM_COUNTER_FIELD_VALUE,
    Start = UVM_COUNTER_FIELD_START,
    End = UVM_COUNTER_FIELD_END,
    Address = UVM_COUNTER_FIELD_ADDRESS,
    SourceId = UVM_COUNTER_FIELD_SRC_ID,
    DestinationId = UVM_COUNTER_FIELD_DST_ID,
    StreamId = UVM_COUNTER_FIELD_STREAM_ID,
    ProcessId = UVM_COUNTER_FIELD_PROCESS_ID,
    Flags = UVM_COUNTER_FIELD_FLAGS,
    Processors = UVM_COUNTER_FIELD_PROCESSORS,
    Max = UVM_COUNTER_FIELD_MAX,
});

activity_field_enum!(ActivityContextField, sys::CUpti_ActivityContextFieldIds, {
    Kind = CONTEXT_FIELD_KIND,
    ContextId = CONTEXT_FIELD_CONTEXT_ID,
    DeviceId = CONTEXT_FIELD_DEVICE_ID,
    ComputeApiKind = CONTEXT_FIELD_COMPUTE_API_KIND,
    NullStreamId = CONTEXT_FIELD_NULL_STREAM_ID,
    ParentContextId = CONTEXT_FIELD_PARENT_CONTEXT_ID,
    IsGreenContext = CONTEXT_FIELD_IS_GREEN_CONTEXT,
    NumMultiprocessors = CONTEXT_FIELD_NUM_MULTIPROCESSORS,
    CigMode = CONTEXT_FIELD_CIG_MODE,
    ProcessId = CONTEXT_FIELD_PROCESS_ID,
});

activity_field_enum!(ActivityKernelField, sys::CUpti_ActivityKernelFieldIds, {
    Kind = KERNEL_FIELD_KIND,
    CacheConfigRequested = KERNEL_FIELD_CACHE_CONFIG_REQUESTED,
    CacheConfigExecuted = KERNEL_FIELD_CACHE_CONFIG_EXECUTED,
    SharedMemoryConfig = KERNEL_FIELD_SHARED_MEMORY_CONFIG,
    RegistersPerThread = KERNEL_FIELD_REGISTERS_PER_THREAD,
    PartitionedGlobalCacheRequested = KERNEL_FIELD_PARTITIONED_GLOBAL_CACHE_REQUESTED,
    PartitionedGlobalCacheExecuted = KERNEL_FIELD_PARTITIONED_GLOBAL_CACHE_EXECUTED,
    Start = KERNEL_FIELD_START,
    End = KERNEL_FIELD_END,
    Completed = KERNEL_FIELD_COMPLETED,
    DeviceId = KERNEL_FIELD_DEVICE_ID,
    ContextId = KERNEL_FIELD_CONTEXT_ID,
    StreamId = KERNEL_FIELD_STREAM_ID,
    GridX = KERNEL_FIELD_GRID_X,
    GridY = KERNEL_FIELD_GRID_Y,
    GridZ = KERNEL_FIELD_GRID_Z,
    BlockX = KERNEL_FIELD_BLOCK_X,
    BlockY = KERNEL_FIELD_BLOCK_Y,
    BlockZ = KERNEL_FIELD_BLOCK_Z,
    StaticSharedMemory = KERNEL_FIELD_STATIC_SHARED_MEMORY,
    DynamicSharedMemory = KERNEL_FIELD_DYNAMIC_SHARED_MEMORY,
    LocalMemoryPerThread = KERNEL_FIELD_LOCAL_MEMORY_PER_THREAD,
    CorrelationId = KERNEL_FIELD_CORRELATION_ID,
    GridId = KERNEL_FIELD_GRID_ID,
    Name = KERNEL_FIELD_NAME,
    Queued = KERNEL_FIELD_QUEUED,
    Submitted = KERNEL_FIELD_SUBMITTED,
    LaunchType = KERNEL_FIELD_LAUNCH_TYPE,
    IsSharedMemoryCarveoutRequested = KERNEL_FIELD_IS_SHARED_MEMORY_CARVEOUT_REQUESTED,
    SharedMemoryCarveoutRequested = KERNEL_FIELD_SHARED_MEMORY_CARVEOUT_REQUESTED,
    SharedMemoryExecuted = KERNEL_FIELD_SHARED_MEMORY_EXECUTED,
    GraphNodeId = KERNEL_FIELD_GRAPH_NODE_ID,
    SharedMemoryLimitConfig = KERNEL_FIELD_SHMEM_LIMIT_CONFIG,
    GraphId = KERNEL_FIELD_GRAPH_ID,
    AccessPolicyWindow = KERNEL_FIELD_ACCESS_POLICY_WINDOW,
    ChannelId = KERNEL_FIELD_CHANNEL_ID,
    ChannelType = KERNEL_FIELD_CHANNEL_TYPE,
    ClusterX = KERNEL_FIELD_CLUSTER_X,
    ClusterY = KERNEL_FIELD_CLUSTER_Y,
    ClusterZ = KERNEL_FIELD_CLUSTER_Z,
    ClusterSchedulingPolicy = KERNEL_FIELD_CLUSTER_SCHEDULING_POLICY,
    LocalMemoryTotal = KERNEL_FIELD_LOCAL_MEMORY_TOTAL,
    MaxPotentialClusterSize = KERNEL_FIELD_MAX_POTENTIAL_CLUSTER_SIZE,
    MaxActiveClusters = KERNEL_FIELD_MAX_ACTIVE_CLUSTERS,
    IsDeviceLaunched = KERNEL_FIELD_IS_DEVICE_LAUNCHED,
    LaunchPriority = KERNEL_FIELD_LAUNCH_PRIORITY,
});

activity_field_enum!(
    ActivityMemDecompressField,
    sys::CUpti_ActivityMemDecompressFieldIds,
    {
        Kind = MEM_DECOMPRESS_FIELD_KIND,
        DeviceId = MEM_DECOMPRESS_FIELD_DEVICE_ID,
        ContextId = MEM_DECOMPRESS_FIELD_CONTEXT_ID,
        StreamId = MEM_DECOMPRESS_FIELD_STREAM_ID,
        ChannelId = MEM_DECOMPRESS_FIELD_CHANNEL_ID,
        ChannelType = MEM_DECOMPRESS_FIELD_CHANNEL_TYPE,
        CorrelationId = MEM_DECOMPRESS_FIELD_CORRELATION_ID,
        NumberOfOperations = MEM_DECOMPRESS_FIELD_NUMBER_OF_OPERATIONS,
        SourceBytes = MEM_DECOMPRESS_FIELD_SOURCE_BYTES,
        Start = MEM_DECOMPRESS_FIELD_START,
        End = MEM_DECOMPRESS_FIELD_END,
    }
);

activity_field_enum!(
    ActivityConfidentialComputeRotationField,
    sys::CUpti_ActivityConfidentialComputeRotationFieldIds,
    {
        Kind = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_KIND,
        EventType = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_EVENT_TYPE,
        DeviceId = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_DEVICE_ID,
        ContextId = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_CONTEXT_ID,
        ChannelId = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_CHANNEL_ID,
        ChannelType = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_CHANNEL_TYPE,
        Timestamp = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_TIMESTAMP,
        Max = CONFIDENTIAL_COMPUTE_ROTATION_FIELD_MAX,
    }
);

activity_field_enum!(ActivityJitField, sys::CUpti_ActivityJitFieldIds, {
    Kind = JIT_FIELD_KIND,
    EntryType = JIT_FIELD_ENTRY_TYPE,
    OperationType = JIT_FIELD_OPERATION_TYPE,
    DeviceId = JIT_FIELD_DEVICE_ID,
    Start = JIT_FIELD_START,
    End = JIT_FIELD_END,
    CorrelationId = JIT_FIELD_CORRELATION_ID,
    OperationCorrelationId = JIT_FIELD_OPERATION_CORRELATION_ID,
    CacheSize = JIT_FIELD_CACHE_SIZE,
    CachePath = JIT_FIELD_CACHE_PATH,
    ProcessId = JIT_FIELD_PROCESS_ID,
    ThreadId = JIT_FIELD_THREAD_ID,
    Max = JIT_FIELD_MAX,
});

activity_field_enum!(ActivityStreamField, sys::CUpti_ActivityStreamFieldIds, {
    Kind = STREAM_FIELD_KIND,
    ContextId = STREAM_FIELD_CONTEXT_ID,
    StreamId = STREAM_FIELD_STREAM_ID,
    Priority = STREAM_FIELD_PRIORITY,
    Flag = STREAM_FIELD_FLAG,
    CorrelationId = STREAM_FIELD_CORRELATION_ID,
});

activity_field_enum!(
    ActivitySynchronizationField,
    sys::CUpti_ActivitySynchronizationFieldIds,
    {
        Kind = SYNCHRONIZATION_FIELD_KIND,
        SynchronizationType = SYNCHRONIZATION_FIELD_TYPE,
        Start = SYNCHRONIZATION_FIELD_START,
        End = SYNCHRONIZATION_FIELD_END,
        CorrelationId = SYNCHRONIZATION_FIELD_CORRELATION_ID,
        ContextId = SYNCHRONIZATION_FIELD_CONTEXT_ID,
        StreamId = SYNCHRONIZATION_FIELD_STREAM_ID,
        CudaEventId = SYNCHRONIZATION_FIELD_CUDA_EVENT_ID,
        CudaEventSyncId = SYNCHRONIZATION_FIELD_CUDA_EVENT_SYNC_ID,
        ReturnValue = SYNCHRONIZATION_FIELD_RETURN_VALUE,
    }
);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ActivityConfig {
    field_ids: Vec<i32>,
}

impl ActivityConfig {
    pub fn create<I>(field_ids: I) -> Self
    where
        I: IntoIterator,
        I::Item: Into<ActivityFieldId>,
    {
        Self {
            field_ids: field_ids
                .into_iter()
                .map(|field| field.into().as_raw())
                .collect(),
        }
    }

    pub fn all_fields() -> Self {
        Self {
            field_ids: Vec::new(),
        }
    }

    pub(crate) fn as_raw_mut(&mut self) -> sys::CUpti_ActivityConfig {
        let field_ids = if self.field_ids.is_empty() {
            std::ptr::null_mut()
        } else {
            self.field_ids.as_mut_ptr()
        };
        let field_selection = sys::CUpti_ActivityFieldSelection {
            structSize: size_of::<sys::CUpti_ActivityFieldSelection>() as u64,
            numFields: self.field_ids.len() as u64,
            pFieldIds: field_ids,
        };
        sys::CUpti_ActivityConfig {
            structSize: size_of::<sys::CUpti_ActivityConfig>() as u64,
            fieldSelection: field_selection,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityPCSamplingPeriod {
    Invalid = sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_INVALID as _,
    Min = sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_MIN as _,
    Low = sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_LOW as _,
    Mid = sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_MID as _,
    High = sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_HIGH as _,
    Max = sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_MAX as _,
    ForceInt =
        sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityPCSamplingPeriod,
    ActivityPCSamplingPeriod
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityEnvironmentKind {
    Unknown = sys::CUpti_ActivityEnvironmentKind::CUPTI_ACTIVITY_ENVIRONMENT_UNKNOWN as _,
    Speed = sys::CUpti_ActivityEnvironmentKind::CUPTI_ACTIVITY_ENVIRONMENT_SPEED as _,
    Temperature = sys::CUpti_ActivityEnvironmentKind::CUPTI_ACTIVITY_ENVIRONMENT_TEMPERATURE as _,
    Power = sys::CUpti_ActivityEnvironmentKind::CUPTI_ACTIVITY_ENVIRONMENT_POWER as _,
    Cooling = sys::CUpti_ActivityEnvironmentKind::CUPTI_ACTIVITY_ENVIRONMENT_COOLING as _,
    Count = sys::CUpti_ActivityEnvironmentKind::CUPTI_ACTIVITY_ENVIRONMENT_COUNT as _,
    ForceInt = sys::CUpti_ActivityEnvironmentKind::CUPTI_ACTIVITY_ENVIRONMENT_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityEnvironmentKind, ActivityEnvironmentKind);

bitflags! {
    #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
    pub struct EnvironmentClocksThrottleReasons: u32 {
        const NONE = sys::CUpti_EnvironmentClocksThrottleReason::CUPTI_CLOCKS_THROTTLE_REASON_NONE as _;
        const GPU_IDLE = sys::CUpti_EnvironmentClocksThrottleReason::CUPTI_CLOCKS_THROTTLE_REASON_GPU_IDLE as _;
        const USER_DEFINED_CLOCKS = sys::CUpti_EnvironmentClocksThrottleReason::CUPTI_CLOCKS_THROTTLE_REASON_USER_DEFINED_CLOCKS as _;
        const SOFTWARE_POWER_CAP = sys::CUpti_EnvironmentClocksThrottleReason::CUPTI_CLOCKS_THROTTLE_REASON_SW_POWER_CAP as _;
        const HARDWARE_SLOWDOWN = sys::CUpti_EnvironmentClocksThrottleReason::CUPTI_CLOCKS_THROTTLE_REASON_HW_SLOWDOWN as _;
        const UNKNOWN = sys::CUpti_EnvironmentClocksThrottleReason::CUPTI_CLOCKS_THROTTLE_REASON_UNKNOWN as _;
        const UNSUPPORTED = sys::CUpti_EnvironmentClocksThrottleReason::CUPTI_CLOCKS_THROTTLE_REASON_UNSUPPORTED as _;
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityPreemptionKind {
    Unknown = sys::CUpti_ActivityPreemptionKind::CUPTI_ACTIVITY_PREEMPTION_KIND_UNKNOWN as _,
    Save = sys::CUpti_ActivityPreemptionKind::CUPTI_ACTIVITY_PREEMPTION_KIND_SAVE as _,
    Restore = sys::CUpti_ActivityPreemptionKind::CUPTI_ACTIVITY_PREEMPTION_KIND_RESTORE as _,
    ForceInt = sys::CUpti_ActivityPreemptionKind::CUPTI_ACTIVITY_PREEMPTION_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityPreemptionKind, ActivityPreemptionKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityPCSamplingStallReason {
    Invalid = sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_INVALID as _,
    None = sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_NONE as _,
    InstructionFetch =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_INST_FETCH as _,
    ExecutionDependency =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_EXEC_DEPENDENCY as _,
    MemoryDependency =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_MEMORY_DEPENDENCY as _,
    Texture = sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_TEXTURE as _,
    Sync = sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_SYNC as _,
    ConstantMemoryDependency =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_CONSTANT_MEMORY_DEPENDENCY as _,
    PipeBusy =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_PIPE_BUSY as _,
    MemoryThrottle =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_MEMORY_THROTTLE as _,
    NotSelected =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_NOT_SELECTED as _,
    Other = sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_OTHER as _,
    Sleeping =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_SLEEPING as _,
    ForceInt =
        sys::CUpti_ActivityPCSamplingStallReason::CUPTI_ACTIVITY_PC_SAMPLING_STALL_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityPCSamplingStallReason,
    ActivityPCSamplingStallReason
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityUnifiedMemoryCounterScope {
    Unknown = sys::CUpti_ActivityUnifiedMemoryCounterScope::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_UNKNOWN as _,
    ProcessSingleDevice = sys::CUpti_ActivityUnifiedMemoryCounterScope::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_PROCESS_SINGLE_DEVICE as _,
    ProcessAllDevices = sys::CUpti_ActivityUnifiedMemoryCounterScope::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_PROCESS_ALL_DEVICES as _,
    Count = sys::CUpti_ActivityUnifiedMemoryCounterScope::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_COUNT as _,
    ForceInt = sys::CUpti_ActivityUnifiedMemoryCounterScope::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityUnifiedMemoryCounterScope,
    ActivityUnifiedMemoryCounterScope
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityUnifiedMemoryCounterKind {
    Unknown = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_UNKNOWN as _,
    BytesTransferHostToDevice = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_BYTES_TRANSFER_HTOD as _,
    BytesTransferDeviceToHost = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_BYTES_TRANSFER_DTOH as _,
    CpuPageFaultCount = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_CPU_PAGE_FAULT_COUNT as _,
    GpuPageFault = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_GPU_PAGE_FAULT as _,
    Thrashing = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_THRASHING as _,
    Throttling = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_THROTTLING as _,
    RemoteMap = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_REMOTE_MAP as _,
    BytesTransferDeviceToDevice = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_BYTES_TRANSFER_DTOD as _,
    Count = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_COUNT as _,
    ForceInt = sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityUnifiedMemoryCounterKind,
    ActivityUnifiedMemoryCounterKind
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityUnifiedMemoryAccessType {
    Unknown = sys::CUpti_ActivityUnifiedMemoryAccessType::CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_UNKNOWN as _,
    Read = sys::CUpti_ActivityUnifiedMemoryAccessType::CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_READ as _,
    Write = sys::CUpti_ActivityUnifiedMemoryAccessType::CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_WRITE as _,
    Atomic = sys::CUpti_ActivityUnifiedMemoryAccessType::CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_ATOMIC as _,
    Prefetch = sys::CUpti_ActivityUnifiedMemoryAccessType::CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_PREFETCH as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityUnifiedMemoryAccessType,
    ActivityUnifiedMemoryAccessType
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityUnifiedMemoryMigrationCause {
    Unknown = sys::CUpti_ActivityUnifiedMemoryMigrationCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_UNKNOWN as _,
    User = sys::CUpti_ActivityUnifiedMemoryMigrationCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_USER as _,
    Coherence = sys::CUpti_ActivityUnifiedMemoryMigrationCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_COHERENCE as _,
    Prefetch = sys::CUpti_ActivityUnifiedMemoryMigrationCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_PREFETCH as _,
    Eviction = sys::CUpti_ActivityUnifiedMemoryMigrationCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_EVICTION as _,
    AccessCounters = sys::CUpti_ActivityUnifiedMemoryMigrationCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_ACCESS_COUNTERS as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityUnifiedMemoryMigrationCause,
    ActivityUnifiedMemoryMigrationCause
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityUnifiedMemoryRemoteMapCause {
    Unknown = sys::CUpti_ActivityUnifiedMemoryRemoteMapCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_UNKNOWN as _,
    Coherence = sys::CUpti_ActivityUnifiedMemoryRemoteMapCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_COHERENCE as _,
    Thrashing = sys::CUpti_ActivityUnifiedMemoryRemoteMapCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_THRASHING as _,
    Policy = sys::CUpti_ActivityUnifiedMemoryRemoteMapCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_POLICY as _,
    OutOfMemory = sys::CUpti_ActivityUnifiedMemoryRemoteMapCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_OUT_OF_MEMORY as _,
    Eviction = sys::CUpti_ActivityUnifiedMemoryRemoteMapCause::CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_EVICTION as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityUnifiedMemoryRemoteMapCause,
    ActivityUnifiedMemoryRemoteMapCause
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityInstructionClass {
    Unknown = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_UNKNOWN as _,
    Float32 = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_FP_32 as _,
    Float64 = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_FP_64 as _,
    Integer = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_INTEGER as _,
    BitConversion =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_BIT_CONVERSION as _,
    ControlFlow =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_CONTROL_FLOW as _,
    Global = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_GLOBAL as _,
    Shared = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_SHARED as _,
    Local = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_LOCAL as _,
    Generic = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_GENERIC as _,
    Surface = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_SURFACE as _,
    Constant = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_CONSTANT as _,
    Texture = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_TEXTURE as _,
    GlobalAtomic =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_GLOBAL_ATOMIC as _,
    SharedAtomic =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_SHARED_ATOMIC as _,
    SurfaceAtomic =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_SURFACE_ATOMIC as _,
    InterThreadCommunication =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_INTER_THREAD_COMMUNICATION as _,
    Barrier = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_BARRIER as _,
    Miscellaneous =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_MISCELLANEOUS as _,
    Float16 = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_FP_16 as _,
    Uniform = sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_UNIFORM as _,
    ForceInt =
        sys::CUpti_ActivityInstructionClass::CUPTI_ACTIVITY_INSTRUCTION_CLASS_KIND_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityInstructionClass,
    ActivityInstructionClass
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ConfidentialComputeRotationEventType {
    Invalid =
        sys::CUpti_ConfidentialComputeRotationEventType::CUPTI_CONFIDENTIAL_COMPUTE_INVALID_ROTATION_EVENT as _,
    ChannelBlocked =
        sys::CUpti_ConfidentialComputeRotationEventType::CUPTI_CONFIDENTIAL_COMPUTE_KEY_ROTATION_CHANNEL_BLOCKED as _,
    ChannelDrained =
        sys::CUpti_ConfidentialComputeRotationEventType::CUPTI_CONFIDENTIAL_COMPUTE_KEY_ROTATION_CHANNEL_DRAINED as _,
    ChannelUnblocked =
        sys::CUpti_ConfidentialComputeRotationEventType::CUPTI_CONFIDENTIAL_COMPUTE_KEY_ROTATION_CHANNEL_UNBLOCKED as _,
    ForceInt =
        sys::CUpti_ConfidentialComputeRotationEventType::CUPTI_CONFIDENTIAL_COMPUTE_EVENT_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ConfidentialComputeRotationEventType,
    ConfidentialComputeRotationEventType
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum DeviceType {
    Invalid = sys::CUpti_DevType::CUPTI_DEV_TYPE_INVALID as _,
    Gpu = sys::CUpti_DevType::CUPTI_DEV_TYPE_GPU as _,
    Npu = sys::CUpti_DevType::CUPTI_DEV_TYPE_NPU as _,
    ForceInt = sys::CUpti_DevType::CUPTI_DEV_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_DevType, DeviceType);

bitflags! {
    #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
    pub struct LinkFlags: u32 {
        const PEER_ACCESS = sys::CUpti_LinkFlag::CUPTI_LINK_FLAG_PEER_ACCESS as _;
        const SYSTEM_MEMORY_ACCESS = sys::CUpti_LinkFlag::CUPTI_LINK_FLAG_SYSMEM_ACCESS as _;
        const PEER_ATOMICS = sys::CUpti_LinkFlag::CUPTI_LINK_FLAG_PEER_ATOMICS as _;
        const SYSTEM_MEMORY_ATOMICS = sys::CUpti_LinkFlag::CUPTI_LINK_FLAG_SYSMEM_ATOMICS as _;
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum PcieDeviceType {
    Gpu = sys::CUpti_PcieDeviceType::CUPTI_PCIE_DEVICE_TYPE_GPU as _,
    Bridge = sys::CUpti_PcieDeviceType::CUPTI_PCIE_DEVICE_TYPE_BRIDGE as _,
    ForceInt = sys::CUpti_PcieDeviceType::CUPTI_PCIE_DEVICE_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_PcieDeviceType, PcieDeviceType);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum OpenAccEventKind {
    Invalid = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_INVALID as _,
    DeviceInit = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_DEVICE_INIT as _,
    DeviceShutdown = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_DEVICE_SHUTDOWN as _,
    RuntimeShutdown = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_RUNTIME_SHUTDOWN as _,
    EnqueueLaunch = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_ENQUEUE_LAUNCH as _,
    EnqueueUpload = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_ENQUEUE_UPLOAD as _,
    EnqueueDownload = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_ENQUEUE_DOWNLOAD as _,
    Wait = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_WAIT as _,
    ImplicitWait = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_IMPLICIT_WAIT as _,
    ComputeConstruct = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_COMPUTE_CONSTRUCT as _,
    Update = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_UPDATE as _,
    EnterData = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_ENTER_DATA as _,
    ExitData = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_EXIT_DATA as _,
    Create = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_CREATE as _,
    Delete = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_DELETE as _,
    Alloc = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_ALLOC as _,
    Free = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_FREE as _,
    ForceInt = sys::CUpti_OpenAccEventKind::CUPTI_OPENACC_EVENT_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_OpenAccEventKind, OpenAccEventKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum OpenAccConstructKind {
    Unknown = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_UNKNOWN as _,
    Parallel = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_PARALLEL as _,
    Kernels = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_KERNELS as _,
    Loop = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_LOOP as _,
    Data = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_DATA as _,
    EnterData = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_ENTER_DATA as _,
    ExitData = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_EXIT_DATA as _,
    HostData = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_HOST_DATA as _,
    Atomic = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_ATOMIC as _,
    Declare = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_DECLARE as _,
    Init = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_INIT as _,
    Shutdown = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_SHUTDOWN as _,
    Set = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_SET as _,
    Update = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_UPDATE as _,
    Routine = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_ROUTINE as _,
    Wait = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_WAIT as _,
    RuntimeApi = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_RUNTIME_API as _,
    ForceInt = sys::CUpti_OpenAccConstructKind::CUPTI_OPENACC_CONSTRUCT_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_OpenAccConstructKind, OpenAccConstructKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum OpenMpEventKind {
    Invalid = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_INVALID as _,
    Parallel = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_PARALLEL as _,
    Task = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_TASK as _,
    Thread = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_THREAD as _,
    Idle = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_IDLE as _,
    WaitBarrier = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_WAIT_BARRIER as _,
    WaitTaskwait = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_WAIT_TASKWAIT as _,
    ForceInt = sys::CUpti_OpenMpEventKind::CUPTI_OPENMP_EVENT_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_OpenMpEventKind, OpenMpEventKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityJitEntryType {
    Invalid = sys::CUpti_ActivityJitEntryType::CUPTI_ACTIVITY_JIT_ENTRY_INVALID as _,
    PtxToCubin = sys::CUpti_ActivityJitEntryType::CUPTI_ACTIVITY_JIT_ENTRY_PTX_TO_CUBIN as _,
    NvvmIrToPtx = sys::CUpti_ActivityJitEntryType::CUPTI_ACTIVITY_JIT_ENTRY_NVVM_IR_TO_PTX as _,
    ForceInt = sys::CUpti_ActivityJitEntryType::CUPTI_ACTIVITY_JIT_ENTRY_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityJitEntryType, ActivityJitEntryType);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityJitOperationType {
    Invalid = sys::CUpti_ActivityJitOperationType::CUPTI_ACTIVITY_JIT_OPERATION_INVALID as _,
    CacheLoad = sys::CUpti_ActivityJitOperationType::CUPTI_ACTIVITY_JIT_OPERATION_CACHE_LOAD as _,
    CacheStore = sys::CUpti_ActivityJitOperationType::CUPTI_ACTIVITY_JIT_OPERATION_CACHE_STORE as _,
    Compile = sys::CUpti_ActivityJitOperationType::CUPTI_ACTIVITY_JIT_OPERATION_COMPILE as _,
    ForceInt =
        sys::CUpti_ActivityJitOperationType::CUPTI_ACTIVITY_JIT_OPERATION_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_ActivityJitOperationType,
    ActivityJitOperationType
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ActivityPCSamplingConfig {
    pub sampling_period: ActivityPCSamplingPeriod,
    pub sampling_period2: u32,
}

impl ActivityPCSamplingConfig {
    pub const fn create(sampling_period: ActivityPCSamplingPeriod) -> Self {
        Self {
            sampling_period,
            sampling_period2: 0,
        }
    }

    pub(crate) fn to_raw(self) -> sys::CUpti_ActivityPCSamplingConfig {
        sys::CUpti_ActivityPCSamplingConfig {
            size: size_of::<sys::CUpti_ActivityPCSamplingConfig>() as u32,
            samplingPeriod: self.sampling_period.into(),
            samplingPeriod2: self.sampling_period2,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ActivityUnifiedMemoryCounterConfig {
    pub scope: ActivityUnifiedMemoryCounterScope,
    pub kind: ActivityUnifiedMemoryCounterKind,
    pub device_id: DeviceId,
    pub enable: bool,
}

impl ActivityUnifiedMemoryCounterConfig {
    pub const fn create(kind: ActivityUnifiedMemoryCounterKind, enable: bool) -> Self {
        Self {
            scope: ActivityUnifiedMemoryCounterScope::ProcessAllDevices,
            kind,
            device_id: DeviceId(0),
            enable,
        }
    }

    pub(crate) fn to_raw(self) -> sys::CUpti_ActivityUnifiedMemoryCounterConfig {
        #[allow(deprecated)]
        sys::CUpti_ActivityUnifiedMemoryCounterConfig {
            scope: self.scope.into(),
            kind: self.kind.into(),
            deviceId: self.device_id.as_raw(),
            enable: self.enable as u32,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ActivityAutoBoostState {
    pub enabled: bool,
    pub process_id: ProcessId,
}

impl From<sys::CUpti_ActivityAutoBoostState> for ActivityAutoBoostState {
    fn from(value: sys::CUpti_ActivityAutoBoostState) -> Self {
        Self {
            enabled: value.enabled != 0,
            process_id: ProcessId::from(value.pid),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum ActivityThreadIdType {
    Default = sys::CUpti_ActivityThreadIdType::CUPTI_ACTIVITY_THREAD_ID_TYPE_DEFAULT as _,
    System = sys::CUpti_ActivityThreadIdType::CUPTI_ACTIVITY_THREAD_ID_TYPE_SYSTEM as _,
    Size = sys::CUpti_ActivityThreadIdType::CUPTI_ACTIVITY_THREAD_ID_TYPE_SIZE as _,
    ForceInt = sys::CUpti_ActivityThreadIdType::CUPTI_ACTIVITY_THREAD_ID_TYPE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_ActivityThreadIdType, ActivityThreadIdType);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum MetricCategory {
    Memory = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_MEMORY as _,
    Instruction = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_INSTRUCTION as _,
    Multiprocessor = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_MULTIPROCESSOR as _,
    Cache = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_CACHE as _,
    Texture = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_TEXTURE as _,
    Nvlink = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_NVLINK as _,
    Pcie = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_PCIE as _,
    ForceInt = sys::CUpti_MetricCategory::CUPTI_METRIC_CATEGORY_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_MetricCategory, MetricCategory);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum MetricEvaluationMode {
    PerInstance = sys::CUpti_MetricEvaluationMode::CUPTI_METRIC_EVALUATION_MODE_PER_INSTANCE as _,
    Aggregate = sys::CUpti_MetricEvaluationMode::CUPTI_METRIC_EVALUATION_MODE_AGGREGATE as _,
    ForceInt = sys::CUpti_MetricEvaluationMode::CUPTI_METRIC_EVALUATION_MODE_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_MetricEvaluationMode, MetricEvaluationMode);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum MetricValueKind {
    Double = sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_DOUBLE as _,
    Uint64 = sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_UINT64 as _,
    Percent = sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_PERCENT as _,
    Throughput = sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_THROUGHPUT as _,
    Int64 = sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_INT64 as _,
    UtilizationLevel = sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_UTILIZATION_LEVEL as _,
    NvtxExtendedPayload =
        sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_NVTX_EXTENDED_PAYLOAD as _,
    ForceInt = sys::CUpti_MetricValueKind::CUPTI_METRIC_VALUE_KIND_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_MetricValueKind, MetricValueKind);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum MetricValueUtilizationLevel {
    Idle = sys::CUpti_MetricValueUtilizationLevel::CUPTI_METRIC_VALUE_UTILIZATION_IDLE as _,
    Low = sys::CUpti_MetricValueUtilizationLevel::CUPTI_METRIC_VALUE_UTILIZATION_LOW as _,
    Mid = sys::CUpti_MetricValueUtilizationLevel::CUPTI_METRIC_VALUE_UTILIZATION_MID as _,
    High = sys::CUpti_MetricValueUtilizationLevel::CUPTI_METRIC_VALUE_UTILIZATION_HIGH as _,
    Max = sys::CUpti_MetricValueUtilizationLevel::CUPTI_METRIC_VALUE_UTILIZATION_MAX as _,
    ForceInt =
        sys::CUpti_MetricValueUtilizationLevel::CUPTI_METRIC_VALUE_UTILIZATION_FORCE_INT as _,
}

impl_enum_conversion!(
    sys::CUpti_MetricValueUtilizationLevel,
    MetricValueUtilizationLevel
);

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MetricValue {
    Double(f64),
    Uint64(u64),
    Percent(f64),
    Throughput(u64),
    Int64(i64),
    UtilizationLevel(MetricValueUtilizationLevel),
    NvtxExtendedPayload(u64),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum MetricAttribute {
    Name = sys::CUpti_MetricAttribute::CUPTI_METRIC_ATTR_NAME as _,
    ShortDescription = sys::CUpti_MetricAttribute::CUPTI_METRIC_ATTR_SHORT_DESCRIPTION as _,
    LongDescription = sys::CUpti_MetricAttribute::CUPTI_METRIC_ATTR_LONG_DESCRIPTION as _,
    Category = sys::CUpti_MetricAttribute::CUPTI_METRIC_ATTR_CATEGORY as _,
    ValueKind = sys::CUpti_MetricAttribute::CUPTI_METRIC_ATTR_VALUE_KIND as _,
    EvaluationMode = sys::CUpti_MetricAttribute::CUPTI_METRIC_ATTR_EVALUATION_MODE as _,
    ForceInt = sys::CUpti_MetricAttribute::CUPTI_METRIC_ATTR_FORCE_INT as _,
}

impl_enum_conversion!(sys::CUpti_MetricAttribute, MetricAttribute);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum MetricAttributeValue {
    Name(String),
    ShortDescription(String),
    LongDescription(String),
    Category(MetricCategory),
    ValueKind(MetricValueKind),
    EvaluationMode(MetricEvaluationMode),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum MetricPropertyDeviceClass {
    Tesla = sys::CUpti_MetricPropertyDeviceClass::CUPTI_METRIC_PROPERTY_DEVICE_CLASS_TESLA as _,
    Quadro = sys::CUpti_MetricPropertyDeviceClass::CUPTI_METRIC_PROPERTY_DEVICE_CLASS_QUADRO as _,
    Geforce = sys::CUpti_MetricPropertyDeviceClass::CUPTI_METRIC_PROPERTY_DEVICE_CLASS_GEFORCE as _,
    Tegra = sys::CUpti_MetricPropertyDeviceClass::CUPTI_METRIC_PROPERTY_DEVICE_CLASS_TEGRA as _,
}

impl_enum_conversion!(
    sys::CUpti_MetricPropertyDeviceClass,
    MetricPropertyDeviceClass
);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive)]
#[repr(u32)]
pub enum MetricPropertyId {
    MultiprocessorCount =
        sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_MULTIPROCESSOR_COUNT as _,
    WarpsPerMultiprocessor =
        sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_WARPS_PER_MULTIPROCESSOR as _,
    KernelGpuTime = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_KERNEL_GPU_TIME as _,
    ClockRate = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_CLOCK_RATE as _,
    FrameBufferCount = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_FRAME_BUFFER_COUNT as _,
    GlobalMemoryBandwidth =
        sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_GLOBAL_MEMORY_BANDWIDTH as _,
    PcieLinkRate = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_PCIE_LINK_RATE as _,
    PcieLinkWidth = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_PCIE_LINK_WIDTH as _,
    PcieGen = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_PCIE_GEN as _,
    DeviceClass = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_DEVICE_CLASS as _,
    FlopSpPerCycle = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_FLOP_SP_PER_CYCLE as _,
    FlopDpPerCycle = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_FLOP_DP_PER_CYCLE as _,
    L2Units = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_L2_UNITS as _,
    EccEnabled = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_ECC_ENABLED as _,
    FlopHpPerCycle = sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_FLOP_HP_PER_CYCLE as _,
    GpuCpuNvlinkBandwidth =
        sys::CUpti_MetricPropertyID::CUPTI_METRIC_PROPERTY_GPU_CPU_NVLINK_BANDWIDTH as _,
}

impl_enum_conversion!(sys::CUpti_MetricPropertyID, MetricPropertyId);

bitflags! {
    #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
    pub struct ActivityFlags: u32 {
        const NONE = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_NONE as _;
        const DEVICE_CONCURRENT_KERNELS = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_DEVICE_CONCURRENT_KERNELS as _;
        const DEVICE_ATTRIBUTE_CUDEVICE = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_DEVICE_ATTRIBUTE_CUDEVICE as _;
        const MARKER_START = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_MARKER_START as _;
        const MARKER_END = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_MARKER_END as _;
        const MARKER_SYNC_ACQUIRE = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_MARKER_SYNC_ACQUIRE as _;
        const MARKER_SYNC_ACQUIRE_SUCCESS = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_MARKER_SYNC_ACQUIRE_SUCCESS as _;
        const MARKER_SYNC_ACQUIRE_FAILED = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_MARKER_SYNC_ACQUIRE_FAILED as _;
        const MARKER_SYNC_RELEASE = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_MARKER_SYNC_RELEASE as _;
        const GLOBAL_ACCESS_KIND_SIZE_MASK = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_GLOBAL_ACCESS_KIND_SIZE_MASK as _;
        const GLOBAL_ACCESS_KIND_LOAD = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_GLOBAL_ACCESS_KIND_LOAD as _;
        const GLOBAL_ACCESS_KIND_CACHED = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_GLOBAL_ACCESS_KIND_CACHED as _;
        const INSTRUCTION_CLASS_MASK = sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_INSTRUCTION_CLASS_MASK as _;
    }
}

impl Display for ApiCallbackSite {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Enter => write!(f, "CUPTI_API_ENTER"),
            Self::Exit => write!(f, "CUPTI_API_EXIT"),
            Self::ForceInt => write!(f, "CUPTI_API_CBSITE_FORCE_INT"),
        }
    }
}

impl Display for DeviceAttributeDeviceClass {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Tesla => write!(f, "CUPTI_DEVICE_ATTR_DEVICE_CLASS_TESLA"),
            Self::Quadro => write!(f, "CUPTI_DEVICE_ATTR_DEVICE_CLASS_QUADRO"),
            Self::Geforce => write!(f, "CUPTI_DEVICE_ATTR_DEVICE_CLASS_GEFORCE"),
            Self::Tegra => write!(f, "CUPTI_DEVICE_ATTR_DEVICE_CLASS_TEGRA"),
        }
    }
}

impl Display for DeviceAttribute {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::MaxEventId => write!(f, "CUPTI_DEVICE_ATTR_MAX_EVENT_ID"),
            Self::MaxEventDomainId => write!(f, "CUPTI_DEVICE_ATTR_MAX_EVENT_DOMAIN_ID"),
            Self::GlobalMemoryBandwidth => write!(f, "CUPTI_DEVICE_ATTR_GLOBAL_MEMORY_BANDWIDTH"),
            Self::InstructionPerCycle => write!(f, "CUPTI_DEVICE_ATTR_INSTRUCTION_PER_CYCLE"),
            Self::InstructionThroughputSinglePrecision => write!(
                f,
                "CUPTI_DEVICE_ATTR_INSTRUCTION_THROUGHPUT_SINGLE_PRECISION"
            ),
            Self::MaxFrameBuffers => write!(f, "CUPTI_DEVICE_ATTR_MAX_FRAME_BUFFERS"),
            Self::PcieLinkRate => write!(f, "CUPTI_DEVICE_ATTR_PCIE_LINK_RATE"),
            Self::PcieLinkWidth => write!(f, "CUPTI_DEVICE_ATTR_PCIE_LINK_WIDTH"),
            Self::PcieGen => write!(f, "CUPTI_DEVICE_ATTR_PCIE_GEN"),
            Self::DeviceClass => write!(f, "CUPTI_DEVICE_ATTR_DEVICE_CLASS"),
            Self::FlopSpPerCycle => write!(f, "CUPTI_DEVICE_ATTR_FLOP_SP_PER_CYCLE"),
            Self::FlopDpPerCycle => write!(f, "CUPTI_DEVICE_ATTR_FLOP_DP_PER_CYCLE"),
            Self::MaxL2Units => write!(f, "CUPTI_DEVICE_ATTR_MAX_L2_UNITS"),
            Self::MaxSharedMemoryCacheConfigPreferShared => write!(
                f,
                "CUPTI_DEVICE_ATTR_MAX_SHARED_MEMORY_CACHE_CONFIG_PREFER_SHARED"
            ),
            Self::MaxSharedMemoryCacheConfigPreferL1 => write!(
                f,
                "CUPTI_DEVICE_ATTR_MAX_SHARED_MEMORY_CACHE_CONFIG_PREFER_L1"
            ),
            Self::MaxSharedMemoryCacheConfigPreferEqual => write!(
                f,
                "CUPTI_DEVICE_ATTR_MAX_SHARED_MEMORY_CACHE_CONFIG_PREFER_EQUAL"
            ),
            Self::FlopHpPerCycle => write!(f, "CUPTI_DEVICE_ATTR_FLOP_HP_PER_CYCLE"),
            Self::NvlinkPresent => write!(f, "CUPTI_DEVICE_ATTR_NVLINK_PRESENT"),
            Self::GpuCpuNvlinkBw => write!(f, "CUPTI_DEVICE_ATTR_GPU_CPU_NVLINK_BW"),
            Self::NvswitchPresent => write!(f, "CUPTI_DEVICE_ATTR_NVSWITCH_PRESENT"),
            Self::ForceInt => write!(f, "CUPTI_DEVICE_ATTR_FORCE_INT"),
        }
    }
}

impl Display for EventDomainAttribute {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Name => write!(f, "CUPTI_EVENT_DOMAIN_ATTR_NAME"),
            Self::InstanceCount => write!(f, "CUPTI_EVENT_DOMAIN_ATTR_INSTANCE_COUNT"),
            Self::TotalInstanceCount => write!(f, "CUPTI_EVENT_DOMAIN_ATTR_TOTAL_INSTANCE_COUNT"),
            Self::CollectionMethod => write!(f, "CUPTI_EVENT_DOMAIN_ATTR_COLLECTION_METHOD"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_DOMAIN_ATTR_FORCE_INT"),
        }
    }
}

impl Display for EventCollectionMethod {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Pm => write!(f, "CUPTI_EVENT_COLLECTION_METHOD_PM"),
            Self::Sm => write!(f, "CUPTI_EVENT_COLLECTION_METHOD_SM"),
            Self::Instrumented => write!(f, "CUPTI_EVENT_COLLECTION_METHOD_INSTRUMENTED"),
            Self::NvlinkTc => write!(f, "CUPTI_EVENT_COLLECTION_METHOD_NVLINK_TC"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_COLLECTION_METHOD_FORCE_INT"),
        }
    }
}

impl Display for EventGroupAttribute {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::EventDomainId => write!(f, "CUPTI_EVENT_GROUP_ATTR_EVENT_DOMAIN_ID"),
            Self::ProfileAllDomainInstances => {
                write!(f, "CUPTI_EVENT_GROUP_ATTR_PROFILE_ALL_DOMAIN_INSTANCES")
            }
            Self::UserData => write!(f, "CUPTI_EVENT_GROUP_ATTR_USER_DATA"),
            Self::NumEvents => write!(f, "CUPTI_EVENT_GROUP_ATTR_NUM_EVENTS"),
            Self::Events => write!(f, "CUPTI_EVENT_GROUP_ATTR_EVENTS"),
            Self::InstanceCount => write!(f, "CUPTI_EVENT_GROUP_ATTR_INSTANCE_COUNT"),
            Self::ProfilingScope => write!(f, "CUPTI_EVENT_GROUP_ATTR_PROFILING_SCOPE"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_GROUP_ATTR_FORCE_INT"),
        }
    }
}

impl Display for EventProfilingScope {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Context => write!(f, "CUPTI_EVENT_PROFILING_SCOPE_CONTEXT"),
            Self::Device => write!(f, "CUPTI_EVENT_PROFILING_SCOPE_DEVICE"),
            Self::Both => write!(f, "CUPTI_EVENT_PROFILING_SCOPE_BOTH"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_PROFILING_SCOPE_FORCE_INT"),
        }
    }
}

impl Display for EventAttribute {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Name => write!(f, "CUPTI_EVENT_ATTR_NAME"),
            Self::ShortDescription => write!(f, "CUPTI_EVENT_ATTR_SHORT_DESCRIPTION"),
            Self::LongDescription => write!(f, "CUPTI_EVENT_ATTR_LONG_DESCRIPTION"),
            Self::Category => write!(f, "CUPTI_EVENT_ATTR_CATEGORY"),
            Self::ProfilingScope => write!(f, "CUPTI_EVENT_ATTR_PROFILING_SCOPE"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_ATTR_FORCE_INT"),
        }
    }
}

impl Display for EventCategory {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Instruction => write!(f, "CUPTI_EVENT_CATEGORY_INSTRUCTION"),
            Self::Memory => write!(f, "CUPTI_EVENT_CATEGORY_MEMORY"),
            Self::Cache => write!(f, "CUPTI_EVENT_CATEGORY_CACHE"),
            Self::ProfileTrigger => write!(f, "CUPTI_EVENT_CATEGORY_PROFILE_TRIGGER"),
            Self::System => write!(f, "CUPTI_EVENT_CATEGORY_SYSTEM"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_CATEGORY_FORCE_INT"),
        }
    }
}

impl Display for EventCollectionMode {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Continuous => write!(f, "CUPTI_EVENT_COLLECTION_MODE_CONTINUOUS"),
            Self::Kernel => write!(f, "CUPTI_EVENT_COLLECTION_MODE_KERNEL"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_COLLECTION_MODE_FORCE_INT"),
        }
    }
}

impl Display for ReadEventFlags {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::None => write!(f, "CUPTI_EVENT_READ_FLAG_NONE"),
            Self::ForceInt => write!(f, "CUPTI_EVENT_READ_FLAG_FORCE_INT"),
        }
    }
}

impl Display for CallbackIdSync {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_CBID_SYNCHRONIZE_INVALID"),
            Self::StreamSynchronized => write!(f, "CUPTI_CBID_SYNCHRONIZE_STREAM_SYNCHRONIZED"),
            Self::ContextSynchronized => write!(f, "CUPTI_CBID_SYNCHRONIZE_CONTEXT_SYNCHRONIZED"),
            Self::Size => write!(f, "CUPTI_CBID_SYNCHRONIZE_SIZE"),
            Self::ForceInt => write!(f, "CUPTI_CBID_SYNCHRONIZE_FORCE_INT"),
        }
    }
}

impl Display for CallbackIdState {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_CBID_STATE_INVALID"),
            Self::FatalError => write!(f, "CUPTI_CBID_STATE_FATAL_ERROR"),
            Self::Error => write!(f, "CUPTI_CBID_STATE_ERROR"),
            Self::Warning => write!(f, "CUPTI_CBID_STATE_WARNING"),
            Self::Size => write!(f, "CUPTI_CBID_STATE_SIZE"),
            Self::ForceInt => write!(f, "CUPTI_CBID_STATE_FORCE_INT"),
        }
    }
}

impl Display for ActivityKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_KIND_INVALID"),
            Self::Memcpy => write!(f, "CUPTI_ACTIVITY_KIND_MEMCPY"),
            Self::Memset => write!(f, "CUPTI_ACTIVITY_KIND_MEMSET"),
            Self::Kernel => write!(f, "CUPTI_ACTIVITY_KIND_KERNEL"),
            Self::Driver => write!(f, "CUPTI_ACTIVITY_KIND_DRIVER"),
            Self::Runtime => write!(f, "CUPTI_ACTIVITY_KIND_RUNTIME"),
            Self::Event => write!(f, "CUPTI_ACTIVITY_KIND_EVENT"),
            Self::Metric => write!(f, "CUPTI_ACTIVITY_KIND_METRIC"),
            Self::Device => write!(f, "CUPTI_ACTIVITY_KIND_DEVICE"),
            Self::Context => write!(f, "CUPTI_ACTIVITY_KIND_CONTEXT"),
            Self::ConcurrentKernel => write!(f, "CUPTI_ACTIVITY_KIND_CONCURRENT_KERNEL"),
            Self::Name => write!(f, "CUPTI_ACTIVITY_KIND_NAME"),
            Self::Marker => write!(f, "CUPTI_ACTIVITY_KIND_MARKER"),
            Self::MarkerData => write!(f, "CUPTI_ACTIVITY_KIND_MARKER_DATA"),
            Self::SourceLocator => write!(f, "CUPTI_ACTIVITY_KIND_SOURCE_LOCATOR"),
            Self::GlobalAccess => write!(f, "CUPTI_ACTIVITY_KIND_GLOBAL_ACCESS"),
            Self::Branch => write!(f, "CUPTI_ACTIVITY_KIND_BRANCH"),
            Self::Overhead => write!(f, "CUPTI_ACTIVITY_KIND_OVERHEAD"),
            Self::CdpKernel => write!(f, "CUPTI_ACTIVITY_KIND_CDP_KERNEL"),
            Self::Preemption => write!(f, "CUPTI_ACTIVITY_KIND_PREEMPTION"),
            Self::Environment => write!(f, "CUPTI_ACTIVITY_KIND_ENVIRONMENT"),
            Self::EventInstance => write!(f, "CUPTI_ACTIVITY_KIND_EVENT_INSTANCE"),
            Self::Memcpy2 => write!(f, "CUPTI_ACTIVITY_KIND_MEMCPY2"),
            Self::MetricInstance => write!(f, "CUPTI_ACTIVITY_KIND_METRIC_INSTANCE"),
            Self::InstructionExecution => write!(f, "CUPTI_ACTIVITY_KIND_INSTRUCTION_EXECUTION"),
            Self::UnifiedMemoryCounter => write!(f, "CUPTI_ACTIVITY_KIND_UNIFIED_MEMORY_COUNTER"),
            Self::Function => write!(f, "CUPTI_ACTIVITY_KIND_FUNCTION"),
            Self::Module => write!(f, "CUPTI_ACTIVITY_KIND_MODULE"),
            Self::DeviceAttribute => write!(f, "CUPTI_ACTIVITY_KIND_DEVICE_ATTRIBUTE"),
            Self::SharedAccess => write!(f, "CUPTI_ACTIVITY_KIND_SHARED_ACCESS"),
            Self::PcSampling => write!(f, "CUPTI_ACTIVITY_KIND_PC_SAMPLING"),
            Self::PcSamplingRecordInfo => write!(f, "CUPTI_ACTIVITY_KIND_PC_SAMPLING_RECORD_INFO"),
            Self::InstructionCorrelation => {
                write!(f, "CUPTI_ACTIVITY_KIND_INSTRUCTION_CORRELATION")
            }
            Self::OpenAccData => write!(f, "CUPTI_ACTIVITY_KIND_OPENACC_DATA"),
            Self::OpenAccLaunch => write!(f, "CUPTI_ACTIVITY_KIND_OPENACC_LAUNCH"),
            Self::OpenAccOther => write!(f, "CUPTI_ACTIVITY_KIND_OPENACC_OTHER"),
            Self::CudaEvent => write!(f, "CUPTI_ACTIVITY_KIND_CUDA_EVENT"),
            Self::Stream => write!(f, "CUPTI_ACTIVITY_KIND_STREAM"),
            Self::Synchronization => write!(f, "CUPTI_ACTIVITY_KIND_SYNCHRONIZATION"),
            Self::ExternalCorrelation => write!(f, "CUPTI_ACTIVITY_KIND_EXTERNAL_CORRELATION"),
            Self::NvLink => write!(f, "CUPTI_ACTIVITY_KIND_NVLINK"),
            Self::InstantaneousEvent => write!(f, "CUPTI_ACTIVITY_KIND_INSTANTANEOUS_EVENT"),
            Self::InstantaneousEventInstance => {
                write!(f, "CUPTI_ACTIVITY_KIND_INSTANTANEOUS_EVENT_INSTANCE")
            }
            Self::InstantaneousMetric => write!(f, "CUPTI_ACTIVITY_KIND_INSTANTANEOUS_METRIC"),
            Self::InstantaneousMetricInstance => {
                write!(f, "CUPTI_ACTIVITY_KIND_INSTANTANEOUS_METRIC_INSTANCE")
            }
            Self::Memory => write!(f, "CUPTI_ACTIVITY_KIND_MEMORY"),
            Self::Pcie => write!(f, "CUPTI_ACTIVITY_KIND_PCIE"),
            Self::OpenMp => write!(f, "CUPTI_ACTIVITY_KIND_OPENMP"),
            Self::InternalLaunchApi => write!(f, "CUPTI_ACTIVITY_KIND_INTERNAL_LAUNCH_API"),
            Self::Memory2 => write!(f, "CUPTI_ACTIVITY_KIND_MEMORY2"),
            Self::MemoryPool => write!(f, "CUPTI_ACTIVITY_KIND_MEMORY_POOL"),
            Self::GraphTrace => write!(f, "CUPTI_ACTIVITY_KIND_GRAPH_TRACE"),
            Self::Jit => write!(f, "CUPTI_ACTIVITY_KIND_JIT"),
            Self::DeviceGraphTrace => write!(f, "CUPTI_ACTIVITY_KIND_DEVICE_GRAPH_TRACE"),
            Self::MemDecompress => write!(f, "CUPTI_ACTIVITY_KIND_MEM_DECOMPRESS"),
            Self::ConfidentialComputeRotation => {
                write!(f, "CUPTI_ACTIVITY_KIND_CONFIDENTIAL_COMPUTE_ROTATION")
            }
            Self::GraphHostNode => write!(f, "CUPTI_ACTIVITY_KIND_GRAPH_HOST_NODE"),
            Self::ComputeEngineCtxSwitch => {
                write!(f, "CUPTI_ACTIVITY_KIND_COMPUTE_ENGINE_CTX_SWITCH")
            }
            Self::HostLaunch => write!(f, "CUPTI_ACTIVITY_KIND_HOST_LAUNCH"),
            Self::GreenContext => write!(f, "CUPTI_ACTIVITY_KIND_GREEN_CONTEXT"),
            Self::Count => write!(f, "CUPTI_ACTIVITY_KIND_COUNT"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_KIND_FORCE_INT"),
        }
    }
}

impl Display for ChannelType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_CHANNEL_TYPE_INVALID"),
            Self::Compute => write!(f, "CUPTI_CHANNEL_TYPE_COMPUTE"),
            Self::AsyncMemcpy => write!(f, "CUPTI_CHANNEL_TYPE_ASYNC_MEMCPY"),
            Self::Decompress => write!(f, "CUPTI_CHANNEL_TYPE_DECOMP"),
            Self::ForceInt => write!(f, "CUPTI_CHANNEL_TYPE_FORCE_INT"),
        }
    }
}

impl Display for ActivityMemcpyKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_UNKNOWN"),
            Self::HostToDevice => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_HTOD"),
            Self::DeviceToHost => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_DTOH"),
            Self::HostToArray => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_HTOA"),
            Self::ArrayToHost => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_ATOH"),
            Self::ArrayToArray => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_ATOA"),
            Self::ArrayToDevice => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_ATOD"),
            Self::DeviceToArray => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_DTOA"),
            Self::DeviceToDevice => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_DTOD"),
            Self::HostToHost => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_HTOH"),
            Self::PeerToPeer => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_PTOP"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_MEMCPY_KIND_FORCE_INT"),
        }
    }
}

impl Display for ActivityMemoryKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_UNKNOWN"),
            Self::Pageable => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_PAGEABLE"),
            Self::Pinned => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_PINNED"),
            Self::Device => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_DEVICE"),
            Self::Array => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_ARRAY"),
            Self::Managed => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_MANAGED"),
            Self::DeviceStatic => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_DEVICE_STATIC"),
            Self::ManagedStatic => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_MANAGED_STATIC"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_MEMORY_KIND_FORCE_INT"),
        }
    }
}

impl Display for ActivityMemoryOperationType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_INVALID"),
            Self::Allocation => write!(f, "CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_ALLOCATION"),
            Self::Release => write!(f, "CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_RELEASE"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_MEMORY_OPERATION_TYPE_FORCE_INT"),
        }
    }
}

impl Display for ActivityMemoryPoolType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_TYPE_INVALID"),
            Self::Local => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_TYPE_LOCAL"),
            Self::Imported => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_TYPE_IMPORTED"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_TYPE_FORCE_INT"),
        }
    }
}

impl Display for ActivityMemoryPoolOperationType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_INVALID"),
            Self::Created => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_CREATED"),
            Self::Destroyed => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_DESTROYED"),
            Self::Trimmed => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_TRIMMED"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_MEMORY_POOL_OPERATION_TYPE_FORCE_INT"),
        }
    }
}

impl Display for DeviceGraphLaunchMode {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_DEVICE_GRAPH_LAUNCH_MODE_INVALID"),
            Self::FireAndForget => write!(f, "CUPTI_DEVICE_GRAPH_LAUNCH_MODE_FIRE_AND_FORGET"),
            Self::Tail => write!(f, "CUPTI_DEVICE_GRAPH_LAUNCH_MODE_TAIL"),
            Self::FireAndForgetAsSibling => write!(
                f,
                "CUPTI_DEVICE_GRAPH_LAUNCH_MODE_FIRE_AND_FORGET_AS_SIBLING"
            ),
        }
    }
}

impl Display for ActivityComputeApiKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_COMPUTE_API_UNKNOWN"),
            Self::Cuda => write!(f, "CUPTI_ACTIVITY_COMPUTE_API_CUDA"),
            Self::CudaMps => write!(f, "CUPTI_ACTIVITY_COMPUTE_API_CUDA_MPS"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_COMPUTE_API_FORCE_INT"),
        }
    }
}

impl Display for ContextCigMode {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::None => write!(f, "CUPTI_CONTEXT_CIG_MODE_NONE"),
            Self::Cig => write!(f, "CUPTI_CONTEXT_CIG_MODE_CIG"),
            Self::CigFallback => write!(f, "CUPTI_CONTEXT_CIG_MODE_CIG_FALLBACK"),
            Self::ForceInt => write!(f, "CUPTI_CONTEXT_CIG_MODE_FORCE_INT"),
        }
    }
}

impl Display for ComputeEngineContextSwitchOperationType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_INVALID"),
            Self::Start => write!(f, "CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_START"),
            Self::End => write!(f, "CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_END"),
            Self::Count => write!(f, "CUPTI_COMPUTE_ENGINE_CTX_SWITCH_OPERATION_COUNT"),
        }
    }
}

impl Display for ActivitySynchronizationType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_UNKNOWN"),
            Self::EventSynchronize => {
                write!(f, "CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_EVENT_SYNCHRONIZE")
            }
            Self::StreamWaitEvent => {
                write!(f, "CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_STREAM_WAIT_EVENT")
            }
            Self::StreamSynchronize => {
                write!(f, "CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_STREAM_SYNCHRONIZE")
            }
            Self::ContextSynchronize => {
                write!(f, "CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_CONTEXT_SYNCHRONIZE")
            }
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_SYNCHRONIZATION_TYPE_FORCE_INT"),
        }
    }
}

impl Display for ActivityStreamFlag {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_STREAM_CREATE_FLAG_UNKNOWN"),
            Self::Default => write!(f, "CUPTI_ACTIVITY_STREAM_CREATE_FLAG_DEFAULT"),
            Self::NonBlocking => write!(f, "CUPTI_ACTIVITY_STREAM_CREATE_FLAG_NON_BLOCKING"),
            Self::Null => write!(f, "CUPTI_ACTIVITY_STREAM_CREATE_FLAG_NULL"),
            Self::Mask => write!(f, "CUPTI_ACTIVITY_STREAM_CREATE_MASK"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_STREAM_CREATE_FLAG_FORCE_INT"),
        }
    }
}

impl Display for ActivityPartitionedGlobalCacheConfig {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_UNKNOWN"),
            Self::NotSupported => write!(
                f,
                "CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_NOT_SUPPORTED"
            ),
            Self::Off => write!(f, "CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_OFF"),
            Self::On => write!(f, "CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_ON"),
            Self::ForceInt => write!(
                f,
                "CUPTI_ACTIVITY_PARTITIONED_GLOBAL_CACHE_CONFIG_FORCE_INT"
            ),
        }
    }
}

impl Display for ActivityLaunchType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Regular => write!(f, "CUPTI_ACTIVITY_LAUNCH_TYPE_REGULAR"),
            Self::CooperativeSingleDevice => {
                write!(f, "CUPTI_ACTIVITY_LAUNCH_TYPE_COOPERATIVE_SINGLE_DEVICE")
            }
            Self::CooperativeMultiDevice => {
                write!(f, "CUPTI_ACTIVITY_LAUNCH_TYPE_COOPERATIVE_MULTI_DEVICE")
            }
            Self::CblCommandlist => write!(f, "CUPTI_ACTIVITY_LAUNCH_TYPE_CBL_COMMANDLIST"),
        }
    }
}

impl Display for FunctionSharedMemoryLimitConfig {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Default => write!(f, "CUPTI_FUNC_SHMEM_LIMIT_DEFAULT"),
            Self::OptIn => write!(f, "CUPTI_FUNC_SHMEM_LIMIT_OPTIN"),
            Self::ForceInt => write!(f, "CUPTI_FUNC_SHMEM_LIMIT_FORCE_INT"),
        }
    }
}

impl Display for ActivityObjectKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_OBJECT_UNKNOWN"),
            Self::Process => write!(f, "CUPTI_ACTIVITY_OBJECT_PROCESS"),
            Self::Thread => write!(f, "CUPTI_ACTIVITY_OBJECT_THREAD"),
            Self::Device => write!(f, "CUPTI_ACTIVITY_OBJECT_DEVICE"),
            Self::Context => write!(f, "CUPTI_ACTIVITY_OBJECT_CONTEXT"),
            Self::Stream => write!(f, "CUPTI_ACTIVITY_OBJECT_STREAM"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_OBJECT_FORCE_INT"),
        }
    }
}

impl Display for ActivityOverheadKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_OVERHEAD_UNKNOWN"),
            Self::DriverCompiler => write!(f, "CUPTI_ACTIVITY_OVERHEAD_DRIVER_COMPILER"),
            Self::BufferFlush => write!(f, "CUPTI_ACTIVITY_OVERHEAD_CUPTI_BUFFER_FLUSH"),
            Self::Instrumentation => write!(f, "CUPTI_ACTIVITY_OVERHEAD_CUPTI_INSTRUMENTATION"),
            Self::Resource => write!(f, "CUPTI_ACTIVITY_OVERHEAD_CUPTI_RESOURCE"),
            Self::RuntimeTriggeredModuleLoading => write!(
                f,
                "CUPTI_ACTIVITY_OVERHEAD_RUNTIME_TRIGGERED_MODULE_LOADING"
            ),
            Self::LazyFunctionLoading => write!(f, "CUPTI_ACTIVITY_OVERHEAD_LAZY_FUNCTION_LOADING"),
            Self::CommandBufferFull => write!(f, "CUPTI_ACTIVITY_OVERHEAD_COMMAND_BUFFER_FULL"),
            Self::ActivityBufferRequest => {
                write!(f, "CUPTI_ACTIVITY_OVERHEAD_ACTIVITY_BUFFER_REQUEST")
            }
            Self::UvmActivityInit => write!(f, "CUPTI_ACTIVITY_OVERHEAD_UVM_ACTIVITY_INIT"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_OVERHEAD_FORCE_INT"),
        }
    }
}

impl Display for DeviceVirtualizationMode {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::None => write!(f, "CUPTI_DEVICE_VIRTUALIZATION_MODE_NONE"),
            Self::PassThrough => write!(f, "CUPTI_DEVICE_VIRTUALIZATION_MODE_PASS_THROUGH"),
            Self::VirtualGpu => write!(f, "CUPTI_DEVICE_VIRTUALIZATION_MODE_VIRTUAL_GPU"),
            Self::ForceInt => write!(f, "CUPTI_DEVICE_VIRTUALIZATION_MODE_FORCE_INT"),
        }
    }
}

impl Display for ExternalCorrelationKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_INVALID"),
            Self::Unknown => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_UNKNOWN"),
            Self::OpenAcc => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_OPENACC"),
            Self::Custom0 => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_CUSTOM0"),
            Self::Custom1 => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_CUSTOM1"),
            Self::Custom2 => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_CUSTOM2"),
            Self::Size => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_SIZE"),
            Self::ForceInt => write!(f, "CUPTI_EXTERNAL_CORRELATION_KIND_FORCE_INT"),
        }
    }
}

impl Display for ActivityAttribute {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::DeviceBufferSize => write!(f, "CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_SIZE"),
            Self::DeviceBufferSizeCdp => write!(f, "CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_SIZE_CDP"),
            Self::DeviceBufferPoolLimit => {
                write!(f, "CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_POOL_LIMIT")
            }
            Self::ProfilingSemaphorePoolSize => {
                write!(f, "CUPTI_ACTIVITY_ATTR_PROFILING_SEMAPHORE_POOL_SIZE")
            }
            Self::ProfilingSemaphorePoolLimit => {
                write!(f, "CUPTI_ACTIVITY_ATTR_PROFILING_SEMAPHORE_POOL_LIMIT")
            }
            Self::ZeroedOutActivityBuffer => {
                write!(f, "CUPTI_ACTIVITY_ATTR_ZEROED_OUT_ACTIVITY_BUFFER")
            }
            Self::DeviceBufferPreAllocateValue => {
                write!(f, "CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_PRE_ALLOCATE_VALUE")
            }
            Self::ProfilingSemaphorePreAllocateValue => write!(
                f,
                "CUPTI_ACTIVITY_ATTR_PROFILING_SEMAPHORE_PRE_ALLOCATE_VALUE"
            ),
            Self::MemAllocationTypeHostPinned => {
                write!(f, "CUPTI_ACTIVITY_ATTR_MEM_ALLOCATION_TYPE_HOST_PINNED")
            }
            Self::PerThreadActivityBuffer => {
                write!(f, "CUPTI_ACTIVITY_ATTR_PER_THREAD_ACTIVITY_BUFFER")
            }
            Self::DeviceBufferSizeDeviceGraphs => {
                write!(f, "CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_SIZE_DEVICE_GRAPHS")
            }
            Self::UserDefinedRecords => write!(f, "CUPTI_ACTIVITY_ATTR_USER_DEFINED_RECORDS"),
            Self::MultipleSubscriberState => {
                write!(f, "CUPTI_ACTIVITY_ATTR_MULTIPLE_SUBSCRIBER_STATE")
            }
            Self::EnableHes => write!(f, "CUPTI_ACTIVITY_ATTR_ENABLE_HES"),
            Self::EnableAllocationSourceTracking => {
                write!(f, "CUPTI_ACTIVITY_ATTR_ENABLE_ALLOCATION_SOURCE_TRACKING")
            }
            Self::EnableKernelLatencyTimestamps => {
                write!(f, "CUPTI_ACTIVITY_ATTR_ENABLE_KERNEL_LATENCY_TIMESTAMPS")
            }
            Self::EnableAllSyncRecords => write!(f, "CUPTI_ACTIVITY_ATTR_ENABLE_ALL_SYNC_RECORDS"),
            Self::EnableCudaEventDeviceTimestamps => {
                write!(f, "CUPTI_ACTIVITY_ATTR_ENABLE_CUDA_EVENT_DEVICE_TIMESTAMPS")
            }
            Self::EnableKernelLaunchAttributes => {
                write!(f, "CUPTI_ACTIVITY_ATTR_ENABLE_KERNEL_LAUNCH_ATTRIBUTES")
            }
            Self::EnableDeviceGraphTrace => {
                write!(f, "CUPTI_ACTIVITY_ATTR_ENABLE_DEVICE_GRAPH_TRACE")
            }
            Self::EnableMultiSubscriberGraphLevelTrace => write!(
                f,
                "CUPTI_ACTIVITY_ATTR_ENABLE_MULTI_SUBSCRIBER_GRAPH_LEVEL_TRACE"
            ),
            Self::ThreadIdType => write!(f, "CUPTI_ACTIVITY_ATTR_THREAD_ID_TYPE"),
            Self::TimestampCallback => write!(f, "CUPTI_ACTIVITY_ATTR_TIMESTAMP_CALLBACK"),
            Self::CigMode => write!(f, "CUPTI_ACTIVITY_ATTR_CIG_MODE"),
            Self::DeviceBufferForceInt => write!(f, "CUPTI_ACTIVITY_ATTR_DEVICE_BUFFER_FORCE_INT"),
        }
    }
}

impl Display for ActivityPCSamplingPeriod {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_INVALID"),
            Self::Min => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_MIN"),
            Self::Low => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_LOW"),
            Self::Mid => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_MID"),
            Self::High => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_HIGH"),
            Self::Max => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_MAX"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_FORCE_INT"),
        }
    }
}

impl Display for ActivityEnvironmentKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_ENVIRONMENT_UNKNOWN"),
            Self::Speed => write!(f, "CUPTI_ACTIVITY_ENVIRONMENT_SPEED"),
            Self::Temperature => write!(f, "CUPTI_ACTIVITY_ENVIRONMENT_TEMPERATURE"),
            Self::Power => write!(f, "CUPTI_ACTIVITY_ENVIRONMENT_POWER"),
            Self::Cooling => write!(f, "CUPTI_ACTIVITY_ENVIRONMENT_COOLING"),
            Self::Count => write!(f, "CUPTI_ACTIVITY_ENVIRONMENT_COUNT"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_ENVIRONMENT_KIND_FORCE_INT"),
        }
    }
}

impl Display for ActivityPreemptionKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_PREEMPTION_KIND_UNKNOWN"),
            Self::Save => write!(f, "CUPTI_ACTIVITY_PREEMPTION_KIND_SAVE"),
            Self::Restore => write!(f, "CUPTI_ACTIVITY_PREEMPTION_KIND_RESTORE"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_PREEMPTION_KIND_FORCE_INT"),
        }
    }
}

impl Display for ActivityPCSamplingStallReason {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_INVALID"),
            Self::None => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_NONE"),
            Self::InstructionFetch => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_INST_FETCH"),
            Self::ExecutionDependency => {
                write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_EXEC_DEPENDENCY")
            }
            Self::MemoryDependency => {
                write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_MEMORY_DEPENDENCY")
            }
            Self::Texture => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_TEXTURE"),
            Self::Sync => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_SYNC"),
            Self::ConstantMemoryDependency => write!(
                f,
                "CUPTI_ACTIVITY_PC_SAMPLING_STALL_CONSTANT_MEMORY_DEPENDENCY"
            ),
            Self::PipeBusy => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_PIPE_BUSY"),
            Self::MemoryThrottle => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_MEMORY_THROTTLE"),
            Self::NotSelected => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_NOT_SELECTED"),
            Self::Other => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_OTHER"),
            Self::Sleeping => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_SLEEPING"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_PC_SAMPLING_STALL_FORCE_INT"),
        }
    }
}

impl Display for ActivityUnifiedMemoryCounterScope {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_UNKNOWN"),
            Self::ProcessSingleDevice => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_PROCESS_SINGLE_DEVICE"
            ),
            Self::ProcessAllDevices => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_PROCESS_ALL_DEVICES"
            ),
            Self::Count => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_COUNT"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_FORCE_INT"),
        }
    }
}

impl Display for ActivityUnifiedMemoryCounterKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_UNKNOWN"),
            Self::BytesTransferHostToDevice => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_BYTES_TRANSFER_HTOD"
            ),
            Self::BytesTransferDeviceToHost => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_BYTES_TRANSFER_DTOH"
            ),
            Self::CpuPageFaultCount => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_CPU_PAGE_FAULT_COUNT"
            ),
            Self::GpuPageFault => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_GPU_PAGE_FAULT"
            ),
            Self::Thrashing => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_THRASHING"),
            Self::Throttling => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_THROTTLING"),
            Self::RemoteMap => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_REMOTE_MAP"),
            Self::BytesTransferDeviceToDevice => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_BYTES_TRANSFER_DTOD"
            ),
            Self::Count => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_COUNT"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_FORCE_INT"),
        }
    }
}

impl Display for ActivityUnifiedMemoryAccessType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_UNKNOWN"),
            Self::Read => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_READ"),
            Self::Write => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_WRITE"),
            Self::Atomic => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_ATOMIC"),
            Self::Prefetch => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_ACCESS_TYPE_PREFETCH"),
        }
    }
}

impl Display for ActivityUnifiedMemoryMigrationCause {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_UNKNOWN"),
            Self::User => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_USER"),
            Self::Coherence => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_COHERENCE"),
            Self::Prefetch => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_PREFETCH"),
            Self::Eviction => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_EVICTION"),
            Self::AccessCounters => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_MIGRATION_CAUSE_ACCESS_COUNTERS"
            ),
        }
    }
}

impl Display for ActivityUnifiedMemoryRemoteMapCause {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_UNKNOWN"),
            Self::Coherence => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_COHERENCE"
            ),
            Self::Thrashing => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_THRASHING"
            ),
            Self::Policy => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_POLICY"),
            Self::OutOfMemory => write!(
                f,
                "CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_OUT_OF_MEMORY"
            ),
            Self::Eviction => write!(f, "CUPTI_ACTIVITY_UNIFIED_MEMORY_REMOTE_MAP_CAUSE_EVICTION"),
        }
    }
}

impl Display for ActivityInstructionClass {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_UNKNOWN"),
            Self::Float32 => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_FP_32"),
            Self::Float64 => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_FP_64"),
            Self::Integer => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_INTEGER"),
            Self::BitConversion => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_BIT_CONVERSION"),
            Self::ControlFlow => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_CONTROL_FLOW"),
            Self::Global => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_GLOBAL"),
            Self::Shared => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_SHARED"),
            Self::Local => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_LOCAL"),
            Self::Generic => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_GENERIC"),
            Self::Surface => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_SURFACE"),
            Self::Constant => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_CONSTANT"),
            Self::Texture => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_TEXTURE"),
            Self::GlobalAtomic => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_GLOBAL_ATOMIC"),
            Self::SharedAtomic => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_SHARED_ATOMIC"),
            Self::SurfaceAtomic => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_SURFACE_ATOMIC"),
            Self::InterThreadCommunication => write!(
                f,
                "CUPTI_ACTIVITY_INSTRUCTION_CLASS_INTER_THREAD_COMMUNICATION"
            ),
            Self::Barrier => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_BARRIER"),
            Self::Miscellaneous => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_MISCELLANEOUS"),
            Self::Float16 => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_FP_16"),
            Self::Uniform => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_UNIFORM"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_INSTRUCTION_CLASS_KIND_FORCE_INT"),
        }
    }
}

impl Display for ConfidentialComputeRotationEventType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_CONFIDENTIAL_COMPUTE_INVALID_ROTATION_EVENT"),
            Self::ChannelBlocked => {
                write!(f, "CUPTI_CONFIDENTIAL_COMPUTE_KEY_ROTATION_CHANNEL_BLOCKED")
            }
            Self::ChannelDrained => {
                write!(f, "CUPTI_CONFIDENTIAL_COMPUTE_KEY_ROTATION_CHANNEL_DRAINED")
            }
            Self::ChannelUnblocked => write!(
                f,
                "CUPTI_CONFIDENTIAL_COMPUTE_KEY_ROTATION_CHANNEL_UNBLOCKED"
            ),
            Self::ForceInt => write!(f, "CUPTI_CONFIDENTIAL_COMPUTE_EVENT_TYPE_FORCE_INT"),
        }
    }
}

impl Display for DeviceType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_DEV_TYPE_INVALID"),
            Self::Gpu => write!(f, "CUPTI_DEV_TYPE_GPU"),
            Self::Npu => write!(f, "CUPTI_DEV_TYPE_NPU"),
            Self::ForceInt => write!(f, "CUPTI_DEV_TYPE_FORCE_INT"),
        }
    }
}

impl Display for PcieDeviceType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Gpu => write!(f, "CUPTI_PCIE_DEVICE_TYPE_GPU"),
            Self::Bridge => write!(f, "CUPTI_PCIE_DEVICE_TYPE_BRIDGE"),
            Self::ForceInt => write!(f, "CUPTI_PCIE_DEVICE_TYPE_FORCE_INT"),
        }
    }
}

impl Display for OpenAccEventKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_OPENACC_EVENT_KIND_INVALID"),
            Self::DeviceInit => write!(f, "CUPTI_OPENACC_EVENT_KIND_DEVICE_INIT"),
            Self::DeviceShutdown => write!(f, "CUPTI_OPENACC_EVENT_KIND_DEVICE_SHUTDOWN"),
            Self::RuntimeShutdown => write!(f, "CUPTI_OPENACC_EVENT_KIND_RUNTIME_SHUTDOWN"),
            Self::EnqueueLaunch => write!(f, "CUPTI_OPENACC_EVENT_KIND_ENQUEUE_LAUNCH"),
            Self::EnqueueUpload => write!(f, "CUPTI_OPENACC_EVENT_KIND_ENQUEUE_UPLOAD"),
            Self::EnqueueDownload => write!(f, "CUPTI_OPENACC_EVENT_KIND_ENQUEUE_DOWNLOAD"),
            Self::Wait => write!(f, "CUPTI_OPENACC_EVENT_KIND_WAIT"),
            Self::ImplicitWait => write!(f, "CUPTI_OPENACC_EVENT_KIND_IMPLICIT_WAIT"),
            Self::ComputeConstruct => write!(f, "CUPTI_OPENACC_EVENT_KIND_COMPUTE_CONSTRUCT"),
            Self::Update => write!(f, "CUPTI_OPENACC_EVENT_KIND_UPDATE"),
            Self::EnterData => write!(f, "CUPTI_OPENACC_EVENT_KIND_ENTER_DATA"),
            Self::ExitData => write!(f, "CUPTI_OPENACC_EVENT_KIND_EXIT_DATA"),
            Self::Create => write!(f, "CUPTI_OPENACC_EVENT_KIND_CREATE"),
            Self::Delete => write!(f, "CUPTI_OPENACC_EVENT_KIND_DELETE"),
            Self::Alloc => write!(f, "CUPTI_OPENACC_EVENT_KIND_ALLOC"),
            Self::Free => write!(f, "CUPTI_OPENACC_EVENT_KIND_FREE"),
            Self::ForceInt => write!(f, "CUPTI_OPENACC_EVENT_KIND_FORCE_INT"),
        }
    }
}

impl Display for OpenAccConstructKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_UNKNOWN"),
            Self::Parallel => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_PARALLEL"),
            Self::Kernels => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_KERNELS"),
            Self::Loop => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_LOOP"),
            Self::Data => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_DATA"),
            Self::EnterData => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_ENTER_DATA"),
            Self::ExitData => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_EXIT_DATA"),
            Self::HostData => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_HOST_DATA"),
            Self::Atomic => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_ATOMIC"),
            Self::Declare => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_DECLARE"),
            Self::Init => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_INIT"),
            Self::Shutdown => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_SHUTDOWN"),
            Self::Set => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_SET"),
            Self::Update => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_UPDATE"),
            Self::Routine => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_ROUTINE"),
            Self::Wait => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_WAIT"),
            Self::RuntimeApi => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_RUNTIME_API"),
            Self::ForceInt => write!(f, "CUPTI_OPENACC_CONSTRUCT_KIND_FORCE_INT"),
        }
    }
}

impl Display for OpenMpEventKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_OPENMP_EVENT_KIND_INVALID"),
            Self::Parallel => write!(f, "CUPTI_OPENMP_EVENT_KIND_PARALLEL"),
            Self::Task => write!(f, "CUPTI_OPENMP_EVENT_KIND_TASK"),
            Self::Thread => write!(f, "CUPTI_OPENMP_EVENT_KIND_THREAD"),
            Self::Idle => write!(f, "CUPTI_OPENMP_EVENT_KIND_IDLE"),
            Self::WaitBarrier => write!(f, "CUPTI_OPENMP_EVENT_KIND_WAIT_BARRIER"),
            Self::WaitTaskwait => write!(f, "CUPTI_OPENMP_EVENT_KIND_WAIT_TASKWAIT"),
            Self::ForceInt => write!(f, "CUPTI_OPENMP_EVENT_KIND_FORCE_INT"),
        }
    }
}

impl Display for ActivityJitEntryType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_JIT_ENTRY_INVALID"),
            Self::PtxToCubin => write!(f, "CUPTI_ACTIVITY_JIT_ENTRY_PTX_TO_CUBIN"),
            Self::NvvmIrToPtx => write!(f, "CUPTI_ACTIVITY_JIT_ENTRY_NVVM_IR_TO_PTX"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_JIT_ENTRY_TYPE_FORCE_INT"),
        }
    }
}

impl Display for ActivityJitOperationType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Invalid => write!(f, "CUPTI_ACTIVITY_JIT_OPERATION_INVALID"),
            Self::CacheLoad => write!(f, "CUPTI_ACTIVITY_JIT_OPERATION_CACHE_LOAD"),
            Self::CacheStore => write!(f, "CUPTI_ACTIVITY_JIT_OPERATION_CACHE_STORE"),
            Self::Compile => write!(f, "CUPTI_ACTIVITY_JIT_OPERATION_COMPILE"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_JIT_OPERATION_TYPE_FORCE_INT"),
        }
    }
}

impl Display for ActivityThreadIdType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Default => write!(f, "CUPTI_ACTIVITY_THREAD_ID_TYPE_DEFAULT"),
            Self::System => write!(f, "CUPTI_ACTIVITY_THREAD_ID_TYPE_SYSTEM"),
            Self::Size => write!(f, "CUPTI_ACTIVITY_THREAD_ID_TYPE_SIZE"),
            Self::ForceInt => write!(f, "CUPTI_ACTIVITY_THREAD_ID_TYPE_FORCE_INT"),
        }
    }
}

impl Display for MetricCategory {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Memory => write!(f, "CUPTI_METRIC_CATEGORY_MEMORY"),
            Self::Instruction => write!(f, "CUPTI_METRIC_CATEGORY_INSTRUCTION"),
            Self::Multiprocessor => write!(f, "CUPTI_METRIC_CATEGORY_MULTIPROCESSOR"),
            Self::Cache => write!(f, "CUPTI_METRIC_CATEGORY_CACHE"),
            Self::Texture => write!(f, "CUPTI_METRIC_CATEGORY_TEXTURE"),
            Self::Nvlink => write!(f, "CUPTI_METRIC_CATEGORY_NVLINK"),
            Self::Pcie => write!(f, "CUPTI_METRIC_CATEGORY_PCIE"),
            Self::ForceInt => write!(f, "CUPTI_METRIC_CATEGORY_FORCE_INT"),
        }
    }
}

impl Display for MetricEvaluationMode {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::PerInstance => write!(f, "CUPTI_METRIC_EVALUATION_MODE_PER_INSTANCE"),
            Self::Aggregate => write!(f, "CUPTI_METRIC_EVALUATION_MODE_AGGREGATE"),
            Self::ForceInt => write!(f, "CUPTI_METRIC_EVALUATION_MODE_FORCE_INT"),
        }
    }
}

impl Display for MetricValueKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Double => write!(f, "CUPTI_METRIC_VALUE_KIND_DOUBLE"),
            Self::Uint64 => write!(f, "CUPTI_METRIC_VALUE_KIND_UINT64"),
            Self::Percent => write!(f, "CUPTI_METRIC_VALUE_KIND_PERCENT"),
            Self::Throughput => write!(f, "CUPTI_METRIC_VALUE_KIND_THROUGHPUT"),
            Self::Int64 => write!(f, "CUPTI_METRIC_VALUE_KIND_INT64"),
            Self::UtilizationLevel => write!(f, "CUPTI_METRIC_VALUE_KIND_UTILIZATION_LEVEL"),
            Self::NvtxExtendedPayload => write!(f, "CUPTI_METRIC_VALUE_KIND_NVTX_EXTENDED_PAYLOAD"),
            Self::ForceInt => write!(f, "CUPTI_METRIC_VALUE_KIND_FORCE_INT"),
        }
    }
}

impl Display for MetricValueUtilizationLevel {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Idle => write!(f, "CUPTI_METRIC_VALUE_UTILIZATION_IDLE"),
            Self::Low => write!(f, "CUPTI_METRIC_VALUE_UTILIZATION_LOW"),
            Self::Mid => write!(f, "CUPTI_METRIC_VALUE_UTILIZATION_MID"),
            Self::High => write!(f, "CUPTI_METRIC_VALUE_UTILIZATION_HIGH"),
            Self::Max => write!(f, "CUPTI_METRIC_VALUE_UTILIZATION_MAX"),
            Self::ForceInt => write!(f, "CUPTI_METRIC_VALUE_UTILIZATION_FORCE_INT"),
        }
    }
}

impl Display for MetricAttribute {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Name => write!(f, "CUPTI_METRIC_ATTR_NAME"),
            Self::ShortDescription => write!(f, "CUPTI_METRIC_ATTR_SHORT_DESCRIPTION"),
            Self::LongDescription => write!(f, "CUPTI_METRIC_ATTR_LONG_DESCRIPTION"),
            Self::Category => write!(f, "CUPTI_METRIC_ATTR_CATEGORY"),
            Self::ValueKind => write!(f, "CUPTI_METRIC_ATTR_VALUE_KIND"),
            Self::EvaluationMode => write!(f, "CUPTI_METRIC_ATTR_EVALUATION_MODE"),
            Self::ForceInt => write!(f, "CUPTI_METRIC_ATTR_FORCE_INT"),
        }
    }
}

impl Display for MetricPropertyDeviceClass {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Tesla => write!(f, "CUPTI_METRIC_PROPERTY_DEVICE_CLASS_TESLA"),
            Self::Quadro => write!(f, "CUPTI_METRIC_PROPERTY_DEVICE_CLASS_QUADRO"),
            Self::Geforce => write!(f, "CUPTI_METRIC_PROPERTY_DEVICE_CLASS_GEFORCE"),
            Self::Tegra => write!(f, "CUPTI_METRIC_PROPERTY_DEVICE_CLASS_TEGRA"),
        }
    }
}

impl Display for MetricPropertyId {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::MultiprocessorCount => write!(f, "CUPTI_METRIC_PROPERTY_MULTIPROCESSOR_COUNT"),
            Self::WarpsPerMultiprocessor => {
                write!(f, "CUPTI_METRIC_PROPERTY_WARPS_PER_MULTIPROCESSOR")
            }
            Self::KernelGpuTime => write!(f, "CUPTI_METRIC_PROPERTY_KERNEL_GPU_TIME"),
            Self::ClockRate => write!(f, "CUPTI_METRIC_PROPERTY_CLOCK_RATE"),
            Self::FrameBufferCount => write!(f, "CUPTI_METRIC_PROPERTY_FRAME_BUFFER_COUNT"),
            Self::GlobalMemoryBandwidth => {
                write!(f, "CUPTI_METRIC_PROPERTY_GLOBAL_MEMORY_BANDWIDTH")
            }
            Self::PcieLinkRate => write!(f, "CUPTI_METRIC_PROPERTY_PCIE_LINK_RATE"),
            Self::PcieLinkWidth => write!(f, "CUPTI_METRIC_PROPERTY_PCIE_LINK_WIDTH"),
            Self::PcieGen => write!(f, "CUPTI_METRIC_PROPERTY_PCIE_GEN"),
            Self::DeviceClass => write!(f, "CUPTI_METRIC_PROPERTY_DEVICE_CLASS"),
            Self::FlopSpPerCycle => write!(f, "CUPTI_METRIC_PROPERTY_FLOP_SP_PER_CYCLE"),
            Self::FlopDpPerCycle => write!(f, "CUPTI_METRIC_PROPERTY_FLOP_DP_PER_CYCLE"),
            Self::L2Units => write!(f, "CUPTI_METRIC_PROPERTY_L2_UNITS"),
            Self::EccEnabled => write!(f, "CUPTI_METRIC_PROPERTY_ECC_ENABLED"),
            Self::FlopHpPerCycle => write!(f, "CUPTI_METRIC_PROPERTY_FLOP_HP_PER_CYCLE"),
            Self::GpuCpuNvlinkBandwidth => {
                write!(f, "CUPTI_METRIC_PROPERTY_GPU_CPU_NVLINK_BANDWIDTH")
            }
        }
    }
}
impl Display for DeviceAttributeValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::U32(value) => write!(f, "U32({value})"),
            Self::DeviceClass(value) => write!(f, "DeviceClass({value})"),
        }
    }
}

impl Display for EventDomainAttributeValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Name(value) => write!(f, "Name({value})"),
            Self::U32(value) => write!(f, "U32({value})"),
            Self::CollectionMethod(value) => write!(f, "CollectionMethod({value})"),
        }
    }
}

impl Display for EventGroupAttributeValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::EventDomainId(value) => write!(f, "EventDomainId({})", value.get()),
            Self::ProfileAllDomainInstances(value) => {
                write!(f, "ProfileAllDomainInstances({value})")
            }
            Self::NumEvents(value) => write!(f, "NumEvents({value})"),
            Self::Events(events) => {
                write!(f, "Events([")?;
                for (index, event) in events.iter().enumerate() {
                    if index != 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}", event.get())?;
                }
                write!(f, "])")
            }
            Self::InstanceCount(value) => write!(f, "InstanceCount({value})"),
            Self::ProfilingScope(value) => write!(f, "ProfilingScope({value})"),
        }
    }
}

impl Display for EventGroupAttributeSetting {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::ProfileAllDomainInstances(value) => {
                write!(f, "ProfileAllDomainInstances({value})")
            }
        }
    }
}

impl Display for EventAttributeValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Name(value) => write!(f, "Name({value})"),
            Self::ShortDescription(value) => write!(f, "ShortDescription({value})"),
            Self::LongDescription(value) => write!(f, "LongDescription({value})"),
            Self::Category(value) => write!(f, "Category({value})"),
            Self::ProfilingScope(value) => write!(f, "ProfilingScope({value})"),
        }
    }
}

impl Display for ActivityFlushFlag {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Default => write!(f, "CUPTI_ACTIVITY_FLAG_NONE"),
            Self::Forced => write!(f, "CUPTI_ACTIVITY_FLAG_FLUSH_FORCED"),
        }
    }
}

impl Display for MultipleSubscriberState {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Disabled => write!(f, "Disabled"),
            Self::Enabled => write!(f, "Enabled"),
            Self::Unset => write!(f, "Unset"),
            Self::Unknown(value) => write!(f, "Unknown({value})"),
        }
    }
}

impl Display for ActivityAttributeValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Bytes(value) => write!(f, "Bytes({value})"),
            Self::Count(value) => write!(f, "Count({value})"),
            Self::Enabled(value) => write!(f, "Enabled({value})"),
            Self::MultipleSubscriberState(value) => write!(f, "MultipleSubscriberState({value})"),
            Self::ThreadIdType(value) => write!(f, "ThreadIdType({value})"),
        }
    }
}

impl Display for ActivityAttributeSetting {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Bytes(value) => write!(f, "Bytes({value})"),
            Self::Count(value) => write!(f, "Count({value})"),
            Self::Enabled(value) => write!(f, "Enabled({value})"),
            Self::ThreadIdType(value) => write!(f, "ThreadIdType({value})"),
        }
    }
}

impl Display for MetricValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Double(value) => write!(f, "Double({value})"),
            Self::Uint64(value) => write!(f, "Uint64({value})"),
            Self::Percent(value) => write!(f, "Percent({value})"),
            Self::Throughput(value) => write!(f, "Throughput({value})"),
            Self::Int64(value) => write!(f, "Int64({value})"),
            Self::UtilizationLevel(value) => write!(f, "UtilizationLevel({value})"),
            Self::NvtxExtendedPayload(value) => write!(f, "NvtxExtendedPayload({value})"),
        }
    }
}

impl Display for MetricAttributeValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Name(value) => write!(f, "Name({value})"),
            Self::ShortDescription(value) => write!(f, "ShortDescription({value})"),
            Self::LongDescription(value) => write!(f, "LongDescription({value})"),
            Self::Category(value) => write!(f, "Category({value})"),
            Self::ValueKind(value) => write!(f, "ValueKind({value})"),
            Self::EvaluationMode(value) => write!(f, "EvaluationMode({value})"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn activity_config_all_fields_uses_null_field_selection() {
        let mut config = ActivityConfig::all_fields();
        let raw = config.as_raw_mut();

        assert_eq!(
            raw.structSize,
            size_of::<sys::CUpti_ActivityConfig>() as u64
        );
        assert_eq!(
            raw.fieldSelection.structSize,
            size_of::<sys::CUpti_ActivityFieldSelection>() as u64
        );
        assert_eq!(raw.fieldSelection.numFields, 0);
        assert!(raw.fieldSelection.pFieldIds.is_null());
    }

    #[test]
    fn activity_config_specific_fields_exposes_stable_raw_slice() {
        let mut config = ActivityConfig::create([
            ActivityKernelField::CacheConfigRequested,
            ActivityKernelField::RegistersPerThread,
            ActivityKernelField::Start,
        ]);
        let raw = config.as_raw_mut();

        assert_eq!(raw.fieldSelection.numFields, 3);
        assert!(!raw.fieldSelection.pFieldIds.is_null());

        let fields = unsafe {
            std::slice::from_raw_parts(
                raw.fieldSelection.pFieldIds,
                raw.fieldSelection.numFields as usize,
            )
        };
        assert_eq!(fields, &[1, 4, 7]);
    }

    #[test]
    fn wrapped_enums_display_cupti_names() {
        assert_eq!(
            ActivityKind::Memcpy.to_string(),
            "CUPTI_ACTIVITY_KIND_MEMCPY"
        );
        assert_eq!(ActivityKernelField::Start.to_string(), "KERNEL_FIELD_START");
        assert_eq!(ActivityDeviceField::Uuid.to_string(), "DEVICE_FIELD_UUID");
    }

    #[test]
    fn activity_field_enums_round_trip_raw_values() {
        let field =
            ActivityApiField::from(sys::CUpti_ActivityApiFieldIds::API_FIELD_CORRELATION_ID);

        assert_eq!(field, ActivityApiField::CorrelationId);
        assert_eq!(
            sys::CUpti_ActivityApiFieldIds::from(field),
            sys::CUpti_ActivityApiFieldIds::API_FIELD_CORRELATION_ID
        );
        assert_eq!(ActivityFieldId::from(field).get(), 6);
    }

    #[test]
    fn activity_pc_sampling_config_sets_struct_size_and_period() {
        let raw = ActivityPCSamplingConfig::create(ActivityPCSamplingPeriod::Low).to_raw();

        assert_eq!(
            raw.size,
            size_of::<sys::CUpti_ActivityPCSamplingConfig>() as u32
        );
        assert_eq!(
            raw.samplingPeriod,
            sys::CUpti_ActivityPCSamplingPeriod::CUPTI_ACTIVITY_PC_SAMPLING_PERIOD_LOW
        );
        assert_eq!(raw.samplingPeriod2, 0);
    }

    #[test]
    #[allow(deprecated)]
    fn unified_memory_counter_config_converts_bool_and_defaults_scope() {
        let raw = ActivityUnifiedMemoryCounterConfig::create(
            ActivityUnifiedMemoryCounterKind::BytesTransferHostToDevice,
            true,
        )
        .to_raw();

        assert_eq!(
            raw.scope,
            sys::CUpti_ActivityUnifiedMemoryCounterScope::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_SCOPE_PROCESS_ALL_DEVICES
        );
        assert_eq!(
            raw.kind,
            sys::CUpti_ActivityUnifiedMemoryCounterKind::CUPTI_ACTIVITY_UNIFIED_MEMORY_COUNTER_KIND_BYTES_TRANSFER_HTOD
        );
        assert_eq!(raw.deviceId, 0);
        assert_eq!(raw.enable, 1);
    }

    #[test]
    fn id_newtypes_round_trip_raw_values() {
        let context = ContextId::from(11);
        let device = DeviceId::from(13);
        let graph = GraphId::from(15);
        let graph_exec = GraphExecId::from(16);
        let graph_node = GraphNodeId::from(19);
        let stream = StreamId::from(21u64);
        let external_correlation = ExternalCorrelationId::from(25);
        let event = EventId::from(17);
        let domain = EventDomainId::from(23);
        let metric = MetricId::from(31);
        let callback = CallbackId::from(37);

        assert_eq!(context.get(), 11);
        assert_eq!(device.get(), 13);
        assert_eq!(graph.get(), 15);
        assert_eq!(graph_exec.get(), 16);
        assert_eq!(graph_node.get(), 19);
        assert_eq!(stream.get(), 21);
        assert_eq!(external_correlation.get(), 25);
        assert_eq!(event.get(), 17);
        assert_eq!(domain.get(), 23);
        assert_eq!(metric.get(), 31);
        assert_eq!(callback.get(), 37);
        assert_eq!(u32::from(context), 11);
        assert_eq!(u32::from(device), 13);
        assert_eq!(u32::from(graph), 15);
        assert_eq!(u32::from(graph_exec), 16);
        assert_eq!(u64::from(graph_node), 19);
        assert_eq!(u64::from(stream), 21);
        assert_eq!(u64::from(external_correlation), 25);
        assert_eq!(sys::CUpti_EventID::from(event), 17);
        assert_eq!(sys::CUpti_EventDomainID::from(domain), 23);
        assert_eq!(sys::CUpti_MetricID::from(metric), 31);
        assert_eq!(callback.as_raw(), 37);
    }

    #[test]
    fn activity_flush_flag_converts_to_cupti_values() {
        assert_eq!(u32::from(ActivityFlushFlag::Default), 0);
        assert_eq!(
            u32::from(ActivityFlushFlag::Forced),
            sys::CUpti_ActivityFlag::CUPTI_ACTIVITY_FLAG_FLUSH_FORCED as u32
        );
    }
}