ホーム › AI.MachineLearning.DirectML › DML_PADDING1_OPERATOR_DESC

DML_PADDING1_OPERATOR_DESC

構造体

サイズx64: 56 バイト / x86: 40 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド	型	サイズ	x64	x86	説明
InputTensor	DML_TENSOR_DESC*	8/4	+0	+0	パディング対象の入力テンソルへのポインタ。
OutputTensor	DML_TENSOR_DESC*	8/4	+8	+4	パディング後の結果を格納する出力テンソルへのポインタ。
PaddingMode	DML_PADDING_MODE	4	+16	+8	縁の埋め方(定数・反射・複製など)を指定するパディングモードの列挙値。
PaddingValueDataType	DML_TENSOR_DATA_TYPE	4	+20	+12	PaddingValueを解釈するデータ型を指定する列挙値。
PaddingValue	DML_SCALAR_UNION	8	+24	+16	定数モード時に縁を埋める値を表す共用体。PaddingValueDataTypeに従う。
DimensionCount	DWORD	4	+32	+24	パディングを適用する次元数。StartPadding/EndPaddingの要素数。
StartPadding	DWORD*	8/4	+40	+28	各次元の先頭側に追加する要素数を並べた配列へのポインタ。
EndPadding	DWORD*	8/4	+48	+32	各次元の末尾側に追加する要素数を並べた配列へのポインタ。

各言語での定義

#include <windows.h>

// DML_SCALAR_UNION  (x64 8 / x86 8 バイト)
typedef struct DML_SCALAR_UNION {
    BYTE Bytes[8];
    CHAR Int8;
    BYTE UInt8;
    SHORT Int16;
    WORD UInt16;
    INT Int32;
    DWORD UInt32;
    LONGLONG Int64;
    ULONGLONG UInt64;
    FLOAT Float32;
    DOUBLE Float64;
} DML_SCALAR_UNION;

// DML_PADDING1_OPERATOR_DESC  (x64 56 / x86 40 バイト)
typedef struct DML_PADDING1_OPERATOR_DESC {
    DML_TENSOR_DESC* InputTensor;
    DML_TENSOR_DESC* OutputTensor;
    DML_PADDING_MODE PaddingMode;
    DML_TENSOR_DATA_TYPE PaddingValueDataType;
    DML_SCALAR_UNION PaddingValue;
    DWORD DimensionCount;
    DWORD* StartPadding;
    DWORD* EndPadding;
} DML_PADDING1_OPERATOR_DESC;

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DML_SCALAR_UNION
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] public byte[] Bytes;
    public sbyte Int8;
    public byte UInt8;
    public short Int16;
    public ushort UInt16;
    public int Int32;
    public uint UInt32;
    public long Int64;
    public ulong UInt64;
    public float Float32;
    public double Float64;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DML_PADDING1_OPERATOR_DESC
{
    public IntPtr InputTensor;
    public IntPtr OutputTensor;
    public int PaddingMode;
    public int PaddingValueDataType;
    public DML_SCALAR_UNION PaddingValue;
    public uint DimensionCount;
    public IntPtr StartPadding;
    public IntPtr EndPadding;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DML_SCALAR_UNION
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=8)> Public Bytes() As Byte
    Public Int8 As SByte
    Public UInt8 As Byte
    Public Int16 As Short
    Public UInt16 As UShort
    Public Int32 As Integer
    Public UInt32 As UInteger
    Public Int64 As Long
    Public UInt64 As ULong
    Public Float32 As Single
    Public Float64 As Double
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DML_PADDING1_OPERATOR_DESC
    Public InputTensor As IntPtr
    Public OutputTensor As IntPtr
    Public PaddingMode As Integer
    Public PaddingValueDataType As Integer
    Public PaddingValue As DML_SCALAR_UNION
    Public DimensionCount As UInteger
    Public StartPadding As IntPtr
    Public EndPadding As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class DML_SCALAR_UNION(ctypes.Structure):
    _fields_ = [
        ("Bytes", ctypes.c_ubyte * 8),
        ("Int8", ctypes.c_byte),
        ("UInt8", ctypes.c_ubyte),
        ("Int16", ctypes.c_short),
        ("UInt16", ctypes.c_ushort),
        ("Int32", ctypes.c_int),
        ("UInt32", wintypes.DWORD),
        ("Int64", ctypes.c_longlong),
        ("UInt64", ctypes.c_ulonglong),
        ("Float32", ctypes.c_float),
        ("Float64", ctypes.c_double),
    ]

