[C++ worker] Ray actor task for RAY_REMOTE (ray-project#15039)

Author: qicosmos

cpp/example/example.cc

@@ -20,6 +20,10 @@ class Counter {
   int count;
 
   Counter(int init) { count = init; }
+  template <typename... Args>
+  static Counter *GenericFactoryCreate(Args... args) {
+    return FactoryCreate(args...);
+  }
   static Counter *FactoryCreate() { return new Counter(0); }
   static Counter *FactoryCreate(int init) { return new Counter(init); }
   static Counter *FactoryCreate(int init1, int init2) {
@@ -73,20 +77,21 @@ int main(int argc, char **argv) {
   std::cout << "task_result2 = " << task_result2 << std::endl;
 
   /// actor task without args
-  ActorHandle<Counter> actor1 = Ray::Actor(Counter::FactoryCreate).Remote();
+  ActorHandle<Counter> actor1 = Ray::Actor(Counter::GenericFactoryCreate<>).Remote();
   auto actor_object1 = actor1.Task(&Counter::Plus1).Remote();
   int actor_result1 = *(Ray::Get(actor_object1));
   std::cout << "actor_result1 = " << actor_result1 << std::endl;
 
   /// actor task with args
-  ActorHandle<Counter> actor2 = Ray::Actor(Counter::FactoryCreate, 1).Remote();
-  auto actor_object2 = actor2.Task(&Counter::Add, 5).Remote();
+  ActorHandle<Counter> actor2 = Ray::Actor(Counter::GenericFactoryCreate<int>).Remote(1);
+  auto actor_object2 = actor2.Task(&Counter::Add).Remote(5);
   int actor_result2 = *(Ray::Get(actor_object2));
   std::cout << "actor_result2 = " << actor_result2 << std::endl;
 
   /// actor task with args which pass by reference
-  ActorHandle<Counter> actor3 = Ray::Actor(Counter::FactoryCreate, 6, 0).Remote();
-  auto actor_object3 = actor3.Task(&Counter::Add, actor_object2).Remote();
+  ActorHandle<Counter> actor3 =
+      Ray::Actor(Counter::GenericFactoryCreate<int, int>).Remote(6, 0);
+  auto actor_object3 = actor3.Task(&Counter::Add).Remote(actor_object2);
   int actor_result3 = *(Ray::Get(actor_object3));
   std::cout << "actor_result3 = " << actor_result3 << std::endl;
 
@@ -107,17 +112,18 @@ int main(int argc, char **argv) {
             << std::endl;
 
   /// create actor and actor function remote call with args passed by value
-  ActorHandle<Counter> actor4 = Ray::Actor(Counter::FactoryCreate, 10).Remote();
-  auto r10 = actor4.Task(&Counter::Add, 8).Remote();
+  ActorHandle<Counter> actor4 = Ray::Actor(Counter::GenericFactoryCreate<int>).Remote(10);
+  auto r10 = actor4.Task(&Counter::Add).Remote(8);
   int actor_result4 = *(Ray::Get(r10));
   std::cout << "actor_result4 = " << actor_result4 << std::endl;
 
   /// create actor and task function remote call with args passed by reference
-  ActorHandle<Counter> actor5 = Ray::Actor(Counter::FactoryCreate, r10, 0).Remote();
-  auto r11 = actor5.Task(&Counter::Add, r0).Remote();
-  auto r12 = actor5.Task(&Counter::Add, r11).Remote();
-  auto r13 = actor5.Task(&Counter::Add, r10).Remote();
-  auto r14 = actor5.Task(&Counter::Add, r13).Remote();
+  ActorHandle<Counter> actor5 =
+      Ray::Actor(Counter::GenericFactoryCreate<int, int>).Remote(r10, 0);
+  auto r11 = actor5.Task(&Counter::Add).Remote(r0);
+  auto r12 = actor5.Task(&Counter::Add).Remote(r11);
+  auto r13 = actor5.Task(&Counter::Add).Remote(r10);
+  auto r14 = actor5.Task(&Counter::Add).Remote(r13);
   auto r15 = Ray::Task(Plus).Remote(r0, r11);
   auto r16 = Ray::Task(Plus1).Remote(r15);
   int result12 = *(Ray::Get(r12));

cpp/include/ray/api.h

@@ -79,42 +79,23 @@ class Ray {
   /// \param[in] args The function arguments passed by a value or ObjectRef.
   /// \return TaskCaller.
   template <typename F>
-  static TaskCaller<boost::callable_traits::return_type_t<F>> Task(F func);
+  static TaskCaller<F> Task(F func);
 
   /// Generic version of creating an actor
   /// It is used for creating an actor, such as: ActorCreator<Counter> creator =
-  /// Ray::Actor(Counter::FactoryCreate, 1).
+  /// Ray::Actor(Counter::FactoryCreate<int>).Remote(1);
   template <typename ActorType, typename... Args>
-  static ActorCreator<ActorType> Actor(
-      CreateActorFunc<ActorType, typename FilterArgType<Args>::type...> create_func,
-      Args... args);
-
-/// TODO: The bellow specific version of creating an actor will be replaced with generic
-/// version later.
-#include <ray/api/generated/create_funcs.generated.h>
-
-#include "api/generated/create_actors.generated.h"
+  static ActorCreator<ActorType> Actor(CreateActorFunc<ActorType, Args...> create_func);
 
  private:
   static std::once_flag is_inited_;
 
-  template <typename ReturnType, typename FuncType>
-  static TaskCaller<ReturnType> TaskInternal(FuncType &func);
+  template <typename FuncType>
+  static TaskCaller<FuncType> TaskInternal(FuncType &func);
 
-  template <typename ActorType, typename FuncType, typename ExecFuncType,
-            typename... ArgTypes>
+  template <typename ActorType, typename FuncType, typename ExecFuncType>
   static ActorCreator<ActorType> CreateActorInternal(FuncType &func,
-                                                     ExecFuncType &exec_func,
-                                                     ArgTypes &... args);
-
-  /// Include the `Call` methods for calling actor methods.
-  /// Used by ActorHandle to implement .Call()
-  /// It is called by ActorHandle: Ray::Task(&Counter::Add, counter/*instance of
-  /// Counter*/, 1);
-  template <typename ReturnType, typename ActorType, typename... Args>
-  static ActorTaskCaller<ReturnType> Task(
-      ActorFunc<ActorType, ReturnType, typename FilterArgType<Args>::type...> actor_func,
-      ActorHandle<ActorType> &actor, Args... args);
+                                                     ExecFuncType &exec_func);
 };
 
 }  // namespace api
@@ -170,8 +151,8 @@ inline WaitResult Ray::Wait(const std::vector<ObjectID> &ids, int num_objects,
   return ray::internal::RayRuntime()->Wait(ids, num_objects, timeout_ms);
 }
 
-template <typename ReturnType, typename FuncType>
-inline TaskCaller<ReturnType> Ray::TaskInternal(FuncType &func) {
+template <typename FuncType>
+inline TaskCaller<FuncType> Ray::TaskInternal(FuncType &func) {
   RemoteFunctionPtrHolder ptr{};
   ptr.function_pointer = reinterpret_cast<uintptr_t>(func);
   if (ray::api::RayConfig::GetInstance()->use_ray_remote) {
@@ -182,55 +163,42 @@ inline TaskCaller<ReturnType> Ray::TaskInternal(FuncType &func) {
     }
     ptr.function_name = std::move(function_name);
   }
-  return TaskCaller<ReturnType>(ray::internal::RayRuntime().get(), ptr);
+  return TaskCaller<FuncType>(ray::internal::RayRuntime().get(), ptr);
 }
 
-template <typename ActorType, typename FuncType, typename ExecFuncType,
-          typename... ArgTypes>
+template <typename ActorType, typename FuncType, typename ExecFuncType>
 inline ActorCreator<ActorType> Ray::CreateActorInternal(FuncType &create_func,
-                                                        ExecFuncType &exec_func,
-                                                        ArgTypes &... args) {
-  std::vector<std::unique_ptr<::ray::TaskArg>> task_args;
-  Arguments::WrapArgs(&task_args, args...);
-  RemoteFunctionPtrHolder ptr;
-  ptr.function_pointer = reinterpret_cast<uintptr_t>(create_func);
-  ptr.exec_function_pointer = reinterpret_cast<uintptr_t>(exec_func);
-  return ActorCreator<ActorType>(ray::internal::RayRuntime().get(), ptr,
-                                 std::move(task_args));
+                                                        ExecFuncType &exec_func) {
+  RemoteFunctionPtrHolder ptr{};
+  if (ray::api::RayConfig::GetInstance()->use_ray_remote) {
+    auto function_name =
+        ray::internal::FunctionManager::Instance().GetFunctionName(create_func);
+    if (function_name.empty()) {
+      throw RayException(
+          "Function not found. Please use RAY_REMOTE to register this function.");
+    }
+
+    ptr.function_name = std::move(function_name);
+  } else {
+    ptr.function_pointer = reinterpret_cast<uintptr_t>(create_func);
+    ptr.exec_function_pointer = reinterpret_cast<uintptr_t>(exec_func);
+  }
+
+  return ActorCreator<ActorType>(ray::internal::RayRuntime().get(), ptr);
 }
 
 /// Normal task.
 template <typename F>
-TaskCaller<boost::callable_traits::return_type_t<F>> Ray::Task(F func) {
-  using ReturnType = boost::callable_traits::return_type_t<F>;
-
-  return TaskInternal<ReturnType>(func);
+TaskCaller<F> Ray::Task(F func) {
+  return TaskInternal<F>(func);
 }
 
-/// Generic version of creating an actor.
+/// Creating an actor.
 template <typename ActorType, typename... Args>
-ActorCreator<ActorType> Ray::Actor(
-    CreateActorFunc<ActorType, typename FilterArgType<Args>::type...> create_func,
-    Args... args) {
+ActorCreator<ActorType> Ray::Actor(CreateActorFunc<ActorType, Args...> create_func) {
   return CreateActorInternal<ActorType>(
       create_func,
-      CreateActorExecFunction<ActorType *, typename FilterArgType<Args>::type...>,
-      args...);
-}
-
-/// TODO: The bellow specific version of creating an actor will be replaced with generic
-/// version later.
-#include <ray/api/generated/create_actors_impl.generated.h>
-
-/// Actor task.
-template <typename ReturnType, typename ActorType, typename... Args>
-ActorTaskCaller<ReturnType> Ray::Task(
-    ActorFunc<ActorType, ReturnType, typename FilterArgType<Args>::type...> actor_func,
-    ActorHandle<ActorType> &actor, Args... args) {
-  return CallActorInternal<ReturnType, ActorType>(
-      actor_func,
-      ActorExecFunction<ReturnType, ActorType, typename FilterArgType<Args>::type...>,
-      actor, args...);
+      CreateActorExecFunction<ActorType *, typename FilterArgType<Args>::type...>);
 }
 
 }  // namespace api

cpp/include/ray/api/actor_creator.h

@@ -12,10 +12,11 @@ class ActorCreator {
  public:
   ActorCreator();
 
-  ActorCreator(RayRuntime *runtime, RemoteFunctionPtrHolder ptr,
-               std::vector<std::unique_ptr<::ray::TaskArg>> &&args);
+  ActorCreator(RayRuntime *runtime, RemoteFunctionPtrHolder ptr)
+      : runtime_(runtime), ptr_(ptr) {}
 
-  ActorHandle<ActorType> Remote();
+  template <typename... Args>
+  ActorHandle<ActorType> Remote(Args... args);
 
  private:
   RayRuntime *runtime_;
@@ -29,12 +30,9 @@ template <typename ActorType>
 ActorCreator<ActorType>::ActorCreator() {}
 
 template <typename ActorType>
-ActorCreator<ActorType>::ActorCreator(RayRuntime *runtime, RemoteFunctionPtrHolder ptr,
-                                      std::vector<std::unique_ptr<::ray::TaskArg>> &&args)
-    : runtime_(runtime), ptr_(ptr), args_(std::move(args)) {}
-
-template <typename ActorType>
-ActorHandle<ActorType> ActorCreator<ActorType>::Remote() {
+template <typename... Args>
+ActorHandle<ActorType> ActorCreator<ActorType>::Remote(Args... args) {
+  Arguments::WrapArgs(&args_, args...);
   auto returned_actor_id = runtime_->CreateActor(ptr_, args_);
   return ActorHandle<ActorType>(returned_actor_id);
 }

cpp/include/ray/api/actor_handle.h

@@ -11,16 +11,6 @@
 namespace ray {
 namespace api {
 
-template <typename T>
-struct FilterArgType {
-  using type = T;
-};
-
-template <typename T>
-struct FilterArgType<ObjectRef<T>> {
-  using type = T;
-};
-
 template <typename ActorType, typename ReturnType, typename... Args>
 using ActorFunc = ReturnType (ActorType::*)(Args...);
 
@@ -39,11 +29,8 @@ class ActorHandle {
   const ActorID &ID() const;
 
   /// Include the `Call` methods for calling remote functions.
-
-  template <typename ReturnType, typename... Args>
-  ActorTaskCaller<ReturnType> Task(
-      ActorFunc<ActorType, ReturnType, typename FilterArgType<Args>::type...> actor_func,
-      Args... args);
+  template <typename F>
+  ActorTaskCaller<F> Task(F actor_func);
 
   /// Make ActorHandle serializable
   MSGPACK_DEFINE(id_);
@@ -53,22 +40,6 @@ class ActorHandle {
 };
 
 // ---------- implementation ----------
-template <typename ReturnType, typename ActorType, typename FuncType,
-          typename ExecFuncType, typename... ArgTypes>
-inline ActorTaskCaller<ReturnType> CallActorInternal(FuncType &actor_func,
-                                                     ExecFuncType &exec_func,
-                                                     ActorHandle<ActorType> &actor,
-                                                     ArgTypes &... args) {
-  std::vector<std::unique_ptr<::ray::TaskArg>> task_args;
-  Arguments::WrapArgs(&task_args, args...);
-  RemoteFunctionPtrHolder ptr;
-  MemberFunctionPtrHolder holder = *(MemberFunctionPtrHolder *)(&actor_func);
-  ptr.function_pointer = reinterpret_cast<uintptr_t>(holder.value[0]);
-  ptr.exec_function_pointer = reinterpret_cast<uintptr_t>(exec_func);
-  return ActorTaskCaller<ReturnType>(internal::RayRuntime().get(), actor.ID(), ptr,
-                                     std::move(task_args));
-}
-
 template <typename ActorType>
 ActorHandle<ActorType>::ActorHandle() {}
 
@@ -83,14 +54,23 @@ const ActorID &ActorHandle<ActorType>::ID() const {
 }
 
 template <typename ActorType>
-template <typename ReturnType, typename... Args>
-ActorTaskCaller<ReturnType> ActorHandle<ActorType>::Task(
-    ActorFunc<ActorType, ReturnType, typename FilterArgType<Args>::type...> actor_func,
-    Args... args) {
-  return CallActorInternal<ReturnType, ActorType>(
-      actor_func,
-      ActorExecFunction<ReturnType, ActorType, typename FilterArgType<Args>::type...>,
-      *this, args...);
+template <typename F>
+ActorTaskCaller<F> ActorHandle<ActorType>::Task(F actor_func) {
+  RemoteFunctionPtrHolder ptr{};
+  if (ray::api::RayConfig::GetInstance()->use_ray_remote) {
+    auto function_name =
+        ray::internal::FunctionManager::Instance().GetFunctionName(actor_func);
+    if (function_name.empty()) {
+      throw RayException(
+          "Function not found. Please use RAY_REMOTE to register this function.");
+    }
+    ptr.function_name = std::move(function_name);
+    return ActorTaskCaller<F>(internal::RayRuntime().get(), id_, ptr);
+  }
+
+  MemberFunctionPtrHolder holder = *(MemberFunctionPtrHolder *)(&actor_func);
+  ptr.function_pointer = reinterpret_cast<uintptr_t>(holder.value[0]);
+  return ActorTaskCaller<F>(internal::RayRuntime().get(), id_, ptr);
 }
 
 }  // namespace api

cpp/include/ray/api/actor_task_caller.h

@@ -1,21 +1,29 @@
 
 #pragma once
 
+#include <ray/api/arguments.h>
+#include <ray/api/exec_funcs.h>
 #include <ray/api/object_ref.h>
+#include <ray/api/static_check.h>
 #include "ray/core.h"
 
 namespace ray {
 namespace api {
 
-template <typename ReturnType>
+template <typename F>
 class ActorTaskCaller {
  public:
-  ActorTaskCaller();
+  ActorTaskCaller() = default;
 
   ActorTaskCaller(RayRuntime *runtime, ActorID id, RemoteFunctionPtrHolder ptr,
-                  std::vector<std::unique_ptr<::ray::TaskArg>> &&args);
+                  std::vector<std::unique_ptr<::ray::TaskArg>> &&args)
+      : runtime_(runtime), id_(id), ptr_(ptr), args_(std::move(args)) {}
 
-  ObjectRef<ReturnType> Remote();
+  ActorTaskCaller(RayRuntime *runtime, ActorID id, RemoteFunctionPtrHolder ptr)
+      : runtime_(runtime), id_(id), ptr_(ptr) {}
+
+  template <typename... Args>
+  ObjectRef<boost::callable_traits::return_type_t<F>> Remote(Args... args);
 
  private:
   RayRuntime *runtime_;
@@ -26,19 +34,23 @@ class ActorTaskCaller {
 
 // ---------- implementation ----------
 
-template <typename ReturnType>
-ActorTaskCaller<ReturnType>::ActorTaskCaller() {}
-
-template <typename ReturnType>
-ActorTaskCaller<ReturnType>::ActorTaskCaller(
-    RayRuntime *runtime, ActorID id, RemoteFunctionPtrHolder ptr,
-    std::vector<std::unique_ptr<::ray::TaskArg>> &&args)
-    : runtime_(runtime), id_(id), ptr_(ptr), args_(std::move(args)) {}
-
-template <typename ReturnType>
-ObjectRef<ReturnType> ActorTaskCaller<ReturnType>::Remote() {
+template <typename F>
+template <typename... Args>
+ObjectRef<boost::callable_traits::return_type_t<F>> ActorTaskCaller<F>::Remote(
+    Args... args) {
+  using ActorType = boost::callable_traits::class_of_t<F>;
+  using ReturnType = boost::callable_traits::return_type_t<F>;
+  StaticCheck<F, Args...>();
+  if (!ray::api::RayConfig::GetInstance()->use_ray_remote) {
+    auto exe_func =
+        ActorExecFunction<ReturnType, ActorType, typename FilterArgType<Args>::type...>;
+    ptr_.exec_function_pointer = reinterpret_cast<uintptr_t>(exe_func);
+  }
+
+  Arguments::WrapArgs(&args_, args...);
   auto returned_object_id = runtime_->CallActor(ptr_, id_, args_);
   return ObjectRef<ReturnType>(returned_object_id);
 }
+
 }  // namespace api
 }  // namespace ray