cudnn_graph 库

数据类型参考

这些是 cudnn_graph 库的数据类型参考。

结构体类型

这些是 cudnn_graph 库的结构体类型。

cudnnDebug_t

cudnnDebug_t 是 cudnnSetCallback() 和 cudnnGetCallback() 使用的结构体，包含元数据，例如时间、自启动以来的时间、流 ID、进程和线程 ID，用户可以选择在自定义回调中打印或存储这些元数据。

cudnnFraction_t

cudnnFraction_t 是一个结构体，允许用户定义 int64_t 分数。

typedef struct cudnnFractionStruct {
    int64_t numerator;
    int64_t denominator;
} cudnnFraction_t;

枚举类型

这些是 cudnn_graph 库的枚举类型。

cudnnActivationMode_t

此枚举类型已弃用，目前仅由已弃用的 API 使用。考虑使用替换已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnActivationMode_t 是一种枚举类型，用于选择 cudnnActivationForward()、cudnnActivationBackward() 和 cudnnConvolutionBiasActivationForward() 中使用的神经元激活函数。

值

CUDNN_ACTIVATION_SIGMOID

选择 sigmoid 函数。

CUDNN_ACTIVATION_RELU

选择修正线性函数。

CUDNN_ACTIVATION_TANH

选择双曲正切函数。

CUDNN_ACTIVATION_CLIPPED_RELU

选择裁剪修正线性函数。

CUDNN_ACTIVATION_ELU

选择指数线性函数。

CUDNN_ACTIVATION_IDENTITY

选择恒等函数，旨在绕过 cudnnConvolutionBiasActivationForward() 中的激活步骤。（cudnnConvolutionBiasActivationForward() 函数必须使用 CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM。）不适用于 cudnnActivationForward() 或 cudnnActivationBackward()。

CUDNN_ACTIVATION_SWISH

选择 swish 函数。

cudnnBackendAttributeName_t

cudnnBackendAttributeName_t 是一种枚举类型，指示可以使用 cudnnBackendSetAttribute() 和 cudnnBackendGetAttribute() 函数设置或获取的后端描述符属性。属性所属的后端描述符由属性名称的前缀标识。

typedef enum {
    CUDNN_ATTR_POINTWISE_MODE                  = 0,
    CUDNN_ATTR_POINTWISE_MATH_PREC             = 1,
    CUDNN_ATTR_POINTWISE_NAN_PROPAGATION       = 2,
    CUDNN_ATTR_POINTWISE_RELU_LOWER_CLIP       = 3,
    CUDNN_ATTR_POINTWISE_RELU_UPPER_CLIP       = 4,
    CUDNN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,
    CUDNN_ATTR_POINTWISE_ELU_ALPHA             = 6,
    CUDNN_ATTR_POINTWISE_SOFTPLUS_BETA         = 7,
    CUDNN_ATTR_POINTWISE_SWISH_BETA            = 8,
    CUDNN_ATTR_POINTWISE_AXIS                  = 9,

    CUDNN_ATTR_CONVOLUTION_COMP_TYPE      = 100,
    CUDNN_ATTR_CONVOLUTION_CONV_MODE      = 101,
    CUDNN_ATTR_CONVOLUTION_DILATIONS      = 102,
    CUDNN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,
    CUDNN_ATTR_CONVOLUTION_POST_PADDINGS  = 104,
    CUDNN_ATTR_CONVOLUTION_PRE_PADDINGS   = 105,
    CUDNN_ATTR_CONVOLUTION_SPATIAL_DIMS   = 106,

    CUDNN_ATTR_ENGINEHEUR_MODE            = 200,
    CUDNN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,
    CUDNN_ATTR_ENGINEHEUR_RESULTS         = 202,
    CUDNN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,

    CUDNN_ATTR_ENGINECFG_ENGINE            = 300,
    CUDNN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,
    CUDNN_ATTR_ENGINECFG_KNOB_CHOICES      = 302,
    CUDNN_ATTR_ENGINECFG_WORKSPACE_SIZE    = 303,

    CUDNN_ATTR_EXECUTION_PLAN_HANDLE                     = 400,
    CUDNN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG              = 401,
    CUDNN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE             = 402,
    CUDNN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,
    CUDNN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,
    CUDNN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION        = 405,
    CUDNN_ATTR_EXECUTION_PLAN_KERNEL_CACHE               = 406,

    CUDNN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID            = 500,
    CUDNN_ATTR_INTERMEDIATE_INFO_SIZE                 = 501,
    CUDNN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS  = 502,
    CUDNN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,

    CUDNN_ATTR_KNOB_CHOICE_KNOB_TYPE  = 600,
    CUDNN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,

    CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA        = 700,
    CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA         = 701,
    CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC    = 702,
    CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_W            = 703,
    CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_X            = 704,
    CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y            = 705,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA       = 706,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA        = 707,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC   = 708,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W           = 709,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX          = 710,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY          = 711,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA     = 712,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA      = 713,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW        = 715,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X         = 716,
    CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY        = 717,
    CUDNN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR          = 750,
    CUDNN_ATTR_OPERATION_POINTWISE_XDESC                  = 751,
    CUDNN_ATTR_OPERATION_POINTWISE_BDESC                  = 752,
    CUDNN_ATTR_OPERATION_POINTWISE_YDESC                  = 753,
    CUDNN_ATTR_OPERATION_POINTWISE_ALPHA1                 = 754,
    CUDNN_ATTR_OPERATION_POINTWISE_ALPHA2                 = 755,
    CUDNN_ATTR_OPERATION_POINTWISE_DXDESC                 = 756,
    CUDNN_ATTR_OPERATION_POINTWISE_DYDESC                 = 757,
    CUDNN_ATTR_OPERATION_POINTWISE_TDESC                  = 758,

    CUDNN_ATTR_OPERATION_GENSTATS_MODE                    = 770,
    CUDNN_ATTR_OPERATION_GENSTATS_MATH_PREC               = 771,
    CUDNN_ATTR_OPERATION_GENSTATS_XDESC                   = 772,
    CUDNN_ATTR_OPERATION_GENSTATS_SUMDESC                 = 773,
    CUDNN_ATTR_OPERATION_GENSTATS_SQSUMDESC               = 774,

    CUDNN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE                = 780,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC                 = 781,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC                = 782,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC             = 783,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC                = 784,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC                 = 785,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC    = 786,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC     = 787,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC  = 789,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC           = 790,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC        = 791,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC             = 792,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC              = 793,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC          = 794,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC              = 795,
    CUDNN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC   = 796,

    CUDNN_ATTR_OPERATIONGRAPH_HANDLE                   = 800,
    CUDNN_ATTR_OPERATIONGRAPH_OPS                      = 801,
    CUDNN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT      = 802,
    CUDNN_ATTR_OPERATIONGRAPH_IS_DYNAMIC_SHAPE_ENABLED = 803,

    CUDNN_ATTR_TENSOR_BYTE_ALIGNMENT       = 900,
    CUDNN_ATTR_TENSOR_DATA_TYPE            = 901,
    CUDNN_ATTR_TENSOR_DIMENSIONS           = 902,
    CUDNN_ATTR_TENSOR_STRIDES              = 903,
    CUDNN_ATTR_TENSOR_VECTOR_COUNT         = 904,
    CUDNN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,
    CUDNN_ATTR_TENSOR_UNIQUE_ID            = 906,
    CUDNN_ATTR_TENSOR_IS_VIRTUAL           = 907,
    CUDNN_ATTR_TENSOR_IS_BY_VALUE          = 908,
    CUDNN_ATTR_TENSOR_REORDERING_MODE      = 909,
    CUDNN_ATTR_TENSOR_RAGGED_OFFSET_DESC   = 910,

    CUDNN_ATTR_VARIANT_PACK_UNIQUE_IDS    = 1000,
    CUDNN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,
    CUDNN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,
    CUDNN_ATTR_VARIANT_PACK_WORKSPACE     = 1003,

    CUDNN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,
    CUDNN_ATTR_LAYOUT_INFO_TYPES      = 1101,

    CUDNN_ATTR_KNOB_INFO_TYPE          = 1200,
    CUDNN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,
    CUDNN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,
    CUDNN_ATTR_KNOB_INFO_STRIDE        = 1203,

    CUDNN_ATTR_ENGINE_OPERATION_GRAPH = 1300,
    CUDNN_ATTR_ENGINE_GLOBAL_INDEX    = 1301,
    CUDNN_ATTR_ENGINE_KNOB_INFO       = 1302,
    CUDNN_ATTR_ENGINE_NUMERICAL_NOTE  = 1303,
    CUDNN_ATTR_ENGINE_LAYOUT_INFO     = 1304,
    CUDNN_ATTR_ENGINE_BEHAVIOR_NOTE   = 1305,
    CUDNN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,

    CUDNN_ATTR_MATMUL_COMP_TYPE       = 1500,
    CUDNN_ATTR_MATMUL_PADDING_VALUE   = 1501,

    CUDNN_ATTR_OPERATION_MATMUL_ADESC                           = 1520,
    CUDNN_ATTR_OPERATION_MATMUL_BDESC                           = 1521,
    CUDNN_ATTR_OPERATION_MATMUL_CDESC                           = 1522,
    CUDNN_ATTR_OPERATION_MATMUL_DESC                            = 1523,
    CUDNN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,
    CUDNN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC            = 1525,
    CUDNN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC            = 1526,
    CUDNN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC            = 1527,

    CUDNN_ATTR_REDUCTION_OPERATOR  = 1600,
    CUDNN_ATTR_REDUCTION_COMP_TYPE = 1601,

    CUDNN_ATTR_OPERATION_REDUCTION_XDESC = 1610,
    CUDNN_ATTR_OPERATION_REDUCTION_YDESC = 1611,
    CUDNN_ATTR_OPERATION_REDUCTION_DESC  = 1612,

    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC        = 1620,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC        = 1621,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC      = 1622,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC    = 1623,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC           = 1624,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC          = 1625,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC   = 1626,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC    = 1627,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC  = 1629,
    CUDNN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS          = 1630,

    CUDNN_ATTR_RESAMPLE_MODE            = 1700,
    CUDNN_ATTR_RESAMPLE_COMP_TYPE       = 1701,
    CUDNN_ATTR_RESAMPLE_SPATIAL_DIMS    = 1702,
    CUDNN_ATTR_RESAMPLE_POST_PADDINGS   = 1703,
    CUDNN_ATTR_RESAMPLE_PRE_PADDINGS    = 1704,
    CUDNN_ATTR_RESAMPLE_STRIDES         = 1705,
    CUDNN_ATTR_RESAMPLE_WINDOW_DIMS     = 1706,
    CUDNN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,
    CUDNN_ATTR_RESAMPLE_PADDING_MODE    = 1708,

    CUDNN_ATTR_OPERATION_RESAMPLE_FWD_XDESC   = 1710,
    CUDNN_ATTR_OPERATION_RESAMPLE_FWD_YDESC   = 1711,
    CUDNN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,
    CUDNN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA   = 1713,
    CUDNN_ATTR_OPERATION_RESAMPLE_FWD_BETA    = 1714,
    CUDNN_ATTR_OPERATION_RESAMPLE_FWD_DESC    = 1716,

    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC  = 1720,
    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC  = 1721,
    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,
    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA   = 1723,
    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_BETA    = 1724,
    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_DESC    = 1725,
    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_XDESC   = 1726,
    CUDNN_ATTR_OPERATION_RESAMPLE_BWD_YDESC   = 1727,

    CUDNN_ATTR_OPERATION_CONCAT_AXIS          = 1800,
    CUDNN_ATTR_OPERATION_CONCAT_INPUT_DESCS   = 1801,
    CUDNN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,
    CUDNN_ATTR_OPERATION_CONCAT_OUTPUT_DESC   = 1803,

    CUDNN_ATTR_OPERATION_SIGNAL_MODE     = 1900,
    CUDNN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,
    CUDNN_ATTR_OPERATION_SIGNAL_VALUE    = 1902,
    CUDNN_ATTR_OPERATION_SIGNAL_XDESC    = 1903,
    CUDNN_ATTR_OPERATION_SIGNAL_YDESC    = 1904,

    CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_CONTAINER_DESC  = 1950,
    CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_YDESC           = 1951,
    CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_SEQUENCE_DESC   = 1952,
    CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_PAGE_TABLE_DESC = 1953,

    CUDNN_ATTR_OPERATION_NORM_FWD_MODE                     = 2000,
    CUDNN_ATTR_OPERATION_NORM_FWD_PHASE                    = 2001,
    CUDNN_ATTR_OPERATION_NORM_FWD_XDESC                    = 2002,
    CUDNN_ATTR_OPERATION_NORM_FWD_MEAN_DESC                = 2003,
    CUDNN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC        = 2004,
    CUDNN_ATTR_OPERATION_NORM_FWD_SCALE_DESC               = 2005,
    CUDNN_ATTR_OPERATION_NORM_FWD_BIAS_DESC                = 2006,
    CUDNN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC             = 2007,
    CUDNN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC      = 2008,
    CUDNN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC  = 2009,
    CUDNN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC   = 2010,
    CUDNN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,
    CUDNN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC  = 2012,
    CUDNN_ATTR_OPERATION_NORM_FWD_YDESC                    = 2013,
    CUDNN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS          = 2014,

    CUDNN_ATTR_OPERATION_NORM_BWD_MODE              = 2100,
    CUDNN_ATTR_OPERATION_NORM_BWD_XDESC             = 2101,
    CUDNN_ATTR_OPERATION_NORM_BWD_MEAN_DESC         = 2102,
    CUDNN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,
    CUDNN_ATTR_OPERATION_NORM_BWD_DYDESC            = 2104,
    CUDNN_ATTR_OPERATION_NORM_BWD_SCALE_DESC        = 2105,
    CUDNN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC      = 2106,
    CUDNN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC       = 2107,
    CUDNN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC        = 2108,
    CUDNN_ATTR_OPERATION_NORM_BWD_DXDESC            = 2109,
    CUDNN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS   = 2110,

    CUDNN_ATTR_OPERATION_RESHAPE_XDESC = 2200,
    CUDNN_ATTR_OPERATION_RESHAPE_YDESC = 2201,

    CUDNN_ATTR_RNG_DISTRIBUTION                   = 2300,
    CUDNN_ATTR_RNG_NORMAL_DIST_MEAN               = 2301,
    CUDNN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,
    CUDNN_ATTR_RNG_UNIFORM_DIST_MAXIMUM           = 2303,
    CUDNN_ATTR_RNG_UNIFORM_DIST_MINIMUM           = 2304,
    CUDNN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY     = 2305,

    CUDNN_ATTR_OPERATION_RNG_YDESC       = 2310,
    CUDNN_ATTR_OPERATION_RNG_SEED        = 2311,
    CUDNN_ATTR_OPERATION_RNG_DESC        = 2312,
    CUDNN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,

    CUDNN_ATTR_KERNEL_CACHE_IS_ENGINECFG_KERNEL_CACHED = 2400,

    CUDNN_ATTR_OPERATION_BLOCK_SCALE_QUANTIZE_XDESC      = 2500,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_QUANTIZE_YDESC      = 2501,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_QUANTIZE_SCALE_DESC = 2502,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_QUANTIZE_MATH_PREC  = 2503,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_QUANTIZE_BLOCK_SIZE = 2504,

    CUDNN_ATTR_OPERATION_BLOCK_SCALE_DEQUANTIZE_XDESC      = 2600,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_DEQUANTIZE_SCALE_DESC = 2601,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_DEQUANTIZE_YDESC      = 2602,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_DEQUANTIZE_MATH_PREC  = 2603,
    CUDNN_ATTR_OPERATION_BLOCK_SCALE_DEQUANTIZE_BLOCK_SIZE = 2604,

} cudnnBackendAttributeName_t;

cudnnBackendAttributeType_t

枚举类型 cudnnBackendAttributeType_t 指定 cuDNN 后端描述符的属性的数据类型。它用于指定 cudnnBackendSetAttribute() 和 cudnnBackendGetAttribute() 的 void *arrayOfElements 参数指向的数据类型。

typedef enum {
    CUDNN_TYPE_HANDLE = 0,
    CUDNN_TYPE_DATA_TYPE,
    CUDNN_TYPE_BOOLEAN,
    CUDNN_TYPE_INT64,
    CUDNN_TYPE_FLOAT,
    CUDNN_TYPE_DOUBLE,
    CUDNN_TYPE_VOID_PTR,
    CUDNN_TYPE_CONVOLUTION_MODE,
    CUDNN_TYPE_HEUR_MODE,
    CUDNN_TYPE_KNOB_TYPE,
    CUDNN_TYPE_NAN_PROPOGATION,
    CUDNN_TYPE_NUMERICAL_NOTE,
    CUDNN_TYPE_LAYOUT_TYPE,
    CUDNN_TYPE_ATTRIB_NAME,
    CUDNN_TYPE_POINTWISE_MODE,
    CUDNN_TYPE_BACKEND_DESCRIPTOR,
    CUDNN_TYPE_GENSTATS_MODE,
    CUDNN_TYPE_BN_FINALIZE_STATS_MODE,
    CUDNN_TYPE_REDUCTION_OPERATOR_TYPE,
    CUDNN_TYPE_BEHAVIOR_NOTE,
    CUDNN_TYPE_TENSOR_REORDERING_MODE,
    CUDNN_TYPE_RESAMPLE_MODE,
    CUDNN_TYPE_PADDING_MODE,
    CUDNN_TYPE_INT32,
    CUDNN_TYPE_CHAR,
    CUDNN_TYPE_SIGNAL_MODE,
    CUDNN_TYPE_FRACTION,
    CUDNN_TYPE_NORM_MODE,
    CUDNN_TYPE_NORM_FWD_PHASE,
    CUDNN_TYPE_RNG_DISTRIBUTION
} cudnnBackendAttributeType_t;

cudnnBackendAttributeType_t 的属性类型

cudnnBackendAttributeType_t	属性类型
CUDNN_TYPE_HANDLE	cudnnHandle_t
CUDNN_TYPE_DATA_TYPE	cudnnDataType_t
CUDNN_TYPE_BOOLEAN	bool
CUDNN_TYPE_INT64	int64_t
CUDNN_TYPE_FLOAT	float
CUDNN_TYPE_DOUBLE	double
CUDNN_TYPE_VOID_PTR	void *
CUDNN_TYPE_CONVOLUTION_MODE	cudnnConvolutionMode_t
CUDNN_TYPE_HEUR_MODE	cudnnBackendHeurMode_t
CUDNN_TYPE_KNOB_TYPE	cudnnBackendKnobType_t
CUDNN_TYPE_NAN_PROPOGATION	cudnnNanPropagation_t
CUDNN_TYPE_NUMERICAL_NOTE	cudnnBackendNumericalNote_t
CUDNN_TYPE_LAYOUT_TYPE	cudnnBackendLayoutType_t
CUDNN_TYPE_ATTRIB_NAME	cudnnBackendAttributeName_t
CUDNN_TYPE_POINTWISE_MODE	cudnnPointwiseMode_t
CUDNN_TYPE_BACKEND_DESCRIPTOR	cudnnBackendDescriptor_t
CUDNN_TYPE_GENSTATS_MODE	cudnnGenStatsMode_t
CUDNN_TYPE_BN_FINALIZE_STATS_MODE	cudnnBnFinalizeStatsMode_t
CUDNN_TYPE_REDUCTION_OPERATOR_TYPE	cudnnReduceTensorOp_t
CUDNN_TYPE_BEHAVIOR_NOTE	cudnnBackendBehaviorNote_t
CUDNN_TYPE_TENSOR_REORDERING_MODE	cudnnBackendTensorReordering_t
CUDNN_TYPE_RESAMPLE_MODE	cudnnResampleMode_t
CUDNN_TYPE_PADDING_MODE	cudnnPaddingMode_t
CUDNN_TYPE_INT32	int32_t
CUDNN_TYPE_CHAR	char
CUDNN_TYPE_SIGNAL_MODE	cudnnSignalMode_t
CUDNN_TYPE_FRACTION	cudnnFraction_t
CUDNN_TYPE_NORM_MODE	cudnnBackendNormMode_t
CUDNN_TYPE_NORM_FWD_PHASE	cudnnBackendNormFwdPhase_t
CUDNN_TYPE_RNG_DISTRIBUTION	cudnnRngDistribution_t

cudnnBackendBehaviorNote_t

cudnnBackendBehaviorNote_t 是一种枚举类型，指示引擎的可查询行为注释。用户可以使用 cudnnBackendGetAttribute() 函数从 CUDNN_BACKEND_ENGINE_DESCRIPTOR 查询行为注释数组。

typedef enum {
    CUDNN_BEHAVIOR_NOTE_RUNTIME_COMPILATION             = 0,
    CUDNN_BEHAVIOR_NOTE_REQUIRES_FILTER_INT8x32_REORDER = 1,
    CUDNN_BEHAVIOR_NOTE_REQUIRES_BIAS_INT8x32_REORDER   = 2,
    CUDNN_BEHAVIOR_NOTE_SUPPORTS_CUDA_GRAPH_NATIVE_API  = 3,
    CUDNN_BEHAVIOR_NOTE_TYPE_COUNT,
} cudnnBackendBehaviorNote_t;

cudnnBackendDescriptorType_t

