wehub-resource-sync
7254f7b4d1
Build / Build (macos-latest) (push) Has been cancelled
Build / Build (ubuntu-latest) (push) Has been cancelled
Build / Build (windows-latest) (push) Has been cancelled
Build / Analyze (javascript) (push) Has been cancelled
Build / Analyze (python) (push) Has been cancelled
1484 lines
47 KiB
JavaScript
1484 lines
47 KiB
JavaScript
|
|
export const executorch_flatbuffer = {};
|
|
|
|
export const fb_xnnpack = {};
|
|
|
|
export const vkgraph = {};
|
|
|
|
executorch_flatbuffer.ScalarType = {
|
|
BYTE: 0, '0': 'BYTE',
|
|
CHAR: 1, '1': 'CHAR',
|
|
SHORT: 2, '2': 'SHORT',
|
|
INT: 3, '3': 'INT',
|
|
LONG: 4, '4': 'LONG',
|
|
HALF: 5, '5': 'HALF',
|
|
FLOAT: 6, '6': 'FLOAT',
|
|
DOUBLE: 7, '7': 'DOUBLE',
|
|
BOOL: 11, '11': 'BOOL',
|
|
QINT8: 12, '12': 'QINT8',
|
|
QUINT8: 13, '13': 'QUINT8',
|
|
QINT32: 14, '14': 'QINT32',
|
|
BFLOAT16: 15, '15': 'BFLOAT16',
|
|
QUINT4X2: 16, '16': 'QUINT4X2',
|
|
QUINT2X4: 17, '17': 'QUINT2X4',
|
|
BITS16: 22, '22': 'BITS16',
|
|
FLOAT8E5M2: 23, '23': 'FLOAT8E5M2',
|
|
FLOAT8E4M3FN: 24, '24': 'FLOAT8E4M3FN',
|
|
FLOAT8E5M2FNUZ: 25, '25': 'FLOAT8E5M2FNUZ',
|
|
FLOAT8E4M3FNUZ: 26, '26': 'FLOAT8E4M3FNUZ',
|
|
UINT16: 27, '27': 'UINT16',
|
|
UINT32: 28, '28': 'UINT32',
|
|
UINT64: 29, '29': 'UINT64'
|
|
};
|
|
|
|
executorch_flatbuffer.ContainerMetadata = class ContainerMetadata {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.ContainerMetadata();
|
|
$.encoded_inp_str = reader.string_(position, 4, null);
|
|
$.encoded_out_str = reader.string_(position, 6, null);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Null = class Null {
|
|
|
|
static decode(/* reader, position */) {
|
|
const $ = new executorch_flatbuffer.Null();
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.AllocationDetails = class AllocationDetails {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.AllocationDetails();
|
|
$.memory_id = reader.uint32_(position, 4, 0);
|
|
$.memory_offset_low = reader.uint32_(position, 6, 0);
|
|
$.memory_offset_high = reader.uint32_(position, 8, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.TensorShapeDynamism = {
|
|
STATIC: 0, '0': 'STATIC',
|
|
DYNAMIC_BOUND: 1, '1': 'DYNAMIC_BOUND',
|
|
DYNAMIC_UNBOUND: 2, '2': 'DYNAMIC_UNBOUND'
|
|
};
|
|
|
|
executorch_flatbuffer.TensorDataLocation = {
|
|
SEGMENT: 0, '0': 'SEGMENT',
|
|
EXTERNAL: 1, '1': 'EXTERNAL'
|
|
};
|
|
|
|
executorch_flatbuffer.DeviceType = {
|
|
CPU: 0, '0': 'CPU',
|
|
CUDA: 1, '1': 'CUDA'
|
|
};
|
|
|
|
executorch_flatbuffer.ExtraTensorInfo = class ExtraTensorInfo {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.ExtraTensorInfo();
|
|
$.mutable_data_segments_idx = reader.uint64_(position, 4, 0n);
|
|
$.fully_qualified_name = reader.string_(position, 6, null);
|
|
$.location = reader.int8_(position, 8, 0);
|
|
$.device_type = reader.int8_(position, 10, 0);
|
|
$.device_index = reader.int8_(position, 12, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Tensor = class Tensor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Tensor();
|
|
$.scalar_type = reader.int8_(position, 4, 0);
|
|
$.storage_offset = reader.int32_(position, 6, 0);
|
|
$.sizes = reader.array(position, 8, Int32Array);
|
|
$.dim_order = reader.array(position, 10, Uint8Array);
|
|
$.requires_grad = reader.bool_(position, 12, false);
|
|
$.data_buffer_idx = reader.uint32_(position, 14, 0);
|
|
$.allocation_info = reader.table(position, 16, executorch_flatbuffer.AllocationDetails);
|
|
$.layout = reader.int8_(position, 18, 0);
|
|
$.shape_dynamism = reader.int8_(position, 20, 0);
|
|
$.extra_tensor_info = reader.table(position, 22, executorch_flatbuffer.ExtraTensorInfo);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Int = class Int {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Int();
|
|
$.int_val = reader.int64_(position, 4, 0n);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Bool = class Bool {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Bool();
|
|
$.bool_val = reader.bool_(position, 4, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Double = class Double {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Double();
|
|
$.double_val = reader.float64_(position, 4, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.String = class String {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.String();
|
|
$.string_val = reader.string_(position, 4, null);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.IntList = class IntList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.IntList();
|
|
$.items = reader.int64s_(position, 4);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.DoubleList = class DoubleList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.DoubleList();
|
|
$.items = reader.array(position, 4, Float64Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.BoolList = class BoolList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.BoolList();
|
|
$.items = reader.bools_(position, 4);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.TensorList = class TensorList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.TensorList();
|
|
$.items = reader.array(position, 4, Int32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.OptionalTensorList = class OptionalTensorList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.OptionalTensorList();
|
|
$.items = reader.array(position, 4, Int32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.KernelTypes = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return executorch_flatbuffer.Null.decode(reader, position);
|
|
case 2: return executorch_flatbuffer.Int.decode(reader, position);
|
|
case 3: return executorch_flatbuffer.Bool.decode(reader, position);
|
|
case 4: return executorch_flatbuffer.Double.decode(reader, position);
|
|
case 5: return executorch_flatbuffer.Tensor.decode(reader, position);
|
|
case 6: return executorch_flatbuffer.String.decode(reader, position);
|
|
case 7: return executorch_flatbuffer.IntList.decode(reader, position);
|
|
case 8: return executorch_flatbuffer.DoubleList.decode(reader, position);
|
|
case 9: return executorch_flatbuffer.BoolList.decode(reader, position);
|
|
case 10: return executorch_flatbuffer.TensorList.decode(reader, position);
|
|
case 11: return executorch_flatbuffer.OptionalTensorList.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.EValue = class EValue {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.EValue();
|
|
$.val = reader.union(position, 4, executorch_flatbuffer.KernelTypes);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Operator = class Operator {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Operator();
|
|
$.name = reader.string_(position, 4, null);
|
|
$.overload = reader.string_(position, 6, null);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.KernelCall = class KernelCall {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.KernelCall();
|
|
$.op_index = reader.int32_(position, 4, 0);
|
|
$.args = reader.array(position, 6, Int32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.DelegateCall = class DelegateCall {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.DelegateCall();
|
|
$.delegate_index = reader.int32_(position, 4, 0);
|
|
$.args = reader.array(position, 6, Int32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.MoveCall = class MoveCall {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.MoveCall();
|
|
$.move_from = reader.int32_(position, 4, 0);
|
|
$.move_to = reader.int32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.JumpFalseCall = class JumpFalseCall {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.JumpFalseCall();
|
|
$.cond_value_index = reader.int32_(position, 4, 0);
|
|
$.destination_instruction = reader.int32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.FreeCall = class FreeCall {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.FreeCall();
|
|
$.value_index = reader.int32_(position, 4, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.InstructionArguments = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return executorch_flatbuffer.KernelCall.decode(reader, position);
|
|
case 2: return executorch_flatbuffer.DelegateCall.decode(reader, position);
|
|
case 3: return executorch_flatbuffer.MoveCall.decode(reader, position);
|
|
case 4: return executorch_flatbuffer.JumpFalseCall.decode(reader, position);
|
|
case 5: return executorch_flatbuffer.FreeCall.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Instruction = class Instruction {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Instruction();
|
|
$.instr_args = reader.union(position, 4, executorch_flatbuffer.InstructionArguments);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Frame = class Frame {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Frame();
|
|
$.filename = reader.string_(position, 4, null);
|
|
$.lineno = reader.int32_(position, 6, 0);
|
|
$.name = reader.string_(position, 8, null);
|
|
$.context = reader.string_(position, 10, null);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.FrameList = class FrameList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.FrameList();
|
|
$.items = reader.tables(position, 4, executorch_flatbuffer.Frame);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.DataLocation = {
|
|
INLINE: 0, '0': 'INLINE',
|
|
SEGMENT: 1, '1': 'SEGMENT'
|
|
};
|
|
|
|
executorch_flatbuffer.BackendDelegateDataReference = class BackendDelegateDataReference {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.BackendDelegateDataReference();
|
|
$.location = reader.int8_(position, 4, 0);
|
|
$.index = reader.uint32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.CompileSpec = class CompileSpec {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.CompileSpec();
|
|
$.key = reader.string_(position, 4, null);
|
|
$.value = reader.array(position, 6, Uint8Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.BackendDelegate = class BackendDelegate {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.BackendDelegate();
|
|
$.id = reader.string_(position, 4, null);
|
|
$.processed = reader.table(position, 6, executorch_flatbuffer.BackendDelegateDataReference);
|
|
$.compile_specs = reader.tables(position, 8, executorch_flatbuffer.CompileSpec);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Chain = class Chain {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Chain();
|
|
$.inputs = reader.array(position, 4, Int32Array);
|
|
$.outputs = reader.array(position, 6, Int32Array);
|
|
$.instructions = reader.tables(position, 8, executorch_flatbuffer.Instruction);
|
|
$.stacktrace = reader.tables(position, 10, executorch_flatbuffer.FrameList);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.ExecutionPlan = class ExecutionPlan {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.ExecutionPlan();
|
|
$.name = reader.string_(position, 4, null);
|
|
$.container_meta_type = reader.table(position, 6, executorch_flatbuffer.ContainerMetadata);
|
|
$.values = reader.tables(position, 8, executorch_flatbuffer.EValue);
|
|
$.inputs = reader.array(position, 10, Int32Array);
|
|
$.outputs = reader.array(position, 12, Int32Array);
|
|
$.chains = reader.tables(position, 14, executorch_flatbuffer.Chain);
|
|
$.operators = reader.tables(position, 16, executorch_flatbuffer.Operator);
|
|
$.delegates = reader.tables(position, 18, executorch_flatbuffer.BackendDelegate);
|
|
$.non_const_buffer_sizes = reader.int64s_(position, 20);
|
|
$.non_const_buffer_device = reader.tables(position, 22, executorch_flatbuffer.NonConstBufferDevice);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.NonConstBufferDevice = class NonConstBufferDevice {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.NonConstBufferDevice();
|
|
$.buffer_idx = reader.int32_(position, 4, 0);
|
|
$.device_type = reader.int8_(position, 6, 0);
|
|
$.device_index = reader.int8_(position, 8, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Buffer = class Buffer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Buffer();
|
|
$.storage = reader.array(position, 4, Uint8Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.BackendDelegateInlineData = class BackendDelegateInlineData {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.BackendDelegateInlineData();
|
|
$.data = reader.array(position, 4, Uint8Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.DataSegment = class DataSegment {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.DataSegment();
|
|
$.offset = reader.uint64_(position, 4, 0n);
|
|
$.size = reader.uint64_(position, 6, 0n);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.SubsegmentOffsets = class SubsegmentOffsets {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.SubsegmentOffsets();
|
|
$.segment_index = reader.uint32_(position, 4, 0);
|
|
$.offsets = reader.uint64s_(position, 6);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.NamedData = class NamedData {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.NamedData();
|
|
$.key = reader.string_(position, 4, null);
|
|
$.segment_index = reader.uint32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
executorch_flatbuffer.Program = class Program {
|
|
|
|
static identifier(reader) {
|
|
return reader.identifier === 'ET12';
|
|
}
|
|
|
|
static create(reader) {
|
|
return executorch_flatbuffer.Program.decode(reader, reader.root);
|
|
}
|
|
|
|
static decode(reader, position) {
|
|
const $ = new executorch_flatbuffer.Program();
|
|
$.version = reader.uint32_(position, 4, 0);
|
|
$.execution_plan = reader.tables(position, 6, executorch_flatbuffer.ExecutionPlan);
|
|
$.constant_buffer = reader.tables(position, 8, executorch_flatbuffer.Buffer);
|
|
$.backend_delegate_data = reader.tables(position, 10, executorch_flatbuffer.BackendDelegateInlineData);
|
|
$.segments = reader.tables(position, 12, executorch_flatbuffer.DataSegment);
|
|
$.constant_segment = reader.table(position, 14, executorch_flatbuffer.SubsegmentOffsets);
|
|
$.mutable_data_segments = reader.tables(position, 16, executorch_flatbuffer.SubsegmentOffsets);
|
|
$.named_data = reader.tables(position, 18, executorch_flatbuffer.NamedData);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNDatatype = {
|
|
xnn_datatype_invalid: 0, '0': 'xnn_datatype_invalid',
|
|
xnn_datatype_fp32: 1, '1': 'xnn_datatype_fp32',
|
|
xnn_datatype_fp16: 2, '2': 'xnn_datatype_fp16',
|
|
xnn_datatype_qint8: 3, '3': 'xnn_datatype_qint8',
|
|
xnn_datatype_quint8: 4, '4': 'xnn_datatype_quint8',
|
|
xnn_datatype_qint32: 5, '5': 'xnn_datatype_qint32',
|
|
xnn_datatype_qcint8: 6, '6': 'xnn_datatype_qcint8',
|
|
xnn_datatype_qcint32: 7, '7': 'xnn_datatype_qcint32',
|
|
xnn_datatype_qcint4: 8, '8': 'xnn_datatype_qcint4',
|
|
xnn_datatype_qdint8: 9, '9': 'xnn_datatype_qdint8',
|
|
xnn_datatype_qbint4: 10, '10': 'xnn_datatype_qbint4',
|
|
xnn_datatype_qpint8: 11, '11': 'xnn_datatype_qpint8',
|
|
xnn_datatype_int32: 12, '12': 'xnn_datatype_int32',
|
|
xnn_datatype_pfp32: 13, '13': 'xnn_datatype_pfp32',
|
|
xnn_datatype_bf16: 14, '14': 'xnn_datatype_bf16'
|
|
};
|
|
|
|
fb_xnnpack.XNNQuantParams = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return fb_xnnpack.PerChannelQuant.decode(reader, position);
|
|
case 2: return fb_xnnpack.PerTensorQuant.decode(reader, position);
|
|
case 3: return fb_xnnpack.PerTokenDynamicQuant.decode(reader, position);
|
|
case 4: return fb_xnnpack.PerChannelGroupQuant.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.Buffer = class Buffer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.Buffer();
|
|
$.storage = reader.array(position, 4, Uint8Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.PerChannelGroupQuant = class PerChannelGroupQuant {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.PerChannelGroupQuant();
|
|
$.scale = reader.array(position, 4, Float32Array);
|
|
$.channel_dim = reader.int32_(position, 6, 0);
|
|
$.group_size = reader.int32_(position, 8, 0);
|
|
$.scale_bf16 = reader.array(position, 10, Uint16Array);
|
|
$.scale_buffer_idx = reader.uint32_(position, 12, 0);
|
|
$.num_scales = reader.uint32_(position, 14, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.PerChannelQuant = class PerChannelQuant {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.PerChannelQuant();
|
|
$.scale = reader.array(position, 4, Float32Array);
|
|
$.channel_dim = reader.int32_(position, 6, 0);
|
|
$.scale_buffer_idx = reader.uint32_(position, 8, 0);
|
|
$.num_scales = reader.uint32_(position, 10, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.PerTokenDynamicQuant = class PerTokenDynamicQuant {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.PerTokenDynamicQuant();
|
|
$.num_nonbatch_dims = reader.int32_(position, 4, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.PerTensorQuant = class PerTensorQuant {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.PerTensorQuant();
|
|
$.scale = reader.float32_(position, 4, 0);
|
|
$.zero_point = reader.int32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNTensorValue = class XNNTensorValue {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNTensorValue();
|
|
$.datatype = reader.int16_(position, 4, 0);
|
|
$.num_dims = reader.uint32_(position, 6, 0);
|
|
$.dims = reader.array(position, 8, Uint32Array);
|
|
$.constant_buffer_idx = reader.uint32_(position, 10, 0);
|
|
$.external_id = reader.uint32_(position, 12, 0);
|
|
$.flags = reader.uint32_(position, 14, 0);
|
|
$.id_out = reader.uint32_(position, 16, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNQuantizedTensorValue = class XNNQuantizedTensorValue {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNQuantizedTensorValue();
|
|
$.tensor_value = reader.table(position, 4, fb_xnnpack.XNNTensorValue);
|
|
$.quant_params = reader.union(position, 6, fb_xnnpack.XNNQuantParams);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNodeUnion = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return fb_xnnpack.XNNAdd.decode(reader, position);
|
|
case 2: return fb_xnnpack.XNNFullyConnected.decode(reader, position);
|
|
case 3: return fb_xnnpack.XNNSoftmax.decode(reader, position);
|
|
case 4: return fb_xnnpack.XNNSigmoid.decode(reader, position);
|
|
case 5: return fb_xnnpack.XNNStaticTranspose.decode(reader, position);
|
|
case 6: return fb_xnnpack.XNNClamp.decode(reader, position);
|
|
case 7: return fb_xnnpack.XNNConv2d.decode(reader, position);
|
|
case 8: return fb_xnnpack.XNNDiv.decode(reader, position);
|
|
case 9: return fb_xnnpack.XNNStaticResizeBilinear2D.decode(reader, position);
|
|
case 10: return fb_xnnpack.XNNStaticConstantPad.decode(reader, position);
|
|
case 11: return fb_xnnpack.XNNAvgPooling2d.decode(reader, position);
|
|
case 12: return fb_xnnpack.XNNMinimum.decode(reader, position);
|
|
case 13: return fb_xnnpack.XNNDepthwiseConv2d.decode(reader, position);
|
|
case 14: return fb_xnnpack.XNNMaxPooling2d.decode(reader, position);
|
|
case 15: return fb_xnnpack.XNNMultiply.decode(reader, position);
|
|
case 16: return fb_xnnpack.XNNSubtract.decode(reader, position);
|
|
case 17: return fb_xnnpack.XNNFloor.decode(reader, position);
|
|
case 18: return fb_xnnpack.XNNConvert.decode(reader, position);
|
|
case 19: return fb_xnnpack.XNNGlobalAvgPooling2d.decode(reader, position);
|
|
case 20: return fb_xnnpack.XNNStaticReshape.decode(reader, position);
|
|
case 21: return fb_xnnpack.XNNArgMaxPooling2d.decode(reader, position);
|
|
case 22: return fb_xnnpack.XNNSquareRoot.decode(reader, position);
|
|
case 23: return fb_xnnpack.XNNCeiling.decode(reader, position);
|
|
case 24: return fb_xnnpack.XNNHardswish.decode(reader, position);
|
|
case 25: return fb_xnnpack.XNNLeakyReLU.decode(reader, position);
|
|
case 26: return fb_xnnpack.XNNMaximum.decode(reader, position);
|
|
case 27: return fb_xnnpack.XNNNegate.decode(reader, position);
|
|
case 28: return fb_xnnpack.XNNSquare.decode(reader, position);
|
|
case 29: return fb_xnnpack.XNNELU.decode(reader, position);
|
|
case 30: return fb_xnnpack.XNNAbs.decode(reader, position);
|
|
case 31: return fb_xnnpack.XNNPReLU.decode(reader, position);
|
|
case 32: return fb_xnnpack.XNNConcatenate2.decode(reader, position);
|
|
case 33: return fb_xnnpack.XNNConcatenate3.decode(reader, position);
|
|
case 34: return fb_xnnpack.XNNConcatenate4.decode(reader, position);
|
|
case 35: return fb_xnnpack.XNNStaticSlice.decode(reader, position);
|
|
case 36: return fb_xnnpack.XNNScaledDotProductAttention.decode(reader, position);
|
|
case 37: return fb_xnnpack.XNNBatchMatrixMultiply.decode(reader, position);
|
|
case 38: return fb_xnnpack.XNNConcatenate5.decode(reader, position);
|
|
case 39: return fb_xnnpack.XNNConvTranspose2d.decode(reader, position);
|
|
case 40: return fb_xnnpack.XNNReciprocalSquareRoot.decode(reader, position);
|
|
case 41: return fb_xnnpack.XNNLog.decode(reader, position);
|
|
case 42: return fb_xnnpack.XNNGelu.decode(reader, position);
|
|
case 43: return fb_xnnpack.XNNTanh.decode(reader, position);
|
|
case 44: return fb_xnnpack.XNNExp.decode(reader, position);
|
|
case 45: return fb_xnnpack.XNNSin.decode(reader, position);
|
|
case 46: return fb_xnnpack.XNNCopy.decode(reader, position);
|
|
case 47: return fb_xnnpack.XNNCos.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XValueUnion = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return fb_xnnpack.XNNTensorValue.decode(reader, position);
|
|
case 2: return fb_xnnpack.XNNQuantizedTensorValue.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.OutputMinMax = class OutputMinMax {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.OutputMinMax();
|
|
$.output_min = reader.float32_(position, 4, 0);
|
|
$.output_max = reader.float32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNode = class XNode {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNode();
|
|
$.xnode_union = reader.union(position, 4, fb_xnnpack.XNodeUnion);
|
|
$.debug_handle = reader.uint32_(position, 8, 0);
|
|
$.output_min_max = reader.table(position, 10, fb_xnnpack.OutputMinMax);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XValue = class XValue {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XValue();
|
|
$.xvalue_union = reader.union(position, 4, fb_xnnpack.XValueUnion);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNStaticTranspose = class XNNStaticTranspose {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNStaticTranspose();
|
|
$.num_dims = reader.uint32_(position, 4, 0);
|
|
$.perm = reader.array(position, 6, Uint32Array);
|
|
$.input_id = reader.uint32_(position, 8, 0);
|
|
$.output_id = reader.uint32_(position, 10, 0);
|
|
$.flags = reader.uint32_(position, 12, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNStaticResizeBilinear2D = class XNNStaticResizeBilinear2D {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNStaticResizeBilinear2D();
|
|
$.new_height = reader.uint32_(position, 4, 0);
|
|
$.new_width = reader.uint32_(position, 6, 0);
|
|
$.input_id = reader.uint32_(position, 8, 0);
|
|
$.output_id = reader.uint32_(position, 10, 0);
|
|
$.flags = reader.uint32_(position, 12, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNStaticConstantPad = class XNNStaticConstantPad {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNStaticConstantPad();
|
|
$.pre_paddings = reader.array(position, 4, Uint32Array);
|
|
$.post_paddings = reader.array(position, 6, Uint32Array);
|
|
$.padding_value = reader.float32_(position, 8, 0);
|
|
$.input_id = reader.uint32_(position, 10, 0);
|
|
$.output_id = reader.uint32_(position, 12, 0);
|
|
$.flags = reader.uint32_(position, 14, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack._XNNNode2x1 = class _XNNNode2x1 {
|
|
|
|
static decode(reader, position, $) {
|
|
$ = $ || new fb_xnnpack._XNNNode2x1();
|
|
$.input1_id = reader.uint32_(position, 4, 0);
|
|
$.input2_id = reader.uint32_(position, 6, 0);
|
|
$.output_id = reader.uint32_(position, 8, 0);
|
|
$.flags = reader.uint32_(position, 10, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack._XNNNode1x1 = class _XNNNode1x1 {
|
|
|
|
static decode(reader, position, $) {
|
|
$ = $ || new fb_xnnpack._XNNNode1x1();
|
|
$.input_id = reader.uint32_(position, 4, 0);
|
|
$.output_id = reader.uint32_(position, 6, 0);
|
|
$.flags = reader.uint32_(position, 8, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack._XNNCat = class _XNNCat {
|
|
|
|
static decode(reader, position, $) {
|
|
$ = $ || new fb_xnnpack._XNNCat();
|
|
$.axis = reader.uint32_(position, 4, 0);
|
|
$.input1_id = reader.uint32_(position, 6, 0);
|
|
$.input2_id = reader.uint32_(position, 8, 0);
|
|
$.input3_id = reader.uint32_(position, 10, 0);
|
|
$.input4_id = reader.uint32_(position, 12, 0);
|
|
$.output_id = reader.uint32_(position, 14, 0);
|
|
$.flags = reader.uint32_(position, 16, 0);
|
|
$.input5_id = reader.uint32_(position, 18, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNELU = class XNNELU {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNELU();
|
|
$.alpha = reader.float32_(position, 4, 0);
|
|
$.input_id = reader.uint32_(position, 6, 0);
|
|
$.output_id = reader.uint32_(position, 8, 0);
|
|
$.flags = reader.uint32_(position, 10, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNFullyConnected = class XNNFullyConnected {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNFullyConnected();
|
|
$.input1_id = reader.uint32_(position, 4, 0);
|
|
$.filter_id = reader.uint32_(position, 6, 0);
|
|
$.bias_id = reader.uint32_(position, 8, 0);
|
|
$.output_id = reader.uint32_(position, 10, 0);
|
|
$.flags = reader.uint32_(position, 12, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack._XNNNodeConv = class _XNNNodeConv {
|
|
|
|
static decode(reader, position, $) {
|
|
$ = $ || new fb_xnnpack._XNNNodeConv();
|
|
$.padding_top = reader.uint32_(position, 4, 0);
|
|
$.padding_right = reader.uint32_(position, 6, 0);
|
|
$.padding_bottom = reader.uint32_(position, 8, 0);
|
|
$.padding_left = reader.uint32_(position, 10, 0);
|
|
$.kernel_height = reader.uint32_(position, 12, 0);
|
|
$.kernel_width = reader.uint32_(position, 14, 0);
|
|
$.subsampling_height = reader.uint32_(position, 16, 0);
|
|
$.subsampling_width = reader.uint32_(position, 18, 0);
|
|
$.dilation_height = reader.uint32_(position, 20, 0);
|
|
$.dilation_width = reader.uint32_(position, 22, 0);
|
|
$.group_input_channels = reader.uint32_(position, 24, 0);
|
|
$.group_output_channels = reader.uint32_(position, 26, 0);
|
|
$.groups = reader.uint32_(position, 28, 0);
|
|
$.adjustment_height = reader.uint32_(position, 30, 0);
|
|
$.adjustment_width = reader.uint32_(position, 32, 0);
|
|
$.input1_id = reader.uint32_(position, 34, 0);
|
|
$.filter_id = reader.uint32_(position, 36, 0);
|
|
$.bias_id = reader.uint32_(position, 38, 0);
|
|
$.output_id = reader.uint32_(position, 40, 0);
|
|
$.flags = reader.uint32_(position, 42, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack._XNNPooling2D = class _XNNPooling2D {
|
|
|
|
static decode(reader, position, $) {
|
|
$ = $ || new fb_xnnpack._XNNPooling2D();
|
|
$.padding_top = reader.uint32_(position, 4, 0);
|
|
$.padding_right = reader.uint32_(position, 6, 0);
|
|
$.padding_bottom = reader.uint32_(position, 8, 0);
|
|
$.padding_left = reader.uint32_(position, 10, 0);
|
|
$.pooling_height = reader.uint32_(position, 12, 0);
|
|
$.pooling_width = reader.uint32_(position, 14, 0);
|
|
$.stride_height = reader.uint32_(position, 16, 0);
|
|
$.stride_width = reader.uint32_(position, 18, 0);
|
|
$.dilation_height = reader.uint32_(position, 20, 0);
|
|
$.dilation_width = reader.uint32_(position, 22, 0);
|
|
$.input_id = reader.uint32_(position, 24, 0);
|
|
$.output_id = reader.uint32_(position, 26, 0);
|
|
$.flags = reader.uint32_(position, 28, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNStaticReshape = class XNNStaticReshape {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNStaticReshape();
|
|
$.num_dims = reader.uint32_(position, 4, 0);
|
|
$.new_shape = reader.array(position, 6, Uint32Array);
|
|
$.input_id = reader.uint32_(position, 8, 0);
|
|
$.output_id = reader.uint32_(position, 10, 0);
|
|
$.flags = reader.uint32_(position, 12, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNStaticSlice = class XNNStaticSlice {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNStaticSlice();
|
|
$.num_dims = reader.uint32_(position, 4, 0);
|
|
$.offsets = reader.array(position, 6, Uint32Array);
|
|
$.sizes = reader.array(position, 8, Uint32Array);
|
|
$.input_id = reader.uint32_(position, 10, 0);
|
|
$.output_id = reader.uint32_(position, 12, 0);
|
|
$.flags = reader.uint32_(position, 14, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNScaledDotProductAttention = class XNNScaledDotProductAttention {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNScaledDotProductAttention();
|
|
$.query_id = reader.uint32_(position, 4, 0);
|
|
$.key_id = reader.uint32_(position, 6, 0);
|
|
$.value_id = reader.uint32_(position, 8, 0);
|
|
$.scale_id = reader.uint32_(position, 10, 0);
|
|
$.mask_id = reader.uint32_(position, 12, 0);
|
|
$.output_id = reader.uint32_(position, 14, 0);
|
|
$.flags = reader.uint32_(position, 16, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNArgMaxPooling2d = class XNNArgMaxPooling2d {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNArgMaxPooling2d();
|
|
$.padding_top = reader.uint32_(position, 4, 0);
|
|
$.padding_right = reader.uint32_(position, 6, 0);
|
|
$.padding_bottom = reader.uint32_(position, 8, 0);
|
|
$.padding_left = reader.uint32_(position, 10, 0);
|
|
$.pooling_height = reader.uint32_(position, 12, 0);
|
|
$.pooling_width = reader.uint32_(position, 14, 0);
|
|
$.input_id = reader.uint32_(position, 16, 0);
|
|
$.output_value_id = reader.uint32_(position, 18, 0);
|
|
$.output_index_id = reader.uint32_(position, 20, 0);
|
|
$.flags = reader.uint32_(position, 22, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNLeakyReLU = class XNNLeakyReLU {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNLeakyReLU();
|
|
$.negative_slope = reader.float32_(position, 4, 0);
|
|
$.input_id = reader.uint32_(position, 6, 0);
|
|
$.output_id = reader.uint32_(position, 8, 0);
|
|
$.flags = reader.uint32_(position, 10, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.ConstantDataOffset = class ConstantDataOffset {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.ConstantDataOffset();
|
|
$.offset = reader.uint64_(position, 4, 0n);
|
|
$.size = reader.uint64_(position, 6, 0n);
|
|
$.named_key = reader.string_(position, 8, null);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNGraph = class XNNGraph {
|
|
|
|
static identifier(reader) {
|
|
return reader.identifier === 'XN01';
|
|
}
|
|
|
|
static create(reader) {
|
|
return fb_xnnpack.XNNGraph.decode(reader, reader.root);
|
|
}
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNGraph();
|
|
$.version = reader.string_(position, 4, null);
|
|
$.xnodes = reader.tables(position, 6, fb_xnnpack.XNode);
|
|
$.xvalues = reader.tables(position, 8, fb_xnnpack.XValue);
|
|
$.num_externs = reader.uint32_(position, 10, 0);
|
|
$.input_ids = reader.array(position, 12, Uint32Array);
|
|
$.output_ids = reader.array(position, 14, Uint32Array);
|
|
$.constant_buffer = reader.tables(position, 16, fb_xnnpack.Buffer);
|
|
$.mem_buffer_sizes = reader.array(position, 18, Uint32Array);
|
|
$.constant_data = reader.tables(position, 20, fb_xnnpack.ConstantDataOffset);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNAdd = class XNNAdd {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNAdd();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNSoftmax = class XNNSoftmax {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNSoftmax();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNSigmoid = class XNNSigmoid {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNSigmoid();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNClamp = class XNNClamp {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNClamp();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNConv2d = class XNNConv2d {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNConv2d();
|
|
fb_xnnpack._XNNNodeConv.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNDiv = class XNNDiv {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNDiv();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNAvgPooling2d = class XNNAvgPooling2d {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNAvgPooling2d();
|
|
fb_xnnpack._XNNPooling2D.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNMinimum = class XNNMinimum {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNMinimum();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNDepthwiseConv2d = class XNNDepthwiseConv2d {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNDepthwiseConv2d();
|
|
fb_xnnpack._XNNNodeConv.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNMaxPooling2d = class XNNMaxPooling2d {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNMaxPooling2d();
|
|
fb_xnnpack._XNNPooling2D.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNMultiply = class XNNMultiply {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNMultiply();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNSubtract = class XNNSubtract {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNSubtract();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNFloor = class XNNFloor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNFloor();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNConvert = class XNNConvert {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNConvert();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNGlobalAvgPooling2d = class XNNGlobalAvgPooling2d {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNGlobalAvgPooling2d();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNSquareRoot = class XNNSquareRoot {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNSquareRoot();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNCeiling = class XNNCeiling {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNCeiling();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNHardswish = class XNNHardswish {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNHardswish();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNMaximum = class XNNMaximum {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNMaximum();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNNegate = class XNNNegate {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNNegate();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNSquare = class XNNSquare {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNSquare();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNAbs = class XNNAbs {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNAbs();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNPReLU = class XNNPReLU {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNPReLU();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNConcatenate2 = class XNNConcatenate2 {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNConcatenate2();
|
|
fb_xnnpack._XNNCat.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNConcatenate3 = class XNNConcatenate3 {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNConcatenate3();
|
|
fb_xnnpack._XNNCat.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNConcatenate4 = class XNNConcatenate4 {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNConcatenate4();
|
|
fb_xnnpack._XNNCat.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNBatchMatrixMultiply = class XNNBatchMatrixMultiply {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNBatchMatrixMultiply();
|
|
fb_xnnpack._XNNNode2x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNConcatenate5 = class XNNConcatenate5 {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNConcatenate5();
|
|
fb_xnnpack._XNNCat.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNConvTranspose2d = class XNNConvTranspose2d {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNConvTranspose2d();
|
|
fb_xnnpack._XNNNodeConv.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNReciprocalSquareRoot = class XNNReciprocalSquareRoot {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNReciprocalSquareRoot();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNLog = class XNNLog {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNLog();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNGelu = class XNNGelu {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNGelu();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNTanh = class XNNTanh {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNTanh();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNExp = class XNNExp {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNExp();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNSin = class XNNSin {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNSin();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNCopy = class XNNCopy {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNCopy();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
fb_xnnpack.XNNCos = class XNNCos {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new fb_xnnpack.XNNCos();
|
|
fb_xnnpack._XNNNode1x1.decode(reader, position, $);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.OperatorCall = class OperatorCall {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.OperatorCall();
|
|
$.node_id = reader.uint32_(position, 4, 0);
|
|
$.name = reader.string_(position, 6, null);
|
|
$.args = reader.array(position, 8, Int32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.VkDataType = {
|
|
BOOL: 0, '0': 'BOOL',
|
|
UINT8: 1, '1': 'UINT8',
|
|
INT8: 2, '2': 'INT8',
|
|
INT32: 3, '3': 'INT32',
|
|
FLOAT16: 4, '4': 'FLOAT16',
|
|
FLOAT32: 5, '5': 'FLOAT32',
|
|
FLOAT64: 6, '6': 'FLOAT64',
|
|
INT64: 7, '7': 'INT64',
|
|
UNSET: 127, '127': 'UNSET'
|
|
};
|
|
|
|
vkgraph.VkStorageType = {
|
|
BUFFER: 0, '0': 'BUFFER',
|
|
TEXTURE_3D: 1, '1': 'TEXTURE_3D',
|
|
TEXTURE_2D: 2, '2': 'TEXTURE_2D',
|
|
DEFAULT_STORAGE: 255, '255': 'DEFAULT_STORAGE'
|
|
};
|
|
|
|
vkgraph.VkMemoryLayout = {
|
|
TENSOR_WIDTH_PACKED: 0, '0': 'TENSOR_WIDTH_PACKED',
|
|
TENSOR_HEIGHT_PACKED: 1, '1': 'TENSOR_HEIGHT_PACKED',
|
|
TENSOR_CHANNELS_PACKED: 2, '2': 'TENSOR_CHANNELS_PACKED',
|
|
PACKED_INT8_4W4C: 3, '3': 'PACKED_INT8_4W4C',
|
|
PACKED_INT8_4H4W: 4, '4': 'PACKED_INT8_4H4W',
|
|
PACKED_INT8_4W: 5, '5': 'PACKED_INT8_4W',
|
|
PACKED_INT8_4C: 6, '6': 'PACKED_INT8_4C',
|
|
PACKED_INT8_4C1W: 8, '8': 'PACKED_INT8_4C1W',
|
|
PACKED_INT8_CONV2D: 9, '9': 'PACKED_INT8_CONV2D',
|
|
DEFAULT_LAYOUT: 255, '255': 'DEFAULT_LAYOUT'
|
|
};
|
|
|
|
vkgraph.VkTensor = class VkTensor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.VkTensor();
|
|
$.datatype = reader.int8_(position, 4, 0);
|
|
$.dims = reader.array(position, 6, Uint32Array);
|
|
$.constant_id = reader.int32_(position, 8, 0);
|
|
$.mem_obj_id = reader.int32_(position, 10, 0);
|
|
$.storage_type = reader.uint8_(position, 12, 255);
|
|
$.memory_layout = reader.uint8_(position, 14, 255);
|
|
$.staging_datatype = reader.int8_(position, 16, 127);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.Null = class Null {
|
|
|
|
static decode(/* reader, position */) {
|
|
const $ = new vkgraph.Null();
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.Int = class Int {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.Int();
|
|
$.int_val = reader.int64_(position, 4, 0n);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.Bool = class Bool {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.Bool();
|
|
$.bool_val = reader.bool_(position, 4, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.Double = class Double {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.Double();
|
|
$.double_val = reader.float64_(position, 4, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.String = class String {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.String();
|
|
$.string_val = reader.string_(position, 4, null);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.IntList = class IntList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.IntList();
|
|
$.items = reader.int64s_(position, 4);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.DoubleList = class DoubleList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.DoubleList();
|
|
$.items = reader.array(position, 4, Float64Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.BoolList = class BoolList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.BoolList();
|
|
$.items = reader.bools_(position, 4);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.ValueList = class ValueList {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.ValueList();
|
|
$.items = reader.array(position, 4, Int32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.SymInt = class SymInt {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.SymInt();
|
|
$.value = reader.int32_(position, 4, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.GraphTypes = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return vkgraph.Null.decode(reader, position);
|
|
case 2: return vkgraph.Int.decode(reader, position);
|
|
case 3: return vkgraph.Double.decode(reader, position);
|
|
case 4: return vkgraph.Bool.decode(reader, position);
|
|
case 5: return vkgraph.VkTensor.decode(reader, position);
|
|
case 6: return vkgraph.IntList.decode(reader, position);
|
|
case 7: return vkgraph.DoubleList.decode(reader, position);
|
|
case 8: return vkgraph.BoolList.decode(reader, position);
|
|
case 9: return vkgraph.ValueList.decode(reader, position);
|
|
case 10: return vkgraph.String.decode(reader, position);
|
|
case 11: return vkgraph.SymInt.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
vkgraph.VkValue = class VkValue {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.VkValue();
|
|
$.value = reader.union(position, 4, vkgraph.GraphTypes);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.VkBytes = class VkBytes {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.VkBytes();
|
|
$.offset = reader.uint64_(position, 4, 0n);
|
|
$.length = reader.uint64_(position, 6, 0n);
|
|
$.named_key = reader.string_(position, 8, null);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
vkgraph.VkGraph = class VkGraph {
|
|
|
|
static identifier(reader) {
|
|
return reader.identifier === 'VK00';
|
|
}
|
|
|
|
static create(reader) {
|
|
return vkgraph.VkGraph.decode(reader, reader.root);
|
|
}
|
|
|
|
static decode(reader, position) {
|
|
const $ = new vkgraph.VkGraph();
|
|
$.version = reader.string_(position, 4, null);
|
|
$.chain = reader.tables(position, 6, vkgraph.OperatorCall);
|
|
$.values = reader.tables(position, 8, vkgraph.VkValue);
|
|
$.input_ids = reader.array(position, 10, Uint32Array);
|
|
$.output_ids = reader.array(position, 12, Uint32Array);
|
|
$.constants = reader.tables(position, 14, vkgraph.VkBytes);
|
|
$.shaders = reader.tables(position, 16, vkgraph.VkBytes);
|
|
$.storage_type_override = reader.uint8_(position, 18, 255);
|
|
$.memory_layout_override = reader.uint8_(position, 20, 255);
|
|
return $;
|
|
}
|
|
};
|