[MLGO] Use binary protobufs for improved training performance.

[mtrofin]

Summary

It turns out that during training, the time required to parse the
textual protobuf of a training log is about the same as the time it
takes to compile the module generating that log. Using binary protobufs
instead elides that cost almost completely.

[phosek]

llvm/CMakeLists.txt

796–804

Can we also provide a way to pass this as a CMake variable? In our case calling pip may not work.

[mtrofin]

• tests
• added option to specific proto header location

[mtrofin]

llvm/CMakeLists.txt

796–804

Ya, let's use TF_PROTO_HEADERS?

[phosek]

LGTM

llvm/CMakeLists.txt

 # In this case, the latest C API library is available for download from
 # https://www.tensorflow.org/install/lang_c.
 # We will expose the conditional compilation variable,
 # LLVM_HAVE_TF_API, through llvm-config.h, so that a user of the LLVM library may
 # also leverage the dependency.
 set(TENSORFLOW_C_LIB_PATH "" CACHE PATH "Path to TensorFlow C library install")
 if (TENSORFLOW_C_LIB_PATH)
   find_library(tensorflow_c_api tensorflow PATHS ${TENSORFLOW_C_LIB_PATH}/lib NO_DEFAULT_PATH REQUIRED)
+  # Currently, the protobuf headers are distributed with the pip package that corresponds to the version
+  # of the C API library.
+  find_library(tensorflow_fx tensorflow_framework PATHS ${TENSORFLOW_C_LIB_PATH}/lib NO_DEFAULT_PATH REQUIRED)
   set(LLVM_HAVE_TF_API "ON" CACHE BOOL "Full Tensorflow API available")
   include_directories(${TENSORFLOW_C_LIB_PATH}/include)
+  if (NOT TF_PROTO_HEADERS)
+    message(STATUS "TF_PROTO_HEADERS not defined. Looking for tensorflow pip package.")
+    execute_process(COMMAND 
+      ${Python3_EXECUTABLE} "-m" "pip" "show" "tensorflow" 
+      OUTPUT_VARIABLE TF_PIP_OUT)
+    if ("${TF_PIP_OUT}" STREQUAL "")
+      message(FATAL ERROR "Tensorflow pip package is also required for 'development' mode (protobuf headers)")
+    endif()
+    string(REGEX MATCH "Location: ([^\n]*\n)" TF_PIP_LOC "${TF_PIP_OUT}")
+    string(REPLACE "Location: " "" TF_PIP ${TF_PIP_LOC})
+    set(TF_PROTO_HEADERS ${TF_PIP}/include)
+  endif()
+  include_directories(${TF_PROTO_HEADERS})
+  add_definitions("-DGOOGLE_PROTOBUF_NO_RTTI")
+  add_definitions("-D_GLIBCXX_USE_CXX11_ABI=0")
 endif()
 
 # For up-to-date instructions for installing the Tensorflow dependency, refer to
 # the bot setup script: https://github.com/google/ml-compiler-opt/blob/master/buildbot/buildbot_init.sh
 # Specifically, assuming python3 is installed:
 # python3 -m pip install --upgrade pip && python3 -m pip install --user tf_nightly==2.3.0.dev20200528
 # Then set TENSORFLOW_AOT_PATH to the package install - usually it's ~/.local/lib/python3.7/site-packages/tensorflow
 #

llvm/lib/Analysis/CMakeLists.txt

tf_find_and_compile(
       serve
       action
       InlinerSizeModel
       llvm::InlinerSizeModel
     )
   endif()
 
   if (DEFINED LLVM_HAVE_TF_API)
