hiro/ray
1
0
Fork 0
mirror of https://github.com/vale981/ray synced 2025-03-05 18:11:42 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

[Java] New Java actor API (#7414)

Browse source
This commit is contained in:
Hao Chen 2020-03-04 22:39:23 +08:00 • committed by GitHub
parent 4198db5038
commit fe7820fec9
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
46 changed files with 1576 additions and 753 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

654
java/api/src/main/java/org/ray/api/ActorCall.java Normal file
View file

@ -0,0 +1,654 @@
// Generated by `RayCallGenerator.java`. DO NOT EDIT.
package org.ray.api;
import org.ray.api.function.RayFunc1;
import org.ray.api.function.RayFunc2;
import org.ray.api.function.RayFunc3;
import org.ray.api.function.RayFunc4;
import org.ray.api.function.RayFunc5;
import org.ray.api.function.RayFunc6;
import org.ray.api.function.RayFuncVoid1;
import org.ray.api.function.RayFuncVoid2;
import org.ray.api.function.RayFuncVoid3;
import org.ray.api.function.RayFuncVoid4;
import org.ray.api.function.RayFuncVoid5;
import org.ray.api.function.RayFuncVoid6;
/**
* This class provides type-safe interfaces for remote actor calls.
**/
@SuppressWarnings({"rawtypes", "unchecked"})
interface ActorCall<A> {
default <R> RayObject<R> call(RayFunc1<A, R> f) {
Object[] args = new Object[]{};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default void call(RayFuncVoid1<A> f) {
Object[] args = new Object[]{};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, T0 t0) {
Object[] args = new Object[]{t0};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, RayObject<T0> t0) {
Object[] args = new Object[]{t0};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0> void call(RayFuncVoid2<A, T0> f, T0 t0) {
Object[] args = new Object[]{t0};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0> void call(RayFuncVoid2<A, T0> f, RayObject<T0> t0) {
Object[] args = new Object[]{t0};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayObject<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayObject<T0> t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayObject<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayObject<T0> t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, R> RayObject<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(f, (RayActor) this, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().callActor(f, (RayActor) this, 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(f, (RayActor) this, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().callActor(f, (RayActor) this, 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(f, (RayActor) this, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, args);
}
default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().callActor(f, (RayActor) this, 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(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, 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) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().callActor(f, (RayActor) this, args);
}
}

26
java/api/src/main/java/org/ray/api/RayActor.java
View file

@ -3,14 +3,34 @@ package org.ray.api;
import org.ray.api.id.ActorId;
/**
* A handle to an actor.
* A handle to an actor. <p>
*
* @param <T> The type of the concrete actor class.
* A handle can be used to invoke a remote actor method, with the {@code "call"} method. For
* example:
* <pre> {@code
* class MyActor {
* public int echo(int x) {
* return x;
* }
* }
* // Create an actor, and get a handle.
* RayActor<MyActor> myActor = Ray.createActor(RayActor::new);
* // Call the `echo` method remotely.
* RayObject<Integer> result = myActor.call(MyActor::echo, 1);
* // Get the result of the remote `echo` method.
* Assert.assertEqual(result.get(), 1);
* }</pre>
*
* Note, the {@code "call"} method is defined in {@link ActorCall} interface, with multiple
* overloaded versions.
*
* @param <A> The type of the concrete actor class.
*/
public interface RayActor<T> {
public interface RayActor<A> extends ActorCall<A> {
/**
* @return The id of this actor.
*/
ActorId getId();
}

1271
java/api/src/main/java/org/ray/api/RayCall.java
View file

File diff suppressed because it is too large Load diff

18
java/api/src/main/java/org/ray/api/annotation/RayRemote.java
View file

@ -1,18 +0,0 @@
package org.ray.api.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Defines a remote function (when used on a method),
* or an actor (when used on a class).
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface RayRemote {
}

2
java/api/src/main/java/org/ray/api/runtime/RayRuntime.java
View file

@ -101,7 +101,7 @@ public interface RayRuntime {
* @param args The arguments of the remote function.
* @return The result object.
*/
RayObject call(RayFunc func, RayActor<?> actor, Object[] args);
RayObject callActor(RayFunc func, RayActor<?> actor, Object[] args);
/**
* Create an actor on a remote node.

1
java/checkstyle-suppressions.xml
View file

@ -11,6 +11,7 @@
<suppress checks="NoFinalizer" files="NativeRayActor.java"/>
<suppress checks="AbbreviationAsWordInNameCheck" files="RayParameters.java"/>
<suppress checks=".*" files="RayCall.java"/>
<suppress checks=".*" files="ActorCall.java"/>
<!-- suppress check for flatbuffer-generated files. -->
<suppress checks=".*" files="org[\\/]ray[\\/]runtime[\\/]generated[\\/]" />
</suppressions>

2
java/runtime/src/main/java/org/ray/runtime/AbstractRayRuntime.java
View file

@ -98,7 +98,7 @@ public abstract class AbstractRayRuntime implements RayRuntime {
}
@Override
public RayObject call(RayFunc func, RayActor<?> actor, Object[] args) {
public RayObject callActor(RayFunc func, RayActor<?> actor, Object[] args) {
FunctionDescriptor functionDescriptor =
functionManager.getFunction(workerContext.getCurrentJobId(), func)
.functionDescriptor;

4
java/runtime/src/main/java/org/ray/runtime/RayMultiWorkerNativeRuntime.java
View file

@ -149,8 +149,8 @@ public class RayMultiWorkerNativeRuntime implements RayRuntime {
}
@Override
public RayObject call(RayFunc func, RayActor<?> actor, Object[] args) {
return getCurrentRuntime().call(func, actor, args);
public RayObject callActor(RayFunc func, RayActor<?> actor, Object[] args) {
return getCurrentRuntime().callActor(func, actor, args);
}
@Override

16
java/runtime/src/main/java/org/ray/runtime/functionmanager/RayFunction.java
View file

@ -3,7 +3,6 @@ package org.ray.runtime.functionmanager;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Method;
import org.ray.api.annotation.RayRemote;
/**
* Represents a Ray function (either a Method or a Constructor in Java) and its metadata.
@ -57,21 +56,6 @@ public class RayFunction {
return functionDescriptor;
}
public RayRemote getRayRemoteAnnotation() {
RayRemote rayRemote;
// If this method is a constructor, the task of it should be a actorCreationTask.
// And the annotation of actorCreationTask should inherit from class.
// Otherwise, it's a normal method, and it shouldn't inherit annotation from class.
if (isConstructor()) {
rayRemote = executable.getDeclaringClass().getAnnotation(RayRemote.class);
} else {
rayRemote = executable.getAnnotation(RayRemote.class);
}
return rayRemote;
}
/**
* @return Whether this function has a return value.
*/

99
java/runtime/src/main/java/org/ray/runtime/util/generator/RayCallGenerator.java
View file

@ -8,18 +8,18 @@ import java.util.List;
import org.apache.commons.io.FileUtils;
/**
* A util class that generates `RayCall.java`, which provides type-safe interfaces for `Ray.call`
* and `Ray.createActor`.
* A util class that generates `RayCall.java` and `ActorCall.java`, which provide type-safe
* interfaces for `Ray.call`, `Ray.createActor` and `actor.call`.
*/
public class RayCallGenerator extends BaseGenerator {
/**
* @return Whole file content of `RayCall.java`.
*/
private String build() {
private String generateRayCallDotJava() {
sb = new StringBuilder();
newLine("// generated automatically, do not modify.");
newLine("// Generated by `RayCallGenerator.java`. DO NOT EDIT.");
newLine("");
newLine("package org.ray.api;");
newLine("");
@ -48,13 +48,6 @@ public class RayCallGenerator extends BaseGenerator {
buildCalls(i, false, false, false, true);
}
newLine(1, "// ===========================================");
newLine(1, "// Methods for remote actor method invocation.");
newLine(1, "// ===========================================");
for (int i = 0; i <= MAX_PARAMETERS - 1; i++) {
buildCalls(i, true, false, true, false);
buildCalls(i, true, false, false, false);
}
newLine(1, "// ===========================");
newLine(1, "// Methods for actor creation.");
newLine(1, "// ===========================");
@ -70,6 +63,7 @@ public class RayCallGenerator extends BaseGenerator {
buildPyCalls(i, false, false, false);
buildPyCalls(i, false, false, true);
}
// TODO(hchen): move Python actor call API to `RayPyActor` class.
for (int i = 0; i <= MAX_PARAMETERS - 1; i++) {
buildPyCalls(i, true, false, false);
}
@ -82,30 +76,61 @@ public class RayCallGenerator extends BaseGenerator {
}
/**
* Build the `Ray.call` or `Ray.createActor` methods with the given number of parameters.
* @return Whole file content of `ActorCall.java`.
*/
private String generateActorCallDotJava() {
sb = new StringBuilder();
newLine("// Generated by `RayCallGenerator.java`. DO NOT EDIT.");
newLine("");
newLine("package org.ray.api;");
newLine("");
for (int i = 1; i <= MAX_PARAMETERS; i++) {
newLine("import org.ray.api.function.RayFunc" + i + ";");
}
for (int i = 1; i <= MAX_PARAMETERS; i++) {
newLine("import org.ray.api.function.RayFuncVoid" + i + ";");
}
newLine("");
newLine("/**");
newLine(" * This class provides type-safe interfaces for remote actor calls.");
newLine(" **/");
newLine("@SuppressWarnings({\"rawtypes\", \"unchecked\"})");
newLine("interface ActorCall<A> {");
newLine("");
for (int i = 0; i <= MAX_PARAMETERS - 1; i++) {
buildCalls(i, true, false, true, false);
buildCalls(i, true, false, false, false);
}
newLine("}");
return sb.toString();
}
/**
* Build `Ray.call`, `Ray.createActor` and `actor.call` methods with
* the given number of parameters.
*
* @param numParameters the number of parameters
* @param forActor build actor api when true, otherwise build task api.
* @param hasReturn if true, build api for functions with return.
* @param forActorCreation build `Ray.createActor` when true, otherwise build `Ray.call`.
* @param forActor Build `actor.call` when true, otherwise build `Ray.call`.
* @param hasReturn if true, Build api for functions with return.
* @param forActorCreation Build `Ray.createActor` when true, otherwise build `Ray.call`.
*/
private void buildCalls(int numParameters, boolean forActor,
boolean forActorCreation, boolean hasReturn, boolean hasOptionsParam) {
// Template of the generated function:
// public static [genericTypes] [returnType] [callFunc]([argsDeclaration]) {
// [modifiers] [genericTypes] [returnType] [callFunc]([argsDeclaration]) {
// Objects[] args = new Object[]{[args]};
// return Ray.internal().[callFunc](f[, actor], args[, options]);
// return Ray.internal().[callFunc](f[, getThis()], args[, options]);
// }
String modifiers = forActor ? "default" : "public static";
// 1) Construct the `genericTypes` part, e.g. `<T0, T1, T2, R>`.
String genericTypes = "";
for (int i = 0; i < numParameters; i++) {
genericTypes += "T" + i + ", ";
}
if (forActor) {
// Actor generic type.
genericTypes = "A, " + genericTypes;
}
// Return generic type.
if (forActorCreation) {
genericTypes += "A, ";
@ -129,15 +154,21 @@ public class RayCallGenerator extends BaseGenerator {
}
// 3) Construct the `argsDeclaration` part.
String rayFuncGenericTypes = genericTypes;
if (forActor) {
if (rayFuncGenericTypes.isEmpty()) {
rayFuncGenericTypes = "<A>";
} else {
rayFuncGenericTypes = rayFuncGenericTypes.replace("<", "<A, ");
}
}
String argsDeclarationPrefix = String.format("RayFunc%s%d%s f, ",
hasReturn ? "" : "Void",
!forActor ? numParameters : numParameters + 1,
genericTypes);
if (forActor) {
argsDeclarationPrefix += "RayActor<A> actor, ";
}
rayFuncGenericTypes);
String callFunc = forActorCreation ? "createActor" : "call";
String internalCallFunc = forActorCreation ? "createActor" : forActor ? "callActor" : "call";
// Enumerate all combinations of the parameters.
for (String param : generateParameters(numParameters)) {
@ -150,7 +181,7 @@ public class RayCallGenerator extends BaseGenerator {
argsDeclaration = argsDeclaration.substring(0, argsDeclaration.length() - 2);
// Print the first line (method signature).
newLine(1, String.format(
"public static%s %s %s(%s) {",
"%s%s %s %s(%s) {", modifiers,
genericTypes.isEmpty() ? "" : " " + genericTypes, returnType, callFunc, argsDeclaration
));
@ -169,22 +200,23 @@ public class RayCallGenerator extends BaseGenerator {
// 5) Construct the third line.
String callFuncArgs = "f, ";
if (forActor) {
callFuncArgs += "actor, ";
callFuncArgs += "(RayActor) this, ";
}
callFuncArgs += "args, ";
callFuncArgs += forActor ? "" : hasOptionsParam ? "options, " : "null, ";
callFuncArgs = callFuncArgs.substring(0, callFuncArgs.length() - 2);
newLine(2, String.format("%sRay.internal().%s(%s);",
hasReturn ? "return " : "", callFunc, callFuncArgs));
hasReturn ? "return " : "", internalCallFunc, callFuncArgs));
newLine(1, "}");
newLine("");
}
}
/**
* Build the `Ray.callPy` or `Ray.createPyActor` methods.
*
* @param forActor build actor api when true, otherwise build task api.
* @param forActorCreation build `Ray.createPyActor` when true, otherwise build `Ray.callPy`.
* @param forActor Build actor api when true, otherwise build task api.
* @param forActorCreation Build `Ray.createPyActor` when true, otherwise build `Ray.callPy`.
*/
private void buildPyCalls(int numParameters, boolean forActor,
boolean forActorCreation, boolean hasOptionsParam) {
@ -269,7 +301,12 @@ public class RayCallGenerator extends BaseGenerator {
public static void main(String[] args) throws IOException {
String path = System.getProperty("user.dir")
+ "/api/src/main/java/org/ray/api/RayCall.java";
FileUtils.write(new File(path), new RayCallGenerator().build(), Charset.defaultCharset());
FileUtils.write(new File(path), new RayCallGenerator().generateRayCallDotJava(),
Charset.defaultCharset());
path = System.getProperty("user.dir")
+ "/api/src/main/java/org/ray/api/ActorCall.java";
FileUtils.write(new File(path), new RayCallGenerator().generateActorCallDotJava(),
Charset.defaultCharset());
}
}

9
java/runtime/src/test/java/org/ray/runtime/functionmanager/FunctionManagerTest.java
View file

@ -9,7 +9,6 @@ import javax.tools.ToolProvider;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.ray.api.annotation.RayRemote;
import org.ray.api.function.RayFunc0;
import org.ray.api.function.RayFunc1;
import org.ray.api.id.JobId;
@ -23,12 +22,10 @@ import org.testng.annotations.Test;
*/
public class FunctionManagerTest {
@RayRemote
public static Object foo() {
return null;
}
@RayRemote
public static class Bar {
public Bar() {
@ -81,19 +78,16 @@ public class FunctionManagerTest {
RayFunction func = functionManager.getFunction(JobId.NIL, fooFunc);
Assert.assertFalse(func.isConstructor());
Assert.assertEquals(func.getFunctionDescriptor(), fooDescriptor);
Assert.assertNotNull(func.getRayRemoteAnnotation());
// Test actor method
func = functionManager.getFunction(JobId.NIL, barFunc);
Assert.assertFalse(func.isConstructor());
Assert.assertEquals(func.getFunctionDescriptor(), barDescriptor);
Assert.assertNull(func.getRayRemoteAnnotation());
// Test actor constructor
func = functionManager.getFunction(JobId.NIL, barConstructor);
Assert.assertTrue(func.isConstructor());
Assert.assertEquals(func.getFunctionDescriptor(), barConstructorDescriptor);
Assert.assertNotNull(func.getRayRemoteAnnotation());
}
@Test
@ -103,19 +97,16 @@ public class FunctionManagerTest {
RayFunction func = functionManager.getFunction(JobId.NIL, fooDescriptor);
Assert.assertFalse(func.isConstructor());
Assert.assertEquals(func.getFunctionDescriptor(), fooDescriptor);
Assert.assertNotNull(func.getRayRemoteAnnotation());
// Test actor method
func = functionManager.getFunction(JobId.NIL, barDescriptor);
Assert.assertFalse(func.isConstructor());
Assert.assertEquals(func.getFunctionDescriptor(), barDescriptor);
Assert.assertNull(func.getRayRemoteAnnotation());
// Test actor constructor
func = functionManager.getFunction(JobId.NIL, barConstructorDescriptor);
Assert.assertTrue(func.isConstructor());
Assert.assertEquals(func.getFunctionDescriptor(), barConstructorDescriptor);
Assert.assertNotNull(func.getRayRemoteAnnotation());
// Test raise overload exception
Assert.expectThrows(RuntimeException.class, () -> {

2
java/test/src/main/java/org/ray/api/TestUtils.java
View file

@ -3,7 +3,6 @@ package org.ray.api;
import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.function.Supplier;
import org.ray.api.annotation.RayRemote;
import org.ray.api.options.ActorCreationOptions;
import org.ray.api.runtime.RayRuntime;
import org.ray.runtime.AbstractRayRuntime;
@ -79,7 +78,6 @@ public class TestUtils {
return false;
}
@RayRemote
private static String hi() {
return "hi";
}

4
java/test/src/main/java/org/ray/api/benchmark/ActorPressTest.java
View file

@ -3,7 +3,6 @@ package org.ray.api.benchmark;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.testng.annotations.Test;
public class ActorPressTest extends RayBenchmarkTest {
@ -45,7 +44,7 @@ public class ActorPressTest extends RayBenchmarkTest {
@Override
public RayObject<RemoteResult<Integer>> rayCall(RayActor rayActor) {
return Ray.call(Adder::add, (RayActor<Adder>) rayActor, 10);
return ((RayActor<Adder>) rayActor).call(Adder::add, 10);
}
@Override
@ -53,7 +52,6 @@ public class ActorPressTest extends RayBenchmarkTest {
return true;
}
@RayRemote
public static class Adder {
private Integer sum = 0;

2
java/test/src/main/java/org/ray/api/benchmark/MaxPressureTest.java
View file

@ -3,7 +3,6 @@ package org.ray.api.benchmark;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.testng.annotations.Test;
public class MaxPressureTest extends RayBenchmarkTest {
@ -12,7 +11,6 @@ public class MaxPressureTest extends RayBenchmarkTest {
public static final int totalNum = 10;
private static final long serialVersionUID = -1684518885171395952L;
@RayRemote
public static RemoteResult<Integer> currentTime() {
RemoteResult<Integer> remoteResult = new RemoteResult<>();
remoteResult.setFinishTime(System.nanoTime());

2
java/test/src/main/java/org/ray/api/benchmark/RateLimiterPressureTest.java
View file

@ -3,7 +3,6 @@ package org.ray.api.benchmark;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.testng.annotations.Test;
public class RateLimiterPressureTest extends RayBenchmarkTest {
@ -13,7 +12,6 @@ public class RateLimiterPressureTest extends RayBenchmarkTest {
public static final int duration = 10;
private static final long serialVersionUID = 6616958120966144235L;
@RayRemote
public static RemoteResult<Integer> currentTime() {
RemoteResult<Integer> remoteResult = new RemoteResult<>();
remoteResult.setFinishTime(System.nanoTime());

2
java/test/src/main/java/org/ray/api/benchmark/RayBenchmarkTest.java
View file

@ -9,7 +9,6 @@ import java.util.List;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.ray.api.function.RayFunc1;
import org.ray.api.test.BaseTest;
import org.slf4j.Logger;
@ -23,7 +22,6 @@ public abstract class RayBenchmarkTest<T> extends BaseTest implements Serializab
public static final DecimalFormat df = new DecimalFormat("00.00");
private static final long serialVersionUID = 416045641835782523L;
@RayRemote
private static List<Long> singleClient(PressureTestParameter pressureTestParameter) {
try {

2
java/test/src/main/java/org/ray/api/benchmark/SingleLatencyTest.java
View file

@ -3,7 +3,6 @@ package org.ray.api.benchmark;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.testng.annotations.Test;
public class SingleLatencyTest extends RayBenchmarkTest {
@ -11,7 +10,6 @@ public class SingleLatencyTest extends RayBenchmarkTest {
public static final int totalNum = 10;
private static final long serialVersionUID = 3559601273941694468L;
@RayRemote
public static RemoteResult<Integer> doFunc() {
RemoteResult<Integer> remoteResult = new RemoteResult<>();
remoteResult.setResult(1);

8
java/test/src/main/java/org/ray/api/test/ActorConcurrentCallTest.java
View file

@ -7,7 +7,6 @@ import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.annotation.RayRemote;
import org.ray.api.options.ActorCreationOptions;
import org.testng.Assert;
import org.testng.annotations.Test;
@ -16,7 +15,6 @@ import org.testng.annotations.Test;
@Test
public class ActorConcurrentCallTest extends BaseTest {
@RayRemote
public static class ConcurrentActor {
private final CountDownLatch countDownLatch = new CountDownLatch(3);
@ -38,9 +36,9 @@ public class ActorConcurrentCallTest extends BaseTest {
.setMaxConcurrency(3)
.createActorCreationOptions();
RayActor<ConcurrentActor> actor = Ray.createActor(ConcurrentActor::new, op);
RayObject<String> obj1 = Ray.call(ConcurrentActor::countDown, actor);
RayObject<String> obj2 = Ray.call(ConcurrentActor::countDown, actor);
RayObject<String> obj3 = Ray.call(ConcurrentActor::countDown, actor);
RayObject<String> obj1 = actor.call(ConcurrentActor::countDown);
RayObject<String> obj2 = actor.call(ConcurrentActor::countDown);
RayObject<String> obj3 = actor.call(ConcurrentActor::countDown);
List<Integer> expectedResult = ImmutableList.of(1, 2, 3);
Assert.assertEquals(obj1.get(), "ok");

26
java/test/src/main/java/org/ray/api/test/ActorReconstructionTest.java
View file

@ -9,7 +9,6 @@ import org.ray.api.Checkpointable;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.TestUtils;
import org.ray.api.annotation.RayRemote;
import org.ray.api.exception.RayActorException;
import org.ray.api.id.ActorId;
import org.ray.api.id.UniqueId;
@ -20,7 +19,6 @@ import org.testng.annotations.Test;
@Test
public class ActorReconstructionTest extends BaseTest {
@RayRemote()
public static class Counter {
protected int value = 0;
@ -52,31 +50,31 @@ public class ActorReconstructionTest extends BaseTest {
RayActor<Counter> actor = Ray.createActor(Counter::new, options);
// Call increase 3 times.
for (int i = 0; i < 3; i++) {
Ray.call(Counter::increase, actor).get();
actor.call(Counter::increase).get();
}
Assert.assertFalse(Ray.call(Counter::wasCurrentActorReconstructed, actor).get());
Assert.assertFalse(actor.call(Counter::wasCurrentActorReconstructed).get());
// Kill the actor process.
int pid = Ray.call(Counter::getPid, actor).get();
int pid = actor.call(Counter::getPid).get();
Runtime.getRuntime().exec("kill -9 " + pid);
// Wait for the actor to be killed.
TimeUnit.SECONDS.sleep(1);
// Try calling increase on this actor again and check the value is now 4.
int value = Ray.call(Counter::increase, actor).get();
int value = actor.call(Counter::increase).get();
Assert.assertEquals(value, options.useDirectCall ? 1 : 4);
Assert.assertTrue(Ray.call(Counter::wasCurrentActorReconstructed, actor).get());
Assert.assertTrue(actor.call(Counter::wasCurrentActorReconstructed).get());
// Kill the actor process again.
pid = Ray.call(Counter::getPid, actor).get();
pid = actor.call(Counter::getPid).get();
Runtime.getRuntime().exec("kill -9 " + pid);
TimeUnit.SECONDS.sleep(1);
// Try calling increase on this actor again and this should fail.
try {
Ray.call(Counter::increase, actor).get();
actor.call(Counter::increase).get();
Assert.fail("The above task didn't fail.");
} catch (RayActorException e) {
// We should receive a RayActorException because the actor is dead.
@ -132,20 +130,20 @@ public class ActorReconstructionTest extends BaseTest {
RayActor<CheckpointableCounter> actor = Ray.createActor(CheckpointableCounter::new, options);
// Call increase 3 times.
for (int i = 0; i < 3; i++) {
Ray.call(CheckpointableCounter::increase, actor).get();
actor.call(CheckpointableCounter::increase).get();
}
// Assert that the actor wasn't resumed from a checkpoint.
Assert.assertFalse(Ray.call(CheckpointableCounter::wasResumedFromCheckpoint, actor).get());
int pid = Ray.call(CheckpointableCounter::getPid, actor).get();
Assert.assertFalse(actor.call(CheckpointableCounter::wasResumedFromCheckpoint).get());
int pid = actor.call(CheckpointableCounter::getPid).get();
Runtime.getRuntime().exec("kill -9 " + pid);
// Wait for the actor to be killed.
TimeUnit.SECONDS.sleep(1);
// Try calling increase on this actor again and check the value is now 4.
int value = Ray.call(CheckpointableCounter::increase, actor).get();
int value = actor.call(CheckpointableCounter::increase).get();
Assert.assertEquals(value, 4);
// Assert that the actor was resumed from a checkpoint.
Assert.assertTrue(Ray.call(CheckpointableCounter::wasResumedFromCheckpoint, actor).get());
Assert.assertTrue(actor.call(CheckpointableCounter::wasResumedFromCheckpoint).get());
}
}

29
java/test/src/main/java/org/ray/api/test/ActorTest.java
View file

@ -10,8 +10,8 @@ import org.ray.api.RayObject;
import org.ray.api.RayPyActor;
import org.ray.api.TestUtils;
import org.ray.api.TestUtils.LargeObject;
import org.ray.api.annotation.RayRemote;
import org.ray.api.exception.UnreconstructableException;
import org.ray.api.id.ActorId;
import org.ray.api.id.UniqueId;
import org.testng.Assert;
import org.testng.annotations.Test;
@ -19,7 +19,6 @@ import org.testng.annotations.Test;
@Test
public class ActorTest extends BaseTest {
@RayRemote
public static class Counter {
private int value;
@ -50,13 +49,13 @@ public class ActorTest extends BaseTest {
public void testCreateAndCallActor() {
// Test creating an actor from a constructor
RayActor<Counter> actor = Ray.createActor(Counter::new, 1);
Assert.assertNotEquals(actor.getId(), UniqueId.NIL);
Assert.assertNotEquals(actor.getId(), ActorId.NIL);
// A java actor is not a python actor
Assert.assertFalse(actor instanceof RayPyActor);
// Test calling an actor
Assert.assertEquals(Integer.valueOf(1), Ray.call(Counter::getValue, actor).get());
Ray.call(Counter::increase, actor, 1);
Assert.assertEquals(Integer.valueOf(3), Ray.call(Counter::increaseAndGet, actor, 1).get());
Assert.assertEquals(Integer.valueOf(1), actor.call(Counter::getValue).get());
actor.call(Counter::increase, 1);
Assert.assertEquals(Integer.valueOf(3), actor.call(Counter::increaseAndGet, 1).get());
}
/**
@ -71,7 +70,7 @@ public class ActorTest extends BaseTest {
*/
public void testGetDirectObjectTwice() {
RayActor<Counter> actor = Ray.createActor(Counter::new, 1);
RayObject<Integer> result = Ray.call(Counter::getValue, actor);
RayObject<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.
@ -82,10 +81,9 @@ public class ActorTest extends BaseTest {
RayActor<Counter> actor = Ray.createActor(Counter::new, 1);
LargeObject largeObject = new LargeObject();
Assert.assertEquals(Integer.valueOf(largeObject.data.length + 1),
Ray.call(Counter::accessLargeObject, actor, largeObject).get());
actor.call(Counter::accessLargeObject, largeObject).get());
}
@RayRemote
static Counter factory(int initValue) {
return new Counter(initValue);
}
@ -95,24 +93,21 @@ public class ActorTest extends BaseTest {
RayActor<Counter> actor = Ray.createActor(ActorTest::factory, 1);
Assert.assertNotEquals(actor.getId(), UniqueId.NIL);
// Test calling an actor
Assert.assertEquals(Integer.valueOf(1), Ray.call(Counter::getValue, actor).get());
Assert.assertEquals(Integer.valueOf(1), actor.call(Counter::getValue).get());
}
@RayRemote
static int testActorAsFirstParameter(RayActor<Counter> actor, int delta) {
RayObject<Integer> res = Ray.call(Counter::increaseAndGet, actor, delta);
RayObject<Integer> res = actor.call(Counter::increaseAndGet, delta);
return res.get();
}
@RayRemote
static int testActorAsSecondParameter(int delta, RayActor<Counter> actor) {
RayObject<Integer> res = Ray.call(Counter::increaseAndGet, actor, delta);
RayObject<Integer> res = actor.call(Counter::increaseAndGet, delta);
return res.get();
}
@RayRemote
static int testActorAsFieldOfParameter(List<RayActor<Counter>> actor, int delta) {
RayObject<Integer> res = Ray.call(Counter::increaseAndGet, actor.get(0), delta);
RayObject<Integer> res = actor.get(0).call(Counter::increaseAndGet, delta);
return res.get();
}
@ -134,7 +129,7 @@ public class ActorTest extends BaseTest {
TestUtils.skipTestIfDirectActorCallEnabled();
RayActor<Counter> counter = Ray.createActor(Counter::new, 100);
// Call an actor method.
RayObject value = Ray.call(Counter::getValue, counter);
RayObject 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);

2
java/test/src/main/java/org/ray/api/test/CrossLanguageInvocationTest.java
View file

@ -12,7 +12,6 @@ import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.RayPyActor;
import org.ray.api.TestUtils;
import org.ray.api.annotation.RayRemote;
import org.ray.runtime.actor.NativeRayActor;
import org.ray.runtime.actor.NativeRayPyActor;
import org.slf4j.Logger;
@ -117,7 +116,6 @@ public class CrossLanguageInvocationTest extends BaseMultiLanguageTest {
return (byte[])res.get();
}
@RayRemote // Python can create java actors without @RayRemote
public static class TestActor {
public TestActor(byte[] v) {
value = v;

2
java/test/src/main/java/org/ray/api/test/DynamicResourceTest.java
View file

@ -7,7 +7,6 @@ import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.WaitResult;
import org.ray.api.annotation.RayRemote;
import org.ray.api.options.CallOptions;
import org.ray.api.runtimecontext.NodeInfo;
import org.testng.Assert;
@ -15,7 +14,6 @@ import org.testng.annotations.Test;
public class DynamicResourceTest extends BaseTest {
@RayRemote
public static String sayHi() {
return "hi";
}

8
java/test/src/main/java/org/ray/api/test/FailureTest.java
View file

@ -95,14 +95,14 @@ public class FailureTest extends BaseTest {
public void testActorCreationFailure() {
TestUtils.skipTestUnderSingleProcess();
RayActor<BadActor> actor = Ray.createActor(BadActor::new, true);
assertTaskFailedWithRayTaskException(Ray.call(BadActor::badMethod, actor));
assertTaskFailedWithRayTaskException(actor.call(BadActor::badMethod));
}
@Test
public void testActorTaskFailure() {
TestUtils.skipTestUnderSingleProcess();
RayActor<BadActor> actor = Ray.createActor(BadActor::new, false);
assertTaskFailedWithRayTaskException(Ray.call(BadActor::badMethod, actor));
assertTaskFailedWithRayTaskException(actor.call(BadActor::badMethod));
}
@Test
@ -125,14 +125,14 @@ public class FailureTest extends BaseTest {
TestUtils.skipTestIfDirectActorCallEnabled();
RayActor<BadActor> actor = Ray.createActor(BadActor::new, false);
try {
Ray.call(BadActor::badMethod2, actor).get();
actor.call(BadActor::badMethod2).get();
Assert.fail("This line shouldn't be reached.");
} catch (RayActorException e) {
// When the actor process dies while executing a task, we should receive an
// RayActorException.
}
try {
Ray.call(BadActor::badMethod, actor).get();
actor.call(BadActor::badMethod).get();
Assert.fail("This line shouldn't be reached.");
} catch (RayActorException e) {
// When a actor task is submitted to a dead actor, we should also receive an

4
java/test/src/main/java/org/ray/api/test/HelloWorldTest.java
View file

@ -2,7 +2,6 @@ package org.ray.api.test;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.testng.Assert;
import org.testng.annotations.Test;
@ -11,17 +10,14 @@ import org.testng.annotations.Test;
*/
public class HelloWorldTest extends BaseTest {
@RayRemote
private static String hello() {
return "hello";
}
@RayRemote
private static String world() {
return "world!";
}
@RayRemote
private static String merge(String hello, String world) {
return hello + "," + world;
}

6
java/test/src/main/java/org/ray/api/test/KillActorTest.java
View file

@ -5,7 +5,6 @@ import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.annotation.RayRemote;
import org.ray.api.exception.RayActorException;
import org.testng.Assert;
import org.testng.annotations.Test;
@ -13,7 +12,6 @@ import org.testng.annotations.Test;
@Test
public class KillActorTest extends BaseTest {
@RayRemote
public static class HangActor {
public boolean alive() {
@ -31,8 +29,8 @@ public class KillActorTest extends BaseTest {
TestUtils.skipTestUnderSingleProcess();
TestUtils.skipTestIfDirectActorCallDisabled();
RayActor<HangActor> actor = Ray.createActor(HangActor::new);
Assert.assertTrue(Ray.call(HangActor::alive, actor).get());
RayObject<Boolean> result = Ray.call(HangActor::hang, actor);
Assert.assertTrue(actor.call(HangActor::alive).get());
RayObject<Boolean> result = actor.call(HangActor::hang);
Assert.assertEquals(0, Ray.wait(ImmutableList.of(result), 1, 500).getReady().size());
Ray.killActor(actor);
Assert.expectThrows(RayActorException.class, result::get);

2
java/test/src/main/java/org/ray/api/test/MultiLanguageClusterTest.java
View file

@ -2,13 +2,11 @@ package org.ray.api.test;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.testng.Assert;
import org.testng.annotations.Test;
public class MultiLanguageClusterTest extends BaseMultiLanguageTest {
@RayRemote
public static String echo(String word) {
return word;
}

12
java/test/src/main/java/org/ray/api/test/MultiThreadingTest.java
View file

@ -14,7 +14,6 @@ import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.WaitResult;
import org.ray.api.annotation.RayRemote;
import org.ray.api.id.ActorId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -29,21 +28,17 @@ public class MultiThreadingTest extends BaseTest {
private static final int LOOP_COUNTER = 100;
private static final int NUM_THREADS = 20;
@RayRemote
static Integer echo(int num) {
return num;
}
@RayRemote
public static class Echo {
@RayRemote
public Integer echo(int num) {
return num;
}
}
@RayRemote
public static class ActorIdTester {
private final ActorId actorId;
@ -53,7 +48,6 @@ public class MultiThreadingTest extends BaseTest {
Assert.assertNotEquals(actorId, ActorId.NIL);
}
@RayRemote
public ActorId getCurrentActorId() throws Exception {
final Object[] result = new Object[1];
Thread thread = new Thread(Ray.wrapRunnable(() -> {
@ -86,7 +80,7 @@ public class MultiThreadingTest extends BaseTest {
RayActor<Echo> echoActor = Ray.createActor(Echo::new);
runTestCaseInMultipleThreads(() -> {
int arg = random.nextInt();
RayObject<Integer> obj = Ray.call(Echo::echo, echoActor, arg);
RayObject<Integer> obj = echoActor.call(Echo::echo, arg);
Assert.assertEquals(arg, (int) obj.get());
}, LOOP_COUNTER);
@ -101,7 +95,7 @@ public class MultiThreadingTest extends BaseTest {
} catch (InterruptedException e) {
LOGGER.warn("Got exception while sleeping.", e);
}
RayObject<Integer> obj = Ray.call(Echo::echo, echoActor1, arg);
RayObject<Integer> obj = echoActor1.call(Echo::echo, arg);
Assert.assertEquals(arg, (int) obj.get());
}, 1);
@ -137,7 +131,7 @@ public class MultiThreadingTest extends BaseTest {
public void testGetCurrentActorId() {
TestUtils.skipTestUnderSingleProcess();
RayActor<ActorIdTester> actorIdTester = Ray.createActor(ActorIdTester::new);
ActorId actorId = Ray.call(ActorIdTester::getCurrentActorId, actorIdTester).get();
ActorId actorId = actorIdTester.call(ActorIdTester::getCurrentActorId).get();
Assert.assertEquals(actorId, actorIdTester.getId());
}

2
java/test/src/main/java/org/ray/api/test/PlasmaFreeTest.java
View file

@ -5,14 +5,12 @@ import java.util.Arrays;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.annotation.RayRemote;
import org.ray.api.id.TaskId;
import org.testng.Assert;
import org.testng.annotations.Test;
public class PlasmaFreeTest extends BaseTest {
@RayRemote
private static String hello() {
return "hello";
}

20
java/test/src/main/java/org/ray/api/test/RayCallTest.java
View file

@ -7,7 +7,6 @@ import java.util.Map;
import org.ray.api.Ray;
import org.ray.api.TestUtils;
import org.ray.api.TestUtils.LargeObject;
import org.ray.api.annotation.RayRemote;
import org.ray.api.id.ObjectId;
import org.testng.Assert;
import org.testng.annotations.Test;
@ -17,62 +16,50 @@ import org.testng.annotations.Test;
*/
public class RayCallTest extends BaseTest {
@RayRemote
private static int testInt(int val) {
return val;
}
@RayRemote
private static byte testByte(byte val) {
return val;
}
@RayRemote
private static short testShort(short val) {
return val;
}
@RayRemote
private static long testLong(long val) {
return val;
}
@RayRemote
private static double testDouble(double val) {
return val;
}
@RayRemote
private static float testFloat(float val) {
return val;
}
@RayRemote
private static boolean testBool(boolean val) {
return val;
}
@RayRemote
private static String testString(String val) {
return val;
}
@RayRemote
private static List<Integer> testList(List<Integer> val) {
return val;
}
@RayRemote
private static Map<String, Integer> testMap(Map<String, Integer> val) {
return val;
}
@RayRemote
private static LargeObject testLargeObject(LargeObject largeObject) {
return largeObject;
}
@RayRemote
private static void testNoReturn(ObjectId objectId) {
// Put an object in object store to inform driver that this function is executing.
TestUtils.getRuntime().getObjectStore().put(1, objectId);
@ -103,37 +90,30 @@ public class RayCallTest extends BaseTest {
Assert.assertEquals(((int) Ray.get(randomObjectId)), 1);
}
@RayRemote
private static int testNoParam() {
return 0;
}
@RayRemote
private static int testOneParam(int a) {
return a;
}
@RayRemote
private static int testTwoParams(int a, int b) {
return a + b;
}
@RayRemote
private static int testThreeParams(int a, int b, int c) {
return a + b + c;
}
@RayRemote
private static int testFourParams(int a, int b, int c, int d) {
return a + b + c + d;
}
@RayRemote
private static int testFiveParams(int a, int b, int c, int d, int e) {
return a + b + c + d + e;
}
@RayRemote
private static int testSixParams(int a, int b, int c, int d, int e, int f) {
return a + b + c + d + e + f;
}

2
java/test/src/main/java/org/ray/api/test/RedisPasswordTest.java
View file

@ -2,7 +2,6 @@ package org.ray.api.test;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
@ -22,7 +21,6 @@ public class RedisPasswordTest extends BaseTest {
System.clearProperty("ray.redis.password");
}
@RayRemote
public static String echo(String str) {
return str;
}

7
java/test/src/main/java/org/ray/api/test/ResourcesManagementTest.java
View file

@ -7,7 +7,6 @@ import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.WaitResult;
import org.ray.api.annotation.RayRemote;
import org.ray.api.options.ActorCreationOptions;
import org.ray.api.options.CallOptions;
import org.testng.Assert;
@ -30,12 +29,10 @@ public class ResourcesManagementTest extends BaseTest {
System.clearProperty("ray.resources");
}
@RayRemote
public static Integer echo(Integer number) {
return number;
}
@RayRemote
public static class Echo {
public Integer echo(Integer number) {
@ -84,7 +81,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".
RayActor<Echo> echo1 = Ray.createActor(Echo::new, actorCreationOptions1);
final RayObject<Integer> result1 = Ray.call(Echo::echo, echo1, 100);
final RayObject<Integer> result1 = echo1.call(Echo::echo, 100);
Assert.assertEquals(100, (int) result1.get());
// This is a case that can't satisfy required resources.
@ -94,7 +91,7 @@ public class ResourcesManagementTest extends BaseTest {
RayActor<ResourcesManagementTest.Echo> echo2 =
Ray.createActor(Echo::new, actorCreationOptions2);
final RayObject<Integer> result2 = Ray.call(Echo::echo, echo2, 100);
final RayObject<Integer> result2 = echo2.call(Echo::echo, 100);
WaitResult<Integer> waitResult = Ray.wait(ImmutableList.of(result2), 1, 1000);
Assert.assertEquals(0, waitResult.getReady().size());

4
java/test/src/main/java/org/ray/api/test/RuntimeContextTest.java
View file

@ -4,7 +4,6 @@ import java.nio.ByteBuffer;
import java.util.Arrays;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.annotation.RayRemote;
import org.ray.api.id.ActorId;
import org.ray.api.id.JobId;
import org.testng.Assert;
@ -47,7 +46,6 @@ public class RuntimeContextTest extends BaseTest {
Ray.getRuntimeContext().getObjectStoreSocketName());
}
@RayRemote
public static class RuntimeContextTester {
public String testRuntimeContext(ActorId actorId) {
@ -64,7 +62,7 @@ public class RuntimeContextTest extends BaseTest {
public void testRuntimeContextInActor() {
RayActor<RuntimeContextTester> actor = Ray.createActor(RuntimeContextTester::new);
Assert.assertEquals("ok",
Ray.call(RuntimeContextTester::testRuntimeContext, actor, actor.getId()).get());
actor.call(RuntimeContextTester::testRuntimeContext, actor.getId()).get());
}
}

6
java/test/src/main/java/org/ray/api/test/SingleProcessModeTest.java
View file

@ -8,7 +8,6 @@ import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.annotation.RayRemote;
import org.ray.api.id.ActorId;
import org.testng.Assert;
import org.testng.annotations.Test;
@ -19,7 +18,6 @@ public class SingleProcessModeTest extends BaseTest {
private static final int TIMES_TO_CALL_PER_ACTOR = 10;
@RayRemote
static class MyActor {
public MyActor() {
}
@ -38,7 +36,7 @@ public class SingleProcessModeTest extends BaseTest {
for (int i = 0; i < NUM_ACTOR_INSTANCE; ++i) {
RayActor<MyActor> actor = Ray.createActor(MyActor::new);
actors.add(actor);
actorThreadIds.put(actor.getId(), Ray.call(MyActor::getThreadId, actor).get());
actorThreadIds.put(actor.getId(), actor.call(MyActor::getThreadId).get());
}
Map<ActorId, List<RayObject<Long>>> allResults = new HashMap<>();
@ -46,7 +44,7 @@ public class SingleProcessModeTest extends BaseTest {
final RayActor<MyActor> actor = actors.get(i);
List<RayObject<Long>> thisActorResult = new ArrayList<>();
for (int j = 0; j < TIMES_TO_CALL_PER_ACTOR; ++j) {
thisActorResult.add(Ray.call(MyActor::getThreadId, actor));
thisActorResult.add(actor.call(MyActor::getThreadId));
}
allResults.put(actor.getId(), thisActorResult);
}

4
java/test/src/main/java/org/ray/api/test/StressTest.java
View file

@ -64,7 +64,7 @@ public class StressTest extends BaseTest {
public int ping(int n) {
List<ObjectId> objectIds = new ArrayList<>();
for (int i = 0; i < n; i++) {
objectIds.add(Ray.call(Actor::ping, actor).getId());
objectIds.add(actor.call(Actor::ping).getId());
}
int sum = 0;
for (Integer result : Ray.<Integer>get(objectIds)) {
@ -81,7 +81,7 @@ public class StressTest extends BaseTest {
List<ObjectId> objectIds = new ArrayList<>();
for (int i = 0; i < 10; i++) {
RayActor<Worker> worker = Ray.createActor(Worker::new, actor);
objectIds.add(Ray.call(Worker::ping, worker, 100).getId());
objectIds.add(worker.call(Worker::ping, 100).getId());
}
for (Integer result : Ray.<Integer>get(objectIds)) {

4
java/test/src/main/java/org/ray/api/test/WaitTest.java
View file

@ -7,18 +7,15 @@ import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.WaitResult;
import org.ray.api.annotation.RayRemote;
import org.testng.Assert;
import org.testng.annotations.Test;
public class WaitTest extends BaseTest {
@RayRemote
private static String hi() {
return "hi";
}
@RayRemote
private static String delayedHi() {
try {
Thread.sleep(100 * 1000);
@ -50,7 +47,6 @@ public class WaitTest extends BaseTest {
testWait();
}
@RayRemote
public static Object waitInWorker() {
testWait();
return null;

4
java/test/src/main/java/org/ray/api/test/WorkerJvmOptionsTest.java
View file

@ -4,14 +4,12 @@ import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.TestUtils;
import org.ray.api.annotation.RayRemote;
import org.ray.api.options.ActorCreationOptions;
import org.testng.Assert;
import org.testng.annotations.Test;
public class WorkerJvmOptionsTest extends BaseTest {
@RayRemote
public static class Echo {
String getOptions() {
return System.getProperty("test.suffix");
@ -27,7 +25,7 @@ public class WorkerJvmOptionsTest extends BaseTest {
.setJvmOptions(" -Dtest.suffix=suffix -Dtest.suffix1=suffix1 ")
.createActorCreationOptions();
RayActor<Echo> actor = Ray.createActor(Echo::new, options);
RayObject<String> obj = Ray.call(Echo::getOptions, actor);
RayObject<String> obj = actor.call(Echo::getOptions);
Assert.assertEquals(obj.get(), "suffix");
}
}

4
java/tutorial/src/main/java/org/ray/exercise/Exercise01.java
View file

@ -3,7 +3,6 @@ package org.ray.exercise;
import java.io.Serializable;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
/**
* Define a remote function, and execute multiple remote functions in parallel.
@ -13,15 +12,12 @@ public class Exercise01 implements Serializable {
/**
* A plain remote function.
*/
// `@RayRemote` annotation converts a normal function to a remote function.
@RayRemote
public static String sayHello() {
String ret = "hello";
System.out.println(ret);
return ret;
}
@RayRemote
public static String sayWorld() {
String ret = "world!";
System.out.println(ret);

4
java/tutorial/src/main/java/org/ray/exercise/Exercise02.java
View file

@ -2,21 +2,18 @@ package org.ray.exercise;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
/**
* Execute remote functions in parallel with some dependencies.
*/
public class Exercise02 {
@RayRemote
public static String sayHello() {
String ret = "hello";
System.out.println(ret);
return ret;
}
@RayRemote
public static String sayWorld() {
String ret = "world!";
System.out.println(ret);
@ -26,7 +23,6 @@ public class Exercise02 {
/**
* A remote function with dependency.
*/
@RayRemote
public static String merge(String hello, String world) {
return hello + "," + world;
}

3
java/tutorial/src/main/java/org/ray/exercise/Exercise03.java
View file

@ -2,7 +2,6 @@ package org.ray.exercise;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
/**
* Call a remote function from within another remote function.
@ -12,7 +11,6 @@ public class Exercise03 {
/**
* A remote function which will call another remote function.
*/
@RayRemote
public static String sayHelloWithWorld() {
String ret = "hello";
System.out.println(ret);
@ -23,7 +21,6 @@ public class Exercise03 {
/**
* A remote function which will be called by another remote function.
*/
@RayRemote
public static String sayWorld() {
String ret = "world!";
System.out.println(ret);

4
java/tutorial/src/main/java/org/ray/exercise/Exercise04.java
View file

@ -5,20 +5,17 @@ import java.util.List;
import org.ray.api.Ray;
import org.ray.api.RayObject;
import org.ray.api.WaitResult;
import org.ray.api.annotation.RayRemote;
/**
* Use Ray.wait to ignore stragglers
*/
public class Exercise04 {
@RayRemote
public static String f1() {
System.out.println("Executing f1");
return "f1";
}
@RayRemote
public static String f2() {
System.out.println("Executing f2");
return "f2";
@ -27,7 +24,6 @@ public class Exercise04 {
/**
* A slow remote function.
*/
@RayRemote
public static String f3() {
System.out.println("Executing f3");
try {

7
java/tutorial/src/main/java/org/ray/exercise/Exercise05.java
View file

@ -3,7 +3,6 @@ package org.ray.exercise;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.annotation.RayRemote;
/**
* Show usage of actors.
@ -16,9 +15,9 @@ public class Exercise05 {
// `Ray.createActor` creates an actor instance.
RayActor<Adder> adder = Ray.createActor(Adder::new, 0);
// Use `Ray.call(actor, parameters)` to call an actor method.
RayObject<Integer> result1 = Ray.call(Adder::add, adder, 1);
RayObject<Integer> result1 = adder.call(Adder::add, 1);
System.out.println(result1.get());
RayObject<Integer> result2 = Ray.call(Adder::add, adder, 10);
RayObject<Integer> result2 = adder.call(Adder::add, 10);
System.out.println(result2.get());
} catch (Throwable t) {
t.printStackTrace();
@ -30,8 +29,6 @@ public class Exercise05 {
/**
* An example actor.
*/
// `@RayRemote` annotation also converts a normal class to an actor.
@RayRemote
public static class Adder {
public Adder(int initValue) {

2
streaming/java/streaming-runtime/src/main/java/org/ray/streaming/runtime/python/PythonGateway.java
View file

@ -6,7 +6,6 @@ import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.msgpack.core.Preconditions;
import org.ray.api.annotation.RayRemote;
import org.ray.streaming.api.context.StreamingContext;
import org.ray.streaming.python.PythonFunction;
import org.ray.streaming.python.PythonPartition;
@ -24,7 +23,6 @@ import org.slf4j.LoggerFactory;
* `streaming/python/runtime/gateway_client.py`
*/
@SuppressWarnings("unchecked")
@RayRemote
public class PythonGateway {
private static final Logger LOG = LoggerFactory.getLogger(PythonGateway.class);
private static final String REFERENCE_ID_PREFIX = "__gateway_reference_id__";

2
streaming/java/streaming-runtime/src/main/java/org/ray/streaming/runtime/schedule/JobSchedulerImpl.java
View file

@ -61,7 +61,7 @@ public class JobSchedulerImpl implements JobScheduler {
switch (executionNode.getLanguage()) {
case JAVA:
RayActor<JobWorker> jobWorker = (RayActor<JobWorker>) worker;
waits.add(Ray.call(JobWorker::init, jobWorker,
waits.add(jobWorker.call(JobWorker::init,
new WorkerContext(taskId, executionGraph, jobConfig)));
break;
case PYTHON:

2
streaming/java/streaming-runtime/src/main/java/org/ray/streaming/runtime/worker/JobWorker.java
View file

@ -4,7 +4,6 @@ import java.io.Serializable;
import java.util.Map;
import org.ray.api.Ray;
import org.ray.api.annotation.RayRemote;
import org.ray.runtime.RayMultiWorkerNativeRuntime;
import org.ray.runtime.functionmanager.JavaFunctionDescriptor;
import org.ray.streaming.runtime.core.graph.ExecutionGraph;
@ -28,7 +27,6 @@ import org.slf4j.LoggerFactory;
/**
* The stream job worker, it is a ray actor.
*/
@RayRemote
public class JobWorker implements Serializable {
private static final Logger LOGGER = LoggerFactory.getLogger(JobWorker.class);

14
streaming/java/streaming-runtime/src/test/java/org/ray/streaming/runtime/streamingqueue/StreamingQueueTest.java
View file

@ -101,11 +101,11 @@ public class StreamingQueueTest extends BaseUnitTest implements Serializable {
builder.createActorCreationOptions());
LOGGER.info("call getName on writerActor: {}",
Ray.call(WriterWorker::getName, writerActor).get());
writerActor.call(WriterWorker::getName).get());
LOGGER.info("call getName on readerActor: {}",
Ray.call(ReaderWorker::getName, readerActor).get());
readerActor.call(ReaderWorker::getName).get());
// LOGGER.info(Ray.call(WriterWorker::testCallReader, writerActor, readerActor).get());
// LOGGER.info(writerActor.call(WriterWorker::testCallReader, readerActor).get());
List<String> outputQueueList = new ArrayList<>();
List<String> inputQueueList = new ArrayList<>();
int queueNum = 2;
@ -118,17 +118,17 @@ public class StreamingQueueTest extends BaseUnitTest implements Serializable {
}
final int msgCount = 100;
Ray.call(ReaderWorker::init, readerActor, inputQueueList, writerActor, msgCount);
readerActor.call(ReaderWorker::init, inputQueueList, writerActor, msgCount);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Ray.call(WriterWorker::init, writerActor, outputQueueList, readerActor, msgCount);
writerActor.call(WriterWorker::init, outputQueueList, readerActor, msgCount);
long time = 0;
while (time < 20000 &&
Ray.call(ReaderWorker::getTotalMsg, readerActor).get() < msgCount * queueNum) {
readerActor.call(ReaderWorker::getTotalMsg).get() < msgCount * queueNum) {
try {
Thread.sleep(1000);
time += 1000;
@ -138,7 +138,7 @@ public class StreamingQueueTest extends BaseUnitTest implements Serializable {
}
Assert.assertEquals(
Ray.call(ReaderWorker::getTotalMsg, readerActor).get().intValue(),
readerActor.call(ReaderWorker::getTotalMsg).get().intValue(),
msgCount * queueNum);
}

19
streaming/java/streaming-runtime/src/test/java/org/ray/streaming/runtime/streamingqueue/Worker.java
View file

@ -9,7 +9,6 @@ import java.util.Map;
import java.util.Random;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.annotation.RayRemote;
import org.ray.api.id.ActorId;
import org.ray.runtime.RayMultiWorkerNativeRuntime;
import org.ray.runtime.actor.NativeRayActor;
@ -59,7 +58,6 @@ public class Worker {
}
}
@RayRemote
class ReaderWorker extends Worker {
private static final Logger LOGGER = LoggerFactory.getLogger(ReaderWorker.class);
@ -68,7 +66,7 @@ class ReaderWorker extends Worker {
private List<ActorId> inputActorIds = new ArrayList<>();
private DataReader dataReader = null;
private long handler = 0;
private RayActor peerActor = null;
private RayActor<WriterWorker> peerActor = null;
private int msgCount = 0;
private int totalMsg = 0;
@ -90,7 +88,7 @@ class ReaderWorker extends Worker {
return "testRayCall";
}
public boolean init(List<String> inputQueueList, RayActor peer, int msgCount) {
public boolean init(List<String> inputQueueList, RayActor<WriterWorker> peer, int msgCount) {
this.inputQueueList = inputQueueList;
this.peerActor = peer;
@ -176,7 +174,6 @@ class ReaderWorker extends Worker {
}
}
@RayRemote
class WriterWorker extends Worker {
private static final Logger LOGGER = LoggerFactory.getLogger(WriterWorker.class);
@ -184,7 +181,7 @@ class WriterWorker extends Worker {
private List<String> outputQueueList = null;
private List<ActorId> outputActorIds = new ArrayList<>();
DataWriter dataWriter = null;
RayActor peerActor = null;
RayActor<ReaderWorker> peerActor = null;
int msgCount = 0;
public WriterWorker(String name) {
@ -199,13 +196,13 @@ class WriterWorker extends Worker {
return name;
}
public String testCallReader(RayActor readerActor) {
String name = (String) Ray.call(ReaderWorker::getName, readerActor).get();
public String testCallReader(RayActor<ReaderWorker> readerActor) {
String name = readerActor.call(ReaderWorker::getName).get();
LOGGER.info("testCallReader: {}", name);
return name;
}
public boolean init(List<String> outputQueueList, RayActor peer, int msgCount) {
public boolean init(List<String> outputQueueList, RayActor<ReaderWorker> peer, int msgCount) {
this.outputQueueList = outputQueueList;
this.peerActor = peer;
@ -221,7 +218,7 @@ class WriterWorker extends Worker {
LOGGER.info("Peer isDirectActorCall: {}", ((NativeRayActor) peer).isDirectCallActor());
int count = 3;
while (count-- != 0) {
Ray.call(ReaderWorker::testRayCall, peer).get();
peer.call(ReaderWorker::testRayCall).get();
}
try {
@ -277,4 +274,4 @@ class WriterWorker extends Worker {
e.printStackTrace();
}
}
}
}