rename consistent to global

oneflow/api/cpp/env.cpp

@@ -18,7 +18,7 @@ limitations under the License.
 #include "oneflow/api/cpp/env.h"
 #include "oneflow/api/cpp/env_impl.h"
 #include "oneflow/core/framework/shut_down_util.h"
-#include "oneflow/core/thread/thread_consistent_id.h"
+#include "oneflow/core/thread/thread_global_id.h"
 
 namespace oneflow_api {
 void initialize() {
@@ -29,7 +29,7 @@ void initialize() {
 void release() {
   if (of::Singleton<OneFlowEnv>::Get() != nullptr) { of::Singleton<OneFlowEnv>::Delete(); }
   of::SetShuttingDown();
-  of::ResetThisThreadUniqueConsistentId().GetOrThrow();
+  of::ResetThisThreadUniqueGlobalId().GetOrThrow();
 }
 
 }  // namespace oneflow_api

oneflow/api/cpp/framework/graph.cpp

@@ -306,7 +306,7 @@ of::Maybe<void> Graph::GraphImpl::AddOp(of::OperatorConf op_conf) {
         0, batch_size_);
   }
   auto* ctx = JUST(of::GetCurInferCtx());
-  JUST(ctx->AddAndInferConsistentOp(op_conf));
+  JUST(ctx->AddAndInferGlobalOp(op_conf));
   return of::Maybe<void>::Ok();
 }
 

oneflow/api/python/framework/session_util.cpp

