saymrwulf/onnxruntime
1
0
Fork 0
mirror of https://github.com/saymrwulf/onnxruntime.git synced 2026-07-19 19:00:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[On-Device-Training] Upgrade Flatbuffers to Support 2GB+ Checkpoints. (#19770)

Browse source 
### Description
Modifications to support 2GB+ checkpoint & Upgrading Flatbuffers


### Motivation and Context
This PR includes changes that will make ort handle 2GB+ checkpoints.
To do that we need to upgrade flatbuffers to 23.5.9 -
https://github.com/google/flatbuffers/pull/7945

- Modified the commitHash and the hash for the new version
- Removed the patch for rust generator's unused variable warning as it
is no longer producing this - [Check it out
here](d121e09d89/src/idl_gen_rust.cpp)
- Updated the VerifyField calls with alignment values that were
introduced in the new version.

---------

Co-authored-by: Sumit Agarwal <sumitagarwal@microsoft.com>
This commit is contained in:
Adam Louly 2024-03-14 16:36:24 -07:00 committed by GitHub
parent 87a9f77c56
commit 32558134a9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
25 changed files with 585 additions and 535 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
cgmanifests/generated/cgmanifest.json
View file

@ -86,7 +86,7 @@
"component": {
"type": "git",
"git": {
"commitHash": "6df40a2471737b27271bdd9b900ab5f3aec746c7",
"commitHash": "0100f6a5779831fa7a651e4b67ef389a8752bd9b",
"repositoryUrl": "https://github.com/google/flatbuffers.git"
},
"comments": "flatbuffers"

2
cmake/deps.txt
View file

@ -23,7 +23,7 @@ dlpack;https://github.com/dmlc/dlpack/archive/refs/tags/v0.6.zip;4d565dd2e5b3132
# Until the 3.4.1 release this is the best option we have.
# Issue link: https://gitlab.com/libeigen/eigen/-/issues/2744
eigen;https://gitlab.com/libeigen/eigen/-/archive/e7248b26a1ed53fa030c5c459f7ea095dfd276ac/eigen-e7248b26a1ed53fa030c5c459f7ea095dfd276ac.zip;be8be39fdbc6e60e94fa7870b280707069b5b81a
flatbuffers;https://github.com/google/flatbuffers/archive/refs/tags/v1.12.0.zip;ba0a75fd12dbef8f6557a74e611b7a3d0c5fe7bf
flatbuffers;https://github.com/google/flatbuffers/archive/refs/tags/v23.5.26.zip;59422c3b5e573dd192fead2834d25951f1c1670c
fp16;https://github.com/Maratyszcza/FP16/archive/0a92994d729ff76a58f692d3028ca1b64b145d91.zip;b985f6985a05a1c03ff1bb71190f66d8f98a1494
fxdiv;https://github.com/Maratyszcza/FXdiv/archive/63058eff77e11aa15bf531df5dd34395ec3017c8.zip;a5658f4036402dbca7cebee32be57fb8149811e1
google_benchmark;https://github.com/google/benchmark/archive/refs/tags/v1.8.3.zip;bf9870756ee3f8d2d3b346b24ee3600a41c74d3d

2
cmake/external/onnxruntime_external_deps.cmake vendored
View file

@ -109,7 +109,7 @@ FetchContent_Declare(
URL ${DEP_URL_flatbuffers}
URL_HASH SHA1=${DEP_SHA1_flatbuffers}
PATCH_COMMAND ${ONNXRUNTIME_FLATBUFFERS_PATCH_COMMAND}
FIND_PACKAGE_ARGS 1.12.0...<2.0.0 NAMES Flatbuffers
FIND_PACKAGE_ARGS 23.5.9 NAMES Flatbuffers
)
# Download a protoc binary from Internet if needed

40
cmake/patches/flatbuffers/flatbuffers.patch
View file

@ -2,35 +2,11 @@ diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3987eac9..5e5462f1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -223,7 +223,7 @@ elseif(CMAKE_COMPILER_IS_GNUCXX)
"${CMAKE_CXX_FLAGS} -std=c++0x")
endif(CYGWIN)
set(CMAKE_CXX_FLAGS
- "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Werror=shadow")
+ "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra -Werror=shadow -Wno-error=stringop-overflow")
set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.4)
if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
diff --git a/src/idl_gen_rust.cpp b/src/idl_gen_rust.cpp
index 55b8439b..dc03e8a8 100644
--- a/src/idl_gen_rust.cpp
+++ b/src/idl_gen_rust.cpp
@@ -406,7 +406,8 @@ class RustGenerator : public BaseGenerator {
// example: f(A, D::E) -> super::D::E
// does not include leaf object (typically a struct type).
- size_t i = 0;
+ // fix unused but set variable warning
+ //size_t i = 0;
std::stringstream stream;
auto s = src->components.begin();
@@ -417,7 +418,7 @@ class RustGenerator : public BaseGenerator {
if (*s != *d) { break; }
++s;
++d;
- ++i;
+ //++i;
}
for (; s != src->components.end(); ++s) { stream << "super::"; }
@@ -279,5 +279,5 @@
# Append FLATBUFFERS_CXX_FLAGS to CMAKE_CXX_FLAGS.
if(DEFINED FLATBUFFERS_CXX_FLAGS)
message(STATUS "extend CXX_FLAGS with ${FLATBUFFERS_CXX_FLAGS}")
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLATBUFFERS_CXX_FLAGS}")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLATBUFFERS_CXX_FLAGS} -Wno-error=stringop-overflow")
endif()
message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")

2
include/onnxruntime/core/graph/graph.h
View file

@ -21,7 +21,7 @@
#pragma warning(pop)
#endif
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/gsl.h"

18
onnxruntime/core/common/flatbuffers.h Normal file
View file

@ -0,0 +1,18 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma once
#if defined(__GNUC__)
#include "onnxruntime_config.h"
#pragma GCC diagnostic push
#ifdef HAS_SHORTEN_64_TO_32
#pragma GCC diagnostic ignored "-Wshorten-64-to-32"
#endif
#endif
#include "flatbuffers/flatbuffers.h"
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif

2
onnxruntime/core/flatbuffers/flatbuffers_utils.h
View file

@ -5,7 +5,7 @@
#include <unordered_map>
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/common.h"
#include "core/common/path_string.h"

2
onnxruntime/core/flatbuffers/schema/README.md
View file

@ -21,7 +21,7 @@ e.g.
- /build/Linux/Debug/_deps/flatbuffers-build/flatc
It is possible to use another flatc as well, e.g., from a separate installation. Note that ONNX Runtime uses
FlatBuffers 1.12.
FlatBuffers 23.5.26.
To update the flatbuffers schemas and generated files:
1. Modify [the ORT file format schema](ort.fbs) or [training checkpoint schema](ort_training_checkpoint.fbs).

