[go: nahoru, domu]
Skip to content

Commit

Permalink
Qualify uses of std::string
Browse files Browse the repository at this point in the history 
PiperOrigin-RevId: 317003622
Change-Id: Iae6a9a287ffd3b97dee8b9993c443db322936592
  • Loading branch information
@tensorflower-gardener
tensorflower-gardener committed Jun 18, 2020
1 parent adf0573 commit 56db128
Show file tree
Hide file tree
Showing 3 changed files with 77 additions and 72 deletions.
67 changes: 35 additions & 32 deletions tensorflow/lite/toco/logging/conversion_log_util.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,8 +34,8 @@ namespace toco {

namespace {

string TryGetOperatorName(const Operator& op) {
string op_name;
std::string TryGetOperatorName(const Operator& op) {
std::string op_name;
if (!op.tensorflow_node_def.empty()) {
// Parse op name from serialized NodeDef.
tensorflow::NodeDef node_def;
Expand Down Expand Up @@ -63,35 +63,36 @@ string TryGetOperatorName(const Operator& op) {
return op_name;
}

string GetOSVersion() {
string os_info;
std::string GetOSVersion() {
std::string os_info;
#ifdef __linux__
utsname info;
if (uname(&info)) {
// Failed
LOG(ERROR) << "Cannot get OS info.";
return "";
}
os_info = string(info.sysname) + ";OSVer=" + string(info.release) + ";";
os_info =
std::string(info.sysname) + ";OSVer=" + std::string(info.release) + ";";
#endif
return os_info;
}

string ShapeToStringNoSpace(const Shape& shape) {
std::string ShapeToStringNoSpace(const Shape& shape) {
if (shape.dimensions_count() == 0) {
return "[]";
}

return absl::StrCat("[", absl::StrJoin(shape.dims(), ","), "]");
}

string GetOperatorSignature(
std::string GetOperatorSignature(
const Model& model, const Operator& op,
const std::map<OperatorType, std::unique_ptr<tflite::BaseOperator>>&
op_types_map) {
// The signature of an op has the following schema:
// INPUT:SHAPE::TYPE::OUTPUT:SHAPE::TYPE::NAME:VERSION:
string op_signature;
std::string op_signature;
constexpr char delimiter[] = "::";

// Get input shapes and types.
Expand Down Expand Up @@ -137,26 +138,26 @@ string GetOperatorSignature(

} // namespace

std::vector<string> GetOperatorNames(const Model& model) {
std::vector<string> op_names;
std::vector<std::string> GetOperatorNames(const Model& model) {
std::vector<std::string> op_names;
for (const auto& op : model.operators) {
op_names.push_back(TryGetOperatorName(*op));
}
return op_names;
}

void CountOperatorsByType(const Model& model,
std::map<string, int>* built_in_ops,
std::map<string, int>* custom_ops,
std::map<string, int>* select_ops) {
std::map<std::string, int>* built_in_ops,
std::map<std::string, int>* custom_ops,
std::map<std::string, int>* select_ops) {
for (const auto& op : model.operators) {
OperatorSignature op_signature = {op.get(), &model};
const auto ops_by_type =
tflite::BuildOperatorByTypeMap(true /*enable_select_tf_ops*/);
tflite::details::OperatorKey op_key(op_signature, ops_by_type,
true /*enable_select_tf_ops*/);

const string op_name = TryGetOperatorName(*op);
const std::string op_name = TryGetOperatorName(*op);
if (op_key.is_custom_op()) {
(*custom_ops)[op_name]++;
} else if (op_key.is_flex_op()) {
Expand All @@ -168,8 +169,9 @@ void CountOperatorsByType(const Model& model,
}

void GetInputAndOutputTypes(
const Model& model, TFLITE_PROTO_NS::RepeatedPtrField<string>* input_types,
TFLITE_PROTO_NS::RepeatedPtrField<string>* output_types) {
const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* input_types,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* output_types) {
for (const auto& input_array : model.flags.input_arrays()) {
const Array& array = model.GetArray(input_array.name());
input_types->Add(ArrayDataTypeName(array.data_type));
Expand All @@ -180,42 +182,43 @@ void GetInputAndOutputTypes(
}
}

string GetTfLiteVersion() { return TFLITE_VERSION_STRING; }
std::string GetTfLiteVersion() { return TFLITE_VERSION_STRING; }

string GetCachedOSVersion() {
static string* version = new string(GetOSVersion());
std::string GetCachedOSVersion() {
static std::string* version = new std::string(GetOSVersion());
return *version;
}

void GetOpSignatures(const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<string>* op_signatures) {
void GetOpSignatures(
const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* op_signatures) {
const auto& op_types_map =
tflite::BuildOperatorByTypeMap(true /*enable_select_tf_ops*/);
for (const auto& op : model.operators) {
op_signatures->Add(GetOperatorSignature(model, *op, op_types_map));
}
}

string GetModelHash(const Model& model) {
std::string GetModelHash(const Model& model) {
// TODO(b/123519920): Implement the hash function for Model.
// Need to consider different implementations for public/private models.
return "";
}

// This function scans through the error message string, extracts the part about
// missing ops and prunes away all other information in the error info.
string SanitizeErrorMessage(const string& error_message) {
const string s1 = "Ops that can be supported by the flex runtime";
const string s2 = "Ops that need custom implementation";
string pruned_message;
std::string SanitizeErrorMessage(const std::string& error_message) {
const std::string s1 = "Ops that can be supported by the flex runtime";
const std::string s2 = "Ops that need custom implementation";
std::string pruned_message;
size_t pos = error_message.find(s1);
if (pos != string::npos) {
if (pos != std::string::npos) {
// Find the terminate point for flex op list.
auto end = error_message.find(".", pos);
pruned_message.append(error_message.substr(pos, end - pos + 1));
}
pos = error_message.find(s2);
if (pos != string::npos) {
if (pos != std::string::npos) {
// Find the terminate point for custom op list.
auto end = error_message.find(".", pos);
pruned_message.append(error_message.substr(pos, end - pos + 1));
Expand All @@ -225,26 +228,26 @@ string SanitizeErrorMessage(const string& error_message) {

void PopulateConversionLog(const Model& model, TocoConversionLog* log) {
// Get the list of ops after conversion.
const std::vector<string> op_names = GetOperatorNames(model);
const std::vector<std::string> op_names = GetOperatorNames(model);
for (const auto& op_name : op_names) {
log->add_op_list(op_name);
}

// Get op signatures.
TFLITE_PROTO_NS::RepeatedPtrField<string> op_signatures;
TFLITE_PROTO_NS::RepeatedPtrField<std::string> op_signatures;
GetOpSignatures(model, &op_signatures);
log->mutable_op_signatures()->CopyFrom(op_signatures);

// Get op counts by category: custom, built-in or select.
std::map<string, int> custom_ops, select_ops, built_in_ops;
std::map<std::string, int> custom_ops, select_ops, built_in_ops;
CountOperatorsByType(model, &built_in_ops, &custom_ops, &select_ops);
log->mutable_custom_ops()->insert(custom_ops.cbegin(), custom_ops.cend());
log->mutable_built_in_ops()->insert(built_in_ops.cbegin(),
built_in_ops.cend());
log->mutable_select_ops()->insert(select_ops.cbegin(), select_ops.cend());

// Get the model's input and output types.
TFLITE_PROTO_NS::RepeatedPtrField<string> input_types, output_types;
TFLITE_PROTO_NS::RepeatedPtrField<std::string> input_types, output_types;
GetInputAndOutputTypes(model, &input_types, &output_types);
log->mutable_input_tensor_types()->CopyFrom(input_types);
log->mutable_output_tensor_types()->CopyFrom(output_types);
Expand Down
22 changes: 12 additions & 10 deletions tensorflow/lite/toco/logging/conversion_log_util.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,37 +25,39 @@ namespace toco {

// This function scans through the error message string, extracts the part about
// missing ops and prunes away all other information in the error info.
string SanitizeErrorMessage(const string& error_message);
std::string SanitizeErrorMessage(const std::string& error_message);

// Populates the TocoConversionLog proto after analyzing the model.
void PopulateConversionLog(const Model& model, TocoConversionLog* log);

// Returns the names of the operators in the model.
std::vector<string> GetOperatorNames(const Model& model);
std::vector<std::string> GetOperatorNames(const Model& model);

// Counts the number of different types of operators in the model:
// Built-in ops, custom ops and select ops.
// Each map is mapping from the name of the operator (such as 'Conv') to its
// total number of occurrences in the model.
void CountOperatorsByType(const Model& model,
std::map<string, int>* built_in_ops,
std::map<string, int>* custom_ops,
std::map<string, int>* select_ops);
std::map<std::string, int>* built_in_ops,
std::map<std::string, int>* custom_ops,
std::map<std::string, int>* select_ops);

// Gets the input and output types of the model. The input and output is
// specified by model.flags.input_arrays and model.flags.output_arrays.
void GetInputAndOutputTypes(
const Model& model, TFLITE_PROTO_NS::RepeatedPtrField<string>* input_types,
TFLITE_PROTO_NS::RepeatedPtrField<string>* output_types);
const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* input_types,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* output_types);

// Calculates signatures for all the ops in the model. An op signature is
// defined by its input/output shapes and types, op name and its version.
void GetOpSignatures(const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<string>* op_signatures);
void GetOpSignatures(
const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* op_signatures);

// TODO(b/123519920): Implement this.
// Calculates a unique hash for the model.
string GetModelHash(const Model& model);
std::string GetModelHash(const Model& model);

} // namespace toco

Expand Down
60 changes: 30 additions & 30 deletions tensorflow/lite/toco/logging/conversion_log_util_test.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -58,9 +58,9 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {
Model model;
// 1st Conv operator.
std::unique_ptr<ConvOperator> conv1(new ConvOperator());
const string conv1_input_name = "conv_input1";
const string conv1_filter_name = "conv_filter1";
const string conv1_output_name = "conv_output1";
const std::string conv1_input_name = "conv_input1";
const std::string conv1_filter_name = "conv_filter1";
const std::string conv1_output_name = "conv_output1";
conv1->inputs.push_back(conv1_input_name);
conv1->inputs.push_back(conv1_filter_name);
conv1->outputs.push_back(conv1_output_name);
Expand All @@ -71,9 +71,9 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {

// 2nd Conv operator.
std::unique_ptr<ConvOperator> conv2(new ConvOperator());
const string conv2_input_name = "conv_input2";
const string conv2_filter_name = "conv_filter2";
const string conv2_output_name = "conv_output2";
const std::string conv2_input_name = "conv_input2";
const std::string conv2_filter_name = "conv_filter2";
const std::string conv2_output_name = "conv_output2";
conv2->inputs.push_back(conv2_input_name);
conv2->inputs.push_back(conv2_filter_name);
conv2->outputs.push_back(conv2_output_name);
Expand All @@ -83,7 +83,7 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {

// Mean operator.
std::unique_ptr<MeanOperator> mean(new MeanOperator());
const string mean_input_name = "mean_input";
const std::string mean_input_name = "mean_input";
mean->inputs.push_back(mean_input_name);
array_map[mean_input_name] = std::unique_ptr<Array>(new Array);

Expand Down Expand Up @@ -111,26 +111,26 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {
model.operators.push_back(std::move(elu_grad));
model.operators.push_back(std::move(my_custom_op));

std::map<string, int> built_in_ops, select_ops, custom_ops;
std::map<std::string, int> built_in_ops, select_ops, custom_ops;
CountOperatorsByType(model, &built_in_ops, &custom_ops, &select_ops);

EXPECT_THAT(built_in_ops,
UnorderedElementsAre(std::pair<string, int>("Conv", 2),
std::pair<string, int>("Mean", 1)));
UnorderedElementsAre(std::pair<std::string, int>("Conv", 2),
std::pair<std::string, int>("Mean", 1)));
EXPECT_THAT(select_ops,
UnorderedElementsAre(std::pair<string, int>("AvgPool3D", 1),
std::pair<string, int>("EluGrad", 1)));
EXPECT_THAT(custom_ops, UnorderedElementsAre(
std::pair<string, int>("MyAwesomeCustomOp", 1)));
UnorderedElementsAre(std::pair<std::string, int>("AvgPool3D", 1),
std::pair<std::string, int>("EluGrad", 1)));
EXPECT_THAT(custom_ops, UnorderedElementsAre(std::pair<std::string, int>(
"MyAwesomeCustomOp", 1)));
}

TEST(ConversionLogUtilTest, TestGetInputAndOutputTypes) {
Model model;
auto& array_map = model.GetMutableArrayMap();
const string input1 = "conv_input";
const string input2 = "conv_filter";
const string input3 = "feature";
const string output = "softmax";
const std::string input1 = "conv_input";
const std::string input2 = "conv_filter";
const std::string input3 = "feature";
const std::string output = "softmax";
array_map[input1] = std::unique_ptr<Array>(new Array);
array_map[input1]->data_type = ArrayDataType::kFloat;
array_map[input2] = std::unique_ptr<Array>(new Array);
Expand All @@ -149,7 +149,7 @@ TEST(ConversionLogUtilTest, TestGetInputAndOutputTypes) {
*model.flags.add_input_arrays() = input_arrays[2];
model.flags.add_output_arrays(output);

TFLITE_PROTO_NS::RepeatedPtrField<string> input_types, output_types;
TFLITE_PROTO_NS::RepeatedPtrField<std::string> input_types, output_types;
GetInputAndOutputTypes(model, &input_types, &output_types);

EXPECT_THAT(input_types, ElementsAre("float", "float", "int16"));
Expand All @@ -161,9 +161,9 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
auto& array_map = model.GetMutableArrayMap();

std::unique_ptr<ConvOperator> conv(new ConvOperator());
const string conv_input_name = "conv_input";
const string conv_filter_name = "conv_filter";
const string conv_output_name = "conv_output";
const std::string conv_input_name = "conv_input";
const std::string conv_filter_name = "conv_filter";
const std::string conv_output_name = "conv_output";
conv->inputs.push_back(conv_input_name);
conv->inputs.push_back(conv_filter_name);
conv->outputs.push_back(conv_output_name);
Expand All @@ -177,15 +177,15 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
array_map[conv_output_name]->data_type = ArrayDataType::kFloat;
array_map[conv_output_name]->copy_shape({4, 4, 2});

const string mean_input_name = "mean_input";
const string mean_output_name = "mean_output";
const std::string mean_input_name = "mean_input";
const std::string mean_output_name = "mean_output";
std::unique_ptr<MeanOperator> mean(new MeanOperator());
mean->inputs.push_back(mean_input_name);
mean->outputs.push_back(mean_output_name);
array_map[mean_input_name] = std::unique_ptr<Array>(new Array);
array_map[mean_output_name] = std::unique_ptr<Array>(new Array);

const string avg_pool_3d_output_name = "avg_pool_output";
const std::string avg_pool_3d_output_name = "avg_pool_output";
auto avg_pool_3d = absl::make_unique<TensorFlowUnsupportedOperator>();
avg_pool_3d->tensorflow_op = "AvgPool3D";
tensorflow::NodeDef node_def;
Expand All @@ -197,7 +197,7 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
array_map[avg_pool_3d_output_name]->data_type = ArrayDataType::kInt32;
array_map[avg_pool_3d_output_name]->copy_shape({2, 2});

const string custom_op_output_name = "custom_op_output";
const std::string custom_op_output_name = "custom_op_output";
auto my_custom_op = absl::make_unique<TensorFlowUnsupportedOperator>();
my_custom_op->tensorflow_op = "MyAwesomeCustomOp";
my_custom_op->inputs.push_back(avg_pool_3d_output_name);
Expand All @@ -211,7 +211,7 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
model.operators.push_back(std::move(avg_pool_3d));
model.operators.push_back(std::move(my_custom_op));

TFLITE_PROTO_NS::RepeatedPtrField<string> op_signatures;
TFLITE_PROTO_NS::RepeatedPtrField<std::string> op_signatures;
GetOpSignatures(model, &op_signatures);
EXPECT_THAT(op_signatures,
UnorderedElementsAre(
Expand All @@ -225,14 +225,14 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
}

TEST(ConversionLogUtilTest, TestSanitizeErrorMessage) {
const string error =
const std::string error =
"error: failed while converting: 'main': Ops that can be supported by "
"the flex runtime (enabled via setting the -emit-select-tf-ops flag): "
"ResizeNearestNeighbor,ResizeNearestNeighbor. Ops that need custom "
"implementation (enabled via setting the -emit-custom-ops flag): "
"CombinedNonMaxSuppression.\nTraceback (most recent call last): File "
"/usr/local/bin/toco_from_protos, line 8, in <module>";
const string pruned_error =
const std::string pruned_error =
"Ops that can be supported by "
"the flex runtime (enabled via setting the -emit-select-tf-ops flag): "
"ResizeNearestNeighbor,ResizeNearestNeighbor.Ops that need custom "
Expand All @@ -242,7 +242,7 @@ TEST(ConversionLogUtilTest, TestSanitizeErrorMessage) {
}

TEST(ConversionLogUtilTest, TestSanitizeErrorMessageNoMatching) {
const string error =
const std::string error =
"error: failed while converting: 'main': Traceback (most recent call "
"last): File "
"/usr/local/bin/toco_from_protos, line 8, in <module>";
Expand Down

0 comments on commit 56db128

Please sign in to comment.