[go: nahoru, domu]
Skip to content

Commit

Permalink
Fix broken build for :validator_runner_entrypoint target in oss.
Browse files Browse the repository at this point in the history 
PiperOrigin-RevId: 493692413
  • Loading branch information
@arfaian @tensorflower-gardener
arfaian authored and tensorflower-gardener committed Dec 7, 2022
1 parent e4d8b98 commit 8684036
Show file tree
Hide file tree
Showing 2 changed files with 150 additions and 9 deletions.
156 changes: 150 additions & 6 deletions tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h
100755 → 100644
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -2408,6 +2422,7 @@ struct BenchmarkResultT : public flatbuffers::NativeTable {
int32_t max_memory_kb = 0;
bool ok = false;
std::vector<std::unique_ptr<tflite::BenchmarkMetricT>> metrics{};
std::vector<std::unique_ptr<tflite::BenchmarkResult_::InferenceOutputT>> actual_output{};
BenchmarkResultT() = default;
BenchmarkResultT(const BenchmarkResultT &o);
BenchmarkResultT(BenchmarkResultT&&) FLATBUFFERS_NOEXCEPT = default;
Expand All @@ -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<int64_t> *initialization_time_us() const {
return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_INITIALIZATION_TIME_US);
Expand All @@ -2439,6 +2455,9 @@ struct BenchmarkResult FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkMetric>> *metrics() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkMetric>> *>(VT_METRICS);
}
const flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>> *actual_output() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>> *>(VT_ACTUAL_OUTPUT);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_INITIALIZATION_TIME_US) &&
Expand All @@ -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;
Expand All @@ -2476,6 +2498,9 @@ struct BenchmarkResultBuilder {
void add_metrics(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkMetric>>> metrics) {
fbb_.AddOffset(BenchmarkResult::VT_METRICS, metrics);
}
void add_actual_output(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>>> actual_output) {
fbb_.AddOffset(BenchmarkResult::VT_ACTUAL_OUTPUT, actual_output);
}
explicit BenchmarkResultBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
Expand All @@ -2493,8 +2518,10 @@ inline flatbuffers::Offset<BenchmarkResult> CreateBenchmarkResult(
flatbuffers::Offset<flatbuffers::Vector<int64_t>> inference_time_us = 0,
int32_t max_memory_kb = 0,
bool ok = false,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkMetric>>> metrics = 0) {
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkMetric>>> metrics = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>>> 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);
Expand All @@ -2509,21 +2536,90 @@ inline flatbuffers::Offset<BenchmarkResult> CreateBenchmarkResultDirect(
const std::vector<int64_t> *inference_time_us = nullptr,
int32_t max_memory_kb = 0,
bool ok = false,
const std::vector<flatbuffers::Offset<tflite::BenchmarkMetric>> *metrics = nullptr) {
const std::vector<flatbuffers::Offset<tflite::BenchmarkMetric>> *metrics = nullptr,
const std::vector<flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>> *actual_output = nullptr) {
auto initialization_time_us__ = initialization_time_us ? _fbb.CreateVector<int64_t>(*initialization_time_us) : 0;
auto inference_time_us__ = inference_time_us ? _fbb.CreateVector<int64_t>(*inference_time_us) : 0;
auto metrics__ = metrics ? _fbb.CreateVector<flatbuffers::Offset<tflite::BenchmarkMetric>>(*metrics) : 0;
auto actual_output__ = actual_output ? _fbb.CreateVector<flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>>(*actual_output) : 0;
return tflite::CreateBenchmarkResult(
_fbb,
initialization_time_us__,
inference_time_us__,
max_memory_kb,
ok,
metrics__);
metrics__,
actual_output__);
}

flatbuffers::Offset<BenchmarkResult> 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<uint8_t> 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<uint8_t> *value() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(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<InferenceOutput> 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<flatbuffers::Vector<uint8_t>> value) {
fbb_.AddOffset(InferenceOutput::VT_VALUE, value);
}
explicit InferenceOutputBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<InferenceOutput> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<InferenceOutput>(end);
return o;
}
};

inline flatbuffers::Offset<InferenceOutput> CreateInferenceOutput(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> value = 0) {
InferenceOutputBuilder builder_(_fbb);
builder_.add_value(value);
return builder_.Finish();
}

inline flatbuffers::Offset<InferenceOutput> CreateInferenceOutputDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *value = nullptr) {
auto value__ = value ? _fbb.CreateVector<uint8_t>(*value) : 0;
return tflite::BenchmarkResult_::CreateInferenceOutput(
_fbb,
value__);
}

flatbuffers::Offset<InferenceOutput> 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;
Expand Down Expand Up @@ -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) {
Expand All @@ -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 {
Expand All @@ -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;
}

Expand All @@ -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<tflite::BenchmarkMetricT>(_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<tflite::BenchmarkResult_::InferenceOutputT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
}

inline flatbuffers::Offset<BenchmarkResult> BenchmarkResult::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkResultT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
Expand All @@ -4505,15 +4606,58 @@ inline flatbuffers::Offset<BenchmarkResult> CreateBenchmarkResult(flatbuffers::F
auto _max_memory_kb = _o->max_memory_kb;
auto _ok = _o->ok;
auto _metrics = _o->metrics.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::BenchmarkMetric>> (_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<flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>> (_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<InferenceOutputT>(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> InferenceOutput::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateInferenceOutput(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<InferenceOutput> 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
Expand Down
3 changes: 0 additions & 3 deletions tensorflow/lite/experimental/acceleration/mini_benchmark/validator_runner_entrypoint.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,9 +16,6 @@ limitations under the License.

#include <string>

#include "flatbuffers/buffer.h" // from @flatbuffers
#include "flatbuffers/vector.h" // from @flatbuffers

#ifndef _WIN32
#include <fcntl.h>
#include <sys/file.h>
Expand Down

0 comments on commit 8684036

Please sign in to comment.