[core] Remove usages of vestigial "direct" call terminology (#52741)

edoakes · web-flow · commit 8561936c8084 · 2025-05-03T15:53:04.000Z
There haven't been non-direct actor calls for years, so this is
unnecessary mental burden.

---------

Signed-off-by: Edward Oakes &lt;ed.nmi.oakes@gmail.com&gt;
diff --git a/src/mock/ray/core_worker/core_worker.h b/src/mock/ray/core_worker/core_worker.h
@@ -29,9 +29,9 @@ class MockCoreWorker : public CoreWorker {
                rpc::SendReplyCallback send_reply_callback),
               (override));
   MOCK_METHOD(void,
-              HandleDirectActorCallArgWaitComplete,
-              (rpc::DirectActorCallArgWaitCompleteRequest request,
-               rpc::DirectActorCallArgWaitCompleteReply *reply,
+              HandleActorCallArgWaitComplete,
+              (rpc::ActorCallArgWaitCompleteRequest request,
+               rpc::ActorCallArgWaitCompleteReply *reply,
                rpc::SendReplyCallback send_reply_callback),
               (override));
   MOCK_METHOD(void,
diff --git a/src/mock/ray/raylet/worker.h b/src/mock/ray/raylet/worker.h
@@ -56,7 +56,7 @@ class MockWorkerInterface : public WorkerInterface {
   MOCK_METHOD(const std::shared_ptr<ClientConnection>, Connection, (), (const, override));
   MOCK_METHOD(void, SetOwnerAddress, (const rpc::Address &address), (override));
   MOCK_METHOD(const rpc::Address &, GetOwnerAddress, (), (const, override));
-  MOCK_METHOD(void, DirectActorCallArgWaitComplete, (int64_t tag), (override));
+  MOCK_METHOD(void, ActorCallArgWaitComplete, (int64_t tag), (override));
   MOCK_METHOD(const BundleID &, GetBundleId, (), (const, override));
   MOCK_METHOD(void, SetBundleId, (const BundleID &bundle_id), (override));
   MOCK_METHOD(void,
diff --git a/src/mock/ray/raylet_client/raylet_client.h b/src/mock/ray/raylet_client/raylet_client.h
@@ -17,7 +17,7 @@ namespace ray {
 class MockRayletClientInterface : public RayletClientInterface {
  public:
   MOCK_METHOD(ray::Status,
-              WaitForDirectActorCallArgs,
+              WaitForActorCallArgs,
               (const std::vector<rpc::ObjectReference> &references, int64_t tag),
               (override));
   MOCK_METHOD(std::shared_ptr<grpc::Channel>, GetChannel, (), (const));
diff --git a/src/mock/ray/rpc/worker/core_worker_client.h b/src/mock/ray/rpc/worker/core_worker_client.h
@@ -36,9 +36,9 @@ class MockCoreWorkerClientInterface : public ray::pubsub::MockSubscriberClientIn
                int64_t timeout_ms),
               (override));
   MOCK_METHOD(void,
-              DirectActorCallArgWaitComplete,
-              (const DirectActorCallArgWaitCompleteRequest &request,
-               const ClientCallback<DirectActorCallArgWaitCompleteReply> &callback),
+              ActorCallArgWaitComplete,
+              (const ActorCallArgWaitCompleteRequest &request,
+               const ClientCallback<ActorCallArgWaitCompleteReply> &callback),
               (override));
   MOCK_METHOD(void,
               GetObjectStatus,
diff --git a/src/ray/core_worker/context.cc b/src/ray/core_worker/context.cc
@@ -385,9 +385,9 @@ TaskID WorkerContext::GetMainThreadOrActorCreationTaskID() const {
 bool WorkerContext::ShouldReleaseResourcesOnBlockingCalls() const {
   // Check if we need to release resources when we block:
   //  - Driver doesn't acquire resources and thus doesn't need to release.
-  //  - We only support lifetime resources for direct actors, which can be
+  //  - We only support lifetime resources for actors, which can be
   //    acquired when the actor is created, per call resources are not supported,
-  //    thus we don't need to release resources for direct actor call.
+  //    thus we don't need to release resources for actor calls.
   return worker_type_ != WorkerType::DRIVER && !CurrentActorIsDirectCall() &&
          CurrentThreadIsMain();
 }
diff --git a/src/ray/core_worker/core_worker.cc b/src/ray/core_worker/core_worker.cc
@@ -3904,9 +3904,9 @@ void CoreWorker::HandlePushTask(rpc::PushTaskRequest request,
   }
 }
 
-void CoreWorker::HandleDirectActorCallArgWaitComplete(
-    rpc::DirectActorCallArgWaitCompleteRequest request,
-    rpc::DirectActorCallArgWaitCompleteReply *reply,
+void CoreWorker::HandleActorCallArgWaitComplete(
+    rpc::ActorCallArgWaitCompleteRequest request,
+    rpc::ActorCallArgWaitCompleteReply *reply,
     rpc::SendReplyCallback send_reply_callback) {
   if (HandleWrongRecipient(WorkerID::FromBinary(request.intended_worker_id()),
                            send_reply_callback)) {
diff --git a/src/ray/core_worker/core_worker.h b/src/ray/core_worker/core_worker.h
@@ -1155,9 +1155,9 @@ class CoreWorker : public rpc::CoreWorkerServiceHandler {
                       rpc::SendReplyCallback send_reply_callback) override;
 
   /// Implements gRPC server handler.
-  void HandleDirectActorCallArgWaitComplete(
-      rpc::DirectActorCallArgWaitCompleteRequest request,
-      rpc::DirectActorCallArgWaitCompleteReply *reply,
+  void HandleActorCallArgWaitComplete(
+      rpc::ActorCallArgWaitCompleteRequest request,
+      rpc::ActorCallArgWaitCompleteReply *reply,
       rpc::SendReplyCallback send_reply_callback) override;
 
   /// Implements gRPC server handler.
diff --git a/src/ray/core_worker/transport/actor_task_submitter.h b/src/ray/core_worker/transport/actor_task_submitter.h
@@ -45,9 +45,6 @@
 namespace ray {
 namespace core {
 
-/// In direct actor call task submitter and receiver, a task is directly submitted
-/// to the actor that will execute it.
-
 // Interface for testing.
 class ActorTaskSubmitterInterface {
  public:
@@ -436,7 +433,7 @@ class ActorTaskSubmitter : public ActorTaskSubmitterInterface {
 
   absl::flat_hash_map<ActorID, ClientQueue> client_queues_ ABSL_GUARDED_BY(mu_);
 
-  /// Resolve direct call object dependencies.
+  /// Resolve object dependencies.
   LocalDependencyResolver resolver_;
 
   /// Used to complete tasks.
diff --git a/src/ray/core_worker/transport/scheduling_util.cc b/src/ray/core_worker/transport/scheduling_util.cc
@@ -65,7 +65,7 @@ void DependencyWaiterImpl::Wait(const std::vector<rpc::ObjectReference> &depende
                                 std::function<void()> on_dependencies_available) {
   auto tag = next_request_id_++;
   requests_[tag] = on_dependencies_available;
-  RAY_CHECK_OK(dependency_client_.WaitForDirectActorCallArgs(dependencies, tag));
+  RAY_CHECK_OK(dependency_client_.WaitForActorCallArgs(dependencies, tag));
 }
 
 /// Fulfills the callback stored by Wait().
diff --git a/src/ray/gcs/gcs_server/test/gcs_server_test_util.h b/src/ray/gcs/gcs_server/test/gcs_server_test_util.h
@@ -322,8 +322,8 @@ struct GcsServerMocker {
         const ray::rpc::ClientCallback<ray::rpc::PinObjectIDsReply> &callback) override {}
 
     /// DependencyWaiterInterface
-    ray::Status WaitForDirectActorCallArgs(
-        const std::vector<rpc::ObjectReference> &references, int64_t tag) override {
+    ray::Status WaitForActorCallArgs(const std::vector<rpc::ObjectReference> &references,
+                                     int64_t tag) override {
       return ray::Status::OK();
     }
 
diff --git a/src/ray/protobuf/core_worker.proto b/src/ray/protobuf/core_worker.proto
@@ -155,15 +155,15 @@ message PushTaskReply {
   repeated StreamingGeneratorReturnIdInfo streaming_generator_return_ids = 10;
 }
 
-message DirectActorCallArgWaitCompleteRequest {
+message ActorCallArgWaitCompleteRequest {
   // The ID of the worker this message is intended for.
   bytes intended_worker_id = 1;
   // Id used to uniquely identify this request. This is sent back to the core
   // worker to notify the wait has completed.
   int64 tag = 2;
 }
 
-message DirectActorCallArgWaitCompleteReply {}
+message ActorCallArgWaitCompleteReply {}
 
 message GetObjectStatusRequest {
   // The ID of the worker that owns this object. This is also
@@ -460,9 +460,9 @@ service CoreWorkerService {
       returns (RayletNotifyGCSRestartReply);
   // Push a task directly to this worker from another.
   rpc PushTask(PushTaskRequest) returns (PushTaskReply);
-  // Reply from raylet that wait for direct actor call args has completed.
-  rpc DirectActorCallArgWaitComplete(DirectActorCallArgWaitCompleteRequest)
-      returns (DirectActorCallArgWaitCompleteReply);
+  // Reply from raylet that wait for actor call args has completed.
+  rpc ActorCallArgWaitComplete(ActorCallArgWaitCompleteRequest)
+      returns (ActorCallArgWaitCompleteReply);
   // Ask the object's owner about the object's current status.
   rpc GetObjectStatus(GetObjectStatusRequest) returns (GetObjectStatusReply);
   // Wait for the actor's owner to decide that the actor has no references.
diff --git a/src/ray/raylet/format/node_manager.fbs b/src/ray/raylet/format/node_manager.fbs
@@ -63,7 +63,7 @@ enum MessageType:int {
   // remaining.
   WaitReply,
   // Wait for objects asynchronously. The reply will be sent back via gRPC push.
-  WaitForDirectActorCallArgsRequest,
+  WaitForActorCallArgsRequest,
   // Push an error to the relevant driver. This is sent from a worker to the
   // node manager.
   PushErrorRequest,
@@ -234,7 +234,7 @@ table WaitReply {
   remaining: [string];
 }
 
-table WaitForDirectActorCallArgsRequest {
+table WaitForActorCallArgsRequest {
   // List of object ids we'll be waiting on.
   object_ids: [string];
   // The RPC addresses of the workers that own the objects in object_ids.
diff --git a/src/ray/raylet/node_manager.cc b/src/ray/raylet/node_manager.cc
@@ -1279,8 +1279,8 @@ void NodeManager::ProcessClientMessage(const std::shared_ptr<ClientConnection> &
   case protocol::MessageType::WaitRequest: {
     ProcessWaitRequestMessage(client, message_data);
   } break;
-  case protocol::MessageType::WaitForDirectActorCallArgsRequest: {
-    ProcessWaitForDirectActorCallArgsRequestMessage(client, message_data);
+  case protocol::MessageType::WaitForActorCallArgsRequest: {
+    ProcessWaitForActorCallArgsRequestMessage(client, message_data);
   } break;
   case protocol::MessageType::PushErrorRequest: {
     ProcessPushErrorRequestMessage(message_data);
@@ -1872,11 +1872,11 @@ void NodeManager::ProcessWaitRequestMessage(
       });
 }
 
-void NodeManager::ProcessWaitForDirectActorCallArgsRequestMessage(
+void NodeManager::ProcessWaitForActorCallArgsRequestMessage(
     const std::shared_ptr<ClientConnection> &client, const uint8_t *message_data) {
   // Read the data.
   auto message =
-      flatbuffers::GetRoot<protocol::WaitForDirectActorCallArgsRequest>(message_data);
+      flatbuffers::GetRoot<protocol::WaitForActorCallArgsRequest>(message_data);
   std::vector<ObjectID> object_ids = from_flatbuf<ObjectID>(*message->object_ids());
   int64_t tag = message->tag();
   // Resolve any missing objects. This will pull the objects from remote node
@@ -1901,7 +1901,7 @@ void NodeManager::ProcessWaitForDirectActorCallArgsRequestMessage(
         if (!worker) {
           RAY_LOG(ERROR) << "Lost worker for wait request " << client;
         } else {
-          worker->DirectActorCallArgWaitComplete(tag);
+          worker->ActorCallArgWaitComplete(tag);
         }
       });
 }
@@ -2449,13 +2449,12 @@ bool NodeManager::FinishAssignedTask(const std::shared_ptr<WorkerInterface> &wor
 
   if (!spec.IsActorCreationTask()) {
     // Unset the worker's assigned task. We keep the assigned task ID for
-    // direct actor creation calls because this ID is used later if the actor
+    // actor creation calls because this ID is used later if the actor
     // requires objects from plasma.
     worker.AssignTaskId(TaskID::Nil());
     worker.SetOwnerAddress(rpc::Address());
   }
-  // Direct actors will be assigned tasks via the core worker and therefore are
-  // not idle.
+  // Actors will be assigned tasks via the core worker and therefore are not idle.
   return !spec.IsActorCreationTask();
 }
 
diff --git a/src/ray/raylet/node_manager.h b/src/ray/raylet/node_manager.h
@@ -314,8 +314,7 @@ class NodeManager : public rpc::NodeManagerServiceHandler,
   ///
   /// \param worker The worker that finished the task.
   /// \return Whether the worker should be returned to the idle pool. This is
-  /// only false for direct actor creation calls, which should never be
-  /// returned to idle.
+  /// only false for actor creation calls, which should never be returned to idle.
   bool FinishAssignedTask(const std::shared_ptr<WorkerInterface> &worker_ptr);
 
   /// Handle a worker finishing an assigned actor creation task.
@@ -351,13 +350,13 @@ class NodeManager : public rpc::NodeManagerServiceHandler,
   void AsyncResolveObjectsFinish(const std::shared_ptr<ClientConnection> &client,
                                  const TaskID &current_task_id);
 
-  /// Handle a direct call task that is blocked. Note that this callback may
+  /// Handle a task that is blocked. Note that this callback may
   /// arrive after the worker lease has been returned to the node manager.
   ///
   /// \param worker Shared ptr to the worker, or nullptr if lost.
   void HandleDirectCallTaskBlocked(const std::shared_ptr<WorkerInterface> &worker);
 
-  /// Handle a direct call task that is unblocked. Note that this callback may
+  /// Handle a task that is unblocked. Note that this callback may
   /// arrive after the worker lease has been returned to the node manager.
   /// However, it is guaranteed to arrive after DirectCallTaskBlocked.
   ///
@@ -504,12 +503,12 @@ class NodeManager : public rpc::NodeManagerServiceHandler,
   void ProcessWaitRequestMessage(const std::shared_ptr<ClientConnection> &client,
                                  const uint8_t *message_data);
 
-  /// Process client message of WaitForDirectActorCallArgsRequest
+  /// Process client message of WaitForActorCallArgsRequest
   ///
   /// \param client The client that sent the message.
   /// \param message_data A pointer to the message data.
   /// \return Void.
-  void ProcessWaitForDirectActorCallArgsRequestMessage(
+  void ProcessWaitForActorCallArgsRequestMessage(
       const std::shared_ptr<ClientConnection> &client, const uint8_t *message_data);
 
   /// Process client message of PushErrorRequest
@@ -839,7 +838,7 @@ class NodeManager : public rpc::NodeManagerServiceHandler,
   absl::flat_hash_map<NodeID, std::pair<std::string, int32_t>>
       remote_node_manager_addresses_;
 
-  /// Map of workers leased out to direct call clients.
+  /// Map of workers leased out to clients.
   absl::flat_hash_map<WorkerID, std::shared_ptr<WorkerInterface>> leased_workers_;
 
   /// Optional extra information about why the task failed.
diff --git a/src/ray/raylet/test/util.h b/src/ray/raylet/test/util.h
@@ -130,7 +130,7 @@ class MockWorker : public WorkerInterface {
     return address_;
   }
 
-  void DirectActorCallArgWaitComplete(int64_t tag) override {
+  void ActorCallArgWaitComplete(int64_t tag) override {
     RAY_CHECK(false) << "Method unused";
   }
 
diff --git a/src/ray/raylet/worker.cc b/src/ray/raylet/worker.cc
@@ -178,13 +178,13 @@ const std::shared_ptr<ClientConnection> Worker::Connection() const { return conn
 void Worker::SetOwnerAddress(const rpc::Address &address) { owner_address_ = address; }
 const rpc::Address &Worker::GetOwnerAddress() const { return owner_address_; }
 
-void Worker::DirectActorCallArgWaitComplete(int64_t tag) {
+void Worker::ActorCallArgWaitComplete(int64_t tag) {
   RAY_CHECK(port_ > 0);
-  rpc::DirectActorCallArgWaitCompleteRequest request;
+  rpc::ActorCallArgWaitCompleteRequest request;
   request.set_tag(tag);
   request.set_intended_worker_id(worker_id_.Binary());
-  rpc_client_->DirectActorCallArgWaitComplete(
-      request, [](Status status, const rpc::DirectActorCallArgWaitCompleteReply &reply) {
+  rpc_client_->ActorCallArgWaitComplete(
+      request, [](Status status, const rpc::ActorCallArgWaitCompleteReply &reply) {
         if (!status.ok()) {
           RAY_LOG(ERROR) << "Failed to send wait complete: " << status.ToString();
         }
diff --git a/src/ray/raylet/worker.h b/src/ray/raylet/worker.h
@@ -81,7 +81,7 @@ class WorkerInterface {
   virtual void SetOwnerAddress(const rpc::Address &address) = 0;
   virtual const rpc::Address &GetOwnerAddress() const = 0;
 
-  virtual void DirectActorCallArgWaitComplete(int64_t tag) = 0;
+  virtual void ActorCallArgWaitComplete(int64_t tag) = 0;
 
   virtual const BundleID &GetBundleId() const = 0;
   virtual void SetBundleId(const BundleID &bundle_id) = 0;
@@ -192,7 +192,7 @@ class Worker : public WorkerInterface {
   void SetOwnerAddress(const rpc::Address &address);
   const rpc::Address &GetOwnerAddress() const;
 
-  void DirectActorCallArgWaitComplete(int64_t tag);
+  void ActorCallArgWaitComplete(int64_t tag);
 
   const BundleID &GetBundleId() const;
   void SetBundleId(const BundleID &bundle_id);
diff --git a/src/ray/raylet_client/raylet_client.cc b/src/ray/raylet_client/raylet_client.cc
@@ -200,7 +200,7 @@ StatusOr<absl::flat_hash_set<ObjectID>> RayletClient::Wait(
   return result;
 }
 
-Status RayletClient::WaitForDirectActorCallArgs(
+Status RayletClient::WaitForActorCallArgs(
     const std::vector<rpc::ObjectReference> &references, int64_t tag) {
   flatbuffers::FlatBufferBuilder fbb;
   std::vector<ObjectID> object_ids;
@@ -209,10 +209,10 @@ Status RayletClient::WaitForDirectActorCallArgs(
     object_ids.push_back(ObjectID::FromBinary(ref.object_id()));
     owner_addresses.push_back(ref.owner_address());
   }
-  auto message = protocol::CreateWaitForDirectActorCallArgsRequest(
+  auto message = protocol::CreateWaitForActorCallArgsRequest(
       fbb, to_flatbuf(fbb, object_ids), AddressesToFlatbuffer(fbb, owner_addresses), tag);
   fbb.Finish(message);
-  return conn_->WriteMessage(MessageType::WaitForDirectActorCallArgsRequest, &fbb);
+  return conn_->WriteMessage(MessageType::WaitForActorCallArgsRequest, &fbb);
 }
 
 Status RayletClient::PushError(const JobID &job_id,
diff --git a/src/ray/raylet_client/raylet_client.h b/src/ray/raylet_client/raylet_client.h
@@ -166,7 +166,7 @@ class DependencyWaiterInterface {
   /// \param references The objects to wait for.
   /// \param tag Value that will be sent to the core worker via gRPC on completion.
   /// \return ray::Status.
-  virtual ray::Status WaitForDirectActorCallArgs(
+  virtual ray::Status WaitForActorCallArgs(
       const std::vector<rpc::ObjectReference> &references, int64_t tag) = 0;
 
   virtual ~DependencyWaiterInterface(){};
@@ -387,8 +387,8 @@ class RayletClient : public RayletClientInterface {
   /// \param references The objects to wait for.
   /// \param tag Value that will be sent to the core worker via gRPC on completion.
   /// \return ray::Status.
-  ray::Status WaitForDirectActorCallArgs(
-      const std::vector<rpc::ObjectReference> &references, int64_t tag) override;
+  ray::Status WaitForActorCallArgs(const std::vector<rpc::ObjectReference> &references,
+                                   int64_t tag) override;
 
   /// Push an error to the relevant driver.
   ///
diff --git a/src/ray/rpc/worker/core_worker_client.h b/src/ray/rpc/worker/core_worker_client.h
@@ -55,7 +55,7 @@ inline constexpr int64_t kMaxBytesInFlight = 16L * 1024 * 1024;
 /// The base size in bytes per request.
 inline constexpr int64_t kBaseRequestSize = 1024;
 
-// Shared between direct actor and task submitters.
+// Shared between actor and task submitters.
 /* class CoreWorkerClientInterface; */
 
 inline bool operator==(const rpc::Address &lhs, const rpc::Address &rhs) {
@@ -99,14 +99,14 @@ class CoreWorkerClientInterface : public pubsub::SubscriberClientInterface {
                                const ClientCallback<NumPendingTasksReply> &callback,
                                int64_t timeout_ms = -1) {}
 
-  /// Notify a wait has completed for direct actor call arguments.
+  /// Notify a wait has completed for actor call arguments.
   ///
   /// \param[in] request The request message.
   /// \param[in] callback The callback function that handles reply.
   /// \return if the rpc call succeeds
-  virtual void DirectActorCallArgWaitComplete(
-      const DirectActorCallArgWaitCompleteRequest &request,
-      const ClientCallback<DirectActorCallArgWaitCompleteReply> &callback) {}
+  virtual void ActorCallArgWaitComplete(
+      const ActorCallArgWaitCompleteRequest &request,
+      const ClientCallback<ActorCallArgWaitCompleteReply> &callback) {}
 
   /// Ask the owner of an object about the object's current status.
   virtual void GetObjectStatus(const GetObjectStatusRequest &request,
@@ -212,7 +212,7 @@ class CoreWorkerClient : public std::enable_shared_from_this<CoreWorkerClient>,
   }
 
   VOID_RPC_CLIENT_METHOD(CoreWorkerService,
-                         DirectActorCallArgWaitComplete,
+                         ActorCallArgWaitComplete,
                          grpc_client_,
                          /*method_timeout_ms*/ -1,
                          override)
diff --git a/src/ray/rpc/worker/core_worker_server.h b/src/ray/rpc/worker/core_worker_server.h

Original file line number	Diff line number	Diff line change
`@@ -3904,9 +3904,9 @@ void CoreWorker::HandlePushTask(rpc::PushTaskRequest request,`
`3904`	`3904`	`}`
`3905`	`3905`	`}`
`3906`	`3906`
`3907`		`-void CoreWorker::HandleDirectActorCallArgWaitComplete(`
`3908`		`- rpc::DirectActorCallArgWaitCompleteRequest request,`
`3909`		`- rpc::DirectActorCallArgWaitCompleteReply *reply,`
	`3907`	`+void CoreWorker::HandleActorCallArgWaitComplete(`
	`3908`	`+ rpc::ActorCallArgWaitCompleteRequest request,`
	`3909`	`+ rpc::ActorCallArgWaitCompleteReply *reply,`
`3910`	`3910`	`rpc::SendReplyCallback send_reply_callback) {`
`3911`	`3911`	`if (HandleWrongRecipient(WorkerID::FromBinary(request.intended_worker_id()),`
`3912`	`3912`	`send_reply_callback)) {`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ void DependencyWaiterImpl::Wait(const std::vector<rpc::ObjectReference> &depende`
`65`	`65`	`std::function<void()> on_dependencies_available) {`
`66`	`66`	`auto tag = next_request_id_++;`
`67`	`67`	`requests_[tag] = on_dependencies_available;`
`68`		`- RAY_CHECK_OK(dependency_client_.WaitForDirectActorCallArgs(dependencies, tag));`
	`68`	`+ RAY_CHECK_OK(dependency_client_.WaitForActorCallArgs(dependencies, tag));`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`/// Fulfills the callback stored by Wait().`
Original file line number	Diff line number	Diff line change
`@@ -322,8 +322,8 @@ struct GcsServerMocker {`
`322`	`322`	`const ray::rpc::ClientCallback<ray::rpc::PinObjectIDsReply> &callback) override {}`
`323`	`323`
`324`	`324`	`/// DependencyWaiterInterface`
`325`		`- ray::Status WaitForDirectActorCallArgs(`
`326`		`- const std::vector<rpc::ObjectReference> &references, int64_t tag) override {`
	`325`	`+ ray::Status WaitForActorCallArgs(const std::vector<rpc::ObjectReference> &references,`
	`326`	`+ int64_t tag) override {`
`327`	`327`	`return ray::Status::OK();`
`328`	`328`	`}`
`329`	`329`