experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove all uses of TENSORFLOW_LITE_PROTOS.

Browse Source 
PiperOrigin-RevId: 310116123
Change-Id: I5fa28cc61644efc2fd202e80997a5c4c0a227572
This commit is contained in:
A. Unique TensorFlower 2020-05-06 02:40:04 -07:00 committed by TensorFlower Gardener
parent 2323679d9e
commit fedc6d951f
21 changed files with 136 additions and 175 deletions

1
tensorflow/compiler/mlir/tensorflow/BUILD
View File

@ -600,7 +600,6 @@ cc_library(
":error_util",
":parse_text_proto",
"//tensorflow/core:lib",
"//tensorflow/core:protos_all_cc",
"@com_google_absl//absl/strings",
"@llvm-project//llvm:support",
],

23
tensorflow/compiler/mlir/tensorflow/utils/import_utils.cc
View File

@ -31,12 +31,17 @@ inline llvm::StringRef StringViewToRef(absl::string_view view) {
}
} // namespace
Status LoadProtoFromBuffer(absl::string_view input,
protobuf::MessageLite* proto) {
Status LoadProtoFromBuffer(absl::string_view input, protobuf::Message* proto) {
// Attempt to parse as text.
if (ParseTextProto(input, "", proto).ok()) return Status::OK();
// Else attempt to parse as binary.
return LoadProtoFromBuffer(input, static_cast<protobuf::MessageLite*>(proto));
}
Status LoadProtoFromBuffer(absl::string_view input,
protobuf::MessageLite* proto) {
// Attempt to parse as binary.
protobuf::io::ArrayInputStream binary_stream(input.data(), input.size());
if (proto->ParseFromZeroCopyStream(&binary_stream)) return Status::OK();
@ -44,8 +49,8 @@ Status LoadProtoFromBuffer(absl::string_view input,
return errors::InvalidArgument("Could not parse input proto");
}
Status LoadProtoFromFile(absl::string_view input_filename,
protobuf::MessageLite* proto) {
template <class T>
Status LoadProtoFromFileImpl(absl::string_view input_filename, T* proto) {
const auto file_or_err =
llvm::MemoryBuffer::getFileOrSTDIN(StringViewToRef(input_filename));
if (std::error_code error = file_or_err.getError()) {
@ -60,4 +65,14 @@ Status LoadProtoFromFile(absl::string_view input_filename,
return LoadProtoFromBuffer(content, proto);
}
Status LoadProtoFromFile(absl::string_view input_filename,
protobuf::Message* proto) {
return LoadProtoFromFileImpl(input_filename, proto);
}
Status LoadProtoFromFile(absl::string_view input_filename,
protobuf::MessageLite* proto) {
return LoadProtoFromFileImpl(input_filename, proto);
}
} // namespace tensorflow

11
tensorflow/compiler/mlir/tensorflow/utils/import_utils.h
View File

@ -24,13 +24,20 @@ namespace tensorflow {
// Reads text (.pbtext) or binary (.pb) format of a proto message from the given
// buffer. Returns error status of the file is not found or malformed proto.
// Note that text protos can only be parsed when full protobuf::Message protos
// are used, and will fail for protobuf::MessageLite protos.
Status LoadProtoFromBuffer(absl::string_view input, protobuf::Message* proto);
Status LoadProtoFromBuffer(absl::string_view input,
tensorflow::protobuf::MessageLite* proto);
protobuf::MessageLite* proto);
// Reads text (.pbtext) or binary (.pb) format of a proto message from the given
// file path. Returns error status of the file is not found or malformed proto.
// Note that text protos can only be parsed when full protobuf::Message protos
// are used, and will fail for protobuf::MessageLite protos.
Status LoadProtoFromFile(absl::string_view input_filename,
tensorflow::protobuf::MessageLite* proto);
protobuf::Message* proto);
Status LoadProtoFromFile(absl::string_view input_filename,
protobuf::MessageLite* proto);
} // namespace tensorflow

11
tensorflow/compiler/mlir/tensorflow/utils/parse_text_proto.cc
View File

@ -24,7 +24,6 @@ limitations under the License.
namespace tensorflow {
#ifndef TENSORFLOW_LITE_PROTOS
namespace {
// Error collector that simply ignores errors reported.
class NoOpErrorCollector : public protobuf::io::ErrorCollector {
@ -32,7 +31,6 @@ class NoOpErrorCollector : public protobuf::io::ErrorCollector {
void AddError(int line, int column, const std::string& message) override {}
};
} // namespace
#endif // TENSORFLOW_LITE_PROTOS
Status ConsumePrefix(absl::string_view str, absl::string_view prefix,
absl::string_view* output) {
@ -45,8 +43,7 @@ Status ConsumePrefix(absl::string_view str, absl::string_view prefix,
Status ParseTextProto(absl::string_view text_proto,
absl::string_view prefix_to_strip,
protobuf::MessageLite* parsed_proto) {
#ifndef TENSORFLOW_LITE_PROTOS
protobuf::Message* parsed_proto) {
protobuf::TextFormat::Parser parser;
// Don't produce errors when attempting to parse text format as it would fail
// when the input is actually a binary file.
@ -60,15 +57,11 @@ Status ParseTextProto(absl::string_view text_proto,
}
protobuf::io::ArrayInputStream input_stream(text_proto_without_prefix.data(),
text_proto_without_prefix.size());
if (parser.Parse(&input_stream,
tensorflow::down_cast<protobuf::Message*>(parsed_proto))) {
if (parser.Parse(&input_stream, parsed_proto)) {
return Status::OK();
}
parsed_proto->Clear();
return errors::InvalidArgument("Could not parse text proto: ", text_proto);
#else
return errors::Unavailable("Cannot parse text protos on mobile.");
#endif // TENSORFLOW_LITE_PROTOS
}
} // namespace tensorflow

7
tensorflow/compiler/mlir/tensorflow/utils/parse_text_proto.h
View File

@ -32,7 +32,12 @@ Status ConsumePrefix(absl::string_view str, absl::string_view prefix,
// proto.
Status ParseTextProto(absl::string_view text_proto,
absl::string_view prefix_to_strip,
protobuf::MessageLite* parsed_proto);
protobuf::Message* parsed_proto);
inline Status ParseTextProto(absl::string_view /* text_proto */,
absl::string_view /* prefix_to_strip */,
protobuf::MessageLite* /* parsed_proto */) {
return errors::Unavailable("Cannot parse text protos on mobile.");
}
} // namespace tensorflow

5
tensorflow/core/BUILD
View File

@ -1374,10 +1374,7 @@ cc_library(
name = "portable_tensorflow_lib_lite",
srcs = if_mobile([":mobile_srcs"]),
copts = tf_copts(android_optimization_level_override = None) + tf_opts_nortti_if_lite_protos() + if_ios(["-Os"]),
defines = ["SUPPORT_SELECTIVE_REGISTRATION"] + tf_portable_full_lite_protos(
full = [],
lite = ["TENSORFLOW_LITE_PROTOS"],
) + if_chromiumos(["IS_MOBILE_PLATFORM"]) + tf_defines_nortti_if_lite_protos(),
defines = ["SUPPORT_SELECTIVE_REGISTRATION"] + if_chromiumos(["IS_MOBILE_PLATFORM"]) + tf_defines_nortti_if_lite_protos(),
linkopts = if_android(["-lz"]) + if_ios(["-lz"]),
tags = [
"manual",

7
tensorflow/core/framework/graph_to_functiondef.cc
View File

@ -276,17 +276,10 @@ Status FillFunctionBody(
}
}
if (!node_attr_def) {
#ifdef TENSORFLOW_LITE_PROTOS
return errors::Unimplemented(
"Placeholder value is not supported for attributes not in OpDef. "
"Attribute: ",
node_attr_name);
#else
return errors::Unimplemented(
"Placeholder value is not supported for attributes not in OpDef. "
"Attribute: ",
node_attr_name, ", OpDef: ", node->op_def().DebugString());
#endif
}
OpDef::AttrDef* attr_def = fdef->mutable_signature()->add_attr();
attr_def->set_name(func_attr_name);

12
tensorflow/core/framework/op_def_util.cc
View File

@ -783,11 +783,13 @@ void RemoveDescriptionsFromOpList(OpList* op_list) {
}
bool AttrDefEqual(const OpDef::AttrDef& a1, const OpDef::AttrDef& a2) {
#ifndef TENSORFLOW_LITE_PROTOS
DCHECK_EQ(7, a1.GetDescriptor()->field_count())
<< "Please modify these equality and hash functions to reflect the "
"changes to the AttrDef protobuf";
#endif // TENSORFLOW_LITE_PROTOS
if (std::is_base_of<protobuf::Message, OpDef::AttrDef>()) {
DCHECK_EQ(7, reinterpret_cast<const protobuf::Message*>(&a1)
->GetDescriptor()
->field_count())
<< "Please modify these equality and hash functions to reflect the "
"changes to the AttrDef protobuf";
}
if (a1.name() != a2.name()) return false;
if (a1.type() != a2.type()) return false;

41
tensorflow/core/grappler/grappler_item_builder.cc
View File

@ -14,6 +14,7 @@ limitations under the License.
==============================================================================*/
#include "tensorflow/core/grappler/grappler_item_builder.h"
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
@ -480,28 +481,28 @@ std::unique_ptr<GrapplerItem> GrapplerItemFromMetaGraphDef(
meta_graph.collection_def().at("saved_model_assets");
const auto& any_assets = collection.any_list().value();
if (!any_assets.empty()) {
#ifndef TENSORFLOW_LITE_PROTOS
for (const auto& any_asset : any_assets) {
AssetFileDef asset_file_def;
if (!ParseAny(any_asset, &asset_file_def, "tensorflow.AssetFileDef")
.ok()) {
LOG(ERROR) << "Failed to parse AssetFile.";
continue;
if (std::is_base_of<protobuf::Message, AssetFileDef>()) {
for (const auto& any_asset : any_assets) {
AssetFileDef asset_file_def;
if (!ParseAny(any_asset, &asset_file_def, "tensorflow.AssetFileDef")
.ok()) {
LOG(ERROR) << "Failed to parse AssetFile.";
continue;
}
string asset_filepath = io::JoinPath(cfg.assets_directory_override,
asset_file_def.filename());
if (!FilesExist({asset_filepath}, nullptr)) {
LOG(ERROR) << "Can't access one or more of the asset files "
<< asset_filepath << ", skipping this input";
return nullptr;
}
asset_node_to_value[NodeName(asset_file_def.tensor_info().name())] =
asset_filepath;
}
string asset_filepath = io::JoinPath(cfg.assets_directory_override,
asset_file_def.filename());
if (!FilesExist({asset_filepath}, nullptr)) {
LOG(ERROR) << "Can't access one or more of the asset files "
<< asset_filepath << ", skipping this input";
return nullptr;
}
asset_node_to_value[NodeName(asset_file_def.tensor_info().name())] =
asset_filepath;
} else {
LOG(ERROR) << "Can't parse AssetFileDef when using lite protos.";
return nullptr;
}
#else
LOG(ERROR) << "Can't parse AssetFileDef on mobile.";
return nullptr;
#endif // TENSORFLOW_LITE_PROTOS
}
}
} else if (meta_graph.collection_def().count("asset_filepaths") > 0) {

13
tensorflow/core/kernels/constant_op.cc
View File

@ -48,12 +48,15 @@ namespace tensorflow {
namespace {
NodeDef StripTensorDataFromNodeDef(OpKernelConstruction* ctx) {
#ifndef TENSORFLOW_LITE_PROTOS
DCHECK_EQ(NodeDef::descriptor()->field_count(), 6)
<< "The NodeDef format has changed, and the attr-stripping code may need "
<< "to be updated.";
#endif
const NodeDef& original = ctx->def();
if (std::is_base_of<protobuf::Message, NodeDef>()) {
DCHECK_EQ(reinterpret_cast<const protobuf::Message*>(&original)
->GetDescriptor()
->field_count(),
6)
<< "The NodeDef format has changed, and the attr-stripping code may "
"need to be updated.";
}
NodeDef ret;
ret.set_name(original.name());
ret.set_op(original.op());

5
tensorflow/core/kernels/example_parsing_ops.cc
View File

@ -950,9 +950,6 @@ class ParseSingleSequenceExampleOp : public OpKernel {
OP_REQUIRES_OK(ctx, ctx->output_list("feature_list_dense_values",
&feature_list_dense_values));
#ifdef TENSORFLOW_LITE_PROTOS
SequenceExample ex;
#else
// Allocate the SequenceExample on an arena. Provides better memory locality
// and greatly speeds up destruction.
protobuf::ArenaOptions options;
@ -965,7 +962,7 @@ class ParseSingleSequenceExampleOp : public OpKernel {
options.max_block_size = std::max(options.max_block_size, block_size);
protobuf::Arena arena(options);
auto& ex = *protobuf::Arena::CreateMessage<SequenceExample>(&arena);
#endif
OP_REQUIRES(
ctx, ParseProtoUnlimited(&ex, serialized_t()),
errors::InvalidArgument("Could not parse example input, value: '",

5
tensorflow/core/platform/BUILD
View File

@ -44,7 +44,6 @@ load(
"tf_cc_tests",
"tf_copts", # @unused
"tf_cuda_library",
"tf_portable_full_lite_protos",
)
load(
"@local_config_rocm//rocm:build_defs.bzl",
@ -472,10 +471,6 @@ cc_library(
"protobuf_util.cc",
],
hdrs = ["protobuf.h"],
defines = tf_portable_full_lite_protos(
full = [],
lite = ["TENSORFLOW_LITE_PROTOS"],
),
deps = [
":platform",
":types",

4
tensorflow/core/platform/build_config.bzl
View File

@ -31,8 +31,6 @@ load(
_tf_proto_library_py = "tf_proto_library_py",
_tf_protobuf_compiler_deps = "tf_protobuf_compiler_deps",
_tf_protobuf_deps = "tf_protobuf_deps",
_tf_protobuf_full_deps = "tf_protobuf_full_deps",
_tf_protobuf_lite_deps = "tf_protobuf_lite_deps",
_tf_protos_all = "tf_protos_all",
_tf_protos_all_impl = "tf_protos_all_impl",
_tf_protos_grappler = "tf_protos_grappler",
@ -73,8 +71,6 @@ tf_proto_library_cc = _tf_proto_library_cc
tf_proto_library_py = _tf_proto_library_py
tf_protobuf_compiler_deps = _tf_protobuf_compiler_deps
tf_protobuf_deps = _tf_protobuf_deps
tf_protobuf_full_deps = _tf_protobuf_full_deps
tf_protobuf_lite_deps = _tf_protobuf_lite_deps
tf_protos_all = _tf_protos_all
tf_protos_all_impl = _tf_protos_all_impl
tf_protos_grappler = _tf_protos_grappler

6
tensorflow/core/platform/default/build_config.bzl
View File

@ -717,12 +717,6 @@ def tf_fingerprint_deps():
"@farmhash_archive//:farmhash",
]
def tf_protobuf_full_deps():
return tf_protobuf_deps()
def tf_protobuf_lite_deps():
return tf_protobuf_deps()
def tf_protobuf_deps():
return if_static(
[

24
tensorflow/core/platform/default/human_readable_json.cc
View File

@ -23,10 +23,6 @@ namespace tensorflow {
Status ProtoToHumanReadableJson(const protobuf::Message& proto, string* result,
bool ignore_accuracy_loss) {
#ifdef TENSORFLOW_LITE_PROTOS
*result = "[human readable output not available on Android]";
return Status::OK();
#else
result->clear();
protobuf::util::JsonPrintOptions json_options;
@ -37,31 +33,37 @@ Status ProtoToHumanReadableJson(const protobuf::Message& proto, string* result,
if (!status.ok()) {
// Convert error_msg google::protobuf::StringPiece to
// tensorflow::StringPiece.
auto error_msg = status.error_message();
auto error_msg = status.message();
return errors::Internal(
strings::StrCat("Could not convert proto to JSON string: ",
StringPiece(error_msg.data(), error_msg.length())));
}
return Status::OK();
#endif
}
Status ProtoToHumanReadableJson(const protobuf::MessageLite& proto,
string* result, bool ignore_accuracy_loss) {
*result = "[human readable output not available for lite protos]";
return Status::OK();
}
Status HumanReadableJsonToProto(const string& str, protobuf::Message* proto) {
#ifdef TENSORFLOW_LITE_PROTOS
return errors::Internal("Cannot parse JSON protos on Android");
#else
proto->Clear();
auto status = protobuf::util::JsonStringToMessage(str, proto);
if (!status.ok()) {
// Convert error_msg google::protobuf::StringPiece to
// tensorflow::StringPiece.
auto error_msg = status.error_message();
auto error_msg = status.message();
return errors::Internal(
strings::StrCat("Could not convert JSON string to proto: ",
StringPiece(error_msg.data(), error_msg.length())));
}
return Status::OK();
#endif
}
Status HumanReadableJsonToProto(const string& str,
protobuf::MessageLite* proto) {
return errors::Internal("Cannot parse JSON protos on Android");
}
} // namespace tensorflow

39
tensorflow/core/platform/env.cc
View File

@ -496,7 +496,7 @@ Status FileSystemCopyFile(FileSystem* src_fs, const string& src,
// A ZeroCopyInputStream on a RandomAccessFile.
namespace {
class FileStream : public ::tensorflow::protobuf::io::ZeroCopyInputStream {
class FileStream : public protobuf::io::ZeroCopyInputStream {
public:
explicit FileStream(RandomAccessFile* file) : file_(file), pos_(0) {}
@ -533,14 +533,14 @@ class FileStream : public ::tensorflow::protobuf::io::ZeroCopyInputStream {
} // namespace
Status WriteBinaryProto(Env* env, const string& fname,
const ::tensorflow::protobuf::MessageLite& proto) {
const protobuf::MessageLite& proto) {
string serialized;
proto.AppendToString(&serialized);
return WriteStringToFile(env, fname, serialized);
}
Status ReadBinaryProto(Env* env, const string& fname,
::tensorflow::protobuf::MessageLite* proto) {
protobuf::MessageLite* proto) {
std::unique_ptr<RandomAccessFile> file;
TF_RETURN_IF_ERROR(env->NewRandomAccessFile(fname, &file));
std::unique_ptr<FileStream> stream(new FileStream(file.get()));
@ -549,7 +549,7 @@ Status ReadBinaryProto(Env* env, const string& fname,
// one to parse arbitrarily large messages for MessageLite. One most likely
// doesn't want to put protobufs larger than 64MB on Android, so we should
// eventually remove this and quit loud when a large protobuf is passed in.
::tensorflow::protobuf::io::CodedInputStream coded_stream(stream.get());
protobuf::io::CodedInputStream coded_stream(stream.get());
// Total bytes hard limit / warning limit are set to 1GB and 512MB
// respectively.
coded_stream.SetTotalBytesLimit(1024LL << 20, 512LL << 20);
@ -563,47 +563,36 @@ Status ReadBinaryProto(Env* env, const string& fname,
}
Status WriteTextProto(Env* env, const string& fname,
const ::tensorflow::protobuf::Message& proto) {
#if !defined(TENSORFLOW_LITE_PROTOS)
const protobuf::Message& proto) {
string serialized;
if (!::tensorflow::protobuf::TextFormat::PrintToString(proto, &serialized)) {
if (!protobuf::TextFormat::PrintToString(proto, &serialized)) {
return errors::FailedPrecondition("Unable to convert proto to text.");
}
return WriteStringToFile(env, fname, serialized);
#else
return errors::Unimplemented("Can't write text protos with protolite.");
#endif
}
Status ReadTextProto(Env* env, const string& fname,
::tensorflow::protobuf::Message* proto) {
#if !defined(TENSORFLOW_LITE_PROTOS)
Status ReadTextProto(Env* env, const string& fname, protobuf::Message* proto) {
std::unique_ptr<RandomAccessFile> file;
TF_RETURN_IF_ERROR(env->NewRandomAccessFile(fname, &file));
std::unique_ptr<FileStream> stream(new FileStream(file.get()));
if (!::tensorflow::protobuf::TextFormat::Parse(stream.get(), proto)) {
if (!protobuf::TextFormat::Parse(stream.get(), proto)) {
TF_RETURN_IF_ERROR(stream->status());
return errors::DataLoss("Can't parse ", fname, " as text proto");
}
return Status::OK();
#else
return errors::Unimplemented("Can't parse text protos with protolite.");
#endif
}
Status ReadTextOrBinaryProto(Env* env, const string& fname,
#if !defined(TENSORFLOW_LITE_PROTOS)
::tensorflow::protobuf::Message* proto
#else
::tensorflow::protobuf::MessageLite* proto
#endif
) {
#if !defined(TENSORFLOW_LITE_PROTOS)
protobuf::Message* proto) {
if (ReadTextProto(env, fname, proto).ok()) {
return Status::OK();
}
#endif
return ReadBinaryProto(env, fname, proto);
}
Status ReadTextOrBinaryProto(Env* env, const string& fname,
protobuf::MessageLite* proto) {
return ReadBinaryProto(env, fname, proto);
}

24
tensorflow/core/platform/env.h
View File

@ -481,37 +481,31 @@ Status WriteStringToFile(Env* env, const string& fname,
/// Write binary representation of "proto" to the named file.
Status WriteBinaryProto(Env* env, const string& fname,
const ::tensorflow::protobuf::MessageLite& proto);
const protobuf::MessageLite& proto);
/// Reads contents of named file and parse as binary encoded proto data
/// and store into `*proto`.
Status ReadBinaryProto(Env* env, const string& fname,
::tensorflow::protobuf::MessageLite* proto);
protobuf::MessageLite* proto);
/// Write the text representation of "proto" to the named file.
Status WriteTextProto(Env* env, const string& fname,
const ::tensorflow::protobuf::Message& proto);
const protobuf::Message& proto);
/// Read contents of named file and parse as text encoded proto data
/// and store into `*proto`.
template <typename T, typename std::enable_if<!std::is_base_of<
protobuf::Message, T>::value>::type* = nullptr>
Status ReadTextProto(Env* env, const string& fname, T* proto) {
inline Status ReadTextProto(Env* /* env */, const string& /* fname */,
protobuf::MessageLite* /* proto */) {
return errors::Unimplemented("Can't parse text protos with protolite.");
}
Status ReadTextProto(Env* env, const string& fname,
::tensorflow::protobuf::Message* proto);
Status ReadTextProto(Env* env, const string& fname, protobuf::Message* proto);
/// Read contents of named file and parse as either text or binary encoded proto
/// data and store into `*proto`.
Status ReadTextOrBinaryProto(Env* env, const string& fname,
#if !defined(TENSORFLOW_LITE_PROTOS)
::tensorflow::protobuf::Message* proto
#else
::tensorflow::protobuf::MessageLite* proto
#endif
);
protobuf::Message* proto);
Status ReadTextOrBinaryProto(Env* env, const string& fname,
protobuf::MessageLite* proto);
// START_SKIP_DOXYGEN

4
tensorflow/core/platform/human_readable_json.h
View File

@ -31,10 +31,14 @@ namespace tensorflow {
// accuracy loss with large integers.
Status ProtoToHumanReadableJson(const protobuf::Message& proto, string* result,
bool ignore_accuracy_loss);
Status ProtoToHumanReadableJson(const protobuf::MessageLite& proto,
string* result, bool ignore_accuracy_loss);
// Converts a string produced by ProtoToHumanReadableJSON to a protobuf. Not
// guaranteed to work for general JSON.
Status HumanReadableJsonToProto(const string& str, protobuf::Message* proto);
Status HumanReadableJsonToProto(const string& str,
protobuf::MessageLite* proto);
} // namespace tensorflow

16
tensorflow/core/platform/protobuf.h
View File

@ -25,22 +25,20 @@ limitations under the License.
// TensorFlow code should use the ::tensorflow::protobuf namespace to
// refer to all protobuf APIs.
#ifndef TENSORFLOW_LITE_PROTOS
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/io/tokenizer.h"
#include "google/protobuf/io/zero_copy_stream.h"
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/dynamic_message.h"
#include "google/protobuf/map.h"
#include "google/protobuf/message.h"
#include "google/protobuf/repeated_field.h"
#include "google/protobuf/text_format.h"
#include "google/protobuf/util/json_util.h"
#include "google/protobuf/util/type_resolver_util.h"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/io/zero_copy_stream.h"
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/map.h"
#include "google/protobuf/repeated_field.h"
namespace tensorflow {

33
tensorflow/core/platform/protobuf_internal.h
View File

@ -24,46 +24,19 @@ limitations under the License.
namespace tensorflow {
// Returns the DebugString when available, or a stub message otherwise. Useful
// for messages that are incompatible with proto_text (e.g. those using Any).
#ifdef TENSORFLOW_LITE_PROTOS
template <class T>
string DebugStringIfAvailable(T proto) {
return "[DebugString not available with lite protos]";
}
#else
template <class T>
auto DebugStringIfAvailable(T proto) -> decltype(proto.DebugString()) {
return proto.DebugString();
}
#endif // defined(TENSORFLOW_LITE_PROTOS)
// Utility for parsing an Any value with full or lite protos.
template <class T>
Status ParseAny(const google::protobuf::Any& any, T* message,
const string& type_name) {
#ifdef TENSORFLOW_LITE_PROTOS
if (any.type_url() != strings::StrCat("type.googleapis.com/", type_name)) {
return errors::FailedPrecondition(
"Expected Any type_url for: ", type_name,
". Got: ", string(any.type_url().data(), any.type_url().size()), ".");
}
if (!message->ParseFromString(ProtobufStringToString(any.value()))) {
return errors::FailedPrecondition("Failed to unpack: ",
DebugStringIfAvailable(any));
}
#else
CHECK_EQ(type_name, message->descriptor()->full_name());
CHECK_EQ(type_name, message->GetTypeName());
if (!any.Is<T>()) {
return errors::FailedPrecondition(
"Expected Any type_url for: ", message->descriptor()->full_name(),
"Expected Any type_url for: ", message->GetTypeName(),
". Got: ", string(any.type_url().data(), any.type_url().size()), ".");
}
if (!any.UnpackTo(message)) {
return errors::FailedPrecondition("Failed to unpack: ",
DebugStringIfAvailable(any));
return errors::FailedPrecondition("Failed to unpack: ", any.DebugString());
}
#endif
return Status::OK();
}

20
tensorflow/core/util/dump_graph.cc
View File

@ -156,18 +156,22 @@ Status CreateWritableFile(Env* env, const string& dirname, const string& name,
return env->NewWritableFile(*filepath, file);
}
template <class T>
Status WriteTextProtoToUniqueFile(T& proto, WritableFile* file) {
Status WriteTextProtoToUniqueFile(const tensorflow::protobuf::Message& proto,
WritableFile* file) {
string s;
#if defined(TENSORFLOW_LITE_PROTOS)
if (!SerializeToStringDeterministic(proto, &s)) {
return errors::Internal("Failed to serialize proto to string.");
}
#else
if (!::tensorflow::protobuf::TextFormat::PrintToString(proto, &s)) {
return errors::FailedPrecondition("Unable to convert proto to text.");
}
#endif
TF_RETURN_IF_ERROR(file->Append(s));
return file->Close();
}
Status WriteTextProtoToUniqueFile(
const tensorflow::protobuf::MessageLite& proto, WritableFile* file) {
string s;
if (!SerializeToStringDeterministic(proto, &s)) {
return errors::Internal("Failed to serialize proto to string.");
}
TF_RETURN_IF_ERROR(file->Append(s));
return file->Close();
}