Merge branch 'tensorflow:master' into bump-ubuntu-to-22.04

Author: mikolajskalka

.bazelrc

@@ -106,3 +106,8 @@ build --copt=-Wno-macro-redefined # absl vs tsl logging clash
 build --copt=-Wno-sign-compare # int as loop variable
 build --copt=-Wno-deprecated-declarations
 build --copt=-Wno-unused-but-set-variable # due to `ifdefs` in ml_dtypes
+
+# Revert to the legacy WORKSPACE dependency resolution system
+# and disable Bzlmod.
+common --enable_bzlmod=false
+common --noincompatible_enable_cc_toolchain_resolution

WORKSPACE

@@ -38,7 +38,7 @@ tf_serving_workspace()
 
 # Check bazel version requirement, which is stricter than TensorFlow's.
 load("@bazel_skylib//lib:versions.bzl", "versions")
-versions.check("6.5.0")
+versions.check("7.4.1")
 
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 

tensorflow_serving/apis/internal/BUILD

@@ -2,12 +2,7 @@
 
 load("//tensorflow_serving:serving.bzl", "serving_proto_library")
 
-package(
-    default_visibility = [
-        "//tensorflow_serving:internal",
-    ],
-    features = ["-layering_check"],
-)
+package(features = ["-layering_check"])
 
 licenses(["notice"])
 

tensorflow_serving/core/aspired_versions_manager_benchmark.cc

@@ -125,7 +125,7 @@ void BenchmarkState::StartServing(const int64_t loader_version) {
       [loader_version](std::unique_ptr<int64_t>* const servable) {
         servable->reset(new int64_t);
         **servable = loader_version;
-        return OkStatus();
+        return absl::OkStatus();
       },
       SimpleLoader<int64_t>::EstimateNoResources()));
   std::vector<ServableData<std::unique_ptr<Loader>>> versions;