56
onnxruntime/core/flatbuffers/schema/ort.fbs.h
View file

@ -4,7 +4,7 @@
#ifndef FLATBUFFERS_GENERATED_ORT_ONNXRUNTIME_FBS_H_
#define FLATBUFFERS_GENERATED_ORT_ONNXRUNTIME_FBS_H_
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
namespace onnxruntime {
namespace fbs {
@ -562,8 +562,8 @@ struct DimensionValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_DIM_TYPE) &&
VerifyField<int64_t>(verifier, VT_DIM_VALUE) &&
VerifyField<int8_t>(verifier, VT_DIM_TYPE, 1) &&
VerifyField<int64_t>(verifier, VT_DIM_VALUE, 8) &&
VerifyOffset(verifier, VT_DIM_PARAM) &&
verifier.VerifyString(dim_param()) &&
verifier.EndTable();
@ -634,7 +634,7 @@ struct TensorTypeAndShape FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_ELEM_TYPE) &&
VerifyField<int32_t>(verifier, VT_ELEM_TYPE, 4) &&
VerifyOffset(verifier, VT_SHAPE) &&
verifier.VerifyTable(shape()) &&
verifier.EndTable();
@ -687,7 +687,7 @@ struct MapType FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_KEY_TYPE) &&
VerifyField<int32_t>(verifier, VT_KEY_TYPE, 4) &&
VerifyOffset(verifier, VT_VALUE_TYPE) &&
verifier.VerifyTable(value_type()) &&
verifier.EndTable();
@ -787,7 +787,7 @@ struct NodeEdge FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_NODE_INDEX) &&
VerifyField<uint32_t>(verifier, VT_NODE_INDEX, 4) &&
VerifyOffset(verifier, VT_INPUT_EDGES) &&
verifier.VerifyVector(input_edges()) &&
VerifyOffset(verifier, VT_OUTPUT_EDGES) &&
@ -911,11 +911,11 @@ struct Node FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyString(doc_string()) &&
VerifyOffset(verifier, VT_DOMAIN) &&
verifier.VerifyString(domain()) &&
VerifyField<int32_t>(verifier, VT_SINCE_VERSION) &&
VerifyField<uint32_t>(verifier, VT_INDEX) &&
VerifyField<int32_t>(verifier, VT_SINCE_VERSION, 4) &&
VerifyField<uint32_t>(verifier, VT_INDEX, 4) &&
VerifyOffset(verifier, VT_OP_TYPE) &&
verifier.VerifyString(op_type()) &&
VerifyField<int32_t>(verifier, VT_TYPE) &&
VerifyField<int32_t>(verifier, VT_TYPE, 4) &&
VerifyOffset(verifier, VT_EXECUTION_PROVIDER_TYPE) &&
verifier.VerifyString(execution_provider_type()) &&
VerifyOffset(verifier, VT_INPUTS) &&
@ -1174,7 +1174,7 @@ struct TypeInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_DENOTATION) &&
verifier.VerifyString(denotation()) &&
VerifyField<uint8_t>(verifier, VT_VALUE_TYPE) &&
VerifyField<uint8_t>(verifier, VT_VALUE_TYPE, 1) &&
VerifyOffset(verifier, VT_VALUE) &&
VerifyTypeInfoValue(verifier, value(), value_type()) &&
verifier.EndTable();
@ -1259,7 +1259,7 @@ struct OperatorSetId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_DOMAIN) &&
verifier.VerifyString(domain()) &&
VerifyField<int64_t>(verifier, VT_VERSION) &&
VerifyField<int64_t>(verifier, VT_VERSION, 8) &&
verifier.EndTable();
}
};
@ -1343,7 +1343,7 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyString(doc_string()) &&
VerifyOffset(verifier, VT_DIMS) &&
verifier.VerifyVector(dims()) &&
VerifyField<int32_t>(verifier, VT_DATA_TYPE) &&
VerifyField<int32_t>(verifier, VT_DATA_TYPE, 4) &&
VerifyOffset(verifier, VT_RAW_DATA) &&
verifier.VerifyVector(raw_data()) &&
VerifyOffset(verifier, VT_STRING_DATA) &&
@ -1568,9 +1568,9 @@ struct Attribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_DOC_STRING) &&
verifier.VerifyString(doc_string()) &&
VerifyField<int32_t>(verifier, VT_TYPE) &&
VerifyField<float>(verifier, VT_F) &&
VerifyField<int64_t>(verifier, VT_I) &&
VerifyField<int32_t>(verifier, VT_TYPE, 4) &&
VerifyField<float>(verifier, VT_F, 4) &&
VerifyField<int64_t>(verifier, VT_I, 8) &&
VerifyOffset(verifier, VT_S) &&
verifier.VerifyString(s()) &&
VerifyOffset(verifier, VT_T) &&
@ -1759,12 +1759,12 @@ struct NodesToOptimizeIndices FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NODE_INDICES) &&
verifier.VerifyVector(node_indices()) &&
VerifyField<uint32_t>(verifier, VT_NUM_INPUTS) &&
VerifyField<uint32_t>(verifier, VT_NUM_OUTPUTS) &&
VerifyField<uint8_t>(verifier, VT_HAS_VARIADIC_INPUT) &&
VerifyField<uint8_t>(verifier, VT_HAS_VARIADIC_OUTPUT) &&
VerifyField<uint32_t>(verifier, VT_NUM_VARIADIC_INPUTS) &&
VerifyField<uint32_t>(verifier, VT_NUM_VARIADIC_OUTPUTS) &&
VerifyField<uint32_t>(verifier, VT_NUM_INPUTS, 4) &&
VerifyField<uint32_t>(verifier, VT_NUM_OUTPUTS, 4) &&
VerifyField<uint8_t>(verifier, VT_HAS_VARIADIC_INPUT, 1) &&
VerifyField<uint8_t>(verifier, VT_HAS_VARIADIC_OUTPUT, 1) &&
VerifyField<uint32_t>(verifier, VT_NUM_VARIADIC_INPUTS, 4) &&
VerifyField<uint32_t>(verifier, VT_NUM_VARIADIC_OUTPUTS, 4) &&
verifier.EndTable();
}
};
@ -1862,8 +1862,8 @@ struct DeprecatedNodeIndexAndKernelDefHash FLATBUFFERS_FINAL_CLASS : private fla
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_NODE_INDEX) &&
VerifyField<uint64_t>(verifier, VT_KERNEL_DEF_HASH) &&
VerifyField<uint32_t>(verifier, VT_NODE_INDEX, 4) &&
VerifyField<uint64_t>(verifier, VT_KERNEL_DEF_HASH, 8) &&
verifier.EndTable();
}
};
@ -2161,7 +2161,7 @@ struct Graph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_NODES) &&
verifier.VerifyVector(nodes()) &&
verifier.VerifyVectorOfTables(nodes()) &&
VerifyField<uint32_t>(verifier, VT_MAX_NODE_INDEX) &&
VerifyField<uint32_t>(verifier, VT_MAX_NODE_INDEX, 4) &&
VerifyOffset(verifier, VT_NODE_EDGES) &&
verifier.VerifyVector(node_edges()) &&
verifier.VerifyVectorOfTables(node_edges()) &&
@ -2390,7 +2390,7 @@ struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_IR_VERSION) &&
VerifyField<int64_t>(verifier, VT_IR_VERSION, 8) &&
VerifyOffset(verifier, VT_OPSET_IMPORT) &&
verifier.VerifyVector(opset_import()) &&
verifier.VerifyVectorOfTables(opset_import()) &&
@ -2400,7 +2400,7 @@ struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyString(producer_version()) &&
VerifyOffset(verifier, VT_DOMAIN) &&
verifier.VerifyString(domain()) &&
VerifyField<int64_t>(verifier, VT_MODEL_VERSION) &&
VerifyField<int64_t>(verifier, VT_MODEL_VERSION, 8) &&
VerifyOffset(verifier, VT_DOC_STRING) &&
verifier.VerifyString(doc_string()) &&
VerifyOffset(verifier, VT_GRAPH) &&
@ -2740,8 +2740,8 @@ struct ArgTypeAndIndex FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_ARG_TYPE) &&
VerifyField<uint32_t>(verifier, VT_INDEX) &&
VerifyField<int8_t>(verifier, VT_ARG_TYPE, 1) &&
VerifyField<uint32_t>(verifier, VT_INDEX, 4) &&
verifier.EndTable();
}
};