cudnnBackendDescriptor_t 是一种枚举类型，指示后端描述符的类型。用户通过将此枚举中的值传递给 cudnnBackendCreateDescriptor() 函数来创建特定类型的后端描述符。

typedef enum {
    CUDNN_BACKEND_POINTWISE_DESCRIPTOR = 0,
    CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR,
    CUDNN_BACKEND_ENGINE_DESCRIPTOR,
    CUDNN_BACKEND_ENGINECFG_DESCRIPTOR,
    CUDNN_BACKEND_ENGINEHEUR_DESCRIPTOR,
    CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,
    CUDNN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,
    CUDNN_BACKEND_KNOB_CHOICE_DESCRIPTOR,
    CUDNN_BACKEND_KNOB_INFO_DESCRIPTOR,
    CUDNN_BACKEND_LAYOUT_INFO_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,
    CUDNN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,
    CUDNN_BACKEND_VARIANT_PACK_DESCRIPTOR,
    CUDNN_BACKEND_TENSOR_DESCRIPTOR,
    CUDNN_BACKEND_MATMUL_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_BN_FINALIZE_STATISTICS_DESCRIPTOR,
    CUDNN_BACKEND_REDUCTION_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_BN_BWD_WEIGHTS_DESCRIPTOR,
    CUDNN_BACKEND_RESAMPLE_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,
    CUDNN_BACKEND_RNG_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_RNG_DESCRIPTOR,
    CUDNN_BACKEND_KERNEL_CACHE_DESCRIPTOR,
    CUDNN_BACKEND_OPERATION_PAGED_CACHE_LOAD_DESCRIPTOR
} cudnnBackendDescriptorType_t;

cudnnBackendHeurMode_t

cudnnBackendHeurMode_t 是一种枚举类型，指示 CUDNN_BACKEND_ENGINEHEUR_DESCRIPTOR 的操作模式。

typedef enum {
    CUDNN_HEUR_MODE_INSTANT  = 0,
    CUDNN_HEUR_MODE_B        = 1,
    CUDNN_HEUR_MODE_FALLBACK = 2,
    CUDNN_HEUR_MODE_A        = 3
}

值

CUDNN_HEUR_MODE_A 和 CUDNN_HEUR_MODE_INSTANT

CUDNN_HEUR_MODE_A 提供与 CUDNN_HEUR_MODE_INSTANT 完全相同的功能。此重命名的目的是更好地匹配 CUDNN_HEUR_MODE_B 的命名。

考虑将 CUDNN_HEUR_MODE_INSTANT 用作已弃用；请改用 CUDNN_HEUR_MODE_A。

CUDNN_HEUR_MODE_A 利用决策树启发式方法，与 CUDNN_HEUR_MODE_B 相比，可在 CPU 上提供最佳推理时间。

CUDNN_HEUR_MODE_A 和 CUDNN_HEUR_MODE_INSTANT 支持以下操作节点或操作图

• ConvolutionFwd

• ConvolutionBwdFilter

• ConvolutionBwdData

• ConvBNfprop

• ConvBNwgrad

• ConvBiasAct

• ConvScaleBiasAct

• DgradDreluBNBwdWeight

• 运行时融合引擎支持的模式

不支持所有其他操作图。

CUDNN_HEUR_MODE_B

与 CUDNN_HEUR_MODE_INSTANT 相比，可以利用基于神经网络的启发式方法来提高泛化性能。

在使用神经网络的情况下，与 CUDNN_HEUR_MODE_INSTANT 相比，CPU 上的推理时间将增加 10-100 倍。以下任何情况都不支持这些神经网络启发式方法

• 3-D 卷积

• 分组卷积（groupCount 大于 1）

• 空洞卷积（任何空间维度的空洞大于 1）

此外，仅当 cuDNN 在 A100 GPU 上运行时，神经网络才在 x86 平台上启用。在不支持神经网络的情况下，CUDNN_HEUR_MODE_B 将回退到 CUDNN_HEUR_MODE_INSTANT。CUDNN_HEUR_MODE_B 在预计 CUDNN_HEUR_MODE_B 的开销会降低整体网络性能的情况下，也将回退到 CUDNN_HEUR_MODE_INSTANT。

CUDNN_HEUR_MODE_FALLBACK

此启发式模式旨在用于查找提供功能支持（不期望提供最佳 GPU 性能）的回退选项。

cudnnBackendKnobType_t

cudnnBackendKnobType_t 是一种枚举类型，指示性能旋钮的类型。性能旋钮是引擎的运行时设置，会影响其性能。用户可以使用 cudnnBackendGetAttribute() 函数从 CUDNN_BACKEND_ENGINE_DESCRIPTOR 查询性能旋钮及其有效值范围的数组。用户可以使用 CUDNN_BACKEND_KNOB_CHOICE_DESCRIPTOR 通过 cudnnBackendSetAttribute() 函数设置每个旋钮的选择。

typedef enum {
    CUDNN_KNOB_TYPE_SPLIT_K                                = 0,
    CUDNN_KNOB_TYPE_SWIZZLE                                = 1,
    CUDNN_KNOB_TYPE_TILE_SIZE                              = 2,
    CUDNN_KNOB_TYPE_USE_TEX                                = 3,
    CUDNN_KNOB_TYPE_EDGE                                   = 4,
    CUDNN_KNOB_TYPE_KBLOCK                                 = 5,
    CUDNN_KNOB_TYPE_LDGA                                   = 6,
    CUDNN_KNOB_TYPE_LDGB                                   = 7,
    CUDNN_KNOB_TYPE_CHUNK_K                                = 8,
    CUDNN_KNOB_TYPE_SPLIT_H                                = 9,
    CUDNN_KNOB_TYPE_WINO_TILE                              = 10,
    CUDNN_KNOB_TYPE_MULTIPLY                               = 11,
    CUDNN_KNOB_TYPE_SPLIT_K_BUF                            = 12,
    CUDNN_KNOB_TYPE_TILEK                                  = 13,
    CUDNN_KNOB_TYPE_STAGES                                 = 14,
    CUDNN_KNOB_TYPE_REDUCTION_MODE                         = 15,
    CUDNN_KNOB_TYPE_CTA_SPLIT_K_MODE                       = 16,
    CUDNN_KNOB_TYPE_SPLIT_K_SLC                            = 17,
    CUDNN_KNOB_TYPE_IDX_MODE                               = 18,
    CUDNN_KNOB_TYPE_SLICED                                 = 19,
    CUDNN_KNOB_TYPE_SPLIT_RS                               = 20,
    CUDNN_KNOB_TYPE_SINGLEBUFFER                           = 21,
    CUDNN_KNOB_TYPE_LDGC                                   = 22,
    CUDNN_KNOB_TYPE_SPECFILT                               = 23,
    CUDNN_KNOB_TYPE_KERNEL_CFG                             = 24,
    CUDNN_KNOB_TYPE_WORKSPACE                              = 25,
    CUDNN_KNOB_TYPE_TILE_CGA CUDNN_DEPRECATED_ENUM         = 26,
    CUDNN_KNOB_TYPE_TILE_CGA_M                             = 27,
    CUDNN_KNOB_TYPE_TILE_CGA_N                             = 28,
    CUDNN_KNOB_TYPE_BLOCK_SIZE                             = 29,
    CUDNN_KNOB_TYPE_OCCUPANCY                              = 30,
    CUDNN_KNOB_TYPE_ARRAY_SIZE_PER_THREAD                  = 31,
    CUDNN_KNOB_TYPE_NUM_C_PER_BLOCK CUDNN_DEPRECATED_ENUM  = 32,
    CUDNN_KNOB_TYPE_SPLIT_COLS                             = 33,
    CUDNN_KNOB_TYPE_TILE_ROWS                              = 34,
    CUDNN_KNOB_TYPE_TILE_COLS                              = 35,
} cudnnBackendKnobType_t;

cudnnBackendLayoutType_t

cudnnBackendLayoutType_t 是一种枚举类型，指示引擎的可查询布局要求。用户可以使用 cudnnBackendGetAttribute() 函数从 CUDNN_BACKEND_ENGINE_DESCRIPTOR 查询布局要求。

typedef enum {
    CUDNN_LAYOUT_TYPE_PREFERRED_NCHW   = 0,
    CUDNN_LAYOUT_TYPE_PREFERRED_NHWC   = 1,
    CUDNN_LAYOUT_TYPE_PREFERRED_PAD4CK = 2,
    CUDNN_LAYOUT_TYPE_PREFERRED_PAD8CK = 3,
    CUDNN_LAYOUT_TYPE_COUNT            = 4,
} cudnnBackendLayoutType_t;

cudnnBackendNormFwdPhase_t

cudnnBackendNormFwdPhase_t 是一种枚举类型，用于区分归一化前向操作的推理和训练阶段。

typedef enum {
    CUDNN_NORM_FWD_INFERENCE = 0,
    CUDNN_NORM_FWD_TRAINING  = 1,
} cudnnBackendNormFwdPhase_t;

cudnnBackendNormMode_t

cudnnBackendNormMode_t 是一种枚举类型，用于指示后端归一化前向和归一化后向操作中的归一化模式。

供参考

• 层归一化的定义可以在 层归一化 论文中找到。

• 实例归一化的定义可以在 实例归一化：快速风格化的缺失成分 论文中找到。

• 批归一化的定义可以在 批归一化：通过减少内部协变量偏移加速深度网络训练 论文中找到。

• 均方根归一化的定义可以在 均方根层归一化 论文中找到。

CUDNN_GROUP_NORM 尚不支持。如果您尝试使用它，cuDNN 将返回 CUDNN_STATUS_INTERNAL_ERROR 错误。

typedef enum {
    CUDNN_LAYER_NORM    = 0,
    CUDNN_INSTANCE_NORM = 1,
    CUDNN_BATCH_NORM    = 2,
    CUDNN_GROUP_NORM    = 3,
    CUDNN_RMS_NORM      = 4,
} cudnnBackendNormMode_t;

cudnnBackendNumericalNote_t

cudnnBackendNumericalNot_t 是一种枚举类型，指示引擎的可查询数值属性。用户可以使用 cudnnBackendGetAttribute() 函数从 CUDNN_BACKEND_ENGINE_DESCRIPTOR 查询数值注释数组。

typedef enum {
    CUDNN_NUMERICAL_NOTE_TENSOR_CORE = 0,
    CUDNN_NUMERICAL_NOTE_DOWN_CONVERT_INPUTS,
    CUDNN_NUMERICAL_NOTE_REDUCED_PRECISION_REDUCTION,
    CUDNN_NUMERICAL_NOTE_FFT,
    CUDNN_NUMERICAL_NOTE_NONDETERMINISTIC,
    CUDNN_NUMERICAL_NOTE_WINOGRAD,
    CUDNN_NUMERICAL_NOTE_WINOGRAD_TILE_4x4,
    CUDNN_NUMERICAL_NOTE_WINOGRAD_TILE_6x6,
    CUDNN_NUMERICAL_NOTE_WINOGRAD_TILE_13x13,
    CUDNN_NUMERICAL_NOTE_STRICT_NAN_PROP,
    CUDNN_NUMERICAL_NOTE_TYPE_COUNT,
} cudnnBackendNumericalNote_t;

cudnnBackendTensorReordering_t

cudnnBackendTensorReordering_t 是一种枚举类型，指示张量重排序作为张量描述符的属性。用户可以使用 cudnnBackendSetAttribute() 和 cudnnBackendGetAttribute() 函数在 CUDNN_BACKEND_TENSOR_DESCRIPTOR 中获取和设置此属性。

typedef enum {
    CUDNN_TENSOR_REORDERING_NONE     = 0,
    CUDNN_TENSOR_REORDERING_INT8x32  = 1,
    CUDNN_TENSOR_REORDERING_F16x16   = 2,
    CUDNN_TENSOR_REORDERING_F8_128x4 = 3,

} cudnnBackendTensorReordering_t;

cudnnBnFinalizeStatsMode_t

cudnnBnFinalizeStatsMode_t 是一种枚举类型，它公开了将批归一化统计信息以及训练后的比例和偏差转换为等效比例和偏差的不同数学运算模式，以便在下一个归一化阶段用于推理和训练用例。

typedef enum {
    CUDNN_BN_FINALIZE_STATISTICS_TRAINING  = 0,
    CUDNN_BN_FINALIZE_STATISTICS_INFERENCE = 1,
} cudnnBnFinalizeStatsMode_t;

cudnnConvolutionMode_t

此枚举类型已弃用，目前仅由已弃用的 API 使用。考虑使用替换已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnConvolutionMode_t 是 cudnnSetConvolution2dDescriptor() 使用的枚举类型，用于配置卷积 descriptor。用于卷积的滤波器可以以两种不同的方式应用，在数学上分别对应于卷积或互相关。（互相关等效于将其滤波器旋转 180 度的卷积。）

值

CUDNN_CONVOLUTION

在此模式下，将滤波器应用于图像时，将完成卷积运算。

CUDNN_CROSS_CORRELATION

在此模式下，将滤波器应用于图像时，将完成互相关运算。

cudnnDataType_t

cudnnDataType_t 是一种枚举类型，指示张量描述符或滤波器描述符引用的数据类型。

值

CUDNN_DATA_FLOAT

数据是 32 位单精度浮点型 (float)。

CUDNN_DATA_DOUBLE

数据是 64 位双精度浮点型 (double)。

CUDNN_DATA_HALF

数据是 16 位浮点型。

CUDNN_DATA_INT8

数据是 8 位有符号整数。

CUDNN_DATA_INT32

数据是 32 位有符号整数。

CUDNN_DATA_INT8x4

数据是 32 位元素，每个元素由 4 个 8 位有符号整数组成。此数据类型仅支持张量格式 CUDNN_TENSOR_NCHW_VECT_C。

CUDNN_DATA_UINT8

数据是 8 位无符号整数。

CUDNN_DATA_UINT8x4

数据是 32 位元素，每个元素由 4 个 8 位无符号整数组成。此数据类型仅支持张量格式 CUDNN_TENSOR_NCHW_VECT_C。

CUDNN_DATA_INT8x32

数据是 32 元素向量，每个元素都是 8 位有符号整数。此数据类型仅支持张量格式 CUDNN_TENSOR_NCHW_VECT_C。此外，此数据类型只能与 algo 1 一起使用，即 CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM。有关更多信息，请参阅 cudnnConvolutionFwdAlgo_t。

CUDNN_DATA_BFLOAT16

数据是 16 位量，具有 7 位尾数、8 位指数和 1 位符号位。

CUDNN_DATA_INT64

数据是 64 位有符号整数。

CUDNN_DATA_BOOLEAN

数据是布尔值 (bool)。

请注意，对于类型 CUDNN_TYPE_BOOLEAN，元素应为“packed”：即，一个字节包含 8 个 CUDNN_TYPE_BOOLEAN 类型的元素。此外，在每个字节中，元素从最低有效位到最高有效位进行索引。例如，一个包含 8 个元素的一维张量 01001111 对于元素 0 到 3 的值为 1，对于元素 4 和 5 的值为 0，对于元素 6 的值为 1，对于元素 7 的值为 0。

具有超过 8 个元素的张量仅使用更多字节，其中顺序也从最低有效字节到最高有效字节。请注意，CUDA 是小端字节序，这意味着最低有效字节具有较低的内存地址。例如，在 16 个元素的情况下，01001111 11111100 对于元素 0 到 3 的值为 1，对于元素 4 和 5 的值为 0，对于元素 6 的值为 1，对于元素 7 的值为 0，对于元素 8 和 9 的值为 0，对于元素 10 到 15 的值为 1。

CUDNN_DATA_FP8_E4M3

数据是 8 位量，具有 3 位尾数、4 位指数和 1 位符号位。

CUDNN_DATA_FP8_E5M2

数据是 8 位量，具有 2 位尾数、5 位指数和 1 位符号位。

CUDNN_DATA_FAST_FLOAT_FOR_FP8

数据类型是更高吞吐量但更低精度的计算类型（与 CUDNN_DATA_FLOAT 相比），用于 FP8 张量核心运算。

cudnnErrQueryMode_t

cudnnErrQueryMode_t 是一种传递给 cudnnQueryRuntimeError() 的枚举类型，用于选择远程内核错误查询模式。

值

CUDNN_ERRQUERY_RAWCODE

读取错误存储位置，无论内核完成状态如何。

CUDNN_ERRQUERY_NONBLOCKING

报告 cuDNN 句柄的用户流中的所有任务是否已完成。如果是，则报告远程内核错误代码。

CUDNN_ERRQUERY_BLOCKING

等待用户流中的所有任务完成后再报告远程内核错误代码。

cudnnGenStatsMode_t

cudnnGenStatsMode_t 是一种枚举类型，用于指示后端统计信息生成操作中的统计信息模式。

值

CUDNN_GENSTATS_SUM_SQSUM

在此模式下，计算并写出沿指定维度的输入张量的总和与平方和。当前支持的缩减维度限于每通道，但可能会根据请求添加更多支持。

cudnnHandle_t

cudnnHandle_t 是指向保存 cuDNN 库上下文的不透明结构的指针。cuDNN 库上下文必须使用 cudnnCreate() 创建，并且返回的句柄必须传递给所有后续库函数调用。上下文应在使用 cudnnDestroy() 结束时销毁。上下文仅与一个 GPU 设备关联，即调用 cudnnCreate() 时的当前设备。但是，可以在同一 GPU 设备上创建多个上下文。

cudnnMathType_t

cudnnMathType_t 是一种枚举类型，用于指示在给定的库例程中是否允许使用 Tensor Core 运算。

值

CUDNN_DEFAULT_MATH

在 NVIDIA A100 之前的 GPU 设备上不使用 Tensor Core 运算。在 A100 GPU 架构设备上，允许使用 Tensor Core TF32 运算。

CUDNN_TENSOR_OP_MATH

允许使用 Tensor Core 运算，但不会主动对张量执行数据类型向下转换以利用 Tensor Core。

CUDNN_TENSOR_OP_MATH_ALLOW_CONVERSION

允许使用 Tensor Core 运算，并将主动对张量执行数据类型向下转换以利用 Tensor Core。

CUDNN_FMA_MATH

仅限于仅使用 FMA 指令的内核。

在 NVIDIA A100 之前的 GPU 设备上，CUDNN_DEFAULT_MATH 和 CUDNN_FMA_MATH 具有相同的行为：不会选择 Tensor Core 内核。使用 NVIDIA Ampere 架构和 CUDA 工具包 11，CUDNN_DEFAULT_MATH 允许 TF32 Tensor Core 运算，而 CUDNN_FMA_MATH 不允许。CUDNN_DEFAULT_MATH 的 TF32 行为和其他 Tensor Core 数学类型可以通过环境变量 NVIDIA_TF32_OVERRIDE=0 显式禁用。

cudnnNanPropagation_t

此枚举类型已弃用，目前仅由已弃用的 API 使用。考虑使用替换已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnNanPropagation_t 是一种枚举类型，用于指示给定的例程是否应传播 Nan 数字。此枚举类型用作 cudnnActivationDescriptor_t 描述符和 cudnnPoolingDescriptor_t 描述符的字段。

值

CUDNN_NOT_PROPAGATE_NAN

不传播 NAN 数字。

CUDNN_PROPAGATE_NAN

传播 NAN 数字。

cudnnCTCGradMode_t

由 cudnnSetCTCLossDescriptor_v9 和 cudnnGetCTCLossDescriptor_v9 使用的枚举类型，用于指示边界外 (OOB) 样本的行为。OOB 样本是在梯度计算期间遇到 L+R > T 的样本。

• 如果 ctcGradMode 设置为 CUDNN_CTC_SKIP_OOB_GRADIENTS，则 CTC 损失函数不会写入该样本的梯度缓冲区。相反，保留当前值，即使不是有限值。

• 如果 ctcGradMode 设置为 CUDNN_CTC_ZERO_OOB_GRADIENTS，则该样本的梯度设置为零。这保证了有限梯度。

cudnnPaddingMode_t

cudnnPaddingMode_t 是一种枚举类型，用于指示后端重采样操作中的填充模式。

typedef enum {
    CUDNN_ZERO_PAD     = 0,
    CUDNN_NEG_INF_PAD  = 1,
    CUDNN_EDGE_VAL_PAD = 2,
} cudnnPaddingMode_t;

cudnnPointwiseMode_t

cudnnPointwiseMode_t 是一种枚举类型，用于指示后端逐点操作描述符中预期的逐点数学运算。

值

CUDNN_POINTWISE_ADD

计算两个张量之间的逐点加法。

CUDNN_POINTWISE_ADD_SQUARE

计算第一个张量和第二个张量的平方之间的逐点加法。

CUDNN_POINTWISE_DIV

计算第一个张量除以第二个张量的逐点真除法。

CUDNN_POINTWISE_MAX

在两个张量之间取逐点最大值。

CUDNN_POINTWISE_MIN

在两个张量之间取逐点最小值。

CUDNN_POINTWISE_MOD

计算第一个张量除以第二个张量的逐点浮点余数。

CUDNN_POINTWISE_MUL

计算两个张量之间的逐点乘法。

CUDNN_POINTWISE_POW

计算第一个张量的值的第二个张量次幂的逐点值。

CUDNN_POINTWISE_SUB

