From 8684036a982ca44f471d3196bb4b02bb537d5146 Mon Sep 17 00:00:00 2001 From: Arian Arfaian Date: Wed, 7 Dec 2022 13:27:03 -0800 Subject: [PATCH] Fix broken build for :validator_runner_entrypoint target in oss. PiperOrigin-RevId: 493692413 --- .../configuration/configuration_generated.h | 156 +++++++++++++++++- .../validator_runner_entrypoint.cc | 3 - 2 files changed, 150 insertions(+), 9 deletions(-) mode change 100755 => 100644 tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h diff --git a/tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h b/tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h old mode 100755 new mode 100644 index 8c90403c3ebee5..e4152020eaf43c --- a/tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h +++ b/tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h @@ -86,6 +86,14 @@ struct BenchmarkResult; struct BenchmarkResultBuilder; struct BenchmarkResultT; +namespace BenchmarkResult_ { + +struct InferenceOutput; +struct InferenceOutputBuilder; +struct InferenceOutputT; + +} // namespace BenchmarkResult_ + struct ErrorCode; struct ErrorCodeBuilder; struct ErrorCodeT; @@ -166,6 +174,12 @@ bool operator==(const BenchmarkMetricT &lhs, const BenchmarkMetricT &rhs); bool operator!=(const BenchmarkMetricT &lhs, const BenchmarkMetricT &rhs); bool operator==(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs); bool operator!=(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs); +namespace BenchmarkResult_ { + +bool operator==(const InferenceOutputT &lhs, const InferenceOutputT &rhs); +bool operator!=(const InferenceOutputT &lhs, const InferenceOutputT &rhs); +} // namespace BenchmarkResult_ + bool operator==(const ErrorCodeT &lhs, const ErrorCodeT &rhs); bool operator!=(const ErrorCodeT &lhs, const ErrorCodeT &rhs); bool operator==(const BenchmarkErrorT &lhs, const BenchmarkErrorT &rhs); @@ -2408,6 +2422,7 @@ struct BenchmarkResultT : public flatbuffers::NativeTable { int32_t max_memory_kb = 0; bool ok = false; std::vector> metrics{}; + std::vector> actual_output{}; BenchmarkResultT() = default; BenchmarkResultT(const BenchmarkResultT &o); BenchmarkResultT(BenchmarkResultT&&) FLATBUFFERS_NOEXCEPT = default; @@ -2422,7 +2437,8 @@ struct BenchmarkResult FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_INFERENCE_TIME_US = 6, VT_MAX_MEMORY_KB = 8, VT_OK = 10, - VT_METRICS = 12 + VT_METRICS = 12, + VT_ACTUAL_OUTPUT = 14 }; const flatbuffers::Vector *initialization_time_us() const { return GetPointer *>(VT_INITIALIZATION_TIME_US); @@ -2439,6 +2455,9 @@ struct BenchmarkResult FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const flatbuffers::Vector> *metrics() const { return GetPointer> *>(VT_METRICS); } + const flatbuffers::Vector> *actual_output() const { + return GetPointer> *>(VT_ACTUAL_OUTPUT); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_INITIALIZATION_TIME_US) && @@ -2450,6 +2469,9 @@ struct BenchmarkResult FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyOffset(verifier, VT_METRICS) && verifier.VerifyVector(metrics()) && verifier.VerifyVectorOfTables(metrics()) && + VerifyOffset(verifier, VT_ACTUAL_OUTPUT) && + verifier.VerifyVector(actual_output()) && + verifier.VerifyVectorOfTables(actual_output()) && verifier.EndTable(); } BenchmarkResultT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; @@ -2476,6 +2498,9 @@ struct BenchmarkResultBuilder { void add_metrics(flatbuffers::Offset>> metrics) { fbb_.AddOffset(BenchmarkResult::VT_METRICS, metrics); } + void add_actual_output(flatbuffers::Offset>> actual_output) { + fbb_.AddOffset(BenchmarkResult::VT_ACTUAL_OUTPUT, actual_output); + } explicit BenchmarkResultBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -2493,8 +2518,10 @@ inline flatbuffers::Offset CreateBenchmarkResult( flatbuffers::Offset> inference_time_us = 0, int32_t max_memory_kb = 0, bool ok = false, - flatbuffers::Offset>> metrics = 0) { + flatbuffers::Offset>> metrics = 0, + flatbuffers::Offset>> actual_output = 0) { BenchmarkResultBuilder builder_(_fbb); + builder_.add_actual_output(actual_output); builder_.add_metrics(metrics); builder_.add_max_memory_kb(max_memory_kb); builder_.add_inference_time_us(inference_time_us); @@ -2509,21 +2536,90 @@ inline flatbuffers::Offset CreateBenchmarkResultDirect( const std::vector *inference_time_us = nullptr, int32_t max_memory_kb = 0, bool ok = false, - const std::vector> *metrics = nullptr) { + const std::vector> *metrics = nullptr, + const std::vector> *actual_output = nullptr) { auto initialization_time_us__ = initialization_time_us ? _fbb.CreateVector(*initialization_time_us) : 0; auto inference_time_us__ = inference_time_us ? _fbb.CreateVector(*inference_time_us) : 0; auto metrics__ = metrics ? _fbb.CreateVector>(*metrics) : 0; + auto actual_output__ = actual_output ? _fbb.CreateVector>(*actual_output) : 0; return tflite::CreateBenchmarkResult( _fbb, initialization_time_us__, inference_time_us__, max_memory_kb, ok, - metrics__); + metrics__, + actual_output__); } flatbuffers::Offset CreateBenchmarkResult(flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkResultT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +namespace BenchmarkResult_ { + +struct InferenceOutputT : public flatbuffers::NativeTable { + typedef InferenceOutput TableType; + std::vector value{}; +}; + +struct InferenceOutput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InferenceOutputT NativeTableType; + typedef InferenceOutputBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + const flatbuffers::Vector *value() const { + return GetPointer *>(VT_VALUE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_VALUE) && + verifier.VerifyVector(value()) && + verifier.EndTable(); + } + InferenceOutputT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(InferenceOutputT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct InferenceOutputBuilder { + typedef InferenceOutput Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(flatbuffers::Offset> value) { + fbb_.AddOffset(InferenceOutput::VT_VALUE, value); + } + explicit InferenceOutputBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInferenceOutput( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> value = 0) { + InferenceOutputBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateInferenceOutputDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *value = nullptr) { + auto value__ = value ? _fbb.CreateVector(*value) : 0; + return tflite::BenchmarkResult_::CreateInferenceOutput( + _fbb, + value__); +} + +flatbuffers::Offset CreateInferenceOutput(flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +} // namespace BenchmarkResult_ + struct ErrorCodeT : public flatbuffers::NativeTable { typedef ErrorCode TableType; tflite::Delegate source = tflite::Delegate_NONE; @@ -4450,7 +4546,8 @@ inline bool operator==(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs) (lhs.inference_time_us == rhs.inference_time_us) && (lhs.max_memory_kb == rhs.max_memory_kb) && (lhs.ok == rhs.ok) && - (lhs.metrics == rhs.metrics); + (lhs.metrics == rhs.metrics) && + (lhs.actual_output == rhs.actual_output); } inline bool operator!=(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs) { @@ -4465,6 +4562,8 @@ inline BenchmarkResultT::BenchmarkResultT(const BenchmarkResultT &o) ok(o.ok) { metrics.reserve(o.metrics.size()); for (const auto &v : o.metrics) { metrics.emplace_back((v) ? new tflite::BenchmarkMetricT(*v) : nullptr); } + actual_output.reserve(o.actual_output.size()); + for (const auto &v : o.actual_output) { actual_output.emplace_back((v) ? new tflite::BenchmarkResult_::InferenceOutputT(*v) : nullptr); } } inline BenchmarkResultT &BenchmarkResultT::operator=(BenchmarkResultT o) FLATBUFFERS_NOEXCEPT { @@ -4473,6 +4572,7 @@ inline BenchmarkResultT &BenchmarkResultT::operator=(BenchmarkResultT o) FLATBUF std::swap(max_memory_kb, o.max_memory_kb); std::swap(ok, o.ok); std::swap(metrics, o.metrics); + std::swap(actual_output, o.actual_output); return *this; } @@ -4490,6 +4590,7 @@ inline void BenchmarkResult::UnPackTo(BenchmarkResultT *_o, const flatbuffers::r { auto _e = max_memory_kb(); _o->max_memory_kb = _e; } { auto _e = ok(); _o->ok = _e; } { auto _e = metrics(); if (_e) { _o->metrics.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->metrics[_i]) { _e->Get(_i)->UnPackTo(_o->metrics[_i].get(), _resolver); } else { _o->metrics[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = actual_output(); if (_e) { _o->actual_output.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->actual_output[_i]) { _e->Get(_i)->UnPackTo(_o->actual_output[_i].get(), _resolver); } else { _o->actual_output[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } } inline flatbuffers::Offset BenchmarkResult::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkResultT* _o, const flatbuffers::rehasher_function_t *_rehasher) { @@ -4505,15 +4606,58 @@ inline flatbuffers::Offset CreateBenchmarkResult(flatbuffers::F auto _max_memory_kb = _o->max_memory_kb; auto _ok = _o->ok; auto _metrics = _o->metrics.size() ? _fbb.CreateVector> (_o->metrics.size(), [](size_t i, _VectorArgs *__va) { return CreateBenchmarkMetric(*__va->__fbb, __va->__o->metrics[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _actual_output = _o->actual_output.size() ? _fbb.CreateVector> (_o->actual_output.size(), [](size_t i, _VectorArgs *__va) { return CreateInferenceOutput(*__va->__fbb, __va->__o->actual_output[i].get(), __va->__rehasher); }, &_va ) : 0; return tflite::CreateBenchmarkResult( _fbb, _initialization_time_us, _inference_time_us, _max_memory_kb, _ok, - _metrics); + _metrics, + _actual_output); +} + +namespace BenchmarkResult_ { + + +inline bool operator==(const InferenceOutputT &lhs, const InferenceOutputT &rhs) { + return + (lhs.value == rhs.value); +} + +inline bool operator!=(const InferenceOutputT &lhs, const InferenceOutputT &rhs) { + return !(lhs == rhs); +} + + +inline InferenceOutputT *InferenceOutput::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new InferenceOutputT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void InferenceOutput::UnPackTo(InferenceOutputT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = value(); if (_e) { _o->value.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->value.begin()); } } } +inline flatbuffers::Offset InferenceOutput::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateInferenceOutput(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateInferenceOutput(flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InferenceOutputT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _value = _o->value.size() ? _fbb.CreateVector(_o->value) : 0; + return tflite::BenchmarkResult_::CreateInferenceOutput( + _fbb, + _value); +} + +} // namespace BenchmarkResult_ + inline bool operator==(const ErrorCodeT &lhs, const ErrorCodeT &rhs) { return diff --git a/tensorflow/lite/experimental/acceleration/mini_benchmark/validator_runner_entrypoint.cc b/tensorflow/lite/experimental/acceleration/mini_benchmark/validator_runner_entrypoint.cc index 041f3dd5bc00c7..8bb59566958c82 100644 --- a/tensorflow/lite/experimental/acceleration/mini_benchmark/validator_runner_entrypoint.cc +++ b/tensorflow/lite/experimental/acceleration/mini_benchmark/validator_runner_entrypoint.cc @@ -16,9 +16,6 @@ limitations under the License. #include -#include "flatbuffers/buffer.h" // from @flatbuffers -#include "flatbuffers/vector.h" // from @flatbuffers - #ifndef _WIN32 #include #include