From 6c8ae19be66cee247980a48e736a4e05d14de179 Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Tue, 2 Dec 2025 16:39:36 -0800 Subject: Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDK --- .../include/directx/DirectML.h | 2651 ++++++++++++++++++++ 1 file changed, 2651 insertions(+) create mode 100644 contrib/DirectX-Headers-1.618.2/include/directx/DirectML.h (limited to 'contrib/DirectX-Headers-1.618.2/include/directx/DirectML.h') diff --git a/contrib/DirectX-Headers-1.618.2/include/directx/DirectML.h b/contrib/DirectX-Headers-1.618.2/include/directx/DirectML.h new file mode 100644 index 0000000..3bd1921 --- /dev/null +++ b/contrib/DirectX-Headers-1.618.2/include/directx/DirectML.h @@ -0,0 +1,2651 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. + +#ifndef DIRECTML_H +#define DIRECTML_H +#pragma once + +#ifdef _GAMING_XBOX_SCARLETT +#include "d3d12_xs.h" +#elif _GAMING_XBOX_XBOXONE +#include "d3d12_x.h" +#else +#include "d3d12.h" +#endif + +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) + +#ifndef DML_DECLARE_INTERFACE +#define DML_DECLARE_INTERFACE(iid) DECLSPEC_UUID(iid) DECLSPEC_NOVTABLE +#endif + +#ifndef DML_TARGET_VERSION + +#if !defined(NTDDI_VERSION) || defined(DML_TARGET_VERSION_USE_LATEST) // Use the latest if using redist or no Windows target set. +#define DML_TARGET_VERSION 0x6400 +#elif defined(NTDDI_WIN10_ZN) && NTDDI_VERSION >= NTDDI_WIN10_ZN +#define DML_TARGET_VERSION 0x6000 +#elif defined(NTDDI_WIN10_NI) && NTDDI_VERSION >= NTDDI_WIN10_NI +#define DML_TARGET_VERSION 0x5000 +#elif defined(NTDDI_WIN10_CO) && NTDDI_VERSION >= NTDDI_WIN10_CO +#define DML_TARGET_VERSION 0x4000 +#elif defined(NTDDI_WIN10_FE) && NTDDI_VERSION >= NTDDI_WIN10_FE +#define DML_TARGET_VERSION 0x3000 +#elif defined(NTDDI_WIN10_VB) && NTDDI_VERSION >= NTDDI_WIN10_VB // Windows 10 2004 Update +#define DML_TARGET_VERSION 0x2000 +#else // defined(NTDDI_WIN10_19H1) && NTDDI_VERSION >= NTDDI_WIN10_19H1 // Windows 10 1903 Update +#define DML_TARGET_VERSION 0x1000 +#endif + +#endif // !defined(DML_TARGET_VERSION) + +// =================================================================================================================== +// DirectML constants +// =================================================================================================================== + +static const UINT DML_TENSOR_DIMENSION_COUNT_MAX = 5; +#if DML_TARGET_VERSION >= 0x3000 +static const UINT DML_TENSOR_DIMENSION_COUNT_MAX1 = 8; +#endif + +static const UINT DML_TEMPORARY_BUFFER_ALIGNMENT = 256; +static const UINT DML_PERSISTENT_BUFFER_ALIGNMENT = 256; + +static const UINT DML_MINIMUM_BUFFER_TENSOR_ALIGNMENT = 16; + + +// =================================================================================================================== +// Interface declarations +// =================================================================================================================== + +interface IDMLObject; +interface IDMLDevice; +interface IDMLDeviceChild; +interface IDMLPageable; +interface IDMLDispatchable; +interface IDMLOperator; +interface IDMLCompiledOperator; +interface IDMLOperatorInitializer; +interface IDMLBindingTable; +interface IDMLCommandRecorder; + + +// =================================================================================================================== +// Tensor descriptions +// =================================================================================================================== + +enum DML_TENSOR_DATA_TYPE +{ + DML_TENSOR_DATA_TYPE_UNKNOWN, + DML_TENSOR_DATA_TYPE_FLOAT32, + DML_TENSOR_DATA_TYPE_FLOAT16, + DML_TENSOR_DATA_TYPE_UINT32, + DML_TENSOR_DATA_TYPE_UINT16, + DML_TENSOR_DATA_TYPE_UINT8, + DML_TENSOR_DATA_TYPE_INT32, + DML_TENSOR_DATA_TYPE_INT16, + DML_TENSOR_DATA_TYPE_INT8, + DML_TENSOR_DATA_TYPE_FLOAT64, + DML_TENSOR_DATA_TYPE_UINT64, + DML_TENSOR_DATA_TYPE_INT64, +#if DML_TARGET_VERSION >= 0x6300 + DML_TENSOR_DATA_TYPE_UINT4, + DML_TENSOR_DATA_TYPE_INT4, +#endif // DML_TARGET_VERSION >= 0x6300 +}; + +enum DML_TENSOR_TYPE +{ + DML_TENSOR_TYPE_INVALID, + + DML_TENSOR_TYPE_BUFFER, +}; + +enum DML_TENSOR_FLAGS +{ + DML_TENSOR_FLAG_NONE = 0x0, + DML_TENSOR_FLAG_OWNED_BY_DML = 0x1, +}; + +DEFINE_ENUM_FLAG_OPERATORS(DML_TENSOR_FLAGS) + +struct DML_BUFFER_TENSOR_DESC +{ + DML_TENSOR_DATA_TYPE DataType; + DML_TENSOR_FLAGS Flags; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Sizes; + _Field_size_opt_(DimensionCount) const UINT* Strides; + UINT64 TotalTensorSizeInBytes; + UINT GuaranteedBaseOffsetAlignment; +}; + +struct DML_TENSOR_DESC +{ + DML_TENSOR_TYPE Type; + _Field_size_(_Inexpressible_("Dependent on tensor type")) const void* Desc; +}; + + +// =================================================================================================================== +// Operator types +// =================================================================================================================== + +enum DML_OPERATOR_TYPE +{ + DML_OPERATOR_INVALID, + + DML_OPERATOR_ELEMENT_WISE_IDENTITY, + DML_OPERATOR_ELEMENT_WISE_ABS, + DML_OPERATOR_ELEMENT_WISE_ACOS, + DML_OPERATOR_ELEMENT_WISE_ADD, + DML_OPERATOR_ELEMENT_WISE_ASIN, + DML_OPERATOR_ELEMENT_WISE_ATAN, + DML_OPERATOR_ELEMENT_WISE_CEIL, + DML_OPERATOR_ELEMENT_WISE_CLIP, + DML_OPERATOR_ELEMENT_WISE_COS, + DML_OPERATOR_ELEMENT_WISE_DIVIDE, + DML_OPERATOR_ELEMENT_WISE_EXP, + DML_OPERATOR_ELEMENT_WISE_FLOOR, + DML_OPERATOR_ELEMENT_WISE_LOG, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_AND, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_EQUALS, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_GREATER_THAN, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_LESS_THAN, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_NOT, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_OR, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_XOR, + DML_OPERATOR_ELEMENT_WISE_MAX, + DML_OPERATOR_ELEMENT_WISE_MEAN, + DML_OPERATOR_ELEMENT_WISE_MIN, + DML_OPERATOR_ELEMENT_WISE_MULTIPLY, + DML_OPERATOR_ELEMENT_WISE_POW, + DML_OPERATOR_ELEMENT_WISE_CONSTANT_POW, + DML_OPERATOR_ELEMENT_WISE_RECIP, + DML_OPERATOR_ELEMENT_WISE_SIN, + DML_OPERATOR_ELEMENT_WISE_SQRT, + DML_OPERATOR_ELEMENT_WISE_SUBTRACT, + DML_OPERATOR_ELEMENT_WISE_TAN, + DML_OPERATOR_ELEMENT_WISE_THRESHOLD, + DML_OPERATOR_ELEMENT_WISE_QUANTIZE_LINEAR, + DML_OPERATOR_ELEMENT_WISE_DEQUANTIZE_LINEAR, + DML_OPERATOR_ACTIVATION_ELU, + DML_OPERATOR_ACTIVATION_HARDMAX, + DML_OPERATOR_ACTIVATION_HARD_SIGMOID, + DML_OPERATOR_ACTIVATION_IDENTITY, + DML_OPERATOR_ACTIVATION_LEAKY_RELU, + DML_OPERATOR_ACTIVATION_LINEAR, + DML_OPERATOR_ACTIVATION_LOG_SOFTMAX, + DML_OPERATOR_ACTIVATION_PARAMETERIZED_RELU, + DML_OPERATOR_ACTIVATION_PARAMETRIC_SOFTPLUS, + DML_OPERATOR_ACTIVATION_RELU, + DML_OPERATOR_ACTIVATION_SCALED_ELU, + DML_OPERATOR_ACTIVATION_SCALED_TANH, + DML_OPERATOR_ACTIVATION_SIGMOID, + DML_OPERATOR_ACTIVATION_SOFTMAX, + DML_OPERATOR_ACTIVATION_SOFTPLUS, + DML_OPERATOR_ACTIVATION_SOFTSIGN, + DML_OPERATOR_ACTIVATION_TANH, + DML_OPERATOR_ACTIVATION_THRESHOLDED_RELU, + DML_OPERATOR_CONVOLUTION, + DML_OPERATOR_GEMM, + DML_OPERATOR_REDUCE, + DML_OPERATOR_AVERAGE_POOLING, + DML_OPERATOR_LP_POOLING, + DML_OPERATOR_MAX_POOLING, + DML_OPERATOR_ROI_POOLING, + DML_OPERATOR_SLICE, + DML_OPERATOR_CAST, + DML_OPERATOR_SPLIT, + DML_OPERATOR_JOIN, + DML_OPERATOR_PADDING, + DML_OPERATOR_VALUE_SCALE_2D, + DML_OPERATOR_UPSAMPLE_2D, + DML_OPERATOR_GATHER, + DML_OPERATOR_SPACE_TO_DEPTH, + DML_OPERATOR_DEPTH_TO_SPACE, + DML_OPERATOR_TILE, + DML_OPERATOR_TOP_K, + DML_OPERATOR_BATCH_NORMALIZATION, + DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION, + DML_OPERATOR_LOCAL_RESPONSE_NORMALIZATION, + DML_OPERATOR_LP_NORMALIZATION, + DML_OPERATOR_RNN, + DML_OPERATOR_LSTM, + DML_OPERATOR_GRU, + +#if DML_TARGET_VERSION >= 0x2000 + DML_OPERATOR_ELEMENT_WISE_SIGN, + DML_OPERATOR_ELEMENT_WISE_IS_NAN, + DML_OPERATOR_ELEMENT_WISE_ERF, + DML_OPERATOR_ELEMENT_WISE_SINH, + DML_OPERATOR_ELEMENT_WISE_COSH, + DML_OPERATOR_ELEMENT_WISE_TANH, + DML_OPERATOR_ELEMENT_WISE_ASINH, + DML_OPERATOR_ELEMENT_WISE_ACOSH, + DML_OPERATOR_ELEMENT_WISE_ATANH, + DML_OPERATOR_ELEMENT_WISE_IF, + DML_OPERATOR_ELEMENT_WISE_ADD1, + DML_OPERATOR_ACTIVATION_SHRINK, + DML_OPERATOR_MAX_POOLING1, + DML_OPERATOR_MAX_UNPOOLING, + DML_OPERATOR_DIAGONAL_MATRIX, + DML_OPERATOR_SCATTER_ELEMENTS, + DML_OPERATOR_SCATTER = DML_OPERATOR_SCATTER_ELEMENTS, // Alias name for backwards compatibility. + DML_OPERATOR_ONE_HOT, + DML_OPERATOR_RESAMPLE, +#endif // DML_TARGET_VERSION >= 0x2000 + +#if DML_TARGET_VERSION >= 0x2100 + DML_OPERATOR_ELEMENT_WISE_BIT_SHIFT_LEFT, + DML_OPERATOR_ELEMENT_WISE_BIT_SHIFT_RIGHT, + DML_OPERATOR_ELEMENT_WISE_ROUND, + DML_OPERATOR_ELEMENT_WISE_IS_INFINITY, + DML_OPERATOR_ELEMENT_WISE_MODULUS_TRUNCATE, + DML_OPERATOR_ELEMENT_WISE_MODULUS_FLOOR, + DML_OPERATOR_FILL_VALUE_CONSTANT, + DML_OPERATOR_FILL_VALUE_SEQUENCE, + DML_OPERATOR_CUMULATIVE_SUMMATION, + DML_OPERATOR_REVERSE_SUBSEQUENCES, + DML_OPERATOR_GATHER_ELEMENTS, + DML_OPERATOR_GATHER_ND, + DML_OPERATOR_SCATTER_ND, + DML_OPERATOR_MAX_POOLING2, + DML_OPERATOR_SLICE1, + DML_OPERATOR_TOP_K1, + DML_OPERATOR_DEPTH_TO_SPACE1, + DML_OPERATOR_SPACE_TO_DEPTH1, + DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION1, + DML_OPERATOR_RESAMPLE1, + DML_OPERATOR_MATRIX_MULTIPLY_INTEGER, + DML_OPERATOR_QUANTIZED_LINEAR_MATRIX_MULTIPLY, + DML_OPERATOR_CONVOLUTION_INTEGER, + DML_OPERATOR_QUANTIZED_LINEAR_CONVOLUTION, +#endif // DML_TARGET_VERSION >= 0x2100 + +#if DML_TARGET_VERSION >= 0x3000 + DML_OPERATOR_ELEMENT_WISE_BIT_AND, + DML_OPERATOR_ELEMENT_WISE_BIT_OR, + DML_OPERATOR_ELEMENT_WISE_BIT_XOR, + DML_OPERATOR_ELEMENT_WISE_BIT_NOT, + DML_OPERATOR_ELEMENT_WISE_BIT_COUNT, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL, + DML_OPERATOR_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL, + DML_OPERATOR_ACTIVATION_CELU, + DML_OPERATOR_ACTIVATION_RELU_GRAD, + DML_OPERATOR_AVERAGE_POOLING_GRAD, + DML_OPERATOR_MAX_POOLING_GRAD, + DML_OPERATOR_RANDOM_GENERATOR, + DML_OPERATOR_NONZERO_COORDINATES, + DML_OPERATOR_RESAMPLE_GRAD, + DML_OPERATOR_SLICE_GRAD, + DML_OPERATOR_ADAM_OPTIMIZER, + DML_OPERATOR_ARGMIN, + DML_OPERATOR_ARGMAX, + DML_OPERATOR_ROI_ALIGN, + DML_OPERATOR_GATHER_ND1, +#endif // DML_TARGET_VERSION >= 0x3000 + +#if DML_TARGET_VERSION >= 0x3100 + DML_OPERATOR_ELEMENT_WISE_ATAN_YX, + DML_OPERATOR_ELEMENT_WISE_CLIP_GRAD, + DML_OPERATOR_ELEMENT_WISE_DIFFERENCE_SQUARE, + DML_OPERATOR_LOCAL_RESPONSE_NORMALIZATION_GRAD, + DML_OPERATOR_CUMULATIVE_PRODUCT, + DML_OPERATOR_BATCH_NORMALIZATION_GRAD, +#endif // DML_TARGET_VERSION >= 0x3100 + +#if DML_TARGET_VERSION >= 0x4000 + DML_OPERATOR_ELEMENT_WISE_QUANTIZED_LINEAR_ADD, + DML_OPERATOR_DYNAMIC_QUANTIZE_LINEAR, + DML_OPERATOR_ROI_ALIGN1, +#endif // DML_TARGET_VERSION >= 0x4000 + +#if DML_TARGET_VERSION >= 0x4100 + DML_OPERATOR_ROI_ALIGN_GRAD, + DML_OPERATOR_BATCH_NORMALIZATION_TRAINING, + DML_OPERATOR_BATCH_NORMALIZATION_TRAINING_GRAD, +#endif // DML_TARGET_VERSION >= 0x4100 + +#if DML_TARGET_VERSION >= 0x5000 + DML_OPERATOR_ELEMENT_WISE_CLIP1, + DML_OPERATOR_ELEMENT_WISE_CLIP_GRAD1, + DML_OPERATOR_PADDING1, + DML_OPERATOR_ELEMENT_WISE_NEGATE, +#endif // DML_TARGET_VERSION >= 0x5000 + +#if DML_TARGET_VERSION >= 0x5100 + DML_OPERATOR_ACTIVATION_GELU, + DML_OPERATOR_ACTIVATION_SOFTMAX1, + DML_OPERATOR_ACTIVATION_LOG_SOFTMAX1, + DML_OPERATOR_ACTIVATION_HARDMAX1, + DML_OPERATOR_RESAMPLE2, + DML_OPERATOR_RESAMPLE_GRAD1, + DML_OPERATOR_DIAGONAL_MATRIX1, +#endif // DML_TARGET_VERSION >= 0x5100 + +#if DML_TARGET_VERSION >= 0x6100 + DML_OPERATOR_MULTIHEAD_ATTENTION, +#endif // DML_TARGET_VERSION >= 0x6100 + +#if DML_TARGET_VERSION >= 0x6200 + DML_OPERATOR_LP_POOLING1, + DML_OPERATOR_AVERAGE_POOLING1, + DML_OPERATOR_ACTIVATION_SWISH, + DML_OPERATOR_ACTIVATION_HARD_SWISH, + DML_OPERATOR_QUANTIZED_LINEAR_AVERAGE_POOLING, + DML_OPERATOR_MATRIX_MULTIPLY_INTEGER_TO_FLOAT, +#endif // DML_TARGET_VERSION >= 0x6200 + +#if DML_TARGET_VERSION >= 0x6300 + DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION2, + DML_OPERATOR_MULTIHEAD_ATTENTION1, + DML_OPERATOR_QUANTIZE, + DML_OPERATOR_DEQUANTIZE, +#endif // DML_TARGET_VERSION >= 0x6300 + +#if DML_TARGET_VERSION >= 0x6400 + DML_OPERATOR_RESAMPLE3, + DML_OPERATOR_FOLD, + DML_OPERATOR_UNFOLD, +#endif // DML_TARGET_VERSION >= 0x6400 +}; + +// =================================================================================================================== +// Operator enumerations and structures +// =================================================================================================================== + +enum DML_REDUCE_FUNCTION +{ + DML_REDUCE_FUNCTION_ARGMAX, + DML_REDUCE_FUNCTION_ARGMIN, + DML_REDUCE_FUNCTION_AVERAGE, + DML_REDUCE_FUNCTION_L1, + DML_REDUCE_FUNCTION_L2, + DML_REDUCE_FUNCTION_LOG_SUM, + DML_REDUCE_FUNCTION_LOG_SUM_EXP, + DML_REDUCE_FUNCTION_MAX, + DML_REDUCE_FUNCTION_MIN, + DML_REDUCE_FUNCTION_MULTIPLY, + DML_REDUCE_FUNCTION_SUM, + DML_REDUCE_FUNCTION_SUM_SQUARE, +}; + +enum DML_MATRIX_TRANSFORM +{ + DML_MATRIX_TRANSFORM_NONE, + DML_MATRIX_TRANSFORM_TRANSPOSE, +}; + +enum DML_CONVOLUTION_MODE +{ + DML_CONVOLUTION_MODE_CONVOLUTION, + DML_CONVOLUTION_MODE_CROSS_CORRELATION, +}; + +enum DML_CONVOLUTION_DIRECTION +{ + DML_CONVOLUTION_DIRECTION_FORWARD, + DML_CONVOLUTION_DIRECTION_BACKWARD, +}; + +enum DML_PADDING_MODE +{ + DML_PADDING_MODE_CONSTANT, + DML_PADDING_MODE_EDGE, + DML_PADDING_MODE_REFLECTION, + +#if DML_TARGET_VERSION >= 0x3000 + DML_PADDING_MODE_SYMMETRIC, +#endif + +#if DML_TARGET_VERSION >= 0x6400 + DML_PADDING_MODE_WRAP, +#endif +}; + +enum DML_INTERPOLATION_MODE +{ + DML_INTERPOLATION_MODE_NEAREST_NEIGHBOR, + DML_INTERPOLATION_MODE_LINEAR, +}; + +struct DML_SCALE_BIAS +{ + FLOAT Scale; + FLOAT Bias; +}; + +struct DML_SIZE_2D +{ + UINT Width; + UINT Height; +}; + +enum DML_RECURRENT_NETWORK_DIRECTION +{ + DML_RECURRENT_NETWORK_DIRECTION_FORWARD, + DML_RECURRENT_NETWORK_DIRECTION_BACKWARD, + DML_RECURRENT_NETWORK_DIRECTION_BIDIRECTIONAL, +}; + +#if DML_TARGET_VERSION >= 0x2100 + +enum DML_ROUNDING_MODE +{ + DML_ROUNDING_MODE_HALVES_TO_NEAREST_EVEN, + DML_ROUNDING_MODE_TOWARD_ZERO, + DML_ROUNDING_MODE_TOWARD_INFINITY, +}; + +enum DML_IS_INFINITY_MODE +{ + DML_IS_INFINITY_MODE_EITHER = 0, + DML_IS_INFINITY_MODE_POSITIVE = 1, + DML_IS_INFINITY_MODE_NEGATIVE = 2, +}; + +enum DML_AXIS_DIRECTION +{ + DML_AXIS_DIRECTION_INCREASING = 0, + DML_AXIS_DIRECTION_DECREASING = 1, +}; + +enum DML_DEPTH_SPACE_ORDER +{ + DML_DEPTH_SPACE_ORDER_DEPTH_COLUMN_ROW, + DML_DEPTH_SPACE_ORDER_COLUMN_ROW_DEPTH, +}; + +union DML_SCALAR_UNION +{ + BYTE Bytes[8]; + INT8 Int8; + UINT8 UInt8; + INT16 Int16; + UINT16 UInt16; + INT32 Int32; + UINT32 UInt32; + INT64 Int64; + UINT64 UInt64; + FLOAT Float32; + DOUBLE Float64; +}; + +#endif // DML_TARGET_VERSION >= 0x2100 + +#if DML_TARGET_VERSION >= 0x3000 + +enum DML_RANDOM_GENERATOR_TYPE +{ + DML_RANDOM_GENERATOR_TYPE_PHILOX_4X32_10 +}; + +#endif // DML_TARGET_VERSION >= 0x3000 + +#if DML_TARGET_VERSION >= 0x6100 + +enum DML_MULTIHEAD_ATTENTION_MASK_TYPE +{ + DML_MULTIHEAD_ATTENTION_MASK_TYPE_NONE, + DML_MULTIHEAD_ATTENTION_MASK_TYPE_KEY_SEQUENCE_LENGTH, + DML_MULTIHEAD_ATTENTION_MASK_TYPE_KEY_SEQUENCE_END_START, + DML_MULTIHEAD_ATTENTION_MASK_TYPE_KEY_QUERY_SEQUENCE_LENGTH_START_END, + DML_MULTIHEAD_ATTENTION_MASK_TYPE_BOOLEAN, +}; + +#endif // DML_TARGET_VERSION >= 0x6100 + +#if DML_TARGET_VERSION >= 0x6300 + +enum DML_QUANTIZATION_TYPE +{ + DML_QUANTIZATION_TYPE_NONE, + DML_QUANTIZATION_TYPE_SCALE, + DML_QUANTIZATION_TYPE_SCALE_ZERO_POINT, +}; + +#endif // DML_TARGET_VERSION >= 0x6300 + +// =================================================================================================================== +// Operator descriptions +// =================================================================================================================== + +struct DML_OPERATOR_DESC +{ + DML_OPERATOR_TYPE Type; + _Field_size_(_Inexpressible_("Dependent on operator type")) const void* Desc; +}; + +struct DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_ABS_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_ACOS_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_ADD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_ADD1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_ELEMENT_WISE_ASIN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_ATAN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_CEIL_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_CLIP_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; + FLOAT Min; + FLOAT Max; +}; + +struct DML_ELEMENT_WISE_COS_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_EXP_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_LOG_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_MAX_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_MEAN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_MIN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_POW_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* ExponentTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; + FLOAT Exponent; +}; + +struct DML_ELEMENT_WISE_RECIP_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_SIN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_SQRT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_TAN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; + FLOAT Min; +}; + +struct DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* ScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* ZeroPointTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* ScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* ZeroPointTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_ELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; +}; + +struct DML_ACTIVATION_HARDMAX_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; + FLOAT Beta; +}; + +struct DML_ACTIVATION_IDENTITY_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; +}; + +struct DML_ACTIVATION_LINEAR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; + FLOAT Beta; +}; + +struct DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* SlopeTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; + FLOAT Beta; +}; + +struct DML_ACTIVATION_RELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; + FLOAT Gamma; +}; + +struct DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; + FLOAT Beta; +}; + +struct DML_ACTIVATION_SIGMOID_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_SOFTMAX_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Steepness; +}; + +struct DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_TANH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; +}; + +struct DML_CONVOLUTION_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* FilterTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_CONVOLUTION_MODE Mode; + DML_CONVOLUTION_DIRECTION Direction; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* Dilations; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + _Field_size_(DimensionCount) const UINT* OutputPadding; + UINT GroupCount; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_GEMM_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + _Maybenull_ const DML_TENSOR_DESC* CTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_MATRIX_TRANSFORM TransA; + DML_MATRIX_TRANSFORM TransB; + FLOAT Alpha; + FLOAT Beta; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_REDUCE_OPERATOR_DESC +{ + DML_REDUCE_FUNCTION Function; + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; +}; + +struct DML_AVERAGE_POOLING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + BOOL IncludePadding; +}; + +struct DML_LP_POOLING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + UINT P; +}; + +struct DML_MAX_POOLING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; +}; + +struct DML_ROI_POOLING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* ROITensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT SpatialScale; + DML_SIZE_2D PooledSize; +}; + +struct DML_SLICE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Offsets; + _Field_size_(DimensionCount) const UINT* Sizes; + _Field_size_(DimensionCount) const UINT* Strides; +}; + +struct DML_CAST_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_SPLIT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + UINT OutputCount; + _Field_size_(OutputCount) const DML_TENSOR_DESC* OutputTensors; + UINT Axis; +}; + +struct DML_JOIN_OPERATOR_DESC +{ + UINT InputCount; + _Field_size_(InputCount) const DML_TENSOR_DESC* InputTensors; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; +}; + +struct DML_PADDING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_PADDING_MODE PaddingMode; + FLOAT PaddingValue; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; +}; + +struct DML_VALUE_SCALE_2D_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Scale; + UINT ChannelCount; + _Field_size_(ChannelCount) const FLOAT* Bias; +}; + +struct DML_UPSAMPLE_2D_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_SIZE_2D ScaleSize; + DML_INTERPOLATION_MODE InterpolationMode; +}; + +struct DML_GATHER_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; + UINT IndexDimensions; +}; + +struct DML_SPACE_TO_DEPTH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT BlockSize; +}; + +struct DML_DEPTH_TO_SPACE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT BlockSize; +}; + +struct DML_TILE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT RepeatsCount; + _Field_size_(RepeatsCount) const UINT* Repeats; +}; + +struct DML_TOP_K_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputValueTensor; + const DML_TENSOR_DESC* OutputIndexTensor; + UINT Axis; + UINT K; +}; + +struct DML_BATCH_NORMALIZATION_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* MeanTensor; + const DML_TENSOR_DESC* VarianceTensor; + const DML_TENSOR_DESC* ScaleTensor; + const DML_TENSOR_DESC* BiasTensor; + const DML_TENSOR_DESC* OutputTensor; + BOOL Spatial; + FLOAT Epsilon; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + _Maybenull_ const DML_TENSOR_DESC* ScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + const DML_TENSOR_DESC* OutputTensor; + BOOL CrossChannel; + BOOL NormalizeVariance; + FLOAT Epsilon; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + BOOL CrossChannel; + UINT LocalSize; + FLOAT Alpha; + FLOAT Beta; + FLOAT Bias; +}; + +struct DML_LP_NORMALIZATION_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; + FLOAT Epsilon; + UINT P; +}; + +struct DML_RNN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* WeightTensor; + const DML_TENSOR_DESC* RecurrenceTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + _Maybenull_ const DML_TENSOR_DESC* HiddenInitTensor; + _Maybenull_ const DML_TENSOR_DESC* SequenceLengthsTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputSequenceTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputSingleTensor; + UINT ActivationDescCount; + _Field_size_(ActivationDescCount) const DML_OPERATOR_DESC* ActivationDescs; + DML_RECURRENT_NETWORK_DIRECTION Direction; +}; + +struct DML_LSTM_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* WeightTensor; + const DML_TENSOR_DESC* RecurrenceTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + _Maybenull_ const DML_TENSOR_DESC* HiddenInitTensor; + _Maybenull_ const DML_TENSOR_DESC* CellMemInitTensor; + _Maybenull_ const DML_TENSOR_DESC* SequenceLengthsTensor; + _Maybenull_ const DML_TENSOR_DESC* PeepholeTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputSequenceTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputSingleTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputCellSingleTensor; + UINT ActivationDescCount; + _Field_size_(ActivationDescCount) const DML_OPERATOR_DESC* ActivationDescs; + DML_RECURRENT_NETWORK_DIRECTION Direction; + float ClipThreshold; + BOOL UseClipThreshold; + BOOL CoupleInputForget; +}; + +struct DML_GRU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* WeightTensor; + const DML_TENSOR_DESC* RecurrenceTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + _Maybenull_ const DML_TENSOR_DESC* HiddenInitTensor; + _Maybenull_ const DML_TENSOR_DESC* SequenceLengthsTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputSequenceTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputSingleTensor; + UINT ActivationDescCount; + _Field_size_(ActivationDescCount) const DML_OPERATOR_DESC* ActivationDescs; + DML_RECURRENT_NETWORK_DIRECTION Direction; + BOOL LinearBeforeReset; +}; + +#if DML_TARGET_VERSION >= 0x2000 + +struct DML_ELEMENT_WISE_SIGN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_ERF_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_SINH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_COSH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_TANH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_ASINH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_ATANH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; +}; + +struct DML_ELEMENT_WISE_IF_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ConditionTensor; + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_SHRINK_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Bias; + FLOAT Threshold; +}; + +struct DML_MAX_POOLING1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputIndicesTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; +}; + +struct DML_MAX_UNPOOLING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_DIAGONAL_MATRIX_OPERATOR_DESC +{ + const DML_TENSOR_DESC* OutputTensor; + INT Offset; + FLOAT Value; +}; + +struct DML_SCATTER_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* UpdatesTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; +}; + +struct DML_ONE_HOT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* ValuesTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; +}; + +struct DML_RESAMPLE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_INTERPOLATION_MODE InterpolationMode; + UINT ScaleCount; + _Field_size_(ScaleCount) const FLOAT* Scales; +}; + +#endif // DML_TARGET_VERSION >= 0x2000 + +#if DML_TARGET_VERSION >= 0x2100 + +struct DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_ROUND_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_ROUNDING_MODE RoundingMode; +}; + +struct DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_IS_INFINITY_MODE InfinityMode; +}; + +struct DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_FILL_VALUE_CONSTANT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* OutputTensor; + DML_TENSOR_DATA_TYPE ValueDataType; + DML_SCALAR_UNION Value; +}; + +struct DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* OutputTensor; + DML_TENSOR_DATA_TYPE ValueDataType; + DML_SCALAR_UNION ValueStart; + DML_SCALAR_UNION ValueDelta; +}; + +struct DML_CUMULATIVE_SUMMATION_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; + DML_AXIS_DIRECTION AxisDirection; + BOOL HasExclusiveSum; +}; + +struct DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* SequenceLengthsTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; +}; + +struct DML_GATHER_ELEMENTS_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; +}; + +// Alias existing operator, symmetric with DML_GATHER_ELEMENTS_OPERATOR_DESC. +using DML_SCATTER_ELEMENTS_OPERATOR_DESC = DML_SCATTER_OPERATOR_DESC; + +struct DML_GATHER_ND_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT InputDimensionCount; + UINT IndicesDimensionCount; +}; + +struct DML_SCATTER_ND_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* UpdatesTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT InputDimensionCount; + UINT IndicesDimensionCount; +}; + +struct DML_MAX_POOLING2_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputIndicesTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + _Field_size_(DimensionCount) const UINT* Dilations; +}; + +struct DML_SLICE1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* InputWindowOffsets; + _Field_size_(DimensionCount) const UINT* InputWindowSizes; + _Field_size_(DimensionCount) const INT* InputWindowStrides; +}; + +struct DML_TOP_K1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputValueTensor; + const DML_TENSOR_DESC* OutputIndexTensor; + UINT Axis; + UINT K; + DML_AXIS_DIRECTION AxisDirection; +}; + +struct DML_DEPTH_TO_SPACE1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT BlockSize; + DML_DEPTH_SPACE_ORDER Order; +}; + +struct DML_SPACE_TO_DEPTH1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT BlockSize; + DML_DEPTH_SPACE_ORDER Order; +}; + +struct DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + _Maybenull_ const DML_TENSOR_DESC* ScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; + BOOL NormalizeVariance; + FLOAT Epsilon; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_RESAMPLE1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_INTERPOLATION_MODE InterpolationMode; + UINT DimensionCount; + _Field_size_(DimensionCount) const FLOAT* Scales; + _Field_size_(DimensionCount) const FLOAT* InputPixelOffsets; + _Field_size_(DimensionCount) const FLOAT* OutputPixelOffsets; +}; + +struct DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + _Maybenull_ const DML_TENSOR_DESC* AZeroPointTensor; + const DML_TENSOR_DESC* BTensor; + _Maybenull_ const DML_TENSOR_DESC* BZeroPointTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* AScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* AZeroPointTensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* BScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* BZeroPointTensor; + const DML_TENSOR_DESC* OutputScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputZeroPointTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_CONVOLUTION_INTEGER_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + _Maybenull_ const DML_TENSOR_DESC* InputZeroPointTensor; + const DML_TENSOR_DESC* FilterTensor; + _Maybenull_ const DML_TENSOR_DESC* FilterZeroPointTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* Dilations; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + UINT GroupCount; +}; + +struct DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* InputZeroPointTensor; + const DML_TENSOR_DESC* FilterTensor; + const DML_TENSOR_DESC* FilterScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* FilterZeroPointTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + const DML_TENSOR_DESC* OutputScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputZeroPointTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* Dilations; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + UINT GroupCount; +}; + +#endif // DML_TARGET_VERSION >= 0x2100 + +#if DML_TARGET_VERSION >= 0x3000 + +struct DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_CELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; +}; + +struct DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; +}; + +struct DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + BOOL IncludePadding; +}; + +struct DML_MAX_POOLING_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + _Field_size_(DimensionCount) const UINT* Dilations; +}; + +struct DML_RANDOM_GENERATOR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputStateTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputStateTensor; + DML_RANDOM_GENERATOR_TYPE Type; +}; + +struct DML_NONZERO_COORDINATES_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputCountTensor; + const DML_TENSOR_DESC* OutputCoordinatesTensor; +}; + +struct DML_RESAMPLE_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + DML_INTERPOLATION_MODE InterpolationMode; + UINT DimensionCount; + _Field_size_(DimensionCount) const FLOAT* Scales; + _Field_size_(DimensionCount) const FLOAT* InputPixelOffsets; + _Field_size_(DimensionCount) const FLOAT* OutputPixelOffsets; +}; + +struct DML_SLICE_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* InputWindowOffsets; + _Field_size_(DimensionCount) const UINT* InputWindowSizes; + _Field_size_(DimensionCount) const INT* InputWindowStrides; +}; + +struct DML_ADAM_OPTIMIZER_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputParametersTensor; + const DML_TENSOR_DESC* InputFirstMomentTensor; + const DML_TENSOR_DESC* InputSecondMomentTensor; + const DML_TENSOR_DESC* GradientTensor; + const DML_TENSOR_DESC* TrainingStepTensor; + const DML_TENSOR_DESC* OutputParametersTensor; + const DML_TENSOR_DESC* OutputFirstMomentTensor; + const DML_TENSOR_DESC* OutputSecondMomentTensor; + FLOAT LearningRate; + FLOAT Beta1; + FLOAT Beta2; + FLOAT Epsilon; +}; + +struct DML_ARGMIN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; + DML_AXIS_DIRECTION AxisDirection; +}; + +struct DML_ARGMAX_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; + DML_AXIS_DIRECTION AxisDirection; +}; + +struct DML_ROI_ALIGN_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* ROITensor; + const DML_TENSOR_DESC* BatchIndicesTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_REDUCE_FUNCTION ReductionFunction; + DML_INTERPOLATION_MODE InterpolationMode; + FLOAT SpatialScaleX; + FLOAT SpatialScaleY; + FLOAT OutOfBoundsInputValue; + UINT MinimumSamplesPerOutput; + UINT MaximumSamplesPerOutput; +}; + +struct DML_GATHER_ND1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* IndicesTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT InputDimensionCount; + UINT IndicesDimensionCount; + UINT BatchDimensionCount; +}; + +#endif // DML_TARGET_VERSION >= 0x3000 + +#if DML_TARGET_VERSION >= 0x3100 + +struct DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + FLOAT Min; + FLOAT Max; +}; + +struct DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + BOOL CrossChannel; + UINT LocalSize; + FLOAT Alpha; + FLOAT Beta; + FLOAT Bias; +}; + +struct DML_CUMULATIVE_PRODUCT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT Axis; + DML_AXIS_DIRECTION AxisDirection; + BOOL HasExclusiveProduct; +}; + +struct DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* MeanTensor; + const DML_TENSOR_DESC* VarianceTensor; + const DML_TENSOR_DESC* ScaleTensor; + + const DML_TENSOR_DESC* OutputGradientTensor; + const DML_TENSOR_DESC* OutputScaleGradientTensor; + const DML_TENSOR_DESC* OutputBiasGradientTensor; + + FLOAT Epsilon; +}; + +#endif // DML_TARGET_VERSION >= 0x3100 + +#if DML_TARGET_VERSION >= 0x4000 +struct DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* AScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* AZeroPointTensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* BScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* BZeroPointTensor; + const DML_TENSOR_DESC* OutputScaleTensor; // This is an input tensor + _Maybenull_ const DML_TENSOR_DESC* OutputZeroPointTensor; // This is an input tensor + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + const DML_TENSOR_DESC* OutputScaleTensor; // This is an output tensor + const DML_TENSOR_DESC* OutputZeroPointTensor; // This is an output tensor +}; + +struct DML_ROI_ALIGN1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* ROITensor; + const DML_TENSOR_DESC* BatchIndicesTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_REDUCE_FUNCTION ReductionFunction; + DML_INTERPOLATION_MODE InterpolationMode; + FLOAT SpatialScaleX; + FLOAT SpatialScaleY; + FLOAT InputPixelOffset; + FLOAT OutputPixelOffset; + FLOAT OutOfBoundsInputValue; + UINT MinimumSamplesPerOutput; + UINT MaximumSamplesPerOutput; + BOOL AlignRegionsToCorners; +}; + +#endif // DML_TARGET_VERSION >= 0x4000 + +#if DML_TARGET_VERSION >= 0x4100 + +struct DML_ROI_ALIGN_GRAD_OPERATOR_DESC +{ + _Maybenull_ const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* ROITensor; + const DML_TENSOR_DESC* BatchIndicesTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputGradientTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputROIGradientTensor; + DML_REDUCE_FUNCTION ReductionFunction; + DML_INTERPOLATION_MODE InterpolationMode; + FLOAT SpatialScaleX; + FLOAT SpatialScaleY; + FLOAT InputPixelOffset; + FLOAT OutputPixelOffset; + UINT MinimumSamplesPerOutput; + UINT MaximumSamplesPerOutput; + BOOL AlignRegionsToCorners; +}; + +struct DML_BATCH_NORMALIZATION_TRAINING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* ScaleTensor; + const DML_TENSOR_DESC* BiasTensor; + _Maybenull_ const DML_TENSOR_DESC* FusedAddTensor; + const DML_TENSOR_DESC* OutputTensor; + const DML_TENSOR_DESC* OutputMeanTensor; + const DML_TENSOR_DESC* OutputVarianceTensor; + FLOAT Epsilon; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_BATCH_NORMALIZATION_TRAINING_GRAD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* MeanTensor; + const DML_TENSOR_DESC* VarianceTensor; + const DML_TENSOR_DESC* ScaleTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + const DML_TENSOR_DESC* OutputScaleGradientTensor; + const DML_TENSOR_DESC* OutputBiasGradientTensor; + FLOAT Epsilon; +}; + +#endif // DML_TARGET_VERSION >= 0x4100 + +#if DML_TARGET_VERSION >= 0x5000 + +struct DML_ELEMENT_WISE_CLIP1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_SCALE_BIAS* ScaleBias; + DML_TENSOR_DATA_TYPE MinMaxDataType; + DML_SCALAR_UNION Min; + DML_SCALAR_UNION Max; +}; + +struct DML_ELEMENT_WISE_CLIP_GRAD1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + DML_TENSOR_DATA_TYPE MinMaxDataType; + DML_SCALAR_UNION Min; + DML_SCALAR_UNION Max; +}; + +struct DML_PADDING1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_PADDING_MODE PaddingMode; + DML_TENSOR_DATA_TYPE PaddingValueDataType; + DML_SCALAR_UNION PaddingValue; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; +}; + +struct DML_ELEMENT_WISE_NEGATE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +#endif // DML_TARGET_VERSION >= 0x5000 + +#if DML_TARGET_VERSION >= 0x5100 + +struct DML_ACTIVATION_GELU_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_ACTIVATION_SOFTMAX1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; +}; + +struct DML_ACTIVATION_LOG_SOFTMAX1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; +}; + +struct DML_ACTIVATION_HARDMAX1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; +}; + +struct DML_RESAMPLE2_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_INTERPOLATION_MODE InterpolationMode; + DML_AXIS_DIRECTION RoundingDirection; + UINT DimensionCount; + _Field_size_(DimensionCount) const FLOAT* Scales; + _Field_size_(DimensionCount) const FLOAT* InputPixelOffsets; + _Field_size_(DimensionCount) const FLOAT* OutputPixelOffsets; +}; + +struct DML_RESAMPLE_GRAD1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputGradientTensor; + const DML_TENSOR_DESC* OutputGradientTensor; + DML_INTERPOLATION_MODE InterpolationMode; + DML_AXIS_DIRECTION RoundingDirection; + UINT DimensionCount; + _Field_size_(DimensionCount) const FLOAT* Scales; + _Field_size_(DimensionCount) const FLOAT* InputPixelOffsets; + _Field_size_(DimensionCount) const FLOAT* OutputPixelOffsets; +}; + +struct DML_DIAGONAL_MATRIX1_OPERATOR_DESC +{ + _Maybenull_ const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_TENSOR_DATA_TYPE ValueDataType; + DML_SCALAR_UNION Value; + INT DiagonalFillBegin; + INT DiagonalFillEnd; +}; + +#endif // DML_TARGET_VERSION >= 0x5100 + +#if DML_TARGET_VERSION >= 0x6100 + +struct DML_MULTIHEAD_ATTENTION_OPERATOR_DESC +{ + _Maybenull_ const DML_TENSOR_DESC* QueryTensor; + _Maybenull_ const DML_TENSOR_DESC* KeyTensor; + _Maybenull_ const DML_TENSOR_DESC* ValueTensor; + _Maybenull_ const DML_TENSOR_DESC* StackedQueryKeyTensor; + _Maybenull_ const DML_TENSOR_DESC* StackedKeyValueTensor; + _Maybenull_ const DML_TENSOR_DESC* StackedQueryKeyValueTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + _Maybenull_ const DML_TENSOR_DESC* MaskTensor; + _Maybenull_ const DML_TENSOR_DESC* RelativePositionBiasTensor; + _Maybenull_ const DML_TENSOR_DESC* PastKeyTensor; + _Maybenull_ const DML_TENSOR_DESC* PastValueTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputPresentKeyTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputPresentValueTensor; + FLOAT Scale; + FLOAT MaskFilterValue; + UINT HeadCount; + DML_MULTIHEAD_ATTENTION_MASK_TYPE MaskType; +}; + +#endif // DML_TARGET_VERSION >= 0x6100 + +#if DML_TARGET_VERSION >= 0x6200 + +struct DML_LP_POOLING1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + _Field_size_(DimensionCount) const UINT* Dilations; + UINT P; +}; + +struct DML_AVERAGE_POOLING1_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + _Field_size_(DimensionCount) const UINT* Dilations; + BOOL IncludePadding; +}; + +struct DML_ACTIVATION_SWISH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT SigmoidInputScale; +}; + +struct DML_ACTIVATION_HARD_SWISH_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + FLOAT Alpha; + FLOAT Beta; +}; + +struct DML_QUANTIZED_LINEAR_AVERAGE_POOLING_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* InputScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* InputZeroPointTensor; + const DML_TENSOR_DESC* OutputScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputZeroPointTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* Strides; + _Field_size_(DimensionCount) const UINT* WindowSize; + _Field_size_(DimensionCount) const UINT* StartPadding; + _Field_size_(DimensionCount) const UINT* EndPadding; + _Field_size_(DimensionCount) const UINT* Dilations; + BOOL IncludePadding; +}; + +struct DML_MATRIX_MULTIPLY_INTEGER_TO_FLOAT_OPERATOR_DESC +{ + const DML_TENSOR_DESC* ATensor; + const DML_TENSOR_DESC* AScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* AZeroPointTensor; + const DML_TENSOR_DESC* BTensor; + const DML_TENSOR_DESC* BScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* BZeroPointTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + const DML_TENSOR_DESC* OutputTensor; +}; + +#endif // DML_TARGET_VERSION >= 0x6200 + +#if DML_TARGET_VERSION >= 0x6300 + +struct DML_MEAN_VARIANCE_NORMALIZATION2_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + _Maybenull_ const DML_TENSOR_DESC* ScaleTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT AxisCount; + _Field_size_(AxisCount) const UINT* Axes; + BOOL UseMean; + BOOL UseVariance; + FLOAT Epsilon; + _Maybenull_ const DML_OPERATOR_DESC* FusedActivation; +}; + +struct DML_MULTIHEAD_ATTENTION1_OPERATOR_DESC +{ + _Maybenull_ const DML_TENSOR_DESC* QueryTensor; + _Maybenull_ const DML_TENSOR_DESC* KeyTensor; + _Maybenull_ const DML_TENSOR_DESC* ValueTensor; + _Maybenull_ const DML_TENSOR_DESC* StackedQueryKeyTensor; + _Maybenull_ const DML_TENSOR_DESC* StackedKeyValueTensor; + _Maybenull_ const DML_TENSOR_DESC* StackedQueryKeyValueTensor; + _Maybenull_ const DML_TENSOR_DESC* BiasTensor; + _Maybenull_ const DML_TENSOR_DESC* MaskTensor; + _Maybenull_ const DML_TENSOR_DESC* RelativePositionBiasTensor; + _Maybenull_ const DML_TENSOR_DESC* PastKeyTensor; + _Maybenull_ const DML_TENSOR_DESC* PastValueTensor; + _Maybenull_ const DML_TENSOR_DESC* PastSequenceLengthsTensor; + const DML_TENSOR_DESC* OutputTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputPresentKeyTensor; + _Maybenull_ const DML_TENSOR_DESC* OutputPresentValueTensor; + FLOAT Scale; + FLOAT MaskFilterValue; + UINT QueryHeadCount; + UINT KeyValueHeadCount; + DML_MULTIHEAD_ATTENTION_MASK_TYPE MaskType; +}; + +struct DML_QUANTIZE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + DML_QUANTIZATION_TYPE QuantizationType; + UINT QuantizationTensorCount; + _Field_size_(QuantizationTensorCount) const DML_TENSOR_DESC* QuantizationTensors; + const DML_TENSOR_DESC* OutputTensor; +}; + +struct DML_DEQUANTIZE_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + DML_QUANTIZATION_TYPE QuantizationType; + UINT QuantizationTensorCount; + _Field_size_(QuantizationTensorCount) const DML_TENSOR_DESC* QuantizationTensors; + const DML_TENSOR_DESC* OutputTensor; +}; + +#endif // DML_TARGET_VERSION >= 0x6300 + +#if DML_TARGET_VERSION >= 0x6400 + +struct DML_RESAMPLE3_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + DML_INTERPOLATION_MODE InterpolationMode; + DML_AXIS_DIRECTION RoundingDirection; + UINT DimensionCount; + _Field_size_(DimensionCount) const FLOAT* Scales; + _Field_size_(DimensionCount) const FLOAT* InputPixelOffsets; + _Field_size_(DimensionCount) const FLOAT* OutputPixelOffsets; + BOOL Antialiased; +}; + +struct DML_FOLD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* WindowSizes; // Size of the extracted patch + _Field_size_(DimensionCount) const UINT* Strides; // Step size of the extracted patches + _Field_size_(DimensionCount) const UINT* Dilations; // Dialations of the extracted patch + _Field_size_(DimensionCount) const UINT* StartPadding; // Start padding of the "source tensor" + _Field_size_(DimensionCount) const UINT* EndPadding; // End padding of the "source tensor" +}; + +struct DML_UNFOLD_OPERATOR_DESC +{ + const DML_TENSOR_DESC* InputTensor; + const DML_TENSOR_DESC* OutputTensor; + UINT DimensionCount; + _Field_size_(DimensionCount) const UINT* WindowSizes; // Size of the extracted patch + _Field_size_(DimensionCount) const UINT* Strides; // Step size of the extracted patches + _Field_size_(DimensionCount) const UINT* Dilations; // Dialations of the extracted patch + _Field_size_(DimensionCount) const UINT* StartPadding; // Start padding of the "source tensor" + _Field_size_(DimensionCount) const UINT* EndPadding; // End padding of the "source tensor" +}; + +#endif // DML_TARGET_VERSION >= 0x6400 + +// =================================================================================================================== +// DML feature support queries +// =================================================================================================================== + +#if DML_TARGET_VERSION >= 0x2000 + +enum DML_FEATURE_LEVEL +{ + DML_FEATURE_LEVEL_1_0 = 0x1000, + DML_FEATURE_LEVEL_2_0 = 0x2000, + DML_FEATURE_LEVEL_2_1 = 0x2100, + DML_FEATURE_LEVEL_3_0 = 0x3000, + DML_FEATURE_LEVEL_3_1 = 0x3100, + DML_FEATURE_LEVEL_4_0 = 0x4000, + DML_FEATURE_LEVEL_4_1 = 0x4100, + DML_FEATURE_LEVEL_5_0 = 0x5000, + DML_FEATURE_LEVEL_5_1 = 0x5100, + DML_FEATURE_LEVEL_5_2 = 0x5200, + DML_FEATURE_LEVEL_6_0 = 0x6000, + DML_FEATURE_LEVEL_6_1 = 0x6100, + DML_FEATURE_LEVEL_6_2 = 0x6200, + DML_FEATURE_LEVEL_6_3 = 0x6300, + DML_FEATURE_LEVEL_6_4 = 0x6400, +}; + +#endif // DML_TARGET_VERSION >= 0x2000 + +enum DML_FEATURE +{ + DML_FEATURE_TENSOR_DATA_TYPE_SUPPORT, + +#if DML_TARGET_VERSION >= 0x2000 + DML_FEATURE_FEATURE_LEVELS, +#endif // DML_TARGET_VERSION >= 0x2000 +}; + +struct DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT +{ + DML_TENSOR_DATA_TYPE DataType; +}; + +struct DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT +{ + BOOL IsSupported; +}; + +#if DML_TARGET_VERSION >= 0x2000 + +struct DML_FEATURE_QUERY_FEATURE_LEVELS +{ + UINT RequestedFeatureLevelCount; + _Field_size_(RequestedFeatureLevelCount) const DML_FEATURE_LEVEL* RequestedFeatureLevels; +}; + +struct DML_FEATURE_DATA_FEATURE_LEVELS +{ + DML_FEATURE_LEVEL MaxSupportedFeatureLevel; +}; + +#endif // DML_TARGET_VERSION >= 0x2000 + +// =================================================================================================================== +// DML device functions, enumerations, and structures +// =================================================================================================================== + +struct DML_BINDING_TABLE_DESC +{ + IDMLDispatchable* Dispatchable; + D3D12_CPU_DESCRIPTOR_HANDLE CPUDescriptorHandle; + D3D12_GPU_DESCRIPTOR_HANDLE GPUDescriptorHandle; + UINT SizeInDescriptors; +}; + +enum DML_EXECUTION_FLAGS +{ + DML_EXECUTION_FLAG_NONE = 0, + DML_EXECUTION_FLAG_ALLOW_HALF_PRECISION_COMPUTATION = 0x1, + DML_EXECUTION_FLAG_DISABLE_META_COMMANDS = 0x2, + DML_EXECUTION_FLAG_DESCRIPTORS_VOLATILE = 0x4, +}; + +DEFINE_ENUM_FLAG_OPERATORS(DML_EXECUTION_FLAGS) + +enum DML_CREATE_DEVICE_FLAGS +{ + DML_CREATE_DEVICE_FLAG_NONE = 0, + DML_CREATE_DEVICE_FLAG_DEBUG = 0x1, +}; + +DEFINE_ENUM_FLAG_OPERATORS(DML_CREATE_DEVICE_FLAGS) + +STDAPI DMLCreateDevice( + ID3D12Device* d3d12Device, + DML_CREATE_DEVICE_FLAGS flags, + REFIID riid, // Expected: IDMLDevice + _COM_Outptr_opt_ void** ppv + ); + +#if DML_TARGET_VERSION >= 0x2000 + +STDAPI DMLCreateDevice1( + ID3D12Device* d3d12Device, + DML_CREATE_DEVICE_FLAGS flags, + DML_FEATURE_LEVEL minimumFeatureLevel, + REFIID riid, // Expected: IDMLDevice + _COM_Outptr_opt_ void** ppv + ); + +#endif // DML_TARGET_VERSION >= 0x2000 + +// =================================================================================================================== +// DML object +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("c8263aac-9e0c-4a2d-9b8e-007521a3317c") IDMLObject : IUnknown +{ + IFACEMETHOD(GetPrivateData)( + REFGUID guid, + _Inout_ UINT* dataSize, + _Out_writes_bytes_opt_(*dataSize) void* data + ) = 0; + + IFACEMETHOD(SetPrivateData)( + REFGUID guid, + UINT dataSize, + _In_reads_bytes_opt_(dataSize) const void* data + ) = 0; + + IFACEMETHOD(SetPrivateDataInterface)( + REFGUID guid, + _In_opt_ IUnknown* data + ) = 0; + + IFACEMETHOD(SetName)( + PCWSTR name + ) = 0; +}; + +// =================================================================================================================== +// DML device +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("6dbd6437-96fd-423f-a98c-ae5e7c2a573f") IDMLDevice : IDMLObject +{ + IFACEMETHOD(CheckFeatureSupport)( + DML_FEATURE feature, + UINT featureQueryDataSize, + _In_reads_bytes_opt_(featureQueryDataSize) const void* featureQueryData, + UINT featureSupportDataSize, + _Out_writes_bytes_(featureSupportDataSize) void* featureSupportData + ) = 0; + + IFACEMETHOD(CreateOperator)( + const DML_OPERATOR_DESC* desc, + REFIID riid, // expected: IDMLOperator + _COM_Outptr_opt_ void** ppv + ) = 0; + + IFACEMETHOD(CompileOperator)( + IDMLOperator* op, + DML_EXECUTION_FLAGS flags, + REFIID riid, // expected: IDMLCompiledOperator + _COM_Outptr_opt_ void** ppv + ) = 0; + + IFACEMETHOD(CreateOperatorInitializer)( + UINT operatorCount, + _In_reads_opt_(operatorCount) IDMLCompiledOperator* const* operators, + REFIID riid, // expected: IDMLOperatorInitializer + _COM_Outptr_ void** ppv + ) = 0; + + IFACEMETHOD(CreateCommandRecorder)( + REFIID riid, // expected: IDMLCommandRecorder + _COM_Outptr_ void** ppv + ) = 0; + + IFACEMETHOD(CreateBindingTable)( + _In_opt_ const DML_BINDING_TABLE_DESC* desc, + REFIID riid, // expected: IDMLBindingTable + _COM_Outptr_ void** ppv + ) = 0; + + IFACEMETHOD(Evict)( + UINT count, + _In_reads_(count) IDMLPageable* const* ppObjects + ) = 0; + + IFACEMETHOD(MakeResident)( + UINT count, + _In_reads_(count) IDMLPageable* const* ppObjects + ) = 0; + + IFACEMETHOD(GetDeviceRemovedReason)( + ) = 0; + + IFACEMETHOD(GetParentDevice)( + REFIID riid, + _COM_Outptr_ void** ppv + ) = 0; +}; + + +// =================================================================================================================== +// DML device children +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("27e83142-8165-49e3-974e-2fd66e4cb69d") IDMLDeviceChild : IDMLObject +{ + IFACEMETHOD(GetDevice)( + REFIID riid, // expected: IDMLDevice + _COM_Outptr_ void** ppv + ) = 0; +}; + +interface DML_DECLARE_INTERFACE("b1ab0825-4542-4a4b-8617-6dde6e8f6201") IDMLPageable : IDMLDeviceChild +{ +}; + + +// =================================================================================================================== +// DML operator +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("26caae7a-3081-4633-9581-226fbe57695d") IDMLOperator : IDMLDeviceChild +{ +}; + + +// =================================================================================================================== +// DML dispatchable +// =================================================================================================================== + +struct DML_BINDING_PROPERTIES +{ + UINT RequiredDescriptorCount; + UINT64 TemporaryResourceSize; + UINT64 PersistentResourceSize; +}; + +interface DML_DECLARE_INTERFACE("dcb821a8-1039-441e-9f1c-b1759c2f3cec") IDMLDispatchable : IDMLPageable +{ + IFACEMETHOD_(DML_BINDING_PROPERTIES, GetBindingProperties)() = 0; +}; + + +// =================================================================================================================== +// DML compiled operator +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("6b15e56a-bf5c-4902-92d8-da3a650afea4") IDMLCompiledOperator : IDMLDispatchable +{ +}; + + +// =================================================================================================================== +// DML operator initializer +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("427c1113-435c-469c-8676-4d5dd072f813") IDMLOperatorInitializer : IDMLDispatchable +{ + IFACEMETHOD(Reset)( + UINT operatorCount, + _In_reads_opt_(operatorCount) IDMLCompiledOperator* const* operators + ) = 0; +}; + +// =================================================================================================================== +// DML binding table +// =================================================================================================================== + +enum DML_BINDING_TYPE +{ + DML_BINDING_TYPE_NONE, + DML_BINDING_TYPE_BUFFER, + DML_BINDING_TYPE_BUFFER_ARRAY, +}; + +struct DML_BINDING_DESC +{ + DML_BINDING_TYPE Type; + _Field_size_opt_(_Inexpressible_("Dependent on binding type")) const void* Desc; +}; + +struct DML_BUFFER_BINDING +{ + _Maybenull_ ID3D12Resource* Buffer; + UINT64 Offset; + UINT64 SizeInBytes; +}; + +struct DML_BUFFER_ARRAY_BINDING +{ + UINT BindingCount; + _Field_size_(BindingCount) const DML_BUFFER_BINDING* Bindings; +}; + +interface DML_DECLARE_INTERFACE("29c687dc-de74-4e3b-ab00-1168f2fc3cfc") IDMLBindingTable : IDMLDeviceChild +{ + IFACEMETHOD_(void, BindInputs)( + UINT bindingCount, + _In_reads_opt_(bindingCount) const DML_BINDING_DESC* bindings + ) = 0; + + IFACEMETHOD_(void, BindOutputs)( + UINT bindingCount, + _In_reads_opt_(bindingCount) const DML_BINDING_DESC* bindings + ) = 0; + + IFACEMETHOD_(void, BindTemporaryResource)( + _In_opt_ const DML_BINDING_DESC* binding + ) = 0; + + IFACEMETHOD_(void, BindPersistentResource)( + _In_opt_ const DML_BINDING_DESC* binding + ) = 0; + + IFACEMETHOD(Reset)( + _In_opt_ const DML_BINDING_TABLE_DESC* desc + ) = 0; +}; + + +// =================================================================================================================== +// DML command recorder +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("e6857a76-2e3e-4fdd-bff4-5d2ba10fb453") IDMLCommandRecorder : IDMLDeviceChild +{ + IFACEMETHOD_(void, RecordDispatch)( + ID3D12CommandList* commandList, + IDMLDispatchable* dispatchable, + IDMLBindingTable* bindings + ) = 0; +}; + + +// =================================================================================================================== +// DML debug +// =================================================================================================================== + +interface DML_DECLARE_INTERFACE("7d6f3ac9-394a-4ac3-92a7-390cc57a8217") IDMLDebugDevice : IUnknown +{ + IFACEMETHOD_(void, SetMuteDebugOutput)( + BOOL mute + ) = 0; +}; + + +// =================================================================================================================== +// DML graph +// =================================================================================================================== + +#if DML_TARGET_VERSION >= 0x2100 + +enum DML_GRAPH_EDGE_TYPE +{ + DML_GRAPH_EDGE_TYPE_INVALID, + DML_GRAPH_EDGE_TYPE_INPUT, + DML_GRAPH_EDGE_TYPE_OUTPUT, + DML_GRAPH_EDGE_TYPE_INTERMEDIATE, +}; + +struct DML_GRAPH_EDGE_DESC +{ + DML_GRAPH_EDGE_TYPE Type; + _Field_size_(_Inexpressible_("Dependent on edge type")) const void* Desc; +}; + +struct DML_INPUT_GRAPH_EDGE_DESC +{ + UINT GraphInputIndex; + UINT ToNodeIndex; + UINT ToNodeInputIndex; + _Field_z_ _Maybenull_ const char* Name; +}; + +struct DML_OUTPUT_GRAPH_EDGE_DESC +{ + UINT FromNodeIndex; + UINT FromNodeOutputIndex; + UINT GraphOutputIndex; + _Field_z_ _Maybenull_ const char* Name; +}; + +struct DML_INTERMEDIATE_GRAPH_EDGE_DESC +{ + UINT FromNodeIndex; + UINT FromNodeOutputIndex; + UINT ToNodeIndex; + UINT ToNodeInputIndex; + _Field_z_ _Maybenull_ const char* Name; +}; + +enum DML_GRAPH_NODE_TYPE +{ + DML_GRAPH_NODE_TYPE_INVALID, + DML_GRAPH_NODE_TYPE_OPERATOR, +#if DML_TARGET_VERSION >= 0x6200 + DML_GRAPH_NODE_TYPE_CONSTANT +#endif // DML_TARGET_VERSION >= 0x6200 +}; + +struct DML_GRAPH_NODE_DESC +{ + DML_GRAPH_NODE_TYPE Type; + _Field_size_(_Inexpressible_("Dependent on node type")) const void* Desc; +}; + +struct DML_OPERATOR_GRAPH_NODE_DESC +{ + IDMLOperator* Operator; + _Field_z_ _Maybenull_ const char* Name; +}; + +#if DML_TARGET_VERSION >= 0x6200 +struct DML_CONSTANT_DATA_GRAPH_NODE_DESC +{ + _Field_size_bytes_(DataSize) const void* Data; + SIZE_T DataSize; + _Field_z_ _Maybenull_ const char* Name; +}; +#endif // DML_TARGET_VERSION >= 0x6200 + +struct DML_GRAPH_DESC +{ + UINT InputCount; + UINT OutputCount; + + UINT NodeCount; + _Field_size_(NodeCount) const DML_GRAPH_NODE_DESC* Nodes; + + UINT InputEdgeCount; + _Field_size_opt_(InputEdgeCount) const DML_GRAPH_EDGE_DESC* InputEdges; + + UINT OutputEdgeCount; + _Field_size_(OutputEdgeCount) const DML_GRAPH_EDGE_DESC* OutputEdges; + + UINT IntermediateEdgeCount; + _Field_size_opt_(IntermediateEdgeCount) const DML_GRAPH_EDGE_DESC* IntermediateEdges; +}; + +interface DML_DECLARE_INTERFACE("a0884f9a-d2be-4355-aa5d-5901281ad1d2") IDMLDevice1 : IDMLDevice +{ + IFACEMETHOD(CompileGraph)( + const DML_GRAPH_DESC* desc, + DML_EXECUTION_FLAGS flags, + REFIID riid, // expected: IDMLCompiledOperator + _COM_Outptr_opt_ void** ppv + ) = 0; +}; + +#endif // DML_TARGET_VERSION >= 0x2100 + +#endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) +#endif // DIRECTML_H -- cgit v1.2.3