计算两个张量之间的逐点减法。

CUDNN_POINTWISE_ABS

计算输入张量的逐点绝对值。

CUDNN_POINTWISE_CEIL

计算输入张量的逐点上限值。

CUDNN_POINTWISE_COS

计算输入张量的逐点三角余弦值。

CUDNN_POINTWISE_EXP

计算输入张量的逐点指数值。

CUDNN_POINTWISE_FLOOR

计算输入张量的逐点下限值。

CUDNN_POINTWISE_LOG

计算输入张量的逐点自然对数值。

CUDNN_POINTWISE_NEG

计算输入张量的逐点数值负值。

CUDNN_POINTWISE_RSQRT

计算输入张量的平方根的逐点倒数值。

CUDNN_POINTWISE_SIN

计算输入张量的逐点三角正弦值。

CUDNN_POINTWISE_SQRT

计算输入张量的逐点平方根值。

CUDNN_POINTWISE_TAN

计算输入张量的逐点三角正切值。

CUDNN_POINTWISE_ERF

计算逐点误差函数。

CUDNN_POINTWISE_IDENTITY

不执行任何计算。与其他逐点模式一样，此模式通过将输入张量的数据类型指定为一种类型，并将输出张量的数据类型指定为另一种类型来提供隐式转换。

CUDNN_POINTWISE_RELU_FWD

计算输入张量的逐点修正线性激活函数。

CUDNN_POINTWISE_TANH_FWD

计算输入张量的逐点 tanh 激活函数。

CUDNN_POINTWISE_SIGMOID_FWD

计算输入张量的逐点 sigmoid 激活函数。

CUDNN_POINTWISE_ELU_FWD

计算输入张量的逐点指数线性单元激活函数。

CUDNN_POINTWISE_GELU_FWD

计算输入张量的逐点高斯误差线性单元激活函数。

CUDNN_POINTWISE_SOFTPLUS_FWD

计算输入张量的逐点 softplus 激活函数。

CUDNN_POINTWISE_SWISH_FWD

计算输入张量的逐点 swish 激活函数。

CUDNN_POINTWISE_GELU_APPROX_TANH_FWD

计算输入张量的高斯误差线性单元激活函数的逐点 tanh 近似值。tanh GELU 近似值计算为 \(0.5x\left( 1+\tanh\left[ \sqrt{2/\pi}\left( x+0.044715x^{3} \right) \right] \right)\)。有关更多信息，请参阅 高斯误差线性单元 (GELUS) 论文。

CUDNN_POINTWISE_RELU_BWD

计算输入张量的修正线性激活的逐点一阶导数。

CUDNN_POINTWISE_TANH_BWD

计算输入张量的 tanh 激活的逐点一阶导数。

CUDNN_POINTWISE_SIGMOID_BWD

计算输入张量的 sigmoid 激活的逐点一阶导数。

CUDNN_POINTWISE_ELU_BWD

计算输入张量的指数线性单元激活的逐点一阶导数。

CUDNN_POINTWISE_GELU_BWD

计算输入张量的高斯误差线性单元激活的逐点一阶导数。

CUDNN_POINTWISE_SOFTPLUS_BWD

计算输入张量的 softplus 激活的逐点一阶导数。

CUDNN_POINTWISE_SWISH_BWD

计算输入张量 swish 激活函数的逐点一阶导数。

CUDNN_POINTWISE_GELU_APPROX_TANH_BWD

计算输入张量高斯误差线性单元激活函数 tanh 近似值的逐点一阶导数。计算公式为 \(0.5\left( 1+\tanh\left( b\left( x+cx^{3} \right) \right)+bxsech^{2}\left( b\left( cx^{3}+x \right) \right)\left( 3cx^{2}+1 \right)dy \right)\)，其中 \(b\) 为 \(\sqrt{2/\pi}\)，\(c\) 为 \(0.044715\)。

CUDNN_POINTWISE_CMP_EQ

计算第一个张量等于第二个张量的逐点真值。

CUDNN_POINTWISE_CMP_NEQ

计算第一个张量不等于第二个张量的逐点真值。

CUDNN_POINTWISE_CMP_GT

计算第一个张量大于第二个张量的逐点真值。

CUDNN_POINTWISE_CMP_GE

计算第一个张量大于等于第二个张量的逐点真值。

CUDNN_POINTWISE_CMP_LT

计算第一个张量小于第二个张量的逐点真值。

CUDNN_POINTWISE_CMP_LE

计算第一个张量小于等于第二个张量的逐点真值。

CUDNN_POINTWISE_LOGICAL_AND

计算第一个张量逻辑 AND 第二个张量的逐点真值。

CUDNN_POINTWISE_LOGICAL_OR

计算第一个张量逻辑 OR 第二个张量的逐点真值。

CUDNN_POINTWISE_LOGICAL_NOT

计算输入张量逻辑 NOT 的逐点真值。

CUDNN_POINTWISE_GEN_INDEX

沿给定轴生成输入张量的逐点索引值。

CUDNN_POINTWISE_BINARY_SELECT

根据给定的谓词张量，从两个输入张量中选择一个逐点值。

CUDNN_POINTWISE_RECIPROCAL

计算输入张量的逐点倒数。换句话说，对于输入张量中的每个元素 x，计算 1/x。

cudnnReduceTensorOp_t

此枚举类型已弃用，目前仅由已弃用的 API 使用。考虑使用替换已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnReduceTensorOp_t 是一个枚举类型，用于指示 cudnnReduceTensor() 例程要使用的 Tensor Core 操作。此枚举类型用作 cudnnReduceTensorDescriptor_t 描述符的字段。

值

CUDNN_REDUCE_TENSOR_ADD

要执行的操作是加法。

CUDNN_REDUCE_TENSOR_MUL

要执行的操作是乘法。

CUDNN_REDUCE_TENSOR_MIN

要执行的操作是最小值比较。

CUDNN_REDUCE_TENSOR_MAX

要执行的操作是最大值比较。

CUDNN_REDUCE_TENSOR_AMAX

要执行的操作是绝对值的最大值比较。

CUDNN_REDUCE_TENSOR_AVG

要执行的操作是平均。

CUDNN_REDUCE_TENSOR_NORM1

要执行的操作是绝对值相加。

CUDNN_REDUCE_TENSOR_NORM2

要执行的操作是平方和的平方根。

CUDNN_REDUCE_TENSOR_MUL_NO_ZEROS

要执行的操作是乘法，不包括值为零的元素。

cudnnReorderType_t

此枚举类型已弃用，目前仅由已弃用的 API 使用。考虑使用替换已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnReorderType_t 是一个枚举类型，用于设置卷积重排序类型。重排序类型可以通过 cudnnSetConvolutionReorderType() 设置，其状态可以通过 cudnnGetConvolutionReorderType() 读取。

typedef enum {
    CUDNN_DEFAULT_REORDER = 0,
    CUDNN_NO_REORDER      = 1,
    } cudnnReorderType_t;

cudnnResampleMode_t

cudnnResampleMode_t 是一个枚举类型，用于指示后端重采样操作中的重采样模式。

typedef enum {
    CUDNN_RESAMPLE_NEAREST                 = 0,
    CUDNN_RESAMPLE_BILINEAR                = 1,
    CUDNN_RESAMPLE_AVGPOOL                 = 2,
    CUDNN_RESAMPLE_AVGPOOL_INCLUDE_PADDING = 2,
    CUDNN_RESAMPLE_AVGPOOL_EXCLUDE_PADDING = 4,
    CUDNN_RESAMPLE_MAXPOOL                 = 3,
} cudnnResampleMode_t;

cudnnRngDistribution_t

cudnnRngDistribution_t 是一个枚举类型，用于指示后端 Rng（随机数生成器）操作中要使用的分布。

typedef enum {
    CUDNN_RNG_DISTRIBUTION_BERNOULLI,
    CUDNN_RNG_DISTRIBUTION_UNIFORM,
    CUDNN_RNG_DISTRIBUTION_NORMAL,
} cudnnRngDistribution_t;

值

CUDNN_RNG_DISTRIBUTION_BERNOULLI

伯努利分布用于随机数生成。属性 CUDNN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY 可用于指定生成 1 的概率。

CUDNN_RNG_DISTRIBUTION_UNIFORM

均匀分布用于随机数生成。属性 CUDNN_ATTR_RNG_UNIFORM_DIST_MINIMUM 和 CUDNN_ATTR_RNG_UNIFORM_DIST_MAXIMUM 可用于指定随机数应均匀生成的最小值和最大值。

CUDNN_RNG_DISTRIBUTION_NORMAL

正态分布用于随机数生成。属性 CUDNN_ATTR_RNG_NORMAL_DIST_MEAN 和 CUDNN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION 可用于指定随机数生成器的均值和标准差。

cudnnSeverity_t

cudnnSeverity_t 是一个枚举类型，传递给用户可以设置的自定义回调函数以进行日志记录。此枚举描述了项目的严重性级别，因此自定义日志记录回调可能会做出不同的反应。数值与用于设置 CUDNN_LOGLEVEL_DBG 环境变量的值相同。

值

CUDNN_SEV_FATAL = 0

此值表示 cuDNN 发出的致命错误。

CUDNN_SEV_ERROR = 1

此值表示 cuDNN 发出的普通错误。

CUDNN_SEV_WARNING = 2

此值表示 cuDNN 发出的警告。

CUDNN_SEV_INFO = 3

此值表示 cuDNN 发出的一条信息（例如，API 日志）。

cudnnSignalMode_t

cudnnSignalMode_t 是一个枚举类型，用于指示后端信号操作中的信号模式。

typedef enum {
    CUDNN_SIGNAL_SET  = 0,
    CUDNN_SIGNAL_WAIT = 1,
} cudnnSignalMode_t;

值

CUDNN_SIGNAL_SET

标志变量使用提供的信号值原子地更新。

CUDNN_SIGNAL_WAIT

该操作会阻塞，直到标志变量保持与提供的信号值相等。

cudnnStatus_t

cudnnStatus_t 是一个枚举类型，用于函数状态返回。所有 cuDNN 库函数都返回其状态，可以是以下值之一

值

CUDNN_STATUS_SUCCESS

操作已成功完成。

CUDNN_STATUS_NOT_INITIALIZED

cuDNN 库未正确初始化。当调用 cudnnCreate() 失败或在调用另一个 cuDNN 例程之前未调用 cudnnCreate() 时，通常会返回此错误。在前一种情况下，通常是由于 cudnnCreate() 调用的 CUDA 运行时 API 中或硬件设置错误导致的错误。

CUDNN_STATUS_SUBLIBRARY_VERSION_MISMATCH

一些 cuDNN 子库具有不同的版本，表明存在安装问题。

CUDNN_STATUS_SERIALIZATION_VERSION_MISMATCH

用于序列化的架构不是当前 cuDNN 库期望的架构，因此序列化项目不再有效，需要重新序列化。

CUDNN_STATUS_DEPRECATED

此错误代码可能会在警告日志级别中报告，以提醒某些功能已弃用，并将在下一个主要版本更新中删除。

CUDNN_STATUS_LICENSE_ERROR

请求的功能需要某些许可证，并且在尝试检查当前许可时检测到错误。如果许可证不存在或已过期，或者环境变量 NVIDIA_LICENSE_FILE 未正确设置，则可能会发生此错误。

CUDNN_STATUS_RUNTIME_IN_PROGRESS

用户流中的某些任务尚未完成。

CUDNN_STATUS_RUNTIME_FP_OVERFLOW

GPU 内核执行期间发生数值溢出。

CUDNN_STATUS_BAD_PARAM

这是一个错误类别代码。不正确的值或参数已传递给函数。

CUDNN_STATUS_BAD_PARAM_NULL_POINTER

cuDNN API 意外地从用户处接收到空指针。

CUDNN_STATUS_BAD_PARAM_MISALIGNED_POINTER

cuDNN API 已从用户处收到未对齐的指针。

CUDNN_STATUS_BAD_PARAM_NOT_FINALIZED

后端描述符尚未最终确定。

CUDNN_STATUS_BAD_PARAM_OUT_OF_BOUND

cuDNN API 已收到超出范围的值。

CUDNN_STATUS_BAD_PARAM_SIZE_INSUFFICIENT

cuDNN API 已收到内存空间不足的内存缓冲区。

CUDNN_STATUS_BAD_PARAM_STREAM_MISMATCH

cuDNN API 已收到意外的流。

CUDNN_STATUS_BAD_PARAM_SHAPE_MISMATCH

cuDNN API 已收到不一致的张量形状。

CUDNN_STATUS_BAD_PARAM_DUPLICATED_ENTRIES

cuDNN API 已收到重复的条目。

CUDNN_STATUS_BAD_PARAM_ATTRIBUTE_TYPE

cuDNN API 已收到无效或不支持的属性类型。

CUDNN_STATUS_BAD_PARAM_CUDA_GRAPH_MISMATCH

cuDNN API 已收到意外的 CUDA 图。

CUDNN_STATUS_NOT_SUPPORTED

这是一个错误类别代码。cuDNN 当前不支持请求的功能。

CUDNN_STATUS_NOT_SUPPORTED_GRAPH_PATTERN

cuDNN 当前不支持这种操作图模式。

CUDNN_STATUS_NOT_SUPPORTED_SHAPE

cuDNN 当前不支持某些特定操作或图形模式中使用的张量形状。

CUDNN_STATUS_NOT_SUPPORTED_DATA_TYPE

cuDNN 当前不支持张量数据类型。

CUDNN_STATUS_NOT_SUPPORTED_LAYOUT

cuDNN 当前不支持张量布局。

CUDNN_STATUS_NOT_SUPPORTED_INCOMPATIBLE_CUDA_DRIVER

请求的功能与当前的 CUDA 驱动程序不兼容。

CUDNN_STATUS_NOT_SUPPORTED_INCOMPATIBLE_CUDART

请求的功能与当前的 CUDA 运行时不兼容。

CUDNN_STATUS_NOT_SUPPORTED_ARCH_MISMATCH

该函数需要当前 GPU 设备中没有的功能。

CUDNN_STATUS_NOT_SUPPORTED_RUNTIME_PREREQUISITE_MISSING

在预定义的搜索路径中找不到 cuDNN 所需的运行时库。这些库是 libcuda.so (nvcuda.dll) 和 libnvrtc.so (nvrtc64_<Major Release Version><Minor Release Version>_0.dll 和 nvrtc-builtins64_<Major Release Version><Minor Release Version>.dll)。

CUDNN_STATUS_NOT_SUPPORTED_SUBLIBRARY_UNAVAILABLE

由于缺少子库，请求的功能不可用。

CUDNN_STATUS_NOT_SUPPORTED_SHARED_MEMORY_INSUFFICIENT

由于 GPU 上共享内存大小不足，请求的功能不可用。

CUDNN_STATUS_NOT_SUPPORTED_PADDING

由于填充要求，请求的功能不可用。

CUDNN_STATUS_NOT_SUPPORTED_BAD_LAUNCH_PARAM

由于请求的功能会导致无效的内核启动参数，因此不可用。

CUDNN_STATUS_NOT_SUPPORTED_CUDA_GRAPH_NATIVE_API

请求的功能不可用，因为此特定引擎不支持原生 CUDA 图形 API。（支持该 API 的引擎具有行为注释 CUDNN_BEHAVIOR_NOTE_SUPPORTS_CUDA_GRAPH_NATIVE_API。）

CUDNN_STATUS_INTERNAL_ERROR

这是一个错误类别代码。内部 cuDNN 操作失败。

CUDNN_STATUS_INTERNAL_ERROR_COMPILATION_FAILED

运行时内核编译失败。

CUDNN_STATUS_INTERNAL_ERROR_UNEXPECTED_VALUE

检测到意外的内部不一致。

CUDNN_STATUS_INTERNAL_ERROR_HOST_ALLOCATION_FAILED

cuDNN 库内部的主机内存分配失败。

CUDNN_STATUS_INTERNAL_ERROR_DEVICE_ALLOCATION_FAILED

cuDNN 库内部的资源分配失败。

CUDNN_STATUS_INTERNAL_ERROR_BAD_LAUNCH_PARAM

意外检测到无效的内核启动参数。

CUDNN_STATUS_INTERNAL_ERROR_TEXTURE_CREATION_FAILED

访问 GPU 内存空间失败，这通常是由于纹理绑定失败引起的。要进行更正，请在函数调用之前取消绑定任何先前绑定的纹理。否则，这可能表明库中存在内部错误/bug。

CUDNN_STATUS_EXECUTION_FAILED

这是一个错误类别代码。GPU 程序执行失败。这通常是由于无法在 GPU 上启动内核引起的，这可能是由 cuDNN 依赖的其他库引起的。

CUDNN_STATUS_EXECUTION_FAILED_CUDA_DRIVER

由于 CUDA 驱动程序报告的错误，GPU 程序执行失败。

CUDNN_STATUS_EXECUTION_FAILED_CUBLAS

由于 cuBLAS 报告的错误，GPU 程序执行失败。

CUDNN_STATUS_EXECUTION_FAILED_CUDART

由于 CUDA 运行时报告的错误，GPU 程序执行失败。

CUDNN_STATUS_EXECUTION_FAILED_CURAND

由于 cuRAND 报告的错误，GPU 程序执行失败。

此外，以下宏可用于 cudnnStatus_t 错误代码。

CUDNN_STATUS_CATEGORY(full_error_code)

从 cudnnStatus_t 错误代码 full_error_code 中提取类别错误代码。这对于检查错误是否属于某个类别很有用。例如，CUDNN_STATUS_CATEGORY(CUDNN_STATUS_BAD_PARAM_NULL_POINTER) 将输出 CUDNN_STATUS_BAD_PARAM。

CUDNN_STATUS_SPECIFIC_ERROR(full_error_code)

从 cudnnStatus_t 错误代码 full_error_code 中提取特定错误代码，即删除类别。

CUDNN_STATUS_FULL_ERROR_CODE(category, specific_err)

将同一类别中的类别错误代码和特定代码重新组合成完整的 cudnnStatus_t 错误代码，使得对于任何有效的 cudnnStatus_t 错误代码，CUDNN_STATUS_FULL_ERROR_CODE(CUDNN_STATUS_CATEGORY(e), CUDNN_STATUS_SPECIFIC_ERROR(e)) == e。

cudnnTensorFormat_t

cudnnTensorFormat_t 是 cudnnSetTensor4dDescriptor() 使用的枚举类型，用于创建具有预定义布局的张量。有关这些张量在内存中如何排列的详细说明，请参阅 数据布局格式。

值

CUDNN_TENSOR_NCHW

此张量格式指定数据按以下顺序布局：批大小、特征图、行、列。步幅以隐式方式定义，以便数据在内存中是连续的，图像、特征图、行和列之间没有填充；列是内部维度，图像是最外层维度。

CUDNN_TENSOR_NHWC

此张量格式指定数据按以下顺序布局：批大小、行、列、特征图。步幅以隐式方式定义，以便数据在内存中是连续的，图像、行、列和特征图之间没有填充；特征图是内部维度，图像是最外层维度。

CUDNN_TENSOR_NCHW_VECT_C

此张量格式指定数据按以下顺序布局：批大小、特征图、行、列。但是，张量的每个元素都是多个特征图的向量。向量的长度由张量的数据类型决定。步幅以隐式方式定义，以便数据在内存中是连续的，图像、特征图、行和列之间没有填充；列是内部维度，图像是最外层维度。此格式仅支持张量数据类型 CUDNN_DATA_INT8x4、CUDNN_DATA_INT8x32 和 CUDNN_DATA_UINT8x4。

CUDNN_TENSOR_NCHW_VECT_C 也可以通过以下方式解释：NCHW INT8x32 格式实际上是 N x (C/32) x H x W x 32（每个 W 有 32 个 C），正如 NCHW INT8x4 格式是 N x (C/4) x H x W x 4（每个 W 有 4 个 C）一样。因此，VECT_C 名称 - 每个 W 都是 C 的向量（4 或 32）。

未分类

这些是在 cudnn_graph 库中找到的未分类引用。

cudnnBackendDescriptor_t

cudnnBackendDescriptor_t 是一个 typedef void 指针，指向许多不透明的 descriptor 结构之一。它指向的结构类型由使用 cudnnBackendCreateDescriptor() 为不透明结构分配内存时的参数确定。

可以使用 cudnnBackendSetAttribute() 设置 descriptor 的属性。在设置 descriptor 的所有必需属性后，可以通过 cudnnBackendFinalize() 最终确定 descriptor。从最终确定的 descriptor，可以使用 cudnnBackendGetAttribute() 查询其可查询属性。最后，可以使用 cudnnBackendDestroyDescriptor() 释放为 descriptor 分配的内存。

API 函数

这些是 cudnn_graph 库中的 API 函数。

cudnnBackendPopulateCudaGraph()

此方法是新的 原生 CUDA 图形 API 的一部分，直接构建表示给定引擎的 CUDA 图（不要与 cuDNN 图混淆）。当调用者实例化并执行此 CUDA 图时，该图将在 VariantPack 上执行引擎配置计划，并在数据上执行最终确定的 ExecutionPlan。

生成的 CUDA 图捕获调用此 API 时 VariantPack 中的指针（数据和工作空间），但可以使用相同指针处的不同数据任意多次运行它。该图也可以稍后通过使用 cudnnBackendUpdateCudaGraph() 使用不同的 VariantPack 指针就地修改。