14
onnxruntime/core/flatbuffers/schema/ort_training_checkpoint.fbs.h
View file

@ -4,7 +4,7 @@
#ifndef FLATBUFFERS_GENERATED_ORTTRAININGCHECKPOINT_ONNXRUNTIME_FBS_H_
#define FLATBUFFERS_GENERATED_ORTTRAININGCHECKPOINT_ONNXRUNTIME_FBS_H_
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "ort.fbs.h"
@ -59,7 +59,7 @@ struct ModuleState FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_FROZEN_PARAMS) &&
verifier.VerifyVector(frozen_params()) &&
verifier.VerifyVectorOfTables(frozen_params()) &&
VerifyField<uint8_t>(verifier, VT_IS_NOMINAL_STATE) &&
VerifyField<uint8_t>(verifier, VT_IS_NOMINAL_STATE, 1) &&
verifier.EndTable();
}
};
@ -206,8 +206,8 @@ struct OptimizerGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_GROUP_NAME) &&
verifier.VerifyString(group_name()) &&
VerifyField<int64_t>(verifier, VT_STEP) &&
VerifyField<float>(verifier, VT_INITIAL_LEARNING_RATE) &&
VerifyField<int64_t>(verifier, VT_STEP, 8) &&
VerifyField<float>(verifier, VT_INITIAL_LEARNING_RATE, 4) &&
VerifyOffset(verifier, VT_OPTIMIZER_STATES) &&
verifier.VerifyVector(optimizer_states()) &&
verifier.VerifyVectorOfTables(optimizer_states()) &&
@ -289,7 +289,7 @@ struct IntProperty FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyField<int64_t>(verifier, VT_VALUE) &&
VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
verifier.EndTable();
}
};
@ -353,7 +353,7 @@ struct FloatProperty FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyField<float>(verifier, VT_VALUE) &&
VerifyField<float>(verifier, VT_VALUE, 4) &&
verifier.EndTable();
}
};
@ -572,7 +572,7 @@ struct Checkpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_VERSION) &&
VerifyField<int32_t>(verifier, VT_VERSION, 4) &&
VerifyOffset(verifier, VT_MODULE_STATE) &&
verifier.VerifyTable(module_state()) &&
VerifyOffset(verifier, VT_OPTIMIZER_GROUPS) &&

2
onnxruntime/core/framework/kernel_type_str_resolver.h
View file

@ -7,7 +7,7 @@
#include <string_view>
#include <utility>
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#if !defined(ORT_MINIMAL_BUILD)
#include "core/graph/onnx_protobuf.h"

2
onnxruntime/core/framework/kernel_type_str_resolver_utils.cc
View file

@ -5,7 +5,7 @@
#include "core/framework/kernel_type_str_resolver_utils.h"
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/common.h"
#include "core/flatbuffers/schema/ort.fbs.h"

2
onnxruntime/core/framework/session_state.h
View file

@ -8,7 +8,7 @@
#include <unordered_map>
#include <vector>
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/gsl.h"

2
onnxruntime/core/graph/graph_flatbuffers_utils.cc
View file

@ -3,7 +3,7 @@
#include "graph_flatbuffers_utils.h"
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/narrow.h"
#include "core/flatbuffers/flatbuffers_utils.h"

2
onnxruntime/core/graph/graph_flatbuffers_utils.h
View file

@ -5,7 +5,7 @@
#include <memory>
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/status.h"
#include "core/graph/ort_format_load_options.h"

2
onnxruntime/core/graph/model.h
View file

@ -8,7 +8,7 @@
#include <climits>
#include <string>
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/path.h"
#include "core/graph/graph_viewer.h"

2
onnxruntime/core/graph/op_identifier_utils.h
View file

@ -3,7 +3,7 @@
#pragma once
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/graph/op_identifier.h"

2
onnxruntime/core/graph/runtime_optimization_record_container.h
View file

@ -9,7 +9,7 @@
#include <unordered_map>
#include <vector>
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "core/common/common.h"
#include "core/graph/runtime_optimization_record.h"

440
onnxruntime/core/providers/dml/DmlExecutionProvider/src/External/DirectMLHelpers/DmlGraphDesc_generated.h vendored
View file

