diff --git a/paddle/fluid/inference/CMakeLists.txt b/paddle/fluid/inference/CMakeLists.txt index 7f2daa942b057df6a74113a1578eb1c51db5d7ef..0b20dbfde7f38bd169a71c06da7e5ee8597ac20a 100644 --- a/paddle/fluid/inference/CMakeLists.txt +++ b/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) diff --git a/paddle/fluid/platform/CMakeLists.txt b/paddle/fluid/platform/CMakeLists.txt index c910e4b4ea0fbf0e43caee3be8bf8ab23a6ce236..627ea8b9aa7ec9e6227b8b37ccc25516021525e8 100644 --- a/paddle/fluid/platform/CMakeLists.txt +++ b/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 diff --git a/paddle/fluid/platform/device/mlu/CMakeLists.txt b/paddle/fluid/platform/device/mlu/CMakeLists.txt index 1d4d87b9ec5326effc57d31f6dc3a832f6d8b023..c723eb149b8cf87eccdc8a3faebf64796cc2f51e 100644 --- a/paddle/fluid/platform/device/mlu/CMakeLists.txt +++ b/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 diff --git a/paddle/fluid/platform/device/xpu/tests/CMakeLists.txt b/paddle/fluid/platform/device/xpu/tests/CMakeLists.txt index e51896df6159af394742b8962490dcebcb70762f..7fd9278bfa7b4879530afb13f4d566446a2de714 100644 --- a/paddle/fluid/platform/device/xpu/tests/CMakeLists.txt +++ b/paddle/fluid/platform/device/xpu/tests/CMakeLists.txt @@ -1,4 +1 @@ -cc_test( - enforce_xpu_test - SRCS enforce_xpu_test.cc - DEPS stringpiece) +cc_test(enforce_xpu_test SRCS enforce_xpu_test.cc) diff --git a/paddle/fluid/string/piece.h b/paddle/fluid/string/piece.h deleted file mode 100644 index 09dee0a31cbc71ba946a05d55714ba1c302bf788..0000000000000000000000000000000000000000 --- a/paddle/fluid/string/piece.h +++ /dev/null @@ -1,20 +0,0 @@ -// 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 -#include - -#include "paddle/utils/string/piece.h" diff --git a/paddle/utils/string/CMakeLists.txt b/paddle/utils/string/CMakeLists.txt index 3e35da9d62d738bc0e8f2fc2d41715c4ec461b9e..89b95385eb133e4b5e9d05ac305e949969c67b9f 100644 --- a/paddle/utils/string/CMakeLists.txt +++ b/paddle/utils/string/CMakeLists.txt @@ -1,7 +1,3 @@ -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 diff --git a/paddle/utils/string/piece.cc b/paddle/utils/string/piece.cc deleted file mode 100644 index ae62f53378f0b259083efa64d70f6eb7f2c910f0..0000000000000000000000000000000000000000 --- a/paddle/utils/string/piece.cc +++ /dev/null @@ -1,148 +0,0 @@ -// 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 - -#include -#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(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 diff --git a/paddle/utils/string/piece.h b/paddle/utils/string/piece.h deleted file mode 100644 index 8dda484eaac4d62b758e57ac5e81bfe68a5c60d4..0000000000000000000000000000000000000000 --- a/paddle/utils/string/piece.h +++ /dev/null @@ -1,105 +0,0 @@ -// 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 -#include - -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(-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 diff --git a/paddle/utils/string/piece_test.cc b/paddle/utils/string/piece_test.cc deleted file mode 100644 index 27b189e251f8ad368895419ff9cf854a6d929893..0000000000000000000000000000000000000000 --- a/paddle/utils/string/piece_test.cc +++ /dev/null @@ -1,291 +0,0 @@ -// 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()); -} diff --git a/tools/parallel_UT_rule.py b/tools/parallel_UT_rule.py index 1b5e7c59a42e74bdfd58ec3c846adf84b92eaf5e..ea36b7785367e6c001e7b5117fd0924b538c1696 100755 --- a/tools/parallel_UT_rule.py +++ b/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',