传递给此 API 的初始 CUDA 图必须为空（没有节点），并且调用者不应将其他节点附加到生成的图中。但是，该图可以嵌入为更大的 CUDA 图的子节点，例如，通过 cudaGraphAddChildGraphNode。（这是典型的用法。）

目前只有有限数量的引擎支持此 API（在 cuDNN 的未来版本中将添加更多）。那些支持它的引擎具有行为注释 CUDNN_BEHAVIOR_NOTE_SUPPORTS_CUDA_GRAPH_NATIVE_API。

注意

此 API 仅在针对 CUDA 运行时 12.x 及更高版本编译的 cuDNN 版本中受支持。

cudnnStatus_t cudnnBackendPopulateCudaGraph(cudnnHandle_t handle, cudnnBackendDescriptor_t executionPlan, cudnnBackendDescriptor_t variantPack, cudaGraph_t cudaGraph)

参数

executionPlan

输入。指向最终确定的 ExecutionPlan 的指针。

variantPack

输入。指向最终确定的 VariantPack 的指针，VariantPack 由以下内容组成：

• 执行计划中操作集中每个非虚拟指针的数据指针。

• 指向用户分配的全局内存工作区的指针，该工作区至少与从 CUDNN_BACKEND_ 查询的大小一样大。

cudaGraph

输入/输出。CUDA 图句柄，表示要由 API 填充的已创建的空 CUDA 图。

返回值

CUDNN_STATUS_SUCCESS

CUDA 图已成功生成。

CUDNN_STATUS_BAD_PARAM

遇到不正确或不一致的值。例如，所需的数据指针无效，或者给定的 cudaGraph 最初不是空的。

CUDNN_STATUS_INTERNAL_ERROR

遇到一些内部错误。

CUDNN_STATUS_EXECUTION_FAILED

为具有变体包的计划创建 CUDA 图时遇到错误。

CUDNN_STATUS_NOT_SUPPORTED_CUDA_GRAPH_NATIVE_API

此特定引擎不支持原生 CUDA 图形 API。

CUDNN_STATUS_NOT_SUPPORTED_INCOMPATIBLE_CUDART

此 cuDNN 是针对低于 12.0 的 CUDA 运行时构建的，并且不支持原生 CUDA 图形 API。

cudnnBackendCreateDescriptor()

此函数在 descriptor 中为给定的 descriptor 类型和 descriptor 指向的位置分配内存。

cudnnStatus_t cudnnBackendCreateDescriptor(cudnnBackendDescriptorType_t descriptorType, cudnnBackendDescriptor_t *descriptor)

注意

cudnnBackendDescriptor_t 是指向 void * 的指针。

参数

descriptorType

输入。cudnnBackendDescriptorType_t 枚举类型之一。

descriptor

输入。指向要创建的 cudnnBackendDescriptor_t 实例的指针。

返回值

CUDNN_STATUS_SUCCESS

创建成功。

CUDNN_STATUS_NOT_SUPPORTED

不支持创建给定类型的描述符。

CUDNN_STATUS_ALLOC_FAILED

内存分配失败。

cudnnBackendDestroyDescriptor()

此函数销毁先前使用 cudnnBackendCreateDescriptor() 创建的 cudnnBackendDescriptor_t 实例。

cudnnStatus_t cudnnBackendDestroyDescriptor(cudnnBackendDescriptor_t descriptor)

参数

descriptor

输入。先前由 cudnnBackendCreateDescriptor() 创建的 cudnnBackendDescriptor_t 实例。

返回值

CUDNN_STATUS_SUCCESS

内存已成功销毁。

CUDNN_STATUS_ALLOC_FAILED

内存销毁失败。

未定义的 行为

descriptor 在 Create 和 Destroy Descriptor 之间被更改。

未定义

在内存释放完成后，descriptor 指向的值将为 Undefined。

cudnnBackendExecute()

此函数在 VariantPack 和数据上最终确定的 ExecutionPlan 上执行给定的 Engine Configuration Plan。数据和工作空间封装在 VariantPack 中。

cudnnStatus_t cudnnBackendExecute(cudnnHandle_t handle, cudnnBackendDescriptor_t executionPlan, cudnnBackendDescriptor_t varianPack)

参数

executionPlan

输入。指向最终确定的 ExecutionPlan 的指针。

variantPack

输入。指向最终确定的 VariantPack 的指针，VariantPack 由以下内容组成：

• 执行计划中操作集中每个非虚拟指针的数据指针。

• 指向用户分配的全局内存工作区的指针，该工作区至少与从 CUDNN_BACKEND_ 查询的大小一样大。

返回值

CUDNN_STATUS_SUCCESS

ExecutionPlan 已成功执行。

CUDNN_STATUS_BAD_PARAM

遇到不正确或不一致的值。例如，所需的数据指针无效。

CUDNN_STATUS_INTERNAL_ERROR

遇到一些内部错误。

CUDNN_STATUS_EXECUTION_FAILED

使用变体包执行计划时遇到错误。

cudnnBackendFinalize()

此函数最终确定 descriptor 指向的内存。最终确定的类型取决于使用 cudnnBackendCreateDescriptor() 创建或使用 cudnnBackendInitialize() 初始化的 descriptorType 参数。

cudnnStatus_t cudnnBackendFinalize(cudnnBackendDescriptor descriptor)

cudnnBackendFinalize() 还会检查在创建/初始化和最终确定阶段之间设置的所有属性。如果成功，cudnnBackendFinalize() 将返回 CUDNN_STATUS_SUCCESS，并且 descriptor 的最终确定状态设置为 true。在此状态下，不允许使用 cudnnBackendSetAttribute() 设置属性。仅当 descriptor 的最终确定状态为 true 时，才允许使用 cudnnBackendGetAttribute() 获取属性。

参数

descriptor

输入。要最终确定的 cudnnBackendDescriptor_t 实例。

返回值

CUDNN_STATUS_SUCCESS

descriptor 已成功最终确定。

CUDNN_STATUS_BAD_PARAM

遇到无效的 descriptor 属性值或其组合。

CUDNN_STATUS_NOT_SUPPORTED

遇到当前 cuDNN 版本不支持的描述符属性值或组合。

CUDNN_STATUS_INTERNAL_ERROR

遇到一些内部错误。

cudnnBackendGetAttribute()

此函数检索 descriptor 的属性值。attributeName 是请求其值的属性的名称。attributeType 是属性的类型。requestsedElementCount 是要潜在检索的元素数。请求属性的元素数存储在 elementCount 中。检索到的值存储在 arrayOfElements 中。当属性预期具有单个值时，arrayOfElements 可以是指向输出值的指针。如果描述符未使用 cudnnBackendFinalize() 成功最终确定，则此函数将返回 CUDNN_STATUS_NOT_INTIALIZED。

cudnnStatus_t cudnnBackendGetAttribute(
    cudnnBackendDescriptor_t descriptor,
    cudnnBackendAttributeName_t attributeName,
    cudnnBackendAttributeType_t attributeType,
    int64_t requestedElementCount,
    int64_t *elementCount,
    void *arrayOfElements);

参数

descriptor

输入。cudnnBackendDescriptor_t 的实例，用户想要检索其属性。

attributeName

输入。要从 descriptor 获取的属性的名称。

attributeType

输入。属性的类型。

requestedElementCount

输入。要输出到 arrayOfElements 的元素数。

elementCount

输入。descriptor 属性具有的元素数的输出指针。请注意，cudnnBackendGetAttribute() 将仅将此值和 requestedElementCount 中的最小值个元素写入 arrayOfElements。

arrayOfElements

输入。attributeType 数据类型的元素数组。attributeType 的数据类型在 cudnnBackendAttributeType_t 的映射表中列出。

返回值

CUDNN_STATUS_SUCCESS

attributeName 已成功赋予 descriptor。

CUDNN_STATUS_BAD_PARAM

遇到一个或多个无效或不一致的参数值。一些示例包括：

• attributeName 不是描述符的有效属性。

• attributeType 不是属性的有效类型之一。

CUDNN_STATUS_NOT_INITIALIZED

descriptor 未使用 cudnnBackendFinalize() 成功最终确定。

cudnnBackendInitialize()

此函数已在 cuDNN 9.2 中弃用。

此函数将 descriptor 指向的大小为 sizeInByte 的预分配内存重新用于 descriptorType 类型的后端 descriptor。descriptor 的最终确定状态设置为 false。

cudnnStatus_t cudnnBackendInitialize(cudnnBackendDescriptor_t descriptor, cudnnBackendDescriptorType_t descriptorType, size_t sizeInBytes)

参数

descriptor

输入。要初始化的 cudnnBackendDescriptor_t 实例。

descriptorType

输入。cuDNN 后端 descriptor 类型的枚举值。

sizeInBytes

输入。descriptor 指向的内存大小。

返回值

CUDNN_STATUS_SUCCESS

内存已成功初始化。

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的参数值。一些示例包括：

• descriptor 是 nullptr

• sizeInBytes 小于 descriptor 类型所需的大小

cudnnBackendSetAttribute()

此函数将 descriptor 的属性设置为作为指针提供的值。descriptor 是要设置的 descriptor。attributeName 是要设置的属性的名称。attributeType 是属性的类型。属性要设置的值由 arrayOfElements 指向。元素的数量由 elementCount 给出。如果 descriptor 已使用 cudnnBackendFinalize() 成功最终确定，则此函数将返回 CUDNN_STATUS_NOT_INTIALIZED。

cudnnStatus_t cudnnBackendSetAttribute(
    cudnnBackendDescriptor_t descriptor,
    cudnnBackendAttributeName_t attributeName,
    cudnnBackendAttributeType_t attributeType,
    int64_t elementCount,
    void *arrayOfElements);

参数

descriptor

输入。 cudnnBackendDescriptor_t 的实例，其属性正在被设置。

attributeName

输入。 要在 descriptor 上设置的属性的名称。

attributeType

输入。属性的类型。

elementCount

输入。 要设置的元素的数量。

arrayOfElements

输入。 从中读取值的数组的起始位置。 数组的元素应为 attributeType 的数据类型。attributeType 的数据类型在 cudnnBackendAttributeType_t 的映射表中列出。

返回值

CUDNN_STATUS_SUCCESS

attributeName 已设置为 descriptor。

CUDNN_STATUS_NOT_INITIALIZED

由 descriptor 指向的后端 descriptor 已处于最终确定状态。

CUDNN_STATUS_BAD_PARAM

该函数使用与无效值对应的参数调用。 一些示例包括

• attributeName 不是 descriptor 的可设置属性。

• attributeType 对于此 attributeName 不正确。

• elemCount 值是意外的。

• arrayOfElements 包含对于 attributeType 无效的值。

CUDNN_STATUS_NOT_SUPPORTED

cuDNN 的当前版本不支持要将属性设置为的值。

cudnnBackendUpdateCudaGraph()

此方法是新的 Native CUDA Graph API 的一部分，使用新的 variantPack 更新先前由 cudnnBackendPopulateCudaGraph()（或其克隆）填充的现有 CUDA 图。

目前只有有限数量的引擎支持此 API（在 cuDNN 的未来版本中将添加更多）。那些支持它的引擎具有行为注释 CUDNN_BEHAVIOR_NOTE_SUPPORTS_CUDA_GRAPH_NATIVE_API。

注意

此 API 仅在针对 CUDA 运行时 12.x 及更高版本编译的 cuDNN 版本中受支持。

cudnnStatus_t cudnnBackendUpdateCudaGraph(cudnnHandle_t handle, cudnnBackendDescriptor_t executionPlan, cudnnBackendDescriptor_t variantPack, cudaGraph_t cudaGraph)

参数

executionPlan

输入。 指向已最终确定的 ExecutionPlan 的指针。 这必须与最初传递给 cudnnBackendPopulateCudaGraph() 的 ExecutionPlan 匹配。

variantPack

输入。 指向已最终确定的 VariantPack 的指针，该指针包含以下指针，这些指针替换 CUDA 图中捕获的 VariantPack 指针

• 执行计划中操作集中每个非虚拟指针的数据指针。

• 指向用户分配的全局内存工作区的指针，该工作区至少与从 CUDNN_BACKEND_ 查询的大小一样大。

cudaGraph

输入。 指向现有 CUDA 图句柄的指针。 此图必须已由 cudnnBackendPopulateCudaGraph() 填充，或为其克隆（例如，由 cudaGraphClone 创建，或通过使用 cudaGraphAddChildGraphNode 嵌入到更大的图中）。

返回值

CUDNN_STATUS_SUCCESS

CUDA 图已成功更新。

CUDNN_STATUS_BAD_PARAM

遇到不正确或不一致的值。例如，所需的数据指针无效。

CUDNN_STATUS_BAD_PARAM_CUDA_GRAPH_MISMATCH

对于此执行计划，CUDA 图似乎不是由 cudnnBackendPopulateCudaGraph()（或其克隆）填充的，或者包含意外的附加节点。

CUDNN_STATUS_INTERNAL_ERROR

遇到一些内部错误。

CUDNN_STATUS_EXECUTION_FAILED

更新具有变体包的计划的 CUDA 图时遇到错误。

CUDNN_STATUS_NOT_SUPPORTED_CUDA_GRAPH_NATIVE_API

此特定引擎不支持原生 CUDA 图形 API。

CUDNN_STATUS_NOT_SUPPORTED_INCOMPATIBLE_CUDART

此 cuDNN 是针对低于 12.0 的 CUDA 运行时构建的，并且不支持原生 CUDA 图形 API。

cudnnCreate()

此函数初始化 cuDNN 库并创建一个句柄，指向保存 cuDNN 库上下文的不透明结构。 它在主机和设备上分配硬件资源，并且必须在进行任何其他 cuDNN 库调用之前调用。

cudnnStatus_t cudnnCreate(cudnnHandle_t *handle)

cuDNN 库句柄绑定到当前的 CUDA 设备（上下文）。 要在多个设备上使用该库，需要为每个设备创建一个 cuDNN 句柄。

对于给定的设备，可以创建具有不同配置（例如，不同的当前 CUDA 流）的多个 cuDNN 句柄。 由于 cudnnCreate() 分配了一些内部资源，因此通过调用 cudnnDestroy() 释放这些资源将隐式调用 cudaDeviceSynchronize； 因此，建议的最佳实践是在性能关键代码路径之外调用 cudnnCreate() 或 cudnnDestroy()。

对于从不同线程使用同一设备的多线程应用程序，推荐的编程模型是为每个线程创建一个（或几个，根据方便程度）cuDNN 句柄，并在线程的整个生命周期中使用该 cuDNN 句柄。

参数

handle

输出。 指向指针的指针，用于存储已分配的 cuDNN 句柄的地址。 有关更多信息，请参阅 cudnnHandle_t。

返回值

CUDNN_STATUS_BAD_PARAM

提供了无效 (NULL) 输入指针。

CUDNN_STATUS_NOT_INITIALIZED

未找到兼容的 GPU，未安装或禁用 CUDA 驱动程序，CUDA 运行时 API 初始化失败。

CUDNN_STATUS_ARCH_MISMATCH

NVIDIA GPU 架构太旧。

CUDNN_STATUS_ALLOC_FAILED

主机内存分配失败。

CUDNN_STATUS_INTERNAL_ERROR

CUDA 资源分配失败。

CUDNN_STATUS_LICENSE_ERROR

cuDNN 许可证验证失败（仅当启用该功能时）。

CUDNN_STATUS_SUCCESS

cuDNN 句柄已成功创建。

cudnnDestroy()

此函数释放 cuDNN 句柄使用的资源。 此函数通常是使用特定句柄对 cuDNN 进行的最后一次调用。 由于 cudnnCreate() 分配内部资源，因此通过调用 cudnnDestroy() 释放这些资源将隐式调用 cudaDeviceSynchronize； 因此，建议的最佳实践是在性能关键代码路径之外调用 cudnnCreate() 或 cudnnDestroy()。

cudnnStatus_t cudnnDestroy(cudnnHandle_t handle)

参数

handle

输入。 要销毁的 cuDNN 句柄。

返回值

CUDNN_STATUS_SUCCESS

cuDNN 上下文销毁成功。

cudnnGetCallback()

此函数查询 cuDNN 错误报告功能的内部状态。

cudnnStatus_t cudnnGetCallback(
        unsigned            mask,
        void                **udata,
        cudnnCallback_t     fptr)

参数

mask

输出。 指向地址的指针，当前内部错误报告消息位掩码将在该地址输出。

udata

输出。 指向地址的指针，当前内部存储的 udata 地址将在该地址存储。

fptr

输出。 指向地址的指针，当前内部存储的 callback 函数指针将在该地址存储。 当使用内置默认回调函数时，将输出 NULL。

返回值

CUDNN_STATUS_SUCCESS

函数启动成功。

CUDNN_STATUS_BAD_PARAM

如果任何输入参数为 NULL。

cudnnGetCudartVersion()

给定 cuDNN 库的相同版本可以针对不同的 CUDA 工具包版本进行编译。 此例程返回当前使用的 cuDNN 库已针对其编译的 CUDA 工具包版本。

size_t cudnnGetCudartVersion()

cudnnGetErrorString()

此函数将 cuDNN 状态代码转换为以 NULL 结尾的 (ASCIIZ) 静态字符串。 例如，当输入参数为 CUDNN_STATUS_SUCCESS 时，返回的字符串为 CUDNN_STATUS_SUCCESS。 当将无效状态值传递给函数时，返回的字符串为 CUDNN_UNKNOWN_STATUS。

const char * cudnnGetErrorString(cudnnStatus_t status)

参数

status

输入。 cuDNN 枚举状态代码。

返回值

指向具有状态名称的静态、以 NULL 结尾的字符串的指针。

cudnnGetLastErrorString()

此函数检索当前线程中上次遇到的 cuDNN 错误消息，并将其转换为以 NULL 结尾的 (ASCIIZ) 字符串。 在 cuDNN 库内部，消息存储在线程局部缓冲区中。 用户调用此 API 检索错误后，错误将被清除。

void cudnnGetLastErrorString(char *message, size_t max_size);

参数

message

输出。 指向可以存储错误消息的字符缓冲区的指针。 由于我们不管理预分配的输出缓冲区“message”的线程安全性以避免不必要的开销，因此我们要求用户根据自己的需要确保其线程安全。

max_size

输入。 可以存储在 message 指向的位置的最大大小。 输出严格受大小限制 max_size 限制，也包括终止符字符 \0，如果存在空间，将自动将其附加到消息中。

cudnnGetMaxDeviceVersion()

此函数返回 cuDNN 库已知并原生支持的最大 SM 版本。 任何高于此值的 SM 版本都将在向前兼容模式下受支持。 有关向前兼容性的更多信息，请参阅 cuDNN 开发者指南。

size_t cudnnGetMaxDeviceVersion(void);

返回值

一个 size_t 类型的值，指示库的当前版本的最新已知 SM 编号。 例如，如果 NVIDIA Hopper (GH100) 是库已知的最新 SM，则返回的值将为 900。

cudnnGetProperty()

此函数将 cuDNN 库版本号的特定部分写入提供的宿主存储。

cudnnStatus_t cudnnGetProperty(
    libraryPropertyType     type,
    int                    *value)

参数

type

输入。 枚举类型，指示函数报告 cuDNN 主版本、次版本或补丁级别的数值，具体取决于 type 是否设置为 MAJOR_VERSION、MINOR_VERSION 或 PATCH_LEVEL。

value

输出。 版本信息应写入的宿主指针。

返回值

CUDNN_STATUS_INVALID_VALUE

type 参数的无效值。

CUDNN_STATUS_SUCCESS

版本信息已成功存储在提供的地址。

cudnnGetStream()

此函数检索在 cuDNN 句柄中编程的用户 CUDA 流。 当用户的 CUDA 流未在 cuDNN 句柄中设置时，此函数报告空流。

cudnnStatus_t cudnnGetStream(
    cudnnHandle_t   handle,
    cudaStream_t   *streamId)

参数

handle

输入。 指向 cuDNN 句柄的指针。

streamID

输出。 应该存储 cuDNN 句柄中的当前 CUDA 流的指针。

返回值

CUDNN_STATUS_BAD_PARAM

无效 (NULL) 句柄。

CUDNN_STATUS_SUCCESS

流标识符已成功检索。

cudnnGetVersion()

此函数返回 cuDNN 库的版本号。 它返回 cudnn.h 头文件中定义的 CUDNN_VERSION。 从 R2 版本开始，该例程可用于动态识别应用程序使用的当前 cuDNN 库。 定义的 CUDNN_VERSION 可用于使同一应用程序链接到使用条件编译语句的不同 cuDNN 版本。

size_t cudnnGetVersion()

cudnnGraphVersionCheck()

跨库版本检查器。 每个子库都有一个版本检查器，用于检查其自身的版本是否与其依赖项的版本匹配。

cudnnStatus_t cudnnGraphVersionCheck(void);

返回值

CUDNN_STATUS_SUCCESS

版本检查通过。

CUDNN_STATUS_SUBLIBRARY_VERSION_MISMATCH

版本不一致。

cudnnQueryRuntimeError()