@@ -147,7 +147,7 @@ void BenchmarkState::StartServing(const int64_t loader_version) {
 
 int64_t BenchmarkState::GetLatestVersion(const bool do_work) {
   ServableHandle<int64_t> handle;
-  const Status status = manager_->GetServableHandle(
+  const absl::Status status = manager_->GetServableHandle(
       ServableRequest::Latest(kServableName), &handle);
   TF_CHECK_OK(status) << status;
   if (do_work) {
@@ -335,7 +335,7 @@ void BM_GetServableHandle(::testing::benchmark::State& state) {
             [j](std::unique_ptr<int64_t>* const servable) {
               servable->reset(new int64_t);
               **servable = j;
-              return OkStatus();
+              return absl::OkStatus();
             },
             SimpleLoader<int64_t>::EstimateNoResources()));
         versions.push_back({{servable_name, j}, std::move(loader)});
@@ -378,7 +378,7 @@ void BM_GetServableHandle(::testing::benchmark::State& state) {
   ServableHandle<int64_t> handle;
   int i = 0;
   for (auto s : state) {
-    const Status status =
+    const absl::Status status =
         manager->GetServableHandle(requests->at(i % kNumRequests), &handle);
     TF_CHECK_OK(status) << status;
     ++i;

tensorflow_serving/core/aspired_versions_manager_builder.cc

@@ -23,7 +23,7 @@ limitations under the License.
 namespace tensorflow {
 namespace serving {
 
-Status AspiredVersionsManagerBuilder::Create(
+absl::Status AspiredVersionsManagerBuilder::Create(
     Options options, std::unique_ptr<AspiredVersionsManagerBuilder>* builder) {
   std::unique_ptr<AspiredVersionsManager> aspired_versions_manager;
   TF_RETURN_IF_ERROR(AspiredVersionsManager::Create(std::move(options),

tensorflow_serving/core/aspired_versions_manager_builder_test.cc

@@ -91,7 +91,7 @@ TEST_F(AspiredVersionsManagerBuilderTest, AddSourceChainConnection) {
       servable_state_monitor_, id, {ServableState::ManagerState::kAvailable});
 
   ServableHandle<StoragePath> handle;
-  const Status status =
+  const absl::Status status =
       manager->GetServableHandle(ServableRequest::FromId(id), &handle);
   EXPECT_EQ(StoragePath("/storage/path/adapter0/adapter1/adapter2"), *handle);
 }

tensorflow_serving/core/basic_manager_test.cc

@@ -32,7 +32,7 @@ limitations under the License.
 namespace tensorflow {
 namespace serving {
 
-Status CachingManager::Create(
+absl::Status CachingManager::Create(
     Options options, std::unique_ptr<LoaderFactory> loader_factory,
     std::unique_ptr<CachingManager>* caching_manager) {
   // Set up basic manager options from the caching manager options.
@@ -53,7 +53,7 @@ Status CachingManager::Create(
 
   caching_manager->reset(
       new CachingManager(std::move(loader_factory), std::move(basic_manager)));
-  return OkStatus();
+  return absl::OkStatus();
 }
 
 CachingManager::CachingManager(std::unique_ptr<LoaderFactory> loader_factory,
@@ -63,7 +63,7 @@ CachingManager::CachingManager(std::unique_ptr<LoaderFactory> loader_factory,
 
 CachingManager::~CachingManager() {}
 
-Status CachingManager::GetUntypedServableHandle(
+absl::Status CachingManager::GetUntypedServableHandle(
     const ServableRequest& request,
     std::unique_ptr<UntypedServableHandle>* const handle) {
   if (request.version) {
@@ -78,11 +78,11 @@ Status CachingManager::GetUntypedServableHandle(
                                        handle);
 }
 
-Status CachingManager::GetUntypedServableHandleForId(
+absl::Status CachingManager::GetUntypedServableHandleForId(
     const ServableId& servable_id,
     std::unique_ptr<UntypedServableHandle>* handle) {
   // Check if the underlying basic manager can already serve this request.
-  const Status handle_status = basic_manager_->GetUntypedServableHandle(
+  const absl::Status handle_status = basic_manager_->GetUntypedServableHandle(
       ServableRequest::FromId(servable_id), handle);
 
   // If the servable is already managed and loaded by the basic manager, serve
@@ -106,7 +106,7 @@ Status CachingManager::GetUntypedServableHandleForId(
       ServableRequest::FromId(servable_id), handle);
 }
 
-Status CachingManager::LoadServable(
+absl::Status CachingManager::LoadServable(
     ServableData<std::unique_ptr<Loader>> loader_data) {
   const ServableId servable_id = loader_data.id();
 
@@ -150,7 +150,7 @@ Status CachingManager::LoadServable(
       // the functionality of the event-bus and the servable state monitor are
       // automatically available in the caching-manager as well (via the basic
       // manager).
-      const Status manage_status =
+      const absl::Status manage_status =
           basic_manager_->ManageServable(std::move(loader_data));
       if (!manage_status.ok()) {
         const string error_msg = strings::StrCat(
@@ -161,18 +161,19 @@ Status CachingManager::LoadServable(
       }
 
       Notification load_done;
-      Status load_status;
-      basic_manager_->LoadServable(servable_id, [&](const Status& status) {
-        load_status = status;
-        load_done.Notify();
-      });
+      absl::Status load_status;
+      basic_manager_->LoadServable(servable_id,
+                                   [&](const absl::Status& status) {
+                                     load_status = status;
+                                     load_done.Notify();
+                                   });
       load_done.WaitForNotification();
       TF_RETURN_IF_ERROR(load_status);
     }
   }
   servable_id_mu.reset();
   MaybeEraseLoadMutexMapEntry(servable_id);
-  return OkStatus();
+  return absl::OkStatus();
 }
 
 void CachingManager::MaybeEraseLoadMutexMapEntry(

tensorflow_serving/core/caching_manager.cc

@@ -65,7 +65,7 @@ class StringLoaderFactory : public CachingManager::LoaderFactory {
     auto servable_creator = [&](std::unique_ptr<string>* servable) {
       servable->reset(new string);
       **servable = strings::StrCat(id.name, "-", id.version);
-      return OkStatus();
+      return absl::OkStatus();
     };
     std::unique_ptr<Loader> loader;
     loader.reset(new SimpleLoader<string>(
@@ -346,7 +346,7 @@ TEST_P(CachingManagerTest, ServableHandleWrongType) {
   // The servable is supposed to be of type string, but we request for a handle
   // of type int. This should cause an invalid argument error.
   ServableHandle<int> handle;
-  const Status status = manager_->GetServableHandle(
+  const absl::Status status = manager_->GetServableHandle(
       ServableRequest::FromId({kServableName, 30}), &handle);
   ASSERT_FALSE(status.ok()) << status;
   EXPECT_EQ(error::INVALID_ARGUMENT, status.code());
@@ -357,7 +357,7 @@ TEST_P(CachingManagerTest, ServableHandleError) {
   std::unique_ptr<CachingManager> error_manager =
       CreateManagerWithErrorLoaderFactory();
   ServableHandle<string> handle;
-  const Status status = error_manager->GetServableHandle(
+  const absl::Status status = error_manager->GetServableHandle(
       ServableRequest::FromId({kServableName, 30}), &handle);
   EXPECT_FALSE(status.ok()) << status;
 }
@@ -419,7 +419,7 @@ TEST_P(CachingManagerTest, AvailableServableHandlesError) {
   std::unique_ptr<CachingManager> error_manager =
       CreateManagerWithErrorLoaderFactory();
   ServableHandle<string> handle;
-  const Status status = error_manager->GetServableHandle(
+  const absl::Status status = error_manager->GetServableHandle(
       ServableRequest::FromId({kServableName, 30}), &handle);
   ASSERT_FALSE(status.ok()) << status;
   std::map<ServableId, ServableHandle<string>> handles =
@@ -474,7 +474,7 @@ TEST_P(CachingManagerTest, EventBusSingleRequest) {
   // Check that the state published on the event-bus matches produced by the
   // loader-factory for a successful request.
   const ServableState expected_published_state = {
-      id, ServableState::ManagerState::kAvailable, OkStatus()};
+      id, ServableState::ManagerState::kAvailable, absl::OkStatus()};
   EXPECT_THAT(*servable_state_monitor_.GetState(id),
               EqualsServableState(expected_published_state));
 }
@@ -485,7 +485,7 @@ TEST_P(CachingManagerTest, EventBusErrorHandle) {
       CreateManagerWithErrorLoaderFactory();
   ServableHandle<string> handle;
   const ServableId id = {kServableName, 30};
-  const Status status =
+  const absl::Status status =
       error_manager->GetServableHandle(ServableRequest::FromId(id), &handle);
   // Check that the state published on the event-bus matches that produced
   // by the loader-factory for an error.
@@ -502,14 +502,14 @@ TEST_P(CachingManagerTest, EventBusErrorHandle) {
 TEST_P(CachingManagerTest, ConcurrentDisjointRequests) {
   // Track the status of each request.
   mutex status_mu;
-  std::vector<Status> statuses(4);
+  std::vector<absl::Status> statuses(4);
   {
     ThreadPoolExecutor request_executor(Env::Default(), "GetHandles",
                                         kNumThreads);
     for (int i = 0; i < 4; i++) {
       request_executor.Schedule([this, i, &statuses, &status_mu]() {
         ServableHandle<string> handle;
-        const Status status =
+        const absl::Status status =
             manager_->GetServableHandle({kServableName, i + 30}, &handle);
         mutex_lock l(status_mu);
         statuses[i] = status;
@@ -519,7 +519,7 @@ TEST_P(CachingManagerTest, ConcurrentDisjointRequests) {
   // Check that all requests returned with an ok status.
   for (int i = 0; i < 4; i++) {
     mutex_lock l(status_mu);
-    EXPECT_EQ(OkStatus(), statuses[i]);
+    EXPECT_EQ(absl::OkStatus(), statuses[i]);
   }
   // Check that the available servable handles now includes all requested
   // servables.
@@ -542,7 +542,7 @@ TEST_P(CachingManagerTest, ConcurrentDisjointRequests) {
 
 TEST_P(CachingManagerTest, ConcurrentIntersectingRequests) {
   mutex status_mu;
-  std::vector<Status> statuses(8);
+  std::vector<absl::Status> statuses(8);
   {
     ThreadPoolExecutor request_executor(Env::Default(), "GetHandles",
                                         kNumThreads);
@@ -552,7 +552,7 @@ TEST_P(CachingManagerTest, ConcurrentIntersectingRequests) {
       const ServableId id = {kServableName, version};
       request_executor.Schedule([this, i, id, &statuses, &status_mu]() {
         ServableHandle<string> handle;
-        const Status status =
+        const absl::Status status =
             manager_->GetServableHandle(ServableRequest::FromId(id), &handle);
         mutex_lock l(status_mu);
         statuses[i] = status;
@@ -562,7 +562,7 @@ TEST_P(CachingManagerTest, ConcurrentIntersectingRequests) {
   // Check that all requests returned with an ok status.
   for (int i = 0; i < 8; i++) {
     mutex_lock l(status_mu);
-    EXPECT_EQ(OkStatus(), statuses[i]);
+    EXPECT_EQ(absl::OkStatus(), statuses[i]);
   }
   // Check that the available servable handles now includes all requested
   // servables.

tensorflow_serving/core/caching_manager_test.cc

@@ -44,10 +44,10 @@ std::function<void(const uint32)> SetManagerNumLoadThreadsNotifier(
   return manager->set_num_load_threads_observer_->Notifier();
 }
 
-Status ConnectSourcesWithFastInitialLoad(
+absl::Status ConnectSourcesWithFastInitialLoad(
     AspiredVersionsManager* manager,
     std::vector<Source<std::unique_ptr<Loader>>*> sources,
-    const std::function<Status()>& wait_until_loaded_fn,
+    const std::function<absl::Status()>& wait_until_loaded_fn,
     const uint32 num_threads) {
   const uint32 prev_num_load_threads = GetManagerNumLoadThreads(manager);
   std::function<void(const uint32)> set_manager_num_load_threads =
@@ -56,14 +56,14 @@ Status ConnectSourcesWithFastInitialLoad(
   for (Source<std::unique_ptr<Loader>>* source : sources) {
     ConnectSourceToTarget(source, manager);
   }
-  const Status status = wait_until_loaded_fn();
+  const absl::Status status = wait_until_loaded_fn();
   set_manager_num_load_threads(prev_num_load_threads);
   return status;
 }
 
 }  // namespace internal
 
-Status ConnectSourceWithFastInitialLoad(
+absl::Status ConnectSourceWithFastInitialLoad(
     AspiredVersionsManager* manager, Source<std::unique_ptr<Loader>>* source,
     ServableStateMonitor* servable_state_monitor,
     const std::vector<ServableRequest>& initial_servables,
@@ -73,7 +73,7 @@ Status ConnectSourceWithFastInitialLoad(
                                            initial_servables, num_threads);
 }
 
-Status ConnectSourcesWithFastInitialLoad(
+absl::Status ConnectSourcesWithFastInitialLoad(
     AspiredVersionsManager* manager,
     std::vector<Source<std::unique_ptr<Loader>>*> sources,
     ServableStateMonitor* servable_state_monitor,
@@ -116,7 +116,7 @@ Status ConnectSourcesWithFastInitialLoad(
           strings::StrAppend(&message, "}");
           return errors::Unknown(message);
         }
-        return OkStatus();
+        return absl::OkStatus();
       },
       num_threads);
 }