-    list(APPEND MLLinkDeps ${tensorflow_c_api})
+    list(APPEND MLLinkDeps ${tensorflow_c_api} ${tensorflow_fx})
   endif()
 endif()
 
 add_llvm_component_library(LLVMAnalysis
   AliasAnalysis.cpp
   AliasAnalysisEvaluator.cpp
   AliasAnalysisSummary.cpp
   AliasSetTracker.cpp

llvm/lib/Analysis/TFUtils.cpp

 // This file implements utilities for interfacing with tensorflow C APIs.
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/Config/config.h"
 #if defined(LLVM_HAVE_TF_API)
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/Utils/TFUtils.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include "google/protobuf/text_format.h"
 #include "tensorflow/c/c_api.h"
 #include "tensorflow/c/c_api_experimental.h"
-
+#include "tensorflow/core/example/example.pb.h"
 #include <cassert>
 #include <numeric>
 
 using namespace llvm;
 
+static cl::opt<bool>
+    ProtobufTextMode("tfutils-text-log", cl::init(false), cl::Hidden,
+                     cl::desc("Output textual (human-readable) protobuf."));
+
 namespace {
 
 using TFGraphPtr = std::unique_ptr<TF_Graph, decltype(&TF_DeleteGraph)>;
 using TFSessionOptionsPtr =
     std::unique_ptr<TF_SessionOptions, decltype(&TF_DeleteSessionOptions)>;
 using TFStatusPtr = std::unique_ptr<TF_Status, decltype(&TF_DeleteStatus)>;
 
 struct TFInitializer {

 TFStatusPtr createTFStatus() {
   return TFStatusPtr(TF_NewStatus(), &TF_DeleteStatus);
 }
 
 TFSessionOptionsPtr createTFSessionOptions() {
   return TFSessionOptionsPtr(TF_NewSessionOptions(), &TF_DeleteSessionOptions);
 }
 
-/// Write the values of one tensor as a list.
-template <typename T>
-void writeTensorValues(raw_ostream &OutFile, const char *TensorData,
-                       size_t ElemCount) {
-  OutFile << "[";
-  const T *TypedData = reinterpret_cast<const T *>(TensorData);
-  ListSeparator LS;
-  for (size_t I = 0; I < ElemCount; ++I)
-    OutFile << LS << TypedData[I];
-  OutFile << "]";
-}
-
 /// Write a list of tensors as a sequence of TensorFlow FeatureList protobufs.
 /// The tensors are assumed to be stored contiguously, in row-major format,
 /// in the TensorData buffer. Each tensor has the shape given by Spec. The
 /// feature name in the output is either the provided LoggingName, if
 /// specified, otherwise it's the name of the tensor (as given by Spec).
-void writeRawTensorsAsFeatureLists(raw_ostream &OutFile,
+void writeRawTensorsAsFeatureLists(tensorflow::FeatureLists *FE,
                                    const LoggedFeatureSpec &LoggedSpec,
                                    const char *TensorData, size_t TensorCount,
                                    bool FinalReward = false) {
-  const char *FieldName = "<invalid>";
-  std::function<void(const char *)> ValueWriter;
   const auto &Spec = LoggedSpec.Spec;
   // The 'Feature' protobuf only has 3 possible fields: float_list,
   // int64_list, or bytes_list, so we capture int32 values as int64. We don't
   // support any other types.
+  tensorflow::FeatureList &FL = (*FE->mutable_feature_list())[(
+      LoggedSpec.LoggingName ? *LoggedSpec.LoggingName : Spec.name())];
+
+  const char *CurrentTensor = TensorData;
+  const size_t TensorByteSize =
+      Spec.getElementCount() * Spec.getElementByteSize();
+  const size_t ElemCount = Spec.getElementCount();
+  for (size_t E = 0; E < TensorCount; ++E) {
+    const bool ShouldWrite = E + 1 == TensorCount || !FinalReward;
+
     if (Spec.isElementType<int64_t>()) {
-    FieldName = "int64_list";
-    ValueWriter = [&](const char *Data) {
-      writeTensorValues<int64_t>(OutFile, Data, Spec.getElementCount());
-    };
+      auto *MF = FL.add_feature()->mutable_int64_list()->mutable_value();
+      MF->Resize(ElemCount, 0);
+      if (ShouldWrite)
+        memcpy(MF->mutable_data(), CurrentTensor, TensorByteSize);
     } else if (Spec.isElementType<int32_t>()) {
-    FieldName = "int64_list";
-    ValueWriter = [&](const char *Data) {
-      writeTensorValues<int32_t>(OutFile, Data, Spec.getElementCount());
-    };
-
+      auto *MF = FL.add_feature()->mutable_int64_list()->mutable_value();
+      MF->Resize(ElemCount, 0);
+      if (ShouldWrite) {
+        const int32_t *TD = reinterpret_cast<const int32_t *>(CurrentTensor);
+        for (size_t I = 0; I < ElemCount; ++I)
+          (*MF)[I] = TD[I];
+      }
     } else if (Spec.isElementType<float>()) {
-    FieldName = "float_list";
-    ValueWriter = [&](const char *Data) {
-      writeTensorValues<float>(OutFile, Data, Spec.getElementCount());
-    };
-
+      auto *MF = FL.add_feature()->mutable_float_list()->mutable_value();
+      MF->Resize(ElemCount, 0.0);
+      if (ShouldWrite)
+        memcpy(MF->mutable_data(), CurrentTensor, TensorByteSize);
     } else {
       llvm_unreachable("Unsupported tensor type.");
     }
-
-  OutFile << "  feature_list: {\n";
-  OutFile << "    key: "
-          << "\""
-          << (LoggedSpec.LoggingName ? *LoggedSpec.LoggingName : Spec.name())
-          << "\" ";
-  OutFile << "value: {\n";
-  size_t TensorByteSize = Spec.getElementCount() * Spec.getElementByteSize();
-
-  auto WriteFeatureProto = [&](const char *P) {
-    OutFile << "      feature: { " << FieldName << ": { value: ";
-    ValueWriter(P);
-    OutFile << " } }\n";
-  };
-
-  const char *CurrentTensor = TensorData;
-  static int64_t Zero = 0;
-  // Write all but the last value. If this is the final reward, don't increment
-  // the CurrentTensor, and just write 0.
-  for (size_t I = 0; I < TensorCount - 1; ++I) {
-    if (FinalReward)
-      WriteFeatureProto(reinterpret_cast<const char *>(&Zero));
-    else {
-      WriteFeatureProto(CurrentTensor);
+    if (ShouldWrite)
       CurrentTensor += TensorByteSize;
-    }
-  }
-
-  WriteFeatureProto(CurrentTensor);
-
-  OutFile << "    }\n";
-  OutFile << "  }\n";
-}
 } // namespace
 
 namespace llvm {
 class EvaluationResultImpl {
 public:
   EvaluationResultImpl(size_t OutputSize)
       : OutputSize(OutputSize), Output(OutputSize){};
 

 TFUTILS_SUPPORTED_TYPES(TFUTILS_GETDATATYPE_IMPL)
 
 #undef TFUTILS_GETDATATYPE_IMPL
 
 TFModelEvaluator::EvaluationResult::~EvaluationResult() {}
 TFModelEvaluator::~TFModelEvaluator() {}
 
 void Logger::print(raw_ostream &OS) {
+  tensorflow::SequenceExample SE;
+
   if (RawLogData.empty())
     return;
   if (RawLogData[0].empty())
     return;
   size_t Tensor0Size = FeatureSpecs[0].Spec.getElementCount() *
                        FeatureSpecs[0].Spec.getElementByteSize();
   size_t NumberOfRecords = RawLogData[0].size() / Tensor0Size;
   if (NumberOfRecords == 0)
     return;
   size_t RewardSize =
       RewardSpec.getElementCount() * RewardSpec.getElementByteSize();
   size_t NumberOfRewards = RawLogData.back().size() / RewardSize;
 
-  OS << "feature_lists: {\n";
+  tensorflow::FeatureLists *FE = SE.mutable_feature_lists();
   for (size_t I = 0; I < FeatureSpecs.size(); ++I)
-    writeRawTensorsAsFeatureLists(OS, FeatureSpecs[I], RawLogData[I].data(),
+    writeRawTensorsAsFeatureLists(FE, FeatureSpecs[I], RawLogData[I].data(),
                                   NumberOfRecords);
 
   if (IncludeReward)
-    writeRawTensorsAsFeatureLists(OS, {RewardSpec, None},
+    writeRawTensorsAsFeatureLists(FE, {RewardSpec, None},
                                   RawLogData.back().data(), NumberOfRecords,
                                   NumberOfRewards == 1);
-
-  OS << "}\n";
+  std::string OutStr;
+  if (ProtobufTextMode) {
+    google::protobuf::TextFormat::PrintToString(SE, &OutStr);
+  } else {
+    OutStr = SE.SerializeAsString();
+  }
+  OS << OutStr;
 }
 #endif // defined(LLVM_HAVE_TF_API)

llvm/test/Transforms/Inline/ML/bounds-checks-rewards.ll

 ; Test behavior when inlining policy grows size out of control.
 ; In all cases, the end result is the same: mandatory inlinings must happen.
 ; Also in all cases, we don't record the mandatory inlining (there's nothing to
 ; learn from it).
 ; However, when we discover we 'trip' over the artificially-low size increase 
 ; factor, we penalize the 'bad' decision.
 ; REQUIRES: have_tf_api
 ;
 ; Generate mock model
-; RUN: rm -rf %t && mkdir %t
+; RUN: rm -rf %t
 ; RUN: %python %S/../../../../lib/Analysis/models/generate_mock_model.py %S/../../../../lib/Analysis/models/inlining/config.py %t
 ;
 ; When the bounds are very wide ("no bounds"), all inlinings happen.
-; RUN: opt -passes=scc-oz-module-inliner -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-model-under-training=%t -training-log=- -enable-ml-inliner=development -ml-advisor-size-increase-threshold=10.0 -S < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=NOBOUNDS
+; RUN: opt -passes=scc-oz-module-inliner -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-model-under-training=%t -training-log=- -tfutils-text-log -enable-ml-inliner=development -ml-advisor-size-increase-threshold=10.0 -S < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=NOBOUNDS
 ;
 ; When the bounds are very restrictive, the first inlining happens but it's
 ; considered as "bad" (since it trips over the bounds) and its reward is a
 ; penalty. However, the mandatory inlining, which is considered next, happens.
 ; No other inlinings happend.
-; RUN: opt -passes=scc-oz-module-inliner -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-model-under-training=%t -training-log=- -enable-ml-inliner=development -ml-advisor-size-increase-threshold=1.0 -S < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=BOUNDS
+; RUN: opt -passes=scc-oz-module-inliner -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-model-under-training=%t -training-log=- -tfutils-text-log -enable-ml-inliner=development -ml-advisor-size-increase-threshold=1.0 -S < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=BOUNDS
 ;
 ; With more restrictive bounds, the first inlining happens and is OK. The
 ; mandatory inlining happens next, and it trips over the bounds, which then
 ; forces no further inlinings.
-; RUN: opt -passes=scc-oz-module-inliner -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-model-under-training=%t -training-log=- -enable-ml-inliner=development -ml-advisor-size-increase-threshold=1.1 -S < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=RELAXED-BOUNDS
-
+; RUN: opt -passes=scc-oz-module-inliner -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-model-under-training=%t -training-log=- -tfutils-text-log -enable-ml-inliner=development -ml-advisor-size-increase-threshold=1.1 -S < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=RELAXED-BOUNDS
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-grtev4-linux-gnu"
-
 declare i64 @f1()
-
 define i64 @may_not_be_inlined() {
   %r = call i64 @f1()
   %r2 = add i64 13, %r
   ret i64 %r2
 }
-
 define i64 @must_be_inlined() #0 {
   %r = call i64 @may_not_be_inlined()
   %r2 = add i64 13, %r
   ret i64 %r2
 }
-
 define i64 @top() {
   %r = call i64 @must_be_inlined()
   %r2 = call i64 @may_not_be_inlined()
   %r3 = call i64 @may_not_be_inlined()
   %r4 = add i64 %r, %r2
   %r5 = add i64 %r3, %r4
   ret i64 %r5
 }
-
 attributes #0 = { alwaysinline }
-; CHECK: key: "delta_size" value: {
-; NOBOUNDS-NEXT: feature: { int64_list: { value: [6] } }
-; RELAXED-BOUNDS-NEXT: feature: { int64_list: { value: [6] } }
-; NOBOUNDS-NEXT: feature: { int64_list: { value: [-11] } }
-; NOBOUNDS-NEXT: feature: { int64_list: { value: [4] } }
-; BOUNDS-NEXT: feature: { int64_list: { value: [2147483647] } }
-; CHECK-NEXT: }
+; CHECK:       key: "delta_size"
+; CHECK-NEXT:     value {
+; CHECK-NEXT:       feature {
+; CHECK-NEXT:         int64_list {
+; NOBOUNDS-NEXT:        value: 6
+; RELAXED-BOUNDS-NEXT:  value: 6
+; NOBOUNDS-NEXT:      }
+; NOBOUNDS-NEXT:    }
+; NOBOUNDS-NEXT:    feature {
+; NOBOUNDS-NEXT:      int64_list {
+; NOBOUNDS-NEXT:        value: -11
+; NOBOUNDS-NEXT:      }
+; NOBOUNDS-NEXT:    }
+; NOBOUNDS-NEXT:    feature {
+; NOBOUNDS-NEXT:      int64_list {
+; NOBOUNDS-NEXT:        value: 4
+; BOUNDS-NEXT:          value: 2147483647
+; CHECK-NEXT:         }
 ; CHECK-LABEL: @top
 ; must_be_inlined must always be inlined, so we won't find a call to it in @top()
 ; CHECK-NOT: call i64 @must_be_inlined
 ; @some-function isn't mandatory, and when we set the increase threshold too low,
 ; it won't be inlined.
 ; NOBOUNDS-NOT: @may_not_be_inlined
 ; RELAXED-BOUNDS: call i64 @may_not_be_inlined
 ; BOUNDS: call i64 @may_not_be_inlined

llvm/test/Transforms/Inline/ML/development-training-log.ll

 ; Test that we can produce a log if we have or do not have a model, in development mode.
 ; REQUIRES: have_tf_api
 ; Generate mock model
-; RUN: rm -rf %t && mkdir %t
+; RUN: rm -rf %t
 ; RUN: %python %S/../../../../lib/Analysis/models/generate_mock_model.py %S/../../../../lib/Analysis/models/inlining/config.py %t
 ;
-; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -ml-inliner-model-under-training=%t -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -S < %s | FileCheck %s 
-; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -ml-inliner-model-under-training=%t -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-output-spec-override=%S/Inputs/test_output_spec.json -S < %s | FileCheck %s --check-prefixes=EXTRA-OUTPUTS,CHECK
-; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -S < %s | FileCheck %s
-; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -ml-inliner-model-under-training=%t -S < %s | FileCheck %s --check-prefix=NOREWARD
-; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -S < %s | FileCheck %s --check-prefix=NOREWARD
-
+; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -tfutils-text-log -ml-inliner-model-under-training=%t -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -S < %s | FileCheck %s 
+; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -tfutils-text-log -ml-inliner-model-under-training=%t -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -ml-inliner-output-spec-override=%S/Inputs/test_output_spec.json -S < %s | FileCheck %s --check-prefixes=EXTRA-OUTPUTS,CHECK
+; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -tfutils-text-log -ml-inliner-ir2native-model=%S/../../../../unittests/Analysis/Inputs/ir2native_x86_64_model -S < %s | FileCheck %s
+; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -tfutils-text-log -ml-inliner-model-under-training=%t -S < %s | FileCheck %s --check-prefix=NOREWARD
+; RUN: opt -enable-ml-inliner=development -passes=scc-oz-module-inliner -training-log=- -tfutils-text-log -S < %s | FileCheck %s --check-prefix=NOREWARD
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
-
 declare i32 @f1(i32)
 declare i32 @f2(i32)
-
 define dso_local i32 @branches(i32) {
   %cond = icmp slt i32 %0, 3
   br i1 %cond, label %then, label %else
-
 then:
   %ret.1 = call i32 @f1(i32 %0)
   br label %last.block
-
 else:
   %ret.2 = call i32 @f2(i32 %0)
   br label %last.block
-
 last.block:
   %ret = phi i32 [%ret.1, %then], [%ret.2, %else]
   ret i32 %ret
 }
-
 define dso_local i32 @top() {
   %1 = call i32 @branches(i32 2)
   ret i32 %1
 }
-
-
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
-
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{!"clang version 7.0.0-6 (tags/RELEASE_700/final)"}
-
 ; Check we produce a protobuf that has inlining decisions and rewards.
-; CHECK-NOT: fake_extra_output
-; EXTRA-OUTPUTS:          key: "fake_extra_output" value: {
-; EXTRA-OUTPUTS-NEXT:       feature: { int64_list: { value: [{{[0-9]+}}] } }
-; CHECK:          key: "inlining_decision" value: {
-; CHECK-NEXT:       feature: { int64_list: { value: [1] } }
-; CHECK:          key: "delta_size" value: {
-; CHECK-NEXT:       feature: { int64_list: { value: [0] } }
-; CHECK-NEXT:     }
-; CHECK-NEXT:   }
-; NOREWARD-NOT: key: "delta_size" value: {
+; CHECK:                  key: "delta_size"
+; CHECK-NEXT:               value {
+; CHECK-NEXT:                 feature {
+; CHECK-NEXT:                   int64_list {
+; CHECK-NEXT:                     value: 0
+; CHECK-NEXT:                   }
+; CHECK-NEXT:                 }
+; CHECK-NOT: fake_extra_output
+; EXTRA-OUTPUTS:          key: "fake_extra_output"
+; EXTRA-OUTPUTS-NEXT:       value {
+; EXTRA-OUTPUTS-NEXT:         feature {
+; EXTRA-OUTPUTS-NEXT:           int64_list {
+; EXTRA-OUTPUTS-NEXT:             value: {{[0-9]+}}
+; CHECK:                  key: "inlining_decision"
+; CHECK-NEXT:               value {
+; CHECK-NEXT:                 feature {
+; CHECK-NEXT:                   int64_list {
+; CHECK-NEXT:                     value: 1
+; NOREWARD-NOT: key: "delta_size"

llvm/unittests/Analysis/TFUtilsTest.cpp

 //===- TFUtilsTest.cpp - test for TFUtils ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/Utils/TFUtils.h"
+#include "tensorflow/core/example/example.pb.h"
+#include "tensorflow/core/example/feature.pb.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
TEST(TFUtilsTest, TensorSpecSizesAndTypes) {
   EXPECT_EQ(Spec1D.getElementCount(), 1U);
   EXPECT_EQ(Spec2D.getElementCount(), 1U);
   EXPECT_EQ(Spec1DLarge.getElementCount(), 10U);
   EXPECT_EQ(Spec3DLarge.getElementCount(), 80U);
   EXPECT_EQ(Spec3DLarge.getElementByteSize(), sizeof(float));
   EXPECT_EQ(Spec1D.getElementByteSize(), sizeof(int16_t));
 }
 
+#define PROTO_CHECKER(FNAME, TYPE, INDEX, EXP)                                 \
+  do {                                                                         \
+    const auto &V = Expected.feature_lists()                                   \
+                        .feature_list()                                        \
+                        .at(FNAME)                                             \
+                        .feature(INDEX)                                        \
+                        .TYPE()                                                \
+                        .value();                                              \
+    for (auto I = 0; I < V.size(); ++I)                                        \
+      EXPECT_EQ(V.at(I), EXP[I]);                                              \
+  } while (false)
+
 TEST(TFUtilsTest, Logger) {
   std::vector<LoggedFeatureSpec> Features;
   Features.push_back(
       {TensorSpec::createSpec<float>("the_float", {2, 3}), None});
   Features.push_back({TensorSpec::createSpec<int64_t>("the_int", {2}),
                       std::string("alternate_name")});
 
   auto Rewards = TensorSpec::createSpec<float>("reward", {1});
   Logger L(Features, Rewards, true);
-  float F00[]{0.0, 0.1, 0.2, 0.3, 0.4, 0.5};
-  int64_t F01[]{2, 3};
+  const float F00[]{0.0, 0.1, 0.2, 0.3, 0.4, 0.5};
+  const int64_t F01[]{2, 3};
 
   L.logTensorValue(0, F00, 6);
   L.logTensorValue(1, F01, 2);
   L.logReward<float>(3.4);
-  float F10[]{0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
-  int64_t F11[]{-2, -3};
+  const float F10[]{0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
+  const int64_t F11[]{-2, -3};
   L.logTensorValue(0, F10, 6);
   L.logTensorValue(1, F11, 2);
   L.logReward<float>(-3.0);
-  const auto *Expected = R"(feature_lists: {
-  feature_list: {
-    key: "the_float" value: {
-      feature: { float_list: { value: [0.000000e+00, 1.000000e-01, 2.000000e-01, 3.000000e-01, 4.000000e-01, 5.000000e-01] } }
-      feature: { float_list: { value: [0.000000e+00, 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00] } }
-    }
-  }
-  feature_list: {
-    key: "alternate_name" value: {
-      feature: { int64_list: { value: [2, 3] } }
-      feature: { int64_list: { value: [-2, -3] } }
-    }
-  }
-  feature_list: {
-    key: "reward" value: {
-      feature: { float_list: { value: [3.400000e+00] } }
-      feature: { float_list: { value: [-3.000000e+00] } }
-    }
-  }
-}
-)";
   std::string Result;
   raw_string_ostream OS(Result);
   L.print(OS);
-  EXPECT_EQ(Result, Expected);
+
+  tensorflow::SequenceExample Expected;
+  EXPECT_TRUE(Expected.ParseFromString(Result));
+  PROTO_CHECKER("the_float", float_list, 0, F00);
+  PROTO_CHECKER("the_float", float_list, 1, F10);
+  PROTO_CHECKER("alternate_name", int64_list, 0, F01);
+  PROTO_CHECKER("alternate_name", int64_list, 1, F11);
+  float R0[]{3.4};
+  float R1[]{-3.0};
+  PROTO_CHECKER("reward", float_list, 0, R0);
+  PROTO_CHECKER("reward", float_list, 1, R1);
 }
 
 TEST(TFUtilsTest, LoggerNoReward) {
   std::vector<LoggedFeatureSpec> Features;
   Features.push_back(
       {TensorSpec::createSpec<float>("the_float", {2, 3}), None});
   Features.push_back({TensorSpec::createSpec<int64_t>("the_int", {2}),
                       std::string("alternate_name")});
 
   auto Rewards = TensorSpec::createSpec<float>("reward", {1});
   Logger L(Features, Rewards, false);
-  float F00[]{0.0, 0.1, 0.2, 0.3, 0.4, 0.5};
-  int64_t F01[]{2, 3};
+  const float F00[]{0.0, 0.1, 0.2, 0.3, 0.4, 0.5};
+  const int64_t F01[]{2, 3};
 
   L.logTensorValue(0, F00, 6);
   L.logTensorValue(1, F01, 2);
-  float F10[]{0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
-  int64_t F11[]{-2, -3};
+  const float F10[]{0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
+  const int64_t F11[]{-2, -3};
   L.logTensorValue(0, F10, 6);
   L.logTensorValue(1, F11, 2);
-  const auto *Expected = R"(feature_lists: {
-  feature_list: {
-    key: "the_float" value: {
-      feature: { float_list: { value: [0.000000e+00, 1.000000e-01, 2.000000e-01, 3.000000e-01, 4.000000e-01, 5.000000e-01] } }
-      feature: { float_list: { value: [0.000000e+00, 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00] } }
-    }
-  }
-  feature_list: {
-    key: "alternate_name" value: {
-      feature: { int64_list: { value: [2, 3] } }
-      feature: { int64_list: { value: [-2, -3] } }
-    }
-  }
-}
-)";
+
   std::string Result;
   raw_string_ostream OS(Result);
   L.print(OS);
-  EXPECT_EQ(Result, Expected);
+  tensorflow::SequenceExample Expected;
+  EXPECT_TRUE(Expected.ParseFromString(Result));
+  PROTO_CHECKER("the_float", float_list, 0, F00);
+  PROTO_CHECKER("the_float", float_list, 1, F10);
+  PROTO_CHECKER("alternate_name", int64_list, 0, F01);
+  PROTO_CHECKER("alternate_name", int64_list, 1, F11);
 }
 
 TEST(TFUtilsTest, LoggerFinalReward) {
   std::vector<LoggedFeatureSpec> Features;
   Features.push_back({TensorSpec::createSpec<float>("the_float", {1}), None});
   Features.push_back({TensorSpec::createSpec<int64_t>("the_int", {1}), None});
 
   auto Rewards = TensorSpec::createSpec<float>("reward", {1});
   Logger L(Features, Rewards, true);
   for (size_t I = 0; I < 3; ++I) {
     float F = static_cast<float>(I);
     L.logTensorValue(0, &F);
     L.logTensorValue(1, &I);
   }
   L.logFinalReward<float>(3.14);
-  const auto *Expected = R"(feature_lists: {
-  feature_list: {
-    key: "the_float" value: {
-      feature: { float_list: { value: [0.000000e+00] } }
-      feature: { float_list: { value: [1.000000e+00] } }
-      feature: { float_list: { value: [2.000000e+00] } }
-    }
-  }
-  feature_list: {
-    key: "the_int" value: {
-      feature: { int64_list: { value: [0] } }
-      feature: { int64_list: { value: [1] } }
-      feature: { int64_list: { value: [2] } }
-    }
-  }
-  feature_list: {
-    key: "reward" value: {
-      feature: { float_list: { value: [0.000000e+00] } }
-      feature: { float_list: { value: [0.000000e+00] } }
-      feature: { float_list: { value: [3.140000e+00] } }
-    }
-  }
-}
-)";
   std::string Result;
   raw_string_ostream OS(Result);
   L.print(OS);
-  EXPECT_EQ(Result, Expected);
+  const float Zero[]{0.0};
+  const float R[]{3.14};
+  tensorflow::SequenceExample Expected;
+  EXPECT_TRUE(Expected.ParseFromString(Result));
+  PROTO_CHECKER("reward", float_list, 0, Zero);
+  PROTO_CHECKER("reward", float_list, 1, Zero);
+  PROTO_CHECKER("reward", float_list, 2, R);
 }