@@ -27,7 +27,7 @@ ONEFLOW_API_PYBIND11_MODULE("", m) {
       .def("push_mirrored_strategy_enabled", &Session::PushMirroredStrategyEnabled)
       .def("pop_mirrored_strategy_enabled", &Session::PopMirroredStrategyEnabled)
       .def("is_mirrored_strategy_enabled", &Session::IsMirroredStrategyEnabled)
-      .def("is_consistent_strategy_enabled", &Session::IsConsistentStrategyEnabled)
+      .def("is_global_strategy_enabled", &Session::IsGlobalStrategyEnabled)
       .def("is_mirrored_strategy_enabled_stack_size",
            [](const Session* sess) { return sess->is_mirrored_strategy_enabled_stack()->size(); });
 

oneflow/api/python/framework/tensor.cpp

@@ -509,7 +509,7 @@ static PyObject* PyTensorObject_is_eager(PyObject* self, void* unused) {
 }
 
 static PyObject* PyTensorObject_is_global(PyObject* self, void* unused) {
-  return functional::CastToPyObject(PyTensor_Unpack(self)->is_consistent());
+  return functional::CastToPyObject(PyTensor_Unpack(self)->is_global());
 }
 
 static PyObject* PyTensorObject_is_local(PyObject* self, void* unused) {

oneflow/api/python/framework/tensor_functions.cpp

@@ -662,16 +662,15 @@ static PyObject* PyTensorObject_local_to_global(PyObject* self, PyObject* args,
         << functional::PyStringAsString(PyObject_Str((PyObject*)Py_TYPE(sbp_obj)));
     sbp = functional::PyUnpackSbpParallelSequence(sbp_obj);
   }
-  return PyTensor_New(ASSERT_PTR(functional::ToConsistent(
+  return PyTensor_New(ASSERT_PTR(functional::ToGlobal(
       tensor, functional::PyUnpackParallelDesc(placement_obj), sbp, {}, check_meta)));
   END_HANDLE_ERRORS
 }
 
 static PyObject* PyTensorObject_global_to_global(PyObject* self, PyObject* args, PyObject* kwargs) {
   HANDLE_ERRORS
   auto tensor = PyTensor_Unpack(self);
-  CHECK_OR_THROW(tensor->is_consistent())
-      << Error::RuntimeError() << "input must be a global tensor";
+  CHECK_OR_THROW(tensor->is_global()) << Error::RuntimeError() << "input must be a global tensor";
   PyObject* placement_obj = Py_None;
   PyObject* sbp_obj = Py_None;
   PyObject* grad_sbp_obj = Py_None;
@@ -721,15 +720,15 @@ static PyObject* PyTensorObject_global_to_global(PyObject* self, PyObject* args,
     grad_sbp = functional::PyUnpackSbpParallelSequence(grad_sbp_obj);
   }
   return PyTensor_New(
-      ASSERT_PTR(functional::ToConsistent(tensor, placement, sbp, grad_sbp, check_meta)));
+      ASSERT_PTR(functional::ToGlobal(tensor, placement, sbp, grad_sbp, check_meta)));
   END_HANDLE_ERRORS
 }
 
 static PyObject* PyTensorObject_to_global(PyObject* self, PyObject* args, PyObject* kwargs) {
   HANDLE_ERRORS
   const auto& tensor = PyTensor_Unpack(self);
   PyObject* result = NULL;
-  if (tensor->is_consistent())
+  if (tensor->is_global())
     result = PyTensorObject_global_to_global(self, args, kwargs);
   else {
     result = PyTensorObject_local_to_global(self, args, kwargs);
@@ -743,9 +742,9 @@ static PyObject* PyTensorObject_to_global(PyObject* self, PyObject* args, PyObje
 static PyObject* PyTensorObject_to_local(PyObject* self, PyObject* unused) {
   HANDLE_ERRORS
   auto tensor = PyTensor_Unpack(self);
-  CHECK_OR_THROW(tensor->is_consistent())
+  CHECK_OR_THROW(tensor->is_global())
       << Error::RuntimeError() << "Expected global tensor for to_local but got local tensor!";
-  return PyTensor_New(ASSERT_PTR(functional::ConsistentToLocal(tensor)));
+  return PyTensor_New(ASSERT_PTR(functional::GlobalToLocal(tensor)));
   END_HANDLE_ERRORS
 }
 
@@ -760,21 +759,21 @@ int PyTensorObject_setitem(PyObject* self, PyObject* item, PyObject* value) {
       << Error::TypeError() << "tensor_setitem(): argument 'value' must be tensor or scalar, not "
       << functional::PyStringAsString(PyObject_Str((PyObject*)Py_TYPE(value)));
 
-  if (tensor->is_consistent()) {
+  if (tensor->is_global()) {
     Symbol<ParallelDesc> placement = ASSERT(tensor->parallel_desc());
     auto ndsbp = ASSERT(tensor->nd_sbp());
     std::vector<Symbol<SbpParallel>> sbp(ndsbp->sbp_parallel_size(),
                                          ASSERT(MakeBroadcastSbpParallel()));
     if (functional::PyScalarCheck(value)) {
       Scalar value_scalar = functional::PyUnpackScalar(value);
       value_tensor = ASSERT_PTR(
-          functional::ConsistentConstant({1}, value_scalar, tensor->dtype(), placement, sbp));
+          functional::GlobalConstant({1}, value_scalar, tensor->dtype(), placement, sbp));
     } else {
       value_tensor = PyTensor_Unpack(value);
-      CHECK_OR_THROW(value_tensor->is_consistent())
+      CHECK_OR_THROW(value_tensor->is_global())
           << Error::RuntimeError()
           << "tensor_setitem(): value must be a global tensor when self is global";
-      value_tensor = ASSERT_PTR(functional::ToConsistent(value_tensor, placement, sbp, {}, true));
+      value_tensor = ASSERT_PTR(functional::ToGlobal(value_tensor, placement, sbp, {}, true));
     }
   } else {
     if (functional::PyScalarCheck(value)) {

oneflow/api/python/functional/tensor_api.cpp

@@ -70,7 +70,7 @@ class TensorWithDataFunctor {
   }
 };
 
-class ConsistentTensorWithDataFunctor {
+class GlobalTensorWithDataFunctor {
  public:
   Maybe<Tensor> operator()(PyObject* data, const Optional<Symbol<DType>>& dtype,
                            const Symbol<ParallelDesc>& placement,
@@ -93,8 +93,8 @@ class ConsistentTensorWithDataFunctor {
       const auto& other = PyTensor_Unpack(data);
       return MakeTensorFromOtherTensor(other, dtype, placement, sbp_tuple, requires_grad);
     }
-    // Make consistent tensor from python sequence or numpy array.
-    return MakeConsistentTensorFromData(data, dtype, placement, sbp_tuple, requires_grad);
+    // Make global tensor from python sequence or numpy array.
+    return MakeGlobalTensorFromData(data, dtype, placement, sbp_tuple, requires_grad);
   }
 };
 
@@ -106,13 +106,13 @@ class TensorEmptyCtorFunctor {
   }
 };
 
-class ConsistentTensorEmptyCtorFunctor {
+class GlobalTensorEmptyCtorFunctor {
  public:
   Maybe<Tensor> operator()(const Symbol<ParallelDesc>& placement,
                            const std::vector<Symbol<SbpParallel>>& sbp_tuple) const {
     Shape shape(DimVector{0});
     JUST(CheckDeviceIdsIsValid(placement));
-    return ConsistentTensorWithShapeCtor(shape, placement, sbp_tuple);
+    return GlobalTensorWithShapeCtor(shape, placement, sbp_tuple);
   }
 };
 
@@ -155,7 +155,7 @@ class TensorWithDataCtorFunctor {
   }
 };
 
-class ConsistentTensorWithDataCtorFunctor {
+class GlobalTensorWithDataCtorFunctor {
  public:
   Maybe<Tensor> operator()(PyObject* data, const Symbol<ParallelDesc>& placement,
                            const std::vector<Symbol<SbpParallel>>& sbp_tuple) const {
@@ -164,10 +164,10 @@ class ConsistentTensorWithDataCtorFunctor {
     if (PyLong_Check(data)) {
       int64_t size = PyLong_AsLongLong(data);
       Shape shape(DimVector{size});
-      return ConsistentTensorWithShapeCtor(shape, placement, sbp_tuple);
+      return GlobalTensorWithShapeCtor(shape, placement, sbp_tuple);
     }
     if (TensorSize_Check(data)) {
-      return ConsistentTensorWithShapeCtor(TensorSize_AsShape(data), placement, sbp_tuple);
+      return GlobalTensorWithShapeCtor(TensorSize_AsShape(data), placement, sbp_tuple);
     }
 
     // NOTE(chengcheng): flow.Tensor or flow.tensor ONLY created by EagerTensor now.
@@ -179,8 +179,8 @@ class ConsistentTensorWithDataCtorFunctor {
       return MakeTensorFromOtherTensor(other, dtype, placement, sbp_tuple,
                                        /*requires_grad=*/false);
     }
-    // Make consistent tensor from python sequence or numpy array.
-    return MakeConsistentTensorFromData(data, dtype, placement, sbp_tuple, /*requires_grad=*/false);
+    // Make global tensor from python sequence or numpy array.
+    return MakeGlobalTensorFromData(data, dtype, placement, sbp_tuple, /*requires_grad=*/false);
   }
 };
 
@@ -199,14 +199,14 @@ class TensorWithShapeCtorFunctor {
   }
 };
 
-class ConsistentTensorWithShapeCtorFunctor {
+class GlobalTensorWithShapeCtorFunctor {
  public:
   Maybe<Tensor> operator()(const Shape& shape, const Symbol<ParallelDesc>& placement,
                            const std::vector<Symbol<SbpParallel>>& sbp_tuple) const {
     // NOTE(chengcheng): flow.Tensor or flow.tensor ONLY created by EagerTensor now.
     LazyMode::Guard lazy_mode_disabled_guard(/*is_enabled*/ false);
     JUST(CheckDeviceIdsIsValid(placement));
-    return functional::ConsistentEmpty(shape, DType::Float(), placement, sbp_tuple);
+    return functional::GlobalEmpty(shape, DType::Float(), placement, sbp_tuple);
   }
 };
 
@@ -305,14 +305,14 @@ class LocalTensorSharedNumpyDataFunctor {
 
 ONEFLOW_FUNCTION_LIBRARY(m) {
   m.add_functor<impl::TensorWithDataFunctor>("TensorWithData");
-  m.add_functor<impl::ConsistentTensorWithDataFunctor>("ConsistentTensorWithData");
+  m.add_functor<impl::GlobalTensorWithDataFunctor>("GlobalTensorWithData");
   m.add_functor<impl::TensorEmptyCtorFunctor>("TensorEmptyCtor");
-  m.add_functor<impl::ConsistentTensorEmptyCtorFunctor>("ConsistentTensorEmptyCtor");
+  m.add_functor<impl::GlobalTensorEmptyCtorFunctor>("GlobalTensorEmptyCtor");
   m.add_functor<impl::TensorWithOtherCtorFunctor>("TensorWithOtherCtor");
   m.add_functor<impl::TensorWithDataCtorFunctor>("TensorWithDataCtor");
-  m.add_functor<impl::ConsistentTensorWithDataCtorFunctor>("ConsistentTensorWithDataCtor");
+  m.add_functor<impl::GlobalTensorWithDataCtorFunctor>("GlobalTensorWithDataCtor");
   m.add_functor<impl::TensorWithShapeCtorFunctor>("TensorWithShapeCtor");
-  m.add_functor<impl::ConsistentTensorWithShapeCtorFunctor>("ConsistentTensorWithShapeCtor");
+  m.add_functor<impl::GlobalTensorWithShapeCtorFunctor>("GlobalTensorWithShapeCtor");
   m.add_functor<impl::AssignLocalTensorFunctor>("AssignLocalTensor");
   m.add_functor<impl::LocalTensorSharedNumpyDataFunctor>("LocalTensorSharedNumpyData");
 }

oneflow/api/python/functional/tensor_api.yaml

@@ -17,20 +17,20 @@
       "Tensor (PyObject* data, *, DataType dtype=None, Device device=None,
       Bool requires_grad=False, Bool pin_memory=False) => TensorWithData",
       "Tensor (PyObject* data, *, DataType dtype=None, Placement placement,
-      SbpList sbp, Bool requires_grad=False) => ConsistentTensorWithData",
+      SbpList sbp, Bool requires_grad=False) => GlobalTensorWithData",
     ]
   bind_python: True
 
 - name: "_legacy_tensor_ctor"
   signature:
     [
       "Tensor (*, Device device=None) => TensorEmptyCtor",
-      "Tensor (*, Placement placement, SbpList sbp) => ConsistentTensorEmptyCtor",
+      "Tensor (*, Placement placement, SbpList sbp) => GlobalTensorEmptyCtor",
       "Tensor (Tensor other) => TensorWithOtherCtor",
       "Tensor (PyObject* data, *, Device device=None) => TensorWithDataCtor",
-      "Tensor (PyObject* data, *, Placement placement, SbpList sbp) => ConsistentTensorWithDataCtor",
+      "Tensor (PyObject* data, *, Placement placement, SbpList sbp) => GlobalTensorWithDataCtor",
       "Tensor (Shape size, *, Device device=None) => TensorWithShapeCtor",
-      "Tensor (Shape size, *, Placement placement, SbpList sbp) => ConsistentTensorWithShapeCtor",
+      "Tensor (Shape size, *, Placement placement, SbpList sbp) => GlobalTensorWithShapeCtor",
     ]
   bind_python: True
 

oneflow/api/python/job_build/job_build_and_infer.cpp

@@ -40,8 +40,7 @@ ONEFLOW_API_PYBIND11_MODULE("", m) {
   m.def("CurJobBuildAndInferCtx_AddAndInferMirroredOp",
         &CurJobBuildAndInferCtx_AddAndInferMirroredOp, py::call_guard<py::gil_scoped_release>());
 
-  m.def("CurJobBuildAndInferCtx_AddAndInferConsistentOp",
-        &CurJobBuildAndInferCtx_AddAndInferConsistentOp);
+  m.def("CurJobBuildAndInferCtx_AddAndInferGlobalOp", &CurJobBuildAndInferCtx_AddAndInferGlobalOp);
   m.def("CurJobBuildAndInferCtx_AddLbiAndDiffWatcherUuidPair",
         &CurJobBuildAndInferCtx_AddLbiAndDiffWatcherUuidPair);
 

oneflow/api/python/job_build/job_build_and_infer.h

@@ -78,12 +78,12 @@ inline Maybe<std::string> CurJobBuildAndInferCtx_AddAndInferMirroredOp(
   return PbMessage2TxtString(*op_attribute);
 }
 
-inline Maybe<std::string> CurJobBuildAndInferCtx_AddAndInferConsistentOp(
+inline Maybe<std::string> CurJobBuildAndInferCtx_AddAndInferGlobalOp(
     const std::string& op_conf_str) {
   OperatorConf op_conf;
   CHECK_OR_RETURN(TxtString2PbMessage(op_conf_str, &op_conf)) << "operator conf parse failed";
   auto* ctx = JUST(GetCurInferCtx());
-  const auto& op_attribute = JUST(ctx->AddAndInferConsistentOp(op_conf));
+  const auto& op_attribute = JUST(ctx->AddAndInferGlobalOp(op_conf));
   return PbMessage2TxtString(*op_attribute);
 }
 

oneflow/api/python/rpc/consistent_rpc_token_scope.cpp → oneflow/api/python/rpc/global_rpc_token_scope.cpp

@@ -17,7 +17,7 @@ limitations under the License.
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
 #include "oneflow/api/python/of_api_registry.h"
-#include "oneflow/core/thread/thread_consistent_id.h"
+#include "oneflow/core/thread/thread_global_id.h"
 #include "oneflow/core/framework/rank_group_rpc_util.h"
 #include "oneflow/core/job/rank_group.h"
 #include "oneflow/core/job/rank_group_scope.h"
@@ -29,32 +29,30 @@ namespace oneflow {
 
 namespace {
 
-Maybe<void> InitConsistentTransportTokenScope(const std::string& thread_tag,
-                                              int64_t thread_consistent_id,
-                                              Symbol<RankGroup> rank_group) {
-  JUST(InitThisThreadUniqueConsistentId(thread_consistent_id, thread_tag));
+Maybe<void> InitGlobalTransportTokenScope(const std::string& thread_tag, int64_t thread_global_id,
+                                          Symbol<RankGroup> rank_group) {
+  JUST(InitThisThreadUniqueGlobalId(thread_global_id, thread_tag));
   static thread_local const auto& init_rank_group_scope =
       JUST(RankGroupScope::MakeInitialRankGroupScope(rank_group));
   // no unused warning for `init_rank_group_scope`.
   (void)(init_rank_group_scope);
   return Maybe<void>::Ok();
 }
 
-Maybe<void> InitConsistentTransportTokenScope(const std::string& thread_tag,
-                                              int64_t thread_consistent_id) {
+Maybe<void> InitGlobalTransportTokenScope(const std::string& thread_tag, int64_t thread_global_id) {
   const auto& rank_group = JUST(RankGroup::DefaultRankGroup());
-  JUST(InitConsistentTransportTokenScope(thread_tag, thread_consistent_id, rank_group));
+  JUST(InitGlobalTransportTokenScope(thread_tag, thread_global_id, rank_group));
   return Maybe<void>::Ok();
 }
 
-Maybe<void> ApiInitDefaultConsistentTransportTokenScope() {
-  return InitConsistentTransportTokenScope("main", kThreadConsistentIdMain);
+Maybe<void> ApiInitDefaultGlobalTransportTokenScope() {
+  return InitGlobalTransportTokenScope("main", kThreadGlobalIdMain);
 }
 
 }  // namespace
 
 ONEFLOW_API_PYBIND11_MODULE("", m) {
-  m.def("InitDefaultConsistentTransportTokenScope", &ApiInitDefaultConsistentTransportTokenScope);
+  m.def("InitDefaultGlobalTransportTokenScope", &ApiInitDefaultGlobalTransportTokenScope);
 }
 
 }  // namespace oneflow

oneflow/api/python/utils/tensor_utils.cpp

@@ -201,10 +201,10 @@ auto* CachedGetAllBroadcastNdSbp = DECORATE(&GetAllBroadcastNdSbp, ThreadLocal);
 
 }  // namespace
 
-Maybe<Tensor> MakeConsistentTensorFromData(PyObject* data, const Optional<Symbol<DType>>& dtype,
-                                           Symbol<ParallelDesc> placement,
-                                           const std::vector<Symbol<SbpParallel>>& sbp_tuple,
-                                           const bool requires_grad) {
+Maybe<Tensor> MakeGlobalTensorFromData(PyObject* data, const Optional<Symbol<DType>>& dtype,
+                                       Symbol<ParallelDesc> placement,
+                                       const std::vector<Symbol<SbpParallel>>& sbp_tuple,
+                                       const bool requires_grad) {
   PyObject* array = NULL;
   if (PyArray_Check(data)) {
     // Only NPY_CORDER is supported, and returns a new C-style contiguous array.
@@ -246,14 +246,14 @@ Maybe<Tensor> MakeConsistentTensorFromData(PyObject* data, const Optional<Symbol
   size_t sbp_dims = sbp_tuple.size();
   Symbol<NdSbp> broadcast_nd_sbp = JUST(CachedGetAllBroadcastNdSbp(sbp_dims));
 
-  std::shared_ptr<Tensor> broadcast_tensor = JUST(functional::LocalToConsistent(
+  std::shared_ptr<Tensor> broadcast_tensor = JUST(functional::LocalToGlobal(
       local_tensor, placement, *JUST(GetSbpList(broadcast_nd_sbp)), shape, local_tensor->dtype()));
 
   std::vector<Symbol<SbpParallel>> grad_sbp_tuple;
-  auto consistent_tensor = JUST(functional::ToConsistent(broadcast_tensor, placement, sbp_tuple,
-                                                         grad_sbp_tuple, /* check_meta */ false));
-  JUST(consistent_tensor->set_requires_grad(requires_grad));
-  return consistent_tensor;
+  auto global_tensor = JUST(functional::ToGlobal(broadcast_tensor, placement, sbp_tuple,
+                                                 grad_sbp_tuple, /* check_meta */ false));
+  JUST(global_tensor->set_requires_grad(requires_grad));
+  return global_tensor;
 }
 
 Maybe<Tensor> MakeTensorFromOtherTensor(const std::shared_ptr<Tensor>& other,
@@ -265,9 +265,9 @@ Maybe<Tensor> MakeTensorFromOtherTensor(const std::shared_ptr<Tensor>& other,
     const Symbol<NdSbp>& nd_sbp = JUST(other->nd_sbp());
     const std::vector<Symbol<SbpParallel>>& sbp_tuple = *JUST(GetSbpList(nd_sbp));
     std::vector<Symbol<SbpParallel>> grad_sbp_tuple;
-    // TODO:(zhaoluyang) consistent case support pin_memory
-    return functional::ToConsistent(other, JUST(other->parallel_desc()), sbp_tuple, grad_sbp_tuple,
-                                    /* check_meta */ false);
+    // TODO:(zhaoluyang) global case support pin_memory
+    return functional::ToGlobal(other, JUST(other->parallel_desc()), sbp_tuple, grad_sbp_tuple,
+                                /* check_meta */ false);
   }
 }
 
@@ -283,7 +283,7 @@ Maybe<Tensor> MakeTensorFromOtherTensor(const std::shared_ptr<Tensor>& other,
     tensor = JUST(functional::Copy(other, device_->type(), device_->device_id(),
                                    pin_memory && !dtype.has_value()));
   } else {
-    tensor = JUST(functional::ConsistentToLocal(other));
+    tensor = JUST(functional::GlobalToLocal(other));
     if (!device) { device_ = JUST(Device::New("cpu")); }
     tensor = JUST(functional::Copy(tensor, device_->type(), device_->device_id(),
                                    pin_memory && !dtype.has_value()));
@@ -302,9 +302,9 @@ Maybe<Tensor> MakeTensorFromOtherTensor(const std::shared_ptr<Tensor>& other,
                                         const std::vector<Symbol<SbpParallel>>& sbp_tuple,
                                         const bool requires_grad) {
   std::vector<Symbol<SbpParallel>> grad_sbp_tuple;
-  bool check_meta = other->is_consistent() ? false : true;
+  bool check_meta = other->is_global() ? false : true;
   std::shared_ptr<Tensor> tensor =
-      JUST(functional::ToConsistent(other, placement, sbp_tuple, grad_sbp_tuple, check_meta));
+      JUST(functional::ToGlobal(other, placement, sbp_tuple, grad_sbp_tuple, check_meta));
   if (dtype) {
     const Symbol<DType>& dtype_ = JUST(dtype);
     if (tensor->dtype() != dtype_) {