cuDNN 库函数在启动 GPU 内核之前执行广泛的输入参数检查。 最后一步是验证 GPU 内核是否实际启动。 当内核启动失败时，相应的 API 调用将返回 CUDNN_STATUS_EXECUTION_FAILED。 通常，在 GPU 内核启动后，内核本身不会执行运行时检查 - 数值结果只是写入输出缓冲区。

cudnnStatus_t cudnnQueryRuntimeError(
    cudnnHandle_t            handle,
    cudnnStatus_t           *rstatus,
    cudnnErrQueryMode_t      mode)

当在 cudnnBatchNormalizationForwardTraining() 或 cudnnBatchNormalizationBackward() 中选择 CUDNN_BATCHNORM_SPATIAL_PERSISTENT 模式时，该算法可能会遇到数值溢出，而 CUDNN_BATCHNORM_SPATIAL 模式可以正常运行，尽管速度较慢。 用户可以调用 cudnnQueryRuntimeError() 以确保内核执行期间未发生数值溢出。 这些问题由执行计算的内核报告。

cudnnQueryRuntimeError() 可用于轮询和阻塞软件控制流。 有两种轮询模式 (CUDNN_ERRQUERY_RAWCODE 和 CUDNN_ERRQUERY_NONBLOCKING) 和一种阻塞模式 CUDNN_ERRQUERY_BLOCKING。

CUDNN_ERRQUERY_RAWCODE 读取错误存储位置，而与内核完成状态无关。 内核甚至可能未启动，并且错误存储（每个 cuDNN 句柄分配）可能已被较早的调用使用。

CUDNN_ERRQUERY_NONBLOCKING 检查用户流中的所有任务是否已完成。 如果用户流中的某些任务正在等待，则 cudnnQueryRuntimeError() 函数将立即返回并在 rstatus 中报告 CUDNN_STATUS_RUNTIME_IN_PROGRESS。 否则，该函数会将远程内核错误代码复制到 rstatus。

在阻塞模式 (CUDNN_ERRQUERY_BLOCKING) 中，该函数等待用户流中的所有任务耗尽，然后报告远程内核错误代码。 可以通过使用 cudaDeviceScheduleSpin、cudaDeviceScheduleYield 或 cudaDeviceScheduleBlockingSync 标志调用 cudaSetDeviceFlags 来进一步调整阻塞模式。

当在 cuDNN 句柄中更改用户流时，不应使用 CUDNN_ERRQUERY_NONBLOCKING 和 CUDNN_ERRQUERY_BLOCKING 模式，这意味着在报告运行时内核错误的函数与 cudnnQueryRuntimeError() 函数之间调用了 cudnnSetStream()。

在 rstatus 中报告的远程错误状态可以设置为：CUDNN_STATUS_SUCCESS、CUDNN_STATUS_RUNTIME_IN_PROGRESS 或 CUDNN_STATUS_RUNTIME_FP_OVERFLOW。 远程内核错误由 cudnnQueryRuntimeError() 自动清除。

当 cudnnBatchNormMode_t 参数为 CUDNN_BATCHNORM_SPATIAL_PERSISTENT 时，cudnnQueryRuntimeError() 函数应与 cudnnBatchNormalizationForwardTraining() 和 cudnnBatchNormalizationBackward() 结合使用。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

rstatus

输出。 指向用户的错误代码存储的指针。

mode

输入。 远程错误查询模式。

tag

输入/输出。 目前，此参数应为 NULL。

返回值

CUDNN_STATUS_SUCCESS

未检测到错误 (rstatus 包含有效值)。

CUDNN_STATUS_BAD_PARAM

无效的输入参数。

CUDNN_STATUS_INTERNAL_ERROR

流阻塞同步或非阻塞流查询失败。

CUDNN_STATUS_MAPPING_ERROR

设备无法访问零复制内存来报告内核错误。

cudnnSetCallback()

此函数设置 cuDNN 错误报告功能的内部状态。

cudnnStatus_t cudnnSetCallback(
        unsigned            mask,
        void                *udata,
        cudnnCallback_t     fptr)

参数

mask

输入。 一个无符号整数。 此无符号整数的四个最低有效位 (LSB) 用于打开和关闭不同级别的错误报告消息。 这适用于默认回调和自定义回调。 位位置与 cudnnSeverity_t 的枚举相对应。 用户可以利用预定义的宏 CUDNN_SEV_ERROR_EN、CUDNN_SEV_WARNING_EN 和 CUDNN_SEV_INFO_EN 来形成位掩码。 当位设置为 1 时，将启用相应的消息通道。

例如，当位 3 设置为 1 时，将启用 API 日志记录。 目前，只有 CUDNN_SEV_INFO 级别的日志输出是功能性的； 其他级别尚未实现。 当用于使用默认回调打开和关闭日志记录时，用户可以将 NULL 传递给 udata 和 fptr。 此外，必须设置环境变量 CUDNN_LOGDEST_DBG。 有关更多信息，请参阅 弃用策略。

CUDNN_SEV_INFO_EN = 0b1000 (功能性)。

CUDNN_SEV_ERROR_EN = 0b0010 (功能性)。

CUDNN_SEV_WARNING_EN = 0b0100 (功能性)。

CUDNN_SEV_FATAL 的输出始终启用，无法禁用。

udata

输入。 用户提供的指针。 此指针将传递给用户的自定义日志记录回调函数。 cuDNN 不会读取或更改它指向的数据。 此指针可以以多种方式使用，例如在互斥锁中或在通信套接字中，用于用户的日志记录回调函数。 如果用户正在使用默认回调函数，或者不想在自定义回调函数中使用此输入，则可以传入 NULL。

fptr

输入。 指向用户提供的回调函数的指针。 当将 NULL 传递给此指针时，cuDNN 将切换回内置的默认回调函数。 用户提供的回调函数原型必须类似于以下内容（也在头文件中定义）

void customizedLoggingCallback (cudnnSeverity_t sev, void *udata, const cudnnDebug_t *dbg, const char *msg);

结构 cudnnDebug_t 在头文件中定义。 它提供了元数据，例如时间、自启动以来的时间、流 ID、进程和线程 ID，用户可以选择在自定义回调中打印或存储这些元数据。

变量 msg 是 cuDNN 生成的日志消息。 此消息的每一行都以 \0 结尾，消息的末尾以 \0\0 结尾。 用户可以选择在日志中显示什么，并可以重新格式化字符串。

返回值

CUDNN_STATUS_SUCCESS

函数启动成功。

cudnnSetStream()

此函数在 cuDNN 句柄中设置用户的 CUDA 流。 新流将用于启动 cuDNN GPU 内核，或者当 cuDNN 内核在内部流中启动时，同步到此流。 如果未设置 cuDNN 库流，则所有内核都使用默认 (NULL) 流。 在 cuDNN 句柄中设置用户流可保证 cuDNN 调用和在同一流中启动的其他 GPU 内核的按顺序执行。

cudnnStatus_t cudnnSetStream(
    cudnnHandle_t   handle,
    cudaStream_t    streamId)

对于 CUDA 11.x 或更高版本，内部流的优先级与上次调用此函数设置的流的优先级相同。 在 CUDA 图捕获模式下，需要 CUDA 11.8 或更高版本才能使流优先级匹配。

参数

handle

输入。 指向 cuDNN 句柄的指针。

streamID

输入。 要写入 cuDNN 句柄的新 CUDA 流。

返回值

CUDNN_STATUS_BAD_PARAM

无效 (NULL) 句柄。

CUDNN_STATUS_BAD_PARAM_STREAM_MISMATCH

用户流和 cuDNN 句柄上下文之间不匹配。

CUDNN_STATUS_NOT_SUPPORTED

流优先级超出范围。

CUDNN_STATUS_INTERNAL_ERROR

CUDA 流 API 报告 cuDNN 内部的更多错误。

CUDNN_STATUS_SUCCESS

新流已成功设置。

后端描述符类型

本节枚举了各种描述符的所有有效属性。

CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR, &desc) 创建； cuDNN 后端卷积描述符指定前向和后向传播的卷积运算符的参数：计算数据类型、卷积模式、滤波器膨胀和步幅以及两侧的填充。

属性

cuDNN 后端卷积描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，前缀为 CUDNN_ATTR_CONVOLUTION_

CUDNN_ATTR_CONVOLUTION_COMP_TYPE

卷积运算符的计算类型。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 必需属性。

CUDNN_ATTR_CONVOLUTION_MODE

卷积或互相关模式。

• CUDNN_TYPE_CONVOLUTION_MODE； 一个元素。

• 必需属性。

CUDNN_ATTR_CONVOLUTION_SPATIAL_DIMS

空间维度的数量，膨胀、滤波器步幅和填充数组的预期数组长度。

• CUDNN_TYPE_INT64； 一个元素。

• 必需属性。

CUDNN_ATTR_CONVOLUTION_DILATIONS

滤波器膨胀。

• CUDNN_TYPE_INT64； 一个或多个，但最多 CUDNN_MAX_DIMS 个元素。

• 必需属性。

CUDNN_ATTR_CONVOLUTION_FILTER_STRIDES

滤波器步幅。

• CUDNN_TYPE_INT64； 一个或多个，但最多 CUDNN_MAX_DIMS 个元素。

• 必需属性。

CUDNN_ATTR_CONVOLUTION_PRE_PADDINGS

每个空间维度开始处的填充。

• CUDNN_TYPE_INT64； 一个或多个，但最多 CUDNN_MAX_DIMS 个元素。

• 必需属性。

CUDNN_ATTR_CONVOLUTION_POST_PADDINGS

每个空间维度结尾处的填充。

• CUDNN_TYPE_INT64； 一个或多个，但最多 CUDNN_MAX_DIMS 个元素。

• 必需属性。

最终确定

使用 CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR 的 cudnnBackendFinalize() 可以具有以下返回值

CUDNN_STATUS_BAD_PARAM

用于设置 CUDNN_ATTR_CONVOLUTION_DILATIONS、CUDNN_ATTR_CONVOLUTION_FILTER_STRIDES、CUDNN_ATTR_CONVOLUTION_PRE_PADDINGS 和 CUDNN_ATTR_CONVOLUTION_POST_PADDINGS 的 elemCount 参数不等于为 CUDNN_ATTR_CONVOLUTION_SPATIAL_DIMS 设置的值。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_ENGINE_DESCRIPTOR

使用描述符类型值 CUDNN_BACKEND_ENGINE_DESCRIPTOR 创建，cuDNN 后端引擎描述符描述用于计算操作图的引擎。 引擎是具有相似计算和数值属性的内核的分组。

属性

cuDNN 后端卷积描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_ENGINE_

CUDNN_ATTR_ENGINE_OPERATION_GRAPH

要计算的操作图。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_OPERATIONGRAPH_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_ENGINE_GLOBAL_INDEX

引擎的索引。

• CUDNN_TYPE_INT64； 一个元素。

• 有效值介于 0 和 CUDNN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT-1 之间。

• 必需属性。

CUDNN_ATTR_ENGINE_KNOB_INFO

引擎性能旋钮的描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_KNOB_INFO_DESCRIPTOR 的一个元素。

• 只读属性。

CUDNN_ATTR_ENGINE_NUMERICAL_NOTE

引擎的数值属性。

• CUDNN_TYPE_NUMERICAL_NOTE；零个或多个元素。

• 只读属性。

CUDNN_ATTR_ENGINE_LAYOUT_INFO

引擎的首选张量布局。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_LAYOUT_INFO_DESCRIPTOR 的一个元素。

• 只读属性。

CUDNN_ATTR_ENGINE_BEHAVIOR_NOTE

引擎的行为属性。

• CUDNN_TYPE_BEHAVIOR_NOTE；零个或多个元素。

• 只读属性。

CUDNN_ATTR_ENGINE_SM_COUNT_TARGET

要定位的 SM 数量。

• CUDNN_TYPE_INT32；一个元素。

• 有效值介于 0 和设备上 SM 的数量之间，其中 0 是默认值，表示将使用所有 SM。

• 可选属性。

最终确定

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_STATUS_NOT_SUPPORTED

当前版本的 cuDNN 不支持描述符属性集。例如，CUDNN_ATTR_ENGINE_GLOBAL_INDEX 的值不在有效范围内。

CUDNN_STATUS_BAD_PARAM

描述符属性集不一致或处于意外状态。例如，操作图描述符集尚未最终确定。

CUDNN_BACKEND_ENGINECFG_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_ENGINECFG_DESCRIPTOR, &desc) 创建；cuDNN 后端引擎配置描述符由引擎描述符和旋钮选择描述符数组组成。用户可以从引擎配置信息中查询关于中间结果的信息：即可在执行之间重用的计算中间结果。

属性

CUDNN_ATTR_ENGINECFG_ENGINE

后端引擎。

• CUDNN_TYPE_BACKEND_DESCRIPTOR：一个元素，类型为 CUDNN_BACKEND_ENGINE_DESCRIPTOR 的后端描述符。

• 必需属性。

CUDNN_ATTR_ENGINECFG_KNOB_CHOICES

引擎调优旋钮和选择。

• CUDNN_TYPE_BACKEND_DESCRIPTOR：零个或多个元素，类型为 CUDNN_BACKEND_KNOB_CHOICE_DESCRIPTOR 的后端描述符。

CUDNN_ATTR_ENGINECFG_INTERMEDIATE_INFO

此引擎配置的计算中间结果信息。

• CUDNN_TYPE_BACKEND_DESCRIPTOR：一个元素，类型为 CUDNN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR 的后端描述符。

• 只读属性。

• 当前不支持。未来实现的占位符。

CUDNN_ATTR_ENGINECFG_WORKSPACE_SIZE

执行此引擎配置所需的工作区缓冲区大小。

• CUDNN_TYPE_INT64； 一个元素。

• 只读属性。

最终确定

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_STATUS_NOT_SUPPORTED

当前版本的 cuDNN 不支持描述符属性集。例如，值旋钮。

CUDNN_BACKEND_ENGINEHEUR_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_ENGINEHEUR_DESCRIPTOR, &desc) 创建；cuDNN 后端引擎启发式描述符允许用户根据 cuDNN 的启发式方法，获取按性能排序的操作图引擎配置描述符。

属性

CUDNN_ATTR_ENGINEHEUR_OPERATION_GRAPH

启发式查询结果所针对的操作图。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；一个元素。

• 必需属性。

CUDNN_ATTR_ENGINEHEUR_MODE

查询结果的启发式模式。

• CUDNN_TYPE_HEUR_MODE；一个元素。

• 必需属性。

CUDNN_ATTR_ENGINEHEUR_RESULTS

启发式查询的结果。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；零个或多个描述符类型为 CUDNN_BACKEND_ENGINECFG_DESCRIPTOR 的元素。

• 只读属性。

CUDNN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

要定位的 SM 数量。

• CUDNN_TYPE_INT32；一个元素。

• 有效值介于 0 和设备上 SM 的数量之间，其中 0 是默认值，表示将使用所有 SM。

• 可选属性。

最终确定

cudnnBackendFinalize(desc) 的返回值，其中 desc 是 cuDNN 后端引擎启发式描述符

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR, &desc) 创建；cuDNN 后端执行计划描述符允许用户指定执行计划，由 cuDNN 句柄、引擎配置以及可选的要计算的中间结果数组组成。

属性

CUDNN_ATTR_EXECUTION_PLAN_HANDLE

一个 cuDNN 句柄。

• CUDNN_TYPE_HANDLE；一个元素。

• 必需属性。

CUDNN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

要执行的引擎配置。

• CUDNN_BACKEND_ENGINECFG_DESCRIPTOR；一个元素。

• 必需属性。

CUDNN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

要计算的中间结果的唯一标识符。

• CUDNN_TYPE_INT64；零个或多个元素。

• 可选属性。如果设置，执行计划将仅计算指定的中间结果，而不会计算引擎配置中操作图上的任何输出张量。

CUDNN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

预计算中间结果的唯一标识符。

• CUDNN_TYPE_INT64；零个或多个元素。

• 可选属性。如果设置，计划将在执行期间期望并使用变体包描述符中每个中间结果的指针。

• 当前不支持。未来实现的占位符。

CUDNN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

执行此计划所需的工作区缓冲区大小。

• CUDNN_TYPE_INT64； 一个元素。

• 只读属性。

CUDNN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

序列化执行计划的 JSON 表示形式。序列化和反序列化可以通过分别获取和设置此属性来完成。

• CUDNN_TYPE_CHAR；多个元素，数量与执行计划的 json 表示形式的空终止字符串的大小相同。

最终确定

cudnnBackendFinalize(desc) 的返回值，其中 desc 是 cuDNN 后端执行计划描述符

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR, &desc) 创建；cuDNN 后端中间描述符是一个只读描述符，其中包含关于执行中间结果的信息。执行中间结果是设备内存中引擎配置的一些中间计算，可以在计划执行之间重用以分摊内核开销。每个中间结果都由唯一的 ID 标识。用户可以查询中间结果的设备内存大小。中间结果可能依赖于由张量 UID 标识的一个或多个张量的数据，或者操作图的一个或多个属性。

这是一个只读描述符。用户无法设置描述符属性或最终确定描述符。用户从引擎配置描述符查询最终确定的描述符。

属性

CUDNN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

中间结果的唯一标识符。

• CUDNN_TYPE_INT64； 一个元素。

• 只读属性。

CUDNN_ATTR_INTERMEDIATE_INFO_SIZE

中间结果所需的设备内存大小。

• CUDNN_TYPE_INT64； 一个元素。

• 只读属性。

CUDNN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

中间结果所依赖的张量的 UID。

• CUDNN_TYPE_INT64；零个或多个元素。

• 只读属性。

CUDNN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

当前不支持。未来实现的占位符。

最终确定

用户不会最终确定此描述符。对后端中间描述符使用 cudnnBackendFinalize(desc) 返回 CUDNN_STATUS_NOT_SUPPORTED。

CUDNN_BACKEND_KNOB_CHOICE_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_KNOB_CHOICE_DESCRIPTOR, &desc) 创建；cuDNN 后端旋钮选择描述符由要设置的旋钮类型和旋钮要设置的值组成。

属性

CUDNN_ATTR_KNOB_CHOICE_KNOB_TYPE

要设置的旋钮类型。

• CUDNN_TYPE_KNOB_TYPE：一个元素。

• 必需属性。

CUDNN_ATTR_KNOB_CHOICE_KNOB_VALUE

要设置的旋钮的值。

• CUDNN_TYPE_INT64：一个元素。

• 必需属性。

最终确定

cudnnBackendFinalize(desc) 的返回值，其中 desc 是 cuDNN 后端旋钮选择描述符

CUDNN_STATUS_SUCCESS

旋钮选择描述符已成功最终确定。

CUDNN_BACKEND_KNOB_INFO_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_INFO_DESCRIPTOR, &desc) 创建；cuDNN 后端旋钮信息描述符由引擎性能旋钮的类型和有效值范围组成。有效值范围以最小值、最大值和有效值的步幅给出。这是一种纯粹的信息性描述符类型。不支持设置描述符属性。用户从最终确定的后端描述符中获取最终确定的描述符数组，每个旋钮类型一个。

属性

CUDNN_ATTR_KNOB_INFO_TYPE

性能旋钮的类型。

• CUDNN_TYPE_KNOB_TYPE：一个元素。

• 只读属性。

CUDNN_ATTR_KNOB_INFO_MAXIMUM_VALUE

此旋钮的最小有效值选择值。

• CUDNN_TYPE_INT64：一个元素。

• 只读属性。

CUDNN_ATTR_KNOB_INFO_MINIMUM_VALUE

此旋钮的最大有效值选择值。

• CUDNN_TYPE_INT64：一个元素。

• 只读属性。

CUDNN_ATTR_KNOB_INFO_STRIDE

此旋钮的有效值选择值的步幅。

• CUDNN_TYPE_INT64：一个元素。

• 只读属性。

最终确定

此描述符是只读的；它从 cuDNN 后端引擎配置描述符中检索和最终确定。用户无法设置或最终确定。

CUDNN_BACKEND_LAYOUT_INFO_DESCRIPTOR

使用描述符类型值 CUDNN_BACKEND_LAYOUT_INFO_DESCRIPTOR 创建，cuDNN 后端布局信息描述符提供关于张量首选布局的信息。

属性

CUDNN_ATTR_LAYOUT_INFO_TENSOR_UID

张量的 UID。

• CUDNN_TYPE_INT64； 一个元素。

• 只读属性。

CUDNN_ATTR_LAYOUT_INFO_TYPES

张量的首选布局。

• CUDNN_TYPE_LAYOUT_TYPE：零个或多个元素 cudnnBackendLayoutType_t。

• 只读属性。

最终确定

此描述符是只读的；它从 cuDNN 后端引擎配置描述符中检索和最终确定。用户无法设置其属性或最终确定它。

CUDNN_BACKEND_MATMUL_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_MATMUL_DESCRIPTOR, &desc) 创建；cuDNN 后端 matmul 描述符指定 matmul 操作所需的任何元数据。

属性

CUDNN_ATTR_MATMUL_COMP_TYPE

用于 matmul 操作的计算精度。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 必需属性。

最终确定

cudnnBackendFinalize(desc) 的返回值，其中 desc 是 cuDNN 后端 matmul 描述符

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_CONCAT_DESCRIPTOR, &desc) 创建；cuDNN 后端连接操作描述符指定一个操作节点，用于沿给定的连接轴连接给定的张量向量。