class DML_PADDING1_OPERATOR_DESC(ctypes.Structure):
    _fields_ = [
        ("InputTensor", ctypes.c_void_p),
        ("OutputTensor", ctypes.c_void_p),
        ("PaddingMode", ctypes.c_int),
        ("PaddingValueDataType", ctypes.c_int),
        ("PaddingValue", DML_SCALAR_UNION),
        ("DimensionCount", wintypes.DWORD),
        ("StartPadding", ctypes.c_void_p),
        ("EndPadding", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct DML_SCALAR_UNION {
    pub Bytes: [u8; 8],
    pub Int8: i8,
    pub UInt8: u8,
    pub Int16: i16,
    pub UInt16: u16,
    pub Int32: i32,
    pub UInt32: u32,
    pub Int64: i64,
    pub UInt64: u64,
    pub Float32: f32,
    pub Float64: f64,
}

#[repr(C)]
pub struct DML_PADDING1_OPERATOR_DESC {
    pub InputTensor: *mut core::ffi::c_void,
    pub OutputTensor: *mut core::ffi::c_void,
    pub PaddingMode: i32,
    pub PaddingValueDataType: i32,
    pub PaddingValue: DML_SCALAR_UNION,
    pub DimensionCount: u32,
    pub StartPadding: *mut core::ffi::c_void,
    pub EndPadding: *mut core::ffi::c_void,
}

import "golang.org/x/sys/windows"

type DML_SCALAR_UNION struct {
	Bytes [8]byte
	Int8 int8
	UInt8 byte
	Int16 int16
	UInt16 uint16
	Int32 int32
	UInt32 uint32
	Int64 int64
	UInt64 uint64
	Float32 float32
	Float64 float64
}

type DML_PADDING1_OPERATOR_DESC struct {
	InputTensor uintptr
	OutputTensor uintptr
	PaddingMode int32
	PaddingValueDataType int32
	PaddingValue DML_SCALAR_UNION
	DimensionCount uint32
	StartPadding uintptr
	EndPadding uintptr
}

type
  DML_SCALAR_UNION = record
    Bytes: array[0..7] of Byte;
    Int8: Shortint;
    UInt8: Byte;
    Int16: Smallint;
    UInt16: Word;
    Int32: Integer;
    UInt32: DWORD;
    Int64: Int64;
    UInt64: UInt64;
    Float32: Single;
    Float64: Double;
  end;

  DML_PADDING1_OPERATOR_DESC = record
    InputTensor: Pointer;
    OutputTensor: Pointer;
    PaddingMode: Integer;
    PaddingValueDataType: Integer;
    PaddingValue: DML_SCALAR_UNION;
    DimensionCount: DWORD;
    StartPadding: Pointer;
    EndPadding: Pointer;
  end;

const DML_SCALAR_UNION = extern struct {
    Bytes: [8]u8,
    Int8: i8,
    UInt8: u8,
    Int16: i16,
    UInt16: u16,
    Int32: i32,
    UInt32: u32,
    Int64: i64,
    UInt64: u64,
    Float32: f32,
    Float64: f64,
};

const DML_PADDING1_OPERATOR_DESC = extern struct {
    InputTensor: ?*anyopaque,
    OutputTensor: ?*anyopaque,
    PaddingMode: i32,
    PaddingValueDataType: i32,
    PaddingValue: DML_SCALAR_UNION,
    DimensionCount: u32,
    StartPadding: ?*anyopaque,
    EndPadding: ?*anyopaque,
};

type
  DML_SCALAR_UNION {.bycopy.} = object
    Bytes: array[8, uint8]
    Int8: int8
    UInt8: uint8
    Int16: int16
    UInt16: uint16
    Int32: int32
    UInt32: uint32
    Int64: int64
    UInt64: uint64
    Float32: float32
    Float64: float64

  DML_PADDING1_OPERATOR_DESC {.bycopy.} = object
    InputTensor: pointer
    OutputTensor: pointer
    PaddingMode: int32
    PaddingValueDataType: int32
    PaddingValue: DML_SCALAR_UNION
    DimensionCount: uint32
    StartPadding: pointer
    EndPadding: pointer

struct DML_SCALAR_UNION
{
    ubyte[8] Bytes;
    byte Int8;
    ubyte UInt8;
    short Int16;
    ushort UInt16;
    int Int32;
    uint UInt32;
    long Int64;
    ulong UInt64;
    float Float32;
    double Float64;
}

struct DML_PADDING1_OPERATOR_DESC
{
    void* InputTensor;
    void* OutputTensor;
    int PaddingMode;
    int PaddingValueDataType;
    DML_SCALAR_UNION PaddingValue;
    uint DimensionCount;
    void* StartPadding;
    void* EndPadding;
}

HSP用定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; DML_PADDING1_OPERATOR_DESC サイズ: 40 バイト(x86)
dim st, 10    ; 4byte整数×10(構造体サイズ 40 / 4 切り上げ)
; InputTensor : DML_TENSOR_DESC* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; OutputTensor : DML_TENSOR_DESC* (+4, 4byte)  varptr(st)+4 を基点に操作(4byte:入れ子/配列)
; PaddingMode : DML_PADDING_MODE (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; PaddingValueDataType : DML_TENSOR_DATA_TYPE (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; PaddingValue : DML_SCALAR_UNION (+16, 8byte)  varptr(st)+16 を基点に操作(8byte:入れ子/配列)
; DimensionCount : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; StartPadding : DWORD* (+28, 4byte)  st.7 = 値  /  値 = st.7   (lpoke/lpeek も可)
; EndPadding : DWORD* (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; DML_PADDING1_OPERATOR_DESC サイズ: 56 バイト(x64)
dim st, 14    ; 4byte整数×14(構造体サイズ 56 / 4 切り上げ)
; InputTensor : DML_TENSOR_DESC* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; OutputTensor : DML_TENSOR_DESC* (+8, 8byte)  varptr(st)+8 を基点に操作(8byte:入れ子/配列)
; PaddingMode : DML_PADDING_MODE (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; PaddingValueDataType : DML_TENSOR_DATA_TYPE (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; PaddingValue : DML_SCALAR_UNION (+24, 8byte)  varptr(st)+24 を基点に操作(8byte:入れ子/配列)
; DimensionCount : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; StartPadding : DWORD* (+40, 8byte)  qpoke st,40,値 / qpeek(st,40)  ※IronHSPのみ。3.7/3.8は lpoke st,40,下位 : lpoke st,44,上位
; EndPadding : DWORD* (+48, 8byte)  qpoke st,48,値 / qpeek(st,48)  ※IronHSPのみ。3.7/3.8は lpoke st,48,下位 : lpoke st,52,上位
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
#defstruct global DML_PADDING1_OPERATOR_DESC
    #field intptr InputTensor
    #field intptr OutputTensor
    #field int PaddingMode
    #field int PaddingValueDataType
    #field byte PaddingValue 8
    #field int DimensionCount
    #field intptr StartPadding
    #field intptr EndPadding
#endstruct

stdim st, DML_PADDING1_OPERATOR_DESC        ; NSTRUCT 変数を確保
st->PaddingMode = 100
mes "PaddingMode=" + st->PaddingMode
; ※union フィールドは byte 列で確保(NSTRUCT は union 非対応)。必要に応じ手動でアクセス。

DML_PADDING1_OPERATOR_DESC

フィールド

各言語での定義

HSP用 定義

HSP用定義