From 3b0a2c4197580bb24f8a7b8f249e3a9ca47dc850 Mon Sep 17 00:00:00 2001 From: Hao Chen Date: Mon, 3 Sep 2018 02:51:16 +0800 Subject: [PATCH] [Java] improve Java API module (#2783) API module (`ray/java/api` dir) includes all public APIs provided by Ray, it should be the only module that normal Ray users need to face. The purpose of this PR to first improve the code quality of the API module. Subsequent PRs will improve other modules later. The changes of this PR include the following aspects: 1) Only keep interfaces in api module, to hide implementation details from users and fix circular dependencies among modules. 2) Document everything in the api module. 3) Improve naming. 4) Add more tests for API. 5) Also fix/improve related code in other modules. 6) Remove some unused code. (Apologize for posting such a large PR. Java worker code has been lack of maintenance for a while. There're a lot of code quality issues that need to be fixed. We plan to use a couple of large PRs to address them. After that, future changes will come in small PRs.) --- java/api/pom.xml | 8 - java/api/src/main/java/org/ray/api/Ray.java | 159 ++-- .../src/main/java/org/ray/api/RayActor.java | 85 +- .../api/src/main/java/org/ray/api/RayApi.java | 60 -- .../src/main/java/org/ray/api/RayCall.java | 772 ++++++++++++++++++ .../main/java/org/ray/api/RayDisabled.java | 5 - .../src/main/java/org/ray/api/RayObject.java | 40 +- .../src/main/java/org/ray/api/RayRemote.java | 20 - .../src/main/java/org/ray/api/RayService.java | 9 - java/api/src/main/java/org/ray/api/Rpc.java | 390 --------- .../src/main/java/org/ray/api/TaskStatus.java | 13 - .../src/main/java/org/ray/api/WaitResult.java | 29 +- .../org/ray/api/annotation/RayRemote.java | 24 + .../org/ray/api/annotation/ResourceItem.java | 28 + .../org/ray/api/exception/RayException.java | 15 + .../ray/api/{funcs => function}/RayFunc.java | 2 +- .../ray/api/{funcs => function}/RayFunc0.java | 5 +- .../ray/api/{funcs => function}/RayFunc1.java | 5 +- .../ray/api/{funcs => function}/RayFunc2.java | 5 +- .../ray/api/{funcs => function}/RayFunc3.java | 5 +- .../ray/api/{funcs => function}/RayFunc4.java | 5 +- .../ray/api/{funcs => function}/RayFunc5.java | 5 +- .../ray/api/{funcs => function}/RayFunc6.java | 5 +- .../api/{UniqueID.java => id/UniqueId.java} | 69 +- .../org/ray/api/internal/RayConnector.java | 26 - .../api/runtime/DefaultRayRuntimeFactory.java | 22 + .../java/org/ray/api/runtime/RayRuntime.java | 81 ++ .../ray/api/runtime/RayRuntimeFactory.java | 9 + java/checkstyle-suppressions.xml | 7 +- .../cli/src/main/java/org/ray/cli/RayCli.java | 11 +- java/common/pom.xml | 80 +- .../java/org/ray/util/RemoteBiFunction.java | 10 - .../java/org/ray/util/RemoteFunction.java | 9 - .../main/java/org/ray/util/ResourceItem.java | 7 - .../main/java/org/ray/util/ResourceUtil.java | 1 + .../org/ray/util/config/ConfigReader.java | 3 +- .../ray/util/generator/RayCallGenerator.java | 113 +++ ...csGenerator.java => RayFuncGenerator.java} | 16 +- .../org/ray/util/generator/RpcGenerator.java | 77 -- java/runtime-common/pom.xml | 5 + ...ayRuntime.java => AbstractRayRuntime.java} | 314 ++++--- .../java/org/ray/core/ArgumentsBuilder.java | 116 +-- .../java/org/ray/core/InvocationExecutor.java | 12 +- .../org/ray/core/LocalFunctionManager.java | 22 +- .../main/java/org/ray/core/RayActorImpl.java | 89 ++ .../main/java/org/ray/core/RayObjectImpl.java | 26 + .../java/org/ray/core/UniqueIdHelper.java | 30 +- .../src/main/java/org/ray/core/Worker.java | 97 +-- .../main/java/org/ray/core/WorkerContext.java | 16 +- .../org/ray/core/model/RayParameters.java | 4 +- .../java/org/ray/spi/LocalSchedulerLink.java | 10 +- .../java/org/ray/spi/LocalSchedulerProxy.java | 136 --- .../org/ray/spi/NopRemoteFunctionManager.java | 20 +- .../java/org/ray/spi/ObjectStoreProxy.java | 29 +- .../org/ray/spi/RemoteFunctionManager.java | 18 +- .../java/org/ray/spi/model/FunctionArg.java | 14 +- .../org/ray/spi/model/RayActorMethods.java | 14 +- .../java/org/ray/spi/model/RayInvocation.java | 56 -- .../java/org/ray/spi/model/RayMethod.java | 12 +- .../org/ray/spi/model/RayTaskMethods.java | 10 +- .../main/java/org/ray/spi/model/TaskSpec.java | 43 +- .../java/org/ray/core/impl/RayDevRuntime.java | 66 +- .../org/ray/spi/impl/MockLocalScheduler.java | 30 +- .../org/ray/spi/impl/MockObjectStore.java | 18 +- .../org/ray/core/impl/RayNativeRuntime.java | 86 +- .../main/java/org/ray/runner/RunManager.java | 20 +- .../org/ray/runner/worker/DefaultDriver.java | 10 +- .../org/ray/runner/worker/DefaultWorker.java | 8 +- .../spi/impl/DefaultLocalSchedulerClient.java | 84 +- .../spi/impl/NativeRemoteFunctionManager.java | 30 +- .../spi/impl/RayletStateStoreProxyImpl.java | 4 +- .../org/ray/api/benchmark/ActorPressTest.java | 8 +- .../ray/api/benchmark/MaxPressureTest.java | 2 +- .../benchmark/RateLimiterPressureTest.java | 2 +- .../ray/api/benchmark/RayBenchmarkTest.java | 2 +- .../ray/api/benchmark/SingleLatencyTest.java | 2 +- .../main/java/org/ray/api/test/ActorTest.java | 171 +--- .../main/java/org/ray/api/test/EchoTest.java | 2 +- .../java/org/ray/api/test/HelloWorldTest.java | 2 +- .../org/ray/api/test/LambdaUtilsTest.java | 6 +- .../java/org/ray/api/test/MethodIdTest.java | 2 +- .../org/ray/api/test/ObjectStoreTest.java | 32 + .../org/ray/api/test/RayActorMethodsTest.java | 30 +- .../java/org/ray/api/test/RayCallTest.java | 133 +++ .../java/org/ray/api/test/RayMethodsTest.java | 11 +- .../org/ray/api/test/RemoteLambdaTest.java | 41 - .../ray/api/test/ResourcesManagementTest.java | 22 +- .../main/java/org/ray/api/test/RpcTest.java | 39 - .../java/org/ray/api/test/TestListener.java | 5 +- .../main/java/org/ray/api/test/TypesTest.java | 82 -- .../java/org/ray/api/test/UniqueIdTest.java | 24 +- .../main/java/org/ray/api/test/WaitTest.java | 27 +- .../java/org/ray/api/test/WordCountTest.java | 2 +- .../java/org/ray/exercise/Exercise01.java | 5 +- .../java/org/ray/exercise/Exercise02.java | 5 +- .../java/org/ray/exercise/Exercise03.java | 5 +- .../java/org/ray/exercise/Exercise04.java | 35 +- .../java/org/ray/exercise/Exercise05.java | 9 +- 98 files changed, 2232 insertions(+), 2158 deletions(-) delete mode 100644 java/api/src/main/java/org/ray/api/RayApi.java create mode 100644 java/api/src/main/java/org/ray/api/RayCall.java delete mode 100644 java/api/src/main/java/org/ray/api/RayDisabled.java delete mode 100644 java/api/src/main/java/org/ray/api/RayRemote.java delete mode 100644 java/api/src/main/java/org/ray/api/RayService.java delete mode 100644 java/api/src/main/java/org/ray/api/Rpc.java delete mode 100644 java/api/src/main/java/org/ray/api/TaskStatus.java create mode 100644 java/api/src/main/java/org/ray/api/annotation/RayRemote.java create mode 100644 java/api/src/main/java/org/ray/api/annotation/ResourceItem.java create mode 100644 java/api/src/main/java/org/ray/api/exception/RayException.java rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc.java (81%) rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc0.java (54%) rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc1.java (56%) rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc2.java (58%) rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc3.java (59%) rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc4.java (61%) rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc5.java (62%) rename java/api/src/main/java/org/ray/api/{funcs => function}/RayFunc6.java (64%) rename java/api/src/main/java/org/ray/api/{UniqueID.java => id/UniqueId.java} (54%) delete mode 100644 java/api/src/main/java/org/ray/api/internal/RayConnector.java create mode 100644 java/api/src/main/java/org/ray/api/runtime/DefaultRayRuntimeFactory.java create mode 100644 java/api/src/main/java/org/ray/api/runtime/RayRuntime.java create mode 100644 java/api/src/main/java/org/ray/api/runtime/RayRuntimeFactory.java delete mode 100644 java/common/src/main/java/org/ray/util/RemoteBiFunction.java delete mode 100644 java/common/src/main/java/org/ray/util/RemoteFunction.java delete mode 100644 java/common/src/main/java/org/ray/util/ResourceItem.java create mode 100644 java/common/src/main/java/org/ray/util/generator/RayCallGenerator.java rename java/common/src/main/java/org/ray/util/generator/{FuncsGenerator.java => RayFuncGenerator.java} (66%) delete mode 100644 java/common/src/main/java/org/ray/util/generator/RpcGenerator.java rename java/runtime-common/src/main/java/org/ray/core/{RayRuntime.java => AbstractRayRuntime.java} (51%) create mode 100644 java/runtime-common/src/main/java/org/ray/core/RayActorImpl.java create mode 100644 java/runtime-common/src/main/java/org/ray/core/RayObjectImpl.java delete mode 100644 java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerProxy.java delete mode 100644 java/runtime-common/src/main/java/org/ray/spi/model/RayInvocation.java create mode 100644 java/test/src/main/java/org/ray/api/test/ObjectStoreTest.java create mode 100644 java/test/src/main/java/org/ray/api/test/RayCallTest.java delete mode 100644 java/test/src/main/java/org/ray/api/test/RemoteLambdaTest.java delete mode 100644 java/test/src/main/java/org/ray/api/test/RpcTest.java delete mode 100644 java/test/src/main/java/org/ray/api/test/TypesTest.java diff --git a/java/api/pom.xml b/java/api/pom.xml index 9c04aadf5..cdd550eba 100644 --- a/java/api/pom.xml +++ b/java/api/pom.xml @@ -20,19 +20,11 @@ - - org.ray - ray-common - ${project.version} - - - commons-cli commons-cli - org.apache.commons commons-lang3 diff --git a/java/api/src/main/java/org/ray/api/Ray.java b/java/api/src/main/java/org/ray/api/Ray.java index 74fca1ce3..648259edd 100644 --- a/java/api/src/main/java/org/ray/api/Ray.java +++ b/java/api/src/main/java/org/ray/api/Ray.java @@ -1,99 +1,124 @@ package org.ray.api; -import com.google.common.collect.ImmutableList; import java.util.List; -import org.ray.api.internal.RayConnector; -import org.ray.util.exception.TaskExecutionException; -import org.ray.util.logger.RayLog; +import org.ray.api.id.UniqueId; +import org.ray.api.runtime.DefaultRayRuntimeFactory; +import org.ray.api.runtime.RayRuntime; +import org.ray.api.runtime.RayRuntimeFactory; /** - * Ray API. + * This class contains all public APIs of Ray. */ -public final class Ray extends Rpc { +public final class Ray extends RayCall { - private static RayApi impl = null; + private static RayRuntime runtime = null; /** - * initialize the current worker or the single-box cluster. + * Initialize Ray runtime with the default runtime implementation. */ public static void init() { - if (impl == null) { - impl = RayConnector.run(); + init(new DefaultRayRuntimeFactory()); + } + + /** + * Initialize Ray runtime with a custom runtime implementation. + * + * @param factory A factory that produces the runtime instance. + */ + public static synchronized void init(RayRuntimeFactory factory) { + if (runtime == null) { + runtime = factory.createRayRuntime(); } } /** - * Put obj into object store. + * Shutdown Ray runtime. + */ + public static void shutdown() { + runtime.shutdown(); + } + + /** + * Store an object in the object store. + * + * @param obj The Java object to be stored. + * @return A RayObject instance that represents the in-store object. */ public static RayObject put(T obj) { - return impl.put(obj); - } - - public static RayObject put(T obj, TMT metadata) { - return impl.put(obj, metadata); + return runtime.put(obj); } /** - * Get obj(s) from object store. - */ - static T get(UniqueID objectId) throws TaskExecutionException { - return impl.get(objectId); - } - - static List get(List objectIds) throws TaskExecutionException { - return impl.get(objectIds); - } - - static T getMeta(UniqueID objectId) throws TaskExecutionException { - return impl.getMeta(objectId); - } - - static List getMeta(List objectIds) throws TaskExecutionException { - return impl.getMeta(objectIds); - } - - /** - * wait until timeout or enough RayObject are ready. + * Get an object from the object store. * - * @param waitfor wait for who - * @param numReturns how many of ready is enough - * @param timeoutMilliseconds in millisecond + * @param objectId The ID of the object to get. + * @return The Java object. */ - public static WaitResult wait(List> waitfor, int numReturns, - int timeoutMilliseconds) { - return impl.wait(waitfor, numReturns, timeoutMilliseconds); - } - - public static WaitResult wait(List> waitfor, int numReturns) { - return impl.wait(waitfor, numReturns, Integer.MAX_VALUE); - } - - public static WaitResult wait(List> waitfor) { - return impl.wait(waitfor, waitfor.size(), Integer.MAX_VALUE); + public static T get(UniqueId objectId) { + return runtime.get(objectId); } /** - * create actor object. + * Get a list of objects from the object store. + * + * @param objectIds The list of object IDs. + * @return A list of Java objects. */ - public static RayActor create(Class cls) { - try { - if (cls.getConstructor() == null) { - System.err.println("class " + cls.getName() - + " does not (actors must) have a constructor with no arguments"); - RayLog.core.error("class {} does not (actors must) have a constructor with no arguments", - cls.getName()); - } - } catch (Exception e) { - System.exit(1); - return null; - } - return impl.create(cls); + public static List get(List objectIds) { + return runtime.get(objectIds); } /** - * get underlying runtime. + * Wait for a list of RayObjects to be locally available, + * until specified number of objects are ready, or specified timeout has passed. + * + * @param waitList A list of RayObject to wait for. + * @param numReturns The number of objects that should be returned. + * @param timeoutMs The maximum time in milliseconds to wait before returning. + * @return Two lists, one containing locally available objects, one containing the rest. */ - static RayApi internal() { - return impl; + public static WaitResult wait(List> waitList, int numReturns, + int timeoutMs) { + return runtime.wait(waitList, numReturns, timeoutMs); + } + + /** + * A convenient helper method for Ray.wait. It will wait infinitely until + * specified number of objects are locally available. + * + * @param waitList A list of RayObject to wait for. + * @param numReturns The number of objects that should be returned. + * @return Two lists, one containing locally available objects, one containing the rest. + */ + public static WaitResult wait(List> waitList, int numReturns) { + return runtime.wait(waitList, numReturns, Integer.MAX_VALUE); + } + + /** + * A convenient helper method for Ray.wait. It will wait infinitely until + * all objects are locally available. + * + * @param waitList A list of RayObject to wait for. + * @return Two lists, one containing locally available objects, one containing the rest. + */ + public static WaitResult wait(List> waitList) { + return runtime.wait(waitList, waitList.size(), Integer.MAX_VALUE); + } + + /** + * Create an actor on a remote node. + * + * @param actorClass the class of the actor to be created. + * @return A handle to the newly created actor. + */ + public static RayActor createActor(Class actorClass) { + return runtime.createActor(actorClass); + } + + /** + * Get the underlying runtime instance. + */ + static RayRuntime internal() { + return runtime; } } diff --git a/java/api/src/main/java/org/ray/api/RayActor.java b/java/api/src/main/java/org/ray/api/RayActor.java index c9eb9df82..0295e43f9 100644 --- a/java/api/src/main/java/org/ray/api/RayActor.java +++ b/java/api/src/main/java/org/ray/api/RayActor.java @@ -1,87 +1,20 @@ package org.ray.api; -import java.io.Externalizable; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; -import org.ray.util.Sha1Digestor; +import org.ray.api.id.UniqueId; /** - * Ray actor abstraction. + * A handle to an actor. + * @param The type of the concrete actor class. */ -public class RayActor extends RayObject implements Externalizable { - public static final RayActor NIL = new RayActor<>(UniqueID.NIL, UniqueID.NIL); - private static final long serialVersionUID = 1877485807405645036L; - - private int taskCounter = 0; - - private UniqueID taskCursor = null; - - private UniqueID actorHandleId = UniqueID.NIL; - - private int forksNum = 0; - - public RayActor() { - } - - public RayActor(UniqueID id) { - super(id); - this.taskCounter = 1; - } - - public RayActor(UniqueID id, UniqueID actorHandleId) { - super(id); - this.actorHandleId = actorHandleId; - this.taskCounter = 0; - } - - public int increaseTaskCounter() { - return taskCounter++; - } +public interface RayActor { /** - * Getter method for property taskCursor. - * - * @return property value of taskCursor + * @return The id of this actor. */ - public UniqueID getTaskCursor() { - return taskCursor; - } + UniqueId getId(); /** - * Setter method for property taskCursor. - * - * @param taskCursor value to be assigned to property taskCursor + * @return The id of this actor handle. */ - public void setTaskCursor(UniqueID taskCursor) { - this.taskCursor = taskCursor; - } - - public UniqueID getActorHandleId() { - return actorHandleId; - } - - public void setActorHandleId(UniqueID actorHandleId) { - this.actorHandleId = actorHandleId; - } - - @Override - public void writeExternal(ObjectOutput out) throws IOException { - out.writeObject(this.id); - out.writeObject(this.computeNextActorHandleId()); - out.writeObject(this.taskCursor); - } - - public UniqueID computeNextActorHandleId() { - byte[] bytes = Sha1Digestor.digest(actorHandleId.getBytes(), ++forksNum); - return new UniqueID(bytes); - } - - @Override - public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { - - this.id = (UniqueID) in.readObject(); - this.actorHandleId = (UniqueID) in.readObject(); - this.taskCursor = (UniqueID) in.readObject(); - } -} \ No newline at end of file + UniqueId getHandleId(); +} diff --git a/java/api/src/main/java/org/ray/api/RayApi.java b/java/api/src/main/java/org/ray/api/RayApi.java deleted file mode 100644 index a7e4f0bd4..000000000 --- a/java/api/src/main/java/org/ray/api/RayApi.java +++ /dev/null @@ -1,60 +0,0 @@ -package org.ray.api; - -import java.util.List; -import org.ray.api.funcs.RayFunc; -import org.ray.util.exception.TaskExecutionException; - -/** - * Ray runtime abstraction. - */ -public interface RayApi { - - /** - * Put obj into object store. - * - * @return RayObject - */ - RayObject put(T obj); - - RayObject put(T obj, TMT metadata); - - /** - * Get real obj from object store. - */ - T get(UniqueID objectId) throws TaskExecutionException; - - /** - * Get real objects from object store. - * - * @param objectIds list of ids of objects to get - */ - List get(List objectIds) throws TaskExecutionException; - - T getMeta(UniqueID objectId) throws TaskExecutionException; - - List getMeta(List objectIds) throws TaskExecutionException; - - /** - * wait until timeout or enough RayObjects are ready. - * - * @param waitfor wait for who - * @param numReturns how many of ready is enough - * @param timeout in millisecond - */ - WaitResult wait(List> waitfor, int numReturns, int timeout); - - /** - * create remote actor. - */ - RayActor create(Class cls); - - /** - * Invoke a remote function. - * - * @param func the target running function - * @param args arguments to this funcRun, can be its original form or RayObject - * @return a set of ray objects with their return ids - */ - RayObject call(RayFunc func, Object... args); - -} diff --git a/java/api/src/main/java/org/ray/api/RayCall.java b/java/api/src/main/java/org/ray/api/RayCall.java new file mode 100644 index 000000000..e3b9bea30 --- /dev/null +++ b/java/api/src/main/java/org/ray/api/RayCall.java @@ -0,0 +1,772 @@ +// generated automatically, do not modify. + +package org.ray.api; + +import org.ray.api.function.*; + +/** + * This class provides type-safe interfaces for Ray.call. + **/ +@SuppressWarnings({"rawtypes", "unchecked"}) +class RayCall { + public static RayObject call(RayFunc0 f) { + Object[] args = new Object[]{}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc1 f, RayActor actor) { + Object[] args = new Object[]{}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc1 f, T0 t0) { + Object[] args = new Object[]{t0}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc1 f, RayObject t0) { + Object[] args = new Object[]{t0}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc2 f, RayActor actor, T1 t1) { + Object[] args = new Object[]{t1}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc2 f, RayActor actor, RayObject t1) { + Object[] args = new Object[]{t1}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc2 f, T0 t0, T1 t1) { + Object[] args = new Object[]{t0, t1}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc2 f, T0 t0, RayObject t1) { + Object[] args = new Object[]{t0, t1}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc2 f, RayObject t0, T1 t1) { + Object[] args = new Object[]{t0, t1}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc2 f, RayObject t0, RayObject t1) { + Object[] args = new Object[]{t0, t1}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, RayActor actor, T1 t1, T2 t2) { + Object[] args = new Object[]{t1, t2}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc3 f, RayActor actor, T1 t1, RayObject t2) { + Object[] args = new Object[]{t1, t2}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc3 f, RayActor actor, RayObject t1, T2 t2) { + Object[] args = new Object[]{t1, t2}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc3 f, RayActor actor, RayObject t1, RayObject t2) { + Object[] args = new Object[]{t1, t2}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc3 f, T0 t0, T1 t1, T2 t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, T0 t0, T1 t1, RayObject t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, T0 t0, RayObject t1, T2 t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, T0 t0, RayObject t1, RayObject t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, RayObject t0, T1 t1, T2 t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, RayObject t0, T1 t1, RayObject t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, RayObject t0, RayObject t1, T2 t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc3 f, RayObject t0, RayObject t1, RayObject t2) { + Object[] args = new Object[]{t0, t1, t2}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, T1 t1, T2 t2, T3 t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, T1 t1, T2 t2, RayObject t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, T1 t1, RayObject t2, T3 t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, T1 t1, RayObject t2, RayObject t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, RayObject t1, T2 t2, T3 t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, RayObject t1, T2 t2, RayObject t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, RayObject t1, RayObject t2, T3 t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, RayActor actor, RayObject t1, RayObject t2, RayObject t3) { + Object[] args = new Object[]{t1, t2, t3}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc4 f, T0 t0, T1 t1, T2 t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, T0 t0, T1 t1, T2 t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, T0 t0, T1 t1, RayObject t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, T0 t0, T1 t1, RayObject t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, T0 t0, RayObject t1, T2 t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, T0 t0, RayObject t1, T2 t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, T0 t0, RayObject t1, RayObject t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, T0 t0, RayObject t1, RayObject t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, T1 t1, T2 t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, T1 t1, T2 t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, T1 t1, RayObject t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, T1 t1, RayObject t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, RayObject t1, T2 t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, RayObject t1, T2 t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, RayObject t1, RayObject t2, T3 t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc4 f, RayObject t0, RayObject t1, RayObject t2, RayObject t3) { + Object[] args = new Object[]{t0, t1, t2, t3}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, T2 t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, T2 t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, T2 t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, T2 t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, RayObject t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, RayObject t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, RayObject t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, T1 t1, RayObject t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, T2 t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, T2 t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, T2 t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, T2 t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, RayObject t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, RayObject t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, RayObject t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, RayActor actor, RayObject t1, RayObject t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t1, t2, t3, t4}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, T2 t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, T2 t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, RayObject t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, RayObject t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, RayObject t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, T1 t1, RayObject t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, T2 t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, T2 t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, T2 t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, T2 t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, RayObject t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, RayObject t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, RayObject t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, T0 t0, RayObject t1, RayObject t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, T2 t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, T2 t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, T2 t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, T2 t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, RayObject t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, RayObject t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, RayObject t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, T1 t1, RayObject t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, T2 t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, T2 t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, T2 t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, T2 t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, RayObject t2, T3 t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, RayObject t2, T3 t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, RayObject t2, RayObject t3, T4 t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc5 f, RayObject t0, RayObject t1, RayObject t2, RayObject t3, RayObject t4) { + Object[] args = new Object[]{t0, t1, t2, t3, t4}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, T1 t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, RayActor actor, RayObject t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t1, t2, t3, t4, t5}; + return Ray.internal().call(f, actor, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, T1 t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, T0 t0, RayObject t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, T1 t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, T3 t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } + public static RayObject call(RayFunc6 f, RayObject t0, RayObject t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { + Object[] args = new Object[]{t0, t1, t2, t3, t4, t5}; + return Ray.internal().call(f, args); + } +} diff --git a/java/api/src/main/java/org/ray/api/RayDisabled.java b/java/api/src/main/java/org/ray/api/RayDisabled.java deleted file mode 100644 index d123f9cdc..000000000 --- a/java/api/src/main/java/org/ray/api/RayDisabled.java +++ /dev/null @@ -1,5 +0,0 @@ -package org.ray.api; - -public @interface RayDisabled { - -} diff --git a/java/api/src/main/java/org/ray/api/RayObject.java b/java/api/src/main/java/org/ray/api/RayObject.java index d5695dc4e..a1971be40 100644 --- a/java/api/src/main/java/org/ray/api/RayObject.java +++ b/java/api/src/main/java/org/ray/api/RayObject.java @@ -1,35 +1,23 @@ package org.ray.api; -import java.io.Serializable; -import org.ray.util.exception.TaskExecutionException; +import org.ray.api.id.UniqueId; /** - * RayObject<T> is a handle for T object, which may or may not be available now. - * That said, RayObject can be viewed as a Future object with metadata. + * Represents an object in the object store. + * @param The object type. */ -public class RayObject implements Serializable { +public interface RayObject { - private static final long serialVersionUID = 3250003902037418062L; + /** + * Fetch the object from the object store, this method will block + * until the object is locally available. + */ + T get(); - UniqueID id; - - public RayObject() { - } - - public RayObject(UniqueID id) { - this.id = id; - } - - public T get() throws TaskExecutionException { - return Ray.get(id); - } - - public TMT getMeta() throws TaskExecutionException { - return Ray.getMeta(id); - } - - public UniqueID getId() { - return id; - } + /** + * Get the object id. + */ + UniqueId getId(); } + diff --git a/java/api/src/main/java/org/ray/api/RayRemote.java b/java/api/src/main/java/org/ray/api/RayRemote.java deleted file mode 100644 index 0e4af13b5..000000000 --- a/java/api/src/main/java/org/ray/api/RayRemote.java +++ /dev/null @@ -1,20 +0,0 @@ -package org.ray.api; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; -import org.ray.util.ResourceItem; - -/** - * a ray remote function or class (as an actor). - */ -@Target({ElementType.METHOD, ElementType.TYPE}) -@Retention(RetentionPolicy.RUNTIME) -public @interface RayRemote { - /** - * This is used for default resources. - * @return The resources of the method or actor need. - */ - ResourceItem[] resources() default {@ResourceItem()}; -} diff --git a/java/api/src/main/java/org/ray/api/RayService.java b/java/api/src/main/java/org/ray/api/RayService.java deleted file mode 100644 index 0012bee64..000000000 --- a/java/api/src/main/java/org/ray/api/RayService.java +++ /dev/null @@ -1,9 +0,0 @@ -package org.ray.api; - -/** - * a RPC service that represent the data processing services implemented in Ray. - * it is programmed in other services but will be shipped and executed on ray machines at runtime - */ -public @interface RayService { - -} diff --git a/java/api/src/main/java/org/ray/api/Rpc.java b/java/api/src/main/java/org/ray/api/Rpc.java deleted file mode 100644 index 7181c216b..000000000 --- a/java/api/src/main/java/org/ray/api/Rpc.java +++ /dev/null @@ -1,390 +0,0 @@ -// generated automatically, do not modify. - -package org.ray.api; - -import org.ray.api.funcs.*; - -@SuppressWarnings({"rawtypes", "unchecked"}) -class Rpc { - public static RayObject call(RayFunc0 f) { - return Ray.internal().call(f); - } - public static RayObject call(RayFunc1 f, T1 t1) { - return Ray.internal().call(f, t1); - } - public static RayObject call(RayFunc1 f, RayObject t1) { - return Ray.internal().call(f, t1); - } - public static RayObject call(RayFunc2 f, T1 t1, T2 t2) { - return Ray.internal().call(f, t1, t2); - } - public static RayObject call(RayFunc2 f, T1 t1, RayObject t2) { - return Ray.internal().call(f, t1, t2); - } - public static RayObject call(RayFunc2 f, RayObject t1, T2 t2) { - return Ray.internal().call(f, t1, t2); - } - public static RayObject call(RayFunc2 f, RayObject t1, RayObject t2) { - return Ray.internal().call(f, t1, t2); - } - public static RayObject call(RayFunc3 f, T1 t1, T2 t2, T3 t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc3 f, T1 t1, T2 t2, RayObject t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc3 f, T1 t1, RayObject t2, T3 t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc3 f, T1 t1, RayObject t2, RayObject t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc3 f, RayObject t1, T2 t2, T3 t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc3 f, RayObject t1, T2 t2, RayObject t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc3 f, RayObject t1, RayObject t2, T3 t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc3 f, RayObject t1, RayObject t2, RayObject t3) { - return Ray.internal().call(f, t1, t2, t3); - } - public static RayObject call(RayFunc4 f, T1 t1, T2 t2, T3 t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, T1 t1, T2 t2, T3 t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, T1 t1, T2 t2, RayObject t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, T1 t1, T2 t2, RayObject t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, T1 t1, RayObject t2, T3 t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, T1 t1, RayObject t2, T3 t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, T1 t1, RayObject t2, RayObject t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, T1 t1, RayObject t2, RayObject t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, T2 t2, T3 t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, T2 t2, T3 t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, T2 t2, RayObject t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, T2 t2, RayObject t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, RayObject t2, T3 t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, RayObject t2, T3 t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, RayObject t2, RayObject t3, T4 t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc4 f, RayObject t1, RayObject t2, RayObject t3, RayObject t4) { - return Ray.internal().call(f, t1, t2, t3, t4); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, T3 t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, T3 t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, RayObject t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, T3 t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, T1 t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, T3 t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, T3 t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, T3 t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, T3 t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, RayObject t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, RayObject t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, RayObject t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, T2 t2, RayObject t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, T3 t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, T3 t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, T3 t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, T3 t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, RayObject t3, T4 t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, RayObject t3, T4 t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, RayObject t3, RayObject t4, T5 t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc5 f, RayObject t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5) { - return Ray.internal().call(f, t1, t2, t3, t4, t5); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, T3 t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, T2 t2, RayObject t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, T3 t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, T1 t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, T3 t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, T2 t2, RayObject t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, T3 t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, T4 t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, T4 t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, T4 t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, T4 t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, RayObject t4, T5 t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, RayObject t4, T5 t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5, T6 t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } - public static RayObject call(RayFunc6 f, RayObject t1, RayObject t2, RayObject t3, RayObject t4, RayObject t5, RayObject t6) { - return Ray.internal().call(f, t1, t2, t3, t4, t5, t6); - } -} diff --git a/java/api/src/main/java/org/ray/api/TaskStatus.java b/java/api/src/main/java/org/ray/api/TaskStatus.java deleted file mode 100644 index bd5532f7e..000000000 --- a/java/api/src/main/java/org/ray/api/TaskStatus.java +++ /dev/null @@ -1,13 +0,0 @@ -package org.ray.api; - -import java.io.Serializable; - -/** - * Represents a status of type T of a task. - */ -public class TaskStatus implements Serializable { - - private static final long serialVersionUID = -3382082416577683751L; - - public T status; -} diff --git a/java/api/src/main/java/org/ray/api/WaitResult.java b/java/api/src/main/java/org/ray/api/WaitResult.java index e847bfb2a..fc022367a 100644 --- a/java/api/src/main/java/org/ray/api/WaitResult.java +++ b/java/api/src/main/java/org/ray/api/WaitResult.java @@ -4,24 +4,31 @@ package org.ray.api; import java.util.List; /** - * The result of Ray.wait() distinguish the ready ones and the remain ones + * Represents the result of a Ray.wait call. It contains 2 lists, + * one containing the locally available objects, one containing the rest. */ -public class WaitResult { +public final class WaitResult { - private final List> readyOnes; - private final List> remainOnes; + private final List> ready; + private final List> unready; - public WaitResult(List> readyOnes, List> remainOnes) { - this.readyOnes = readyOnes; - this.remainOnes = remainOnes; + public WaitResult(List> ready, List> unready) { + this.ready = ready; + this.unready = unready; } - public List> getReadyOnes() { - return readyOnes; + /** + * Get the list of ready objects. + */ + public List> getReady() { + return ready; } - public List> getRemainOnes() { - return remainOnes; + /** + * Get the list of unready objects. + */ + public List> getUnready() { + return unready; } } diff --git a/java/api/src/main/java/org/ray/api/annotation/RayRemote.java b/java/api/src/main/java/org/ray/api/annotation/RayRemote.java new file mode 100644 index 000000000..a47e0768f --- /dev/null +++ b/java/api/src/main/java/org/ray/api/annotation/RayRemote.java @@ -0,0 +1,24 @@ +package org.ray.api.annotation; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Defines a remote function (when used on a method), + * or an actor (when used on a class). + */ +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.METHOD, ElementType.TYPE}) +public @interface RayRemote { + + /** + * Defines the quantity of various custom resources to reserve + * for this task or for the lifetime of the actor. + * @return an array of custom resource items. + */ + ResourceItem[] resources() default {}; +} diff --git a/java/api/src/main/java/org/ray/api/annotation/ResourceItem.java b/java/api/src/main/java/org/ray/api/annotation/ResourceItem.java new file mode 100644 index 000000000..f4895eba6 --- /dev/null +++ b/java/api/src/main/java/org/ray/api/annotation/ResourceItem.java @@ -0,0 +1,28 @@ +package org.ray.api.annotation; + + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Represents a custom resource, including its name and quantity. + */ +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.ANNOTATION_TYPE) +public @interface ResourceItem { + + /** + * Name of this resource, must not be null or empty. + */ + String name(); + + /** + * Quantity of this resource. + */ + double value() default 0; + +} diff --git a/java/api/src/main/java/org/ray/api/exception/RayException.java b/java/api/src/main/java/org/ray/api/exception/RayException.java new file mode 100644 index 000000000..588899de7 --- /dev/null +++ b/java/api/src/main/java/org/ray/api/exception/RayException.java @@ -0,0 +1,15 @@ +package org.ray.api.exception; + +/** + * Base class of all ray exceptions. + */ +public class RayException extends RuntimeException { + + public RayException(String message) { + super(message); + } + + public RayException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc.java b/java/api/src/main/java/org/ray/api/function/RayFunc.java similarity index 81% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc.java rename to java/api/src/main/java/org/ray/api/function/RayFunc.java index f1d0b911e..35aa44694 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc.java @@ -1,4 +1,4 @@ -package org.ray.api.funcs; +package org.ray.api.function; import java.io.Serializable; diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc0.java b/java/api/src/main/java/org/ray/api/function/RayFunc0.java similarity index 54% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc0.java rename to java/api/src/main/java/org/ray/api/function/RayFunc0.java index bb7bc89e4..79756a9d1 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc0.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc0.java @@ -1,7 +1,10 @@ // generated automatically, do not modify. -package org.ray.api.funcs; +package org.ray.api.function; +/** + * Functional interface for a remote function that has 0 parameter. + */ @FunctionalInterface public interface RayFunc0 extends RayFunc { R apply(); diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc1.java b/java/api/src/main/java/org/ray/api/function/RayFunc1.java similarity index 56% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc1.java rename to java/api/src/main/java/org/ray/api/function/RayFunc1.java index fc2bbb5d0..4a3f25049 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc1.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc1.java @@ -1,7 +1,10 @@ // generated automatically, do not modify. -package org.ray.api.funcs; +package org.ray.api.function; +/** + * Functional interface for a remote function that has 1 parameter. + */ @FunctionalInterface public interface RayFunc1 extends RayFunc { R apply(T0 t0); diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc2.java b/java/api/src/main/java/org/ray/api/function/RayFunc2.java similarity index 58% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc2.java rename to java/api/src/main/java/org/ray/api/function/RayFunc2.java index 3a0fbcae1..6ee81ba4e 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc2.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc2.java @@ -1,7 +1,10 @@ // generated automatically, do not modify. -package org.ray.api.funcs; +package org.ray.api.function; +/** + * Functional interface for a remote function that has 2 parameters. + */ @FunctionalInterface public interface RayFunc2 extends RayFunc { R apply(T0 t0, T1 t1); diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc3.java b/java/api/src/main/java/org/ray/api/function/RayFunc3.java similarity index 59% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc3.java rename to java/api/src/main/java/org/ray/api/function/RayFunc3.java index 37de1d779..1f901fcb2 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc3.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc3.java @@ -1,7 +1,10 @@ // generated automatically, do not modify. -package org.ray.api.funcs; +package org.ray.api.function; +/** + * Functional interface for a remote function that has 3 parameters. + */ @FunctionalInterface public interface RayFunc3 extends RayFunc { R apply(T0 t0, T1 t1, T2 t2); diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc4.java b/java/api/src/main/java/org/ray/api/function/RayFunc4.java similarity index 61% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc4.java rename to java/api/src/main/java/org/ray/api/function/RayFunc4.java index 19dfba0b1..33a29d082 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc4.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc4.java @@ -1,7 +1,10 @@ // generated automatically, do not modify. -package org.ray.api.funcs; +package org.ray.api.function; +/** + * Functional interface for a remote function that has 4 parameters. + */ @FunctionalInterface public interface RayFunc4 extends RayFunc { R apply(T0 t0, T1 t1, T2 t2, T3 t3); diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc5.java b/java/api/src/main/java/org/ray/api/function/RayFunc5.java similarity index 62% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc5.java rename to java/api/src/main/java/org/ray/api/function/RayFunc5.java index aa3fa7832..e9bf12102 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc5.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc5.java @@ -1,7 +1,10 @@ // generated automatically, do not modify. -package org.ray.api.funcs; +package org.ray.api.function; +/** + * Functional interface for a remote function that has 5 parameters. + */ @FunctionalInterface public interface RayFunc5 extends RayFunc { R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4); diff --git a/java/api/src/main/java/org/ray/api/funcs/RayFunc6.java b/java/api/src/main/java/org/ray/api/function/RayFunc6.java similarity index 64% rename from java/api/src/main/java/org/ray/api/funcs/RayFunc6.java rename to java/api/src/main/java/org/ray/api/function/RayFunc6.java index 61d9307eb..a79cc0e27 100644 --- a/java/api/src/main/java/org/ray/api/funcs/RayFunc6.java +++ b/java/api/src/main/java/org/ray/api/function/RayFunc6.java @@ -1,7 +1,10 @@ // generated automatically, do not modify. -package org.ray.api.funcs; +package org.ray.api.function; +/** + * Functional interface for a remote function that has 6 parameters. + */ @FunctionalInterface public interface RayFunc6 extends RayFunc { R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5); diff --git a/java/api/src/main/java/org/ray/api/UniqueID.java b/java/api/src/main/java/org/ray/api/id/UniqueId.java similarity index 54% rename from java/api/src/main/java/org/ray/api/UniqueID.java rename to java/api/src/main/java/org/ray/api/id/UniqueId.java index d6af0a664..0d32d0f8f 100644 --- a/java/api/src/main/java/org/ray/api/UniqueID.java +++ b/java/api/src/main/java/org/ray/api/id/UniqueId.java @@ -1,4 +1,4 @@ -package org.ray.api; +package org.ray.api.id; import java.io.Serializable; import java.nio.ByteBuffer; @@ -7,59 +7,88 @@ import java.util.Random; import javax.xml.bind.DatatypeConverter; /** - * Unique ID for task, worker, function. + * Represents a unique id of all Ray concepts, including + * objects, tasks, workers, actors, etc. */ -public class UniqueID implements Serializable { +public class UniqueId implements Serializable { public static final int LENGTH = 20; - public static final UniqueID NIL = genNil(); + public static final UniqueId NIL = genNil(); private static final long serialVersionUID = 8588849129675565761L; private final byte[] id; - public static UniqueID fromHexString(String hex) { + /** + * Create a UniqueId from a hex string. + */ + public static UniqueId fromHexString(String hex) { byte[] bytes = DatatypeConverter.parseHexBinary(hex); - return new UniqueID(bytes); + return new UniqueId(bytes); } - public static UniqueID fromByteBuffer(ByteBuffer bb) { + /** + * Creates a UniqueId from a ByteBuffer. + */ + public static UniqueId fromByteBuffer(ByteBuffer bb) { byte[] id = new byte[bb.remaining()]; bb.get(id); - return new UniqueID(id); + return new UniqueId(id); } - public static UniqueID genNil() { + /** + * Generate a nil UniqueId. + */ + public static UniqueId genNil() { byte[] b = new byte[LENGTH]; Arrays.fill(b, (byte) 0xFF); - return new UniqueID(b); + return new UniqueId(b); } - public static UniqueID randomId() { + /** + * Generate an UniqueId with random value. + */ + public static UniqueId randomId() { byte[] b = new byte[LENGTH]; new Random().nextBytes(b); - return new UniqueID(b); + return new UniqueId(b); } - public UniqueID(byte[] id) { + public UniqueId(byte[] id) { if (id.length != LENGTH) { - throw new IllegalArgumentException("Illegal argument for UniqueID, expect " + LENGTH + throw new IllegalArgumentException("Illegal argument for UniqueId, expect " + LENGTH + " bytes, but got " + id.length + " bytes."); } this.id = id; } + /** + * Get the byte data of this UniqueId. + */ public byte[] getBytes() { return id; } + /** + * Convert the byte data to a ByteBuffer. + */ public ByteBuffer toByteBuffer() { return ByteBuffer.wrap(id); } - public UniqueID copy() { + /** + * Create a copy of this UniqueId. + */ + public UniqueId copy() { byte[] nid = Arrays.copyOf(id, id.length); - return new UniqueID(nid); + return new UniqueId(nid); + } + + /** + * Returns true if this id is nil. + */ + public boolean isNil() { + return this.equals(NIL); } @Override @@ -73,11 +102,11 @@ public class UniqueID implements Serializable { return false; } - if (!(obj instanceof UniqueID)) { + if (!(obj instanceof UniqueId)) { return false; } - UniqueID r = (UniqueID) obj; + UniqueId r = (UniqueId) obj; return Arrays.equals(id, r.id); } @@ -85,8 +114,4 @@ public class UniqueID implements Serializable { public String toString() { return DatatypeConverter.printHexBinary(id); } - - public boolean isNil() { - return this.equals(NIL); - } } diff --git a/java/api/src/main/java/org/ray/api/internal/RayConnector.java b/java/api/src/main/java/org/ray/api/internal/RayConnector.java deleted file mode 100644 index 3d50dead1..000000000 --- a/java/api/src/main/java/org/ray/api/internal/RayConnector.java +++ /dev/null @@ -1,26 +0,0 @@ -package org.ray.api.internal; - -import java.lang.reflect.Method; -import org.ray.api.RayApi; -import org.ray.util.logger.RayLog; - -/** - * Mediator, which pulls the {@code org.ray.api.RayApi} up to run. - */ -public class RayConnector { - - private static final String className = "org.ray.core.RayRuntime"; - - public static RayApi run() { - try { - Method m = Class.forName(className).getDeclaredMethod("init"); - m.setAccessible(true); - RayApi api = (RayApi) m.invoke(null); - m.setAccessible(false); - return api; - } catch (ReflectiveOperationException | IllegalArgumentException | SecurityException e) { - RayLog.core.error("Load {} class failed.", className, e); - throw new Error("RayApi is not successfully initiated."); - } - } -} diff --git a/java/api/src/main/java/org/ray/api/runtime/DefaultRayRuntimeFactory.java b/java/api/src/main/java/org/ray/api/runtime/DefaultRayRuntimeFactory.java new file mode 100644 index 000000000..9f7302a98 --- /dev/null +++ b/java/api/src/main/java/org/ray/api/runtime/DefaultRayRuntimeFactory.java @@ -0,0 +1,22 @@ +package org.ray.api.runtime; + +import java.lang.reflect.Method; + +/** + * The default Ray runtime factory. It produces an instance of AbstractRayRuntime. + */ +public class DefaultRayRuntimeFactory implements RayRuntimeFactory { + + @Override + public RayRuntime createRayRuntime() { + try { + Method m = Class.forName("org.ray.core.AbstractRayRuntime").getDeclaredMethod("init"); + m.setAccessible(true); + RayRuntime runtime = (RayRuntime) m.invoke(null); + m.setAccessible(false); + return runtime; + } catch (Exception e) { + throw new RuntimeException("Failed to initialize ray runtime", e); + } + } +} diff --git a/java/api/src/main/java/org/ray/api/runtime/RayRuntime.java b/java/api/src/main/java/org/ray/api/runtime/RayRuntime.java new file mode 100644 index 000000000..3f47c988d --- /dev/null +++ b/java/api/src/main/java/org/ray/api/runtime/RayRuntime.java @@ -0,0 +1,81 @@ +package org.ray.api.runtime; + +import java.util.List; +import org.ray.api.RayActor; +import org.ray.api.RayObject; +import org.ray.api.WaitResult; +import org.ray.api.function.RayFunc; +import org.ray.api.id.UniqueId; + +/** + * Base interface of a Ray runtime. + */ +public interface RayRuntime { + + /** + * Shutdown the runtime. + */ + void shutdown(); + + /** + * Store an object in the object store. + * + * @param obj The Java object to be stored. + * @return A RayObject instance that represents the in-store object. + */ + RayObject put(T obj); + + /** + * Get an object from the object store. + * + * @param objectId The ID of the object to get. + * @return The Java object. + */ + T get(UniqueId objectId); + + /** + * Get a list of objects from the object store. + * + * @param objectIds The list of object IDs. + * @return A list of Java objects. + */ + List get(List objectIds); + + /** + * Wait for a list of RayObjects to be locally available, + * until specified number of objects are ready, or specified timeout has passed. + * + * @param waitList A list of RayObject to wait for. + * @param numReturns The number of objects that should be returned. + * @param timeoutMs The maximum time in milliseconds to wait before returning. + * @return Two lists, one containing locally available objects, one containing the rest. + */ + WaitResult wait(List> waitList, int numReturns, int timeoutMs); + + /** + * Create an actor on a remote node. + * + * @param actorClass the class of the actor to be created. + * @return A handle to the newly created actor. + */ + RayActor createActor(Class actorClass); + + /** + * Invoke a remote function. + * + * @param func The remote function to run. + * @param args The arguments of the remote function. + * @return The result object. + */ + RayObject call(RayFunc func, Object[] args); + + /** + * Invoke a remote function on an actor. + * + * @param func The remote function to run, it must be a method of the given actor. + * @param actor A handle to the actor. + * @param args The arguments of the remote function. + * @return The result object. + */ + RayObject call(RayFunc func, RayActor actor, Object[] args); +} diff --git a/java/api/src/main/java/org/ray/api/runtime/RayRuntimeFactory.java b/java/api/src/main/java/org/ray/api/runtime/RayRuntimeFactory.java new file mode 100644 index 000000000..61344de0c --- /dev/null +++ b/java/api/src/main/java/org/ray/api/runtime/RayRuntimeFactory.java @@ -0,0 +1,9 @@ +package org.ray.api.runtime; + +/** + * A factory that produces a RayRuntime instance. + */ +public interface RayRuntimeFactory { + + RayRuntime createRayRuntime(); +} diff --git a/java/checkstyle-suppressions.xml b/java/checkstyle-suppressions.xml index 80cfea7c4..c32146e18 100644 --- a/java/checkstyle-suppressions.xml +++ b/java/checkstyle-suppressions.xml @@ -3,15 +3,10 @@ "http://www.puppycrawl.com/dtds/suppressions_1_1.dtd"> - - - - - - + diff --git a/java/cli/src/main/java/org/ray/cli/RayCli.java b/java/cli/src/main/java/org/ray/cli/RayCli.java index f65e42570..cdff1d9f1 100644 --- a/java/cli/src/main/java/org/ray/cli/RayCli.java +++ b/java/cli/src/main/java/org/ray/cli/RayCli.java @@ -6,7 +6,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.List; import net.lingala.zip4j.core.ZipFile; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.core.model.RayParameters; import org.ray.core.model.RunMode; import org.ray.runner.RunManager; @@ -162,10 +162,7 @@ public class RayCli { cmdSubmit.packageZip.lastIndexOf('/') + 1, cmdSubmit.packageZip.lastIndexOf('.')); - //final RemoteFunctionManager functionManager = RayRuntime - // .getInstance().getRemoteFunctionManager(); - - UniqueID resourceId = functionManager.registerResource(zip); + UniqueId resourceId = functionManager.registerResource(zip); // Init RayLog before using it. RayLog.init(params.log_dir); @@ -173,7 +170,7 @@ public class RayCli { RayLog.rapp.debug( "registerResource " + resourceId + " for package " + packageName + " done"); - UniqueID appId = params.driver_id; + UniqueId appId = params.driver_id; functionManager.registerApp(appId, resourceId); RayLog.rapp.debug("registerApp " + appId + " for resouorce " + resourceId + " done"); @@ -206,8 +203,6 @@ public class RayCli { RayLog.rapp.debug("Find app class path " + additionalClassPath); // Start driver process. - //RunManager runManager = new RunManager(params, RayRuntime.getInstance().getPaths(), - // RayRuntime.configReader); RunManager runManager = new RunManager(params, paths, config); Process proc = runManager.startDriver( DefaultDriver.class.getName(), diff --git a/java/common/pom.xml b/java/common/pom.xml index 3debbf8d4..f7b6f7716 100644 --- a/java/common/pom.xml +++ b/java/common/pom.xml @@ -1,46 +1,48 @@ - - org.ray.parent - ray-superpom - 1.0 - - 4.0.0 + xmlns="http://maven.apache.org/POM/4.0.0" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> + + org.ray.parent + ray-superpom + 1.0 + + 4.0.0 - org.ray - ray-common - java common and util for ray - java common and util for ray - - - jar - - - - org.slf4j - slf4j-log4j12 - - - quartz - quartz - - - org.ini4j - ini4j - - - org.ow2.asm - asm - - - - com.google.guava - guava - - + org.ray + ray-common + java common and util for ray + java common and util for ray + + jar + + + org.ray + ray-api + ${project.version} + + + org.slf4j + slf4j-log4j12 + + + quartz + quartz + + + org.ini4j + ini4j + + + org.ow2.asm + asm + + + com.google.guava + guava + + \ No newline at end of file diff --git a/java/common/src/main/java/org/ray/util/RemoteBiFunction.java b/java/common/src/main/java/org/ray/util/RemoteBiFunction.java deleted file mode 100644 index 722e3c74e..000000000 --- a/java/common/src/main/java/org/ray/util/RemoteBiFunction.java +++ /dev/null @@ -1,10 +0,0 @@ -package org.ray.util; - -import java.io.Serializable; -import java.util.function.BiFunction; - -@FunctionalInterface -public interface RemoteBiFunction extends BiFunction, Serializable { - -} - diff --git a/java/common/src/main/java/org/ray/util/RemoteFunction.java b/java/common/src/main/java/org/ray/util/RemoteFunction.java deleted file mode 100644 index b05184e3b..000000000 --- a/java/common/src/main/java/org/ray/util/RemoteFunction.java +++ /dev/null @@ -1,9 +0,0 @@ -package org.ray.util; - -import java.io.Serializable; -import java.util.function.Function; - -@FunctionalInterface -public interface RemoteFunction extends Function, Serializable { - -} diff --git a/java/common/src/main/java/org/ray/util/ResourceItem.java b/java/common/src/main/java/org/ray/util/ResourceItem.java deleted file mode 100644 index 25e67acfb..000000000 --- a/java/common/src/main/java/org/ray/util/ResourceItem.java +++ /dev/null @@ -1,7 +0,0 @@ -package org.ray.util; - -public @interface ResourceItem { - public String name() default ""; - public double value() default 0; - -} diff --git a/java/common/src/main/java/org/ray/util/ResourceUtil.java b/java/common/src/main/java/org/ray/util/ResourceUtil.java index a8adf2c33..fce0d5f67 100644 --- a/java/common/src/main/java/org/ray/util/ResourceUtil.java +++ b/java/common/src/main/java/org/ray/util/ResourceUtil.java @@ -2,6 +2,7 @@ package org.ray.util; import java.util.HashMap; import java.util.Map; +import org.ray.api.annotation.ResourceItem; public class ResourceUtil { public static final String CPU_LITERAL = "CPU"; diff --git a/java/common/src/main/java/org/ray/util/config/ConfigReader.java b/java/common/src/main/java/org/ray/util/config/ConfigReader.java index 889e72d85..db477e2bd 100644 --- a/java/common/src/main/java/org/ray/util/config/ConfigReader.java +++ b/java/common/src/main/java/org/ray/util/config/ConfigReader.java @@ -12,6 +12,7 @@ import java.util.Vector; import org.ini4j.Config; import org.ini4j.Ini; import org.ini4j.Profile; +import org.ray.api.id.UniqueId; import org.ray.util.ObjectUtil; import org.ray.util.StringUtil; @@ -319,7 +320,7 @@ public class ConfigReader { Object v = Enum.valueOf((Class) fld.getType(), sv); fld.set(obj, v); // TODO: this is a hack and needs to be resolved later - } else if (fld.getType().getName().equals("org.ray.api.UniqueID")) { + } else if (fld.getType().equals(UniqueId.class)) { String sv = getStringValue(section, fld.getName(), defaultFldValue.toString(), comment); Object v; try { diff --git a/java/common/src/main/java/org/ray/util/generator/RayCallGenerator.java b/java/common/src/main/java/org/ray/util/generator/RayCallGenerator.java new file mode 100644 index 000000000..caaad28b0 --- /dev/null +++ b/java/common/src/main/java/org/ray/util/generator/RayCallGenerator.java @@ -0,0 +1,113 @@ +package org.ray.util.generator; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import org.ray.util.FileUtil; + +/** + * A util class that generates `RayCall.java` + */ +public class RayCallGenerator extends BaseGenerator { + + /** + * @return Whole file content of `RayCall.java`. + */ + private String build() { + sb = new StringBuilder(); + + newLine("// generated automatically, do not modify."); + newLine(""); + newLine("package org.ray.api;"); + newLine(""); + newLine("import org.ray.api.function.*;"); + newLine(""); + + newLine("/**"); + newLine(" * This class provides type-safe interfaces for Ray.call."); + newLine(" **/"); + newLine("@SuppressWarnings({\"rawtypes\", \"unchecked\"})"); + newLine("class RayCall {"); + for (int i = 0; i <= 6; i++) { + if (i > 0) { + buildCalls(i, true); + } + buildCalls(i, false); + } + newLine("}"); + return sb.toString(); + } + + /** + * Build the `Ray.call` methods for given number of parameters. + * @param numParameters the number of parameters, including the actor parameter. + * @param forActor build actor api when true, otherwise build task api. + */ + private void buildCalls(int numParameters, boolean forActor) { + String genericTypes = ""; + String argList = ""; + for (int i = 0; i < numParameters; i++) { + genericTypes += "T" + i + ", "; + if (!forActor || i > 0) { + argList += "t" + i + ", "; + } + } + if (argList.endsWith(", ")) { + argList = argList.substring(0, argList.length() - 2); + } + + String funcParam = String.format("RayFunc%d<%sR> f%s", + numParameters, + genericTypes, + numParameters > 0 ? ", " : ""); + String actorParam = ""; + if (forActor) { + actorParam = "RayActor actor"; + if (numParameters > 1) { + actorParam += ", "; + } + } + + for (String param : generateParameters(forActor ? 1 : 0, numParameters)) { + // method signature + indents(1); + newLine(String.format( + "public static <%sR> RayObject call(%s%s%s) {", + genericTypes, funcParam, actorParam, param + )); + // method body + indents(2); + newLine(String.format("Object[] args = new Object[]{%s};", argList)); + indents(2); + newLine(String.format("return Ray.internal().call(f%s, args);", forActor ? ", actor" : "")); + indents(1); + newLine("}"); + } + } + + private List generateParameters(int from, int to) { + List res = new ArrayList<>(); + dfs(from, from, to, "", res); + return res; + } + + private void dfs(int pos, int from, int to, String cur, List res) { + if (pos >= to) { + res.add(cur); + return; + } + if (pos > from) { + cur += ", "; + } + String nextParameter = String.format("T%d t%d", pos, pos); + dfs(pos + 1, from, to, cur + nextParameter, res); + nextParameter = String.format("RayObject t%d", pos, pos); + dfs(pos + 1, from, to, cur + nextParameter, res); + } + + public static void main(String[] args) throws IOException { + String path = System.getProperty("user.dir") + + "/api/src/main/java/org/ray/api/RayCall.java"; + FileUtil.overrideFile(path, new RayCallGenerator().build()); + } +} diff --git a/java/common/src/main/java/org/ray/util/generator/FuncsGenerator.java b/java/common/src/main/java/org/ray/util/generator/RayFuncGenerator.java similarity index 66% rename from java/common/src/main/java/org/ray/util/generator/FuncsGenerator.java rename to java/common/src/main/java/org/ray/util/generator/RayFuncGenerator.java index 04ce024b1..040d36c1d 100644 --- a/java/common/src/main/java/org/ray/util/generator/FuncsGenerator.java +++ b/java/common/src/main/java/org/ray/util/generator/RayFuncGenerator.java @@ -4,9 +4,9 @@ import java.io.IOException; import org.ray.util.FileUtil; /** - * A util class that generates all the classes under org.ray.api.funcs package. + * A util class that generates all the RayFuncX classes under org.ray.api.function package. */ -public class FuncsGenerator extends BaseGenerator { +public class RayFuncGenerator extends BaseGenerator { private String generate(int numParameters) { sb = new StringBuilder(); @@ -23,8 +23,14 @@ public class FuncsGenerator extends BaseGenerator { newLine("// generated automatically, do not modify."); newLine(""); - newLine("package org.ray.api.funcs;"); + newLine("package org.ray.api.function;"); newLine(""); + newLine("/**"); + String comment = String.format( + " * Functional interface for a remote function that has %d parameter%s.", + numParameters, numParameters > 1 ? "s" : ""); + newLine(comment); + newLine(" */"); newLine("@FunctionalInterface"); newLine(String.format("public interface RayFunc%d<%sR> extends RayFunc {", numParameters, genericTypes)); @@ -37,8 +43,8 @@ public class FuncsGenerator extends BaseGenerator { public static void main(String[] args) throws IOException { String root = System.getProperty("user.dir") - + "/api/src/main/java/org/ray/api/funcs/"; - FuncsGenerator generator = new FuncsGenerator(); + + "/api/src/main/java/org/ray/api/function/"; + RayFuncGenerator generator = new RayFuncGenerator(); for (int i = 0; i <= MAX_PARAMETERS; i++) { String content = generator.generate(i); FileUtil.overrideFile(root + "RayFunc" + i + ".java", content); diff --git a/java/common/src/main/java/org/ray/util/generator/RpcGenerator.java b/java/common/src/main/java/org/ray/util/generator/RpcGenerator.java deleted file mode 100644 index d08c58f27..000000000 --- a/java/common/src/main/java/org/ray/util/generator/RpcGenerator.java +++ /dev/null @@ -1,77 +0,0 @@ -package org.ray.util.generator; - -import java.io.IOException; -import java.util.ArrayList; -import java.util.List; -import org.ray.util.FileUtil; - -/** - * A util class that generates Rpc.java - */ -public class RpcGenerator extends BaseGenerator { - - private String build() { - sb = new StringBuilder(); - - newLine("// generated automatically, do not modify."); - newLine(""); - newLine("package org.ray.api;"); - newLine(""); - newLine("import org.ray.api.funcs.*;"); - newLine(""); - - newLine("@SuppressWarnings({\"rawtypes\", \"unchecked\"})"); - newLine("class Rpc {"); - for (int i = 0; i <= 6; i++) { - buildCalls(i); - } - newLine("}"); - return sb.toString(); - } - - private void buildCalls(int numParameters) { - String funcClass = "RayFunc" + numParameters; - String genericTypes = ""; - String callList = ""; - for (int i = 1; i <= numParameters; i++) { - genericTypes += "T" + i + ", "; - callList += ", t" + i; - } - String body = String.format("return Ray.internal().call(f%s);", callList); - for (String param : generateParameters(numParameters)) { - indents(1); - newLine(String.format( - "public static <%sR> RayObject call(%s<%sR> f%s) {", - genericTypes, funcClass, genericTypes, param - )); - indents(2); - newLine(body); - indents(1); - newLine("}"); - } - } - - private List generateParameters(int numParameters) { - List res = new ArrayList<>(); - dfs(1, numParameters, "", res); - return res; - } - - private void dfs(int pos, int max, String cur, List res) { - if (pos > max) { - res.add(cur); - return; - } - cur += ", "; - String nextParameter = String.format("T%d t%d", pos, pos); - dfs(pos + 1, max, cur + nextParameter, res); - nextParameter = String.format("RayObject t%d", pos, pos); - dfs(pos + 1, max, cur + nextParameter, res); - } - - public static void main(String[] args) throws IOException { - String path = System.getProperty("user.dir") + "/api/src/main/java"; - path += "/org/ray/api/Rpc.java"; - FileUtil.overrideFile(path, new RpcGenerator().build()); - } -} diff --git a/java/runtime-common/pom.xml b/java/runtime-common/pom.xml index 648c13bb1..34cde7dcc 100644 --- a/java/runtime-common/pom.xml +++ b/java/runtime-common/pom.xml @@ -23,6 +23,11 @@ ray-api ${project.version} + + org.ray + ray-common + ${project.version} + de.ruedigermoeller fst diff --git a/java/runtime-common/src/main/java/org/ray/core/RayRuntime.java b/java/runtime-common/src/main/java/org/ray/core/AbstractRayRuntime.java similarity index 51% rename from java/runtime-common/src/main/java/org/ray/core/RayRuntime.java rename to java/runtime-common/src/main/java/org/ray/core/AbstractRayRuntime.java index f0ccc6f60..a372d2bce 100644 --- a/java/runtime-common/src/main/java/org/ray/core/RayRuntime.java +++ b/java/runtime-common/src/main/java/org/ray/core/AbstractRayRuntime.java @@ -11,18 +11,24 @@ import java.util.Map; import org.apache.arrow.plasma.ObjectStoreLink; import org.apache.commons.lang3.tuple.Pair; import org.ray.api.Ray; -import org.ray.api.RayApi; +import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.UniqueID; import org.ray.api.WaitResult; -import org.ray.api.funcs.RayFunc; +import org.ray.api.annotation.RayRemote; +import org.ray.api.function.RayFunc; +import org.ray.api.function.RayFunc2; +import org.ray.api.id.UniqueId; +import org.ray.api.runtime.RayRuntime; import org.ray.core.model.RayParameters; import org.ray.spi.LocalSchedulerLink; -import org.ray.spi.LocalSchedulerProxy; import org.ray.spi.ObjectStoreProxy; import org.ray.spi.ObjectStoreProxy.GetStatus; import org.ray.spi.PathConfig; import org.ray.spi.RemoteFunctionManager; +import org.ray.spi.model.RayMethod; +import org.ray.spi.model.TaskSpec; +import org.ray.util.MethodId; +import org.ray.util.ResourceUtil; import org.ray.util.config.ConfigReader; import org.ray.util.exception.TaskExecutionException; import org.ray.util.logger.RayLog; @@ -30,26 +36,31 @@ import org.ray.util.logger.RayLog; /** * Core functionality to implement Ray APIs. */ -public abstract class RayRuntime implements RayApi { +public abstract class AbstractRayRuntime implements RayRuntime { public static ConfigReader configReader; - protected static RayRuntime ins = null; + protected static AbstractRayRuntime ins = null; protected static RayParameters params = null; private static boolean fromRayInit = false; protected Worker worker; - protected LocalSchedulerProxy localSchedulerProxy; + protected LocalSchedulerLink localSchedulerClient; protected ObjectStoreProxy objectStoreProxy; protected LocalFunctionManager functions; protected RemoteFunctionManager remoteFunctionManager; protected PathConfig pathConfig; + /** + * Actor ID -> actor instance. + */ + private Map actors = new HashMap<>(); + // app level Ray.init() // make it private so there is no direct usage but only from Ray.init - private static RayRuntime init() { + private static AbstractRayRuntime init() { if (ins == null) { try { fromRayInit = true; - RayRuntime.init(null, null); + AbstractRayRuntime.init(null, null); fromRayInit = false; } catch (Exception e) { e.printStackTrace(); @@ -59,9 +70,10 @@ public abstract class RayRuntime implements RayApi { return ins; } - // engine level RayRuntime.init(xx, xx) + // engine level AbstractRayRuntime.init(xx, xx) // updateConfigStr is sth like section1.k1=v1;section2.k2=v2 - public static RayRuntime init(String configPath, String updateConfigStr) throws Exception { + public static AbstractRayRuntime init(String configPath, String updateConfigStr) + throws Exception { if (ins == null) { if (configPath == null) { configPath = System.getenv("RAY_CONFIG"); @@ -74,7 +86,7 @@ public abstract class RayRuntime implements RayApi { } } configReader = new ConfigReader(configPath, updateConfigStr); - RayRuntime.params = new RayParameters(configReader); + AbstractRayRuntime.params = new RayParameters(configReader); RayLog.init(params.log_dir); assert RayLog.core != null; @@ -91,7 +103,7 @@ public abstract class RayRuntime implements RayApi { // init with command line args // --config=ray.config.ini --overwrite=updateConfigStr - public static RayRuntime init(String[] args) throws Exception { + public static AbstractRayRuntime init(String[] args) throws Exception { String config = null; String updateConfig = null; for (String arg : args) { @@ -117,7 +129,7 @@ public abstract class RayRuntime implements RayApi { pathConfig = pathManager; functions = new LocalFunctionManager(remoteLoader); - localSchedulerProxy = new LocalSchedulerProxy(slink); + localSchedulerClient = slink; if (!params.use_raylet) { objectStoreProxy = new ObjectStoreProxy(plink); @@ -125,22 +137,23 @@ public abstract class RayRuntime implements RayApi { objectStoreProxy = new ObjectStoreProxy(plink, slink); } - worker = new Worker(localSchedulerProxy, functions); + worker = new Worker(localSchedulerClient, functions); } - private static RayRuntime instantiate(RayParameters params) { + private static AbstractRayRuntime instantiate(RayParameters params) { String className = params.run_mode.isNativeRuntime() ? "org.ray.core.impl.RayNativeRuntime" : "org.ray.core.impl.RayDevRuntime"; - RayRuntime runtime; + AbstractRayRuntime runtime; try { Class cls = Class.forName(className); if (cls.getConstructors().length > 0) { - throw new Error("The RayRuntime final class should not have any public constructor."); + throw new Error( + "The AbstractRayRuntime final class should not have any public constructor."); } Constructor cons = cls.getDeclaredConstructor(); cons.setAccessible(true); - runtime = (RayRuntime) cons.newInstance(); + runtime = (AbstractRayRuntime) cons.newInstance(); cons.setAccessible(false); } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | SecurityException | ClassNotFoundException @@ -148,7 +161,8 @@ public abstract class RayRuntime implements RayApi { RayLog.core .error("Load class " + className + " failed for run-mode " + params.run_mode.toString(), e); - throw new Error("RayRuntime not registered for run-mode " + params.run_mode.toString()); + throw new Error("AbstractRayRuntime not registered for run-mode " + + params.run_mode.toString()); } RayLog.core @@ -156,9 +170,7 @@ public abstract class RayRuntime implements RayApi { try { runtime.start(params); } catch (Exception e) { - System.err.println("RayRuntime start failed:" + e.getMessage()); //in case of logger not ready - e.printStackTrace(); //in case of logger not ready - RayLog.core.error("RayRuntime start failed", e); + RayLog.core.error("Failed to init RayRuntime", e); System.exit(-1); } @@ -170,7 +182,7 @@ public abstract class RayRuntime implements RayApi { */ public abstract void start(RayParameters params) throws Exception; - public static RayRuntime getInstance() { + public static AbstractRayRuntime getInstance() { return ins; } @@ -178,39 +190,29 @@ public abstract class RayRuntime implements RayApi { return params; } - public abstract void cleanUp(); + @Override + public abstract void shutdown(); - public void putRaw(UniqueID taskId, UniqueID objectId, T obj) { - putRaw(taskId, objectId, obj, null); + @Override + public RayObject put(T obj) { + UniqueId objectId = getCurrentTaskNextPutId(); + put(objectId, obj); + return new RayObjectImpl<>(objectId); } - /*********** - * RayApi methods. - ***********/ - - public void putRaw(UniqueID taskId, UniqueID objectId, T obj, TMT metadata) { - RayLog.core.info("Task " + taskId.toString() + " Object " + objectId.toString() + " put"); + public void put(UniqueId objectId, T obj) { + UniqueId taskId = getCurrentTaskId(); + RayLog.core.info("Putting object {}, for task {} ", objectId, taskId); if (!params.use_raylet) { - localSchedulerProxy.markTaskPutDependency(taskId, objectId); + localSchedulerClient.markTaskPutDependency(taskId, objectId); } - objectStoreProxy.put(objectId, obj, metadata); - } - - public void putRaw(UniqueID objectId, T obj) { - UniqueID taskId = getCurrentTaskId(); - putRaw(taskId, objectId, obj, null); - } - - public void putRaw(T obj) { - UniqueID taskId = getCurrentTaskId(); - UniqueID objectId = getCurrentTaskNextPutId(); - putRaw(taskId, objectId, obj, null); + objectStoreProxy.put(objectId, obj, null); } /** - * get the task identity of the currently running task, UniqueID.NIL if not inside any + * get the task identity of the currently running task, UniqueId.NIL if not inside any */ - public UniqueID getCurrentTaskId() { + public UniqueId getCurrentTaskId() { return worker.getCurrentTaskId(); } @@ -218,79 +220,42 @@ public abstract class RayRuntime implements RayApi { * get the to-be-returned objects identities of the currently running task, empty array if not * inside any. */ - public UniqueID getCurrentTaskNextPutId() { + public UniqueId getCurrentTaskNextPutId() { return worker.getCurrentTaskNextPutId(); } @Override - public RayObject put(T obj) { - return put(obj, null); + public T get(UniqueId objectId) throws TaskExecutionException { + List ret = get(ImmutableList.of(objectId)); + return ret.get(0); } @Override - public RayObject put(T obj, TMT metadata) { - UniqueID taskId = getCurrentTaskId(); - UniqueID objectId = getCurrentTaskNextPutId(); - putRaw(taskId, objectId, obj, metadata); - return new RayObject<>(objectId); - } - - @Override - public T get(UniqueID objectId) throws TaskExecutionException { - return doGet(objectId, false); - } - - @Override - public List get(List objectIds) throws TaskExecutionException { - return doGet(objectIds, false); - } - - @Override - public T getMeta(UniqueID objectId) throws TaskExecutionException { - return doGet(objectId, true); - } - - @Override - public List getMeta(List objectIds) throws TaskExecutionException { - return doGet(objectIds, true); - } - - @Override - public WaitResult wait(List> waitfor, int numReturns, int timeout) { - return objectStoreProxy.wait(waitfor, numReturns, timeout); - } - - @Override - public RayObject call(RayFunc func, Object... args) { - return worker.submit(func, args); - } - - private List doGet(List objectIds, boolean isMetadata) - throws TaskExecutionException { + public List get(List objectIds) { boolean wasBlocked = false; - UniqueID taskId = getCurrentTaskId(); + UniqueId taskId = getCurrentTaskId(); try { int numObjectIds = objectIds.size(); // Do an initial fetch for remote objects. - List> fetchBatches = + List> fetchBatches = splitIntoBatches(objectIds, params.worker_fetch_request_size); - for (List batch : fetchBatches) { + for (List batch : fetchBatches) { if (!params.use_raylet) { objectStoreProxy.fetch(batch); } else { - localSchedulerProxy.reconstructObjects(batch, true); + localSchedulerClient.reconstructObjects(batch, true); } } // Get the objects. We initially try to get the objects immediately. List> ret = objectStoreProxy - .get(objectIds, params.default_first_check_timeout_ms, isMetadata); + .get(objectIds, params.default_first_check_timeout_ms, false); assert ret.size() == numObjectIds; // Mapping the object IDs that we haven't gotten yet to their original index in objectIds. - Map unreadys = new HashMap<>(); + Map unreadys = new HashMap<>(); for (int i = 0; i < numObjectIds; i++) { if (ret.get(i).getRight() != GetStatus.SUCCESS) { unreadys.put(objectIds.get(i), i); @@ -301,32 +266,32 @@ public abstract class RayRuntime implements RayApi { // Try reconstructing any objects we haven't gotten yet. Try to get them // until at least PlasmaLink.GET_TIMEOUT_MS milliseconds passes, then repeat. while (unreadys.size() > 0) { - List unreadyList = new ArrayList<>(unreadys.keySet()); - List> reconstructBatches = + List unreadyList = new ArrayList<>(unreadys.keySet()); + List> reconstructBatches = splitIntoBatches(unreadyList, params.worker_fetch_request_size); - for (List batch : reconstructBatches) { + for (List batch : reconstructBatches) { if (!params.use_raylet) { - for (UniqueID objectId : batch) { - localSchedulerProxy.reconstructObject(objectId, false); + for (UniqueId objectId : batch) { + localSchedulerClient.reconstructObject(objectId, false); } // Do another fetch for objects that aren't available locally yet, in case // they were evicted since the last fetch. objectStoreProxy.fetch(batch); } else { - localSchedulerProxy.reconstructObjects(batch, false); + localSchedulerClient.reconstructObjects(batch, false); } } List> results = objectStoreProxy - .get(unreadyList, params.default_get_check_interval_ms, isMetadata); + .get(unreadyList, params.default_get_check_interval_ms, false); // Remove any entries for objects we received during this iteration so we // don't retrieve the same object twice. for (int i = 0; i < results.size(); i++) { Pair value = results.get(i); if (value.getRight() == GetStatus.SUCCESS) { - UniqueID id = unreadyList.get(i); + UniqueId id = unreadyList.get(i); ret.set(unreadys.get(id), value); unreadys.remove(id); } @@ -350,26 +315,18 @@ public abstract class RayRuntime implements RayApi { // If there were objects that we weren't able to get locally, let the local // scheduler know that we're now unblocked. if (wasBlocked) { - localSchedulerProxy.notifyUnblocked(); + localSchedulerClient.notifyUnblocked(); } } } - private T doGet(UniqueID objectId, boolean isMetadata) throws TaskExecutionException { - ImmutableList objectIds = ImmutableList.of(objectId); - List results = doGet(objectIds, isMetadata); - - assert results.size() == 1; - return results.get(0); - } - - private List> splitIntoBatches(List objectIds, int batchSize) { - List> batches = new ArrayList<>(); + private List> splitIntoBatches(List objectIds, int batchSize) { + List> batches = new ArrayList<>(); int objectsSize = objectIds.size(); for (int i = 0; i < objectsSize; i += batchSize) { int endIndex = i + batchSize; - List batchIds = (endIndex < objectsSize) + List batchIds = (endIndex < objectsSize) ? objectIds.subList(i, endIndex) : objectIds.subList(i, objectsSize); @@ -379,11 +336,121 @@ public abstract class RayRuntime implements RayApi { return batches; } + @Override + public WaitResult wait(List> waitList, int numReturns, int timeoutMs) { + return objectStoreProxy.wait(waitList, numReturns, timeoutMs); + } + + @Override + public RayObject call(RayFunc func, Object[] args) { + TaskSpec spec = createTaskSpec(func, RayActorImpl.NIL, args, null); + localSchedulerClient.submitTask(spec); + return new RayObjectImpl(spec.returnIds[0]); + } + + @Override + public RayObject call(RayFunc func, RayActor actor, Object[] args) { + if (!(actor instanceof RayActorImpl)) { + throw new IllegalArgumentException("Unsupported actor type: " + actor.getClass().getName()); + } + RayActorImpl actorImpl = (RayActorImpl)actor; + TaskSpec spec = createTaskSpec(func, actorImpl, args, null); + actorImpl.setTaskCursor(spec.returnIds[1]); + localSchedulerClient.submitTask(spec); + return new RayObjectImpl(spec.returnIds[0]); + } + + @Override + @SuppressWarnings("unchecked") + public RayActor createActor(Class actorClass) { + RayFunc2 func = AbstractRayRuntime::createLocalActor; + TaskSpec spec = createTaskSpec(func, RayActorImpl.NIL, null, actorClass); + RayActorImpl actor = new RayActorImpl(spec.returnIds[0]); + actor.increaseTaskCounter(); + actor.setTaskCursor(spec.returnIds[0]); + localSchedulerClient.submitTask(spec); + return actor; + } + + @RayRemote + private static Object createLocalActor(UniqueId actorId, String className) { + try { + Class cls = Class.forName(className, true, Thread.currentThread().getContextClassLoader()); + Object actor = cls.getConstructor().newInstance(); + getInstance().actors.put(actorId, actor); + RayLog.core.info("Created actor: {}, actor id: {}", className, actorId); + return null; + } catch (ClassNotFoundException | InstantiationException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException | NoSuchMethodException + | SecurityException e) { + RayLog.core.error("Failed to create actor {}", className, e); + throw new TaskExecutionException(e); + } + } + /** - * get the object put identity of the currently running task, UniqueID.NIL if not inside any + * Generate the return ids of a task. */ - public UniqueID[] getCurrentTaskReturnIDs() { - return worker.getCurrentTaskReturnIDs(); + private UniqueId[] genReturnIds(UniqueId taskId, int numReturns) { + UniqueId[] ret = new UniqueId[numReturns]; + for (int i = 0; i < numReturns; i++) { + ret[i] = UniqueIdHelper.computeReturnId(taskId, i + 1); + } + return ret; + } + + /** + * Create the task specification. + * @param func The target remote function. + * @param actor The actor handle. If the task is not an actor task, actor id must be NIL. + * @param args The arguments for the remote function. + * @param actorClassForCreation If the task is a actor creation task, the argument should be + * the actor class. Otherwise, it should be null. + * @return A TaskSpec object. + */ + private TaskSpec createTaskSpec(RayFunc func, RayActorImpl actor, Object[] args, + Class actorClassForCreation) { + final TaskSpec current = WorkerContext.currentTask(); + UniqueId taskId = localSchedulerClient.generateTaskId(current.driverId, + current.taskId, + WorkerContext.nextCallIndex()); + int numReturns = actor.getId().isNil() ? 1 : 2; + UniqueId[] returnIds = genReturnIds(taskId, numReturns); + + UniqueId actorCreationId = UniqueId.NIL; + if (actorClassForCreation != null) { + args = new Object[] {returnIds[0], actorClassForCreation.getName()}; + actorCreationId = returnIds[0]; + } + + MethodId methodId = MethodId.fromSerializedLambda(func); + + // NOTE: we append the class name at the end of arguments, + // so that we can look up the method based on the class name. + // TODO(hchen): move class name to task spec. + args = Arrays.copyOf(args, args.length + 1); + args[args.length - 1] = methodId.className; + + RayMethod rayMethod = functions.getMethod( + current.driverId, actor.getId(), new UniqueId(methodId.getSha1Hash()), methodId.className + ).getRight(); + UniqueId funcId = rayMethod.getFuncId(); + + return new TaskSpec( + current.driverId, + taskId, + current.taskId, + -1, + actor.getId(), + actor.increaseTaskCounter(), + funcId, + ArgumentsBuilder.wrap(args), + returnIds, + actor.getHandleId(), + actorCreationId, + ResourceUtil.getResourcesMapFromArray(rayMethod.remoteAnnotation.resources()), + actor.getTaskCursor() + ); } /*********** @@ -397,13 +464,8 @@ public abstract class RayRuntime implements RayApi { /** * get actor with given id. */ - public abstract Object getLocalActor(UniqueID id); - - public PathConfig getPaths() { - return pathConfig; + public Object getLocalActor(UniqueId id) { + return actors.get(id); } - public RemoteFunctionManager getRemoteFunctionManager() { - return remoteFunctionManager; - } } \ No newline at end of file diff --git a/java/runtime-common/src/main/java/org/ray/core/ArgumentsBuilder.java b/java/runtime-common/src/main/java/org/ray/core/ArgumentsBuilder.java index 2f1d8449d..9250b32d6 100644 --- a/java/runtime-common/src/main/java/org/ray/core/ArgumentsBuilder.java +++ b/java/runtime-common/src/main/java/org/ray/core/ArgumentsBuilder.java @@ -1,22 +1,13 @@ package org.ray.core; -import java.io.Serializable; import java.lang.reflect.Method; -import java.lang.reflect.Modifier; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; import org.apache.commons.lang3.tuple.Pair; +import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.spi.model.FunctionArg; -import org.ray.spi.model.RayInvocation; import org.ray.spi.model.TaskSpec; -import org.ray.util.exception.TaskExecutionException; /** * arguments wrap and unwrap. @@ -24,36 +15,27 @@ import org.ray.util.exception.TaskExecutionException; public class ArgumentsBuilder { @SuppressWarnings({"rawtypes", "unchecked"}) - public static FunctionArg[] wrap(RayInvocation invocation) { - Object[] oargs = invocation.getArgs(); - FunctionArg[] fargs = new FunctionArg[oargs.length]; - int k = 0; - for (Object oarg : oargs) { - fargs[k] = new FunctionArg(); - if (oarg == null) { - fargs[k].data = Serializer.encode(null); - } else if (oarg.getClass().equals(RayActor.class)) { - // serialize actor unique id - if (k == 0) { - RayActorId aid = new RayActorId(); - aid.id = ((RayActor) oarg).getId(); - fargs[k].data = Serializer.encode(aid); - } else { // serialize actor handle - fargs[k].data = Serializer.encode(oarg); - } - } else if (oarg.getClass().equals(RayObject.class)) { - fargs[k].ids = new ArrayList<>(); - fargs[k].ids.add(((RayObject) oarg).getId()); - } else if (checkSimpleValue(oarg)) { - fargs[k].data = Serializer.encode(oarg); + public static FunctionArg[] wrap(Object[] args) { + FunctionArg[] ret = new FunctionArg[args.length]; + for (int i = 0; i < ret.length; i++) { + Object arg = args[i]; + UniqueId id = null; + byte[] data = null; + if (arg == null) { + data = Serializer.encode(null); + } else if (arg instanceof RayActor) { + data = Serializer.encode(arg); + } else if (arg instanceof RayObject) { + id = ((RayObject) arg).getId(); + } else if (checkSimpleValue(arg)) { + data = Serializer.encode(arg); } else { - //big parameter, use object store and pass future - fargs[k].ids = new ArrayList<>(); - fargs[k].ids.add(RayRuntime.getInstance().put(oarg).getId()); + RayObject obj = Ray.put(arg); + id = obj.getId(); } - k++; + ret[i] = new FunctionArg(id, data); } - return fargs; + return ret; } private static boolean checkSimpleValue(Object o) { @@ -61,52 +43,22 @@ public class ArgumentsBuilder { } @SuppressWarnings({"rawtypes", "unchecked"}) - public static Pair unwrap(TaskSpec task, Method m, ClassLoader classLoader) - throws TaskExecutionException { + public static Pair unwrap(TaskSpec task, Method m, ClassLoader classLoader) { // the last arg is className - - FunctionArg[] fargs = Arrays.copyOf(task.args, task.args.length - 1); - Object current = null; - Object[] realArgs; - - int start = 0; - - // check actor method - if (!Modifier.isStatic(m.getModifiers())) { - start = 1; - RayActorId actorId = Serializer.decode(fargs[0].data, classLoader); - current = RayRuntime.getInstance().getLocalActor(actorId.id); - realArgs = new Object[fargs.length - 1]; - } else { - realArgs = new Object[fargs.length]; - } - - int raIndex = 0; - for (int k = start; k < fargs.length; k++, raIndex++) { - FunctionArg farg = fargs[k]; - - // pass by value - if (farg.ids == null) { - Object obj = Serializer.decode(farg.data, classLoader); - - // due to remote lambda, method may be static - if (obj instanceof RayActorId) { - assert (k == 0); - realArgs[raIndex] = RayRuntime.getInstance().getLocalActor(((RayActorId) obj).id); - } else { - realArgs[raIndex] = obj; - } - } else if (farg.data == null) { // only ids, big data or single object id - assert (farg.ids.size() == 1); - realArgs[raIndex] = RayRuntime.getInstance().get(farg.ids.get(0)); + Object[] realArgs = new Object[task.args.length - 1]; + for (int i = 0; i < task.args.length - 1; i++) { + FunctionArg arg = task.args[i]; + if (arg.id == null) { + // pass by value + Object obj = Serializer.decode(arg.data, classLoader); + realArgs[i] = obj; + } else if (arg.data == null) { + // pass by reference + realArgs[i] = Ray.get(arg.id); } } - return Pair.of(current, realArgs); - } - - public static class RayActorId implements Serializable { - - private static final long serialVersionUID = 3993646395842605166L; - public UniqueID id; + Object actor = task.actorId.isNil() + ? null : AbstractRayRuntime.getInstance().getLocalActor(task.actorId); + return Pair.of(actor, realArgs); } } diff --git a/java/runtime-common/src/main/java/org/ray/core/InvocationExecutor.java b/java/runtime-common/src/main/java/org/ray/core/InvocationExecutor.java index e961217c6..4782e3d00 100644 --- a/java/runtime-common/src/main/java/org/ray/core/InvocationExecutor.java +++ b/java/runtime-common/src/main/java/org/ray/core/InvocationExecutor.java @@ -2,9 +2,8 @@ package org.ray.core; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.util.Map; import org.apache.commons.lang3.tuple.Pair; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.spi.model.RayMethod; import org.ray.spi.model.TaskSpec; import org.ray.util.exception.TaskExecutionException; @@ -33,7 +32,8 @@ public class InvocationExecutor { try { executeInternal(task, pr); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - if (!task.actorId.isNil() && RayRuntime.getInstance().getLocalActor(task.actorId) == null) { + if (!task.actorId.isNil() + && AbstractRayRuntime.getInstance().getLocalActor(task.actorId) == null) { ex = new TaskExecutionException("Task " + taskdesc + " execution on actor " + task.actorId + " failed as the actor is not present ", e); RayLog.core.error("Task " + taskdesc + " execution on actor " + task.actorId @@ -80,7 +80,7 @@ public class InvocationExecutor { if (task.returnIds == null || task.returnIds.length == 0) { return; } - RayRuntime.getInstance().putRaw(task.returnIds[0], result); + AbstractRayRuntime.getInstance().put(task.returnIds[0], result); } private static String formatTaskExecutionExceptionMsg(TaskSpec task, String funcName) { @@ -88,7 +88,7 @@ public class InvocationExecutor { + " failed with function name = " + funcName; } - private static void safePut(UniqueID objectId, Object obj) { - RayRuntime.getInstance().putRaw(objectId, obj); + private static void safePut(UniqueId objectId, Object obj) { + AbstractRayRuntime.getInstance().put(objectId, obj); } } \ No newline at end of file diff --git a/java/runtime-common/src/main/java/org/ray/core/LocalFunctionManager.java b/java/runtime-common/src/main/java/org/ray/core/LocalFunctionManager.java index 5d3f97993..0eb9beb2e 100644 --- a/java/runtime-common/src/main/java/org/ray/core/LocalFunctionManager.java +++ b/java/runtime-common/src/main/java/org/ray/core/LocalFunctionManager.java @@ -3,7 +3,7 @@ package org.ray.core; import com.google.common.base.Preconditions; import java.util.concurrent.ConcurrentHashMap; import org.apache.commons.lang3.tuple.Pair; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.spi.RemoteFunctionManager; import org.ray.spi.model.FunctionArg; import org.ray.spi.model.RayActorMethods; @@ -18,7 +18,7 @@ public class LocalFunctionManager { private final RemoteFunctionManager remoteLoader; - private final ConcurrentHashMap functionTables + private final ConcurrentHashMap functionTables = new ConcurrentHashMap<>(); /** @@ -29,7 +29,7 @@ public class LocalFunctionManager { this.remoteLoader = remoteLoader; } - private FunctionTable loadDriverFunctions(UniqueID driverId) { + private FunctionTable loadDriverFunctions(UniqueId driverId) { FunctionTable functionTable = functionTables.get(driverId); if (functionTable == null) { RayLog.core.info("DriverId " + driverId + " Try to load functions"); @@ -44,8 +44,8 @@ public class LocalFunctionManager { return functionTable; } - Pair getMethod(UniqueID driverId, UniqueID actorId, - UniqueID methodId, String className) { + Pair getMethod(UniqueId driverId, UniqueId actorId, + UniqueId methodId, String className) { // assert the driver's resource is load. FunctionTable functionTable = loadDriverFunctions(driverId); Preconditions.checkNotNull(functionTable, "driver's resource is not loaded:%s", driverId); @@ -61,8 +61,8 @@ public class LocalFunctionManager { * get local method for executing, which pulls information from remote repo on-demand, therefore * it may block for a while if the related resources (e.g., jars) are not ready on local machine */ - public Pair getMethod(UniqueID driverId, UniqueID actorId, - UniqueID methodId, + public Pair getMethod(UniqueId driverId, UniqueId actorId, + UniqueId methodId, FunctionArg[] args) throws NoSuchMethodException, SecurityException, ClassNotFoundException { Preconditions.checkArgument(args.length >= 1, "method's args len %s<=1", args.length); String className = (String) Serializer.decode(args[args.length - 1].data); @@ -72,7 +72,7 @@ public class LocalFunctionManager { /** * unload the functions when the driver is declared dead. */ - public synchronized void removeApp(UniqueID driverId) { + public synchronized void removeApp(UniqueId driverId) { FunctionTable funcs = functionTables.get(driverId); if (funcs != null) { functionTables.remove(driverId); @@ -90,7 +90,7 @@ public class LocalFunctionManager { this.classLoader = classLoader; } - RayMethod getTaskMethod(UniqueID methodId, String className) { + RayMethod getTaskMethod(UniqueId methodId, String className) { RayTaskMethods tasks = taskMethods.get(className); if (tasks == null) { tasks = RayTaskMethods.fromClass(className, classLoader); @@ -105,11 +105,11 @@ public class LocalFunctionManager { return getActorMethod(methodId, className, true); } - RayMethod getActorMethod(UniqueID methodId, String className) { + RayMethod getActorMethod(UniqueId methodId, String className) { return getActorMethod(methodId, className, false); } - private RayMethod getActorMethod(UniqueID methodId, String className, boolean isStatic) { + private RayMethod getActorMethod(UniqueId methodId, String className, boolean isStatic) { RayActorMethods actor = actors.get(className); if (actor == null) { actor = RayActorMethods.fromClass(className, classLoader); diff --git a/java/runtime-common/src/main/java/org/ray/core/RayActorImpl.java b/java/runtime-common/src/main/java/org/ray/core/RayActorImpl.java new file mode 100644 index 000000000..3f3c9642a --- /dev/null +++ b/java/runtime-common/src/main/java/org/ray/core/RayActorImpl.java @@ -0,0 +1,89 @@ +package org.ray.core; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import org.ray.api.RayActor; +import org.ray.api.id.UniqueId; +import org.ray.util.Sha1Digestor; + +public final class RayActorImpl implements RayActor, Externalizable { + + public static final RayActorImpl NIL = new RayActorImpl(); + + private UniqueId id; + private UniqueId handleId; + /** + * The number of tasks that have been invoked on this actor. + */ + private int taskCounter; + /** + * The unique id of the last return of the last task. + * It's used as a dependency for the next task. + */ + private UniqueId taskCursor; + /** + * The number of times that this actor handle has been forked. + * It's used to make sure ids of actor handles are unique. + */ + private int numForks; + + public RayActorImpl() { + this(UniqueId.NIL, UniqueId.NIL); + } + + public RayActorImpl(UniqueId id) { + this(id, UniqueId.NIL); + } + + public RayActorImpl(UniqueId id, UniqueId handleId) { + this.id = id; + this.handleId = handleId; + this.taskCounter = 0; + this.taskCursor = null; + numForks = 0; + } + + @Override + public UniqueId getId() { + return id; + } + + @Override + public UniqueId getHandleId() { + return handleId; + } + + public void setTaskCursor(UniqueId taskCursor) { + this.taskCursor = taskCursor; + } + + public UniqueId getTaskCursor() { + return taskCursor; + } + + public int increaseTaskCounter() { + return taskCounter++; + } + + + private UniqueId computeNextActorHandleId() { + byte[] bytes = Sha1Digestor.digest(handleId.getBytes(), ++numForks); + return new UniqueId(bytes); + } + + @Override + public void writeExternal(ObjectOutput out) throws IOException { + out.writeObject(this.id); + out.writeObject(this.computeNextActorHandleId()); + out.writeObject(this.taskCursor); + } + + @Override + public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + this.id = (UniqueId) in.readObject(); + this.handleId = (UniqueId) in.readObject(); + this.taskCursor = (UniqueId) in.readObject(); + } +} diff --git a/java/runtime-common/src/main/java/org/ray/core/RayObjectImpl.java b/java/runtime-common/src/main/java/org/ray/core/RayObjectImpl.java new file mode 100644 index 000000000..2dddf91f4 --- /dev/null +++ b/java/runtime-common/src/main/java/org/ray/core/RayObjectImpl.java @@ -0,0 +1,26 @@ +package org.ray.core; + +import java.io.Serializable; +import org.ray.api.Ray; +import org.ray.api.RayObject; +import org.ray.api.id.UniqueId; + +public final class RayObjectImpl implements RayObject, Serializable { + + private final UniqueId id; + + public RayObjectImpl(UniqueId id) { + this.id = id; + } + + @Override + public T get() { + return Ray.get(id); + } + + @Override + public UniqueId getId() { + return id; + } + +} diff --git a/java/runtime-common/src/main/java/org/ray/core/UniqueIdHelper.java b/java/runtime-common/src/main/java/org/ray/core/UniqueIdHelper.java index 7cb4e4dd5..0dc8e5b5a 100644 --- a/java/runtime-common/src/main/java/org/ray/core/UniqueIdHelper.java +++ b/java/runtime-common/src/main/java/org/ray/core/UniqueIdHelper.java @@ -3,12 +3,14 @@ package org.ray.core; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.Arrays; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; -// -// Helper methods for UniqueID. These are the same as the helper functions in src/ray/id.h. -// +/** + * Helper method for UniqueId. + * Note: any changes to these methods must be synced with C++ helper functions + * in src/ray/id.h + */ public class UniqueIdHelper { public static final int OBJECT_INDEX_POS = 0; public static final int OBJECT_INDEX_LENGTH = 4; @@ -20,7 +22,7 @@ public class UniqueIdHelper { * @param returnIndex What number return value this object is in the task. * @return The computed object ID. */ - public static UniqueID computeReturnId(UniqueID taskId, int returnIndex) { + public static UniqueId computeReturnId(UniqueId taskId, int returnIndex) { return computeObjectId(taskId, returnIndex); } @@ -30,14 +32,14 @@ public class UniqueIdHelper { * @param index The index which can distinguish different objects in one task. * @return The computed object ID. */ - private static UniqueID computeObjectId(UniqueID taskId, int index) { - byte[] objId = new byte[UniqueID.LENGTH]; - System.arraycopy(taskId.getBytes(),0, objId, 0, UniqueID.LENGTH); + private static UniqueId computeObjectId(UniqueId taskId, int index) { + byte[] objId = new byte[UniqueId.LENGTH]; + System.arraycopy(taskId.getBytes(),0, objId, 0, UniqueId.LENGTH); ByteBuffer wbb = ByteBuffer.wrap(objId); wbb.order(ByteOrder.LITTLE_ENDIAN); wbb.putInt(UniqueIdHelper.OBJECT_INDEX_POS, index); - return new UniqueID(objId); + return new UniqueId(objId); } /** @@ -47,7 +49,7 @@ public class UniqueIdHelper { * @param putIndex What number put this object was created by in the task. * @return The computed object ID. */ - public static UniqueID computePutId(UniqueID taskId, int putIndex) { + public static UniqueId computePutId(UniqueId taskId, int putIndex) { // We multiply putIndex by -1 to distinguish from returnIndex. return computeObjectId(taskId, -1 * putIndex); } @@ -58,13 +60,13 @@ public class UniqueIdHelper { * @param objectId The object ID. * @return The task ID of the task that created this object. */ - public static UniqueID computeTaskId(UniqueID objectId) { - byte[] taskId = new byte[UniqueID.LENGTH]; - System.arraycopy(objectId.getBytes(), 0, taskId, 0, UniqueID.LENGTH); + public static UniqueId computeTaskId(UniqueId objectId) { + byte[] taskId = new byte[UniqueId.LENGTH]; + System.arraycopy(objectId.getBytes(), 0, taskId, 0, UniqueId.LENGTH); Arrays.fill(taskId, UniqueIdHelper.OBJECT_INDEX_POS, UniqueIdHelper.OBJECT_INDEX_POS + UniqueIdHelper.OBJECT_INDEX_LENGTH, (byte) 0); - return new UniqueID(taskId); + return new UniqueId(taskId); } } diff --git a/java/runtime-common/src/main/java/org/ray/core/Worker.java b/java/runtime-common/src/main/java/org/ray/core/Worker.java index f6d05c50f..8f465cd46 100644 --- a/java/runtime-common/src/main/java/org/ray/core/Worker.java +++ b/java/runtime-common/src/main/java/org/ray/core/Worker.java @@ -1,19 +1,11 @@ package org.ray.core; -import com.google.common.base.Preconditions; -import java.util.Arrays; import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.tuple.Pair; -import org.ray.api.RayActor; -import org.ray.api.RayObject; -import org.ray.api.UniqueID; -import org.ray.api.funcs.RayFunc; -import org.ray.spi.LocalSchedulerProxy; -import org.ray.spi.model.RayInvocation; +import org.ray.api.id.UniqueId; +import org.ray.spi.LocalSchedulerLink; import org.ray.spi.model.RayMethod; import org.ray.spi.model.TaskSpec; -import org.ray.util.MethodId; -import org.ray.util.exception.TaskExecutionException; import org.ray.util.logger.RayLog; /** @@ -22,10 +14,10 @@ import org.ray.util.logger.RayLog; */ public class Worker { - private final LocalSchedulerProxy scheduler; + private final LocalSchedulerLink scheduler; private final LocalFunctionManager functions; - public Worker(LocalSchedulerProxy scheduler, LocalFunctionManager functions) { + public Worker(LocalSchedulerLink scheduler, LocalFunctionManager functions) { this.scheduler = scheduler; this.functions = functions; } @@ -39,8 +31,7 @@ public class Worker { } public static void execute(TaskSpec task, LocalFunctionManager funcs) { - RayLog.core.info("Task " + task.taskId + " start execute"); - Throwable ex = null; + RayLog.core.info("Executing task {}", task.taskId); if (!task.actorId.isNil() || (task.createActorId != null && !task.createActorId.isNil())) { task.returnIds = ArrayUtils.subarray(task.returnIds, 0, task.returnIds.length - 1); @@ -51,85 +42,23 @@ public class Worker { .getMethod(task.driverId, task.actorId, task.functionId, task.args); WorkerContext.prepare(task, pr.getLeft()); InvocationExecutor.execute(task, pr); - } catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) { - RayLog.core.error("task execution failed for " + task.taskId, e); - ex = new TaskExecutionException("task execution failed for " + task.taskId, e); - } catch (Throwable e) { - RayLog.core.error("catch Throwable when execute for " + task.taskId, e); - ex = e; - } - - if (ex != null) { - for (int k = 0; k < task.returnIds.length; k++) { - RayRuntime.getInstance().putRaw(task.returnIds[k], ex); - } - } - - } - - private RayObject taskSubmit(UniqueID taskId, MethodId methodId, Object[] args) { - RayInvocation ri = createRemoteInvocation(methodId, args, RayActor.NIL); - return scheduler.submit(taskId, ri); - } - - private RayObject actorTaskSubmit(UniqueID taskId, MethodId methodId, Object[] args, - RayActor actor) { - RayInvocation ri = createRemoteInvocation(methodId, args, actor); - RayObject ret = scheduler.submitActorTask(taskId, ri); - actor.setTaskCursor(ret.getId()); - return ret; - } - - public RayObject submit(RayFunc func, Object[] args) { - MethodId methodId = methodIdOf(func); - UniqueID taskId = scheduler.generateTaskId(WorkerContext.currentTask().driverId, - WorkerContext.currentTask().taskId, - WorkerContext.nextCallIndex()); - if (args.length > 0 && args[0].getClass().equals(RayActor.class)) { - return actorTaskSubmit(taskId, methodId, args, (RayActor) args[0]); - } else { - return taskSubmit(taskId, methodId, args); + RayLog.core.info("Finished executing task {}", task.taskId); + } catch (Exception e) { + RayLog.core.error("Failed to execute task " + task.taskId, e); + AbstractRayRuntime.getInstance().put(task.returnIds[0], e); } } - public RayObject createActor(UniqueID taskId, UniqueID createActorId, - RayFunc func, Object[] args) { - Preconditions.checkNotNull(taskId); - MethodId mid = methodIdOf(func); - RayInvocation ri = createRemoteInvocation(mid, args, RayActor.NIL); - return scheduler.submitActorCreationTask(taskId, createActorId, ri); - } - - private RayInvocation createRemoteInvocation(MethodId methodId, Object[] args, - RayActor actor) { - UniqueID driverId = WorkerContext.currentTask().driverId; - - Object[] ls = Arrays.copyOf(args, args.length + 1); - ls[args.length] = methodId.className; - - RayMethod method = functions - .getMethod(driverId, actor.getId(), new UniqueID(methodId.getSha1Hash()), - methodId.className).getRight(); - - RayInvocation ri = new RayInvocation(methodId.className, method.getFuncId(), - ls, method.remoteAnnotation, actor); - return ri; - } - - private MethodId methodIdOf(RayFunc serialLambda) { - return MethodId.fromSerializedLambda(serialLambda); - } - - public UniqueID getCurrentTaskId() { + public UniqueId getCurrentTaskId() { return WorkerContext.currentTask().taskId; } - public UniqueID getCurrentTaskNextPutId() { + public UniqueId getCurrentTaskNextPutId() { return UniqueIdHelper.computePutId( WorkerContext.currentTask().taskId, WorkerContext.nextPutIndex()); } - public UniqueID[] getCurrentTaskReturnIDs() { + public UniqueId[] getCurrentTaskReturnIDs() { return WorkerContext.currentTask().returnIds; } -} \ No newline at end of file +} diff --git a/java/runtime-common/src/main/java/org/ray/core/WorkerContext.java b/java/runtime-common/src/main/java/org/ray/core/WorkerContext.java index 0b19fb31d..a078a52f3 100644 --- a/java/runtime-common/src/main/java/org/ray/core/WorkerContext.java +++ b/java/runtime-common/src/main/java/org/ray/core/WorkerContext.java @@ -1,6 +1,6 @@ package org.ray.core; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.core.model.RayParameters; import org.ray.core.model.WorkerMode; import org.ray.spi.model.TaskSpec; @@ -8,11 +8,11 @@ import org.ray.spi.model.TaskSpec; public class WorkerContext { private static final ThreadLocal currentWorkerCtx = - ThreadLocal.withInitial(() -> init(RayRuntime.getParams())); + ThreadLocal.withInitial(() -> init(AbstractRayRuntime.getParams())); /** * id of worker. */ - public static UniqueID workerID = UniqueID.randomId(); + public static UniqueId workerID = UniqueId.randomId(); /** * current doing task. */ @@ -35,13 +35,13 @@ public class WorkerContext { currentWorkerCtx.set(ctx); TaskSpec dummy = new TaskSpec(); - dummy.parentTaskId = UniqueID.NIL; + dummy.parentTaskId = UniqueId.NIL; if (params.worker_mode == WorkerMode.DRIVER) { - dummy.taskId = UniqueID.randomId(); + dummy.taskId = UniqueId.randomId(); } else { - dummy.taskId = UniqueID.NIL; + dummy.taskId = UniqueId.NIL; } - dummy.actorId = UniqueID.NIL; + dummy.actorId = UniqueId.NIL; dummy.driverId = params.driver_id; prepare(dummy, null); @@ -72,7 +72,7 @@ public class WorkerContext { return ++get().currentTaskCallCount; } - public static UniqueID currentWorkerId() { + public static UniqueId currentWorkerId() { return WorkerContext.workerID; } diff --git a/java/runtime-common/src/main/java/org/ray/core/model/RayParameters.java b/java/runtime-common/src/main/java/org/ray/core/model/RayParameters.java index a240b7c4f..a17daa9d6 100644 --- a/java/runtime-common/src/main/java/org/ray/core/model/RayParameters.java +++ b/java/runtime-common/src/main/java/org/ray/core/model/RayParameters.java @@ -1,6 +1,6 @@ package org.ray.core.model; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.util.NetworkUtil; import org.ray.util.config.AConfig; import org.ray.util.config.ConfigReader; @@ -44,7 +44,7 @@ public class RayParameters { public int local_scheduler_rpc_port = 34567; @AConfig(comment = "driver ID when the worker is served as a driver") - public UniqueID driver_id = UniqueID.NIL; + public UniqueId driver_id = UniqueId.NIL; @AConfig(comment = "logging directory") public String log_dir = "/tmp/raylogs"; diff --git a/java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerLink.java b/java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerLink.java index ed07d5524..04e201149 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerLink.java +++ b/java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerLink.java @@ -1,7 +1,7 @@ package org.ray.spi; import java.util.List; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.spi.model.TaskSpec; /** @@ -13,15 +13,15 @@ public interface LocalSchedulerLink { TaskSpec getTask(); - void markTaskPutDependency(UniqueID taskId, UniqueID objectId); + void markTaskPutDependency(UniqueId taskId, UniqueId objectId); - void reconstructObject(UniqueID objectId, boolean fetchOnly); + void reconstructObject(UniqueId objectId, boolean fetchOnly); - void reconstructObjects(List objectIds, boolean fetchOnly); + void reconstructObjects(List objectIds, boolean fetchOnly); void notifyUnblocked(); - UniqueID generateTaskId(UniqueID driverId, UniqueID parentTaskId, int taskIndex); + UniqueId generateTaskId(UniqueId driverId, UniqueId parentTaskId, int taskIndex); List wait(byte[][] objectIds, int timeoutMs, int numReturns); } diff --git a/java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerProxy.java b/java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerProxy.java deleted file mode 100644 index 6a9d9861a..000000000 --- a/java/runtime-common/src/main/java/org/ray/spi/LocalSchedulerProxy.java +++ /dev/null @@ -1,136 +0,0 @@ -package org.ray.spi; - -import java.util.ArrayList; -import java.util.List; -import org.ray.api.RayObject; -import org.ray.api.UniqueID; -import org.ray.api.WaitResult; -import org.ray.core.ArgumentsBuilder; -import org.ray.core.UniqueIdHelper; -import org.ray.core.WorkerContext; -import org.ray.spi.model.RayInvocation; -import org.ray.spi.model.TaskSpec; -import org.ray.util.ResourceUtil; -import org.ray.util.logger.RayLog; - -/** - * Local scheduler proxy, which provides a user-friendly facet on top of {code - * org.ray.spi.LocalSchedulerLink}. - */ -@SuppressWarnings("rawtypes") -public class LocalSchedulerProxy { - - private final LocalSchedulerLink scheduler; - - public LocalSchedulerProxy(LocalSchedulerLink scheduler) { - this.scheduler = scheduler; - } - - public RayObject submit(UniqueID taskId, RayInvocation invocation) { - UniqueID[] returnIds = genReturnIds(taskId, 1); - this.doSubmit(invocation, taskId, returnIds, UniqueID.NIL); - return new RayObject(returnIds[0]); - } - - public RayObject submitActorTask(UniqueID taskId, RayInvocation invocation) { - // add one for the dummy return ID - UniqueID[] returnIds = genReturnIds(taskId, 2); - this.doSubmit(invocation, taskId, returnIds, UniqueID.NIL); - return new RayObject(returnIds[0]); - } - - public RayObject submitActorCreationTask(UniqueID taskId, UniqueID createActorId, - RayInvocation invocation) { - UniqueID[] returnIds = genReturnIds(taskId, 1); - this.doSubmit(invocation, taskId, returnIds, createActorId); - return new RayObject(returnIds[0]); - } - - // generate the return ids of a task. - private UniqueID[] genReturnIds(UniqueID taskId, int numReturns) { - UniqueID[] ret = new UniqueID[numReturns]; - for (int i = 0; i < numReturns; i++) { - ret[i] = UniqueIdHelper.computeReturnId(taskId, i + 1); - } - return ret; - } - - private void doSubmit(RayInvocation invocation, UniqueID taskId, UniqueID[] returnIds, - UniqueID createActorId) { - - final TaskSpec current = WorkerContext.currentTask(); - TaskSpec task = new TaskSpec(); - task.actorCounter = invocation.getActor().increaseTaskCounter(); - task.actorId = invocation.getActor().getId(); - task.createActorId = createActorId; - - task.args = ArgumentsBuilder.wrap(invocation); - task.driverId = current.driverId; - task.functionId = invocation.getId(); - task.parentCounter = -1; // TODO: this field is not used in core or python logically yet - task.parentTaskId = current.taskId; - task.actorHandleId = invocation.getActor().getActorHandleId(); - task.taskId = taskId; - task.returnIds = returnIds; - task.cursorId = invocation.getActor() != null ? invocation.getActor().getTaskCursor() : null; - task.resources = ResourceUtil.getResourcesMapFromArray( - invocation.getRemoteAnnotation().resources()); - - scheduler.submitTask(task); - } - - public TaskSpec getTask() { - TaskSpec ts = scheduler.getTask(); - RayLog.core.info("Task " + ts.taskId.toString() + " received"); - return ts; - } - - public void markTaskPutDependency(UniqueID taskId, UniqueID objectId) { - scheduler.markTaskPutDependency(taskId, objectId); - } - - public void reconstructObject(UniqueID objectId, boolean fetchOnly) { - scheduler.reconstructObject(objectId, fetchOnly); - } - - public void reconstructObjects(List objectIds, boolean fetchOnly) { - scheduler.reconstructObjects(objectIds, fetchOnly); - } - - public void notifyUnblocked() { - scheduler.notifyUnblocked(); - } - - private static byte[][] getIdBytes(List objectIds) { - int size = objectIds.size(); - byte[][] ids = new byte[size][]; - for (int i = 0; i < size; i++) { - ids[i] = objectIds.get(i).getBytes(); - } - return ids; - } - - public WaitResult wait(List> waitfor, int numReturns, int timeout) { - List ids = new ArrayList<>(); - for (RayObject obj : waitfor) { - ids.add(obj.getId()); - } - List readys = scheduler.wait(getIdBytes(ids), timeout, numReturns); - - List> readyObjs = new ArrayList<>(); - List> remainObjs = new ArrayList<>(); - for (RayObject obj : waitfor) { - if (readys.contains(obj.getId().getBytes())) { - readyObjs.add(obj); - } else { - remainObjs.add(obj); - } - } - - return new WaitResult<>(readyObjs, remainObjs); - } - - public UniqueID generateTaskId(UniqueID driverId, UniqueID parentTaskId, int taskIndex) { - return scheduler.generateTaskId(driverId, parentTaskId, taskIndex); - } -} diff --git a/java/runtime-common/src/main/java/org/ray/spi/NopRemoteFunctionManager.java b/java/runtime-common/src/main/java/org/ray/spi/NopRemoteFunctionManager.java index d72e6347b..370ffb8dc 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/NopRemoteFunctionManager.java +++ b/java/runtime-common/src/main/java/org/ray/spi/NopRemoteFunctionManager.java @@ -1,57 +1,57 @@ package org.ray.spi; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; /** * mock version of remote function manager using local loaded jars. */ public class NopRemoteFunctionManager implements RemoteFunctionManager { - public NopRemoteFunctionManager(UniqueID driverId) { + public NopRemoteFunctionManager(UniqueId driverId) { //onLoad(driverId, Agent.hookedMethods); //Agent.consumers.add(m -> { this.onLoad(m); }); } @Override - public UniqueID registerResource(byte[] resourceZip) { + public UniqueId registerResource(byte[] resourceZip) { return null; // nothing to do } @Override - public byte[] getResource(UniqueID resourceId) { + public byte[] getResource(UniqueId resourceId) { return null; } @Override - public void unregisterResource(UniqueID resourceId) { + public void unregisterResource(UniqueId resourceId) { // nothing to do } @Override - public void registerApp(UniqueID driverId, UniqueID resourceId) { + public void registerApp(UniqueId driverId, UniqueId resourceId) { // nothing to do } @Override - public UniqueID getAppResourceId(UniqueID driverId) { + public UniqueId getAppResourceId(UniqueId driverId) { return null; // nothing to do } @Override - public void unregisterApp(UniqueID driverId) { + public void unregisterApp(UniqueId driverId) { // nothing to do } @Override - public ClassLoader loadResource(UniqueID driverId) { + public ClassLoader loadResource(UniqueId driverId) { //assert (startupDriverId().equals(driverId)); return this.getClass().getClassLoader(); } @Override - public void unloadFunctions(UniqueID driverId) { + public void unloadFunctions(UniqueId driverId) { // never //assert (startupDriverId().equals(driverId)); } diff --git a/java/runtime-common/src/main/java/org/ray/spi/ObjectStoreProxy.java b/java/runtime-common/src/main/java/org/ray/spi/ObjectStoreProxy.java index 9a1ab6f11..25b78223f 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/ObjectStoreProxy.java +++ b/java/runtime-common/src/main/java/org/ray/spi/ObjectStoreProxy.java @@ -5,11 +5,10 @@ import java.util.List; import org.apache.arrow.plasma.ObjectStoreLink; import org.apache.commons.lang3.tuple.Pair; import org.ray.api.RayObject; -import org.ray.api.UniqueID; import org.ray.api.WaitResult; +import org.ray.api.id.UniqueId; import org.ray.core.Serializer; import org.ray.core.WorkerContext; -import org.ray.spi.LocalSchedulerLink; import org.ray.util.exception.TaskExecutionException; /** @@ -32,12 +31,12 @@ public class ObjectStoreProxy { this.localSchedulerLink = localSchedulerLink; } - public Pair get(UniqueID objectId, boolean isMetadata) + public Pair get(UniqueId objectId, boolean isMetadata) throws TaskExecutionException { return get(objectId, getTimeoutMs, isMetadata); } - public Pair get(UniqueID id, int timeoutMs, boolean isMetadata) + public Pair get(UniqueId id, int timeoutMs, boolean isMetadata) throws TaskExecutionException { byte[] obj = store.get(id.getBytes(), timeoutMs, isMetadata); if (obj != null) { @@ -52,12 +51,12 @@ public class ObjectStoreProxy { } } - public List> get(List objectIds, boolean isMetadata) + public List> get(List objectIds, boolean isMetadata) throws TaskExecutionException { return get(objectIds, getTimeoutMs, isMetadata); } - public List> get(List ids, int timeoutMs, boolean isMetadata) + public List> get(List ids, int timeoutMs, boolean isMetadata) throws TaskExecutionException { List objs = store.get(getIdBytes(ids), timeoutMs, isMetadata); List> ret = new ArrayList<>(); @@ -77,7 +76,7 @@ public class ObjectStoreProxy { return ret; } - private static byte[][] getIdBytes(List objectIds) { + private static byte[][] getIdBytes(List objectIds) { int size = objectIds.size(); byte[][] ids = new byte[size][]; for (int i = 0; i < size; i++) { @@ -86,12 +85,12 @@ public class ObjectStoreProxy { return ids; } - public void put(UniqueID id, Object obj, Object metadata) { + public void put(UniqueId id, Object obj, Object metadata) { store.put(id.getBytes(), Serializer.encode(obj), Serializer.encode(metadata)); } public WaitResult wait(List> waitfor, int numReturns, int timeout) { - List ids = new ArrayList<>(); + List ids = new ArrayList<>(); for (RayObject obj : waitfor) { ids.add(obj.getId()); } @@ -102,20 +101,20 @@ public class ObjectStoreProxy { readys = localSchedulerLink.wait(getIdBytes(ids), timeout, numReturns); } - List> readyObjs = new ArrayList<>(); - List> remainObjs = new ArrayList<>(); + List> readyList = new ArrayList<>(); + List> unreadyList = new ArrayList<>(); for (RayObject obj : waitfor) { if (readys.contains(obj.getId().getBytes())) { - readyObjs.add(obj); + readyList.add(obj); } else { - remainObjs.add(obj); + unreadyList.add(obj); } } - return new WaitResult<>(readyObjs, remainObjs); + return new WaitResult<>(readyList, unreadyList); } - public void fetch(List objectIds) { + public void fetch(List objectIds) { if (localSchedulerLink == null) { store.fetch(getIdBytes(objectIds)); } else { diff --git a/java/runtime-common/src/main/java/org/ray/spi/RemoteFunctionManager.java b/java/runtime-common/src/main/java/org/ray/spi/RemoteFunctionManager.java index 8b221b482..338eaf991 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/RemoteFunctionManager.java +++ b/java/runtime-common/src/main/java/org/ray/spi/RemoteFunctionManager.java @@ -1,6 +1,6 @@ package org.ray.spi; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; /** * register and load functions from function table. @@ -15,14 +15,14 @@ public interface RemoteFunctionManager { * @param resourceZip a directory zip from @JarRewriter * @return SHA-1 hash of the content */ - UniqueID registerResource(byte[] resourceZip); + UniqueId registerResource(byte[] resourceZip); /** * download resource content. * * @return resource content */ - byte[] getResource(UniqueID resourceId); + byte[] getResource(UniqueId resourceId); /** * remove resource by its hash id @@ -30,35 +30,35 @@ public interface RemoteFunctionManager { * * @param resourceId SHA-1 hash of the resource zip bytes */ - void unregisterResource(UniqueID resourceId); + void unregisterResource(UniqueId resourceId); /* * register the mapping to repo, * this function is invoked by whoever initiates the driver id */ - void registerApp(UniqueID driverId, UniqueID resourceId); + void registerApp(UniqueId driverId, UniqueId resourceId); /** * get the resourceId of one app. * * @return resourceId of the app driver */ - UniqueID getAppResourceId(UniqueID driverId); + UniqueId getAppResourceId(UniqueId driverId); /* * unregister mapping * this function is called when the driver exits or detected dead */ - void unregisterApp(UniqueID driverId); + void unregisterApp(UniqueId driverId); /** * load resource. */ - ClassLoader loadResource(UniqueID driverId); + ClassLoader loadResource(UniqueId driverId); /** * unload functions for this driver * this function is used by the workers on demand when a driver is dead. */ - void unloadFunctions(UniqueID driverId); + void unloadFunctions(UniqueId driverId); } \ No newline at end of file diff --git a/java/runtime-common/src/main/java/org/ray/spi/model/FunctionArg.java b/java/runtime-common/src/main/java/org/ray/spi/model/FunctionArg.java index ab147bd68..6cf52275f 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/model/FunctionArg.java +++ b/java/runtime-common/src/main/java/org/ray/spi/model/FunctionArg.java @@ -1,17 +1,21 @@ package org.ray.spi.model; -import java.util.ArrayList; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; /** * Represents arguments for ray function calls. */ public class FunctionArg { - public ArrayList ids; - public byte[] data; + public final UniqueId id; + public final byte[] data; + + public FunctionArg(UniqueId id, byte[] data) { + this.id = id; + this.data = data; + } public void toString(StringBuilder builder) { - builder.append("ids: ").append(ids).append(", ").append(":").append(data); + builder.append("ids: ").append(id).append(", ").append(":").append(data); } } diff --git a/java/runtime-common/src/main/java/org/ray/spi/model/RayActorMethods.java b/java/runtime-common/src/main/java/org/ray/spi/model/RayActorMethods.java index 68a95c0ec..69ebf770e 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/model/RayActorMethods.java +++ b/java/runtime-common/src/main/java/org/ray/spi/model/RayActorMethods.java @@ -6,22 +6,22 @@ import java.lang.reflect.Modifier; import java.util.Collections; import java.util.HashMap; import java.util.Map; -import org.ray.api.RayRemote; -import org.ray.api.UniqueID; +import org.ray.api.annotation.RayRemote; +import org.ray.api.id.UniqueId; public final class RayActorMethods { public final Class clazz; public final RayRemote remoteAnnotation; - public final Map functions; + public final Map functions; /** * the static function in Actor, call as task. */ - public final Map staticFunctions; + public final Map staticFunctions; private RayActorMethods(Class clazz, RayRemote remoteAnnotation, - Map functions, Map staticFunctions) { + Map functions, Map staticFunctions) { this.clazz = clazz; this.remoteAnnotation = remoteAnnotation; this.functions = Collections.unmodifiableMap(new HashMap<>(functions)); @@ -35,8 +35,8 @@ public final class RayActorMethods { Preconditions .checkNotNull(remoteAnnotation, "%s must declare @RayRemote", clazzName); Method[] methods = clazz.getDeclaredMethods(); - Map functions = new HashMap<>(methods.length * 2); - Map staticFunctions = new HashMap<>(methods.length * 2); + Map functions = new HashMap<>(methods.length * 2); + Map staticFunctions = new HashMap<>(methods.length * 2); for (Method m : methods) { if (!Modifier.isPublic(m.getModifiers())) { diff --git a/java/runtime-common/src/main/java/org/ray/spi/model/RayInvocation.java b/java/runtime-common/src/main/java/org/ray/spi/model/RayInvocation.java deleted file mode 100644 index 40dbe40cf..000000000 --- a/java/runtime-common/src/main/java/org/ray/spi/model/RayInvocation.java +++ /dev/null @@ -1,56 +0,0 @@ -package org.ray.spi.model; - -import org.ray.api.RayActor; -import org.ray.api.RayRemote; -import org.ray.api.UniqueID; - -/** - * Represents an invocation of ray remote function. - */ -public class RayInvocation { - - private static final RayActor nil = new RayActor<>(UniqueID.NIL, UniqueID.NIL); - public final String className; - /** - * unique id for a method. - */ - private final UniqueID id; - private final RayRemote remoteAnnotation; - /** - * function arguments. - */ - private Object[] args; - - - private RayActor actor; - - public RayInvocation(String className, UniqueID id, Object[] args, RayRemote remoteAnnotation, - RayActor actor) { - this.className = className; - this.id = id; - this.args = args; - this.actor = actor; - this.remoteAnnotation = remoteAnnotation; - } - - public UniqueID getId() { - return id; - } - - public Object[] getArgs() { - return args; - } - - public void setArgs(Object[] args) { - this.args = args; - } - - public RayActor getActor() { - return actor; - } - - public RayRemote getRemoteAnnotation() { - return remoteAnnotation; - } - -} \ No newline at end of file diff --git a/java/runtime-common/src/main/java/org/ray/spi/model/RayMethod.java b/java/runtime-common/src/main/java/org/ray/spi/model/RayMethod.java index bb1179b5f..f31fdf6f2 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/model/RayMethod.java +++ b/java/runtime-common/src/main/java/org/ray/spi/model/RayMethod.java @@ -1,8 +1,8 @@ package org.ray.spi.model; import java.lang.reflect.Method; -import org.ray.api.RayRemote; -import org.ray.api.UniqueID; +import org.ray.api.annotation.RayRemote; +import org.ray.api.id.UniqueId; import org.ray.util.MethodId; /** @@ -13,9 +13,9 @@ public class RayMethod { public final Method invokable; public final String fullName; public final RayRemote remoteAnnotation; - private final UniqueID funcId; + private final UniqueId funcId; - private RayMethod(Method m, RayRemote remoteAnnotation, UniqueID funcId) { + private RayMethod(Method m, RayRemote remoteAnnotation, UniqueId funcId) { this.invokable = m; this.remoteAnnotation = remoteAnnotation; this.funcId = funcId; @@ -26,7 +26,7 @@ public class RayMethod { Class clazz = m.getDeclaringClass(); RayRemote remoteAnnotation = m.getAnnotation(RayRemote.class); MethodId mid = MethodId.fromMethod(m); - UniqueID funcId = new UniqueID(mid.getSha1Hash()); + UniqueId funcId = new UniqueId(mid.getSha1Hash()); RayMethod method = new RayMethod(m, remoteAnnotation != null ? remoteAnnotation : parentRemoteAnnotation, funcId); @@ -38,7 +38,7 @@ public class RayMethod { return fullName; } - public UniqueID getFuncId() { + public UniqueId getFuncId() { return funcId; } } diff --git a/java/runtime-common/src/main/java/org/ray/spi/model/RayTaskMethods.java b/java/runtime-common/src/main/java/org/ray/spi/model/RayTaskMethods.java index a884b110f..1bdf38c34 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/model/RayTaskMethods.java +++ b/java/runtime-common/src/main/java/org/ray/spi/model/RayTaskMethods.java @@ -5,17 +5,17 @@ import java.lang.reflect.Modifier; import java.util.Collections; import java.util.HashMap; import java.util.Map; -import org.ray.api.RayRemote; -import org.ray.api.UniqueID; +import org.ray.api.annotation.RayRemote; +import org.ray.api.id.UniqueId; public final class RayTaskMethods { public final Class clazz; - public final Map functions; + public final Map functions; public RayTaskMethods(Class clazz, - Map functions) { + Map functions) { this.clazz = clazz; this.functions = Collections.unmodifiableMap(new HashMap<>(functions)); } @@ -24,7 +24,7 @@ public final class RayTaskMethods { try { Class clazz = Class.forName(clazzName, true, classLoader); Method[] methods = clazz.getDeclaredMethods(); - Map functions = new HashMap<>(methods.length * 2); + Map functions = new HashMap<>(methods.length * 2); for (Method m : methods) { if (!Modifier.isStatic(m.getModifiers())) { diff --git a/java/runtime-common/src/main/java/org/ray/spi/model/TaskSpec.java b/java/runtime-common/src/main/java/org/ray/spi/model/TaskSpec.java index 88101092a..3f902222c 100644 --- a/java/runtime-common/src/main/java/org/ray/spi/model/TaskSpec.java +++ b/java/runtime-common/src/main/java/org/ray/spi/model/TaskSpec.java @@ -2,7 +2,7 @@ package org.ray.spi.model; import java.util.Arrays; import java.util.Map; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.util.ResourceUtil; /** @@ -11,43 +11,64 @@ import org.ray.util.ResourceUtil; public class TaskSpec { // ID of the driver that created this task. - public UniqueID driverId; + public UniqueId driverId; // Task ID of the task. - public UniqueID taskId; + public UniqueId taskId; // Task ID of the parent task. - public UniqueID parentTaskId; + public UniqueId parentTaskId; // A count of the number of tasks submitted by the parent task before this one. public int parentCounter; // Actor ID of the task. This is the actor that this task is executed on // or NIL_ACTOR_ID if the task is just a normal task. - public UniqueID actorId; + public UniqueId actorId; // Number of tasks that have been submitted to this actor so far. public int actorCounter; // Function ID of the task. - public UniqueID functionId; + public UniqueId functionId; // Task arguments. public FunctionArg[] args; // return ids - public UniqueID[] returnIds; + public UniqueId[] returnIds; // ID per actor client for session consistency - public UniqueID actorHandleId; + public UniqueId actorHandleId; - // Id for create a target actor - public UniqueID createActorId; + // Id for createActor a target actor + public UniqueId createActorId; // The task's resource demands. public Map resources; - public UniqueID cursorId; + public UniqueId cursorId; + + public TaskSpec() {} + + public TaskSpec(UniqueId driverId, UniqueId taskId, UniqueId parentTaskId, int parentCounter, + UniqueId actorId, int actorCounter, UniqueId functionId, FunctionArg[] args, + UniqueId[] returnIds, UniqueId actorHandleId, UniqueId createActorId, + Map resources, UniqueId cursorId) { + this.driverId = driverId; + this.taskId = taskId; + this.parentTaskId = parentTaskId; + this.parentCounter = parentCounter; + this.actorId = actorId; + this.actorCounter = actorCounter; + this.functionId = functionId; + this.args = args; + this.returnIds = returnIds; + this.actorHandleId = actorHandleId; + this.createActorId = createActorId; + this.resources = resources; + this.cursorId = cursorId; + } @Override public String toString() { diff --git a/java/runtime-dev/src/main/java/org/ray/core/impl/RayDevRuntime.java b/java/runtime-dev/src/main/java/org/ray/core/impl/RayDevRuntime.java index 451841250..18556a5fa 100644 --- a/java/runtime-dev/src/main/java/org/ray/core/impl/RayDevRuntime.java +++ b/java/runtime-dev/src/main/java/org/ray/core/impl/RayDevRuntime.java @@ -1,64 +1,14 @@ package org.ray.core.impl; -import java.lang.reflect.Constructor; -import java.lang.reflect.InvocationTargetException; -import java.util.concurrent.ConcurrentHashMap; -import org.ray.api.Ray; -import org.ray.api.RayActor; -import org.ray.api.RayRemote; -import org.ray.api.UniqueID; -import org.ray.core.RayRuntime; -import org.ray.core.UniqueIdHelper; -import org.ray.core.WorkerContext; +import org.ray.core.AbstractRayRuntime; import org.ray.core.model.RayParameters; import org.ray.spi.NopRemoteFunctionManager; import org.ray.spi.PathConfig; import org.ray.spi.RemoteFunctionManager; import org.ray.spi.impl.MockLocalScheduler; import org.ray.spi.impl.MockObjectStore; -import org.ray.util.exception.TaskExecutionException; -import org.ray.util.logger.RayLog; -public class RayDevRuntime extends RayRuntime { - - private final ConcurrentHashMap actors = new ConcurrentHashMap<>(); - - protected RayDevRuntime() { - } - - @RayRemote - private static byte[] createActor(String className) { - return ((RayDevRuntime) RayRuntime.getInstance()).createLocalActor(className); - } - - private byte[] createLocalActor(String className) { - UniqueID taskId = WorkerContext.currentTask().taskId; - UniqueID actorId = UniqueIdHelper.computeReturnId(taskId, 0); - try { - Class cls = Class.forName(className); - - Constructor[] cts = cls.getConstructors(); - for (Constructor ct : cts) { - System.err.println(ct.getName() + ", param count = " + ct.getParameterCount()); - } - - Object r = cls.getConstructor().newInstance(); - actors.put(actorId, r); - RayLog.core.info("TaskId " + taskId + ", create actor ok " + actorId); - return actorId.getBytes(); - } catch (ClassNotFoundException | InstantiationException | IllegalAccessException - | IllegalArgumentException | InvocationTargetException | NoSuchMethodException - | SecurityException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - String logInfo = - "TaskId " + taskId + " error at RayDevRuntime createLocalActor, create actor " + actorId - + " for " + className + " failed"; - System.err.println(logInfo + ", ex = " + e.getMessage()); - RayLog.core.error(logInfo, e); - throw new TaskExecutionException(logInfo, e); - } - } +public class RayDevRuntime extends AbstractRayRuntime { @Override public void start(RayParameters params) { @@ -71,17 +21,7 @@ public class RayDevRuntime extends RayRuntime { } @Override - public void cleanUp() { + public void shutdown() { // nothing to do } - - @Override - public Object getLocalActor(UniqueID id) { - return actors.get(id); - } - - @Override - public RayActor create(Class cls) { - return new RayActor<>(Ray.call(RayDevRuntime::createActor, cls.getName()).getId()); - } } diff --git a/java/runtime-dev/src/main/java/org/ray/spi/impl/MockLocalScheduler.java b/java/runtime-dev/src/main/java/org/ray/spi/impl/MockLocalScheduler.java index b60289bac..170f50225 100644 --- a/java/runtime-dev/src/main/java/org/ray/spi/impl/MockLocalScheduler.java +++ b/java/runtime-dev/src/main/java/org/ray/spi/impl/MockLocalScheduler.java @@ -3,7 +3,7 @@ package org.ray.spi.impl; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.core.LocalFunctionManager; import org.ray.core.Worker; import org.ray.spi.LocalSchedulerLink; @@ -16,7 +16,7 @@ import org.ray.spi.model.TaskSpec; */ public class MockLocalScheduler implements LocalSchedulerLink { - private final Map> waitTasks = new ConcurrentHashMap<>(); + private final Map> waitTasks = new ConcurrentHashMap<>(); private final MockObjectStore store; private LocalFunctionManager functions = null; @@ -29,8 +29,8 @@ public class MockLocalScheduler implements LocalSchedulerLink { functions = mgr; } - public void onObjectPut(UniqueID id) { - Map bucket = waitTasks.get(id); + public void onObjectPut(UniqueId id) { + Map bucket = waitTasks.get(id); if (bucket != null) { waitTasks.remove(id); for (TaskSpec ts : bucket.values()) { @@ -41,23 +41,21 @@ public class MockLocalScheduler implements LocalSchedulerLink { @Override public void submitTask(TaskSpec task) { - UniqueID id = isTaskReady(task); + UniqueId id = isTaskReady(task); if (id == null) { Worker.execute(task, functions); } else { - Map bucket = waitTasks + Map bucket = waitTasks .computeIfAbsent(id, id_ -> new ConcurrentHashMap<>()); bucket.put(id, task); } } - private UniqueID isTaskReady(TaskSpec spec) { + private UniqueId isTaskReady(TaskSpec spec) { for (FunctionArg arg : spec.args) { - if (arg.ids != null) { - for (UniqueID id : arg.ids) { - if (!store.isObjectReady(id)) { - return id; - } + if (arg.id != null) { + if (!store.isObjectReady(arg.id)) { + return arg.id; } } } @@ -70,17 +68,17 @@ public class MockLocalScheduler implements LocalSchedulerLink { } @Override - public void markTaskPutDependency(UniqueID taskId, UniqueID objectId) { + public void markTaskPutDependency(UniqueId taskId, UniqueId objectId) { } @Override - public void reconstructObject(UniqueID objectId, boolean fetchOnly) { + public void reconstructObject(UniqueId objectId, boolean fetchOnly) { } @Override - public void reconstructObjects(List objectIds, boolean fetchOnly) { + public void reconstructObjects(List objectIds, boolean fetchOnly) { } @@ -90,7 +88,7 @@ public class MockLocalScheduler implements LocalSchedulerLink { } @Override - public UniqueID generateTaskId(UniqueID driverId, UniqueID parentTaskId, int taskIndex) { + public UniqueId generateTaskId(UniqueId driverId, UniqueId parentTaskId, int taskIndex) { throw new RuntimeException("Not implemented here."); } diff --git a/java/runtime-dev/src/main/java/org/ray/spi/impl/MockObjectStore.java b/java/runtime-dev/src/main/java/org/ray/spi/impl/MockObjectStore.java index 96b3f0bad..916b1ea32 100644 --- a/java/runtime-dev/src/main/java/org/ray/spi/impl/MockObjectStore.java +++ b/java/runtime-dev/src/main/java/org/ray/spi/impl/MockObjectStore.java @@ -6,7 +6,7 @@ import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import org.apache.arrow.plasma.ObjectStoreLink; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.core.WorkerContext; import org.ray.util.logger.RayLog; @@ -15,8 +15,8 @@ import org.ray.util.logger.RayLog; */ public class MockObjectStore implements ObjectStoreLink { - private final Map data = new ConcurrentHashMap<>(); - private final Map metadata = new ConcurrentHashMap<>(); + private final Map data = new ConcurrentHashMap<>(); + private final Map metadata = new ConcurrentHashMap<>(); private MockLocalScheduler scheduler = null; @Override @@ -26,7 +26,7 @@ public class MockObjectStore implements ObjectStoreLink { .error(logPrefix() + "cannot put null: " + objectId + "," + Arrays.toString(value)); System.exit(-1); } - UniqueID uniqueId = new UniqueID(objectId); + UniqueId uniqueId = new UniqueId(objectId); data.put(uniqueId, value); metadata.put(uniqueId, metadataValue); @@ -37,10 +37,10 @@ public class MockObjectStore implements ObjectStoreLink { @Override public List get(byte[][] objectIds, int timeoutMs, boolean isMetadata) { - final Map dataMap = isMetadata ? metadata : data; + final Map dataMap = isMetadata ? metadata : data; ArrayList rets = new ArrayList<>(objectIds.length); for (byte[] objId : objectIds) { - UniqueID uniqueId = new UniqueID(objId); + UniqueId uniqueId = new UniqueId(objId); RayLog.core.info(logPrefix() + " is notified for objectid " + uniqueId); rets.add(dataMap.get(uniqueId)); } @@ -52,7 +52,7 @@ public class MockObjectStore implements ObjectStoreLink { ArrayList rets = new ArrayList<>(); for (byte[] objId : objectIds) { //tod test - if (data.containsKey(new UniqueID(objId))) { + if (data.containsKey(new UniqueId(objId))) { rets.add(objId); } } @@ -82,7 +82,7 @@ public class MockObjectStore implements ObjectStoreLink { @Override public boolean contains(byte[] objectId) { - return data.containsKey(new UniqueID(objectId)); + return data.containsKey(new UniqueId(objectId)); } private String logPrefix() { @@ -99,7 +99,7 @@ public class MockObjectStore implements ObjectStoreLink { return stes[k].getFileName() + ":" + stes[k].getLineNumber(); } - public boolean isObjectReady(UniqueID id) { + public boolean isObjectReady(UniqueId id) { return data.containsKey(id); } diff --git a/java/runtime-native/src/main/java/org/ray/core/impl/RayNativeRuntime.java b/java/runtime-native/src/main/java/org/ray/core/impl/RayNativeRuntime.java index e00d3abcc..8085de80f 100644 --- a/java/runtime-native/src/main/java/org/ray/core/impl/RayNativeRuntime.java +++ b/java/runtime-native/src/main/java/org/ray/core/impl/RayNativeRuntime.java @@ -1,18 +1,11 @@ package org.ray.core.impl; -import java.lang.reflect.Constructor; -import java.lang.reflect.InvocationTargetException; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.arrow.plasma.ObjectStoreLink; import org.apache.arrow.plasma.PlasmaClient; -import org.ray.api.RayActor; -import org.ray.api.RayRemote; -import org.ray.api.UniqueID; -import org.ray.api.funcs.RayFunc2; -import org.ray.core.RayRuntime; -import org.ray.core.UniqueIdHelper; +import org.ray.core.AbstractRayRuntime; import org.ray.core.WorkerContext; import org.ray.core.model.RayParameters; import org.ray.core.model.WorkerMode; @@ -29,13 +22,12 @@ import org.ray.spi.impl.NonRayletStateStoreProxyImpl; import org.ray.spi.impl.RayletStateStoreProxyImpl; import org.ray.spi.impl.RedisClient; import org.ray.spi.model.AddressInfo; -import org.ray.util.exception.TaskExecutionException; import org.ray.util.logger.RayLog; /** * native runtime for local box and cluster run. */ -public class RayNativeRuntime extends RayRuntime { +public final class RayNativeRuntime extends AbstractRayRuntime { static { System.err.println("Current working directory is " + System.getProperty("user.dir")); @@ -46,8 +38,6 @@ public class RayNativeRuntime extends RayRuntime { private StateStoreProxy stateStoreProxy; private KeyValueStoreLink kvStore = null; private RunManager manager = null; - private Object actor = null; - private UniqueID actorId = UniqueID.NIL; protected RayNativeRuntime() { } @@ -103,12 +93,12 @@ public class RayNativeRuntime extends RayRuntime { if (params.worker_mode != WorkerMode.NONE) { String overwrites = ""; // initialize the links - int releaseDelay = RayRuntime.configReader + int releaseDelay = AbstractRayRuntime.configReader .getIntegerValue("ray", "plasma_default_release_delay", 0, "how many release requests should be delayed in plasma client"); if (!params.use_raylet) { - ObjectStoreLink plink = new PlasmaClient(params.object_store_name, + ObjectStoreLink plink = new PlasmaClient(params.object_store_name, params.object_store_manager_name, releaseDelay); LocalSchedulerLink slink = new DefaultLocalSchedulerClient( @@ -152,24 +142,15 @@ public class RayNativeRuntime extends RayRuntime { } @Override - public void cleanUp() { + public void shutdown() { if (null != manager) { manager.cleanup(true); } } - @Override - public Object getLocalActor(UniqueID id) { - if (actorId.equals(id)) { - return actor; - } else { - return null; - } - } - private void startOnebox(RayParameters params, PathConfig paths) throws Exception { params.cleanup = true; - manager = new RunManager(params, paths, RayRuntime.configReader); + manager = new RunManager(params, paths, AbstractRayRuntime.configReader); manager.startRayHead(); params.redis_address = manager.info().redisAddress; @@ -235,59 +216,4 @@ public class RayNativeRuntime extends RayRuntime { kvStore.hmset("Workers:" + workerId, workerInfo); } } - - @SuppressWarnings("unchecked") - @Override - public RayActor create(Class cls) { - UniqueID createTaskId = localSchedulerProxy.generateTaskId( - WorkerContext.currentTask().driverId, - WorkerContext.currentTask().taskId, - WorkerContext.nextCallIndex() - ); - - UniqueID actorId = UniqueIdHelper.computeReturnId(createTaskId, 0); - RayActor actor = new RayActor<>(actorId); - UniqueID cursorId; - - RayFunc2 createActorLambda = RayNativeRuntime::createActorInActor; - cursorId = worker.createActor( - createTaskId, - actorId, - createActorLambda, - new Object[]{actorId.getBytes(), cls.getName()} - ).getId(); - actor.setTaskCursor(cursorId); - return actor; - } - - @RayRemote - public static byte[] createActorInActor(byte[] actorId, String className) { - ((RayNativeRuntime) RayRuntime.getInstance()).localCreateActorInActor(actorId, className); - return actorId; - } - - public Object localCreateActorInActor(byte[] actorId, String className) { - try { - this.actorId = new UniqueID(actorId); - Class cls = Class.forName(className, true, Thread.currentThread().getContextClassLoader()); - - Constructor[] cts = cls.getConstructors(); - for (Constructor ct : cts) { - System.err.println(ct.getName() + ", param count = " + ct.getParameterCount()); - } - - actor = cls.getConstructor(new Class[0]).newInstance(); - RayLog.core.info("create actor " + this.actorId + " inside actor ok"); - return actor; - } catch (ClassNotFoundException | InstantiationException | IllegalAccessException - | IllegalArgumentException | InvocationTargetException | NoSuchMethodException - | SecurityException e) { - e.printStackTrace(); - String log = "create actor " + this.actorId + " for " + className + " failed, ex = " + e - .getMessage(); - System.err.println(log); - RayLog.core.error(log, e); - throw new TaskExecutionException(log, e); - } - } } diff --git a/java/runtime-native/src/main/java/org/ray/runner/RunManager.java b/java/runtime-native/src/main/java/org/ray/runner/RunManager.java index 77e5002bd..95ff76e3a 100644 --- a/java/runtime-native/src/main/java/org/ray/runner/RunManager.java +++ b/java/runtime-native/src/main/java/org/ray/runner/RunManager.java @@ -12,7 +12,7 @@ import java.util.List; import java.util.Map; import java.util.Random; import java.util.concurrent.TimeUnit; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.core.model.RayParameters; import org.ray.core.model.RunMode; import org.ray.runner.RunInfo.ProcessType; @@ -101,7 +101,7 @@ public class RunManager { startRayProcesses(); } - public Process startDriver(String mainClass, String redisAddress, UniqueID driverId, + public Process startDriver(String mainClass, String redisAddress, UniqueId driverId, String logDir, String ip, String driverClass, String driverArgs, String additonalClassPaths, String additionalConfigs) { @@ -369,7 +369,7 @@ public class RunManager { for (int j = 0; j < localNumWorkers[i]; j++) { startWorker(localStores.storeName, localStores.managerName, localStores.schedulerName, "/worker" + i + "." + j, params.redis_address, - params.node_ip_address, UniqueID.NIL, "", params.redirect, params.cleanup); + params.node_ip_address, UniqueId.NIL, "", params.redirect, params.cleanup); } } } @@ -570,7 +570,7 @@ public class RunManager { String workerCmd = null; workerCmd = buildWorkerCommand(true, info.storeName, info.managerName, name, - UniqueID.NIL, "", ip, redisAddress); + UniqueId.NIL, "", ip, redisAddress); cmd += " -w \"" + workerCmd + "\""; if (redisAddress.length() > 0) { @@ -614,7 +614,7 @@ public class RunManager { //Create the worker command that the raylet will use to start workers. String workerCommand = buildWorkerCommandRaylet(info.storeName, rayletSocketName, - UniqueID.NIL, "", ip, redisAddress); + UniqueId.NIL, "", ip, redisAddress); int sep = redisAddress.indexOf(':'); assert (sep != -1); @@ -654,13 +654,13 @@ public class RunManager { } private String buildWorkerCommandRaylet(String storeName, String rayletSocketName, - UniqueID actorId, String actorClass, + UniqueId actorId, String actorClass, String ip, String redisAddress) { String workerConfigs = "ray.java.start.object_store_name=" + storeName + ";ray.java.start.raylet_socket_name=" + rayletSocketName + ";ray.java.start.worker_mode=WORKER;ray.java.start.use_raylet=true"; workerConfigs += ";ray.java.start.deploy=" + params.deploy; - if (!actorId.equals(UniqueID.NIL)) { + if (!actorId.equals(UniqueId.NIL)) { workerConfigs += ";ray.java.start.actor_id=" + actorId; } if (!actorClass.equals("")) { @@ -685,14 +685,14 @@ public class RunManager { private String buildWorkerCommand(boolean isFromLocalScheduler, String storeName, String storeManagerName, String localSchedulerName, - UniqueID actorId, String actorClass, String + UniqueId actorId, String actorClass, String ip, String redisAddress) { String workerConfigs = "ray.java.start.object_store_name=" + storeName + ";ray.java.start.object_store_manager_name=" + storeManagerName + ";ray.java.start.worker_mode=WORKER" + ";ray.java.start.local_scheduler_name=" + localSchedulerName; workerConfigs += ";ray.java.start.deploy=" + params.deploy; - if (!actorId.equals(UniqueID.NIL)) { + if (!actorId.equals(UniqueId.NIL)) { workerConfigs += ";ray.java.start.actor_id=" + actorId; } if (!actorClass.equals("")) { @@ -783,7 +783,7 @@ public class RunManager { public void startWorker(String storeName, String storeManagerName, String localSchedulerName, String workerName, String redisAddress, - String ip, UniqueID actorId, String actorClass, + String ip, UniqueId actorId, String actorClass, boolean redirect, boolean cleanup) { String cmd = buildWorkerCommand(false, storeName, storeManagerName, localSchedulerName, actorId, actorClass, ip, redisAddress); diff --git a/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultDriver.java b/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultDriver.java index 2eeb30439..47a87ddab 100644 --- a/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultDriver.java +++ b/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultDriver.java @@ -1,6 +1,6 @@ package org.ray.runner.worker; -import org.ray.core.RayRuntime; +import org.ray.core.AbstractRayRuntime; import org.ray.core.model.WorkerMode; /** @@ -15,13 +15,13 @@ public class DefaultDriver { // public static void main(String[] args) { try { - RayRuntime.init(args); - assert RayRuntime.getParams().worker_mode == WorkerMode.DRIVER; + AbstractRayRuntime.init(args); + assert AbstractRayRuntime.getParams().worker_mode == WorkerMode.DRIVER; - String driverClass = RayRuntime.configReader + String driverClass = AbstractRayRuntime.configReader .getStringValue("ray.java.start", "driver_class", "", "java class which main is served as the driver in a java worker"); - String driverArgs = RayRuntime.configReader + String driverArgs = AbstractRayRuntime.configReader .getStringValue("ray.java.start", "driver_args", "", "arguments for the java class main function which is served at the driver"); Class cls = Class.forName(driverClass); diff --git a/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultWorker.java b/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultWorker.java index 0cb2b367f..0711b5566 100644 --- a/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultWorker.java +++ b/java/runtime-native/src/main/java/org/ray/runner/worker/DefaultWorker.java @@ -1,6 +1,6 @@ package org.ray.runner.worker; -import org.ray.core.RayRuntime; +import org.ray.core.AbstractRayRuntime; import org.ray.core.model.WorkerMode; /** @@ -16,9 +16,9 @@ public class DefaultWorker { // public static void main(String[] args) { try { - RayRuntime.init(args); - assert RayRuntime.getParams().worker_mode == WorkerMode.WORKER; - RayRuntime.getInstance().loop(); + AbstractRayRuntime.init(args); + assert AbstractRayRuntime.getParams().worker_mode == WorkerMode.WORKER; + AbstractRayRuntime.getInstance().loop(); throw new RuntimeException("Control flow should never reach here"); } catch (Throwable e) { diff --git a/java/runtime-native/src/main/java/org/ray/spi/impl/DefaultLocalSchedulerClient.java b/java/runtime-native/src/main/java/org/ray/spi/impl/DefaultLocalSchedulerClient.java index 69eca5910..35eb25f2b 100644 --- a/java/runtime-native/src/main/java/org/ray/spi/impl/DefaultLocalSchedulerClient.java +++ b/java/runtime-native/src/main/java/org/ray/spi/impl/DefaultLocalSchedulerClient.java @@ -7,9 +7,8 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; -import org.ray.api.Ray; -import org.ray.api.UniqueID; -import org.ray.core.RayRuntime; +import org.ray.api.id.UniqueId; +import org.ray.core.AbstractRayRuntime; import org.ray.core.UniqueIdHelper; import org.ray.spi.LocalSchedulerLink; import org.ray.spi.model.FunctionArg; @@ -24,15 +23,15 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { private static ThreadLocal _taskBuffer = ThreadLocal.withInitial(() -> { ByteBuffer bb = ByteBuffer - .allocateDirect(RayRuntime.getParams().max_submit_task_buffer_size_bytes); + .allocateDirect(AbstractRayRuntime.getParams().max_submit_task_buffer_size_bytes); bb.order(ByteOrder.LITTLE_ENDIAN); return bb; }); private long client = 0; boolean useRaylet = false; - public DefaultLocalSchedulerClient(String schedulerSockName, UniqueID clientId, - boolean isWorker, UniqueID driverId, boolean useRaylet) { + public DefaultLocalSchedulerClient(String schedulerSockName, UniqueId clientId, + boolean isWorker, UniqueId driverId, boolean useRaylet) { client = nativeInit(schedulerSockName, clientId.getBytes(), isWorker, driverId.getBytes(), useRaylet); this.useRaylet = useRaylet; @@ -57,6 +56,7 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { @Override public void submitTask(TaskSpec task) { + RayLog.core.debug("Submitting task: {}", task); // We don't support resources management in non raylet mode. if (!useRaylet) { task.resources.clear(); @@ -72,12 +72,12 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { } ByteBuffer info = taskSpec2Info(task); - byte[] a = null; + byte[] cursorId = null; if (!task.actorId.isNil()) { - a = task.cursorId.getBytes(); + cursorId = task.cursorId.getBytes(); } - nativeSubmitTask(client, a, info, info.position(), info.remaining(), useRaylet); + nativeSubmitTask(client, cursorId, info, info.position(), info.remaining(), useRaylet); } @Override @@ -89,19 +89,19 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { } @Override - public void markTaskPutDependency(UniqueID taskId, UniqueID objectId) { + public void markTaskPutDependency(UniqueId taskId, UniqueId objectId) { nativePutObject(client, taskId.getBytes(), objectId.getBytes()); } @Override - public void reconstructObject(UniqueID objectId, boolean fetchOnly) { - List objects = new ArrayList<>(); + public void reconstructObject(UniqueId objectId, boolean fetchOnly) { + List objects = new ArrayList<>(); objects.add(objectId); nativeReconstructObjects(client, getIdBytes(objects), fetchOnly); } @Override - public void reconstructObjects(List objectIds, boolean fetchOnly) { + public void reconstructObjects(List objectIds, boolean fetchOnly) { if (RayLog.core.isInfoEnabled()) { RayLog.core.info("Reconstructing objects for task {}, object IDs are {}", UniqueIdHelper.computeTaskId(objectIds.get(0)), objectIds); @@ -110,9 +110,9 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { } @Override - public UniqueID generateTaskId(UniqueID driverId, UniqueID parentTaskId, int taskIndex) { + public UniqueId generateTaskId(UniqueId driverId, UniqueId parentTaskId, int taskIndex) { byte[] bytes = nativeGenerateTaskId(driverId.getBytes(), parentTaskId.getBytes(), taskIndex); - return new UniqueID(bytes); + return new UniqueId(bytes); } @Override @@ -125,49 +125,47 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { TaskInfo info = TaskInfo.getRootAsTaskInfo(bb); TaskSpec spec = new TaskSpec(); - spec.driverId = UniqueID.fromByteBuffer(info.driverIdAsByteBuffer()); - spec.taskId = UniqueID.fromByteBuffer(info.taskIdAsByteBuffer()); - spec.parentTaskId = UniqueID.fromByteBuffer(info.parentTaskIdAsByteBuffer()); + spec.driverId = UniqueId.fromByteBuffer(info.driverIdAsByteBuffer()); + spec.taskId = UniqueId.fromByteBuffer(info.taskIdAsByteBuffer()); + spec.parentTaskId = UniqueId.fromByteBuffer(info.parentTaskIdAsByteBuffer()); spec.parentCounter = info.parentCounter(); - spec.actorId = UniqueID.fromByteBuffer(info.actorIdAsByteBuffer()); + spec.actorId = UniqueId.fromByteBuffer(info.actorIdAsByteBuffer()); spec.actorCounter = info.actorCounter(); - spec.createActorId = UniqueID.fromByteBuffer(info.actorCreationIdAsByteBuffer()); + spec.createActorId = UniqueId.fromByteBuffer(info.actorCreationIdAsByteBuffer()); - spec.functionId = UniqueID.fromByteBuffer(info.functionIdAsByteBuffer()); + spec.functionId = UniqueId.fromByteBuffer(info.functionIdAsByteBuffer()); List args = new ArrayList<>(); for (int i = 0; i < info.argsLength(); i++) { - FunctionArg darg = new FunctionArg(); + UniqueId id = null; + byte[] data = null; Arg sarg = info.args(i); int idCount = sarg.objectIdsLength(); if (idCount > 0) { - darg.ids = new ArrayList<>(); - for (int j = 0; j < idCount; j++) { - ByteBuffer lbb = sarg.objectIdAsByteBuffer(j); - assert (lbb != null && lbb.remaining() > 0); - darg.ids.add(UniqueID.fromByteBuffer(lbb)); - } + ByteBuffer lbb = sarg.objectIdAsByteBuffer(0); + assert (lbb != null && lbb.remaining() > 0); + id = UniqueId.fromByteBuffer(lbb); } ByteBuffer lbb = sarg.dataAsByteBuffer(); if (lbb != null && lbb.remaining() > 0) { // TODO: how to avoid memory copy - darg.data = new byte[lbb.remaining()]; - lbb.get(darg.data); + data = new byte[lbb.remaining()]; + lbb.get(data); } - args.add(darg); + args.add(new FunctionArg(id, data)); } spec.args = args.toArray(new FunctionArg[0]); - List rids = new ArrayList<>(); + List rids = new ArrayList<>(); for (int i = 0; i < info.returnsLength(); i++) { ByteBuffer lbb = info.returnsAsByteBuffer(i); assert (lbb != null && lbb.remaining() > 0); - rids.add(UniqueID.fromByteBuffer(lbb)); + rids.add(UniqueId.fromByteBuffer(lbb)); } - spec.returnIds = rids.toArray(new UniqueID[0]); + spec.returnIds = rids.toArray(new UniqueId[0]); return spec; } @@ -183,7 +181,7 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { final int parentTaskIdOffset = fbb.createString(task.parentTaskId.toByteBuffer()); final int parentCounter = task.parentCounter; final int actorCreateIdOffset = fbb.createString(task.createActorId.toByteBuffer()); - final int actorCreateDummyIdOffset = fbb.createString(UniqueID.NIL.toByteBuffer()); + final int actorCreateDummyIdOffset = fbb.createString(UniqueId.NIL.toByteBuffer()); final int actorIdOffset = fbb.createString(task.actorId.toByteBuffer()); final int actorHandleIdOffset = fbb.createString(task.actorHandleId.toByteBuffer()); final int actorCounter = task.actorCounter; @@ -195,12 +193,10 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { int objectIdOffset = 0; int dataOffset = 0; - if (task.args[i].ids != null) { - int idCount = task.args[i].ids.size(); - int[] idOffsets = new int[idCount]; - for (int k = 0; k < idCount; k++) { - idOffsets[k] = fbb.createString(task.args[i].ids.get(k).toByteBuffer()); - } + if (task.args[i].id != null) { + int[] idOffsets = new int[] { + fbb.createString(task.args[i].id.toByteBuffer()) + }; objectIdOffset = fbb.createVectorOfTables(idOffsets); } else { objectIdOffset = fbb.createVectorOfTables(new int[0]); @@ -248,9 +244,9 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { fbb.finish(root); ByteBuffer buffer = fbb.dataBuffer(); - if (buffer.remaining() > RayRuntime.getParams().max_submit_task_buffer_size_bytes) { + if (buffer.remaining() > AbstractRayRuntime.getParams().max_submit_task_buffer_size_bytes) { RayLog.core.error( - "Allocated buffer is not enough to transfer the task specification: " + RayRuntime + "Allocated buffer is not enough to transfer the task specification: " + AbstractRayRuntime .getParams().max_submit_task_buffer_size_bytes + " vs " + buffer.remaining()); assert (false); } @@ -258,7 +254,7 @@ public class DefaultLocalSchedulerClient implements LocalSchedulerLink { return buffer; } - private static byte[][] getIdBytes(List objectIds) { + private static byte[][] getIdBytes(List objectIds) { int size = objectIds.size(); byte[][] ids = new byte[size][]; for (int i = 0; i < size; i++) { diff --git a/java/runtime-native/src/main/java/org/ray/spi/impl/NativeRemoteFunctionManager.java b/java/runtime-native/src/main/java/org/ray/spi/impl/NativeRemoteFunctionManager.java index 4a04414f2..c162baf79 100644 --- a/java/runtime-native/src/main/java/org/ray/spi/impl/NativeRemoteFunctionManager.java +++ b/java/runtime-native/src/main/java/org/ray/spi/impl/NativeRemoteFunctionManager.java @@ -5,7 +5,7 @@ import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.concurrent.ConcurrentHashMap; import net.lingala.zip4j.core.ZipFile; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.spi.KeyValueStoreLink; import org.ray.spi.RemoteFunctionManager; import org.ray.util.FileUtil; @@ -18,7 +18,7 @@ import org.ray.util.logger.RayLog; */ public class NativeRemoteFunctionManager implements RemoteFunctionManager { - private final ConcurrentHashMap loadedApps = new ConcurrentHashMap<>(); + private final ConcurrentHashMap loadedApps = new ConcurrentHashMap<>(); private MessageDigest md; private final String appDir = System.getProperty("user.dir") + "/apps"; private final KeyValueStoreLink kvStore; @@ -35,11 +35,11 @@ public class NativeRemoteFunctionManager implements RemoteFunctionManager { } @Override - public UniqueID registerResource(byte[] resourceZip) { + public UniqueId registerResource(byte[] resourceZip) { byte[] digest = Sha1Digestor.digest(resourceZip); - assert (digest.length == UniqueID.LENGTH); + assert (digest.length == UniqueId.LENGTH); - UniqueID resourceId = new UniqueID(digest); + UniqueId resourceId = new UniqueId(digest); // TODO: resources must be saved in persistent store kvStore.set(resourceId.getBytes(), resourceZip, null); @@ -48,32 +48,32 @@ public class NativeRemoteFunctionManager implements RemoteFunctionManager { } @Override - public byte[] getResource(UniqueID resourceId) { + public byte[] getResource(UniqueId resourceId) { return kvStore.get(resourceId.getBytes(), null); } @Override - public void unregisterResource(UniqueID resourceId) { + public void unregisterResource(UniqueId resourceId) { kvStore.delete(resourceId.getBytes(), null); } @Override - public void registerApp(UniqueID driverId, UniqueID resourceId) { + public void registerApp(UniqueId driverId, UniqueId resourceId) { kvStore.set("App2ResMap", resourceId.toString(), driverId.toString()); } @Override - public UniqueID getAppResourceId(UniqueID driverId) { - return UniqueID.fromHexString(kvStore.get("App2ResMap", driverId.toString())); + public UniqueId getAppResourceId(UniqueId driverId) { + return UniqueId.fromHexString(kvStore.get("App2ResMap", driverId.toString())); } @Override - public void unregisterApp(UniqueID driverId) { + public void unregisterApp(UniqueId driverId) { kvStore.delete("App2ResMap", driverId.toString()); } @Override - public ClassLoader loadResource(UniqueID driverId) { + public ClassLoader loadResource(UniqueId driverId) { ClassLoader classLoader = loadedApps.get(driverId); if (classLoader == null) { synchronized (this) { @@ -86,13 +86,13 @@ public class NativeRemoteFunctionManager implements RemoteFunctionManager { return classLoader; } - private ClassLoader initLoadedApps(UniqueID driverId) { + private ClassLoader initLoadedApps(UniqueId driverId) { try { RayLog.core.info("initLoadedApps" + driverId.toString()); ClassLoader cl = loadedApps.get(driverId); if (cl == null) { - UniqueID resId = UniqueID.fromHexString(kvStore.get("App2ResMap", driverId.toString())); + UniqueId resId = UniqueId.fromHexString(kvStore.get("App2ResMap", driverId.toString())); byte[] res = getResource(resId); if (res == null) { throw new RuntimeException("get resource null, the resId " + resId.toString()); @@ -120,7 +120,7 @@ public class NativeRemoteFunctionManager implements RemoteFunctionManager { } @Override - public synchronized void unloadFunctions(UniqueID driverId) { + public synchronized void unloadFunctions(UniqueId driverId) { ClassLoader cl = loadedApps.get(driverId); try { JarLoader.unloadJars(cl); diff --git a/java/runtime-native/src/main/java/org/ray/spi/impl/RayletStateStoreProxyImpl.java b/java/runtime-native/src/main/java/org/ray/spi/impl/RayletStateStoreProxyImpl.java index 0cfa4f532..c2b5f5574 100644 --- a/java/runtime-native/src/main/java/org/ray/spi/impl/RayletStateStoreProxyImpl.java +++ b/java/runtime-native/src/main/java/org/ray/spi/impl/RayletStateStoreProxyImpl.java @@ -5,7 +5,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Objects; import java.util.Set; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.format.gcs.ClientTableData; import org.ray.spi.KeyValueStoreLink; import org.ray.spi.model.AddressInfo; @@ -29,7 +29,7 @@ public class RayletStateStoreProxyImpl extends BaseStateStoreProxyImpl { List schedulerInfo = new ArrayList<>(); byte[] prefix = "CLIENT".getBytes(); - byte[] postfix = UniqueID.genNil().getBytes(); + byte[] postfix = UniqueId.genNil().getBytes(); byte[] clientKey = new byte[prefix.length + postfix.length]; System.arraycopy(prefix, 0, clientKey, 0, prefix.length); System.arraycopy(postfix, 0, clientKey, prefix.length, postfix.length); diff --git a/java/test/src/main/java/org/ray/api/benchmark/ActorPressTest.java b/java/test/src/main/java/org/ray/api/benchmark/ActorPressTest.java index d1148b1f2..ff070884f 100644 --- a/java/test/src/main/java/org/ray/api/benchmark/ActorPressTest.java +++ b/java/test/src/main/java/org/ray/api/benchmark/ActorPressTest.java @@ -5,7 +5,7 @@ import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; import org.ray.api.test.MyRunner; @RunWith(MyRunner.class) @@ -14,7 +14,7 @@ public class ActorPressTest extends RayBenchmarkTest { @Test public void singleLatencyTest() { int times = 10; - RayActor adder = Ray.create(ActorPressTest.Adder.class); + RayActor adder = Ray.createActor(ActorPressTest.Adder.class); super.singleLatencyTest(times, adder); } @@ -22,7 +22,7 @@ public class ActorPressTest extends RayBenchmarkTest { public void maxTest() { int clientNum = 2; int totalNum = 20; - RayActor adder = Ray.create(ActorPressTest.Adder.class); + RayActor adder = Ray.createActor(ActorPressTest.Adder.class); PressureTestParameter pressureTestParameter = new PressureTestParameter(); pressureTestParameter.setClientNum(clientNum); pressureTestParameter.setTotalNum(totalNum); @@ -36,7 +36,7 @@ public class ActorPressTest extends RayBenchmarkTest { int clientNum = 2; int totalQps = 2; int duration = 3; - RayActor adder = Ray.create(ActorPressTest.Adder.class); + RayActor adder = Ray.createActor(ActorPressTest.Adder.class); PressureTestParameter pressureTestParameter = new PressureTestParameter(); pressureTestParameter.setClientNum(clientNum); pressureTestParameter.setTotalQps(totalQps); diff --git a/java/test/src/main/java/org/ray/api/benchmark/MaxPressureTest.java b/java/test/src/main/java/org/ray/api/benchmark/MaxPressureTest.java index ed8e5a116..923ed4dd3 100644 --- a/java/test/src/main/java/org/ray/api/benchmark/MaxPressureTest.java +++ b/java/test/src/main/java/org/ray/api/benchmark/MaxPressureTest.java @@ -5,7 +5,7 @@ import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; import org.ray.api.test.MyRunner; @RunWith(MyRunner.class) diff --git a/java/test/src/main/java/org/ray/api/benchmark/RateLimiterPressureTest.java b/java/test/src/main/java/org/ray/api/benchmark/RateLimiterPressureTest.java index 94e55b33c..0594dfae7 100644 --- a/java/test/src/main/java/org/ray/api/benchmark/RateLimiterPressureTest.java +++ b/java/test/src/main/java/org/ray/api/benchmark/RateLimiterPressureTest.java @@ -5,7 +5,7 @@ import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; import org.ray.api.test.MyRunner; @RunWith(MyRunner.class) diff --git a/java/test/src/main/java/org/ray/api/benchmark/RayBenchmarkTest.java b/java/test/src/main/java/org/ray/api/benchmark/RayBenchmarkTest.java index 7f3775a08..6336516a5 100644 --- a/java/test/src/main/java/org/ray/api/benchmark/RayBenchmarkTest.java +++ b/java/test/src/main/java/org/ray/api/benchmark/RayBenchmarkTest.java @@ -10,7 +10,7 @@ import org.junit.Assert; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; import org.ray.util.logger.RayLog; public abstract class RayBenchmarkTest implements Serializable { diff --git a/java/test/src/main/java/org/ray/api/benchmark/SingleLatencyTest.java b/java/test/src/main/java/org/ray/api/benchmark/SingleLatencyTest.java index 7eee020d7..de9c1e838 100644 --- a/java/test/src/main/java/org/ray/api/benchmark/SingleLatencyTest.java +++ b/java/test/src/main/java/org/ray/api/benchmark/SingleLatencyTest.java @@ -5,7 +5,7 @@ import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; import org.ray.api.test.MyRunner; @RunWith(MyRunner.class) diff --git a/java/test/src/main/java/org/ray/api/test/ActorTest.java b/java/test/src/main/java/org/ray/api/test/ActorTest.java index 0fe26d369..fadd4cdbb 100644 --- a/java/test/src/main/java/org/ray/api/test/ActorTest.java +++ b/java/test/src/main/java/org/ray/api/test/ActorTest.java @@ -1,152 +1,59 @@ package org.ray.api.test; -import java.util.ArrayList; -import java.util.List; import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; -import org.ray.api.UniqueID; +import org.ray.api.annotation.RayRemote; +import org.ray.api.function.RayFunc2; +import org.ray.api.id.UniqueId; @RunWith(MyRunner.class) public class ActorTest { @RayRemote - public static Integer sayWorld(Integer n, RayActor adder) { - RayObject result = Ray.call(ActorTest.Adder::add, adder, 1); - return result.get() + n; + public static class Counter { + + private int value = 0; + + public int incr(int delta) { + value += delta; + return value; + } + } + + @RayRemote + public static int testActorAsFirstParameter(RayActor actor, int delta) { + RayObject res = Ray.call(Counter::incr, actor, delta); + return res.get(); + } + + @RayRemote + public static int testActorAsSecondParameter(int delta, RayActor actor) { + RayObject res = Ray.call(Counter::incr, actor, delta); + return res.get(); } @Test - public void test() { - - RayActor adder = Ray.create(ActorTest.Adder.class); - Ray.call(Adder::set, adder, 10); - RayObject result = Ray.call(Adder::add, adder, 1); - Assert.assertEquals(11, (int) result.get()); - - RayActor secondAdder = Ray.create(Adder.class); - RayObject result2 = Ray.call(Adder::add, secondAdder, 1); - Assert.assertEquals(1, (int) result2.get()); - - RayObject result3 = Ray.call(Adder::add2, 1); - Assert.assertEquals(2, (int) result3.get()); - - RayObject result4 = Ray.call(ActorTest::sayWorld, 2, adder); - Assert.assertEquals(14, (int) result4.get()); - - RayActor adder2 = Ray.create(Adder2.class); - Ray.call(Adder2::setAdder, adder2, adder); - RayObject result5 = Ray.call(Adder2::increase, adder2); - Assert.assertEquals(1, (int) result5.get()); - - List list = new ArrayList<>(); - list.add(adder); - Ray.call(Adder2::setAdderList, adder2, list); - - RayObject result7 = Ray.call(Adder2::testActorList, adder2); - Assert.assertEquals(14, (int) result7.get()); - - List tempList = new ArrayList<>(); - tempList.add(result); - Ray.call(Adder::setObjectList, adder, tempList); - RayObject result8 = Ray.call(Adder::testObjectList, adder); - Assert.assertEquals(11, (int) result8.get()); + public void testCreateAndCallActor() { + // Test creating an actor + RayActor actor = Ray.createActor(Counter.class); + Assert.assertNotEquals(actor.getId(), UniqueId.NIL); + // Test calling an actor + RayFunc2 f = Counter::incr; + Assert.assertEquals(Integer.valueOf(1), Ray.call(f, actor, 1).get()); + Assert.assertEquals(Integer.valueOf(11), Ray.call(Counter::incr, actor, 10).get()); } - @RayRemote - public static class Adder { - - private List> objectList; - private Integer sum = 0; - - public static Integer add2(Integer n) { - return n + 1; - } - - public Integer set(Integer n) { - sum = n; - return sum; - } - - public Integer increase() { - return (++sum); - } - - public Integer add(Integer n) { - return (sum += n); - } - - public Integer setObjectList(List> objectList) { - this.objectList = objectList; - return 1; - } - - public Integer testObjectList() { - return ((RayObject) objectList.get(0)).get(); - } - } - - @RayRemote - public static class Adder2 { - - private RayActor adder; - - private List> adderList; - - private UniqueID id; - private Integer sum = 0; - - public static Integer add2(Adder a, Integer n) { - return n + 1; - } - - public Integer set(Integer n) { - sum = n; - return sum; - } - - public Integer increase() { - RayObject result = Ray.call(Adder::increase, adder); - Assert.assertEquals(13, (int) result.get()); - return (++sum); - } - - public Integer testActorList() { - RayActor temp = adderList.get(0); - RayObject result = Ray.call(Adder::increase, temp); - return result.get(); - } - - public Integer add(Integer n) { - return (sum += n); - } - - public RayActor getAdder() { - return adder; - } - - public Integer setAdder(RayActor adder) { - this.adder = adder; - return 0; - } - - public UniqueID getId() { - return id; - } - - public Integer setId(UniqueID id) { - this.id = id; - adder = new RayActor<>(id); - return 0; - } - - public Integer setAdderList(List> adderList) { - this.adderList = adderList; - return 0; - } + @Test + public void testPassActorAsParameter() { + RayActor actor = Ray.createActor(Counter.class); + RayFunc2 f = ActorTest::testActorAsFirstParameter; + Assert.assertEquals(Integer.valueOf(1), + Ray.call(ActorTest::testActorAsFirstParameter, actor, 1).get()); + Assert.assertEquals(Integer.valueOf(11), + Ray.call(ActorTest::testActorAsSecondParameter, 10, actor).get()); } } diff --git a/java/test/src/main/java/org/ray/api/test/EchoTest.java b/java/test/src/main/java/org/ray/api/test/EchoTest.java index a8eb52268..4123a2df3 100644 --- a/java/test/src/main/java/org/ray/api/test/EchoTest.java +++ b/java/test/src/main/java/org/ray/api/test/EchoTest.java @@ -3,7 +3,7 @@ package org.ray.api.test; import org.junit.Test; import org.junit.runner.RunWith; import org.ray.api.Ray; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; @RunWith(MyRunner.class) public class EchoTest { diff --git a/java/test/src/main/java/org/ray/api/test/HelloWorldTest.java b/java/test/src/main/java/org/ray/api/test/HelloWorldTest.java index 9001f9cc8..3dddce1f5 100644 --- a/java/test/src/main/java/org/ray/api/test/HelloWorldTest.java +++ b/java/test/src/main/java/org/ray/api/test/HelloWorldTest.java @@ -5,7 +5,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayObject; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; /** * Hello world. diff --git a/java/test/src/main/java/org/ray/api/test/LambdaUtilsTest.java b/java/test/src/main/java/org/ray/api/test/LambdaUtilsTest.java index 3aeea57b2..227cb0eed 100644 --- a/java/test/src/main/java/org/ray/api/test/LambdaUtilsTest.java +++ b/java/test/src/main/java/org/ray/api/test/LambdaUtilsTest.java @@ -8,9 +8,9 @@ import java.lang.reflect.Method; import java.util.concurrent.TimeUnit; import org.junit.Assert; import org.junit.Test; -import org.ray.api.funcs.RayFunc0; -import org.ray.api.funcs.RayFunc1; -import org.ray.api.funcs.RayFunc3; +import org.ray.api.function.RayFunc0; +import org.ray.api.function.RayFunc1; +import org.ray.api.function.RayFunc3; import org.ray.util.MethodId; import org.ray.util.logger.RayLog; diff --git a/java/test/src/main/java/org/ray/api/test/MethodIdTest.java b/java/test/src/main/java/org/ray/api/test/MethodIdTest.java index 46f4eba26..d4a307801 100644 --- a/java/test/src/main/java/org/ray/api/test/MethodIdTest.java +++ b/java/test/src/main/java/org/ray/api/test/MethodIdTest.java @@ -4,7 +4,7 @@ package org.ray.api.test; import java.lang.reflect.Method; import org.junit.Assert; import org.junit.Test; -import org.ray.api.funcs.RayFunc3; +import org.ray.api.function.RayFunc3; import org.ray.util.MethodId; import org.ray.util.logger.RayLog; diff --git a/java/test/src/main/java/org/ray/api/test/ObjectStoreTest.java b/java/test/src/main/java/org/ray/api/test/ObjectStoreTest.java new file mode 100644 index 000000000..961c02bd2 --- /dev/null +++ b/java/test/src/main/java/org/ray/api/test/ObjectStoreTest.java @@ -0,0 +1,32 @@ +package org.ray.api.test; + +import com.google.common.collect.ImmutableList; +import java.util.List; +import java.util.stream.Collectors; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.ray.api.Ray; +import org.ray.api.RayObject; +import org.ray.api.id.UniqueId; + +/** + * Test putting and getting objects. + */ +@RunWith(MyRunner.class) +public class ObjectStoreTest { + + @Test + public void testPutAndGet() { + RayObject obj = Ray.put(1); + Assert.assertEquals(1, (int) obj.get()); + } + + @Test + public void testGetMultipleObjects() { + List ints = ImmutableList.of(1, 2, 3, 4, 5); + List ids = ints.stream().map(obj -> Ray.put(obj).getId()) + .collect(Collectors.toList()); + Assert.assertEquals(ints, Ray.get(ids)); + } +} diff --git a/java/test/src/main/java/org/ray/api/test/RayActorMethodsTest.java b/java/test/src/main/java/org/ray/api/test/RayActorMethodsTest.java index 90a354063..7a3e92f45 100644 --- a/java/test/src/main/java/org/ray/api/test/RayActorMethodsTest.java +++ b/java/test/src/main/java/org/ray/api/test/RayActorMethodsTest.java @@ -2,24 +2,28 @@ package org.ray.api.test; import org.junit.Assert; import org.junit.Test; +import org.ray.api.annotation.RayRemote; import org.ray.spi.model.RayActorMethods; import org.ray.util.logger.RayLog; public class RayActorMethodsTest { - @Test - public void testActor() throws Exception { - RayActorMethods methods = RayActorMethods - .fromClass(ActorTest.Adder.class.getName(), RayActorMethodsTest.class.getClassLoader()); - RayLog.core.info(methods.toString()); - Assert.assertEquals(methods.functions.size(), 5); - Assert.assertEquals(methods.staticFunctions.size(), 1); + @RayRemote + public static class ExampleActor { - RayActorMethods methods2 = RayActorMethods - .fromClass(ActorTest.Adder2.class.getName(), RayActorMethodsTest.class.getClassLoader()); - RayLog.core.info(methods2.toString()); + public void func1() {} - Assert.assertEquals(methods2.functions.size(), 9); - Assert.assertEquals(methods2.staticFunctions.size(), 1); + public void func2() {} + + public static void func3() {} } -} \ No newline at end of file + + @Test + public void testActorMethods() { + RayActorMethods methods = RayActorMethods + .fromClass(ExampleActor.class.getName(), RayActorMethodsTest.class.getClassLoader()); + RayLog.core.info(methods.toString()); + Assert.assertEquals(methods.functions.size(), 2); + Assert.assertEquals(methods.staticFunctions.size(), 1); + } +} diff --git a/java/test/src/main/java/org/ray/api/test/RayCallTest.java b/java/test/src/main/java/org/ray/api/test/RayCallTest.java new file mode 100644 index 000000000..ae1fc4483 --- /dev/null +++ b/java/test/src/main/java/org/ray/api/test/RayCallTest.java @@ -0,0 +1,133 @@ +package org.ray.api.test; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import java.util.List; +import java.util.Map; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.ray.api.Ray; +import org.ray.api.annotation.RayRemote; + +/** + * Test Ray.call API + */ +@RunWith(MyRunner.class) +public class RayCallTest { + + @RayRemote + private static int testInt(int val) { + return val; + } + + @RayRemote + private static byte testByte(byte val) { + return val; + } + + @RayRemote + private static short testShort(short val) { + return val; + } + + @RayRemote + private static long testLong(long val) { + return val; + } + + @RayRemote + private static double testDouble(double val) { + return val; + } + + @RayRemote + private static float testFloat(float val) { + return val; + } + + @RayRemote + private static boolean testBool(boolean val) { + return val; + } + + @RayRemote + private static String testString(String val) { + return val; + } + + @RayRemote + private static List testList(List val) { + return val; + } + + @RayRemote + private static Map testMap(Map val) { + return val; + } + + /** + * Test calling and returning different types. + */ + @Test + public void testType() { + Assert.assertEquals(1, (int) Ray.call(RayCallTest::testInt, 1).get()); + Assert.assertEquals(1, (byte) Ray.call(RayCallTest::testByte, (byte) 1).get()); + Assert.assertEquals(1, (short) Ray.call(RayCallTest::testShort, (short) 1).get()); + Assert.assertEquals(1, (long) Ray.call(RayCallTest::testLong, 1L).get()); + Assert.assertEquals(1.0, Ray.call(RayCallTest::testDouble, 1.0).get(), 0.0); + Assert.assertEquals(1.0f, Ray.call(RayCallTest::testFloat, 1.0f).get(), 0.0); + Assert.assertEquals(true, Ray.call(RayCallTest::testBool, true).get()); + Assert.assertEquals("foo", Ray.call(RayCallTest::testString, "foo").get()); + List list = ImmutableList.of(1, 2, 3); + Assert.assertEquals(list, Ray.call(RayCallTest::testList, list).get()); + Map map = ImmutableMap.of("1", 1, "2", 2); + Assert.assertEquals(map, Ray.call(RayCallTest::testMap, map).get()); + } + + @RayRemote + private static int testNoParam() { + return 0; + } + + @RayRemote + private static int testOneParam(int a) { + return a; + } + + @RayRemote + private static int testTwoParams(int a, int b) { + return a + b; + } + + @RayRemote + private static int testThreeParams(int a, int b, int c) { + return a + b + c; + } + + @RayRemote + private static int testFourParams(int a, int b, int c, int d) { + return a + b + c + d; + } + + @RayRemote + private static int testFiveParams(int a, int b, int c, int d, int e) { + return a + b + c + d + e; + } + + @RayRemote + private static int testSixParams(int a, int b, int c, int d, int e, int f) { + return a + b + c + d + e + f; + } + + @Test + public void testNumberOfParameters() { + Assert.assertEquals(0, (int) Ray.call(RayCallTest::testNoParam).get()); + Assert.assertEquals(1, (int) Ray.call(RayCallTest::testOneParam, 1).get()); + Assert.assertEquals(2, (int) Ray.call(RayCallTest::testTwoParams, 1, 1).get()); + Assert.assertEquals(3, (int) Ray.call(RayCallTest::testThreeParams, 1, 1, 1).get()); + Assert.assertEquals(4, (int) Ray.call(RayCallTest::testFourParams, 1, 1, 1, 1).get()); + Assert.assertEquals(5, (int) Ray.call(RayCallTest::testFiveParams, 1, 1, 1, 1, 1).get()); + Assert.assertEquals(6, (int) Ray.call(RayCallTest::testSixParams, 1, 1, 1, 1, 1, 1).get()); + } +} diff --git a/java/test/src/main/java/org/ray/api/test/RayMethodsTest.java b/java/test/src/main/java/org/ray/api/test/RayMethodsTest.java index 3d7ef9ba6..67aeb6d7e 100644 --- a/java/test/src/main/java/org/ray/api/test/RayMethodsTest.java +++ b/java/test/src/main/java/org/ray/api/test/RayMethodsTest.java @@ -26,9 +26,9 @@ public class RayMethodsTest { RayObject s2Id = Ray.put(String.valueOf("World!")); RayObject n1Id = Ray.put(null); - WaitResult res = Ray.wait(ImmutableList.of(s1Id, s2Id), 2); + WaitResult res = Ray.wait(ImmutableList.of(s1Id, s2Id), 2, 1000); - List ss = res.getReadyOnes().stream().map(RayObject::get).collect(Collectors.toList()); + List ss = res.getReady().stream().map(RayObject::get).collect(Collectors.toList()); int i1 = i1Id.get(); double f1 = f1Id.get(); Object n1 = n1Id.get(); @@ -40,12 +40,5 @@ public class RayMethodsTest { Assert.assertEquals(3.14, f1, Double.MIN_NORMAL); Assert.assertNull(n1); - // metadata test - RayObject vid = Ray.put(643, "test metadata"); - Integer v = vid.get(); - String m = vid.getMeta(); - - Assert.assertEquals(643L, v.longValue()); - Assert.assertEquals("test metadata", m); } } diff --git a/java/test/src/main/java/org/ray/api/test/RemoteLambdaTest.java b/java/test/src/main/java/org/ray/api/test/RemoteLambdaTest.java deleted file mode 100644 index ec363973f..000000000 --- a/java/test/src/main/java/org/ray/api/test/RemoteLambdaTest.java +++ /dev/null @@ -1,41 +0,0 @@ -package org.ray.api.test; - -import org.apache.commons.lang3.SerializationUtils; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.ray.util.RemoteFunction; - -@RunWith(MyRunner.class) -public class RemoteLambdaTest { - - public static String remoteToString(T o) { - return o.toString(); - } - - @Test - public void test() { - - RemoteFunction f0 = RemoteLambdaTest::remoteToString; - byte[] bytes = SerializationUtils.serialize(f0); - //System.out.println(new String(bytes)); - //Object m = SerializationUtils.deserialize(bytes); - - RemoteFunction f = x -> { - System.out.println("remote function " + x); - return x + 1; - }; - - RemoteFunction f2 = SerializationUtils.clone(f); - Assert.assertEquals(101, (int) f2.apply(100)); - - Integer y = 100; - RemoteFunction f3 = x -> { - System.out.println("remote function " + x); - return x + y + 1; - }; - RemoteFunction f4 = SerializationUtils.clone(f3); - Assert.assertEquals(201, (int) f4.apply(100)); - Assert.assertEquals(201, (int) f4.apply(100)); - } -} diff --git a/java/test/src/main/java/org/ray/api/test/ResourcesManagementTest.java b/java/test/src/main/java/org/ray/api/test/ResourcesManagementTest.java index b908f7240..89b1159dc 100644 --- a/java/test/src/main/java/org/ray/api/test/ResourcesManagementTest.java +++ b/java/test/src/main/java/org/ray/api/test/ResourcesManagementTest.java @@ -8,10 +8,10 @@ import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; import org.ray.api.WaitResult; -import org.ray.core.RayRuntime; -import org.ray.util.ResourceItem; +import org.ray.api.annotation.RayRemote; +import org.ray.api.annotation.ResourceItem; +import org.ray.core.AbstractRayRuntime; /** * Resources Management Test. @@ -49,7 +49,7 @@ public class ResourcesManagementTest { @Test public void testMethods() { - Assume.assumeTrue(RayRuntime.getParams().use_raylet); + Assume.assumeTrue(AbstractRayRuntime.getParams().use_raylet); // This is a case that can satisfy required resources. RayObject result1 = Ray.call(ResourcesManagementTest::echo1, 100); Assert.assertEquals(100, (int) result1.get()); @@ -58,25 +58,25 @@ public class ResourcesManagementTest { final RayObject result2 = Ray.call(ResourcesManagementTest::echo2, 200); WaitResult waitResult = Ray.wait(ImmutableList.of(result2), 1, 1000); - Assert.assertEquals(0, waitResult.getReadyOnes().size()); - Assert.assertEquals(1, waitResult.getRemainOnes().size()); + Assert.assertEquals(0, waitResult.getReady().size()); + Assert.assertEquals(1, waitResult.getUnready().size()); } @Test public void testActors() { - Assume.assumeTrue(RayRuntime.getParams().use_raylet); + Assume.assumeTrue(AbstractRayRuntime.getParams().use_raylet); // This is a case that can satisfy required resources. - RayActor echo1 = Ray.create(Echo1.class); + RayActor echo1 = Ray.createActor(Echo1.class); final RayObject result1 = Ray.call(Echo1::echo, echo1, 100); Assert.assertEquals(100, (int) result1.get()); // This is a case that can't satisfy required resources. - RayActor echo2 = Ray.create(Echo2.class); + RayActor echo2 = Ray.createActor(Echo2.class); final RayObject result2 = Ray.call(Echo2::echo, echo2, 100); WaitResult waitResult = Ray.wait(ImmutableList.of(result2), 1, 1000); - Assert.assertEquals(0, waitResult.getReadyOnes().size()); - Assert.assertEquals(1, waitResult.getRemainOnes().size()); + Assert.assertEquals(0, waitResult.getReady().size()); + Assert.assertEquals(1, waitResult.getUnready().size()); } } diff --git a/java/test/src/main/java/org/ray/api/test/RpcTest.java b/java/test/src/main/java/org/ray/api/test/RpcTest.java deleted file mode 100644 index 0c8165b74..000000000 --- a/java/test/src/main/java/org/ray/api/test/RpcTest.java +++ /dev/null @@ -1,39 +0,0 @@ -package org.ray.api.test; - -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.ray.api.Ray; -import org.ray.api.RayRemote; - -@RunWith(MyRunner.class) -public class RpcTest { - - @RayRemote - public static Integer with0Params() { - return 0; - } - - @RayRemote - public static Integer with1Params(Integer x) { - return x; - } - - @RayRemote - public static Integer with2Params(Integer x, Integer y) { - return x + y; - } - - @RayRemote - public static Integer with3Params(Integer x, Integer y, Integer z) { - return x + y + z; - } - - @Test - public void test() { - Assert.assertEquals(0, (int) Ray.call(RpcTest::with0Params).get()); - Assert.assertEquals(1, (int) Ray.call(RpcTest::with1Params, 1).get()); - Assert.assertEquals(3, (int) Ray.call(RpcTest::with2Params, 1, 2).get()); - Assert.assertEquals(6, (int) Ray.call(RpcTest::with3Params, 1, 2, 3).get()); - } -} diff --git a/java/test/src/main/java/org/ray/api/test/TestListener.java b/java/test/src/main/java/org/ray/api/test/TestListener.java index 5af2dfb22..323b1eb74 100644 --- a/java/test/src/main/java/org/ray/api/test/TestListener.java +++ b/java/test/src/main/java/org/ray/api/test/TestListener.java @@ -4,7 +4,6 @@ import org.junit.runner.Description; import org.junit.runner.Result; import org.junit.runner.notification.RunListener; import org.ray.api.Ray; -import org.ray.core.RayRuntime; public class TestListener extends RunListener { @@ -15,6 +14,6 @@ public class TestListener extends RunListener { @Override public void testRunFinished(Result result) { - RayRuntime.getInstance().cleanUp(); + Ray.shutdown(); } -} \ No newline at end of file +} diff --git a/java/test/src/main/java/org/ray/api/test/TypesTest.java b/java/test/src/main/java/org/ray/api/test/TypesTest.java deleted file mode 100644 index f64b27d9f..000000000 --- a/java/test/src/main/java/org/ray/api/test/TypesTest.java +++ /dev/null @@ -1,82 +0,0 @@ -package org.ray.api.test; - -import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableMap; -import java.util.List; -import java.util.Map; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.ray.api.Ray; -import org.ray.api.RayRemote; - -/** - * Test returning different types. - */ -@RunWith(MyRunner.class) -public class TypesTest { - - @RayRemote - private static int testInt() { - return 1; - } - - @RayRemote - private static byte testByte() { - return 1; - } - - @RayRemote - private static short testShort() { - return 1; - } - - @RayRemote - private static long testLong() { - return 1; - } - - @RayRemote - private static double testDouble() { - return 1; - } - - @RayRemote - private static float testFloat() { - return 1; - } - - @RayRemote - private static boolean testBool() { - return true; - } - - @RayRemote - private static String testString() { - return "foo"; - } - - @RayRemote - private static List testList() { - return ImmutableList.of(1, 2, 3); - } - - @RayRemote - private static Map testMap() { - return ImmutableMap.of("1", 1, "2", 2); - } - - @Test - public void test() { - Assert.assertEquals(1, (int) Ray.call(TypesTest::testInt).get()); - Assert.assertEquals(1, (byte) Ray.call(TypesTest::testByte).get()); - Assert.assertEquals(1, (short) Ray.call(TypesTest::testShort).get()); - Assert.assertEquals(1, (long) Ray.call(TypesTest::testLong).get()); - Assert.assertEquals(1.0, Ray.call(TypesTest::testDouble).get(), 0.0); - Assert.assertEquals(1.0f, Ray.call(TypesTest::testFloat).get(), 0.0); - Assert.assertEquals(true, Ray.call(TypesTest::testBool).get()); - Assert.assertEquals("foo", Ray.call(TypesTest::testString).get()); - Assert.assertEquals(ImmutableList.of(1, 2, 3), Ray.call(TypesTest::testList).get()); - Assert.assertEquals(ImmutableMap.of("1", 1, "2", 2), Ray.call(TypesTest::testMap).get()); - } -} diff --git a/java/test/src/main/java/org/ray/api/test/UniqueIdTest.java b/java/test/src/main/java/org/ray/api/test/UniqueIdTest.java index 0ffa8c582..6c5982a1b 100644 --- a/java/test/src/main/java/org/ray/api/test/UniqueIdTest.java +++ b/java/test/src/main/java/org/ray/api/test/UniqueIdTest.java @@ -6,7 +6,7 @@ import javax.xml.bind.DatatypeConverter; import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; -import org.ray.api.UniqueID; +import org.ray.api.id.UniqueId; import org.ray.core.UniqueIdHelper; @RunWith(MyRunner.class) @@ -15,12 +15,12 @@ public class UniqueIdTest { @Test public void testConstructUniqueId() { // Test `fromHexString()` - UniqueID id1 = UniqueID.fromHexString("00000000123456789ABCDEF123456789ABCDEF00"); + UniqueId id1 = UniqueId.fromHexString("00000000123456789ABCDEF123456789ABCDEF00"); Assert.assertEquals("00000000123456789ABCDEF123456789ABCDEF00", id1.toString()); Assert.assertFalse(id1.isNil()); try { - UniqueID id2 = UniqueID.fromHexString("000000123456789ABCDEF123456789ABCDEF00"); + UniqueId id2 = UniqueId.fromHexString("000000123456789ABCDEF123456789ABCDEF00"); // This shouldn't be happened. Assert.assertTrue(false); } catch (IllegalArgumentException e) { @@ -28,7 +28,7 @@ public class UniqueIdTest { } try { - UniqueID id3 = UniqueID.fromHexString("GGGGGGGGGGGGG"); + UniqueId id3 = UniqueId.fromHexString("GGGGGGGGGGGGG"); // This shouldn't be happened. Assert.assertTrue(false); } catch (IllegalArgumentException e) { @@ -38,13 +38,13 @@ public class UniqueIdTest { // Test `fromByteBuffer()` byte[] bytes = DatatypeConverter.parseHexBinary("0123456789ABCDEF0123456789ABCDEF01234567"); ByteBuffer byteBuffer = ByteBuffer.wrap(bytes, 0, 20); - UniqueID id4 = UniqueID.fromByteBuffer(byteBuffer); + UniqueId id4 = UniqueId.fromByteBuffer(byteBuffer); Assert.assertTrue(Arrays.equals(bytes, id4.getBytes())); Assert.assertEquals("0123456789ABCDEF0123456789ABCDEF01234567", id4.toString()); // Test `genNil()` - UniqueID id6 = UniqueID.genNil(); + UniqueId id6 = UniqueId.genNil(); Assert.assertEquals("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", id6.toString()); Assert.assertTrue(id6.isNil()); } @@ -52,9 +52,9 @@ public class UniqueIdTest { @Test public void testComputeReturnId() { // Mock a taskId, and the lowest 4 bytes should be 0. - UniqueID taskId = UniqueID.fromHexString("00000000123456789ABCDEF123456789ABCDEF00"); + UniqueId taskId = UniqueId.fromHexString("00000000123456789ABCDEF123456789ABCDEF00"); - UniqueID returnId = UniqueIdHelper.computeReturnId(taskId, 1); + UniqueId returnId = UniqueIdHelper.computeReturnId(taskId, 1); Assert.assertEquals("01000000123456789ABCDEF123456789ABCDEF00", returnId.toString()); returnId = UniqueIdHelper.computeReturnId(taskId, 0x01020304); @@ -63,8 +63,8 @@ public class UniqueIdTest { @Test public void testComputeTaskId() { - UniqueID objId = UniqueID.fromHexString("34421980123456789ABCDEF123456789ABCDEF00"); - UniqueID taskId = UniqueIdHelper.computeTaskId(objId); + UniqueId objId = UniqueId.fromHexString("34421980123456789ABCDEF123456789ABCDEF00"); + UniqueId taskId = UniqueIdHelper.computeTaskId(objId); Assert.assertEquals("00000000123456789ABCDEF123456789ABCDEF00", taskId.toString()); } @@ -72,9 +72,9 @@ public class UniqueIdTest { @Test public void testComputePutId() { // Mock a taskId, the lowest 4 bytes should be 0. - UniqueID taskId = UniqueID.fromHexString("00000000123456789ABCDEF123456789ABCDEF00"); + UniqueId taskId = UniqueId.fromHexString("00000000123456789ABCDEF123456789ABCDEF00"); - UniqueID putId = UniqueIdHelper.computePutId(taskId, 1); + UniqueId putId = UniqueIdHelper.computePutId(taskId, 1); Assert.assertEquals("FFFFFFFF123456789ABCDEF123456789ABCDEF00", putId.toString()); putId = UniqueIdHelper.computePutId(taskId, 0x01020304); diff --git a/java/test/src/main/java/org/ray/api/test/WaitTest.java b/java/test/src/main/java/org/ray/api/test/WaitTest.java index a3339b783..ee1df5f30 100644 --- a/java/test/src/main/java/org/ray/api/test/WaitTest.java +++ b/java/test/src/main/java/org/ray/api/test/WaitTest.java @@ -7,45 +7,40 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.ray.api.Ray; import org.ray.api.RayObject; -import org.ray.api.RayRemote; import org.ray.api.WaitResult; +import org.ray.api.annotation.RayRemote; @RunWith(MyRunner.class) public class WaitTest { @RayRemote - public static String hi() { + private static String hi() { return "hi"; } @RayRemote - public static String delayHi() { + private static String delayedHi() { try { Thread.sleep(100 * 1000); } catch (Exception e) { e.printStackTrace(); } - return "hi"; } @Test public void test() { RayObject obj1 = Ray.call(WaitTest::hi); - RayObject obj2 = Ray.call(WaitTest::delayHi); + RayObject obj2 = Ray.call(WaitTest::delayedHi); - List> waitfor = ImmutableList.of(obj1, obj2); - WaitResult waitResult = Ray.wait(waitfor, 2, 2 * 1000); - List> readys = waitResult.getReadyOnes(); + List> waitList = ImmutableList.of(obj1, obj2); + WaitResult waitResult = Ray.wait(waitList, 2, 2 * 1000); - if (!readys.isEmpty()) { - Assert.assertEquals(1, waitResult.getReadyOnes().size()); - Assert.assertEquals(1, waitResult.getRemainOnes().size()); - Assert.assertEquals("hi", readys.get(0).get()); - } else { - Assert.assertEquals(0, waitResult.getReadyOnes().size()); - Assert.assertEquals(2, waitResult.getRemainOnes().size()); - } + List> readyList = waitResult.getReady(); + + Assert.assertEquals(1, waitResult.getReady().size()); + Assert.assertEquals(1, waitResult.getUnready().size()); + Assert.assertEquals("hi", readyList.get(0).get()); } } diff --git a/java/test/src/main/java/org/ray/api/test/WordCountTest.java b/java/test/src/main/java/org/ray/api/test/WordCountTest.java index 92c6763d1..850190c99 100644 --- a/java/test/src/main/java/org/ray/api/test/WordCountTest.java +++ b/java/test/src/main/java/org/ray/api/test/WordCountTest.java @@ -6,7 +6,7 @@ import java.util.List; import org.junit.Assert; import org.ray.api.Ray; import org.ray.api.RayObject; -import org.ray.api.RayRemote; +import org.ray.api.annotation.RayRemote; import org.ray.util.FileUtil; /** diff --git a/java/tutorial/src/main/java/org/ray/exercise/Exercise01.java b/java/tutorial/src/main/java/org/ray/exercise/Exercise01.java index fc1ab8c66..1a8ad516e 100644 --- a/java/tutorial/src/main/java/org/ray/exercise/Exercise01.java +++ b/java/tutorial/src/main/java/org/ray/exercise/Exercise01.java @@ -3,8 +3,7 @@ package org.ray.exercise; import java.io.Serializable; import org.ray.api.Ray; import org.ray.api.RayObject; -import org.ray.api.RayRemote; -import org.ray.core.RayRuntime; +import org.ray.api.annotation.RayRemote; /** * Define a remote function, and execute multiple remote functions in parallel. @@ -41,7 +40,7 @@ public class Exercise01 implements Serializable { } catch (Throwable t) { t.printStackTrace(); } finally { - RayRuntime.getInstance().cleanUp(); + Ray.shutdown(); } } } diff --git a/java/tutorial/src/main/java/org/ray/exercise/Exercise02.java b/java/tutorial/src/main/java/org/ray/exercise/Exercise02.java index 734019790..b21be5957 100644 --- a/java/tutorial/src/main/java/org/ray/exercise/Exercise02.java +++ b/java/tutorial/src/main/java/org/ray/exercise/Exercise02.java @@ -2,8 +2,7 @@ package org.ray.exercise; import org.ray.api.Ray; import org.ray.api.RayObject; -import org.ray.api.RayRemote; -import org.ray.core.RayRuntime; +import org.ray.api.annotation.RayRemote; /** * Execute remote functions in parallel with some dependencies. @@ -48,7 +47,7 @@ public class Exercise02 { } catch (Throwable t) { t.printStackTrace(); } finally { - RayRuntime.getInstance().cleanUp(); + Ray.shutdown(); } } } diff --git a/java/tutorial/src/main/java/org/ray/exercise/Exercise03.java b/java/tutorial/src/main/java/org/ray/exercise/Exercise03.java index b4c61796c..7e751e7fa 100644 --- a/java/tutorial/src/main/java/org/ray/exercise/Exercise03.java +++ b/java/tutorial/src/main/java/org/ray/exercise/Exercise03.java @@ -2,8 +2,7 @@ package org.ray.exercise; import org.ray.api.Ray; import org.ray.api.RayObject; -import org.ray.api.RayRemote; -import org.ray.core.RayRuntime; +import org.ray.api.annotation.RayRemote; /** * Call a remote function from within another remote function. @@ -39,7 +38,7 @@ public class Exercise03 { } catch (Throwable t) { t.printStackTrace(); } finally { - RayRuntime.getInstance().cleanUp(); + Ray.shutdown(); } } } diff --git a/java/tutorial/src/main/java/org/ray/exercise/Exercise04.java b/java/tutorial/src/main/java/org/ray/exercise/Exercise04.java index 8c8234c18..7a81a5dc1 100644 --- a/java/tutorial/src/main/java/org/ray/exercise/Exercise04.java +++ b/java/tutorial/src/main/java/org/ray/exercise/Exercise04.java @@ -4,9 +4,8 @@ import com.google.common.collect.ImmutableList; import java.util.List; import org.ray.api.Ray; import org.ray.api.RayObject; -import org.ray.api.RayRemote; import org.ray.api.WaitResult; -import org.ray.core.RayRuntime; +import org.ray.api.annotation.RayRemote; /** * Use Ray.wait to ignore stragglers @@ -15,16 +14,14 @@ public class Exercise04 { @RayRemote public static String f1() { - String ret = "f1"; - System.out.println(ret); - return ret; + System.out.println("Executing f1"); + return "f1"; } @RayRemote public static String f2() { - String ret = "f2"; - System.out.println(ret); - return ret; + System.out.println("Executing f2"); + return "f2"; } /** @@ -32,14 +29,14 @@ public class Exercise04 { */ @RayRemote public static String f3() { - String ret = "f3"; + System.out.println("Executing f3"); try { Thread.sleep(5000L); } catch (Exception e) { e.printStackTrace(); } - System.out.println(ret); - return ret; + System.out.println("Finished executing f3"); + return "f3"; } public static void main(String[] args) throws Exception { @@ -54,20 +51,14 @@ public class Exercise04 { // or specified timeout have passed. // In this case, the result of f3 will be ignored. WaitResult waitResult = Ray.wait(waitList, 2, 3000); - List> readyOnes = waitResult.getReadyOnes(); - List> remainOnes = waitResult.getRemainOnes(); - System.out.println("Number of readyOnes: " + readyOnes.size()); - for (int i = 0; i < readyOnes.size(); i++) { - System.out.println("The value of readyOnes " + i + " is " + readyOnes.get(i).get()); - } - System.out.println("Number of remainOnes: " + remainOnes.size()); - for (int i = 0; i < remainOnes.size(); i++) { - System.out.println("The value of remainOnes " + i + " is " + remainOnes.get(i).get()); - } + System.out.printf("%d ready object(s): \n", waitResult.getReady().size()); + waitResult.getReady().forEach(rayObject -> System.out.println(rayObject.get())); + System.out.printf("%d unready object(s): \n", waitResult.getUnready().size()); + waitResult.getUnready().forEach(rayObject -> System.out.println(rayObject.getId())); } catch (Throwable t) { t.printStackTrace(); } finally { - RayRuntime.getInstance().cleanUp(); + Ray.shutdown(); } } } diff --git a/java/tutorial/src/main/java/org/ray/exercise/Exercise05.java b/java/tutorial/src/main/java/org/ray/exercise/Exercise05.java index a44d8d61e..ce23e72fc 100644 --- a/java/tutorial/src/main/java/org/ray/exercise/Exercise05.java +++ b/java/tutorial/src/main/java/org/ray/exercise/Exercise05.java @@ -3,8 +3,7 @@ package org.ray.exercise; import org.ray.api.Ray; import org.ray.api.RayActor; import org.ray.api.RayObject; -import org.ray.api.RayRemote; -import org.ray.core.RayRuntime; +import org.ray.api.annotation.RayRemote; /** * Show usage of actors. @@ -14,8 +13,8 @@ public class Exercise05 { public static void main(String[] args) { try { Ray.init(); - // `Ray.create` creates an actor instance. - RayActor adder = Ray.create(Adder.class); + // `Ray.createActor` creates an actor instance. + RayActor adder = Ray.createActor(Adder.class); // Use `Ray.call(actor, parameters)` to call an actor method. RayObject result1 = Ray.call(Adder::add, adder, 1); System.out.println(result1.get()); @@ -24,7 +23,7 @@ public class Exercise05 { } catch (Throwable t) { t.printStackTrace(); } finally { - RayRuntime.getInstance().cleanUp(); + Ray.shutdown(); } }