此操作还支持就地模式，其中假定其中一个输入张量已位于输出张量中的正确位置，即它们共享相同的设备缓冲区。

属性

cuDNN 后端连接操作描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_OPERATION_CONCAT_

CUDNN_ATTR_OPERATION_CONCAT_AXIS

张量要沿其连接的维度。

• 类型： CUDNN_TYPE_INT64

• 必需属性。

CUDNN_ATTR_OPERATION_CONCAT_INPUT_DESCS

输入张量描述符的向量，它们按照在此向量中提供的顺序连接。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；一个或多个描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

输入张量描述符向量中输入张量的索引，该输入张量已就地存在于输出张量中。

• 类型： CUDNN_TYPE_INT64

• 可选属性。

CUDNN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

来自输入张量连接结果的输出张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

最终确定

cudnnBackendFinalize() 和 CUDNN_BACKEND_OPERATION_CONCAT_DESCRIPTOR() 可以具有以下返回值

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 除了它们要沿其连接的维度之外，操作中涉及的张量应在所有维度上具有相同的形状。

• 连接维度中的输出张量形状应等于该相同维度中所有输入张量的张量形状之和。

• 连接轴应为有效的张量维度。

• 如果提供，则就地输入张量索引应为输入张量描述符向量中的有效索引。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR, &desc) 创建；cuDNN 后端卷积反向数据操作描述符指定一个用于卷积反向数据的操作节点，以计算输入数据 dx 相对于滤波器张量 w 和响应梯度 dy 的梯度，输出带有 \(\alpha\) 缩放和残差加法带有 \(\beta\) 缩放。也就是说，等式为：\(dx=\alpha\left( w\bar{*}dy \right)+\beta dx\)，其中 \(\bar{*}\) 表示卷积反向数据算子。

属性

cuDNN 后端卷积描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

alpha 值。

• CUDNN_TYPE_FLOAT 或 CUDNN_TYPE_DOUBLE；一个或多个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

beta 值。

• CUDNN_TYPE_FLOAT 或 CUDNN_TYPE_DOUBLE；一个或多个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

卷积算子描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

卷积滤波器张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

图像梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

响应梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

最终确定

在最终确定卷积操作时，张量 DX、W 和 DY 的张量维度基于与 CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR 部分中描述的 X、W 和 Y 张量维度相同的解释进行绑定。

cudnnBackendFinalize() 和 CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR 可以具有以下返回值

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。例如，在卷积算子下，DX、W 和 DY 张量不构成有效的卷积操作。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR, &desc) 创建；cuDNN 后端卷积反向滤波器操作描述符指定一个用于卷积反向滤波器的操作节点，以计算滤波器 dw 相对于图像张量 x 和响应梯度 dy 的梯度，输出带有 \(\alpha\) 缩放和残差加法带有 \(\beta\) 缩放。也就是说，等式为：\(dx=\alpha\left( x\tilde{*}dy \right)+\beta dx\)，其中 \(\tilde{*}\) 表示卷积反向滤波器算子。

属性

cuDNN 后端卷积描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

alpha 值。

• CUDNN_TYPE_FLOAT 或 CUDNN_TYPE_DOUBLE；一个或多个元素。

• 必需属性。需要在最终确定之前设置。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

beta 值。

• CUDNN_TYPE_FLOAT 或 CUDNN_TYPE_DOUBLE；一个或多个元素。

• 必需属性。需要在最终确定之前设置。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

卷积算子描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR 的一个元素。

• 必需属性。需要在最终确定之前设置。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

卷积滤波器张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。需要在最终确定之前设置。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

图像梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。需要在最终确定之前设置。

CUDNN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

响应梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。需要在最终确定之前设置。

最终确定

在最终确定卷积操作时，张量 X、DW 和 DY 的张量维度基于与 CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR 部分中描述的 X、W 和 Y 张量维度相同的解释进行绑定。

cudnnBackendFinalize() 和 CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR() 可以具有以下返回值

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。例如，在卷积算子下，X、DW 和 DY 张量不构成有效的卷积操作。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR, &desc) 创建；cuDNN 后端卷积前向操作描述符指定一个用于前向卷积的操作节点，以计算图像张量 x 与滤波器张量 w 卷积后的响应张量 y，输出带有 \(\alpha\) 缩放和残差加法带有 \(\beta\) 缩放。也就是说，等式为：\(y=\alpha\left( w*x \right)+\beta y\)，其中 \(*\) 是前向方向的卷积算子。

属性

cuDNN 后端卷积描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_

CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

alpha 值。

• CUDNN_TYPE_FLOAT 或 CUDNN_TYPE_DOUBLE；一个或多个元素。

• 需要在最终确定之前设置。

CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

beta 值。

• CUDNN_TYPE_FLOAT 或 CUDNN_TYPE_DOUBLE；一个或多个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

卷积算子描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

卷积滤波器张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

图像张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

响应张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

最终确定

在最终确定卷积操作时，张量 X、W 和 Y 的张量维度基于以下解释进行绑定

CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC 的 CUDNN_ATTR_CONVOLUTION_SPATIAL_DIMS 属性是卷积的空间维度数。张量 X、W 和 Y 的维度数必须比空间维度数大 2 或 3，具体取决于用户如何选择指定卷积张量。

如果张量维度数是空间维度数加 2

• X 张量维度和步幅数组为 [N, GC, …]

• W 张量维度和步幅数组为 [GK, C, …]

• Y 张量维度和步幅数组为 [N, GK, …]

其中省略号 … 是每个张量的空间维度的简写，G 是卷积组的数量，C 和 K 是每组输入和输出特征图的数量。在此解释中，假定每组的内存布局是紧凑的。cudnnBackendFinalize() 断言张量维度和步幅与此解释一致，否则返回 CUDNN_STATUS_BAD_PARAM。

cudnnBackendFinalize() 和 CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR 可以具有以下返回值

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。例如，在卷积算子下，X、W 和 Y 张量不构成有效的卷积操作。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

表示将生成每通道统计信息的操作。将生成的具体统计信息取决于描述符中的 CUDNN_ATTR_OPERATION_GENSTATS_MODE 属性。目前，CUDNN_ATTR_OPERATION_GENSTATS_MODE 仅支持 CUDNN_GENSTATS_SUM_SQSUM。它将生成输入张量 x 的每通道元素的和与平方和。输出维度应全部为 1，除了 C 维度。此外，输出的 C 维度应等于输入的 C 维度。此不透明结构可以使用 cudnnBackendCreateDescriptor() (CUDNN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR) 创建。

属性

CUDNN_ATTR_OPERATION_GENSTATS_MODE

设置操作的 CUDNN_TYPE_GENSTATS_MODE。此属性是必需的。

CUDNN_ATTR_OPERATION_GENSTATS_MATH_PREC

计算的数学精度。此属性是必需的。

CUDNN_ATTR_OPERATION_GENSTATS_XDESC

设置输入张量 X 的描述符。此属性是必需的。

CUDNN_ATTR_OPERATION_GENSTATS_SUMDESC

设置输出张量 sum 的描述符。此属性是必需的。

CUDNN_ATTR_OPERATION_GENSTATS_SQSUMDESC

设置输出张量 quadratic sum 的描述符。此属性是必需的。

最终确定

在最终确定阶段，将交叉检查属性以确保没有冲突。可能会返回以下状态

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 输入张量和输出张量之间的维度数不匹配。

• 输入/输出张量维度与上述描述不符。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_MATMUL_DESCRIPTOR, &desc) 创建；cuDNN 后端 matmul 操作描述符指定一个用于 matmul 的操作节点，以通过将矩阵 A 和矩阵 B 相乘来计算矩阵乘积 C，如下面的等式所示：C=AB

当使用 matmul 操作时，矩阵预计至少为秩为 2 的张量。最后两个维度预计对应于 M、K 或 N。所有前面的维度都解释为批次维度。如果批次维度为零，则要求如下

零批次维度的 CUDNN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

情况	矩阵 A	矩阵 B	矩阵 C
单个矩阵乘法	M x K	K x N	M x N

对于单个批次维度，我们有以下要求

单个批次维度的 CUDNN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

情况	矩阵 A	矩阵 B	矩阵 C
单个矩阵乘法	1 x M x K	1 x K x N	1 x M x N
批次矩阵乘法	B x M x K	B x K x N	B x M x N
广播 A	(B/c) x M x K	B x K x N	B x M x N
广播 B	B x M x K	(B/c) x K x N	B x M x N

其中

• B 表示批次大小

• M 是矩阵 A 的行数

• K 是输入矩阵 A 的列数（与输入矩阵 B 的行数相同）

• N 是输入矩阵 B 的列数

• c 是一个常数整数，是 B 的因子

如果矩阵 A 或 B 的批次大小设置为 B/c，则表示该矩阵将在批次矩阵乘法中广播。结果输出矩阵 C 将是 B x M x N 的张量。

上述广播约定扩展到所有批次维度。具体来说，对于具有三个批次维度的张量

三个批次维度的 CUDNN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

情况	矩阵 A	矩阵 B	矩阵 C
多批次矩阵乘法	B1 x 1 x B3 x M x K	1 x B2 x (B3/c) x K x N	B1 x B2 x B3 x M x N

多批次维度功能允许您拥有批次未以单个步幅打包的布局。这种情况在多头注意力机制中尤其常见。对于矩阵乘法和矩阵乘法融合，c 仅允许为 B（导致批次维度为 1）。对于 cuDNN 融合 Flash 注意力中的分组查询注意力，支持 c 的其他可能值。

可以使用张量描述符中的步幅来指定给定张量中矩阵元素的寻址方式。步幅表示每个张量维度中元素之间的间隔。考虑一个矩阵张量 A（B x M x N），其步幅为 [BS, MS, NS]，这表示实际的矩阵元素 A[x, y, z] 在（A_base_address + x * BS + y * MS + z * NS）处找到，该地址相对于为张量 A 分配的线性内存空间的基地址。在我们当前的支持下，最内层维度必须是紧密排列的，这要求 MS=1 或 NS=1。 否则，关于如何在张量描述符中指定步幅没有其他技术限制，因为它应遵循上述寻址公式以及用户指定的步幅。

这种表示形式为一些常见的用法提供了支持，例如前导维度和矩阵转置，我们将在以下示例中进行解释。

1. 最基本的情况是完全打包的行优先批次矩阵，不考虑前导维度或转置。在这种情况下，BS = M*N，MS = N，NS = 1。

2. 矩阵转置可以通过交换内部和外部维度（使用步幅）来实现。即：

   1. 要指定非转置矩阵：BS = M*N，MS = N，NS = 1。

   2. 要指定矩阵转置：BS = M*N，MS = 1，NS = M。

3. 前导维度是 BLAS 类 API 中广泛使用的概念，描述了 2D 数组内存分配的内部维度（与概念矩阵维度相反）。它在某种程度上类似于步幅，因为它定义了外部维度中元素之间的间隔。当矩阵只是已分配内存中数据的一部分、寻址子矩阵或从对齐的内存分配中寻址矩阵时，最典型的用例会显示它与矩阵内部维度的不同之处。因此，在列优先矩阵 A 中，前导维度 LDA 必须满足 LDA >= M，而在行优先矩阵 A 中，它必须满足 LDA >= N。为了从前导维度概念过渡到使用步幅，这意味着 MS >= N 且 NS = 1 或 MS = 1 且 NS >= M。 请记住，虽然这些是一些实际用例，但这些不等式并没有对步幅的可接受规范施加技术约束。

其他常用的 GEMM 功能，例如 alpha/beta 输出混合，也可以使用此 matmul 操作以及其他逐点操作来实现。

属性

cuDNN 后端 matmul 描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_OPERATION_MATMUL_

CUDNN_ATTR_OPERATION_MATMUL_ADESC

矩阵 A 描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_MATMUL_BDESC

矩阵 B 描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_MATMUL_CDESC

矩阵 C 描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

要在批次矩阵上执行的 matmul 操作的数量。

• CUDNN_TYPE_INT64； 一个元素。

• 默认值为 1。

CUDNN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

张量 gemm_m_override 描述符。允许您通过此张量覆盖批次矩阵乘法的 M 维度。仅在 融合注意力前向传播、融合注意力反向传播、融合 Flash 注意力前向传播 和 融合 Flash 注意力反向传播 部分中记录的情况下受支持。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

张量 gemm_n_override 描述符。允许您通过此张量覆盖批次矩阵乘法的 N 维度。仅在 融合注意力前向传播、融合注意力反向传播、融合 Flash 注意力前向传播 和 融合 Flash 注意力反向传播 部分中记录的情况下受支持。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

张量 gemm_k_override 描述符。允许您通过此张量覆盖批次矩阵乘法的 K 维度。仅在 融合注意力前向传播、融合注意力反向传播、融合 Flash 注意力前向传播 和 融合 Flash 注意力反向传播 部分中记录的情况下受支持。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_MATMUL_DESC

matmul 操作描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型 CUDNN_BACKEND_MATMUL_DESCRIPTOR 的一个元素。

• 必需属性。

最终确定

在 matmul 操作的最终确定中，将检查矩阵 A、B 和 C 的张量维度，以确保它们满足矩阵乘法的要求

带有 CUDNN_BACKEND_OPERATION_MATMUL_DESCRIPTOR 的 cudnnBackendFinalize() 可以具有以下返回值：

CUDNN_STATUS_NOT_SUPPORTED

遇到不支持的属性值。例如，如果并非所有矩阵 A、B 和 C 都是至少秩为 2 的张量。

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 指定的 CUDNN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT 为负值。

• CUDNN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT 和矩阵 A、B 和 C 的一个或多个批次大小不等于 1。也就是说，存在冲突，其中同时指定了不规则步幅和规则步幅批次矩阵乘法，这不是有效的用例。

• 矩阵 A、B 和 C 的维度不满足矩阵乘法的要求。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR, &desc) 创建；cuDNN 后端归一化反向操作指定一个用于反向归一化的节点，该节点将梯度张量 dY 作为输入，并输出梯度张量 dX 以及权重梯度 dScale 和 dBias。归一化模式使用 CUDNN_ATTR_OPERATION_NORM_BWD_MODE 属性设置。

限制

• 不支持 CUDNN_GROUP_NORM 模式。

用于 CUDNN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR 的支持配置

CUDNN_LAYER_NORM	CUDNN_INSTANCE_NORM	CUDNN_BATCH_NORM	CUDNN_GROUP_NORM	CUDNN_RMS_NORM
是	是	是	否	是

注意

除了单 GPU 之外，CUDNN_BATCH_NORM 还支持单节点多 GPU 批次归一化，而其他归一化模式仅支持在单个 GPU 上运行。有关更多信息，请参阅 DReluForkDBn 模式。

属性

CUDNN_ATTR_OPERATION_NORM_BWD_MODE

选择用于范数反向操作的归一化模式。

• CUDNN_TYPE_NORM_MODE；一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_BWD_XDESC

输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

保存的均值输入张量描述符，用于重用训练阶段前向计算期间计算的均值。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

保存的逆方差输入张量描述符，用于重用训练阶段前向计算期间计算的均值。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_BWD_DYDESC

梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

归一化比例描述符。请注意，反向传递不需要偏置描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

epsilon 值的标量输入张量描述符。仅当未将保存的均值和方差作为操作的输入传递时，才需要 epsilon 值。请注意，此描述符的属性 CUDNN_ATTR_TENSOR_IS_BY_VALUE 应设置为 true。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

比例梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

偏置梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_BWD_DXDESC

输入梯度张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

用于多 GPU 归一化中通信缓冲区的张量描述符向量。通常，为节点中的每个 GPU 提供一个缓冲区。这是一个可选属性，仅用于多 GPU 张量统计量缩减。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；一个或多个描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的元素。

• 可选属性。

最终确定

在最终确定阶段，将检查属性以确保没有冲突。

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 梯度张量 dY、dX 和输入张量 X 的张量维度不匹配。

• mean、scale 和 inv_variance 张量的通道计数 C 不匹配。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR, &desc) 创建；cuDNN 后端归一化前向操作指定一个用于前向归一化的节点，该节点将张量 X 作为输入，并生成归一化输出 Y，其归一化模式由 CUDNN_ATTR_OPERATION_NORM_FWD_MODE 属性设置。该操作支持可选的运行统计量计算，并允许存储计算出的均值和方差，以便在反向计算中重用，具体取决于 CUDNN_ATTR_OPERATION_NORM_FWD_PHASE 属性的设置。

限制

• 不支持 CUDNN_GROUP_NORM 模式。

• 批次归一化仅支持前向训练，不支持前向推理。

用于 CUDNN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR 的支持配置

CUDNN_ATTR_OPERATION_NORM_FWD_PHASE	CUDNN_LAYER_NORM	CUDNN_INSTANCE_NORM	CUDNN_BATCH_NORM	CUDNN_GROUP_NORM	CUDNN_RMS_NORM
CUDNN_NORM_FWD_TRAINING	是	是	是	否	是
CUDNN_NORM_FWD_INFERENCE	是	是	否	否	是

注意

除了单 GPU 之外，批次归一化还支持在单节点多 GPU 上运行，而其他归一化模式仅支持在单个 GPU 上运行。有关更多信息，请参阅 BNAddRelu 模式。

属性

CUDNN_ATTR_OPERATION_NORM_FWD_MODE

选择用于范数前向操作的归一化模式。

• CUDNN_TYPE_NORM_MODE；一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_FWD_PHASE

选择用于范数前向操作的训练或推理阶段。

• CUDNN_TYPE_NORM_FWD_PHASE；一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_FWD_XDESC

输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

推理阶段的估计均值输入张量描述符，以及训练阶段的计算均值输出张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

推理阶段的估计逆方差输入张量描述符，以及训练阶段的计算逆方差输出张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

归一化比例输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

归一化偏置输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

用于归一化计算的 epsilon 值的标量输入张量描述符。请注意，此描述符的属性 CUDNN_ATTR_TENSOR_IS_BY_VALUE 应设置为 true。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

用于运行统计量计算中指数平均因子的标量输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

训练阶段运行统计量计算的输入运行均值张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

训练阶段运行统计量计算的输入运行方差张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

训练阶段运行统计量计算的输出运行 mean 张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

训练阶段运行统计量计算的输出运行方差张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_NORM_FWD_YDESC

归一化操作输出的张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

用于多 GPU 归一化中通信缓冲区的张量描述符向量。通常，为节点中的每个 GPU 提供一个缓冲区。这是一个可选属性，仅用于多 GPU 张量统计量缩减。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；一个或多个描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的元素。

• 可选属性。

最终确定

在最终确定阶段，将检查属性以确保没有冲突。

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 输出张量维度与输入张量维度不匹配。

• mean、scale、bias 和 inv_variance 张量的通道计数 C 不匹配。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

表示一个逐点操作，该操作实现方程 Y = op(alpha1 * X) 或 Y = op(alpha1 * X, alpha2 * B)，具体取决于操作类型。上面 op() 表示的实际操作类型取决于描述符中的 CUDNN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR 属性。此操作描述符支持单输入单输出的操作。

有关支持的操作列表，请参阅 cudnnPointwiseMode_t 部分。

对于双输入逐点操作，当其中一个张量中的张量维度为 1，而另一个张量的对应维度不为 1 时，则假定进行广播。

对于三输入单输出逐点操作，我们不支持任何张量中的广播。

此不透明结构可以使用 cudnnBackendCreateDescriptor() (CUDNN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR) 创建。

属性

CUDNN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

设置包含逐点操作的数学设置的描述符。此属性是必需的。

CUDNN_ATTR_OPERATION_POINTWISE_XDESC

设置输入张量 X 的描述符。对于逐点数学函数或激活前向传播计算，此属性是必需的。

CUDNN_ATTR_OPERATION_POINTWISE_BDESC

如果操作需要两个输入，例如 add 或 multiply，则此属性设置第二个输入张量 B。如果操作仅需要 1 个输入，则不使用此字段，也不应设置此字段。

CUDNN_ATTR_OPERATION_POINTWISE_YDESC

设置输出张量 Y 的描述符。对于逐点数学函数或激活前向传播计算，此属性是必需的。

CUDNN_ATTR_OPERATION_POINTWISE_TDESC

设置张量 T 的描述符。当 CUDNN_ATTR_POINTWISE_MODE 设置为 CUDNN_POINTWISE_BINARY_SELECT 时，此属性是必需的，并充当基于其完成选择的掩码。

CUDNN_ATTR_OPERATION_POINTWISE_ALPHA1

设置方程中的标量 alpha1 值。可以是 float 或 half 类型。此属性是可选的，如果未设置，则默认值为 1.0。

CUDNN_ATTR_OPERATION_POINTWISE_ALPHA2

如果操作需要 2 个输入，例如 add 或 multiply。此属性设置方程中的标量 alpha2 值。可以是 float 或 half 类型。此属性是可选的，如果未设置，则默认值为 1.0。如果操作仅需要 1 个输入，则不使用此字段，也不应设置此字段。

CUDNN_ATTR_OPERATION_POINTWISE_DXDESC

设置输出张量 dX 的描述符。对于逐点激活反向传播计算，此属性是必需的。

CUDNN_ATTR_OPERATION_POINTWISE_DYDESC

