wassname/ray
1
0
Fork 0
mirror of https://github.com/wassname/ray.git synced 2026-06-27 22:08:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

[Java] Rename java ObjectRef/ActorHandle (#8799)

Browse Source
This commit is contained in:
chaokunyang
2020-06-09 11:40:43 +08:00
committed by GitHub
parent c1e6813cea
commit 31a4d07bc4
88 changed files with 1551 additions and 1544 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/api/src/main/java/io/ray/api/ActorCall.java
+246 -246
View File
@@ -21,634 +21,634 @@ import io.ray.api.function.RayFuncVoid6;
@SuppressWarnings({"rawtypes", "unchecked"})
interface ActorCall<A> {
default <R> RayObject<R> call(RayFunc1<A, R> f) {
default <R> ObjectRef<R> call(RayFunc1<A, R> f) {
Object[] args = new Object[]{};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default void call(RayFuncVoid1<A> f) {
Object[] args = new Object[]{};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, T0 t0) {
default <T0, R> ObjectRef<R> call(RayFunc2<A, T0, R> f, T0 t0) {
Object[] args = new Object[]{t0};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, RayObject<T0> t0) {
default <T0, R> ObjectRef<R> call(RayFunc2<A, T0, R> f, ObjectRef<T0> t0) {
Object[] args = new Object[]{t0};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0> void call(RayFuncVoid2<A, T0> f, T0 t0) {
Object[] args = new Object[]{t0};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0> void call(RayFuncVoid2<A, T0> f, RayObject<T0> t0) {
default <T0> void call(RayFuncVoid2<A, T0> f, ObjectRef<T0> t0) {
Object[] args = new Object[]{t0};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, T1 t1) {
default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, RayObject<T1> t1) {
default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, ObjectRef<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayObject<T0> t0, T1 t1) {
default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayObject<T0> t0, RayObject<T1> t1) {
default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, RayObject<T1> t1) {
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, ObjectRef<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayObject<T0> t0, T1 t1) {
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayObject<T0> t0, RayObject<T1> t1) {
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, RayObject<T2> t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, T2 t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, ObjectRef<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, T2 t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, RayObject<T2> t2) {
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, RayObject<T1> t1, T2 t2) {
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, T1 t1, T2 t2) {
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor((RayActor) this, f, args);
return Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor((RayActor) this, f, args);
Ray.internal().callActor((ActorHandle) this, f, args);
}
}
java/api/src/main/java/io/ray/api/RayActor.java → java/api/src/main/java/io/ray/api/ActorHandle.java
+3 -3
View File
@@ -12,9 +12,9 @@ package io.ray.api;
* }
* }
* // Create an actor, and get a handle.
* RayActor<MyActor> myActor = Ray.createActor(MyActor::new);
* ActorHandle<MyActor> myActor = Ray.createActor(MyActor::new);
* // Call the `echo` method remotely.
* RayObject<Integer> result = myActor.call(MyActor::echo, 1);
* ObjectRef<Integer> result = myActor.call(MyActor::echo, 1);
* // Get the result of the remote `echo` method.
* Assert.assertEqual(result.get(), 1);
* }</pre>
@@ -24,6 +24,6 @@ package io.ray.api;
*
* @param <A> The type of the concrete actor class.
*/
public interface RayActor<A> extends BaseActor, ActorCall<A> {
public interface ActorHandle<A> extends BaseActorHandle, ActorCall<A> {
}
java/api/src/main/java/io/ray/api/BaseActor.java → java/api/src/main/java/io/ray/api/BaseActorHandle.java
+1 -1
View File
@@ -7,7 +7,7 @@ import io.ray.api.id.ActorId;
*
* A handle can be used to invoke a remote actor method.
*/
public interface BaseActor {
public interface BaseActorHandle {
/**
* @return The id of this actor.
java/api/src/main/java/io/ray/api/RayObject.java → java/api/src/main/java/io/ray/api/ObjectRef.java
+2 -2
View File
@@ -3,10 +3,10 @@ package io.ray.api;
import io.ray.api.id.ObjectId;
/**
* Represents an object in the object store.
* Represents a reference to an object in the object store.
* @param <T> The object type.
*/
public interface RayObject<T> {
public interface ObjectRef<T> {
/**
* Fetch the object from the object store, this method will block
java/api/src/main/java/io/ray/api/PyActorCall.java
+12 -12
View File
@@ -10,34 +10,34 @@ import io.ray.api.function.PyActorMethod;
@SuppressWarnings({"rawtypes", "unchecked"})
interface PyActorCall {
default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod) {
default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod) {
Object[] args = new Object[]{};
return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
}
default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0) {
default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0) {
Object[] args = new Object[]{obj0};
return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
}
default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1) {
default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1) {
Object[] args = new Object[]{obj0, obj1};
return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
}
default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2) {
default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2) {
Object[] args = new Object[]{obj0, obj1, obj2};
return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
}
default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3) {
default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3};
return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
}
default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4};
return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
}
}
java/api/src/main/java/io/ray/api/RayPyActor.java → java/api/src/main/java/io/ray/api/PyActorHandle.java
+1 -1
View File
@@ -3,7 +3,7 @@ package io.ray.api;
/**
* Handle of a Python actor.
*/
public interface RayPyActor extends BaseActor, PyActorCall {
public interface PyActorHandle extends BaseActorHandle, PyActorCall {
/**
* @return Module name of the Python actor class.
java/api/src/main/java/io/ray/api/Ray.java
+13 -13
View File
@@ -56,9 +56,9 @@ public final class Ray extends RayCall {
* 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.
* @return A ObjectRef instance that represents the in-store object.
*/
public static <T> RayObject<T> put(T obj) {
public static <T> ObjectRef<T> put(T obj) {
return runtime.put(obj);
}
@@ -85,15 +85,15 @@ public final class Ray extends RayCall {
}
/**
* Get a list of objects by RayObjects from the object store.
* Get a list of objects by `ObjectRef`s from the object store.
*
* @param objectList A list of RayObject to get.
* @param objectList A list of object references.
* @return A list of Java objects.
*/
public static <T> List<T> get(List<RayObject<T>> objectList) {
public static <T> List<T> get(List<ObjectRef<T>> objectList) {
List<ObjectId> objectIds = new ArrayList<>();
Class<T> objectType = null;
for (RayObject<T> o : objectList) {
for (ObjectRef<T> o : objectList) {
objectIds.add(o.getId());
objectType = o.getType();
}
@@ -104,13 +104,13 @@ public final class Ray extends RayCall {
* 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 waitList A list of object references 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.
*/
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns,
int timeoutMs) {
public static <T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns,
int timeoutMs) {
return runtime.wait(waitList, numReturns, timeoutMs);
}
@@ -118,11 +118,11 @@ public final class Ray extends RayCall {
* 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 waitList A list of object references 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 <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns) {
public static <T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns) {
return runtime.wait(waitList, numReturns, Integer.MAX_VALUE);
}
@@ -130,10 +130,10 @@ public final class Ray extends RayCall {
* 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.
* @param waitList A list of object references to wait for.
* @return Two lists, one containing locally available objects, one containing the rest.
*/
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList) {
public static <T> WaitResult<T> wait(List<ObjectRef<T>> waitList) {
return runtime.wait(waitList, waitList.size(), Integer.MAX_VALUE);
}
java/api/src/main/java/io/ray/api/RayCall.java
+776 -776
View File
File diff suppressed because it is too large Load Diff
java/api/src/main/java/io/ray/api/WaitResult.java
+5 -5
View File
@@ -8,10 +8,10 @@ import java.util.List;
*/
public final class WaitResult<T> {
private final List<RayObject<T>> ready;
private final List<RayObject<T>> unready;
private final List<ObjectRef<T>> ready;
private final List<ObjectRef<T>> unready;
public WaitResult(List<RayObject<T>> ready, List<RayObject<T>> unready) {
public WaitResult(List<ObjectRef<T>> ready, List<ObjectRef<T>> unready) {
this.ready = ready;
this.unready = unready;
}
@@ -19,14 +19,14 @@ public final class WaitResult<T> {
/**
* Get the list of ready objects.
*/
public List<RayObject<T>> getReady() {
public List<ObjectRef<T>> getReady() {
return ready;
}
/**
* Get the list of unready objects.
*/
public List<RayObject<T>> getUnready() {
public List<ObjectRef<T>> getUnready() {
return unready;
}
java/api/src/main/java/io/ray/api/function/PyActorClass.java
+1 -1
View File
@@ -18,7 +18,7 @@ package io.ray.api.function;
* we can create this Python actor from Java:
*
* {@code
* RayPyActor actor = Ray.createActor(new PyActorClass("example_package.example_module", "A"),
* PyActorHandle actor = Ray.createActor(new PyActorClass("example_package.example_module", "A"),
* "the value for x");
* }
* </pre>
java/api/src/main/java/io/ray/api/function/PyActorMethod.java
+2 -2
View File
@@ -17,14 +17,14 @@ package io.ray.api.function;
* suppose we have got the Python actor class A's handle in Java
*
* {@code
* RayPyActor actor = ...; // returned from Ray.createActor or passed from Python
* PyActorHandle actor = ...; // returned from Ray.createActor or passed from Python
* }
*
* then we can call the actor method:
*
* {@code
* // A.foo returns a string, so we have to set the returnType to String.class
* RayObject<String> res = actor.call(new PyActorMethod<>("foo", String.class));
* ObjectRef<String> res = actor.call(new PyActorMethod<>("foo", String.class));
* String x = res.get();
* }
* </pre>
java/api/src/main/java/io/ray/api/function/PyRemoteFunction.java
+2 -2
View File
@@ -18,13 +18,13 @@ package io.ray.api.function;
*
* {@code
* // bar returns input, so we have to set the returnType to int.class if bar accepts an int
* RayObject<Integer> res = actor.call(
* ObjectRef<Integer> res = actor.call(
* new PyRemoteFunction<>("example_package.example_module", "bar", Integer.class),
* 1);
* Integer value = res.get();
*
* // bar returns input, so we have to set the returnType to String.class if bar accepts a string
* RayObject<String> res = actor.call(
* ObjectRef<String> res = actor.call(
* new PyRemoteFunction<>("example_package.example_module", "bar", String.class),
* "Hello world!");
* String value = res.get();
java/api/src/main/java/io/ray/api/runtime/RayRuntime.java
+17 -17
View File
@@ -1,9 +1,9 @@
package io.ray.api.runtime;
import io.ray.api.BaseActor;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.RayPyActor;
import io.ray.api.ActorHandle;
import io.ray.api.BaseActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.PyActorHandle;
import io.ray.api.WaitResult;
import io.ray.api.function.PyActorClass;
import io.ray.api.function.PyActorMethod;
@@ -31,9 +31,9 @@ public interface RayRuntime {
* 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.
* @return A ObjectRef instance that represents the in-store object.
*/
<T> RayObject<T> put(T obj);
<T> ObjectRef<T> put(T obj);
/**
* Get an object from the object store.
@@ -57,12 +57,12 @@ public interface RayRuntime {
* 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 waitList A list of ObjectRef 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.
*/
<T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs);
<T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns, int timeoutMs);
/**
* Free a list of objects from Plasma Store.
@@ -88,7 +88,7 @@ public interface RayRuntime {
* @param actor The actor to be killed.
* @param noRestart If set to true, the killed actor will not be restarted anymore.
*/
void killActor(BaseActor actor, boolean noRestart);
void killActor(BaseActorHandle actor, boolean noRestart);
/**
* Invoke a remote function.
@@ -98,7 +98,7 @@ public interface RayRuntime {
* @param options The options for this call.
* @return The result object.
*/
RayObject call(RayFunc func, Object[] args, CallOptions options);
ObjectRef call(RayFunc func, Object[] args, CallOptions options);
/**
* Invoke a remote Python function.
@@ -108,7 +108,7 @@ public interface RayRuntime {
* @param options The options for this call.
* @return The result object.
*/
RayObject call(PyRemoteFunction pyRemoteFunction, Object[] args, CallOptions options);
ObjectRef call(PyRemoteFunction pyRemoteFunction, Object[] args, CallOptions options);
/**
* Invoke a remote function on an actor.
@@ -118,7 +118,7 @@ public interface RayRuntime {
* @param args The arguments of the remote function.
* @return The result object.
*/
RayObject callActor(RayActor<?> actor, RayFunc func, Object[] args);
ObjectRef callActor(ActorHandle<?> actor, RayFunc func, Object[] args);
/**
* Invoke a remote Python function on an actor.
@@ -128,7 +128,7 @@ public interface RayRuntime {
* @param args Arguments of the function.
* @return The result object.
*/
RayObject callActor(RayPyActor pyActor, PyActorMethod pyActorMethod, Object[] args);
ObjectRef callActor(PyActorHandle pyActor, PyActorMethod pyActorMethod, Object[] args);
/**
* Create an actor on a remote node.
@@ -139,8 +139,8 @@ public interface RayRuntime {
* @param options The options for creating actor.
* @return A handle to the actor.
*/
<T> RayActor<T> createActor(RayFunc actorFactoryFunc, Object[] args,
ActorCreationOptions options);
<T> ActorHandle<T> createActor(RayFunc actorFactoryFunc, Object[] args,
ActorCreationOptions options);
/**
* Create a Python actor on a remote node.
@@ -150,8 +150,8 @@ public interface RayRuntime {
* @param options The options for creating actor.
* @return A handle to the actor.
*/
RayPyActor createActor(PyActorClass pyActorClass, Object[] args,
ActorCreationOptions options);
PyActorHandle createActor(PyActorClass pyActorClass, Object[] args,
ActorCreationOptions options);
RuntimeContext getRuntimeContext();
java/generate_jni_header_files.sh
+1 -1
View File
@@ -36,7 +36,7 @@ EOF
generate_one io.ray.runtime.RayNativeRuntime
generate_one io.ray.runtime.task.NativeTaskSubmitter
generate_one io.ray.runtime.context.NativeWorkerContext
generate_one io.ray.runtime.actor.NativeRayActor
generate_one io.ray.runtime.actor.NativeActorHandle
generate_one io.ray.runtime.object.NativeObjectStore
generate_one io.ray.runtime.task.NativeTaskExecutor
generate_one io.ray.runtime.gcs.GlobalStateAccessor
java/runtime/src/main/java/io/ray/runtime/AbstractRayRuntime.java
+31 -27
View File
@@ -3,10 +3,10 @@ package io.ray.runtime;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import io.ray.api.BaseActor;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.RayPyActor;
import io.ray.api.ActorHandle;
import io.ray.api.BaseActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.PyActorHandle;
import io.ray.api.WaitResult;
import io.ray.api.exception.RayException;
import io.ray.api.function.PyActorClass;
@@ -27,8 +27,8 @@ import io.ray.runtime.functionmanager.RayFunction;
import io.ray.runtime.gcs.GcsClient;
import io.ray.runtime.generated.Common;
import io.ray.runtime.generated.Common.Language;
import io.ray.runtime.object.ObjectRefImpl;
import io.ray.runtime.object.ObjectStore;
import io.ray.runtime.object.RayObjectImpl;
import io.ray.runtime.task.ArgumentsBuilder;
import io.ray.runtime.task.FunctionArg;
import io.ray.runtime.task.TaskExecutor;
@@ -72,9 +72,9 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
public abstract void shutdown();
@Override
public <T> RayObject<T> put(T obj) {
public <T> ObjectRef<T> put(T obj) {
ObjectId objectId = objectStore.put(obj);
return new RayObjectImpl<T>(objectId, (Class<T>)(obj == null ? Object.class : obj.getClass()));
return new ObjectRefImpl<T>(objectId, (Class<T>)(obj == null ? Object.class : obj.getClass()));
}
@Override
@@ -94,12 +94,12 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
}
@Override
public <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs) {
public <T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns, int timeoutMs) {
return objectStore.wait(waitList, numReturns, timeoutMs);
}
@Override
public RayObject call(RayFunc func, Object[] args, CallOptions options) {
public ObjectRef call(RayFunc func, Object[] args, CallOptions options) {
RayFunction rayFunction = functionManager.getFunction(workerContext.getCurrentJobId(), func);
FunctionDescriptor functionDescriptor = rayFunction.functionDescriptor;
Optional<Class<?>> returnType = rayFunction.getReturnType();
@@ -107,8 +107,8 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
}
@Override
public RayObject call(PyRemoteFunction pyRemoteFunction, Object[] args,
CallOptions options) {
public ObjectRef call(PyRemoteFunction pyRemoteFunction, Object[] args,
CallOptions options) {
PyFunctionDescriptor functionDescriptor = new PyFunctionDescriptor(
pyRemoteFunction.moduleName,
"",
@@ -119,7 +119,7 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
}
@Override
public RayObject callActor(RayActor<?> actor, RayFunc func, Object[] args) {
public ObjectRef callActor(ActorHandle<?> actor, RayFunc func, Object[] args) {
RayFunction rayFunction = functionManager.getFunction(workerContext.getCurrentJobId(), func);
FunctionDescriptor functionDescriptor = rayFunction.functionDescriptor;
Optional<Class<?>> returnType = rayFunction.getReturnType();
@@ -127,7 +127,7 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
}
@Override
public RayObject callActor(RayPyActor pyActor, PyActorMethod pyActorMethod, Object... args) {
public ObjectRef callActor(PyActorHandle pyActor, PyActorMethod pyActorMethod, Object... args) {
PyFunctionDescriptor functionDescriptor = new PyFunctionDescriptor(pyActor.getModuleName(),
pyActor.getClassName(), pyActorMethod.methodName);
// Python functions always have a return value, even if it's `None`.
@@ -137,22 +137,22 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
@Override
@SuppressWarnings("unchecked")
public <T> RayActor<T> createActor(RayFunc actorFactoryFunc,
Object[] args, ActorCreationOptions options) {
public <T> ActorHandle<T> createActor(RayFunc actorFactoryFunc,
Object[] args, ActorCreationOptions options) {
FunctionDescriptor functionDescriptor =
functionManager.getFunction(workerContext.getCurrentJobId(), actorFactoryFunc)
.functionDescriptor;
return (RayActor<T>) createActorImpl(functionDescriptor, args, options);
return (ActorHandle<T>) createActorImpl(functionDescriptor, args, options);
}
@Override
public RayPyActor createActor(PyActorClass pyActorClass, Object[] args,
ActorCreationOptions options) {
public PyActorHandle createActor(PyActorClass pyActorClass, Object[] args,
ActorCreationOptions options) {
PyFunctionDescriptor functionDescriptor = new PyFunctionDescriptor(
pyActorClass.moduleName,
pyActorClass.className,
PYTHON_INIT_METHOD_NAME);
return (RayPyActor) createActorImpl(functionDescriptor, args, options);
return (PyActorHandle) createActorImpl(functionDescriptor, args, options);
}
@@ -207,7 +207,8 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
};
}
private RayObject callNormalFunction(FunctionDescriptor functionDescriptor,
private ObjectRef callNormalFunction(
FunctionDescriptor functionDescriptor,
Object[] args, Optional<Class<?>> returnType, CallOptions options) {
int numReturns = returnType.isPresent() ? 1 : 0;
List<FunctionArg> functionArgs = ArgumentsBuilder
@@ -218,12 +219,15 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
if (returnIds.isEmpty()) {
return null;
} else {
return new RayObjectImpl(returnIds.get(0), returnType.get());
return new ObjectRefImpl(returnIds.get(0), returnType.get());
}
}
private RayObject callActorFunction(BaseActor rayActor,
FunctionDescriptor functionDescriptor, Object[] args, Optional<Class<?>> returnType) {
private ObjectRef callActorFunction(
BaseActorHandle rayActor,
FunctionDescriptor functionDescriptor,
Object[] args,
Optional<Class<?>> returnType) {
int numReturns = returnType.isPresent() ? 1 : 0;
List<FunctionArg> functionArgs = ArgumentsBuilder
.wrap(args, functionDescriptor.getLanguage());
@@ -233,18 +237,18 @@ public abstract class AbstractRayRuntime implements RayRuntimeInternal {
if (returnIds.isEmpty()) {
return null;
} else {
return new RayObjectImpl(returnIds.get(0), returnType.get());
return new ObjectRefImpl(returnIds.get(0), returnType.get());
}
}
private BaseActor createActorImpl(FunctionDescriptor functionDescriptor,
Object[] args, ActorCreationOptions options) {
private BaseActorHandle createActorImpl(FunctionDescriptor functionDescriptor,
Object[] args, ActorCreationOptions options) {
List<FunctionArg> functionArgs = ArgumentsBuilder
.wrap(args, functionDescriptor.getLanguage());
if (functionDescriptor.getLanguage() != Language.JAVA && options != null) {
Preconditions.checkState(Strings.isNullOrEmpty(options.jvmOptions));
}
BaseActor actor = taskSubmitter.createActor(functionDescriptor, functionArgs, options);
BaseActorHandle actor = taskSubmitter.createActor(functionDescriptor, functionArgs, options);
return actor;
}
java/runtime/src/main/java/io/ray/runtime/RayDevRuntime.java
+2 -2
View File
@@ -1,7 +1,7 @@
package io.ray.runtime;
import com.google.common.base.Preconditions;
import io.ray.api.BaseActor;
import io.ray.api.BaseActorHandle;
import io.ray.api.id.JobId;
import io.ray.api.id.UniqueId;
import io.ray.runtime.config.RayConfig;
@@ -62,7 +62,7 @@ public class RayDevRuntime extends AbstractRayRuntime {
}
@Override
public void killActor(BaseActor actor, boolean noRestart) {
public void killActor(BaseActorHandle actor, boolean noRestart) {
throw new UnsupportedOperationException();
}
java/runtime/src/main/java/io/ray/runtime/RayNativeRuntime.java
+2 -2
View File
@@ -1,7 +1,7 @@
package io.ray.runtime;
import com.google.common.base.Preconditions;
import io.ray.api.BaseActor;
import io.ray.api.BaseActorHandle;
import io.ray.api.id.JobId;
import io.ray.api.id.UniqueId;
import io.ray.runtime.config.RayConfig;
@@ -132,7 +132,7 @@ public final class RayNativeRuntime extends AbstractRayRuntime {
}
@Override
public void killActor(BaseActor actor, boolean noRestart) {
public void killActor(BaseActorHandle actor, boolean noRestart) {
nativeKillActor(actor.getId().getBytes(), noRestart);
}
java/runtime/src/main/java/io/ray/runtime/actor/LocalModeRayActor.java → java/runtime/src/main/java/io/ray/runtime/actor/LocalModeActorHandle.java
+4 -4
View File
@@ -1,6 +1,6 @@
package io.ray.runtime.actor;
import io.ray.api.RayActor;
import io.ray.api.ActorHandle;
import io.ray.api.id.ActorId;
import io.ray.api.id.ObjectId;
import java.io.Externalizable;
@@ -12,13 +12,13 @@ import java.util.concurrent.atomic.AtomicReference;
/**
* Implementation of actor handle for local mode.
*/
public class LocalModeRayActor implements RayActor, Externalizable {
public class LocalModeActorHandle implements ActorHandle, Externalizable {
private ActorId actorId;
private AtomicReference<ObjectId> previousActorTaskDummyObjectId = new AtomicReference<>();
public LocalModeRayActor(ActorId actorId, ObjectId previousActorTaskDummyObjectId) {
public LocalModeActorHandle(ActorId actorId, ObjectId previousActorTaskDummyObjectId) {
this.actorId = actorId;
this.previousActorTaskDummyObjectId.set(previousActorTaskDummyObjectId);
}
@@ -26,7 +26,7 @@ public class LocalModeRayActor implements RayActor, Externalizable {
/**
* Required by FST
*/
public LocalModeRayActor() {
public LocalModeActorHandle() {
}
@Override
java/runtime/src/main/java/io/ray/runtime/actor/NativeRayActor.java → java/runtime/src/main/java/io/ray/runtime/actor/NativeActorHandle.java
+9 -12
View File
@@ -1,7 +1,7 @@
package io.ray.runtime.actor;
import com.google.common.base.Preconditions;
import io.ray.api.BaseActor;
import io.ray.api.BaseActorHandle;
import io.ray.api.id.ActorId;
import io.ray.runtime.generated.Common.Language;
import java.io.Externalizable;
@@ -14,7 +14,7 @@ import java.util.List;
* Abstract and language-independent implementation of actor handle for cluster mode. This is a
* wrapper class for C++ ActorHandle.
*/
public abstract class NativeRayActor implements BaseActor, Externalizable {
public abstract class NativeActorHandle implements BaseActorHandle, Externalizable {
/**
* ID of the actor.
@@ -23,7 +23,7 @@ public abstract class NativeRayActor implements BaseActor, Externalizable {
private Language language;
NativeRayActor(byte[] actorId, Language language) {
NativeActorHandle(byte[] actorId, Language language) {
Preconditions.checkState(!ActorId.fromBytes(actorId).isNil());
this.actorId = actorId;
this.language = language;
@@ -32,15 +32,15 @@ public abstract class NativeRayActor implements BaseActor, Externalizable {
/**
* Required by FST
*/
NativeRayActor() {
NativeActorHandle() {
}
public static NativeRayActor create(byte[] actorId, Language language) {
public static NativeActorHandle create(byte[] actorId, Language language) {
switch (language) {
case JAVA:
return new NativeRayJavaActor(actorId);
return new NativeJavaActorHandle(actorId);
case PYTHON:
return new NativeRayPyActor(actorId);
return new NativePyActorHandle(actorId);
default:
throw new IllegalStateException("Unknown actor handle language: " + language);
}
@@ -81,17 +81,14 @@ public abstract class NativeRayActor implements BaseActor, Externalizable {
*
* @return the bytes of an actor handle
*/
public static NativeRayActor fromBytes(byte[] bytes) {
public static NativeActorHandle fromBytes(byte[] bytes) {
byte[] actorId = nativeDeserialize(bytes);
Language language = Language.forNumber(nativeGetLanguage(actorId));
Preconditions.checkNotNull(language);
return create(actorId, language);
}
@Override
protected void finalize() {
// TODO(zhijunfu): do we need to free the ActorHandle in core worker?
}
// TODO(chaokunyang) do we need to free the ActorHandle in core worker by using phantom reference?
private static native int nativeGetLanguage(byte[] actorId);
java/runtime/src/main/java/io/ray/runtime/actor/NativeRayActorSerializer.java → java/runtime/src/main/java/io/ray/runtime/actor/NativeActorHandleSerializer.java
+4 -4
View File
@@ -8,20 +8,20 @@ import org.nustaq.serialization.FSTObjectInput;
import org.nustaq.serialization.FSTObjectOutput;
/**
* To deal with serialization about {@link NativeRayActor}.
* To deal with serialization about {@link NativeActorHandle}.
*/
public class NativeRayActorSerializer extends FSTBasicObjectSerializer {
public class NativeActorHandleSerializer extends FSTBasicObjectSerializer {
@Override
public void writeObject(FSTObjectOutput out, Object toWrite, FSTClazzInfo clzInfo,
FSTClazzInfo.FSTFieldInfo referencedBy, int streamPosition) throws IOException {
((NativeRayActor) toWrite).writeExternal(out);
((NativeActorHandle) toWrite).writeExternal(out);
}
@Override
public void readObject(FSTObjectInput in, Object toRead, FSTClazzInfo clzInfo,
FSTFieldInfo referencedBy) throws Exception {
super.readObject(in, toRead, clzInfo, referencedBy);
((NativeRayActor) toRead).readExternal(in);
((NativeActorHandle) toRead).readExternal(in);
}
}
java/runtime/src/main/java/io/ray/runtime/actor/NativeRayJavaActor.java → java/runtime/src/main/java/io/ray/runtime/actor/NativeJavaActorHandle.java
+4 -4
View File
@@ -1,7 +1,7 @@
package io.ray.runtime.actor;
import com.google.common.base.Preconditions;
import io.ray.api.RayActor;
import io.ray.api.ActorHandle;
import io.ray.runtime.generated.Common.Language;
import java.io.IOException;
import java.io.ObjectInput;
@@ -9,16 +9,16 @@ import java.io.ObjectInput;
/**
* Java implementation of actor handle for cluster mode.
*/
public class NativeRayJavaActor extends NativeRayActor implements RayActor {
public class NativeJavaActorHandle extends NativeActorHandle implements ActorHandle {
NativeRayJavaActor(byte[] actorId) {
NativeJavaActorHandle(byte[] actorId) {
super(actorId, Language.JAVA);
}
/**
* Required by FST
*/
public NativeRayJavaActor() {
public NativeJavaActorHandle() {
super();
}
java/runtime/src/main/java/io/ray/runtime/actor/NativeRayPyActor.java → java/runtime/src/main/java/io/ray/runtime/actor/NativePyActorHandle.java
+4 -4
View File
@@ -1,7 +1,7 @@
package io.ray.runtime.actor;
import com.google.common.base.Preconditions;
import io.ray.api.RayPyActor;
import io.ray.api.PyActorHandle;
import io.ray.runtime.generated.Common.Language;
import java.io.IOException;
import java.io.ObjectInput;
@@ -9,16 +9,16 @@ import java.io.ObjectInput;
/**
* Python actor handle implementation for cluster mode.
*/
public class NativeRayPyActor extends NativeRayActor implements RayPyActor {
public class NativePyActorHandle extends NativeActorHandle implements PyActorHandle {
NativeRayPyActor(byte[] actorId) {
NativePyActorHandle(byte[] actorId) {
super(actorId, Language.PYTHON);
}
/**
* Required by FST
*/
public NativeRayPyActor() {
public NativePyActorHandle() {
super();
}
java/runtime/src/main/java/io/ray/runtime/object/RayObjectImpl.java → java/runtime/src/main/java/io/ray/runtime/object/ObjectRefImpl.java
+4 -4
View File
@@ -1,14 +1,14 @@
package io.ray.runtime.object;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.id.ObjectId;
import java.io.Serializable;
/**
* Implementation of {@link RayObject}.
* Implementation of {@link ObjectRef}.
*/
public final class RayObjectImpl<T> implements RayObject<T>, Serializable {
public final class ObjectRefImpl<T> implements ObjectRef<T>, Serializable {
private final ObjectId id;
@@ -27,7 +27,7 @@ public final class RayObjectImpl<T> implements RayObject<T>, Serializable {
*/
private transient boolean objectGotten;
public RayObjectImpl(ObjectId id, Class<T> type) {
public ObjectRefImpl(ObjectId id, Class<T> type) {
this.id = id;
this.type = type;
object = null;
java/runtime/src/main/java/io/ray/runtime/object/ObjectStore.java
+6 -6
View File
@@ -1,7 +1,7 @@
package io.ray.runtime.object;
import com.google.common.base.Preconditions;
import io.ray.api.RayObject;
import io.ray.api.ObjectRef;
import io.ray.api.WaitResult;
import io.ray.api.exception.RayException;
import io.ray.api.id.ObjectId;
@@ -126,22 +126,22 @@ public abstract class ObjectStore {
* 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 waitList A list of object references 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.
*/
public <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs) {
public <T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns, int timeoutMs) {
Preconditions.checkNotNull(waitList);
if (waitList.isEmpty()) {
return new WaitResult<>(Collections.emptyList(), Collections.emptyList());
}
List<ObjectId> ids = waitList.stream().map(RayObject::getId).collect(Collectors.toList());
List<ObjectId> ids = waitList.stream().map(ObjectRef::getId).collect(Collectors.toList());
List<Boolean> ready = wait(ids, numReturns, timeoutMs);
List<RayObject<T>> readyList = new ArrayList<>();
List<RayObject<T>> unreadyList = new ArrayList<>();
List<ObjectRef<T>> readyList = new ArrayList<>();
List<ObjectRef<T>> unreadyList = new ArrayList<>();
for (int i = 0; i < ready.size(); i++) {
if (ready.get(i)) {
java/runtime/src/main/java/io/ray/runtime/serializer/FstSerializer.java
+3 -3
View File
@@ -1,7 +1,7 @@
package io.ray.runtime.serializer;
import io.ray.runtime.actor.NativeRayActor;
import io.ray.runtime.actor.NativeRayActorSerializer;
import io.ray.runtime.actor.NativeActorHandle;
import io.ray.runtime.actor.NativeActorHandleSerializer;
import org.nustaq.serialization.FSTConfiguration;
/**
@@ -11,7 +11,7 @@ public class FstSerializer {
private static final ThreadLocal<FSTConfiguration> conf = ThreadLocal.withInitial(() -> {
FSTConfiguration conf = FSTConfiguration.createDefaultConfiguration();
conf.registerSerializer(NativeRayActor.class, new NativeRayActorSerializer(), true);
conf.registerSerializer(NativeActorHandle.class, new NativeActorHandleSerializer(), true);
return conf;
});
java/runtime/src/main/java/io/ray/runtime/task/ArgumentsBuilder.java
+3 -3
View File
@@ -1,7 +1,7 @@
package io.ray.runtime.task;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.id.ObjectId;
import io.ray.runtime.RayRuntimeInternal;
import io.ray.runtime.generated.Common.Language;
@@ -36,8 +36,8 @@ public class ArgumentsBuilder {
for (Object arg : args) {
ObjectId id = null;
NativeRayObject value = null;
if (arg instanceof RayObject) {
id = ((RayObject) arg).getId();
if (arg instanceof ObjectRef) {
id = ((ObjectRef) arg).getId();
} else {
value = ObjectSerializer.serialize(arg);
if (language != Language.JAVA) {
java/runtime/src/main/java/io/ray/runtime/task/LocalModeTaskSubmitter.java
+7 -7
View File
@@ -3,7 +3,7 @@ package io.ray.runtime.task;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.protobuf.ByteString;
import io.ray.api.BaseActor;
import io.ray.api.BaseActorHandle;
import io.ray.api.id.ActorId;
import io.ray.api.id.ObjectId;
import io.ray.api.id.TaskId;
@@ -11,7 +11,7 @@ import io.ray.api.id.UniqueId;
import io.ray.api.options.ActorCreationOptions;
import io.ray.api.options.CallOptions;
import io.ray.runtime.RayRuntimeInternal;
import io.ray.runtime.actor.LocalModeRayActor;
import io.ray.runtime.actor.LocalModeActorHandle;
import io.ray.runtime.context.LocalModeWorkerContext;
import io.ray.runtime.functionmanager.FunctionDescriptor;
import io.ray.runtime.functionmanager.JavaFunctionDescriptor;
@@ -149,8 +149,8 @@ public class LocalModeTaskSubmitter implements TaskSubmitter {
}
@Override
public BaseActor createActor(FunctionDescriptor functionDescriptor, List<FunctionArg> args,
ActorCreationOptions options) {
public BaseActorHandle createActor(FunctionDescriptor functionDescriptor, List<FunctionArg> args,
ActorCreationOptions options) {
ActorId actorId = ActorId.fromRandom();
TaskSpec taskSpec = getTaskSpecBuilder(TaskType.ACTOR_CREATION_TASK, functionDescriptor, args)
.setNumReturns(1)
@@ -159,12 +159,12 @@ public class LocalModeTaskSubmitter implements TaskSubmitter {
.build())
.build();
submitTaskSpec(taskSpec);
return new LocalModeRayActor(actorId, getReturnIds(taskSpec).get(0));
return new LocalModeActorHandle(actorId, getReturnIds(taskSpec).get(0));
}
@Override
public List<ObjectId> submitActorTask(
BaseActor actor, FunctionDescriptor functionDescriptor,
BaseActorHandle actor, FunctionDescriptor functionDescriptor,
List<FunctionArg> args, int numReturns, CallOptions options) {
Preconditions.checkState(numReturns <= 1);
TaskSpec.Builder builder = getTaskSpecBuilder(TaskType.ACTOR_TASK, functionDescriptor, args);
@@ -175,7 +175,7 @@ public class LocalModeTaskSubmitter implements TaskSubmitter {
.setActorTaskSpec(
ActorTaskSpec.newBuilder().setActorId(ByteString.copyFrom(actor.getId().getBytes()))
.setPreviousActorTaskDummyObjectId(ByteString.copyFrom(
((LocalModeRayActor) actor)
((LocalModeActorHandle) actor)
.exchangePreviousActorTaskDummyObjectId(returnIds.get(returnIds.size() - 1))
.getBytes()))
.build())
java/runtime/src/main/java/io/ray/runtime/task/NativeTaskSubmitter.java
+7 -7
View File
@@ -1,11 +1,11 @@
package io.ray.runtime.task;
import com.google.common.base.Preconditions;
import io.ray.api.BaseActor;
import io.ray.api.BaseActorHandle;
import io.ray.api.id.ObjectId;
import io.ray.api.options.ActorCreationOptions;
import io.ray.api.options.CallOptions;
import io.ray.runtime.actor.NativeRayActor;
import io.ray.runtime.actor.NativeActorHandle;
import io.ray.runtime.functionmanager.FunctionDescriptor;
import java.util.List;
import java.util.stream.Collectors;
@@ -23,17 +23,17 @@ public class NativeTaskSubmitter implements TaskSubmitter {
}
@Override
public BaseActor createActor(FunctionDescriptor functionDescriptor, List<FunctionArg> args,
ActorCreationOptions options) {
public BaseActorHandle createActor(FunctionDescriptor functionDescriptor, List<FunctionArg> args,
ActorCreationOptions options) {
byte[] actorId = nativeCreateActor(functionDescriptor, args, options);
return NativeRayActor.create(actorId, functionDescriptor.getLanguage());
return NativeActorHandle.create(actorId, functionDescriptor.getLanguage());
}
@Override
public List<ObjectId> submitActorTask(
BaseActor actor, FunctionDescriptor functionDescriptor,
BaseActorHandle actor, FunctionDescriptor functionDescriptor,
List<FunctionArg> args, int numReturns, CallOptions options) {
Preconditions.checkState(actor instanceof NativeRayActor);
Preconditions.checkState(actor instanceof NativeActorHandle);
List<byte[]> returnIds = nativeSubmitActorTask(actor.getId().getBytes(),
functionDescriptor, args, numReturns, options);
return returnIds.stream().map(ObjectId::new).collect(Collectors.toList());
java/runtime/src/main/java/io/ray/runtime/task/TaskSubmitter.java
+5 -5
View File
@@ -1,6 +1,6 @@
package io.ray.runtime.task;
import io.ray.api.BaseActor;
import io.ray.api.BaseActorHandle;
import io.ray.api.id.ObjectId;
import io.ray.api.options.ActorCreationOptions;
import io.ray.api.options.CallOptions;
@@ -30,8 +30,8 @@ public interface TaskSubmitter {
* @param options Options for this actor creation task.
* @return Handle to the actor.
*/
BaseActor createActor(FunctionDescriptor functionDescriptor, List<FunctionArg> args,
ActorCreationOptions options);
BaseActorHandle createActor(FunctionDescriptor functionDescriptor, List<FunctionArg> args,
ActorCreationOptions options);
/**
* Submit an actor task.
@@ -42,6 +42,6 @@ public interface TaskSubmitter {
* @param options Options for this task.
* @return Ids of the return objects.
*/
List<ObjectId> submitActorTask(BaseActor actor, FunctionDescriptor functionDescriptor,
List<FunctionArg> args, int numReturns, CallOptions options);
List<ObjectId> submitActorTask(BaseActorHandle actor, FunctionDescriptor functionDescriptor,
List<FunctionArg> args, int numReturns, CallOptions options);
}
java/runtime/src/main/java/io/ray/runtime/util/generator/RayCallGenerator.java
+6 -6
View File
@@ -170,9 +170,9 @@ public class RayCallGenerator extends BaseGenerator {
// 2) Construct the `returnType` part.
String returnType;
if (forActorCreation) {
returnType = "RayActor<A>";
returnType = "ActorHandle<A>";
} else {
returnType = hasReturn ? "RayObject<R>" : "void";
returnType = hasReturn ? "ObjectRef<R>" : "void";
}
// 3) Construct the `argsDeclaration` part.
@@ -222,7 +222,7 @@ public class RayCallGenerator extends BaseGenerator {
// 5) Construct the third line.
String callFuncArgs = "";
if (forActor) {
callFuncArgs += "(RayActor) this, ";
callFuncArgs += "(ActorHandle) this, ";
}
callFuncArgs += "f, args, ";
callFuncArgs += forActor ? "" : hasOptionsParam ? "options, " : "null, ";
@@ -297,7 +297,7 @@ public class RayCallGenerator extends BaseGenerator {
}
String genericType = forActorCreation ? "" : " <R>";
String returnType = !forActorCreation ? "RayObject<R>" : "RayPyActor";
String returnType = !forActorCreation ? "ObjectRef<R>" : "PyActorHandle";
String funcName = forActorCreation ? "createActor" : "call";
String internalCallFunc = forActorCreation ? "createActor" :
forActor ? "callActor" : "call";
@@ -310,7 +310,7 @@ public class RayCallGenerator extends BaseGenerator {
// Method body.
newLine(2, String.format("Object[] args = new Object[]{%s};", argList));
if (forActor) {
newLine(2, String.format("return Ray.internal().%s((RayPyActor)this, %s%s);",
newLine(2, String.format("return Ray.internal().%s((PyActorHandle)this, %s%s);",
internalCallFunc, funcArgs, optionsArg));
} else {
newLine(2, String.format("return Ray.internal().%s(%s%s);",
@@ -333,7 +333,7 @@ public class RayCallGenerator extends BaseGenerator {
}
String nextParameter = String.format("T%d t%d, ", pos, pos);
dfs(pos + 1, numParams, cur + nextParameter, res);
nextParameter = String.format("RayObject<T%d> t%d, ", pos, pos);
nextParameter = String.format("ObjectRef<T%d> t%d, ", pos, pos);
dfs(pos + 1, numParams, cur + nextParameter, res);
}
java/test/src/main/java/io/ray/api/TestUtils.java
+1 -1
View File
@@ -73,7 +73,7 @@ public class TestUtils {
* idle workers in Raylet's worker pool.
*/
public static void warmUpCluster() {
RayObject<String> obj = Ray.call(TestUtils::hi);
ObjectRef<String> obj = Ray.call(TestUtils::hi);
Assert.assertEquals(obj.get(), "hi");
}
java/test/src/main/java/io/ray/api/benchmark/ActorPressTest.java
+7 -7
View File
@@ -1,8 +1,8 @@
package io.ray.api.benchmark;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import org.testng.annotations.Test;
public class ActorPressTest extends RayBenchmarkTest {
@@ -10,7 +10,7 @@ public class ActorPressTest extends RayBenchmarkTest {
@Test
public void singleLatencyTest() {
int times = 10;
RayActor<Adder> adder = Ray.createActor(ActorPressTest.Adder::new);
ActorHandle<Adder> adder = Ray.createActor(ActorPressTest.Adder::new);
super.singleLatencyTest(times, adder);
}
@@ -18,7 +18,7 @@ public class ActorPressTest extends RayBenchmarkTest {
public void maxTest() {
int clientNum = 2;
int totalNum = 20;
RayActor<ActorPressTest.Adder> adder = Ray.createActor(ActorPressTest.Adder::new);
ActorHandle<Adder> adder = Ray.createActor(ActorPressTest.Adder::new);
PressureTestParameter pressureTestParameter = new PressureTestParameter();
pressureTestParameter.setClientNum(clientNum);
pressureTestParameter.setTotalNum(totalNum);
@@ -32,7 +32,7 @@ public class ActorPressTest extends RayBenchmarkTest {
int clientNum = 2;
int totalQps = 2;
int duration = 3;
RayActor<ActorPressTest.Adder> adder = Ray.createActor(ActorPressTest.Adder::new);
ActorHandle<Adder> adder = Ray.createActor(ActorPressTest.Adder::new);
PressureTestParameter pressureTestParameter = new PressureTestParameter();
pressureTestParameter.setClientNum(clientNum);
pressureTestParameter.setTotalQps(totalQps);
@@ -43,8 +43,8 @@ public class ActorPressTest extends RayBenchmarkTest {
}
@Override
public RayObject<RemoteResult<Integer>> rayCall(RayActor rayActor) {
return ((RayActor<Adder>) rayActor).call(Adder::add, 10);
public ObjectRef<RemoteResult<Integer>> rayCall(ActorHandle rayActor) {
return ((ActorHandle<Adder>) rayActor).call(Adder::add, 10);
}
@Override
java/test/src/main/java/io/ray/api/benchmark/MaxPressureTest.java
+3 -3
View File
@@ -1,8 +1,8 @@
package io.ray.api.benchmark;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import org.testng.annotations.Test;
public class MaxPressureTest extends RayBenchmarkTest {
@@ -28,7 +28,7 @@ public class MaxPressureTest extends RayBenchmarkTest {
}
@Override
public RayObject<RemoteResult<Integer>> rayCall(RayActor rayActor) {
public ObjectRef<RemoteResult<Integer>> rayCall(ActorHandle rayActor) {
return Ray.call(MaxPressureTest::currentTime);
}
java/test/src/main/java/io/ray/api/benchmark/PressureTestParameter.java
+5 -4
View File
@@ -1,6 +1,6 @@
package io.ray.api.benchmark;
import io.ray.api.RayActor;
import io.ray.api.ActorHandle;
import java.io.Serializable;
public class PressureTestParameter implements Serializable {
@@ -19,7 +19,8 @@ public class PressureTestParameter implements Serializable {
private RayBenchmarkTest rayBenchmarkTest; //reference of current test case instance
private RayActor rayActor; // reference of the Actor, if only test remote funtion it could be null
// reference of the Actor, if only test remote funtion it could be null
private ActorHandle rayActor;
public Integer getClientNum() {
return clientNum;
@@ -69,11 +70,11 @@ public class PressureTestParameter implements Serializable {
this.rayBenchmarkTest = rayBenchmarkTest;
}
public RayActor getRayActor() {
public ActorHandle getRayActor() {
return rayActor;
}
public void setRayActor(RayActor rayActor) {
public void setRayActor(ActorHandle rayActor) {
this.rayActor = rayActor;
}
}
java/test/src/main/java/io/ray/api/benchmark/RateLimiterPressureTest.java
+3 -3
View File
@@ -1,8 +1,8 @@
package io.ray.api.benchmark;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import org.testng.annotations.Test;
public class RateLimiterPressureTest extends RayBenchmarkTest {
@@ -30,7 +30,7 @@ public class RateLimiterPressureTest extends RayBenchmarkTest {
}
@Override
public RayObject<RemoteResult<Integer>> rayCall(RayActor rayActor) {
public ObjectRef<RemoteResult<Integer>> rayCall(ActorHandle rayActor) {
return Ray.call(RateLimiterPressureTest::currentTime);
}
java/test/src/main/java/io/ray/api/benchmark/RayBenchmarkTest.java
+11 -11
View File
@@ -1,9 +1,9 @@
package io.ray.api.benchmark;
import com.google.common.util.concurrent.RateLimiter;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.function.RayFunc1;
import io.ray.api.test.BaseTest;
import java.io.Serializable;
@@ -52,14 +52,14 @@ public abstract class RayBenchmarkTest<T> extends BaseTest implements Serializab
}
RemoteResultWrapper temp = new RemoteResultWrapper();
temp.setStartTime(System.nanoTime());
temp.setRayObject(rayBenchmarkTest.rayCall(pressureTestParameter.getRayActor()));
temp.setObjectRef(rayBenchmarkTest.rayCall(pressureTestParameter.getRayActor()));
remoteResultWrappers[i++] = temp;
}
int j = 0;
while (j < len) {
RemoteResultWrapper temp = remoteResultWrappers[j++];
RemoteResult remoteResult = (RemoteResult) temp.getRayObject().get();
RemoteResult remoteResult = (RemoteResult) temp.getObjectRef().get();
long endTime = remoteResult.getFinishTime();
long costTime = endTime - temp.getStartTime();
counterList.add(costTime / 1000);
@@ -74,13 +74,13 @@ public abstract class RayBenchmarkTest<T> extends BaseTest implements Serializab
}
}
public void singleLatencyTest(int times, RayActor rayActor) {
public void singleLatencyTest(int times, ActorHandle rayActor) {
List<Long> counterList = new ArrayList<>();
for (int i = 0; i < times; i++) {
long startTime = System.nanoTime();
RayObject<RemoteResult<T>> rayObject = rayCall(rayActor);
RemoteResult<T> remoteResult = rayObject.get();
ObjectRef<RemoteResult<T>> objectRef = rayCall(rayActor);
RemoteResult<T> remoteResult = objectRef.get();
T t = remoteResult.getResult();
long endTime = System.nanoTime();
long costTime = endTime - startTime;
@@ -92,7 +92,7 @@ public abstract class RayBenchmarkTest<T> extends BaseTest implements Serializab
printList(counterList);
}
public abstract RayObject<RemoteResult<T>> rayCall(RayActor rayActor);
public abstract ObjectRef<RemoteResult<T>> rayCall(ActorHandle rayActor);
public abstract boolean checkResult(T t);
@@ -126,7 +126,7 @@ public abstract class RayBenchmarkTest<T> extends BaseTest implements Serializab
List<Long> counterList = new ArrayList<>();
int clientNum = pressureTestParameter.getClientNum();
RayObject<List<Long>>[] rayObjects = new RayObject[clientNum];
ObjectRef<List<Long>>[] objectRefs = new ObjectRef[clientNum];
for (int i = 0; i < clientNum; i++) {
// Java compiler can't automatically infer the type of
@@ -135,10 +135,10 @@ public abstract class RayBenchmarkTest<T> extends BaseTest implements Serializab
// defect of the Java compiler.
// TODO(hchen): Figure out how to avoid manually declaring `RayFunc` type in this case.
RayFunc1<PressureTestParameter, List<Long>> func = RayBenchmarkTest::singleClient;
rayObjects[i] = Ray.call(func, pressureTestParameter);
objectRefs[i] = Ray.call(func, pressureTestParameter);
}
for (int i = 0; i < clientNum; i++) {
List<Long> subCounterList = rayObjects[i].get();
List<Long> subCounterList = objectRefs[i].get();
Assert.assertNotNull(subCounterList);
counterList.addAll(subCounterList);
}
java/test/src/main/java/io/ray/api/benchmark/RemoteResultWrapper.java
+6 -6
View File
@@ -1,12 +1,12 @@
package io.ray.api.benchmark;
import io.ray.api.RayObject;
import io.ray.api.ObjectRef;
public class RemoteResultWrapper<T> {
private long startTime;
private RayObject<RemoteResult<T>> rayObject;
private ObjectRef<RemoteResult<T>> objectRef;
public long getStartTime() {
return startTime;
@@ -16,11 +16,11 @@ public class RemoteResultWrapper<T> {
this.startTime = startTime;
}
public RayObject<RemoteResult<T>> getRayObject() {
return rayObject;
public ObjectRef<RemoteResult<T>> getObjectRef() {
return objectRef;
}
public void setRayObject(RayObject<RemoteResult<T>> rayObject) {
this.rayObject = rayObject;
public void setObjectRef(ObjectRef<RemoteResult<T>> objectRef) {
this.objectRef = objectRef;
}
}
java/test/src/main/java/io/ray/api/benchmark/SingleLatencyTest.java
+3 -3
View File
@@ -1,8 +1,8 @@
package io.ray.api.benchmark;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import org.testng.annotations.Test;
public class SingleLatencyTest extends RayBenchmarkTest {
@@ -22,7 +22,7 @@ public class SingleLatencyTest extends RayBenchmarkTest {
}
@Override
public RayObject<RemoteResult<Integer>> rayCall(RayActor rayActor) {
public ObjectRef<RemoteResult<Integer>> rayCall(ActorHandle rayActor) {
return Ray.call(SingleLatencyTest::doFunc);
}
java/test/src/main/java/io/ray/api/test/ActorConcurrentCallTest.java
+6 -6
View File
@@ -1,9 +1,9 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.options.ActorCreationOptions;
import java.util.List;
@@ -35,10 +35,10 @@ public class ActorConcurrentCallTest extends BaseTest {
ActorCreationOptions op = new ActorCreationOptions.Builder()
.setMaxConcurrency(3)
.createActorCreationOptions();
RayActor<ConcurrentActor> actor = Ray.createActor(ConcurrentActor::new, op);
RayObject<String> obj1 = actor.call(ConcurrentActor::countDown);
RayObject<String> obj2 = actor.call(ConcurrentActor::countDown);
RayObject<String> obj3 = actor.call(ConcurrentActor::countDown);
ActorHandle<ConcurrentActor> actor = Ray.createActor(ConcurrentActor::new, op);
ObjectRef<String> obj1 = actor.call(ConcurrentActor::countDown);
ObjectRef<String> obj2 = actor.call(ConcurrentActor::countDown);
ObjectRef<String> obj3 = actor.call(ConcurrentActor::countDown);
List<Integer> expectedResult = ImmutableList.of(1, 2, 3);
Assert.assertEquals(obj1.get(), "ok");
java/test/src/main/java/io/ray/api/test/ActorRestartTest.java
+3 -3
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import io.ray.api.ActorHandle;
import io.ray.api.Checkpointable;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.TestUtils;
import io.ray.api.exception.RayActorException;
import io.ray.api.id.ActorId;
@@ -46,7 +46,7 @@ public class ActorRestartTest extends BaseTest {
TestUtils.skipTestUnderSingleProcess();
ActorCreationOptions options =
new ActorCreationOptions.Builder().setMaxRestarts(1).createActorCreationOptions();
RayActor<Counter> actor = Ray.createActor(Counter::new, options);
ActorHandle<Counter> actor = Ray.createActor(Counter::new, options);
// Call increase 3 times.
for (int i = 0; i < 3; i++) {
actor.call(Counter::increase).get();
@@ -125,7 +125,7 @@ public class ActorRestartTest extends BaseTest {
TestUtils.skipTestUnderSingleProcess();
ActorCreationOptions options =
new ActorCreationOptions.Builder().setMaxRestarts(1).createActorCreationOptions();
RayActor<CheckpointableCounter> actor = Ray.createActor(CheckpointableCounter::new, options);
ActorHandle<CheckpointableCounter> actor = Ray.createActor(CheckpointableCounter::new, options);
// Call increase 3 times.
for (int i = 0; i < 3; i++) {
actor.call(CheckpointableCounter::increase).get();
java/test/src/main/java/io/ray/api/test/ActorTest.java
+18 -18
View File
@@ -1,10 +1,10 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.PyActorHandle;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.RayPyActor;
import io.ray.api.TestUtils;
import io.ray.api.exception.UnreconstructableException;
import io.ray.api.id.ActorId;
@@ -47,10 +47,10 @@ public class ActorTest extends BaseTest {
public void testCreateAndCallActor() {
// Test creating an actor from a constructor
RayActor<Counter> actor = Ray.createActor(Counter::new, 1);
ActorHandle<Counter> actor = Ray.createActor(Counter::new, 1);
Assert.assertNotEquals(actor.getId(), ActorId.NIL);
// A java actor is not a python actor
Assert.assertFalse(actor instanceof RayPyActor);
Assert.assertFalse(actor instanceof PyActorHandle);
// Test calling an actor
Assert.assertEquals(Integer.valueOf(1), actor.call(Counter::getValue).get());
actor.call(Counter::increase, 1);
@@ -64,8 +64,8 @@ public class ActorTest extends BaseTest {
* get. To enable getting it twice, we cache the object in `RayObjectImpl`.
*/
public void testGetObjectTwice() {
RayActor<Counter> actor = Ray.createActor(Counter::new, 1);
RayObject<Integer> result = actor.call(Counter::getValue);
ActorHandle<Counter> actor = Ray.createActor(Counter::new, 1);
ObjectRef<Integer> result = actor.call(Counter::getValue);
Assert.assertEquals(result.get(), Integer.valueOf(1));
Assert.assertEquals(result.get(), Integer.valueOf(1));
// TODO(hchen): The following code will still fail, and can be fixed by using ref counting.
@@ -73,7 +73,7 @@ public class ActorTest extends BaseTest {
}
public void testCallActorWithLargeObject() {
RayActor<Counter> actor = Ray.createActor(Counter::new, 1);
ActorHandle<Counter> actor = Ray.createActor(Counter::new, 1);
TestUtils.LargeObject largeObject = new TestUtils.LargeObject();
Assert.assertEquals(Integer.valueOf(largeObject.data.length + 1),
actor.call(Counter::accessLargeObject, largeObject).get());
@@ -85,29 +85,29 @@ public class ActorTest extends BaseTest {
public void testCreateActorFromFactory() {
// Test creating an actor from a factory method
RayActor<Counter> actor = Ray.createActor(ActorTest::factory, 1);
ActorHandle<Counter> actor = Ray.createActor(ActorTest::factory, 1);
Assert.assertNotEquals(actor.getId(), UniqueId.NIL);
// Test calling an actor
Assert.assertEquals(Integer.valueOf(1), actor.call(Counter::getValue).get());
}
static int testActorAsFirstParameter(RayActor<Counter> actor, int delta) {
RayObject<Integer> res = actor.call(Counter::increaseAndGet, delta);
static int testActorAsFirstParameter(ActorHandle<Counter> actor, int delta) {
ObjectRef<Integer> res = actor.call(Counter::increaseAndGet, delta);
return res.get();
}
static int testActorAsSecondParameter(int delta, RayActor<Counter> actor) {
RayObject<Integer> res = actor.call(Counter::increaseAndGet, delta);
static int testActorAsSecondParameter(int delta, ActorHandle<Counter> actor) {
ObjectRef<Integer> res = actor.call(Counter::increaseAndGet, delta);
return res.get();
}
static int testActorAsFieldOfParameter(List<RayActor<Counter>> actor, int delta) {
RayObject<Integer> res = actor.get(0).call(Counter::increaseAndGet, delta);
static int testActorAsFieldOfParameter(List<ActorHandle<Counter>> actor, int delta) {
ObjectRef<Integer> res = actor.get(0).call(Counter::increaseAndGet, delta);
return res.get();
}
public void testPassActorAsParameter() {
RayActor<Counter> actor = Ray.createActor(Counter::new, 0);
ActorHandle<Counter> actor = Ray.createActor(Counter::new, 0);
Assert.assertEquals(Integer.valueOf(1),
Ray.call(ActorTest::testActorAsFirstParameter, actor, 1).get());
Assert.assertEquals(Integer.valueOf(11),
@@ -123,9 +123,9 @@ public class ActorTest extends BaseTest {
TestUtils.skipTestUnderSingleProcess();
// The UnreconstructableException is created by raylet.
RayActor<Counter> counter = Ray.createActor(Counter::new, 100);
ActorHandle<Counter> counter = Ray.createActor(Counter::new, 100);
// Call an actor method.
RayObject value = counter.call(Counter::getValue);
ObjectRef value = counter.call(Counter::getValue);
Assert.assertEquals(100, value.get());
// Delete the object from the object store.
Ray.internal().free(ImmutableList.of(value.getId()), false, false);
java/test/src/main/java/io/ray/api/test/ClassLoaderTest.java
+28 -24
View File
@@ -1,9 +1,9 @@
package io.ray.api.test;
import io.ray.api.BaseActor;
import io.ray.api.ActorHandle;
import io.ray.api.BaseActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.options.ActorCreationOptions;
import io.ray.runtime.AbstractRayRuntime;
@@ -93,18 +93,20 @@ public class ClassLoaderTest extends BaseTest {
// Compile the java file.
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
int result = compiler.run(null, null, null, "-d", jobResourcePath, javaFilePath);
int result = compiler.run(null, null, null, "-d",
jobResourcePath, javaFilePath);
if (result != 0) {
throw new RuntimeException("Couldn't compile ClassLoaderTester.java.");
}
FunctionDescriptor constructor = new JavaFunctionDescriptor("ClassLoaderTester", "<init>",
"()V");
RayActor<?> actor1 = createActor(constructor);
FunctionDescriptor getPid = new JavaFunctionDescriptor("ClassLoaderTester", "getPid", "()I");
FunctionDescriptor constructor = new JavaFunctionDescriptor(
"ClassLoaderTester", "<init>", "()V");
ActorHandle<?> actor1 = createActor(constructor);
FunctionDescriptor getPid = new JavaFunctionDescriptor(
"ClassLoaderTester", "getPid", "()I");
int pid = this.<Integer>callActorFunction(actor1, getPid, new Object[0],
Optional.of(Integer.class)).get();
RayActor<?> actor2;
ActorHandle<?> actor2;
while (true) {
// Create another actor which share the same process of actor 1.
actor2 = createActor(constructor);
@@ -115,40 +117,42 @@ public class ClassLoaderTest extends BaseTest {
}
}
FunctionDescriptor getClassLoaderHashCode = new JavaFunctionDescriptor("ClassLoaderTester",
"getClassLoaderHashCode",
"()I");
RayObject<Integer> hashCode1 = callActorFunction(actor1, getClassLoaderHashCode, new Object[0],
FunctionDescriptor getClassLoaderHashCode = new JavaFunctionDescriptor(
"ClassLoaderTester", "getClassLoaderHashCode", "()I");
ObjectRef<Integer> hashCode1 = callActorFunction(actor1, getClassLoaderHashCode, new Object[0],
Optional.of(Integer.class));
RayObject<Integer> hashCode2 = callActorFunction(actor2, getClassLoaderHashCode, new Object[0],
ObjectRef<Integer> hashCode2 = callActorFunction(actor2, getClassLoaderHashCode, new Object[0],
Optional.of(Integer.class));
Assert.assertEquals(hashCode1.get(), hashCode2.get());
FunctionDescriptor increase = new JavaFunctionDescriptor("ClassLoaderTester", "increase",
"()I");
RayObject<Integer> value1 = callActorFunction(actor1, increase, new Object[0],
FunctionDescriptor increase = new JavaFunctionDescriptor(
"ClassLoaderTester", "increase", "()I");
ObjectRef<Integer> value1 = callActorFunction(actor1, increase, new Object[0],
Optional.of(Integer.class));
RayObject<Integer> value2 = callActorFunction(actor2, increase, new Object[0],
ObjectRef<Integer> value2 = callActorFunction(actor2, increase, new Object[0],
Optional.of(Integer.class));
Assert.assertNotEquals(value1.get(), value2.get());
}
private RayActor<?> createActor(FunctionDescriptor functionDescriptor)
private ActorHandle<?> createActor(FunctionDescriptor functionDescriptor)
throws Exception {
Method createActorMethod = AbstractRayRuntime.class.getDeclaredMethod("createActorImpl",
FunctionDescriptor.class, Object[].class, ActorCreationOptions.class);
createActorMethod.setAccessible(true);
return (RayActor<?>) createActorMethod
return (ActorHandle<?>) createActorMethod
.invoke(TestUtils.getUnderlyingRuntime(), functionDescriptor, new Object[0], null);
}
private <T> RayObject<T> callActorFunction(RayActor<?> rayActor,
FunctionDescriptor functionDescriptor, Object[] args, Optional<Class<?>> returnType)
private <T> ObjectRef<T> callActorFunction(
ActorHandle<?> rayActor,
FunctionDescriptor functionDescriptor,
Object[] args,
Optional<Class<?>> returnType)
throws Exception {
Method callActorFunctionMethod = AbstractRayRuntime.class.getDeclaredMethod("callActorFunction",
BaseActor.class, FunctionDescriptor.class, Object[].class, Optional.class);
BaseActorHandle.class, FunctionDescriptor.class, Object[].class, Optional.class);
callActorFunctionMethod.setAccessible(true);
return (RayObject<T>) callActorFunctionMethod
return (ObjectRef<T>) callActorFunctionMethod
.invoke(TestUtils.getUnderlyingRuntime(), rayActor, functionDescriptor, args, returnType);
}
}
java/test/src/main/java/io/ray/api/test/CrossLanguageInvocationTest.java
+25 -24
View File
@@ -2,15 +2,15 @@ package io.ray.api.test;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.PyActorHandle;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.RayPyActor;
import io.ray.api.function.PyActorClass;
import io.ray.api.function.PyActorMethod;
import io.ray.api.function.PyRemoteFunction;
import io.ray.runtime.actor.NativeRayActor;
import io.ray.runtime.actor.NativeRayPyActor;
import io.ray.runtime.actor.NativeActorHandle;
import io.ray.runtime.actor.NativePyActorHandle;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
@@ -69,7 +69,7 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
1.234, // Double
"example binary".getBytes()}; // byte[]
for (Object o : inputs) {
RayObject res = Ray.call(
ObjectRef res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_return_input", o.getClass()),
o);
Assert.assertEquals(res.get(), o);
@@ -77,7 +77,7 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
// null
{
Object input = null;
RayObject<Object> res = Ray.call(
ObjectRef<Object> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_return_input", Object.class), input);
Object r = res.get();
Assert.assertEquals(r, input);
@@ -85,7 +85,7 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
// array
{
int[] input = new int[]{1, 2};
RayObject<int[]> res = Ray.call(
ObjectRef<int[]> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_return_input", int[].class), input);
int[] r = res.get();
Assert.assertEquals(r, input);
@@ -94,7 +94,7 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
{
Object[] input = new Object[]{1, 2.3f, 4.56, "789", "10".getBytes(), null, true,
new int[]{1, 2}};
RayObject<Object[]> res = Ray.call(
ObjectRef<Object[]> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_return_input", Object[].class), input);
Object[] r = res.get();
// If we tell the value type is Object, then all numbers will be Number type.
@@ -119,7 +119,7 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
{
Assert.expectThrows(Exception.class, () -> {
List<Integer> input = Arrays.asList(1, 2);
RayObject<List<Integer>> res = Ray.call(
ObjectRef<List<Integer>> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_return_input",
(Class<List<Integer>>) input.getClass()), input);
List<Integer> r = res.get();
@@ -130,15 +130,16 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
@Test
public void testPythonCallJavaFunction() {
RayObject<String> res = Ray.call(
ObjectRef<String> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_func_call_java_function", String.class));
Assert.assertEquals(res.get(), "success");
}
@Test
public void testCallingPythonActor() {
RayPyActor actor = Ray.createActor(new PyActorClass(PYTHON_MODULE, "Counter"), "1".getBytes());
RayObject<byte[]> res = actor.call(
PyActorHandle actor = Ray.createActor(
new PyActorClass(PYTHON_MODULE, "Counter"), "1".getBytes());
ObjectRef<byte[]> res = actor.call(
new PyActorMethod<>("increase", byte[].class),
"1".getBytes());
Assert.assertEquals(res.get(), "2".getBytes());
@@ -146,7 +147,7 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
@Test
public void testPythonCallJavaActor() {
RayObject<byte[]> res = Ray.call(
ObjectRef<byte[]> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_func_call_java_actor", byte[].class),
"1".getBytes());
Assert.assertEquals(res.get(), "Counter1".getBytes());
@@ -157,7 +158,7 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
public void testPassActorHandleFromPythonToJava() {
// Call a python function which creates a python actor
// and pass the actor handle to callPythonActorHandle.
RayObject<byte[]> res = Ray.call(
ObjectRef<byte[]> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE, "py_func_pass_python_actor_handle", byte[].class));
Assert.assertEquals(res.get(), "3".getBytes());
}
@@ -165,20 +166,20 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
@Test
public void testPassActorHandleFromJavaToPython() {
// Create a java actor, and pass actor handle to python.
RayActor<TestActor> javaActor = Ray.createActor(TestActor::new, "1".getBytes());
Preconditions.checkState(javaActor instanceof NativeRayActor);
byte[] actorHandleBytes = ((NativeRayActor) javaActor).toBytes();
RayObject<byte[]> res = Ray.call(
ActorHandle<TestActor> javaActor = Ray.createActor(TestActor::new, "1".getBytes());
Preconditions.checkState(javaActor instanceof NativeActorHandle);
byte[] actorHandleBytes = ((NativeActorHandle) javaActor).toBytes();
ObjectRef<byte[]> res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE,
"py_func_call_java_actor_from_handle",
byte[].class),
actorHandleBytes);
Assert.assertEquals(res.get(), "12".getBytes());
// Create a python actor, and pass actor handle to python.
RayPyActor pyActor = Ray.createActor(
PyActorHandle pyActor = Ray.createActor(
new PyActorClass(PYTHON_MODULE, "Counter"), "1".getBytes());
Preconditions.checkState(pyActor instanceof NativeRayActor);
actorHandleBytes = ((NativeRayActor) pyActor).toBytes();
Preconditions.checkState(pyActor instanceof NativeActorHandle);
actorHandleBytes = ((NativeActorHandle) pyActor).toBytes();
res = Ray.call(
new PyRemoteFunction<>(PYTHON_MODULE,
"py_func_call_python_actor_from_handle",
@@ -218,8 +219,8 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
public static byte[] callPythonActorHandle(byte[] value) {
// This function will be called from test_cross_language_invocation.py
NativeRayPyActor actor = (NativeRayPyActor) NativeRayActor.fromBytes(value);
RayObject<byte[]> res = actor.call(
NativePyActorHandle actor = (NativePyActorHandle) NativeActorHandle.fromBytes(value);
ObjectRef<byte[]> res = actor.call(
new PyActorMethod<>("increase", byte[].class),
"1".getBytes());
Assert.assertEquals(res.get(), "3".getBytes());
java/test/src/main/java/io/ray/api/test/DynamicResourceTest.java
+2 -2
View File
@@ -2,8 +2,8 @@ package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.WaitResult;
import io.ray.api.options.CallOptions;
@@ -27,7 +27,7 @@ public class DynamicResourceTest extends BaseTest {
CallOptions op1 =
new CallOptions.Builder().setResources(ImmutableMap.of("A", 10.0)).createCallOptions();
RayObject<String> obj = Ray.call(DynamicResourceTest::sayHi, op1);
ObjectRef<String> obj = Ray.call(DynamicResourceTest::sayHi, op1);
WaitResult<String> result = Ray.wait(ImmutableList.of(obj), 1, 1000);
Assert.assertEquals(result.getReady().size(), 0);
java/test/src/main/java/io/ray/api/test/FailureTest.java
+9 -9
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.exception.RayActorException;
import io.ray.api.exception.RayException;
@@ -71,9 +71,9 @@ public class FailureTest extends BaseTest {
}
}
private static void assertTaskFailedWithRayTaskException(RayObject<?> rayObject) {
private static void assertTaskFailedWithRayTaskException(ObjectRef<?> objectRef) {
try {
rayObject.get();
objectRef.get();
Assert.fail("Task didn't fail.");
} catch (RayTaskException e) {
Throwable rootCause = e.getCause();
@@ -94,14 +94,14 @@ public class FailureTest extends BaseTest {
@Test
public void testActorCreationFailure() {
TestUtils.skipTestUnderSingleProcess();
RayActor<BadActor> actor = Ray.createActor(BadActor::new, true);
ActorHandle<BadActor> actor = Ray.createActor(BadActor::new, true);
assertTaskFailedWithRayTaskException(actor.call(BadActor::badMethod));
}
@Test
public void testActorTaskFailure() {
TestUtils.skipTestUnderSingleProcess();
RayActor<BadActor> actor = Ray.createActor(BadActor::new, false);
ActorHandle<BadActor> actor = Ray.createActor(BadActor::new, false);
assertTaskFailedWithRayTaskException(actor.call(BadActor::badMethod));
}
@@ -120,7 +120,7 @@ public class FailureTest extends BaseTest {
@Test
public void testActorProcessDying() {
TestUtils.skipTestUnderSingleProcess();
RayActor<BadActor> actor = Ray.createActor(BadActor::new, false);
ActorHandle<BadActor> actor = Ray.createActor(BadActor::new, false);
try {
actor.call(BadActor::badMethod2).get();
Assert.fail("This line shouldn't be reached.");
@@ -144,8 +144,8 @@ public class FailureTest extends BaseTest {
FailureTest::badFunc2);
TestUtils.warmUpCluster();
for (RayFunc0<Integer> badFunc : badFunctions) {
RayObject<Integer> obj1 = Ray.call(badFunc);
RayObject<Integer> obj2 = Ray.call(FailureTest::slowFunc);
ObjectRef<Integer> obj1 = Ray.call(badFunc);
ObjectRef<Integer> obj2 = Ray.call(FailureTest::slowFunc);
Instant start = Instant.now();
try {
Ray.get(Arrays.asList(obj1, obj2));
java/test/src/main/java/io/ray/api/test/HelloWorldTest.java
+3 -3
View File
@@ -1,7 +1,7 @@
package io.ray.api.test;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -24,8 +24,8 @@ public class HelloWorldTest extends BaseTest {
@Test
public void testHelloWorld() {
RayObject<String> hello = Ray.call(HelloWorldTest::hello);
RayObject<String> world = Ray.call(HelloWorldTest::world);
ObjectRef<String> hello = Ray.call(HelloWorldTest::hello);
ObjectRef<String> world = Ray.call(HelloWorldTest::world);
String helloWorld = Ray.call(HelloWorldTest::merge, hello, world).get();
Assert.assertEquals("hello,world!", helloWorld);
}
java/test/src/main/java/io/ray/api/test/KillActorTest.java
+9 -9
View File
@@ -1,9 +1,9 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.exception.RayActorException;
import io.ray.api.options.ActorCreationOptions;
@@ -41,27 +41,27 @@ public class KillActorTest extends BaseTest {
public static class KillerActor {
public void kill(RayActor<?> actor, boolean noRestart) {
public void kill(ActorHandle<?> actor, boolean noRestart) {
actor.kill(noRestart);
}
}
private static void localKill(RayActor<?> actor, boolean noRestart) {
private static void localKill(ActorHandle<?> actor, boolean noRestart) {
actor.kill(noRestart);
}
private static void remoteKill(RayActor<?> actor, boolean noRestart) {
RayActor<KillerActor> killer = Ray.createActor(KillerActor::new);
private static void remoteKill(ActorHandle<?> actor, boolean noRestart) {
ActorHandle<KillerActor> killer = Ray.createActor(KillerActor::new);
killer.call(KillerActor::kill, actor, noRestart);
}
private void testKillActor(BiConsumer<RayActor<?>, Boolean> kill, boolean noRestart) {
private void testKillActor(BiConsumer<ActorHandle<?>, Boolean> kill, boolean noRestart) {
TestUtils.skipTestUnderSingleProcess();
ActorCreationOptions options =
new ActorCreationOptions.Builder().setMaxRestarts(1).createActorCreationOptions();
RayActor<HangActor> actor = Ray.createActor(HangActor::new, options);
RayObject<Boolean> result = actor.call(HangActor::hang);
ActorHandle<HangActor> actor = Ray.createActor(HangActor::new, options);
ObjectRef<Boolean> result = actor.call(HangActor::hang);
// The actor will hang in this task.
Assert.assertEquals(0, Ray.wait(ImmutableList.of(result), 1, 500).getReady().size());
java/test/src/main/java/io/ray/api/test/MultiLanguageClusterTest.java
+2 -2
View File
@@ -1,7 +1,7 @@
package io.ray.api.test;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -13,7 +13,7 @@ public class MultiLanguageClusterTest extends BaseMultiLanguageTest {
@Test
public void testMultiLanguageCluster() {
RayObject<String> obj = Ray.call(MultiLanguageClusterTest::echo, "hello");
ObjectRef<String> obj = Ray.call(MultiLanguageClusterTest::echo, "hello");
Assert.assertEquals("hello", obj.get());
}
java/test/src/main/java/io/ray/api/test/MultiThreadingTest.java
+16 -16
View File
@@ -1,9 +1,9 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.WaitResult;
import io.ray.api.exception.RayException;
@@ -73,22 +73,22 @@ public class MultiThreadingTest extends BaseTest {
// Test calling normal functions.
runTestCaseInMultipleThreads(() -> {
int arg = random.nextInt();
RayObject<Integer> obj = Ray.call(MultiThreadingTest::echo, arg);
ObjectRef<Integer> obj = Ray.call(MultiThreadingTest::echo, arg);
Assert.assertEquals(arg, (int) obj.get());
}, LOOP_COUNTER);
// Test calling actors.
RayActor<Echo> echoActor = Ray.createActor(Echo::new);
ActorHandle<Echo> echoActor = Ray.createActor(Echo::new);
runTestCaseInMultipleThreads(() -> {
int arg = random.nextInt();
RayObject<Integer> obj = echoActor.call(Echo::echo, arg);
ObjectRef<Integer> obj = echoActor.call(Echo::echo, arg);
Assert.assertEquals(arg, (int) obj.get());
}, LOOP_COUNTER);
// Test creating multi actors
runTestCaseInMultipleThreads(() -> {
int arg = random.nextInt();
RayActor<Echo> echoActor1 = Ray.createActor(Echo::new);
ActorHandle<Echo> echoActor1 = Ray.createActor(Echo::new);
try {
// Sleep a while to test the case that another actor is created before submitting
// tasks to this actor.
@@ -96,20 +96,20 @@ public class MultiThreadingTest extends BaseTest {
} catch (InterruptedException e) {
LOGGER.warn("Got exception while sleeping.", e);
}
RayObject<Integer> obj = echoActor1.call(Echo::echo, arg);
ObjectRef<Integer> obj = echoActor1.call(Echo::echo, arg);
Assert.assertEquals(arg, (int) obj.get());
}, 1);
// Test put and get.
runTestCaseInMultipleThreads(() -> {
int arg = random.nextInt();
RayObject<Integer> obj = Ray.put(arg);
ObjectRef<Integer> obj = Ray.put(arg);
Assert.assertEquals(arg, (int) obj.get());
}, LOOP_COUNTER);
TestUtils.warmUpCluster();
// Test wait for one object in multi threads.
RayObject<Integer> obj = Ray.call(MultiThreadingTest::echo, 100);
ObjectRef<Integer> obj = Ray.call(MultiThreadingTest::echo, 100);
runTestCaseInMultipleThreads(() -> {
WaitResult<Integer> result = Ray.wait(ImmutableList.of(obj), 1, 1000);
Assert.assertEquals(1, result.getReady().size());
@@ -125,23 +125,23 @@ public class MultiThreadingTest extends BaseTest {
public void testInWorker() {
// Single-process mode doesn't have real workers.
TestUtils.skipTestUnderSingleProcess();
RayObject<String> obj = Ray.call(MultiThreadingTest::testMultiThreading);
ObjectRef<String> obj = Ray.call(MultiThreadingTest::testMultiThreading);
Assert.assertEquals("ok", obj.get());
}
public void testGetCurrentActorId() {
TestUtils.skipTestUnderSingleProcess();
RayActor<ActorIdTester> actorIdTester = Ray.createActor(ActorIdTester::new);
ActorHandle<ActorIdTester> actorIdTester = Ray.createActor(ActorIdTester::new);
ActorId actorId = actorIdTester.call(ActorIdTester::getCurrentActorId).get();
Assert.assertEquals(actorId, actorIdTester.getId());
}
/**
* Call this method each time to avoid hitting the cache in {@link RayObject#get()}.
* Call this method each time to avoid hitting the cache in {@link ObjectRef#get()}.
*/
static Runnable[] generateRunnables() {
final RayObject<Integer> fooObject = Ray.put(1);
final RayActor<Echo> fooActor = Ray.createActor(Echo::new);
final ObjectRef<Integer> fooObject = Ray.put(1);
final ActorHandle<Echo> fooActor = Ray.createActor(Echo::new);
return new Runnable[]{
() -> Ray.put(1),
() -> Ray.get(fooObject.getId(), fooObject.getType()),
@@ -219,7 +219,7 @@ public class MultiThreadingTest extends BaseTest {
runnables[0].run();
}
// Return true here to make the Ray.call returns an RayObject.
// Return true here to make the Ray.call returns an ObjectRef.
return true;
}
@@ -303,7 +303,7 @@ public class MultiThreadingTest extends BaseTest {
}
public void testGetAsyncContextAndSetAsyncContextInWorker() {
RayObject<Boolean> obj = Ray.call(MultiThreadingTest::testGetAsyncContextAndSetAsyncContext);
ObjectRef<Boolean> obj = Ray.call(MultiThreadingTest::testGetAsyncContextAndSetAsyncContext);
Assert.assertTrue(obj.get());
}
java/test/src/main/java/io/ray/api/test/ObjectStoreTest.java
+4 -4
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.id.ObjectId;
import java.util.List;
import java.util.stream.Collectors;
@@ -17,19 +17,19 @@ public class ObjectStoreTest extends BaseTest {
@Test
public void testPutAndGet() {
{
RayObject<Integer> obj = Ray.put(1);
ObjectRef<Integer> obj = Ray.put(1);
Assert.assertEquals(1, (int) obj.get());
}
{
String s = null;
RayObject<String> obj = Ray.put(s);
ObjectRef<String> obj = Ray.put(s);
Assert.assertNull(obj.get());
}
{
List<List<String>> l = ImmutableList.of(ImmutableList.of("abc"));
RayObject<List<List<String>>> obj = Ray.put(l);
ObjectRef<List<List<String>>> obj = Ray.put(l);
Assert.assertEquals(obj.get(), l);
}
}
java/test/src/main/java/io/ray/api/test/PlasmaFreeTest.java
+3 -3
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.id.TaskId;
import java.util.Arrays;
@@ -17,7 +17,7 @@ public class PlasmaFreeTest extends BaseTest {
@Test
public void testDeleteObjects() {
RayObject<String> helloId = Ray.call(PlasmaFreeTest::hello);
ObjectRef<String> helloId = Ray.call(PlasmaFreeTest::hello);
String helloString = helloId.get();
Assert.assertEquals("hello", helloString);
Ray.internal().free(ImmutableList.of(helloId.getId()), true, false);
@@ -36,7 +36,7 @@ public class PlasmaFreeTest extends BaseTest {
@Test
public void testDeleteCreatingTasks() {
TestUtils.skipTestUnderSingleProcess();
RayObject<String> helloId = Ray.call(PlasmaFreeTest::hello);
ObjectRef<String> helloId = Ray.call(PlasmaFreeTest::hello);
Assert.assertEquals("hello", helloId.get());
Ray.internal().free(ImmutableList.of(helloId.getId()), true, true);
java/test/src/main/java/io/ray/api/test/RayMethodsTest.java
+7 -7
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.WaitResult;
import java.util.List;
import java.util.stream.Collectors;
@@ -16,15 +16,15 @@ public class RayMethodsTest extends BaseTest {
@Test
public void test() {
RayObject<Integer> i1Id = Ray.put(1);
RayObject<Double> f1Id = Ray.put(3.14);
RayObject<String> s1Id = Ray.put(String.valueOf("Hello "));
RayObject<String> s2Id = Ray.put(String.valueOf("World!"));
RayObject<Object> n1Id = Ray.put(null);
ObjectRef<Integer> i1Id = Ray.put(1);
ObjectRef<Double> f1Id = Ray.put(3.14);
ObjectRef<String> s1Id = Ray.put(String.valueOf("Hello "));
ObjectRef<String> s2Id = Ray.put(String.valueOf("World!"));
ObjectRef<Object> n1Id = Ray.put(null);
WaitResult<String> res = Ray.wait(ImmutableList.of(s1Id, s2Id), 2, 1000);
List<String> ss = res.getReady().stream().map(RayObject::get).collect(Collectors.toList());
List<String> ss = res.getReady().stream().map(ObjectRef::get).collect(Collectors.toList());
int i1 = i1Id.get();
double f1 = f1Id.get();
Object n1 = n1Id.get();
java/test/src/main/java/io/ray/api/test/RaySerializerTest.java
+4 -3
View File
@@ -1,7 +1,7 @@
package io.ray.api.test;
import io.ray.api.PyActorHandle;
import io.ray.api.Ray;
import io.ray.api.RayPyActor;
import io.ray.api.function.PyActorClass;
import io.ray.runtime.object.NativeRayObject;
import io.ray.runtime.object.ObjectSerializer;
@@ -12,9 +12,10 @@ public class RaySerializerTest extends BaseMultiLanguageTest {
@Test
public void testSerializePyActor() {
RayPyActor pyActor = Ray.createActor(new PyActorClass("test", "RaySerializerTest"));
PyActorHandle pyActor = Ray.createActor(
new PyActorClass("test", "RaySerializerTest"));
NativeRayObject nativeRayObject = ObjectSerializer.serialize(pyActor);
RayPyActor result = (RayPyActor) ObjectSerializer
PyActorHandle result = (PyActorHandle) ObjectSerializer
.deserialize(nativeRayObject, null, Object.class);
Assert.assertEquals(result.getId(), pyActor.getId());
Assert.assertEquals(result.getModuleName(), "test");
java/test/src/main/java/io/ray/api/test/RayletConfigTest.java
+2 -2
View File
@@ -1,7 +1,7 @@
package io.ray.api.test;
import io.ray.api.ActorHandle;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.TestUtils;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
@@ -32,7 +32,7 @@ public class RayletConfigTest extends BaseTest {
@Test
public void testRayletConfigPassThrough() {
RayActor<TestActor> actor = Ray.createActor(TestActor::new);
ActorHandle<TestActor> actor = Ray.createActor(TestActor::new);
String configValue = actor.call(TestActor::getConfigValue).get();
Assert.assertEquals(configValue, RAY_CONFIG_VALUE);
}
java/test/src/main/java/io/ray/api/test/RedisPasswordTest.java
+2 -2
View File
@@ -1,7 +1,7 @@
package io.ray.api.test;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
@@ -27,7 +27,7 @@ public class RedisPasswordTest extends BaseTest {
@Test
public void testRedisPassword() {
RayObject<String> obj = Ray.call(RedisPasswordTest::echo, "hello");
ObjectRef<String> obj = Ray.call(RedisPasswordTest::echo, "hello");
Assert.assertEquals("hello", obj.get());
}
java/test/src/main/java/io/ray/api/test/ResourcesManagementTest.java
+8 -8
View File
@@ -2,9 +2,9 @@ package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.WaitResult;
import io.ray.api.options.ActorCreationOptions;
@@ -48,7 +48,7 @@ public class ResourcesManagementTest extends BaseTest {
// This is a case that can satisfy required resources.
// The static resources for test are "CPU:4,RES-A:4".
RayObject<Integer> result1 = Ray.call(ResourcesManagementTest::echo, 100, callOptions1);
ObjectRef<Integer> result1 = Ray.call(ResourcesManagementTest::echo, 100, callOptions1);
Assert.assertEquals(100, (int) result1.get());
CallOptions callOptions2 =
@@ -56,7 +56,7 @@ public class ResourcesManagementTest extends BaseTest {
// This is a case that can't satisfy required resources.
// The static resources for test are "CPU:4,RES-A:4".
final RayObject<Integer> result2 = Ray.call(ResourcesManagementTest::echo, 200, callOptions2);
final ObjectRef<Integer> result2 = Ray.call(ResourcesManagementTest::echo, 200, callOptions2);
WaitResult<Integer> waitResult = Ray.wait(ImmutableList.of(result2), 1, 1000);
Assert.assertEquals(1, waitResult.getReady().size());
@@ -80,8 +80,8 @@ public class ResourcesManagementTest extends BaseTest {
.setResources(ImmutableMap.of("CPU", 2.0)).createActorCreationOptions();
// This is a case that can satisfy required resources.
// The static resources for test are "CPU:4,RES-A:4".
RayActor<Echo> echo1 = Ray.createActor(Echo::new, actorCreationOptions1);
final RayObject<Integer> result1 = echo1.call(Echo::echo, 100);
ActorHandle<Echo> echo1 = Ray.createActor(Echo::new, actorCreationOptions1);
final ObjectRef<Integer> result1 = echo1.call(Echo::echo, 100);
Assert.assertEquals(100, (int) result1.get());
// This is a case that can't satisfy required resources.
@@ -89,9 +89,9 @@ public class ResourcesManagementTest extends BaseTest {
ActorCreationOptions actorCreationOptions2 = new ActorCreationOptions.Builder()
.setResources(ImmutableMap.of("CPU", 8.0)).createActorCreationOptions();
RayActor<ResourcesManagementTest.Echo> echo2 =
ActorHandle<Echo> echo2 =
Ray.createActor(Echo::new, actorCreationOptions2);
final RayObject<Integer> result2 = echo2.call(Echo::echo, 100);
final ObjectRef<Integer> result2 = echo2.call(Echo::echo, 100);
WaitResult<Integer> waitResult = Ray.wait(ImmutableList.of(result2), 1, 1000);
Assert.assertEquals(0, waitResult.getReady().size());
java/test/src/main/java/io/ray/api/test/RuntimeContextTest.java
+2 -2
View File
@@ -1,7 +1,7 @@
package io.ray.api.test;
import io.ray.api.ActorHandle;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.id.ActorId;
import io.ray.api.id.JobId;
import java.nio.ByteBuffer;
@@ -60,7 +60,7 @@ public class RuntimeContextTest extends BaseTest {
@Test
public void testRuntimeContextInActor() {
RayActor<RuntimeContextTester> actor = Ray.createActor(RuntimeContextTester::new);
ActorHandle<RuntimeContextTester> actor = Ray.createActor(RuntimeContextTester::new);
Assert.assertEquals("ok",
actor.call(RuntimeContextTester::testRuntimeContext, actor.getId()).get());
}
java/test/src/main/java/io/ray/api/test/SingleProcessModeTest.java
+10 -10
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.id.ActorId;
import java.util.ArrayList;
@@ -31,18 +31,18 @@ public class SingleProcessModeTest extends BaseTest {
public void testActorTasksInOneThread() {
TestUtils.skipTestUnderClusterMode();
List<RayActor<MyActor>> actors = new ArrayList<>();
List<ActorHandle<MyActor>> actors = new ArrayList<>();
Map<ActorId, Long> actorThreadIds = new HashMap<>();
for (int i = 0; i < NUM_ACTOR_INSTANCE; ++i) {
RayActor<MyActor> actor = Ray.createActor(MyActor::new);
ActorHandle<MyActor> actor = Ray.createActor(MyActor::new);
actors.add(actor);
actorThreadIds.put(actor.getId(), actor.call(MyActor::getThreadId).get());
}
Map<ActorId, List<RayObject<Long>>> allResults = new HashMap<>();
Map<ActorId, List<ObjectRef<Long>>> allResults = new HashMap<>();
for (int i = 0; i < NUM_ACTOR_INSTANCE; ++i) {
final RayActor<MyActor> actor = actors.get(i);
List<RayObject<Long>> thisActorResult = new ArrayList<>();
final ActorHandle<MyActor> actor = actors.get(i);
List<ObjectRef<Long>> thisActorResult = new ArrayList<>();
for (int j = 0; j < TIMES_TO_CALL_PER_ACTOR; ++j) {
thisActorResult.add(actor.call(MyActor::getThreadId));
}
@@ -51,10 +51,10 @@ public class SingleProcessModeTest extends BaseTest {
// check result.
for (int i = 0; i < NUM_ACTOR_INSTANCE; ++i) {
final RayActor<MyActor> actor = actors.get(i);
final List<RayObject<Long>> thisActorResult = allResults.get(actor.getId());
final ActorHandle<MyActor> actor = actors.get(i);
final List<ObjectRef<Long>> thisActorResult = allResults.get(actor.getId());
// assert
for (RayObject<Long> threadId : thisActorResult) {
for (ObjectRef<Long> threadId : thisActorResult) {
Assert.assertEquals(threadId.get(), actorThreadIds.get(actor.getId()));
}
}
java/test/src/main/java/io/ray/api/test/StressTest.java
+9 -9
View File
@@ -1,9 +1,9 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.id.ObjectId;
import java.util.ArrayList;
@@ -38,7 +38,7 @@ public class StressTest extends BaseTest {
@Test
public void testDependency() {
TestUtils.skipTestUnderSingleProcess();
RayObject<Integer> x = Ray.call(StressTest::echo, 1);
ObjectRef<Integer> x = Ray.call(StressTest::echo, 1);
for (int i = 0; i < 1000; i++) {
x = Ray.call(StressTest::echo, x);
}
@@ -55,9 +55,9 @@ public class StressTest extends BaseTest {
public static class Worker {
private RayActor<Actor> actor;
private ActorHandle<Actor> actor;
public Worker(RayActor<Actor> actor) {
public Worker(ActorHandle<Actor> actor) {
this.actor = actor;
}
@@ -77,10 +77,10 @@ public class StressTest extends BaseTest {
@Test
public void testSubmittingManyTasksToOneActor() throws Exception {
TestUtils.skipTestUnderSingleProcess();
RayActor<Actor> actor = Ray.createActor(Actor::new);
ActorHandle<Actor> actor = Ray.createActor(Actor::new);
List<ObjectId> objectIds = new ArrayList<>();
for (int i = 0; i < 10; i++) {
RayActor<Worker> worker = Ray.createActor(Worker::new, actor);
ActorHandle<Worker> worker = Ray.createActor(Worker::new, actor);
objectIds.add(worker.call(Worker::ping, 100).getId());
}
@@ -93,12 +93,12 @@ public class StressTest extends BaseTest {
public void testPuttingAndGettingManyObjects() {
TestUtils.skipTestUnderSingleProcess();
Integer objectToPut = 1;
List<RayObject<Integer>> objects = new ArrayList<>();
List<ObjectRef<Integer>> objects = new ArrayList<>();
for (int i = 0; i < 100_000; i++) {
objects.add(Ray.put(objectToPut));
}
for (RayObject<Integer> object : objects) {
for (ObjectRef<Integer> object : objects) {
Assert.assertEquals(object.get(), objectToPut);
}
}
java/test/src/main/java/io/ray/api/test/WaitTest.java
+6 -6
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import com.google.common.collect.ImmutableList;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.WaitResult;
import java.util.ArrayList;
@@ -29,13 +29,13 @@ public class WaitTest extends BaseTest {
// Call a task in advance to warm up the cluster to avoid being too slow to start workers.
TestUtils.warmUpCluster();
RayObject<String> obj1 = Ray.call(WaitTest::hi);
RayObject<String> obj2 = Ray.call(WaitTest::delayedHi);
ObjectRef<String> obj1 = Ray.call(WaitTest::hi);
ObjectRef<String> obj2 = Ray.call(WaitTest::delayedHi);
List<RayObject<String>> waitList = ImmutableList.of(obj1, obj2);
List<ObjectRef<String>> waitList = ImmutableList.of(obj1, obj2);
WaitResult<String> waitResult = Ray.wait(waitList, 2, 2 * 1000);
List<RayObject<String>> readyList = waitResult.getReady();
List<ObjectRef<String>> readyList = waitResult.getReady();
Assert.assertEquals(1, waitResult.getReady().size());
Assert.assertEquals(1, waitResult.getUnready().size());
@@ -54,7 +54,7 @@ public class WaitTest extends BaseTest {
@Test
public void testWaitInWorker() {
RayObject<Object> res = Ray.call(WaitTest::waitInWorker);
ObjectRef<Object> res = Ray.call(WaitTest::waitInWorker);
res.get();
}
java/test/src/main/java/io/ray/api/test/WorkerJvmOptionsTest.java
+4 -4
View File
@@ -1,8 +1,8 @@
package io.ray.api.test;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
import io.ray.api.TestUtils;
import io.ray.api.options.ActorCreationOptions;
import org.testng.Assert;
@@ -24,8 +24,8 @@ public class WorkerJvmOptionsTest extends BaseTest {
// that raylet can correctly handle dynamic options with whitespaces.
.setJvmOptions(" -Dtest.suffix=suffix -Dtest.suffix1=suffix1 ")
.createActorCreationOptions();
RayActor<Echo> actor = Ray.createActor(Echo::new, options);
RayObject<String> obj = actor.call(Echo::getOptions);
ActorHandle<Echo> actor = Ray.createActor(Echo::new, options);
ObjectRef<String> obj = actor.call(Echo::getOptions);
Assert.assertEquals(obj.get(), "suffix");
}
}
java/tutorial/src/main/java/io/ray/exercise/Exercise01.java
+3 -3
View File
@@ -1,7 +1,7 @@
package io.ray.exercise;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import java.io.Serializable;
/**
@@ -29,8 +29,8 @@ public class Exercise01 implements Serializable {
// Use `Ray.init` to initialize the Ray runtime.
Ray.init();
// Use `Ray.call` to call a remote function.
RayObject<String> hello = Ray.call(Exercise01::sayHello);
RayObject<String> world = Ray.call(Exercise01::sayWorld);
ObjectRef<String> hello = Ray.call(Exercise01::sayHello);
ObjectRef<String> world = Ray.call(Exercise01::sayWorld);
System.out.println("First remote call result:" + hello.get());
System.out.println("Second remote call result:" + world.get());
} catch (Throwable t) {
java/tutorial/src/main/java/io/ray/exercise/Exercise02.java
+3 -3
View File
@@ -1,7 +1,7 @@
package io.ray.exercise;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
/**
* Execute remote functions in parallel with some dependencies.
@@ -28,8 +28,8 @@ public class Exercise02 {
}
public static String sayHelloWorld() {
RayObject<String> hello = Ray.call(Exercise02::sayHello);
RayObject<String> world = Ray.call(Exercise02::sayWorld);
ObjectRef<String> hello = Ray.call(Exercise02::sayHello);
ObjectRef<String> world = Ray.call(Exercise02::sayWorld);
// Pass unfinished results as the parameters to another remote function.
return Ray.call(Exercise02::merge, hello, world).get();
}
java/tutorial/src/main/java/io/ray/exercise/Exercise03.java
+2 -2
View File
@@ -1,7 +1,7 @@
package io.ray.exercise;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
/**
* Call a remote function from within another remote function.
@@ -14,7 +14,7 @@ public class Exercise03 {
public static String sayHelloWithWorld() {
String ret = "hello";
System.out.println(ret);
RayObject<String> world = Ray.call(Exercise03::sayWorld);
ObjectRef<String> world = Ray.call(Exercise03::sayWorld);
return ret + "," + world.get();
}
java/tutorial/src/main/java/io/ray/exercise/Exercise04.java
+2 -2
View File
@@ -1,8 +1,8 @@
package io.ray.exercise;
import com.google.common.collect.ImmutableList;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayObject;
import io.ray.api.WaitResult;
import java.util.List;
@@ -38,7 +38,7 @@ public class Exercise04 {
public static void main(String[] args) throws Exception {
try {
Ray.init();
List<RayObject<String>> waitList = ImmutableList.of(
List<ObjectRef<String>> waitList = ImmutableList.of(
Ray.call(Exercise04::f1),
Ray.call(Exercise04::f2),
Ray.call(Exercise04::f3)
java/tutorial/src/main/java/io/ray/exercise/Exercise05.java
+5 -5
View File
@@ -1,8 +1,8 @@
package io.ray.exercise;
import io.ray.api.ActorHandle;
import io.ray.api.ObjectRef;
import io.ray.api.Ray;
import io.ray.api.RayActor;
import io.ray.api.RayObject;
/**
* Show usage of actors.
@@ -13,11 +13,11 @@ public class Exercise05 {
try {
Ray.init();
// `Ray.createActor` creates an actor instance.
RayActor<Adder> adder = Ray.createActor(Adder::new, 0);
ActorHandle<Adder> adder = Ray.createActor(Adder::new, 0);
// Use `Ray.call(actor, parameters)` to call an actor method.
RayObject<Integer> result1 = adder.call(Adder::add, 1);
ObjectRef<Integer> result1 = adder.call(Adder::add, 1);
System.out.println(result1.get());
RayObject<Integer> result2 = adder.call(Adder::add, 10);
ObjectRef<Integer> result2 = adder.call(Adder::add, 10);
System.out.println(result2.get());
} catch (Throwable t) {
t.printStackTrace();