clean unused code: piece.cc/h (#47103)

* clean unused code: piece.cc/h

* clean usage

paddle/fluid/inference/CMakeLists.txt

@@ -38,7 +38,7 @@ endif()
 get_property(fluid_modules GLOBAL PROPERTY FLUID_MODULES)
 get_property(phi_modules GLOBAL PROPERTY PHI_MODULES)
 get_property(phi_kernels GLOBAL PROPERTY PHI_KERNELS)
-set(utils_modules stringpiece pretty_log string_helper benchmark)
+set(utils_modules pretty_log string_helper benchmark)
 
 if(WITH_CUSTOM_DEVICE)
   set(fluid_modules ${fluid_modules} phi_capi)

paddle/fluid/platform/CMakeLists.txt

@@ -61,7 +61,7 @@ cc_library(monitor SRCS monitor.cc)
 cc_test(
   enforce_test
   SRCS enforce_test.cc
-  DEPS stringpiece enforce)
+  DEPS enforce)
 
 set(CPU_INFO_DEPS gflags glog enforce)
 if(WITH_XBYAK)
@@ -205,7 +205,6 @@ cc_library(
        place
        phi_place
        eigen3
-       stringpiece
        cpu_helper
        cpu_info
        framework_proto

paddle/fluid/platform/device/mlu/CMakeLists.txt

@@ -2,10 +2,7 @@ if(NOT WITH_MLU)
   return()
 endif()
 
-cc_test(
-  mlu_enforce_test
-  SRCS enforce_test.cc
-  DEPS stringpiece)
+cc_test(mlu_enforce_test SRCS enforce_test.cc)
 cc_library(
   mlu_info
   SRCS mlu_info.cc

paddle/fluid/platform/device/xpu/tests/CMakeLists.txt

-cc_test(
-  enforce_xpu_test
-  SRCS enforce_xpu_test.cc
-  DEPS stringpiece)
+cc_test(enforce_xpu_test SRCS enforce_xpu_test.cc)

paddle/fluid/string/piece.h

-//  Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <ostream>
-#include <string>
-
-#include "paddle/utils/string/piece.h"

paddle/utils/string/CMakeLists.txt

-cc_library(
-  stringpiece
-  SRCS piece.cc
-  DEPS flags)
 cc_library(
   pretty_log
   SRCS pretty_log.cc
@@ -10,10 +6,6 @@ cc_library(
   string_helper
   SRCS string_helper.cc
   DEPS flags)
-cc_test(
-  stringpiece_test
-  SRCS piece_test.cc
-  DEPS stringpiece gflags)
 cc_test(
   stringprintf_test
   SRCS printf_test.cc

paddle/utils/string/piece.cc

-//  Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/utils/string/piece.h"
-
-#include <string.h>
-
-#include <algorithm>
-#define CHAR_POINTER_CMP(a, b) \
-  do {                         \
-    if (!a && !b) return 0;    \
-    if (!a) return -1;         \
-    if (!b) return 1;          \
-  } while (0)
-
-namespace paddle {
-namespace string {
-
-Piece::Piece() : data_(NULL), size_(0) {}
-
-Piece::Piece(const char* d, size_t n) : data_(d), size_(n) {
-  if (d == NULL && n != 0)
-    throw std::invalid_argument("Piece requires len to be 0 for NULL data");
-}
-
-Piece::Piece(const char* s) : data_(s) { size_ = (s == NULL) ? 0 : strlen(s); }
-
-Piece::Piece(const std::string& s) : data_(s.data()), size_(s.size()) {}
-
-char Piece::operator[](size_t n) const {
-  if (n >= len()) throw std::invalid_argument("index out of Piece length");
-  return data_[n];
-}
-
-int Compare(Piece a, Piece b) {
-  CHAR_POINTER_CMP(a.data(), b.data());
-  const size_t min_len = (a.len() < b.len()) ? a.len() : b.len();
-  int r = memcmp(a.data(), b.data(), min_len);
-  if (r == 0) {
-    if (a.len() < b.len())
-      return -1;
-    else if (a.len() > b.len())
-      return 1;
-  }
-  return r;
-}
-
-bool operator==(Piece x, Piece y) {
-  return (!x.len() && !y.len()) ? true
-                                : ((x.len() == y.len()) &&
-                                   (x.data() == y.data() ||
-                                    memcmp(x.data(), y.data(), x.len()) == 0));
-}
-
-bool operator!=(Piece x, Piece y) { return !(x == y); }
-
-bool operator<(Piece x, Piece y) { return Compare(x, y) < 0; }
-bool operator>(Piece x, Piece y) { return Compare(x, y) > 0; }
-
-bool operator<=(Piece x, Piece y) { return Compare(x, y) <= 0; }
-bool operator>=(Piece x, Piece y) { return Compare(x, y) >= 0; }
-
-bool HasPrefix(Piece s, Piece x) {
-  return !x.len() ? true
-                  : ((s.len() >= x.len()) &&
-                     (memcmp(s.data(), x.data(), x.len()) == 0));
-}
-
-bool HasSuffix(Piece s, Piece x) {
-  return !x.len()
-             ? true
-             : ((s.len() >= x.len()) &&
-                (memcmp(s.data() + (s.len() - x.len()), x.data(), x.len()) ==
-                 0));
-}
-
-Piece SkipPrefix(Piece s, size_t n) {
-  if (n > s.len())
-    throw std::invalid_argument("Skip distance larger than Piece length");
-  return Piece(s.data() + n, s.len() - n);
-}
-
-Piece SkipSuffix(Piece s, size_t n) {
-  if (n > s.len())
-    throw std::invalid_argument("Skip distance larger than Piece length");
-  return Piece(s.data(), s.len() - n);
-}
-
-Piece TrimPrefix(Piece s, Piece x) {
-  return HasPrefix(s, x) ? SkipPrefix(s, x.len()) : s;
-}
-
-Piece TrimSuffix(Piece s, Piece x) {
-  return HasSuffix(s, x) ? SkipSuffix(s, x.len()) : s;
-}
-
-bool Contains(Piece s, Piece sub) {
-  return std::search(s.begin(), s.end(), sub.begin(), sub.end()) != s.end();
-}
-
-size_t Index(Piece s, Piece sub) {
-  auto e = std::search(s.begin(), s.end(), sub.begin(), sub.end());
-  return e != s.end() ? e - s.data() : Piece::npos;
-}
-
-size_t Find(Piece s, char c, size_t pos) {
-  if (pos >= s.len()) {
-    return Piece::npos;
-  }
-  const char* result =
-      reinterpret_cast<const char*>(memchr(s.data() + pos, c, s.len() - pos));
-  return result != nullptr ? result - s.data() : Piece::npos;
-}
-
-size_t RFind(Piece s, char c, size_t pos) {
-  if (s.len() == 0) return Piece::npos;
-  for (const char* p = s.data() + std::min(pos, s.len() - 1); p >= s.data();
-       p--) {
-    if (*p == c) {
-      return p - s.data();
-    }
-  }
-  return Piece::npos;
-}
-
-Piece SubStr(Piece s, size_t pos, size_t n) {
-  if (pos > s.len()) pos = s.len();
-  if (n > s.len() - pos) n = s.len() - pos;
-  return Piece(s.data() + pos, n);
-}
-
-std::ostream& operator<<(std::ostream& o, Piece piece) {
-  return o << piece.ToString();
-}
-
-}  // namespace string
-}  // namespace paddle

paddle/utils/string/piece.h

-//  Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <ostream>
-#include <string>
-
-namespace paddle {
-namespace string {
-
-// Piece points into a std::string object but doesn't own the
-// string.  It is for efficient access to strings.  Like Go's string
-// type.  Not that Piece doesn't mutate the underlying string,
-// so it is thread-safe given that the underlying string doesn't
-// change.  Because Piece contains a little data members, and
-// its syntax is simple as it doesn't own/manage the string, it is
-// cheap to construct Pieces and pass them around.
-class Piece {
- public:
-  static const size_t npos = static_cast<size_t>(-1);
-
-  // We provide non-explicit singleton constructors so users can
-  // pass in a "const char*" or a "string" wherever a "Piece"
-  // is expected.  These constructors ensure that if data_ is NULL,
-  // size_ is 0.
-  Piece();
-  Piece(const char* d, size_t n);
-  Piece(const char* d);         // NOLINT: accept C string into Piece.
-  Piece(const std::string& s);  // NOLINT: accept C++ string into Piece.
-
-  const char* data() const { return data_; }
-  size_t len() const { return size_; }
-
-  char operator[](size_t n) const;
-
-  // Piece doesn't own the string, so both iterator and const
-  // iterator are const char* indeed.
-  typedef const char* const_iterator;
-  typedef const char* iterator;
-  iterator begin() const { return data_; }
-  iterator end() const { return data_ + size_; }
-
-  // Return a string that contains the copy of the referenced data.
-  std::string ToString() const { return std::string(data_, size_); }
-
- private:
-  const char* data_;
-  size_t size_;
-
-  // Intentionally copyable
-};
-
-int Compare(Piece a, Piece b);
-
-bool operator==(Piece x, Piece y);
-bool operator!=(Piece x, Piece y);
-bool operator<(Piece x, Piece y);
-bool operator>(Piece x, Piece y);
-bool operator<=(Piece x, Piece y);
-bool operator>=(Piece x, Piece y);
-
-bool HasPrefix(Piece s, Piece prefix);
-bool HasSuffix(Piece s, Piece suffix);
-
-Piece SkipPrefix(Piece s, size_t n);
-Piece SkipSuffix(Piece s, size_t n);
-
-// Skip the prefix (or suffix) if it matches with the string.
-Piece TrimPrefix(Piece s, Piece prefix);
-Piece TrimSuffix(Piece s, Piece suffix);
-
-// Returns if s contains sub.  Any s except for empty s contains an
-// empty sub.
-bool Contains(Piece s, Piece sub);
-
-// Return the first occurrence of sub in s, or npos.  If both s and
-// sub is empty, it returns npos; otherwise, if only sub is empty, it
-// returns 0.
-size_t Index(Piece s, Piece sub);
-
-// Return the first occurrence of c in s[pos:end], or npos.
-size_t Find(Piece s, char c, size_t pos);
-
-// Search range is [0..pos] inclusive.  If pos == npos, search everything.
-size_t RFind(Piece s, char c, size_t pos);
-
-Piece SubStr(Piece s, size_t pos, size_t n);
-
-// allow Piece to be logged
-std::ostream& operator<<(std::ostream& o, Piece piece);
-
-}  // namespace string
-}  // namespace paddle

paddle/utils/string/piece_test.cc

-//  Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/utils/string/piece.h"
-
-#include "gtest/gtest.h"
-
-TEST(StringPiece, Construct) {
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ(NULL, s.data());
-    EXPECT_EQ(0U, s.len());
-  }
-  {
-    EXPECT_THROW(paddle::string::Piece s(NULL, 10000U), std::invalid_argument);
-  }
-  {
-    paddle::string::Piece s(NULL);
-    EXPECT_EQ(0U, s.len());
-  }
-  {
-    std::string a;
-    EXPECT_EQ(0U, a.size());
-    paddle::string::Piece s(a);
-    EXPECT_EQ(0U, s.len());
-  }
-}
-
-TEST(StringPiece, CopyAndAssign) {
-  paddle::string::Piece empty;
-  EXPECT_EQ(0U, empty.len());
-
-  paddle::string::Piece a("hello");
-  paddle::string::Piece b = a;
-  EXPECT_EQ(b.len(), strlen("hello"));
-  EXPECT_EQ(a, b);
-
-  std::string storage("hello");
-  paddle::string::Piece c(storage);
-  EXPECT_EQ(a, c);
-  EXPECT_NE(a.data(), c.data());
-}
-
-TEST(StringPiece, Compare) {
-  {
-    paddle::string::Piece a("hello");
-    paddle::string::Piece b("world");
-    EXPECT_TRUE(a != b);
-    EXPECT_FALSE(a == b);
-    EXPECT_TRUE(a < b);
-    EXPECT_TRUE(a <= b);
-    EXPECT_FALSE(a > b);
-    EXPECT_FALSE(a >= b);
-    EXPECT_LT(Compare(a, b), 0);
-    EXPECT_GT(Compare(b, a), 0);
-  }
-  {
-    paddle::string::Piece a, b;
-    EXPECT_TRUE(a == b);
-    EXPECT_FALSE(a != b);
-    EXPECT_FALSE(a < b);
-    EXPECT_FALSE(a > b);
-    EXPECT_TRUE(a <= b);
-    EXPECT_TRUE(a >= b);
-    EXPECT_EQ(0, Compare(a, b));
-    EXPECT_EQ(0, Compare(b, a));
-  }
-}
-
-TEST(StringPiece, ToString) {
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ(std::string(""), s.ToString());
-  }
-  {
-    paddle::string::Piece s(NULL);
-    EXPECT_EQ(std::string(""), s.ToString());
-  }
-  {
-    paddle::string::Piece s("hello");
-    EXPECT_EQ(std::string("hello"), s.ToString());
-  }
-}
-
-TEST(StringPiece, HasPrefixSuffix) {
-  using paddle::string::HasPrefix;
-  using paddle::string::HasSuffix;
-  {
-    paddle::string::Piece s;
-    EXPECT_FALSE(HasPrefix(s, "something"));
-    EXPECT_TRUE(HasPrefix(s, ""));
-    EXPECT_FALSE(HasSuffix(s, "something"));
-    EXPECT_TRUE(HasSuffix(s, ""));
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_TRUE(HasPrefix(s, ""));
-    EXPECT_TRUE(HasPrefix(s, "a"));
-    EXPECT_TRUE(HasPrefix(s, "ap"));
-    EXPECT_TRUE(HasPrefix(s, "app"));
-
-    EXPECT_TRUE(HasSuffix(s, ""));
-    EXPECT_TRUE(HasSuffix(s, "p"));
-    EXPECT_TRUE(HasSuffix(s, "pp"));
-    EXPECT_TRUE(HasSuffix(s, "app"));
-  }
-}
-
-TEST(StringPiece, SkipPrefixSuffix) {
-  using paddle::string::SkipPrefix;
-  using paddle::string::SkipSuffix;
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ("", SkipPrefix(s, 0));
-    EXPECT_THROW(SkipPrefix(s, 1), std::invalid_argument);
-
-    EXPECT_EQ("", SkipSuffix(s, 0));
-    EXPECT_THROW(SkipSuffix(s, 1), std::invalid_argument);
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_EQ("app", SkipPrefix(s, 0));
-    EXPECT_EQ("pp", SkipPrefix(s, 1));
-    EXPECT_EQ("p", SkipPrefix(s, 2));
-    EXPECT_EQ("", SkipPrefix(s, 3));
-    EXPECT_THROW(SkipPrefix(s, 4), std::invalid_argument);
-
-    EXPECT_EQ("app", SkipSuffix(s, 0));
-    EXPECT_EQ("ap", SkipSuffix(s, 1));
-    EXPECT_EQ("a", SkipSuffix(s, 2));
-    EXPECT_EQ("", SkipSuffix(s, 3));
-    EXPECT_THROW(SkipSuffix(s, 4), std::invalid_argument);
-  }
-}
-
-TEST(StringPiece, TrimPrefixSuffix) {
-  using paddle::string::TrimPrefix;
-  using paddle::string::TrimSuffix;
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ("", TrimPrefix(s, ""));
-    EXPECT_EQ("", TrimPrefix(s, "something"));
-
-    EXPECT_EQ("", TrimSuffix(s, ""));
-    EXPECT_EQ("", TrimSuffix(s, "something"));
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_EQ("app", TrimPrefix(s, ""));
-    EXPECT_EQ("pp", TrimPrefix(s, "a"));
-    EXPECT_EQ("p", TrimPrefix(s, "ap"));
-    EXPECT_EQ("", TrimPrefix(s, "app"));
-    EXPECT_EQ("app", TrimPrefix(s, "something"));
-
-    EXPECT_EQ("app", TrimSuffix(s, ""));
-    EXPECT_EQ("ap", TrimSuffix(s, "p"));
-    EXPECT_EQ("a", TrimSuffix(s, "pp"));
-    EXPECT_EQ("", TrimSuffix(s, "app"));
-    EXPECT_EQ("app", TrimSuffix(s, "something"));
-  }
-}
-
-TEST(StringPiece, Contains) {
-  using paddle::string::Contains;
-  {
-    paddle::string::Piece s;
-    EXPECT_FALSE(Contains(s, ""));
-    EXPECT_FALSE(Contains(s, "something"));
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_TRUE(Contains(s, ""));
-    EXPECT_TRUE(Contains(s, "a"));
-    EXPECT_TRUE(Contains(s, "p"));
-    EXPECT_TRUE(Contains(s, "ap"));
-    EXPECT_TRUE(Contains(s, "pp"));
-    EXPECT_TRUE(Contains(s, "app"));
-    EXPECT_FALSE(Contains(s, "something"));
-  }
-}
-
-TEST(StringPiece, Index) {
-  using paddle::string::Index;
-  auto npos = paddle::string::Piece::npos;
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ(npos, Index(s, ""));
-    EXPECT_EQ(npos, Index(s, "something"));
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_EQ(0U, Index(s, ""));
-    EXPECT_EQ(0U, Index(s, "a"));
-    EXPECT_EQ(1U, Index(s, "p"));
-    EXPECT_EQ(0U, Index(s, "ap"));
-    EXPECT_EQ(1U, Index(s, "pp"));
-    EXPECT_EQ(0U, Index(s, "app"));
-    EXPECT_EQ(npos, Index(s, "something"));
-  }
-}
-
-TEST(StringPiece, Find) {
-  using paddle::string::Find;
-  auto npos = paddle::string::Piece::npos;
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ(npos, Find(s, 'a', 0U));
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_EQ(0U, Find(s, 'a', 0U));
-    EXPECT_EQ(1U, Find(s, 'p', 0U));
-    EXPECT_EQ(1U, Find(s, 'p', 1U));
-    EXPECT_EQ(2U, Find(s, 'p', 2U));
-    EXPECT_EQ(npos, Find(s, 'z', 2U));
-  }
-}
-
-TEST(StringPiece, RFind) {
-  using paddle::string::RFind;
-  auto npos = paddle::string::Piece::npos;
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ(npos, RFind(s, 'a', 0U));
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_EQ(2U, RFind(s, 'p', 2U));
-    EXPECT_EQ(0U, RFind(s, 'a', 2U));
-    EXPECT_EQ(1U, RFind(s, 'p', 1U));
-    EXPECT_EQ(0U, RFind(s, 'a', 0));
-    EXPECT_EQ(npos, RFind(s, 'z', 2U));
-  }
-}
-
-TEST(StringPiece, SubStr) {
-  using paddle::string::SubStr;
-  {
-    paddle::string::Piece s;
-    EXPECT_EQ("", SubStr(s, 0, 0));
-    EXPECT_EQ("", SubStr(s, 0, 1));
-    EXPECT_EQ("", SubStr(s, 1, 0));
-  }
-  {
-    paddle::string::Piece s("app");
-    EXPECT_EQ("", SubStr(s, 0, 0));
-    EXPECT_EQ("", SubStr(s, 1, 0));
-    EXPECT_EQ("", SubStr(s, 2, 0));
-    EXPECT_EQ("", SubStr(s, 3, 0));
-
-    EXPECT_EQ("a", SubStr(s, 0, 1));
-    EXPECT_EQ("p", SubStr(s, 1, 1));
-    EXPECT_EQ("p", SubStr(s, 2, 1));
-    EXPECT_EQ("", SubStr(s, 3, 1));
-
-    EXPECT_EQ("ap", SubStr(s, 0, 2));
-    EXPECT_EQ("pp", SubStr(s, 1, 2));
-    EXPECT_EQ("p", SubStr(s, 2, 2));
-    EXPECT_EQ("", SubStr(s, 3, 2));
-
-    EXPECT_EQ("app", SubStr(s, 0, 3));
-    EXPECT_EQ("pp", SubStr(s, 1, 3));
-    EXPECT_EQ("p", SubStr(s, 2, 3));
-    EXPECT_EQ("", SubStr(s, 3, 3));
-  }
-}
-
-TEST(StringPiece, StreamOutput) {
-  using paddle::string::Piece;
-
-  std::stringstream o;
-  o << paddle::string::Piece();
-  EXPECT_EQ("", o.str());
-
-  o << paddle::string::Piece("hello");
-  EXPECT_EQ("hello", o.str());
-
-  o << paddle::string::Piece();
-  EXPECT_EQ("hello", o.str());
-}

tools/parallel_UT_rule.py

@@ -387,7 +387,6 @@ HIGH_PARALLEL_JOB_NEW = [
     'test_fleet_lamb_meta_optimizer',
     'test_op_version',
     'fused_broadcast_op_test',
-    'stringpiece_test',
     'test_tdm_child_op',
     'test_imperative_group',
     'test_analyzer_capi_exp',
@@ -1499,7 +1498,6 @@ CPU_PARALLEL_JOB = [
     'test_analyzer',
     'test_aligned_allocator',
     'stringprintf_test',
-    'stringpiece_test',
     'split_test',
     'selected_rows_functor_test',
     'scope_test',