设置输入张量 dY 的描述符。对于逐点激活反向传播计算，此属性是必需的。

最终确定

在最终确定阶段，将交叉检查属性以确保没有冲突。可能会返回以下状态

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 输入张量和输出张量之间的维度数不匹配。

• 输入/输出张量维度与上述自动广播规则不符。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

cuDNN 后端 reduction 操作描述符表示一个操作节点，该节点实现在一个或多个维度中缩减输入张量 X 的值以获得输出张量 Y。用于缩减张量值的数学运算和计算数据类型通过 CUDNN_ATTR_OPERATION_REDUCTION_DESC 指定。

此操作描述符可以使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR, &desc) 创建。

输出张量 Y 的大小应与输入张量 X 的大小相同，但在其大小为 1 的维度除外。

在 cuDNN 融合 Flash 注意力中，分组查询注意力和多查询注意力有一个特殊的用例，其中输出张量 Y 中的某些维度也可以是输入张量 X 中相应维度的因子。

属性

cuDNN 后端 reduction 描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_OPERATION_REDUCTION_

CUDNN_ATTR_OPERATION_REDUCTION_XDESC

矩阵 X 描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR 描述符类型 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_REDUCTION_YDESC

矩阵 Y 描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR 描述符类型 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_REDUCTION_DESC

reduction 操作描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR 描述符类型 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

最终确定

在 reduction 操作的最终确定中，将检查张量 X 和 Y 的维度，以确保它们满足缩减操作的要求。

带有 CUDNN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR 的 cudnnBackendFinalize() 可以具有以下返回值：

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。例如，张量 X 和 Y 的维度不满足缩减操作的要求。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR, &desc) 创建；cuDNN 后端重采样反向操作描述符指定用于反向重采样的操作节点。它根据 CUDNN_ATTR_RESAMPLE_MODE 计算来自输出张量梯度 dy 的输入张量梯度 dx，并使用输出缩放 \(\alpha\) 和残差加法与 \(\beta\) 缩放完成反向重采样。

属性

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_DESC

重采样操作描述符（CUDNN_BACKEND_RESAMPLE_DESCRIPTOR）实例包含有关操作的元数据。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型 CUDNN_BACKEND_RESAMPLE_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

输入张量梯度描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

输出张量梯度描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

包含用于反向传播的 maxpool 或最近邻重采样索引的张量。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

设置混合中使用的 alpha 参数。

• CUDNN_TYPE_DOUBLE 或 CUDNN_TYPE_FLOAT；一个元素。

• 可选属性。

• 默认值为 1.0。

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_BETA

设置混合中使用的 beta 参数。

• CUDNN_TYPE_DOUBLE 或 CUDNN_TYPE_FLOAT；一个元素。

• 可选属性。

• 默认值为 0.0。

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

输入张量 X 描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

• NCHW 布局必需。

CUDNN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

输入张量 Y 描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

• NCHW 布局必需。

最终确定

在最终确定阶段，将交叉检查属性以确保没有冲突。可能会返回以下状态

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 基于填充和步幅计算的输出形状与给定的输出张量维度不匹配。

• YDESC 和 IDXDESC（如果给定）的形状不匹配。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR, &desc) 创建；cuDNN 后端重采样前向操作描述符指定用于前向重采样的操作节点。它根据 CUDNN_ATTR_RESAMPLE_MODE 计算图像张量 x 的重采样输出张量 y，并使用输出缩放 \(\alpha\) 和残差加法与 \(\beta\) 缩放。

重采样模式独立作用于每个空间维度。对于空间维度 i，输出空间维度大小 y_i 可以通过组合输入图像的空间维度大小 x_i、后填充 post_i、前填充 pre_i、步幅 s_i 和窗口大小 w_i 计算得出：y_i = 1+(x_i + post_i + pre_i - w_i) / s_i

属性

CUDNN_ATTR_OPERATION_RESAMPLE_FWD_DESC

重采样操作描述符（CUDNN_BACKEND_RESAMPLE_DESCRIPTOR）实例包含有关操作的元数据。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型 CUDNN_BACKEND_RESAMPLE_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

输出张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

包含用于反向传播的 maxpool 或最近邻重采样索引的张量。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性（主要用于涉及训练的用例）。

CUDNN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

设置混合中使用的 alpha 参数。

• CUDNN_TYPE_DOUBLE 或 CUDNN_TYPE_FLOAT；一个元素。

• 可选属性。

• 默认值为 1.0。

CUDNN_ATTR_OPERATION_RESAMPLE_FWD_BETA

设置混合中使用的 beta 参数。

• CUDNN_TYPE_DOUBLE 或 CUDNN_TYPE_FLOAT；一个元素。

• 可选属性。

• 默认值为 0.0。

最终确定

在最终确定阶段，将交叉检查属性以确保没有冲突。可能会返回以下状态

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。一些示例包括

• 基于填充和步幅计算的输出形状与给定的输出张量维度不匹配。

• YDESC 和 IDXDESC（如果给定）的形状不匹配。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_RNG_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_RNG_DESCRIPTOR, &desc) 创建；cuDNN 后端 Rng 操作描述符指定一个操作节点，用于根据 Rng 描述符中指定的概率分布生成具有随机数的张量。

随机数是使用 Philox 随机数生成器 (RNG) 生成的，如 Pytorch 中所述。Philox 对象接受种子值、用于启动生成的子序列以及子序列的偏移量。可以使用属性设置种子和偏移量。子序列在内部设置，以确保独立的随机数。

属性

CUDNN_ATTR_OPERATION_RNG_DESC

Rng 描述符（CUDNN_BACKEND_RNG_DESCRIPTOR）实例，包含有关操作的元数据。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型 CUDNN_BACKEND_RNG_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RNG_YDESC

输出张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_RNG_SEED

设置用于创建 Y 张量的随机数生成器的种子。它可以是主机 INT64 值或绑定到设备上值的后端描述符。仅支持所有维度设置为 1 且所有步幅设置为 1 的张量。

• CUDNN_TYPE_INT64；一个元素或 CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

• 默认值为 0。

CUDNN_ATTR_OPERATION_RNG_OFFSET_DESC

用于 RNG Philox 对象中偏移量的张量描述符。仅支持所有维度设置为 1 且所有步幅设置为 1 的张量。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

最终确定

在最终确定阶段，将交叉检查属性以确保没有冲突。可能会返回以下状态

CUDNN_STATUS_BAD_PARAM

CUDNN_ATTR_OPERATION_RNG_OFFSET_DESC 或 CUDNN_ATTR_OPERATION_RNG_SEED 并非所有维度和步幅都设置为 1。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_PAGED_CACHE_LOAD_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_PAGED_CACHE_LOAD_DESCRIPTOR, &desc) 创建；cuDNN 后端分页缓存加载操作描述符与融合 flash 注意力前向传播图一起使用，并指定用于重建 k 缓存或 v 缓存的操作节点。

k/v 缓存通过使用页表张量在非连续容器张量中查找特定序列 ID 的位置来重建。非连续地存储 k/v 缓存可以通过避免碎片来实现高效的内存管理。有关更多信息，请参阅 Paged Attention 论文。

属性

CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_YDESC

虚拟输出张量描述符，包含重建的 k/v 缓存。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_CONTAINER_DESC

非虚拟张量描述符，维度为 [num_blocks,H,block_size,D]，包含 k/v 缓存。k/v 缓存分为 num_blocks 个 [H,block_size,D] 张量，其中 block_size 是用户选择的参数。较小的 block_size 会减少碎片，但也会降低并行性。num_blocks 是任意的，取决于已分配 k/v 缓存的大小。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_PAGE_TABLE_DESC

非虚拟张量描述符，维度为 [B,1,ceil(max_seq_size/block_size),1]，指向查找表。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 数据类型：INT32

• 必需属性。

CUDNN_ATTR_OPERATION_PAGED_CACHE_LOAD_SEQUENCE_DESC

非虚拟 [B,1,1,1] 张量描述符，指示请求 k/v 缓存中的哪些序列号。对于每个批次，容器中的所有项目将从序列 0 复制到序列号 1。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 数据类型：INT32 或 INT64

• 序列号在区间 [1, max_seq_size] 内

• 必需属性。

最终确定

在最终确定阶段，将交叉检查属性以确保没有冲突。可能会返回以下状态

CUDNN_STATUS_BAD_PARAM

一个或多个输入/输出张量的类型或维度无效。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR, &desc) 创建；cuDNN 后端信号操作描述符指定一个操作节点，用于更新或等待标志变量。信号操作可用于在 cuDNN 操作图之间进行通信，甚至可以与另一个 GPU 中的操作图进行通信。

此操作（连接到图中的其他节点）还具有一个直通输入张量，该张量不进行任何操作，仅传递到输出张量。此必需的直通输入张量有助于确定信号操作应在其后执行的前置节点。可选的输出张量有助于确定信号执行应在其之前完成的后继节点。此外，对于作为输出张量的非虚拟张量，保证在操作更新信号值之前，张量的所有写入操作都已完成。

属性

CUDNN_ATTR_OPERATION_SIGNAL_MODE

要使用的信号模式。

• CUDNN_TYPE_SIGNAL_MODE

• 必需属性。

CUDNN_ATTR_OPERATION_SIGNAL_FLAGDESC

标志张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_SIGNAL_VALUE

用于比较或更新标志变量的标量值。

• CUDNN_TYPE_INT64

• 必需属性。

CUDNN_ATTR_OPERATION_SIGNAL_XDESC

一个直通输入张量，用于将此信号操作连接到图中的其他节点。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_SIGNAL_YDESC

直通输入张量的输出张量。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

最终确定

在最终确定阶段，将交叉检查属性以确保没有冲突。可能会返回以下状态

CUDNN_STATUS_BAD_PARAM

遇到无效或不一致的属性值。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_BN_FINALIZE_STATISTICS_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_BN_FINALIZE_STATISTICS_DESCRIPTOR, &desc) 创建；cuDNN 后端 bn_finalize 统计信息操作描述符指定了批归一化最终化操作的操作节点。

在类似 ResNet 的模型中，将批归一化与卷积融合的常用技术是将批归一化操作拆分为三个部分 - genStats、finalize 和 apply（逐点、缩放和偏差）。genStats 操作通常与批归一化之前的卷积操作融合，而 apply 操作与批归一化操作之后的 ReLU 和卷积融合。批归一化 finalize 操作是两个融合之间的缓冲区操作，它将批归一化 scale、bias、sum 和 sqsum（由 genStats 操作生成）作为输入，并生成等效的 scale 和 bias 作为输出。等效的 scale 和 bias 随后在 apply 阶段被消耗。此外，bn_finalize 操作还生成运行统计信息、均值和逆标准差作为输出。

属性

CUDNN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

为 bn_finalize 操作设置推理或训练模式。

• CUDNN_TYPE_BN_FINALIZE_STATS_MODE；一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

计算的数学精度。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

输入和张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

输入平方和张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

批归一化输入缩放张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

批归一化输入偏差张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

批归一化输入运行均值描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

批归一化输入运行方差描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

批归一化输出运行均值描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

批归一化输出运行方差描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 可选属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

批归一化输出保存的均值张量描述符。这是从前面 genStats 操作馈入的和输入计算得出的。存储保存的均值有助于避免在反向传播阶段重新计算。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

批归一化输出逆标准差张量描述符。这是从前面 genStats 操作馈入的和和平方和输入计算得出的。存储保存的逆标准差有助于避免在反向传播阶段重新计算。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

等效缩放张量的输出张量描述符。等效缩放张量通常作为输入馈送到批归一化 apply 计算（逐点、缩放和偏差），该计算在批归一化 finalize 操作之后进行。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

等效偏差张量的输出张量描述符。等效偏差张量通常作为输入馈送到批归一化 apply 计算（逐点、缩放和偏差），该计算在批归一化 finalize 操作之后进行。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

标量输入张量描述符，表示在计算 sum 和 sqsum 输入时累积的元素数量。在批归一化的情况下，计数通常等于 N*H*W。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

用于批归一化方差计算的 epsilon 值的标量输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERAGE_FACTOR_DESC

用于批归一化运行统计信息计算的指数平均值的标量输入张量描述符。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；描述符类型为 CUDNN_BACKEND_TENSOR_DESCRIPTOR 的一个元素。

• 必需属性。

CUDNN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

使用描述符类型值 CUDNN_BACKEND_OPERATIONGRAPH_DESCRIPTOR 创建，cuDNN 后端操作图描述符描述了一个操作图，这是一个由虚拟张量连接的一个或多个操作的小型网络。操作图定义了用户希望计算的计算案例或数学表达式。

属性

cuDNN 后端卷积描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_OPERATIONGRAPH_

CUDNN_ATTR_OPERATIONGRAPH_HANDLE

一个 cuDNN 句柄。

• CUDNN_TYPE_HANDLE；一个元素。

• 必需属性。

CUDNN_ATTR_OPERATIONGRAPH_OPS

构成操作图的操作节点。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；一个或多个描述符类型为 CUDNN_BACKEND_OPERATION_*_DESCRIPTOR 的元素。

• 必需属性。

CUDNN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

支持操作图的引擎数量。

• CUDNN_TYPE_INT64； 一个元素。

• 只读属性。

CUDNN_ATTR_OPERATIONGRAPH_ENGINE_SUPPORTED_COUNT

支持操作图的引擎数量。

• CUDNN_TYPE_INT64； 一个元素。

• 只读属性。

• 当前不支持。未来实现的占位符。

CUDNN_ATTR_OPERATIONGRAPH_IS_DYNAMIC_SHAPE_ENABLED

是否为操作图启用了动态形状。后端 API 的其余部分将把该图视为动态形状图并启用此功能。

• CUDNN_TYPE_BOOLEAN；一个元素。

最终确定

CUDNN_STATUS_BAD_PARAM

遇到无效的属性值。一些示例包括

• CUDNN_ATTR_OPERATIONGRAPH_OPS 中的后端描述符之一未最终确定。

• 值 CUDNN_ATTR_OPERATIONGRAPH_HANDLE 不是有效的 cuDNN 句柄。

CUDNN_STATUS_NOT_SUPPORTED

遇到不支持的属性值。例如，不支持属性 CUDNN_ATTR_OPERATIONGRAPH_OPS 的操作组合。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_POINTWISE_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_POINTWISE_DESCRIPTOR, &desc) 创建；cuDNN 后端逐点描述符指定了逐点运算符的参数，例如模式、数学精度、NaN 传播等等。

属性

cuDNN 后端卷积描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_POINTWISE_

CUDNN_ATTR_POINTWISE_MODE

逐点操作的模式。

• CUDNN_TYPE_POINTWISE_MODE；一个元素。

• 必需属性。

CUDNN_ATTR_POINTWISE_MATH_PREC

计算的数学精度。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 必需属性。

CUDNN_ATTR_POINTWISE_NAN_PROPAGATION

指定传播 NaN 的方法。

• CUDNN_TYPE_NAN_PROPOGATION；一个元素。

• 仅对于基于比较的逐点模式（如 ReLU）是必需的。

• 当前支持仅包括枚举值 CUDNN_PROPAGATE_NAN。

• 默认值为 CUDNN_NOT_PROPAGATE_NAN。

CUDNN_ATTR_POINTWISE_RELU_LOWER_CLIP

为 ReLU 设置下限裁剪值。如果 (value < lower_clip) value = lower_clip + lower_clip_slope * (value - lower_clip)

• CUDNN_TYPE_DOUBLE/ CUDNN_TYPE_FLOAT；一个元素。

• 默认值为 0.0f。

CUDNN_ATTR_POINTWISE_RELU_UPPER_CLIP

为 ReLU 设置上限裁剪值。如果 (value > upper_clip) value = upper_clip

• CUDNN_TYPE_DOUBLE/ CUDNN_TYPE_FLOAT；一个元素。

• 默认值为 Numeric limit max。

CUDNN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

为 ReLU 设置下限裁剪斜率值。如果 (value < lower_clip) value = lower_clip + lower_clip_slope * (value - lower_clip)

• CUDNN_TYPE_DOUBLE/ CUDNN_TYPE_FLOAT；一个元素。

• 默认值为 0.0f。

CUDNN_ATTR_POINTWISE_ELU_ALPHA

为 ELU 设置 alpha 值。如果 (value < 0.0) value = alpha * (e^value - 1.0)

• CUDNN_TYPE_DOUBLE/ CUDNN_TYPE_FLOAT；一个元素。

• 默认值为 1.0f。

CUDNN_ATTR_POINTWISE_SOFTPLUS_BETA

为 softplus 设置 beta 值。如果 value = log (1 + e^(beta * value)) / beta

• CUDNN_TYPE_DOUBLE/ CUDNN_TYPE_FLOAT；一个元素。

• 默认值为 1.0f。

CUDNN_ATTR_POINTWISE_SWISH_BETA

为 swish 设置 beta 值。如果 value = value / (1 + e^(-beta * value))

• CUDNN_TYPE_DOUBLE/ CUDNN_TYPE_FLOAT；一个元素。

• 默认值为 1.0f。

CUDNN_ATTR_POINTWISE_AXIS

为 GEN_INDEX 设置轴值。索引将为此轴生成。

• CUDNN_TYPE_INT64； 一个元素。

• 默认值为 -1。

• 需要介于 [0,input_dim_size-1] 之间。例如，如果您的输入具有维度 [N,C,H,W]，则轴可以设置为 [0,3] 中的任何值。

最终确定

cudnnBackendFinalize() 与 CUDNN_BACKEND_POINTWISE_DESCRIPTOR 一起使用可以具有以下返回值

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_REDUCTION_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_REDUCTION_DESCRIPTOR, &desc) 创建；cuDNN 后端 reduction 描述符指定了 reduction 操作所需的任何元数据，包括数学运算和计算数据类型。

属性

CUDNN_ATTR_REDUCTION_OPERATOR

用于 reduction 操作的数学运算。

• CUDNN_TYPE_REDUCTION_OPERATOR_TYPE；一个元素。

• 必需属性。

CUDNN_ATTR_REDUCTION_COMP_TYPE

用于 reduction 操作的计算精度。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 必需属性。

最终确定

cudnnBackendFinalize(desc) 的返回值，其中 desc 是 CUDNN_BACKEND_REDUCTION_DESCRIPTOR，为

CUDNN_STATUS_NOT_SUPPORTED

遇到不支持的属性值。例如，CUDNN_ATTR_REDUCTION_OPERATOR 未设置为 CUDNN_REDUCE_TENSOR_ADD、CUDNN_REDUCE_TENSOR_MUL、CUDNN_REDUCE_TENSOR_MIN 或 CUDNN_REDUCE_TENSOR_MAX 中的任何一个。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_RESAMPLE_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_RESAMPLE_DESCRIPTOR, &desc) 创建；cuDNN 后端重采样描述符指定了前向和后向传播中重采样操作（上采样或下采样）的参数。

属性

CUDNN_ATTR_RESAMPLE_MODE

指定重采样模式，例如，平均池化、最近邻等等。

• CUDNN_TYPE_RESAMPLE_MODE；一个元素。

• 默认值为 CUDNN_RESAMPLE_NEAREST。

CUDNN_ATTR_RESAMPLE_COMP_TYPE

重采样运算符的计算数据类型。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 默认值为 CUDNN_DATA_FLOAT。

CUDNN_ATTR_RESAMPLE_NAN_PROPAGATION

指定传播 NaN 的方法。

• CUDNN_TYPE_NAN_PROPAGATION；一个元素。

• 默认值为 CUDNN_NOT_PROPAGATE_NAN。

CUDNN_ATTR_RESAMPLE_SPATIAL_DIMS

指定要执行重采样的空间维度数。

• CUDNN_TYPE_INT64； 一个元素。

• 必需属性。

CUDNN_ATTR_RESAMPLE_PADDING_MODE

指定用于填充的值。

• CUDNN_TYPE_PADDING_MODE；一个元素。

• 默认值为 CUDNN_ZERO_PAD。

CUDNN_ATTR_RESAMPLE_STRIDES

内核或滤波器的每个维度上的步幅。

• CUDNN_TYPE_INT64 或 CUDNN_TYPE_FRACTION；最多 CUDNN_MAX_DIMS - 2。

• 必需属性。

CUDNN_ATTR_RESAMPLE_PRE_PADDINGS

在每个维度上添加到输入张量开头的填充。

• CUDNN_TYPE_INT64 或 CUDNN_TYPE_FRACTION；最多 CUDNN_MAX_DIMS - 2。

• 必需属性。

CUDNN_ATTR_RESAMPLE_POST_PADDINGS

在每个维度上添加到输入张量末尾的填充。

• CUDNN_TYPE_INT64 或 CUDNN_TYPE_FRACTION；最多 CUDNN_MAX_DIMS - 2。

• 必需属性。

CUDNN_ATTR_RESAMPLE_WINDOW_DIMS

滤波器的空间维度。

• CUDNN_TYPE_INT64 或 CUDNN_TYPE_FRACTION；最多 CUDNN_MAX_DIMS - 2。

• 必需属性。

最终确定

使用 CUDNN_BACKEND_RESAMPLE_DESCRIPTOR 调用 cudnnBackendFinalize() 时的返回值是

CUDNN_STATUS_NOT_SUPPORTED

遇到不支持的属性值。一些示例包括