@ -4,7 +4,14 @@
#ifndef FLATBUFFERS_GENERATED_DMLGRAPHDESC_DML_IR_H_
#define FLATBUFFERS_GENERATED_DMLGRAPHDESC_DML_IR_H_
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
FLATBUFFERS_VERSION_MINOR == 5 &&
FLATBUFFERS_VERSION_REVISION == 26,
"Non-compatible flatbuffers version included");
#include "OperatorFieldTypes_generated.h"
@ -32,7 +39,7 @@ struct DmlGraphNodeBuilder;
struct DmlGraphDesc;
struct DmlGraphDescBuilder;
enum ConstantNodeDescDetail {
enum ConstantNodeDescDetail : uint8_t {
ConstantNodeDescDetail_NONE = 0,
ConstantNodeDescDetail_ConstantName = 1,
ConstantNodeDescDetail_ConstantRawData = 2,
@ -60,7 +67,7 @@ inline const char * const *EnumNamesConstantNodeDescDetail() {
}
inline const char *EnumNameConstantNodeDescDetail(ConstantNodeDescDetail e) {
if (flatbuffers::IsOutRange(e, ConstantNodeDescDetail_NONE, ConstantNodeDescDetail_ConstantRawData)) return "";
if (::flatbuffers::IsOutRange(e, ConstantNodeDescDetail_NONE, ConstantNodeDescDetail_ConstantRawData)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesConstantNodeDescDetail()[index];
}
@ -77,10 +84,10 @@ template<> struct ConstantNodeDescDetailTraits<dml::ir::ConstantRawData> {
static const ConstantNodeDescDetail enum_value = ConstantNodeDescDetail_ConstantRawData;
};
bool VerifyConstantNodeDescDetail(flatbuffers::Verifier &verifier, const void *obj, ConstantNodeDescDetail type);
bool VerifyConstantNodeDescDetailVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
bool VerifyConstantNodeDescDetail(::flatbuffers::Verifier &verifier, const void *obj, ConstantNodeDescDetail type);
bool VerifyConstantNodeDescDetailVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum NodeDesc {
enum NodeDesc : uint8_t {
NodeDesc_NONE = 0,
NodeDesc_OperatorNodeDesc = 1,
NodeDesc_ConstantNodeDesc = 2,
@ -108,7 +115,7 @@ inline const char * const *EnumNamesNodeDesc() {
}
inline const char *EnumNameNodeDesc(NodeDesc e) {
if (flatbuffers::IsOutRange(e, NodeDesc_NONE, NodeDesc_ConstantNodeDesc)) return "";
if (::flatbuffers::IsOutRange(e, NodeDesc_NONE, NodeDesc_ConstantNodeDesc)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesNodeDesc()[index];
}
@ -125,18 +132,21 @@ template<> struct NodeDescTraits<dml::ir::ConstantNodeDesc> {
static const NodeDesc enum_value = NodeDesc_ConstantNodeDesc;
};
bool VerifyNodeDesc(flatbuffers::Verifier &verifier, const void *obj, NodeDesc type);
bool VerifyNodeDescVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
bool VerifyNodeDesc(::flatbuffers::Verifier &verifier, const void *obj, NodeDesc type);
bool VerifyNodeDescVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
struct ConstantRawData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ConstantRawData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ConstantRawDataBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DATA = 4
};
const flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(flatbuffers::Verifier &verifier) const {
::flatbuffers::Vector<uint8_t> *mutable_data() {
return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
@ -146,33 +156,32 @@ struct ConstantRawData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ConstantRawDataBuilder {
typedef ConstantRawData Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(ConstantRawData::VT_DATA, data);
}
explicit ConstantRawDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit ConstantRawDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ConstantRawDataBuilder &operator=(const ConstantRawDataBuilder &);
flatbuffers::Offset<ConstantRawData> Finish() {
::flatbuffers::Offset<ConstantRawData> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ConstantRawData>(end);
auto o = ::flatbuffers::Offset<ConstantRawData>(end);
return o;
}
};
inline flatbuffers::Offset<ConstantRawData> CreateConstantRawData(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
inline ::flatbuffers::Offset<ConstantRawData> CreateConstantRawData(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
ConstantRawDataBuilder builder_(_fbb);
builder_.add_data(data);
return builder_.Finish();
}
inline flatbuffers::Offset<ConstantRawData> CreateConstantRawDataDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<ConstantRawData> CreateConstantRawDataDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *data = nullptr) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return dml::ir::CreateConstantRawData(
@ -180,15 +189,18 @@ inline flatbuffers::Offset<ConstantRawData> CreateConstantRawDataDirect(
data__);
}
struct ConstantName FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ConstantName FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ConstantNameBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4
};
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
const ::flatbuffers::String *name() const {
return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
bool Verify(flatbuffers::Verifier &verifier) const {
::flatbuffers::String *mutable_name() {
return GetPointer<::flatbuffers::String *>(VT_NAME);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
@ -198,33 +210,32 @@ struct ConstantName FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ConstantNameBuilder {
typedef ConstantName Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(ConstantName::VT_NAME, name);
}
explicit ConstantNameBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit ConstantNameBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ConstantNameBuilder &operator=(const ConstantNameBuilder &);
flatbuffers::Offset<ConstantName> Finish() {
::flatbuffers::Offset<ConstantName> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ConstantName>(end);
auto o = ::flatbuffers::Offset<ConstantName>(end);
return o;
}
};
inline flatbuffers::Offset<ConstantName> CreateConstantName(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> name = 0) {
inline ::flatbuffers::Offset<ConstantName> CreateConstantName(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> name = 0) {
ConstantNameBuilder builder_(_fbb);
builder_.add_name(name);
return builder_.Finish();
}
inline flatbuffers::Offset<ConstantName> CreateConstantNameDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<ConstantName> CreateConstantNameDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *name = nullptr) {
auto name__ = name ? _fbb.CreateString(name) : 0;
return dml::ir::CreateConstantName(
@ -232,7 +243,7 @@ inline flatbuffers::Offset<ConstantName> CreateConstantNameDirect(
name__);
}
struct ConstantNodeDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ConstantNodeDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ConstantNodeDescBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DATA_TYPE = 4,
@ -251,9 +262,12 @@ struct ConstantNodeDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const dml::ir::ConstantRawData *data_as_ConstantRawData() const {
return data_type() == dml::ir::ConstantNodeDescDetail_ConstantRawData ? static_cast<const dml::ir::ConstantRawData *>(data()) : nullptr;
}
bool Verify(flatbuffers::Verifier &verifier) const {
void *mutable_data() {
return GetPointer<void *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_DATA_TYPE) &&
VerifyField<uint8_t>(verifier, VT_DATA_TYPE, 1) &&
VerifyOffset(verifier, VT_DATA) &&
VerifyConstantNodeDescDetail(verifier, data(), data_type()) &&
verifier.EndTable();
@ -270,37 +284,36 @@ template<> inline const dml::ir::ConstantRawData *ConstantNodeDesc::data_as<dml:
struct ConstantNodeDescBuilder {
typedef ConstantNodeDesc Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_data_type(dml::ir::ConstantNodeDescDetail data_type) {
fbb_.AddElement<uint8_t>(ConstantNodeDesc::VT_DATA_TYPE, static_cast<uint8_t>(data_type), 0);
}
void add_data(flatbuffers::Offset<void> data) {
void add_data(::flatbuffers::Offset<void> data) {
fbb_.AddOffset(ConstantNodeDesc::VT_DATA, data);
}
explicit ConstantNodeDescBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit ConstantNodeDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ConstantNodeDescBuilder &operator=(const ConstantNodeDescBuilder &);
flatbuffers::Offset<ConstantNodeDesc> Finish() {
::flatbuffers::Offset<ConstantNodeDesc> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ConstantNodeDesc>(end);
auto o = ::flatbuffers::Offset<ConstantNodeDesc>(end);
return o;
}
};
inline flatbuffers::Offset<ConstantNodeDesc> CreateConstantNodeDesc(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<ConstantNodeDesc> CreateConstantNodeDesc(
::flatbuffers::FlatBufferBuilder &_fbb,
dml::ir::ConstantNodeDescDetail data_type = dml::ir::ConstantNodeDescDetail_NONE,
flatbuffers::Offset<void> data = 0) {
::flatbuffers::Offset<void> data = 0) {
ConstantNodeDescBuilder builder_(_fbb);
builder_.add_data(data);
builder_.add_data_type(data_type);
return builder_.Finish();
}
struct DmlBufferTensorDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct DmlBufferTensorDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DmlBufferTensorDescBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DATATYPE = 4,
@ -308,19 +321,31 @@ struct DmlBufferTensorDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
VT_STRIDES = 8,
VT_TOTALTENSORSIZEINBYTES = 10
};
const flatbuffers::String *dataType() const {
return GetPointer<const flatbuffers::String *>(VT_DATATYPE);
const ::flatbuffers::String *dataType() const {
return GetPointer<const ::flatbuffers::String *>(VT_DATATYPE);
}
const flatbuffers::Vector<uint32_t> *sizes() const {
return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIZES);
::flatbuffers::String *mutable_dataType() {
return GetPointer<::flatbuffers::String *>(VT_DATATYPE);
}
const flatbuffers::Vector<uint32_t> *strides() const {
return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_STRIDES);
const ::flatbuffers::Vector<uint32_t> *sizes() const {
return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_SIZES);
}
::flatbuffers::Vector<uint32_t> *mutable_sizes() {
return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_SIZES);
}
const ::flatbuffers::Vector<uint32_t> *strides() const {
return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_STRIDES);
}
::flatbuffers::Vector<uint32_t> *mutable_strides() {
return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_STRIDES);
}
uint64_t totalTensorSizeInBytes() const {
return GetField<uint64_t>(VT_TOTALTENSORSIZEINBYTES, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
bool mutate_totalTensorSizeInBytes(uint64_t _totalTensorSizeInBytes = 0) {
return SetField<uint64_t>(VT_TOTALTENSORSIZEINBYTES, _totalTensorSizeInBytes, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_DATATYPE) &&
verifier.VerifyString(dataType()) &&
@ -328,44 +353,43 @@ struct DmlBufferTensorDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
verifier.VerifyVector(sizes()) &&
VerifyOffset(verifier, VT_STRIDES) &&
verifier.VerifyVector(strides()) &&
VerifyField<uint64_t>(verifier, VT_TOTALTENSORSIZEINBYTES) &&
VerifyField<uint64_t>(verifier, VT_TOTALTENSORSIZEINBYTES, 8) &&
verifier.EndTable();
}
};
struct DmlBufferTensorDescBuilder {
typedef DmlBufferTensorDesc Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_dataType(flatbuffers::Offset<flatbuffers::String> dataType) {
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_dataType(::flatbuffers::Offset<::flatbuffers::String> dataType) {
fbb_.AddOffset(DmlBufferTensorDesc::VT_DATATYPE, dataType);
}
void add_sizes(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> sizes) {
void add_sizes(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> sizes) {
fbb_.AddOffset(DmlBufferTensorDesc::VT_SIZES, sizes);
}
void add_strides(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> strides) {
void add_strides(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> strides) {
fbb_.AddOffset(DmlBufferTensorDesc::VT_STRIDES, strides);
}
void add_totalTensorSizeInBytes(uint64_t totalTensorSizeInBytes) {
fbb_.AddElement<uint64_t>(DmlBufferTensorDesc::VT_TOTALTENSORSIZEINBYTES, totalTensorSizeInBytes, 0);
}
explicit DmlBufferTensorDescBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit DmlBufferTensorDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DmlBufferTensorDescBuilder &operator=(const DmlBufferTensorDescBuilder &);
flatbuffers::Offset<DmlBufferTensorDesc> Finish() {
::flatbuffers::Offset<DmlBufferTensorDesc> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DmlBufferTensorDesc>(end);
auto o = ::flatbuffers::Offset<DmlBufferTensorDesc>(end);
return o;
}
};
inline flatbuffers::Offset<DmlBufferTensorDesc> CreateDmlBufferTensorDesc(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> dataType = 0,
flatbuffers::Offset<flatbuffers::Vector<uint32_t>> sizes = 0,
flatbuffers::Offset<flatbuffers::Vector<uint32_t>> strides = 0,
inline ::flatbuffers::Offset<DmlBufferTensorDesc> CreateDmlBufferTensorDesc(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> dataType = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> sizes = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> strides = 0,
uint64_t totalTensorSizeInBytes = 0) {
DmlBufferTensorDescBuilder builder_(_fbb);
builder_.add_totalTensorSizeInBytes(totalTensorSizeInBytes);
@ -375,8 +399,8 @@ inline flatbuffers::Offset<DmlBufferTensorDesc> CreateDmlBufferTensorDesc(
return builder_.Finish();
}
inline flatbuffers::Offset<DmlBufferTensorDesc> CreateDmlBufferTensorDescDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<DmlBufferTensorDesc> CreateDmlBufferTensorDescDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *dataType = nullptr,
const std::vector<uint32_t> *sizes = nullptr,
const std::vector<uint32_t> *strides = nullptr,
@ -392,7 +416,7 @@ inline flatbuffers::Offset<DmlBufferTensorDesc> CreateDmlBufferTensorDescDirect(
totalTensorSizeInBytes);
}
struct OperatorNodeDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct OperatorNodeDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef OperatorNodeDescBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TYPE = 4,
@ -400,19 +424,31 @@ struct OperatorNodeDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_OUTPUTS = 8,
VT_ATTRIBUTES = 10
};
const flatbuffers::String *type() const {
return GetPointer<const flatbuffers::String *>(VT_TYPE);
const ::flatbuffers::String *type() const {
return GetPointer<const ::flatbuffers::String *>(VT_TYPE);
}
const flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *inputs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *>(VT_INPUTS);
::flatbuffers::String *mutable_type() {
return GetPointer<::flatbuffers::String *>(VT_TYPE);
}
const flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *outputs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *>(VT_OUTPUTS);
const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *inputs() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *>(VT_INPUTS);
}
const flatbuffers::Vector<flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *attributes() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *>(VT_ATTRIBUTES);
::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *mutable_inputs() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *>(VT_INPUTS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *outputs() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *>(VT_OUTPUTS);
}
::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *mutable_outputs() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *>(VT_OUTPUTS);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *attributes() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *>(VT_ATTRIBUTES);
}
::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *mutable_attributes() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *>(VT_ATTRIBUTES);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_TYPE) &&
verifier.VerifyString(type()) &&
@ -431,38 +467,37 @@ struct OperatorNodeDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct OperatorNodeDescBuilder {
typedef OperatorNodeDesc Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_type(flatbuffers::Offset<flatbuffers::String> type) {
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_type(::flatbuffers::Offset<::flatbuffers::String> type) {
fbb_.AddOffset(OperatorNodeDesc::VT_TYPE, type);
}
void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> inputs) {
void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> inputs) {
fbb_.AddOffset(OperatorNodeDesc::VT_INPUTS, inputs);
}
void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> outputs) {
void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> outputs) {
fbb_.AddOffset(OperatorNodeDesc::VT_OUTPUTS, outputs);
}
void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>>> attributes) {
void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>>> attributes) {
fbb_.AddOffset(OperatorNodeDesc::VT_ATTRIBUTES, attributes);
}
explicit OperatorNodeDescBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit OperatorNodeDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
OperatorNodeDescBuilder &operator=(const OperatorNodeDescBuilder &);
flatbuffers::Offset<OperatorNodeDesc> Finish() {
::flatbuffers::Offset<OperatorNodeDesc> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<OperatorNodeDesc>(end);
auto o = ::flatbuffers::Offset<OperatorNodeDesc>(end);
return o;
}
};
inline flatbuffers::Offset<OperatorNodeDesc> CreateOperatorNodeDesc(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> type = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> inputs = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> outputs = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>>> attributes = 0) {
inline ::flatbuffers::Offset<OperatorNodeDesc> CreateOperatorNodeDesc(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> type = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> inputs = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>> outputs = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>>> attributes = 0) {
OperatorNodeDescBuilder builder_(_fbb);
builder_.add_attributes(attributes);
builder_.add_outputs(outputs);
@ -471,16 +506,16 @@ inline flatbuffers::Offset<OperatorNodeDesc> CreateOperatorNodeDesc(
return builder_.Finish();
}
inline flatbuffers::Offset<OperatorNodeDesc> CreateOperatorNodeDescDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<OperatorNodeDesc> CreateOperatorNodeDescDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *type = nullptr,
const std::vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *inputs = nullptr,
const std::vector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *outputs = nullptr,
const std::vector<flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *attributes = nullptr) {
const std::vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *inputs = nullptr,
const std::vector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>> *outputs = nullptr,
const std::vector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>> *attributes = nullptr) {
auto type__ = type ? _fbb.CreateString(type) : 0;
auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>(*inputs) : 0;
auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>(*outputs) : 0;
auto attributes__ = attributes ? _fbb.CreateVector<flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>>(*attributes) : 0;
auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>(*inputs) : 0;
auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<dml::ir::DmlBufferTensorDesc>>(*outputs) : 0;
auto attributes__ = attributes ? _fbb.CreateVector<::flatbuffers::Offset<dml::ir::operatorFieldTypes::AttributeDesc>>(*attributes) : 0;
return dml::ir::CreateOperatorNodeDesc(
_fbb,
type__,
@ -489,7 +524,7 @@ inline flatbuffers::Offset<OperatorNodeDesc> CreateOperatorNodeDescDirect(
attributes__);
}
struct DmlGraphNode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct DmlGraphNode FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DmlGraphNodeBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DESC_TYPE = 4,
@ -511,18 +546,30 @@ struct DmlGraphNode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const dml::ir::ConstantNodeDesc *desc_as_ConstantNodeDesc() const {
return desc_type() == dml::ir::NodeDesc_ConstantNodeDesc ? static_cast<const dml::ir::ConstantNodeDesc *>(desc()) : nullptr;
}
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
void *mutable_desc() {
return GetPointer<void *>(VT_DESC);
}
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputNames() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTNAMES);
const ::flatbuffers::String *name() const {
return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputNames() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTNAMES);
::flatbuffers::String *mutable_name() {
return GetPointer<::flatbuffers::String *>(VT_NAME);
}
bool Verify(flatbuffers::Verifier &verifier) const {
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *inputNames() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INPUTNAMES);
}
::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_inputNames() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INPUTNAMES);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *outputNames() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_OUTPUTNAMES);
}
::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_outputNames() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_OUTPUTNAMES);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_DESC_TYPE) &&
VerifyField<uint8_t>(verifier, VT_DESC_TYPE, 1) &&
VerifyOffset(verifier, VT_DESC) &&
VerifyNodeDesc(verifier, desc(), desc_type()) &&
VerifyOffset(verifier, VT_NAME) &&
@ -547,42 +594,41 @@ template<> inline const dml::ir::ConstantNodeDesc *DmlGraphNode::desc_as<dml::ir
struct DmlGraphNodeBuilder {
typedef DmlGraphNode Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_desc_type(dml::ir::NodeDesc desc_type) {
fbb_.AddElement<uint8_t>(DmlGraphNode::VT_DESC_TYPE, static_cast<uint8_t>(desc_type), 0);
}
void add_desc(flatbuffers::Offset<void> desc) {
void add_desc(::flatbuffers::Offset<void> desc) {
fbb_.AddOffset(DmlGraphNode::VT_DESC, desc);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(DmlGraphNode::VT_NAME, name);
}
void add_inputNames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputNames) {
void add_inputNames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> inputNames) {
fbb_.AddOffset(DmlGraphNode::VT_INPUTNAMES, inputNames);
}
void add_outputNames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputNames) {
void add_outputNames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> outputNames) {
fbb_.AddOffset(DmlGraphNode::VT_OUTPUTNAMES, outputNames);
}
explicit DmlGraphNodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit DmlGraphNodeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DmlGraphNodeBuilder &operator=(const DmlGraphNodeBuilder &);
flatbuffers::Offset<DmlGraphNode> Finish() {
::flatbuffers::Offset<DmlGraphNode> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DmlGraphNode>(end);
auto o = ::flatbuffers::Offset<DmlGraphNode>(end);
return o;
}
};
inline flatbuffers::Offset<DmlGraphNode> CreateDmlGraphNode(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<DmlGraphNode> CreateDmlGraphNode(
::flatbuffers::FlatBufferBuilder &_fbb,
dml::ir::NodeDesc desc_type = dml::ir::NodeDesc_NONE,
flatbuffers::Offset<void> desc = 0,
flatbuffers::Offset<flatbuffers::String> name = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputNames = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputNames = 0) {
::flatbuffers::Offset<void> desc = 0,
::flatbuffers::Offset<::flatbuffers::String> name = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> inputNames = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> outputNames = 0) {
DmlGraphNodeBuilder builder_(_fbb);
builder_.add_outputNames(outputNames);
builder_.add_inputNames(inputNames);
@ -592,16 +638,16 @@ inline flatbuffers::Offset<DmlGraphNode> CreateDmlGraphNode(
return builder_.Finish();
}
inline flatbuffers::Offset<DmlGraphNode> CreateDmlGraphNodeDirect(
flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<DmlGraphNode> CreateDmlGraphNodeDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
dml::ir::NodeDesc desc_type = dml::ir::NodeDesc_NONE,
flatbuffers::Offset<void> desc = 0,
::flatbuffers::Offset<void> desc = 0,
const char *name = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputNames = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputNames = nullptr) {
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *inputNames = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *outputNames = nullptr) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto inputNames__ = inputNames ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputNames) : 0;
auto outputNames__ = outputNames ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputNames) : 0;
auto inputNames__ = inputNames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*inputNames) : 0;
auto outputNames__ = outputNames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*outputNames) : 0;
return dml::ir::CreateDmlGraphNode(
_fbb,
desc_type,
@ -611,23 +657,32 @@ inline flatbuffers::Offset<DmlGraphNode> CreateDmlGraphNodeDirect(
outputNames__);
}
struct DmlGraphDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct DmlGraphDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef DmlGraphDescBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NODES = 4,
VT_GRAPHINPUTNAMES = 6,
VT_GRAPHOUTPUTNAMES = 8
};
const flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlGraphNode>> *nodes() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlGraphNode>> *>(VT_NODES);
const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlGraphNode>> *nodes() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlGraphNode>> *>(VT_NODES);
}
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *graphInputNames() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_GRAPHINPUTNAMES);
::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlGraphNode>> *mutable_nodes() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlGraphNode>> *>(VT_NODES);
}
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *graphOutputNames() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_GRAPHOUTPUTNAMES);
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *graphInputNames() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GRAPHINPUTNAMES);
}
bool Verify(flatbuffers::Verifier &verifier) const {
::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_graphInputNames() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GRAPHINPUTNAMES);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *graphOutputNames() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GRAPHOUTPUTNAMES);
}
::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_graphOutputNames() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GRAPHOUTPUTNAMES);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NODES) &&
verifier.VerifyVector(nodes()) &&
@ -644,34 +699,33 @@ struct DmlGraphDesc FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct DmlGraphDescBuilder {
typedef DmlGraphDesc Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_nodes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlGraphNode>>> nodes) {
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_nodes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlGraphNode>>> nodes) {
fbb_.AddOffset(DmlGraphDesc::VT_NODES, nodes);
}
void add_graphInputNames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> graphInputNames) {
void add_graphInputNames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> graphInputNames) {
fbb_.AddOffset(DmlGraphDesc::VT_GRAPHINPUTNAMES, graphInputNames);
}
void add_graphOutputNames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> graphOutputNames) {
void add_graphOutputNames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> graphOutputNames) {
fbb_.AddOffset(DmlGraphDesc::VT_GRAPHOUTPUTNAMES, graphOutputNames);
}
explicit DmlGraphDescBuilder(flatbuffers::FlatBufferBuilder &_fbb)
explicit DmlGraphDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DmlGraphDescBuilder &operator=(const DmlGraphDescBuilder &);
flatbuffers::Offset<DmlGraphDesc> Finish() {
::flatbuffers::Offset<DmlGraphDesc> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DmlGraphDesc>(end);
auto o = ::flatbuffers::Offset<DmlGraphDesc>(end);
return o;
}
};
inline flatbuffers::Offset<DmlGraphDesc> CreateDmlGraphDesc(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<dml::ir::DmlGraphNode>>> nodes = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> graphInputNames = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> graphOutputNames = 0) {
inline ::flatbuffers::Offset<DmlGraphDesc> CreateDmlGraphDesc(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<dml::ir::DmlGraphNode>>> nodes = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> graphInputNames = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> graphOutputNames = 0) {
DmlGraphDescBuilder builder_(_fbb);
builder_.add_graphOutputNames(graphOutputNames);
builder_.add_graphInputNames(graphInputNames);
@ -679,14 +733,14 @@ inline flatbuffers::Offset<DmlGraphDesc> CreateDmlGraphDesc(
return builder_.Finish();
}
inline flatbuffers::Offset<DmlGraphDesc> CreateDmlGraphDescDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<flatbuffers::Offset<dml::ir::DmlGraphNode>> *nodes = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *graphInputNames = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *graphOutputNames = nullptr) {
auto nodes__ = nodes ? _fbb.CreateVector<flatbuffers::Offset<dml::ir::DmlGraphNode>>(*nodes) : 0;
auto graphInputNames__ = graphInputNames ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*graphInputNames) : 0;
auto graphOutputNames__ = graphOutputNames ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*graphOutputNames) : 0;
inline ::flatbuffers::Offset<DmlGraphDesc> CreateDmlGraphDescDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<dml::ir::DmlGraphNode>> *nodes = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *graphInputNames = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *graphOutputNames = nullptr) {
auto nodes__ = nodes ? _fbb.CreateVector<::flatbuffers::Offset<dml::ir::DmlGraphNode>>(*nodes) : 0;
auto graphInputNames__ = graphInputNames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*graphInputNames) : 0;
auto graphOutputNames__ = graphOutputNames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*graphOutputNames) : 0;
return dml::ir::CreateDmlGraphDesc(
_fbb,
nodes__,
@ -694,7 +748,7 @@ inline flatbuffers::Offset<DmlGraphDesc> CreateDmlGraphDescDirect(
graphOutputNames__);
}
inline bool VerifyConstantNodeDescDetail(flatbuffers::Verifier &verifier, const void *obj, ConstantNodeDescDetail type) {
inline bool VerifyConstantNodeDescDetail(::flatbuffers::Verifier &verifier, const void *obj, ConstantNodeDescDetail type) {
switch (type) {
case ConstantNodeDescDetail_NONE: {
return true;
@ -711,10 +765,10 @@ inline bool VerifyConstantNodeDescDetail(flatbuffers::Verifier &verifier, const
}
}
inline bool VerifyConstantNodeDescDetailVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
inline bool VerifyConstantNodeDescDetailVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyConstantNodeDescDetail(
verifier, values->Get(i), types->GetEnum<ConstantNodeDescDetail>(i))) {
return false;
@ -723,7 +777,7 @@ inline bool VerifyConstantNodeDescDetailVector(flatbuffers::Verifier &verifier,
return true;
}
inline bool VerifyNodeDesc(flatbuffers::Verifier &verifier, const void *obj, NodeDesc type) {
inline bool VerifyNodeDesc(::flatbuffers::Verifier &verifier, const void *obj, NodeDesc type) {
switch (type) {
case NodeDesc_NONE: {
return true;
@ -740,10 +794,10 @@ inline bool VerifyNodeDesc(flatbuffers::Verifier &verifier, const void *obj, Nod
}
}
inline bool VerifyNodeDescVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
inline bool VerifyNodeDescVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyNodeDesc(
verifier, values->Get(i), types->GetEnum<NodeDesc>(i))) {
return false;
@ -753,32 +807,40 @@ inline bool VerifyNodeDescVector(flatbuffers::Verifier &verifier, const flatbuff
}
inline const dml::ir::DmlGraphDesc *GetDmlGraphDesc(const void *buf) {
return flatbuffers::GetRoot<dml::ir::DmlGraphDesc>(buf);
return ::flatbuffers::GetRoot<dml::ir::DmlGraphDesc>(buf);
}
inline const dml::ir::DmlGraphDesc *GetSizePrefixedDmlGraphDesc(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<dml::ir::DmlGraphDesc>(buf);
return ::flatbuffers::GetSizePrefixedRoot<dml::ir::DmlGraphDesc>(buf);
}
inline DmlGraphDesc *GetMutableDmlGraphDesc(void *buf) {
return ::flatbuffers::GetMutableRoot<DmlGraphDesc>(buf);
}
inline dml::ir::DmlGraphDesc *GetMutableSizePrefixedDmlGraphDesc(void *buf) {
return ::flatbuffers::GetMutableSizePrefixedRoot<dml::ir::DmlGraphDesc>(buf);
}
inline bool VerifyDmlGraphDescBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<dml::ir::DmlGraphDesc>(nullptr);
}
inline bool VerifySizePrefixedDmlGraphDescBuffer(
flatbuffers::Verifier &verifier) {
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<dml::ir::DmlGraphDesc>(nullptr);
}
inline void FinishDmlGraphDescBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<dml::ir::DmlGraphDesc> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<dml::ir::DmlGraphDesc> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedDmlGraphDescBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<dml::ir::DmlGraphDesc> root) {
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<dml::ir::DmlGraphDesc> root) {
fbb.FinishSizePrefixed(root);
}

495
onnxruntime/core/providers/dml/DmlExecutionProvider/src/External/DirectMLHelpers/OperatorFieldTypes_generated.h vendored
View file

File diff suppressed because it is too large Load diff

2
onnxruntime/core/providers/dml/DmlExecutionProvider/src/precomp.h
View file

@ -39,7 +39,7 @@
#include <d3d12sdklayers.h>
#include "External/D3DX12/d3dx12.h"
#endif
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
#include "GraphicsUnknownHelper.h"

2
onnxruntime/core/providers/migraphx/ort_trt_int8_cal_table.fbs.h
View file

@ -4,7 +4,7 @@
#define ONNXRUNTIME_CORE_PROVIDERS_MIGRAPHX_ORT_TRT_INT8_CAL_TABLE_FBS_H_
#include <vector>
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
namespace CalTableFlatBuffers {

2
onnxruntime/core/providers/tensorrt/ort_trt_int8_cal_table.fbs.h
View file

@ -3,7 +3,7 @@
#ifndef FLATBUFFERS_GENERATED_ORTTRTINT8CALTABLE_CALTABLEFLATBUFFERS_H_
#define FLATBUFFERS_GENERATED_ORTTRTINT8CALTABLE_CALTABLEFLATBUFFERS_H_
#include "flatbuffers/flatbuffers.h"
#include "core/common/flatbuffers.h"
namespace CalTableFlatBuffers {

4
tools/ci_build/github/azure-pipelines/templates/download-deps.yml
View file

@ -11,7 +11,7 @@ steps:
packageType: upack
feed: '/7424c8e4-5c62-490e-95c4-79446f31017c'
definition: '517c4f6f-5437-4392-a70d-4f15ec5be2f0'
version: 1.0.134
version: 1.0.143
downloadPath: $(Build.BinariesDirectory)/deps
# The private ADO project
@ -22,7 +22,7 @@ steps:
packageType: upack
feed: '/4c7631f5-24c0-4307-8822-1aa8f180c325'
definition: 'fd9dd5ad-b73e-4678-890e-edcf680dbc1a'
version: 1.0.134
version: 1.0.143
downloadPath: $(Build.BinariesDirectory)/deps
# You can add more ADO accounts at here.

19
tools/ci_build/github/azure-pipelines/templates/jobs/win-ci-vs-2022-job.yml
View file

@ -148,12 +148,9 @@ jobs:
Get-Volume $("$(Build.BinariesDirectory)")[0]
displayName: check disk size
- task: DeleteFiles@1
displayName: 'Delete intermedia files from $(Build.BinariesDirectory)\${{ parameters.BuildConfig }}'
inputs:
SourceFolder: '$(Build.BinariesDirectory)\${{ parameters.BuildConfig }}'
Contents: |
**/*.obj
- powershell: |
Remove-Item "$(Build.BinariesDirectory)\${{ parameters.BuildConfig }}" -Include "*.obj" -Recurse
displayName: 'Delete intermediate files from $(Build.BinariesDirectory)\${{ parameters.BuildConfig }}'
- powershell: |
Get-Volume $("$(Build.BinariesDirectory)")[0]
@ -221,14 +218,6 @@ jobs:
workingDirectory: '$(Build.BinariesDirectory)\${{ parameters.BuildConfig }}\${{ parameters.BuildConfig }}'
displayName: 'Run tests'
- task: PublishTestResults@2
displayName: 'Publish unit test results'
inputs:
testResultsFiles: '**/*.results.xml'
searchFolder: '$(Build.BinariesDirectory)/${{ parameters.BuildConfig }}'
testRunTitle: 'Unit Test Run'
condition: succeededOrFailed()
- ${{ if eq(parameters.GenerateDocumentation, true) }}:
- task: PythonScript@0
displayName: 'Generate documentation'
@ -251,4 +240,4 @@ jobs:
condition: and(failed(), eq(variables['DocUpdateNeeded'], 'true'))
inputs:
pathtoPublish: '$(Build.SourcesDirectory)/docs/ContribOperators.md'
artifactName: 'ContribOperators.md'
artifactName: 'ContribOperators.md'