Use ParseFromTString/ParseFromArray for tstring.

1) This change elides an implicit copy to std::string.
2) Implicit conversion from tstring to std::string was added temporarily in
order to ease migration to tstring; implicit
`tstring::operator std::string() const' is now being deprecated.
3) ParseFromStringPiece is not available in external proto compilers.

PiperOrigin-RevId: 293226987
Change-Id: I5239be8219da1ff5170fe189179a1cac13c42959

tensorflow/compiler/xrt/kernels/xrt_compile_ops.cc

@@ -148,11 +148,11 @@ void XRTCompileOp::Compute(OpKernelContext* ctx) {
               errors::Internal("computation input should be a string scalar"));
 
   xrt::XLAComputation computation_proto;
-  OP_REQUIRES(
-      ctx,
-      computation_proto.ParseFromString(computation_input.scalar<tstring>()()),
-      errors::InvalidArgument(
-          "Unable to parse computation input to XLAComputation"));
+  OP_REQUIRES(ctx,
+              ParseFromTString(computation_input.scalar<tstring>()(),
+                               &computation_proto),
+              errors::InvalidArgument(
+                  "Unable to parse computation input to XLAComputation"));
 
   string key;
   OP_REQUIRES_OK(ctx, CompilationCacheKey(computation_proto, &key));

tensorflow/compiler/xrt/kernels/xrt_execute_op.cc

@@ -263,7 +263,7 @@ Status XRTExecuteOp::DoWork(OpKernelContext* context) {
   TF_RET_CHECK(TensorShapeUtils::IsScalar(execution_config.shape()));
   xrt::XRTExecutionConfig config_proto;
   TF_RET_CHECK(
-      config_proto.ParseFromString(execution_config.scalar<tstring>()()));
+      ParseFromTString(execution_config.scalar<tstring>()(), &config_proto));
 
   int core_index_in_replica = config_proto.core_index_in_replica();
   TF_RET_CHECK(core_index_in_replica == 0);
@@ -344,12 +344,12 @@ Status XRTExecuteChainedOp::DoWork(OpKernelContext* context) {
   const Tensor& execution_plan = context->input(0);
   TF_RET_CHECK(TensorShapeUtils::IsScalar(execution_plan.shape()));
   xrt::XRTChainedExecutePlan plan;
-  TF_RET_CHECK(plan.ParseFromString(execution_plan.scalar<tstring>()()));
+  TF_RET_CHECK(ParseFromTString(execution_plan.scalar<tstring>()(), &plan));
 
   const Tensor& execution_config = context->input(1);
   TF_RET_CHECK(TensorShapeUtils::IsScalar(execution_config.shape()));
   xrt::XRTChainedExecuteConfig config;
-  TF_RET_CHECK(config.ParseFromString(execution_config.scalar<tstring>()()));
+  TF_RET_CHECK(ParseFromTString(execution_config.scalar<tstring>()(), &config));
 
   TF_ASSIGN_OR_RETURN(
       auto cache, GetOrCreateCompilationCache(rm, /*max_number_of_entries=*/0));

tensorflow/compiler/xrt/kernels/xrt_state_ops.cc

@@ -39,7 +39,8 @@ class XRTMetricsCollectOp : public OpKernel {
     OP_REQUIRES(ctx, TensorShapeUtils::IsScalar(metrics_proto.shape()),
                 errors::Internal("request input should be a string scalar"));
     xrt::XRTMetricsCollect metrics;
-    OP_REQUIRES(ctx, metrics.ParseFromString(metrics_proto.scalar<tstring>()()),
+    OP_REQUIRES(ctx,
+                ParseFromTString(metrics_proto.scalar<tstring>()(), &metrics),
                 errors::InvalidArgument(
                     "Unable to parse request input to XRTMetricsCollect"));
 

tensorflow/compiler/xrt/kernels/xrt_state_ops.h

@@ -179,11 +179,11 @@ class XRTAllocateOp : public OpKernel {
     OP_REQUIRES(ctx, TensorShapeUtils::IsScalar(allocation_info.shape()),
                 errors::Internal("allocation input should be a string scalar"));
     xrt::XLAAllocation allocation_proto;
-    OP_REQUIRES(
-        ctx,
-        allocation_proto.ParseFromString(allocation_info.scalar<tstring>()()),
-        errors::InvalidArgument(
-            "Unable to parse allocation input to XLAAllocation"));
+    OP_REQUIRES(ctx,
+                ParseFromTString(allocation_info.scalar<tstring>()(),
+                                 &allocation_proto),
+                errors::InvalidArgument(
+                    "Unable to parse allocation input to XLAAllocation"));
 
     xla::Literal literal;
     OP_REQUIRES_OK(
@@ -429,7 +429,7 @@ class XRTMakeTupleOp : public OpKernel {
         errors::Internal("tuple description input should be a string scalar"));
     xrt::XLATupleNode tuple_proto;
     OP_REQUIRES(
-        ctx, tuple_proto.ParseFromString(tuple_info.scalar<tstring>()()),
+        ctx, ParseFromTString(tuple_info.scalar<tstring>()(), &tuple_proto),
         errors::InvalidArgument("Unable to parse tuple input to XLATupleNode"));
 
     OpInputList arg_list;
@@ -639,10 +639,10 @@ class XRTWriteLiteralOp : public OpKernel {
     OP_REQUIRES(ctx, TensorShapeUtils::IsScalar(literal_info.shape()),
                 errors::Internal("literal input should be a string scalar"));
     xla::LiteralProto literal_proto;
-    OP_REQUIRES(ctx,
-                literal_proto.ParseFromString(literal_info.scalar<tstring>()()),
-                errors::InvalidArgument(
-                    "Unable to parse allocation input to LiteralProto"));
+    OP_REQUIRES(
+        ctx, ParseFromTString(literal_info.scalar<tstring>()(), &literal_proto),
+        errors::InvalidArgument(
+            "Unable to parse allocation input to LiteralProto"));
     xla::Literal literal;
     OP_REQUIRES_OK(ctx, XRTStateHelpers::MakeLiteral(literal_proto, &literal));
 

tensorflow/compiler/xrt/tests/raw_api_test.cc

@@ -127,7 +127,7 @@ xla::LiteralProto FloatMatrix(
 
 xla::Literal ReadOutputLiteral(const std::vector<Tensor>& outputs, size_t idx) {
   xla::LiteralProto response;
-  CHECK(response.ParseFromString(outputs[idx].scalar<tstring>()()));
+  CHECK(ParseFromTString(outputs[idx].scalar<tstring>()(), &response));
   return xla::Literal::CreateFromProto(response).ValueOrDie();
 }
 
@@ -319,7 +319,7 @@ TEST(RawApiTest, AllocFromTensor) {
   EXPECT_EQ(outputs.size(), 1);
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
   EXPECT_TRUE(CompareLiteralToLiteralProto(literal, response));
 }
 
@@ -354,7 +354,7 @@ TEST(RawApiTest, AllocUninitialized) {
     EXPECT_EQ(outputs.size(), 1);
     xla::LiteralProto read_back_literal;
     EXPECT_TRUE(
-        read_back_literal.ParseFromString(outputs[0].scalar<tstring>()()));
+        ParseFromTString(outputs[0].scalar<tstring>()(), &read_back_literal));
     Tensor read_back_tensor;
     TF_ASSERT_OK(LiteralToHostTensor(
         xla::Literal::CreateFromProto(read_back_literal).ValueOrDie(), DT_FLOAT,
@@ -384,7 +384,7 @@ TEST(RawApiTest, AllocUninitialized) {
     EXPECT_EQ(outputs.size(), 1);
 
     xla::LiteralProto response;
-    EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+    EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
     EXPECT_TRUE(CompareLiteralProtos(response, new_literal));
   }
 }
@@ -416,7 +416,7 @@ TEST(RawApiTest, AllocFromTensorTuple) {
   EXPECT_EQ(outputs.size(), 1);
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
   EXPECT_TRUE(CompareLiteralToLiteralProto(literal, response));
 }
 
@@ -442,7 +442,7 @@ TEST(RawApiTest, AllocFromTensorTupleSingle) {
   EXPECT_EQ(outputs.size(), 1);
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
   EXPECT_TRUE(CompareLiteralToLiteralProto(literal, response));
 }
 
@@ -468,7 +468,7 @@ TEST(RawApiTest, AllocFromTensorRelayout) {
   EXPECT_EQ(outputs.size(), 1);
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
   // We have sent literal's data (in array layout) with a attribute layout
   // {0,1}, so the expected literal read from device needs to be changed
   // accordingly.
@@ -496,7 +496,7 @@ TEST(RawApiTest, AllocAndRewrite) {
 
   int64 allocation_handle = outputs[1].scalar<int64>()();
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
   EXPECT_TRUE(CompareLiteralProtos(alloc.value(), response));
 
   xla::LiteralProto new_literal =
@@ -515,7 +515,7 @@ TEST(RawApiTest, AllocAndRewrite) {
   EXPECT_EQ(outputs.size(), 1);
 
   xla::LiteralProto new_response;
-  EXPECT_TRUE(new_response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &new_response));
   EXPECT_TRUE(CompareLiteralProtos(new_literal, new_response));
 
   Tensor release_tensor(DT_INT64, TensorShape({1}));
@@ -655,7 +655,7 @@ TEST(RawApiTest, ReadAndWriteState) {
       session.Run(ClientSession::FeedType(), {read_back}, {release}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   EXPECT_TRUE(CompareLiteralProtos(alloc.value(), response));
 }
@@ -676,7 +676,7 @@ TEST(RawApiTest, ReadAndWriteStateAutoFree) {
   TF_EXPECT_OK(session.Run({read_back}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
   EXPECT_TRUE(CompareLiteralProtos(alloc.value(), response));
 }
 
@@ -710,13 +710,13 @@ TEST(RawApiTest, SubBuffer) {
   auto base_elements = base_literal.DecomposeTuple();
   auto nested_0_elements = base_elements[0].Clone().DecomposeTuple();
   xla::LiteralProto response_0;
-  EXPECT_TRUE(response_0.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response_0));
   EXPECT_TRUE(CompareLiteralToLiteralProto(base_elements[0], response_0));
   xla::LiteralProto response_1;
-  EXPECT_TRUE(response_1.ParseFromString(outputs[1].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[1].scalar<tstring>()(), &response_1));
   EXPECT_TRUE(CompareLiteralToLiteralProto(base_elements[1], response_1));
   xla::LiteralProto response_00;
-  EXPECT_TRUE(response_00.ParseFromString(outputs[2].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[2].scalar<tstring>()(), &response_00));
   EXPECT_TRUE(CompareLiteralToLiteralProto(nested_0_elements[0], response_00));
 }
 
@@ -782,9 +782,9 @@ TEST(RawApiTest, MakeTuple) {
   std::vector<Tensor> outputs;
   TF_EXPECT_OK(session.Run({res_0, res_1}, &outputs));
   xla::LiteralProto response_0;
-  EXPECT_TRUE(response_0.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response_0));
   xla::LiteralProto response_1;
-  EXPECT_TRUE(response_1.ParseFromString(outputs[1].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[1].scalar<tstring>()(), &response_1));
 
   auto expected_0 = MakeTuple0();
   EXPECT_TRUE(CompareLiteralProtos(response_0, expected_0));
@@ -856,7 +856,7 @@ TEST(RawApiTest, ExecuteChainedOpByOp) {
   TF_EXPECT_OK(session.Run({read_back}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto expected = xla::LiteralUtil::CreateR1<float>({-150.0f, -36.0f});
   EXPECT_TRUE(CompareLiteralToLiteralProto(expected, response));
@@ -976,7 +976,7 @@ TEST(RawApiTest, ExecuteChained) {
   EXPECT_EQ(outputs.size(), 1);
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto expected = xla::LiteralUtil::CreateR1<float>({-150.0f, -36.0f});
   EXPECT_TRUE(CompareLiteralToLiteralProto(expected, response));
@@ -1025,13 +1025,13 @@ TEST(RawApiTest, CompileAndExecute) {
   TF_EXPECT_OK(session.Run({read_back, c_handle.program_shape}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto expected = xla::LiteralUtil::CreateR1<float>({27.0f, 21.0f});
   EXPECT_TRUE(CompareLiteralToLiteralProto(expected, response));
 
   xla::ProgramShapeProto program_shape;
-  EXPECT_TRUE(program_shape.ParseFromString(outputs[1].vec<tstring>()(0)));
+  EXPECT_TRUE(ParseFromTString(outputs[1].vec<tstring>()(0), &program_shape));
   EXPECT_EQ(program_shape.parameters_size(), 2);
 }
 
@@ -1080,13 +1080,13 @@ TEST(RawApiTest, CompileAndExecuteWithArgumentVector) {
   TF_EXPECT_OK(session.Run({read_back, c_handle.program_shape}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto expected = xla::LiteralUtil::CreateR1<float>({27.0f, 21.0f});
   EXPECT_TRUE(CompareLiteralToLiteralProto(expected, response));
 
   xla::ProgramShapeProto program_shape;
-  EXPECT_TRUE(program_shape.ParseFromString(outputs[1].vec<tstring>()(0)));
+  EXPECT_TRUE(ParseFromTString(outputs[1].vec<tstring>()(0), &program_shape));
   EXPECT_EQ(program_shape.parameters_size(), 2);
 }
 
@@ -1132,7 +1132,7 @@ TEST(RawApiTest, CompileWithXlaReturnShapes) {
 
   xla::ProgramShapeProto program_shape_proto;
   EXPECT_TRUE(
-      program_shape_proto.ParseFromString(outputs[0].vec<tstring>()(0)));
+      ParseFromTString(outputs[0].vec<tstring>()(0), &program_shape_proto));
   xla::ProgramShape program_shape(program_shape_proto);
   EXPECT_EQ(program_shape.parameters_size(), 1);
 
@@ -1200,7 +1200,7 @@ TEST(RawApiTest, DotGeneralWithLayoutTest) {
   TF_EXPECT_OK(session.Run({read_back}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto expected =
       xla::LiteralUtil::CreateR2WithLayout<float>({{18.0f}, {44.0f}}, layout);
@@ -1235,7 +1235,7 @@ TEST(RawApiTest, CompileAndExecuteZeroArg) {
   TF_EXPECT_OK(session.Run({read_back}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto expected = xla::LiteralUtil::CreateR0<float>(3.0f);
   EXPECT_TRUE(CompareLiteralToLiteralProto(expected, response));
@@ -1285,7 +1285,7 @@ TEST(RawApiTest, CompileAndExecuteReturnTuple) {
   TF_EXPECT_OK(session.Run({read_back}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto sum = xla::LiteralUtil::CreateR1<float>({9.0f, 7.0f});
   auto expected = xla::LiteralUtil::MakeTuple({&sum});
@@ -1347,7 +1347,7 @@ TEST(RawApiTest, CompileAndExecuteReturnExplodedTuple) {
     EXPECT_EQ(voutputs.size(), 1);
 
     xla::LiteralProto response;
-    EXPECT_TRUE(response.ParseFromString(voutputs[0].scalar<tstring>()()));
+    EXPECT_TRUE(ParseFromTString(voutputs[0].scalar<tstring>()(), &response));
 
     auto expected = xla::LiteralUtil::CreateR0<float>(kResults[i]);
     EXPECT_TRUE(CompareLiteralToLiteralProto(expected, response));
@@ -1518,13 +1518,13 @@ TEST(RawApiTest, CompileAndExecuteWithS64Argument) {
   TF_EXPECT_OK(session.Run({read_back, c_handle.program_shape}, &outputs));
 
   xla::LiteralProto response;
-  EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
 
   auto expected = xla::LiteralUtil::CreateR0<int64>(15123899);
   EXPECT_TRUE(CompareLiteralToLiteralProto(expected, response));
 
   xla::ProgramShapeProto program_shape;
-  EXPECT_TRUE(program_shape.ParseFromString(outputs[1].vec<tstring>()(0)));
+  EXPECT_TRUE(ParseFromTString(outputs[1].vec<tstring>()(0), &program_shape));
   EXPECT_EQ(program_shape.parameters_size(), 2);
   EXPECT_TRUE(xla::ShapeUtil::HasPrimitiveType(
       xla::Shape(program_shape.result()), xla::S64));
@@ -1584,7 +1584,7 @@ TEST(RawApiTest, TestDeviceMemoryCompaction) {
   // we have on record.
   for (size_t i = 1, j = 0; i < handles.size(); i += 2, ++j) {
     xla::LiteralProto response;
-    EXPECT_TRUE(response.ParseFromString(outputs[j].scalar<tstring>()()));
+    EXPECT_TRUE(ParseFromTString(outputs[j].scalar<tstring>()(), &response));
     EXPECT_TRUE(CompareLiteralProtos(allocs[i].value(), response));
   }
 }
@@ -1672,7 +1672,7 @@ TEST(RawApiTest, TestDeviceMemorySwap) {
     EXPECT_EQ(outputs.size(), 1);
 
     xla::LiteralProto response;
-    EXPECT_TRUE(response.ParseFromString(outputs[0].scalar<tstring>()()));
+    EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &response));
     auto literal = xla::Literal::CreateFromProto(response).ValueOrDie();
     EXPECT_EQ(literal, zero_literal);
   }
@@ -1693,7 +1693,7 @@ TEST(RawApiTest, TestMetricsFetch) {
   ASSERT_EQ(outputs.size(), 1);
 
   xrt::MetricsReport report;
-  EXPECT_TRUE(report.ParseFromString(outputs[0].scalar<tstring>()()));
+  EXPECT_TRUE(ParseFromTString(outputs[0].scalar<tstring>()(), &report));
   for (auto& metric : report.metrics()) {
     EXPECT_EQ(metric.name().compare(0, 16, "/tensorflow/xrt/"), 0);
   }

tensorflow/core/kernels/summary_tensor_op.cc

@@ -48,8 +48,8 @@ class SummaryTensorOpV2 : public OpKernel {
       tensor.AsProtoTensorContent(v->mutable_tensor());
     }
 
-    v->mutable_metadata()->ParseFromString(
-        serialized_summary_metadata_tensor.scalar<tstring>()());
+    ParseFromTString(serialized_summary_metadata_tensor.scalar<tstring>()(),
+                     v->mutable_metadata());
 
     Tensor* summary_tensor = nullptr;
     OP_REQUIRES_OK(c, c->allocate_output(0, TensorShape({}), &summary_tensor));