• 用于设置 CUDNN_ATTR_RESAMPLE_WINDOW_DIMS、CUDNN_ATTR_RESAMPLE_STRIDES、CUDNN_ATTR_RESAMPLE_PRE_PADDINGS 和 CUDNN_ATTR_RESAMPLE_POST_PADDINGS 的 elemCount 参数不等于为 CUDNN_ATTR_RESAMPLE_SPATIAL_DIMS 设置的值。

• CUDNN_ATTR_RESAMPLE_MODE 设置为 CUDNN_RESAMPLE_BILINEAR，并且任何 CUDNN_ATTR_RESAMPLE_WINDOW_DIMS 均未设置为 2。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_RNG_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_RNG_DESCRIPTOR, &desc) 创建；cuDNN 后端 Rng 描述符指定了任何元数据，包括将用于生成张量的概率分布以及分布的相应参数。

属性

CUDNN_ATTR_RNG_DISTRIBUTION

用于 rng 操作的概率分布。

• CUDNN_TYPE_RNG_DISTRIBUTION；一个元素。

• 默认值为 CUDNN_RNG_DISTRIBUTION_BERNOULLI。

CUDNN_ATTR_RNG_NORMAL_DIST_MEAN

正态分布的均值，如果 CUDNN_ATTR_RNG_DISTRIBUTION = CUDNN_RNG_DISTRIBUTION_NORMAL，则使用该值。

• CUDNN_TYPE_DOUBLE；一个元素。

• 默认值为 -1。

CUDNN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

正态分布的标准差值，如果 CUDNN_ATTR_RNG_DISTRIBUTION = CUDNN_RNG_DISTRIBUTION_NORMAL，则使用该值。

• CUDNN_TYPE_DOUBLE；一个元素。

• 默认值为 -1。

最终确定

cudnnBackendFinalize(desc) 的返回值，其中 desc 是 CUDNN_BACKEND_RNG_DESCRIPTOR，为

CUDNN_STATUS_BAD_PARAM

遇到无效的属性值。一些示例包括

• 如果 CUDNN_ATTR_RNG_DISTRIBUTION = CUDNN_RNG_DISTRIBUTION_NORMAL 且提供的标准差为负数。

• 如果 CUDNN_ATTR_RNG_DISTRIBUTION = CUDNN_RNG_DISTRIBUTION_UNIFORM 且范围的最大值低于最小值。

• 如果 CUDNN_ATTR_RNG_DISTRIBUTION = CUDNN_RNG_DISTRIBUTION_BERNOULLI 且提供的概率为负数。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_TENSOR_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_TENSOR_DESCRIPTOR, &desc) 创建；cuDNN 后端张量允许用户指定通用张量的内存存储。张量由唯一标识符标识，并由其数据类型、其数据字节对齐要求以及其维度的范围和步幅来描述。可选地，张量元素可以在其一个维度中是向量。当张量是计算图中的中间变量，并且未映射到物理全局内存存储时，张量也可以设置为虚拟张量。

属性

cuDNN 后端张量描述符的属性是枚举类型 cudnnBackendAttributeName_t 的值，带有前缀 CUDNN_ATTR_TENSOR_

CUDNN_ATTR_TENSOR_UNIQUE_ID

唯一标识张量的整数。

• CUDNN_TYPE_INT64； 一个元素。

• 必需属性。

CUDNN_ATTR_TENSOR_DATA_TYPE

张量的数据类型。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 必需属性。

CUDNN_ATTR_TENSOR_BYTE_ALIGNMENT

此张量的指针的字节对齐方式。

• CUDNN_TYPE_INT64； 一个元素。

• 必需属性。

CUDNN_ATTR_TENSOR_DIMENSIONS

张量维度。

• CUDNN_TYPE_INT64；最多 CUDNN_MAX_DIMS 个元素。

• 必需属性。

CUDNN_ATTR_TENSOR_STRIDES

张量步幅。

• CUDNN_TYPE_INT64；最多 CUDNN_MAX_DIMS 个元素。

• 必需属性。

CUDNN_ATTR_TENSOR_VECTOR_COUNT

向量化的大小。

• CUDNN_TYPE_INT64； 一个元素。

• 默认值为 1。

CUDNN_ATTR_TENSOR_VECTORIZED_DIMENSION

向量化维度的索引。

• CUDNN_TYPE_INT64； 一个元素。

• 如果 CUDNN_ATTR_TENSOR_VECTOR_COUNT 设置为与其默认值不同的值，则需要在最终确定之前设置；否则将被忽略。

CUDNN_ATTR_TENSOR_IS_VIRTUAL

指示张量是否为虚拟张量。虚拟张量是操作图中的中间张量，它存在于瞬态中，并且不会从全局设备内存读取或写入到全局设备内存。

• CUDNN_TYPE_BOOLEAN；一个元素。

• 默认值为 false。

CUDNN_ATTR_TENSOR_RAGGED_OFFSET_DESC

不规则张量，即内部维度具有嵌套可变长度列表的张量，将具有另一个称为不规则偏移描述符的张量，该张量包含内存中到下一个可变长度列表的偏移量。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；一个元素。

• 默认值为 None。

最终确定

使用 CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR 的 cudnnBackendFinalize() 可以具有以下返回值

CUDNN_STATUS_BAD_PARAM

遇到无效的属性值。一些示例包括

• 任何张量维度或步幅都不是正数。

• 张量对齐属性的值不能被数据类型的大小整除。

CUDNN_STATUS_NOT_SUPPORTED

遇到不支持的属性值。一些示例包括

• 数据类型属性为 CUDNN_DATA_INT8x4、CUDNN_DATA_UINT8x4 或 CUDNN_DATA_INT8x32。

• 数据类型属性为 CUDNN_DATA_INT8 且 CUDNN_ATTR_TENSOR_VECTOR_COUNT 值不是 1、4 或 32。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_VARIANT_PACK_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_VARIANT_PACK_DESCRIPTOR, &desc) 创建；cuDNN 后端变体包计划允许用户为操作图、工作区和计算中间结果的各种非虚拟张量（由唯一标识符标识）设置指向设备缓冲区的指针。

属性

CUDNN_ATTR_VARIANT_PACK_UNIQUE_IDS

每个数据指针的张量的唯一标识符。

• CUDNN_TYPE_INT64；零个或多个元素。

• 必需属性。

CUDNN_ATTR_VARIANT_PACK_DATA_POINTERS

张量数据设备指针。

• CUDNN_TYPE_VOID_PTR；零个或多个元素。

• 必需属性。

CUDNN_ATTR_VARIANT_PACK_INTERMEDIATES

中间设备指针。

• CUDNN_TYPE_VOID_PTR；零个或多个元素。

• 当前不支持。未来实现的占位符。

CUDNN_ATTR_VARIANT_PACK_WORKSPACE

工作区到设备指针。

• CUDNN_TYPE_VOID_PTR；一个元素。

• 必需属性。

最终确定

使用 cuDNN 后端变体包描述符调用 cudnnBackendFinalize() 时的返回值是

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_KERNEL_CACHE_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_KERNEL_CACHE_DESCRIPTOR, &desc) 创建；cuDNN 后端内核缓存通过将先前编译的适用内核绑定到执行计划，而不是从头开始重新编译新内核，从而显著减少了具有相同拓扑动态形状操作图的用例的执行计划最终确定时间。这与启用 CUDNN_ATTR_OPERATIONGRAPH_IS_DYNAMIC_SHAPE_ENABLED 的图的执行计划一起使用。

属性

CUDNN_ATTR_KERNEL_CACHE_IS_ENGINECFG_KERNEL_CACHED

用于查询给定引擎配置是否已缓存的属性。

• CUDNN_TYPE_BACKEND_DESCRIPTOR；一个元素。

• 使用 cudnnBackendGetAttribute() API 的只读属性。有问题的引擎配置将作为常量输入通过 arrayOfElements 传递到此属性中，elementCount 将用作结果输出，零值表示未缓存，正数表示已缓存。

• 必需属性。

最终确定

使用 cuDNN 后端变体包描述符调用 cudnnBackendFinalize() 时的返回值是

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_BLOCK_SCALE_QUANTIZE_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_BLOCK_SCALE_QUANTIZE_DESCRIPTOR, &desc) 创建；cuDNN 块缩放量化描述符指定了块缩放量化操作的参数，以输出块缩放张量。

属性

CUDNN_ATTR_OPERATION_BLOCK_SCALE_QUANTIZE_MATH_PREC

计算的数学精度。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BLOCK_SCALE_QUANTIZE_BLOCK_SIZE

每个块中执行块缩放的元素数。

• CUDNN_TYPE_INT32；一个元素。

• 必需属性。

最终确定

使用 cuDNN 后端块缩放量化描述符调用 cudnnBackendFinalize() 时的返回值是

CUDNN_STATUS_BAD_PARAM

遇到无效的属性值。一些示例包括

• x、y 和缩放张量之间的张量形状不匹配。

• y 和缩放张量之间的数据类型不匹配。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

CUDNN_BACKEND_OPERATION_BLOCK_SCALE_DEQUANTIZE_DESCRIPTOR

使用 cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_BLOCK_SCALE_DEQUANTIZE_DESCRIPTOR, &desc) 创建；cuDNN 块缩放反量化描述符指定了块缩放反量化操作的参数，以接收块缩放张量。

属性

CUDNN_ATTR_OPERATION_BLOCK_SCALE_DEQUANTIZE_MATH_PREC

计算的数学精度。

• CUDNN_TYPE_DATA_TYPE； 一个元素。

• 必需属性。

CUDNN_ATTR_OPERATION_BLOCK_SCALE_DEQUANTIZE_BLOCK_SIZE

每个块中执行块缩放的元素数。

• CUDNN_TYPE_INT32；一个元素。

• 必需属性。

最终确定

使用 cuDNN 后端块缩放反量化描述符调用 cudnnBackendFinalize() 时的返回值是

CUDNN_STATUS_BAD_PARAM

遇到无效的属性值。一些示例包括

• x、缩放和 y 张量之间的张量形状不匹配。

• x 和缩放张量之间的数据类型不匹配。

CUDNN_STATUS_SUCCESS

描述符已成功最终确定。

用例

本节介绍 cuDNN 后端 API 的一些典型用例；例如，设置简单的操作图、为该操作图设置引擎配置，以及最终设置执行计划并使用在变体包描述符中设置的数据指针来执行它。还给出了 cuDNN 的原生 CUDA 图 API 的示例。

为分组卷积设置操作图

此用例创建一个操作图，其中包含单个分组 3D 卷积前向操作。它首先设置输入和输出张量，将它们绑定到卷积前向操作，最后设置一个包含单个节点的操作图。

1. 创建张量描述符。

   cudnnBackendDescriptor_t xDesc;
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_TENSOR_DESCRIPTOR, &xDesc);
   
   cudnnDataType_t dtype = CUDNN_DATA_FLOAT;
   cudnnBackendSetAttribute(xDesc, CUDNN_ATTR_TENSOR_DATA_TYPE,
                           CUDNN_TYPE_DATA_TYPE, 1, &dtype);
   
   int64_t xDim[] = {n, g, c, d, h, w};
   int64_t xStr[] = {g * c * d * h * w, c *d *h *w, d *h *w, h *w, w, 1};
   int64_t xUi = 'x';
   int64_t alignment = 4;
   
   cudnnBackendSetAttribute(xDesc, CUDNN_ATTR_TENSOR_DIMENSIONS,
                           CUDNN_TYPE_INT64, 6, xDim);
   
   cudnnBackendSetAttribute(xDesc, CUDNN_ATTR_TENSOR_STRIDES,
                           CUDNN_TYPE_INT64, 6, xStr);
   
   cudnnBackendSetAttribute(xDesc, CUDNN_ATTR_TENSOR_UNIQUE_ID,
                           CUDNN_TYPE_INT64, 1, &xUi);
   
   cudnnBackendSetAttribute(xDesc, CUDNN_ATTR_TENSOR_BYTE_ALIGNMENT,
                           CUDNN_TYPE_INT64, 1, &alignment);
   
   cudnnBackendFinalize(xDesc);
   

2. 对卷积滤波器和输出张量描述符重复上述步骤。六个滤波器张量维度为 [g, k, c, t, r, s]，六个输出张量维度分别为 [n, g, k, o, p, q]。在下面，当最终确定张量绑定到的卷积运算符时，将检查维度一致性，这意味着三个张量之间共享的所有 n、g、c、k 值都必须相同。否则，将返回 CUDNN_STATUS_BAD_PARAM 状态。

   为了与 cudnnTensorDescriptor_t 中张量的指定方式以及在卷积 API 中的使用方式向后兼容，也可以指定具有以下维度的 5D 张量

   • 图像：[n, g*c, d, h, w]

   • 滤波器：[g*k, c, t, r, s]

   • 响应：[n, g*k, o, p, q]

   在这种格式中，当最终确定张量绑定到的卷积运算符描述符时，也会执行类似的兼容性检查。

3. 创建、设置和最终确定卷积运算符描述符。

   cudnnBackendDescriptor_t cDesc;
   int64_t nbDims = 3;
   cudnnDataType_t compType = CUDNN_DATA_FLOAT;
   cudnnConvolutionMode_t mode = CUDNN_CONVOLUTION;
   int64_t pad[] = {0, 0, 0};
   int64_t filterStr[] = {1, 1, 1};
   int64_t dilation[] = {1, 1, 1};
   
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_CONVOLUTION_DESCRIPTOR, &cDesc);
   
   cudnnBackendSetAttribute(cDesc, CUDNN_ATTR_CONVOLUTION_SPATIAL_DIMS,
                           CUDNN_TYPE_INT64, 1, &nbDims);
   
   cudnnBackendSetAttribute(cDesc, CUDNN_ATTR_CONVOLUTION_COMP_TYPE,
                           CUDNN_TYPE_DATA_TYPE, 1, &compType);
   
   cudnnBackendSetAttribute(cDesc, CUDNN_ATTR_CONVOLUTION_CONV_MODE,
                           CUDNN_TYPE_CONVOLUTION_MODE, 1, &mode);
   
   cudnnBackendSetAttribute(cDesc, CUDNN_ATTR_CONVOLUTION_PRE_PADDINGS,
                           CUDNN_TYPE_INT64, nbDims, pad);
   
   cudnnBackendSetAttribute(cDesc, CUDNN_ATTR_CONVOLUTION_POST_PADDINGS,
                           CUDNN_TYPE_INT64, nbDims, pad);
   
   cudnnBackendSetAttribute(cDesc, CUDNN_ATTR_CONVOLUTION_DILATIONS,
                           CUDNN_TYPE_INT64, nbDims, dilation);
   
   cudnnBackendSetAttribute(cDesc, CUDNN_ATTR_CONVOLUTION_FILTER_STRIDES,
                           CUDNN_TYPE_INT64, nbDims, filterStr);
   cudnnBackendFinalize(cDesc);
   

4. 创建、设置和最终确定卷积前向操作描述符。

   cudnnBackendDescriptor_t fprop;
   float alpha = 1.0;
   float beta = 0.5;
   
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,
                   &fprop);
   cudnnBackendSetAttribute(fprop, CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_X,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &xDesc);
   cudnnBackendSetAttribute(fprop, CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_W,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &wDesc);
   cudnnBackendSetAttribute(fprop, CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &yDesc);
   cudnnBackendSetAttribute(fprop,
   CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &cDesc);
   
   cudnnBackendSetAttribute(fprop, CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA,
                           CUDNN_TYPE_FLOAT, 1, &alpha);
   cudnnBackendSetAttribute(fprop, CUDNN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA,
                           CUDNN_TYPE_FLOAT, 1, &beta);
   
   cudnnBackendFinalize(fprop);
   

5. 创建、设置和最终确定操作图描述符。

   cudnnBackendDescriptor_t op_graph;
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_OPERATIONGRAPH_DESCRIPTOR, &op_graph);
   cudnnBackendSetAttribute(op_graph, CUDNN_ATTR_OPERATIONGRAPH_OPS,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &fprop);
   cudnnBackendSetAttribute(op_graph, CUDNN_ATTR_OPERATIONGRAPH_HANDLE,
                           CUDNN_TYPE_HANDLE, 1, &handle);
   cudnnBackendFinalize(op_graph);
   

设置引擎配置

此用例描述了用户可以使用先前最终确定的操作图设置引擎配置的步骤。这是一个示例，其中用户希望将引擎与此操作图的 CUDNN_ATTR_ENGINE_GLOBAL_INDEX 0 一起使用，并且不设置任何性能旋钮。

1. 创建、设置和最终确定引擎描述符。

   cudnnBackendDescriptor_t engine;
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_ENGINE_DESCRIPTOR, &engine);
   cudnnBackendSetAttribute(engine, CUDNN_ATTR_ENGINE_OPERATION_GRAPH,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &op_graph);
   int64_t gidx = 0;
   cudnnBackendSetAttribute(engine, CUDNN_ATTR_ENGINE_GLOBAL_INDEX,
                           CUDNN_TYPE_INT64, 1, &gidx);
   cudnnBackendFinalize(engine);
   

   用户可以使用 cudnnBackendGetAttribute() API 调用查询最终确定的引擎描述符的属性，包括它具有的性能旋钮。为简单起见，此用例跳过此步骤，并假设用户在下面设置引擎配置描述符时未对性能旋钮进行任何更改。

2. 创建、设置和最终确定引擎配置描述符。从引擎配置中获取工作区大小。

   cudnnBackendDescriptor_t engcfg;
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_ENGINECFG_DESCRIPTOR, &engcfg);
   cudnnBackendSetAttribute(engcfg, CUDNN_ATTR_ENGINECFG_ENGINE,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &engine);
   cudnnBackendFinalize(engcfg);
   
   int64_t workspaceSize;
   cudnnBackendGetAttribute(engcfg, CUDNN_ATTR_ENGINECFG_WORKSPACE_SIZE,
                           CUDNN_TYPE_INT64, 1, NULL, &workspaceSize);
   

设置和执行计划

此用例描述了用户使用先前最终确定的引擎配置描述符设置执行计划、设置数据指针变体包，并最终执行计划的步骤。

1. 创建、设置和最终确定执行计划描述符。获取要分配的工作区大小。

   cudnnBackendDescriptor_t plan;
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR, &plan);
   cudnnBackendSetAttribute(plan, CUDNN_ATTR_EXECUTION_PLAN_HANDLE, CUDNN_TYPE_HANDLE, 1, &handle);
   cudnnBackendSetAttribute(plan, CUDNN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG,
                           CUDNN_TYPE_BACKEND_DESCRIPTOR, 1, &engcfg);
   cudnnBackendFinalize(plan);
   
   int64_t workspaceSize;
   cudnnBackendGetAttribute(plan, CUDNN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE,
                           CUDNN_TYPE_INT64, 1, NULL, &workspaceSize);
   

2. 创建、设置和最终确定变体包描述符。

   void *dev_ptrs[3] = {xData, wData, yData}; // device pointer
   int64_t uids[3] = {'x', 'w', 'y'};
   void *workspace;
   
   cudnnBackendDescriptor_t varpack;
   cudnnBackendCreateDescriptor(CUDNN_BACKEND_VARIANT_PACK_DESCRIPTOR, &varpack);
   cudnnBackendSetAttribute(varpack, CUDNN_ATTR_VARIANT_PACK_DATA_POINTERS,
                           CUDNN_TYPE_VOID_PTR, 3, dev_ptrs);
   cudnnBackendSetAttribute(varpack, CUDNN_ATTR_VARIANT_PACK_UNIQUE_IDS,
                           CUDNN_TYPE_INT64, 3, uids);
   cudnnBackendSetAttribute(varpack, CUDNN_ATTR_VARIANT_PACK_WORKSPACE,
                           CUDNN_TYPE_VOID_PTR, 1, &workspace);
   cudnnBackendFinalize(varpack);
   

3. 使用变体包执行计划。

   cudnnBackendExecute(handle, plan, varpack);
   

从计划创建和更新 CUDA 图

此用例描述了用户使用先前最终确定的执行计划和变体包创建 CUDA 图、在所需的流上执行该图以及使用新的变体包更新该图的步骤。请注意，此用例目前仅适用于有限选择的 cuDNN 引擎。

1. 创建 CUDA 图。

   cudaGraph_t cuda_graph;
   cudaGraphCreate(&cuda_graph, 0);
   cudnnBackendPopulateCudaGraph(handle, plan, varpack, cuda_graph);
   

2. 实例化和执行 CUDA 图。

   cudaGraphExec_t cuda_graph_exec;
   cudaGraphInstantiate (&cuda_graph_exec, cuda_graph);
   cudaGraphLaunch(instance, stream);  // stream is a cudaStream_t
   cudaStreamSynchronize(stream);
   

3. 更新 CUDA 图，更新实例化的图并重新执行该图。（这可以执行任意次数。）

   cudaGraphExec_t cuda_graph_exec;
   cudnnBackendUpdateCudaGraph(handle, plan, new_varpack, cuda_graph);
   cudaGraphExecUpdateResultInfo result_info;
   cudaGraphExecUpdate(cuda_graph_exec, cuda_graph, &result_info);
   cudaGraphLaunch(instance, stream);
   cudaStreamSynchronize(stream);
   

4. 在我们完成所有操作后销毁 CUDA 图。

   cudaGraphDestroy(cuda_graph);