Python api of placement group (#9243)

src/ray/gcs/gcs_server/gcs_placement_group_manager.cc

@@ -154,14 +154,17 @@ void GcsPlacementGroupManager::HandleCreatePlacementGroup(
     ray::rpc::SendReplyCallback send_reply_callback) {
   auto placement_group_id =
       PlacementGroupID::FromBinary(request.placement_group_spec().placement_group_id());
-
+  const auto &strategy = request.placement_group_spec().strategy();
+  const auto &name = request.placement_group_spec().name();
   RAY_LOG(INFO) << "Registering placement group, placement group id = "
-                << placement_group_id;
+                << placement_group_id << ", name = " << name
+                << ", strategy = " << PlacementStrategy_Name(strategy);
   RegisterPlacementGroup(
       request, [reply, send_reply_callback, placement_group_id](
                    std::shared_ptr<gcs::GcsPlacementGroup> placement_group) {
         RAY_LOG(INFO) << "Registered placement group, placement group id = "
-                      << placement_group_id;
+                      << placement_group_id << ", name = " << placement_group->GetName()
+                      << ", strategy = " << placement_group->GetStrategy();
         GCS_RPC_SEND_REPLY(send_reply_callback, reply, Status::OK());
       });
   auto placement_group = std::make_shared<GcsPlacementGroup>(request);
@@ -171,7 +174,7 @@ void GcsPlacementGroupManager::HandleCreatePlacementGroup(
 }
 
 void GcsPlacementGroupManager::ScheduleTick() {
-  reschedule_timer_.expires_from_now(boost::posix_time::milliseconds(5));
+  reschedule_timer_.expires_from_now(boost::posix_time::milliseconds(500));
   reschedule_timer_.async_wait([this](const boost::system::error_code &error) {
     if (error == boost::system::errc::operation_canceled) {
       return;

src/ray/gcs/gcs_server/gcs_placement_group_scheduler.cc

@@ -154,14 +154,11 @@ void GcsPlacementGroupScheduler::ReserveResourceFromNode(
     std::shared_ptr<ray::rpc::GcsNodeInfo> node, ReserveResourceCallback callback) {
   RAY_CHECK(node);
 
-  auto node_id = ClientID::FromBinary(node->node_id());
-  RAY_LOG(DEBUG) << "Start leasing resource from node " << node_id << " for bundle "
-                 << bundle->BundleId().first << std::to_string(bundle->BundleId().second);
-
   rpc::Address remote_address;
   remote_address.set_raylet_id(node->node_id());
   remote_address.set_ip_address(node->node_manager_address());
   remote_address.set_port(node->node_manager_port());
+  auto node_id = ClientID::FromBinary(node->node_id());
   auto lease_client = GetOrConnectLeaseClient(remote_address);
   RAY_LOG(DEBUG) << "Start leasing resource from node " << node_id << " for bundle "
                  << bundle->BundleId().first << bundle->BundleId().second;
@@ -183,7 +180,7 @@ void GcsPlacementGroupScheduler::ReserveResourceFromNode(
                              << " for bundle " << bundle->BundleId().first
                              << bundle->BundleId().second;
             }
-            // Remove the actor from the leasing map as the reply is returned from the
+            // Remove the bundle from the leasing map as the reply is returned from the
             // remote node.
             iter->second.erase(bundle_iter);
             if (iter->second.empty()) {

src/ray/gcs/gcs_server/gcs_server.h

@@ -152,7 +152,6 @@ class GcsServer {
   /// Worker info service
   std::unique_ptr<rpc::WorkerInfoGrpcService> worker_info_service_;
   /// Placement Group info handler and service
-  std::unique_ptr<rpc::PlacementGroupInfoHandler> placement_group_info_handler_;
   std::unique_ptr<rpc::PlacementGroupInfoGrpcService> placement_group_info_service_;
   /// Backend client
   std::shared_ptr<RedisGcsClient> redis_gcs_client_;

src/ray/gcs/gcs_server/gcs_table_storage.h

@@ -410,8 +410,8 @@ class GcsTableStorage {
   std::unique_ptr<GcsObjectTable> object_table_;
   std::unique_ptr<GcsNodeTable> node_table_;
   std::unique_ptr<GcsNodeResourceTable> node_resource_table_;
-  std::unique_ptr<GcsHeartbeatTable> heartbeat_table_;
   std::unique_ptr<GcsPlacementGroupScheduleTable> placement_group_schedule_table_;
+  std::unique_ptr<GcsHeartbeatTable> heartbeat_table_;
   std::unique_ptr<GcsHeartbeatBatchTable> heartbeat_batch_table_;
   std::unique_ptr<GcsErrorInfoTable> error_info_table_;
   std::unique_ptr<GcsProfileTable> profile_table_;

src/ray/gcs/redis_accessor.cc

@@ -835,6 +835,11 @@ Status RedisWorkerInfoAccessor::AsyncAdd(
   return Status::Invalid("Not implemented");
 }
 
+Status RedisPlacementGroupInfoAccessor::AsyncCreatePlacementGroup(
+    const PlacementGroupSpecification &placement_group_spec) {
+  return Status::Invalid("Not implemented");
+}
+
 }  // namespace gcs
 
 }  // namespace ray

src/ray/gcs/redis_accessor.h

@@ -473,6 +473,14 @@ class RedisWorkerInfoAccessor : public WorkerInfoAccessor {
   WorkerFailureSubscriptionExecutor worker_failure_sub_executor_;
 };
 
+class RedisPlacementGroupInfoAccessor : public PlacementGroupInfoAccessor {
+ public:
+  virtual ~RedisPlacementGroupInfoAccessor() = default;
+
+  Status AsyncCreatePlacementGroup(
+      const PlacementGroupSpecification &placement_group_spec) override;
+};
+
 }  // namespace gcs
 
 }  // namespace ray

src/ray/gcs/redis_gcs_client.cc

@@ -82,6 +82,7 @@ Status RedisGcsClient::Connect(boost::asio::io_service &io_service) {
   error_accessor_.reset(new RedisErrorInfoAccessor(this));
   stats_accessor_.reset(new RedisStatsInfoAccessor(this));
   worker_accessor_.reset(new RedisWorkerInfoAccessor(this));
+  placement_group_accessor_.reset(new RedisPlacementGroupInfoAccessor());
 
   is_connected_ = true;
 

src/ray/raylet/node_manager.cc

@@ -1986,8 +1986,8 @@ ResourceIdSet NodeManager::ScheduleBundle(
       std::string resource_name = bundle_id_str + "_" + resource.first;
       local_available_resources_.AddBundleResource(resource_name, resource.second);
     }
-    cluster_resource_map_[self_node_id_].UpdateBundleResource(
-        bundle_id_str, bundle_spec.GetRequiredResources());
+    resource_map[self_node_id_].UpdateBundleResource(bundle_id_str,
+                                                     bundle_spec.GetRequiredResources());
   }
   return acquired_resources;
 }
@@ -2566,7 +2566,6 @@ void NodeManager::AssignTask(const std::shared_ptr<WorkerInterface> &worker,
   auto acquired_resources =
       local_available_resources_.Acquire(spec.GetRequiredResources());
   cluster_resource_map_[self_node_id_].Acquire(spec.GetRequiredResources());
-
   if (spec.IsActorCreationTask()) {
     // Check that the actor's placement resource requirements are satisfied.
     RAY_CHECK(spec.GetRequiredPlacementResources().IsSubset(