file_path stringlengths 3 280 | file_language stringclasses 66 values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108 values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
doc/examples/cython/cython_examples/__init__.py | Python | from .cython_simple import simple_func, fib, fib_int, \
fib_cpdef, fib_cdef, simple_class
from .masked_log import masked_log
from .cython_blas import \
compute_self_corr_for_voxel_sel, \
compute_kernel_matrix, \
compute_single_self_corr_syrk, \
compute_single_self_corr_gemm, \
compute_corr_vectors, \
compute_single_matrix_multiplication
__all__ = [
"simple_func",
"fib",
"fib_int",
"fib_cpdef",
"fib_cdef",
"simple_class",
"masked_log",
"compute_self_corr_for_voxel_sel",
"compute_kernel_matrix",
"compute_single_self_corr_syrk",
"compute_single_self_corr_gemm",
"compute_corr_vectors",
"compute_single_matrix_multiplication"
]
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/cython/cython_examples/cython_blas.pyx | Cython | #!python
# cython: embedsignature=True, binding=True
# Copyright 2016 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Authors: Yida Wang
# (Intel Labs), 2016
cimport scipy.linalg.cython_blas as blas
def compute_self_corr_for_voxel_sel(py_trans_a, py_trans_b, py_m, py_n, py_k,
py_alpha, py_a, py_lda, int py_start_voxel,
py_b, py_ldb, py_beta, py_c, py_ldc,
int py_start_epoch):
""" use blas API sgemm wrapped by scipy to compute correlation
This method is limited to process self-correlation.
The blas APIs process matrices in column-major,
but our matrices are in row-major,
so we play the transpose trick here, i.e. A*B=(B^T*A^T)^T.
The resulting matrix in shape [num_assigned_voxels, num_voxels]
is stored in an alternate way to make sure that
the correlation vectors of the same voxel stored continuously
Parameters
----------
py_trans_a: str
do transpose or not for the first matrix A
py_trans_b: str
do transpose or not for the first matrix B
py_m: int
the row of the resulting matrix C
in our case, is num_voxels
py_n: int
the column of the resulting matrix C
in our case, is num_assigned_voxels
py_k: int
the collapsed dimension of the multiplying matrices
i.e. the column of the first matrix after transpose if necessary
the row of the second matrix after transpose if necessary
py_alpha: float
the weight applied to the first matrix A
py_a: 2D array in shape [epoch_length, num_voxels]
It is the activity data of an epoch, part 1 of the data to be
correlated with. Note that py_a can point to the same location of py_b.
py_lda: int
the stride of the first matrix A
py_start_voxel: int
the starting voxel of assigned voxels
used to locate the second matrix B
py_b: 2D array in shape [epoch_length, num_voxels]
It is the activity data of an epoch, part 2 of the data to be
correlated with. Note that py_a can point to the same location of py_b.
py_ldb: int
the stride of the second matrix B
py_beta: float
the weight applied to the resulting matrix C
py_c: 3D array in shape [num_selected_voxels, num_epochs, num_voxels]
place to store the resulting correlation values
py_ldc: int
the stride of the resulting matrix
in our case, num_voxels*num_epochs
py_start_epoch: int
the epoch over which the correlation is computed
Returns
-------
py_c: 3D array in shape [num_selected_voxels, num_epochs, num_voxels]
write the resulting correlation values in an alternate way
for the processing epoch
"""
cdef bytes by_trans_a=py_trans_a.encode()
cdef bytes by_trans_b=py_trans_b.encode()
cdef char* trans_a = by_trans_a
cdef char* trans_b = by_trans_b
cdef int M, N, K, lda, ldb, ldc
M = py_m
N = py_n
K = py_k
lda = py_lda
ldb = py_ldb
ldc = py_ldc
cdef float alpha, beta
alpha = py_alpha
beta = py_beta
cdef float[:, ::1] A
A = py_a
cdef float[:, ::1] B
B = py_b
cdef float[:, :, ::1] C
C = py_c
blas.sgemm(trans_a, trans_b, &M, &N, &K, &alpha, &A[0, 0], &lda,
&B[0, py_start_voxel], &ldb, &beta,
&C[0, py_start_epoch, 0], &ldc)
def compute_kernel_matrix(py_uplo, py_trans, py_n, py_k, py_alpha, py_a,
int py_start_voxel, py_lda,
py_beta, py_c, py_ldc):
""" use blas API syrk wrapped by scipy to compute kernel matrix of SVM
The blas APIs process matrices in column-major, but our matrices are
in row-major, so we play the transpose trick here, i.e. A*B=(B^T*A^T)^T
In SVM with linear kernel, the distance of two samples
is essentially the dot product of them.
Therefore, the kernel matrix can be obtained by matrix multiplication.
Since the kernel matrix is symmetric, ssyrk is used,
the other half of the matrix is assigned later.
In our case, the dimension of samples is much larger than
the number samples, so we proportionally shrink the values of
the kernel matrix for getting more robust alpha values in SVM iteration.
Parameters
----------
py_uplo: str
getting the upper or lower triangle of the matrix
py_trans: str
do transpose or not for the input matrix A
py_n: int
the row and column of the resulting matrix C
in our case, is num_epochs
py_k: int
the collapsed dimension of the multiplying matrices
i.e. the column of the first matrix after transpose if necessary
the row of the second matrix after transpose if necessary
in our case, is num_voxels
py_alpha: float
the weight applied to the input matrix A
py_a: 3D array in shape [num_assigned_voxels, num_epochs, num_voxels]
in our case the normalized correlation values of a voxel
py_start_voxel: int
the processed voxel
used to locate the input matrix A
py_lda: int
the stride of the input matrix A
py_beta: float
the weight applied to the resulting matrix C
py_c: 2D array in shape [num_epochs, num_epochs]
place to store the resulting kernel matrix
py_ldc: int
the stride of the resulting matrix
Returns
-------
py_c: 2D array in shape [num_epochs, num_epochs]
write the resulting kernel_matrix
for the processing voxel
"""
cdef bytes by_uplo=py_uplo.encode()
cdef bytes by_trans=py_trans.encode()
cdef char* uplo = by_uplo
cdef char* trans = by_trans
cdef int N, K, lda, ldc
N = py_n
K = py_k
lda = py_lda
ldc = py_ldc
cdef float alpha, beta
alpha = py_alpha
beta = py_beta
cdef float[:, :, ::1] A
A = py_a
cdef float[:, ::1] C
C = py_c
blas.ssyrk(uplo, trans, &N, &K, &alpha, &A[py_start_voxel, 0, 0], &lda,
&beta, &C[0, 0], &ldc)
# complete the other half of the kernel matrix
if py_uplo == 'L':
for j in range(py_c.shape[0]):
for k in range(j):
py_c[j, k] = py_c[k, j]
else:
for j in range(py_c.shape[0]):
for k in range(j):
py_c[k, j] = py_c[j, k]
def compute_single_self_corr_syrk(py_uplo, py_trans, py_n, py_k,
py_alpha, py_a, py_lda,
py_beta, py_c, py_ldc,
int py_start_sample):
""" use blas API syrk wrapped by scipy to compute correlation matrix
This is to compute the correlation between selected voxels for
final training and classification. Since the resulting correlation
matrix is symmetric, syrk is used. However, it looks like that in most
cases, syrk performs much worse than gemm (the next function).
Here we assume that the resulting matrix is stored in a compact way,
i.e. py_ldc == py_n.
Parameters
----------
py_uplo: str
getting the upper or lower triangle of the matrix
py_trans: str
do transpose or not for the input matrix A
py_n: int
the row and column of the resulting matrix C
in our case, is num_selected_voxels
py_k: int
the collapsed dimension of the multiplying matrices
i.e. the column of the first matrix after transpose if necessary
the row of the second matrix after transpose if necessary
in our case, is num_TRs
py_alpha: float
the weight applied to the input matrix A
py_a: 2D array in shape [num_TRs, num_selected_voxels]
in our case the normalized activity values
py_lda: int
the stride of the input matrix A
py_beta: float
the weight applied to the resulting matrix C
py_c: 3D array
in shape [num_samples, num_selected_voxels, num_selected_voxels]
place to store the resulting kernel matrix
py_ldc: int
the stride of the resulting matrix
py_start_sample: int
the processed sample
used to locate the resulting matrix C
Returns
-------
py_c: 3D array
in shape [num_samples, num_selected_voxels, num_selected_voxels]
write the resulting correlation matrices
for the processed sample
"""
cdef bytes by_uplo=py_uplo.encode()
cdef bytes by_trans=py_trans.encode()
cdef char* uplo = by_uplo
cdef char* trans = by_trans
cdef int N, K, lda, ldc
N = py_n
K = py_k
lda = py_lda
ldc = py_ldc
cdef float alpha, beta
alpha = py_alpha
beta = py_beta
cdef float[:, ::1] A
A = py_a
cdef float[:, :, ::1] C
C = py_c
blas.ssyrk(uplo, trans, &N, &K, &alpha, &A[0, 0], &lda,
&beta, &C[py_start_sample, 0, 0], &ldc)
# complete the other half of the kernel matrix
if py_uplo == 'L':
for j in range(py_c.shape[1]):
for k in range(j):
py_c[py_start_sample, j, k] = py_c[py_start_sample, k, j]
else:
for j in range(py_c.shape[1]):
for k in range(j):
py_c[py_start_sample, k, j] = py_c[py_start_sample, j, k]
def compute_single_self_corr_gemm(py_trans_a, py_trans_b, py_m, py_n,
py_k, py_alpha, py_a, py_lda,
py_ldb, py_beta, py_c, py_ldc,
int py_start_sample):
""" use blas API gemm wrapped by scipy to compute correlation matrix
This is to compute the correlation between selected voxels for
final training and classification. Although the resulting correlation
matrix is symmetric, in most cases, gemm performs better than syrk.
Here we assume that the resulting matrix is stored in a compact way,
i.e. py_ldc == py_n.
Parameters
----------
py_trans_a: str
do transpose or not for the first matrix A
py_trans_b: str
do transpose or not for the first matrix B
py_m: int
the row of the resulting matrix C
in our case, is num_selected_voxels
py_n: int
the column of the resulting matrix C
in our case, is num_selected_voxels
py_k: int
the collapsed dimension of the multiplying matrices
i.e. the column of the first matrix after transpose if necessary
the row of the second matrix after transpose if necessary
in our case, is num_TRs
py_alpha: float
the weight applied to the input matrix A
py_a: 2D array in shape [num_TRs, num_selected_voxels]
in our case the normalized activity values
both multipliers are specified here as the same one
py_lda: int
the stride of the input matrix A
py_ldb: int
the stride of the input matrix B
in our case, the same as py_lda
py_beta: float
the weight applied to the resulting matrix C
py_c: 3D array
in shape [num_samples, num_selected_voxels, num_selected_voxels]
place to store the resulting kernel matrix
py_ldc: int
the stride of the resulting matrix
py_start_sample: int
the processed sample
used to locate the resulting matrix C
Returns
-------
py_c: 3D array
in shape [num_samples, num_selected_voxels, num_selected_voxels]
write the resulting correlation matrices
for the processed sample
"""
cdef bytes by_trans_a=py_trans_a.encode()
cdef bytes by_trans_b=py_trans_b.encode()
cdef char* trans_a = by_trans_a
cdef char* trans_b = by_trans_b
cdef int M, N, K, lda, ldb, ldc
M = py_m
N = py_n
K = py_k
lda = py_lda
ldb = py_ldb
ldc = py_ldc
cdef float alpha, beta
alpha = py_alpha
beta = py_beta
cdef float[:, ::1] A
A = py_a
cdef float[:, :, ::1] C
C = py_c
blas.sgemm(trans_a, trans_b, &M, &N, &K, &alpha, &A[0, 0], &lda,
&A[0, 0], &ldb, &beta, &C[py_start_sample, 0, 0], &ldc)
def compute_corr_vectors(py_trans_a, py_trans_b, py_m, py_n,
py_k, py_alpha, py_a, py_lda,
py_b, py_ldb, py_beta, py_c, py_ldc,
int py_start_voxel,
int py_start_sample):
""" use blas API gemm wrapped by scipy to construct a correlation vector
The correlation vector is essentially correlation matrices computed
from two activity matrices. It will be placed in the corresponding place
of the resulting correlation data set.
The blas APIs process matrices in column-major,
but our matrices are in row-major, so we play the transpose trick here,
i.e. A*B=(B^T*A^T)^T
py_trans_a: str
do transpose or not for the first matrix A
py_trans_b: str
do transpose or not for the first matrix B
py_m: int
the row of the resulting matrix C
py_n: int
the column of the resulting matrix C
py_k: int
the collapsed dimension of the multiplying matrices
i.e. the column of the first matrix after transpose if necessary
the row of the second matrix after transpose if necessary
py_alpha: float
the weight applied to the input matrix A
py_a: 2D array
py_lda: int
the stride of the input matrix A
py_b: 2D array
py_ldb: int
the stride of the input matrix B
py_beta: float
the weight applied to the resulting matrix C
py_c: 2D array
in shape [py_m, py_n] of column-major
in fact it is
in shape [py_n, py_m] of row-major
py_ldc: int
the stride of the resulting matrix
py_start_voxel: int
the starting voxel of assigned voxels
used to locate the second matrix B
py_start_sample: int
the processed sample
used to locate the resulting matrix C
Returns
-------
py_c: 2D array
in shape [py_m, py_n] of column-major
write the resulting matrix to the place indicated by py_start_sample
"""
cdef bytes by_trans_a=py_trans_a.encode()
cdef bytes by_trans_b=py_trans_b.encode()
cdef char* trans_a = by_trans_a
cdef char* trans_b = by_trans_b
cdef int M, N, K, lda, ldb, ldc
M = py_m
N = py_n
K = py_k
lda = py_lda
ldb = py_ldb
ldc = py_ldc
cdef float alpha, beta
alpha = py_alpha
beta = py_beta
cdef float[:, ::1] A
A = py_a
cdef float[:, ::1] B
B = py_b
cdef float[:, :, ::1] C
C = py_c
blas.sgemm(trans_a, trans_b, &M, &N, &K, &alpha, &A[0, 0], &lda,
&B[0, py_start_voxel], &ldb, &beta,
&C[py_start_sample, 0, 0], &ldc)
def compute_single_matrix_multiplication(py_trans_a, py_trans_b, py_m, py_n,
py_k, py_alpha, py_a, py_lda,
py_b, py_ldb, py_beta, py_c, py_ldc):
""" use blas API gemm wrapped by scipy to do matrix multiplication
This is to compute the matrix multiplication.
The blas APIs process matrices in column-major,
but our matrices are in row-major, so we play the transpose trick here,
i.e. A*B=(B^T*A^T)^T
Parameters
----------
py_trans_a: str
do transpose or not for the first matrix A
py_trans_b: str
do transpose or not for the first matrix B
py_m: int
the row of the resulting matrix C
py_n: int
the column of the resulting matrix C
py_k: int
the collapsed dimension of the multiplying matrices
i.e. the column of the first matrix after transpose if necessary
the row of the second matrix after transpose if necessary
py_alpha: float
the weight applied to the input matrix A
py_a: 2D array
py_lda: int
the stride of the input matrix A
py_b: 2D array
py_ldb: int
the stride of the input matrix B
py_beta: float
the weight applied to the resulting matrix C
py_c: 2D array
in shape [py_m, py_n] of column-major
in fact it is
in shape [py_n, py_m] of row-major
py_ldc: int
the stride of the resulting matrix
Returns
-------
py_c: 2D array
in shape [py_m, py_n] of column-major
write the resulting matrix
"""
cdef bytes by_trans_a=py_trans_a.encode()
cdef bytes by_trans_b=py_trans_b.encode()
cdef char* trans_a = by_trans_a
cdef char* trans_b = by_trans_b
cdef int M, N, K, lda, ldb, ldc
M = py_m
N = py_n
K = py_k
lda = py_lda
ldb = py_ldb
ldc = py_ldc
cdef float alpha, beta
alpha = py_alpha
beta = py_beta
cdef float[:, ::1] A
A = py_a
cdef float[:, ::1] B
B = py_b
cdef float[:, ::1] C
C = py_c
blas.sgemm(trans_a, trans_b, &M, &N, &K, &alpha, &A[0, 0], &lda,
&B[0, 0], &ldb, &beta, &C[0, 0], &ldc)
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/cython/cython_examples/cython_simple.pyx | Cython | #!python
# cython: embedsignature=True, binding=True
def simple_func(x, y, z):
return x + y + z
# Cython code directly callable from Python
def fib(n):
if n < 2:
return n
return fib(n-2) + fib(n-1)
# Typed Cython code
def fib_int(int n):
if n < 2:
return n
return fib_int(n-2) + fib_int(n-1)
# Cython-Python code
cpdef fib_cpdef(int n):
if n < 2:
return n
return fib_cpdef(n-2) + fib_cpdef(n-1)
# C code
def fib_cdef(int n):
return fib_in_c(n)
cdef int fib_in_c(int n):
if n < 2:
return n
return fib_in_c(n-2) + fib_in_c(n-1)
# Simple class
class simple_class(object):
def __init__(self):
self.value = 0
def increment(self):
self.value += 1
return self.value
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/cython/cython_examples/masked_log.pyx | Cython | #!python
# cython: embedsignature=True, binding=True
# Copyright 2016 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from libc.math cimport log
import numpy as np
cimport numpy as np
def masked_log(x):
"""Compute natural logarithm while accepting nonpositive input
For nonpositive elements, return -inf.
Modified slightly from the original BrainIAK code to support
Python 2.
Parameters
----------
x: ndarray[T]
Returns
-------
ndarray[Union[T, np.float64]]
"""
y = np.empty(x.shape, dtype=np.float64)
lim = x.shape[0]
for i in range(lim):
if x[i] <= 0:
y[i] = float("-inf")
else:
y[i] = log(x[i])
return y
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/cython/cython_main.py | Python | import ray
import click
import inspect
import numpy as np
import cython_examples as cyth
def run_func(func, *args, **kwargs):
"""Helper function for running examples"""
ray.init()
func = ray.remote(func)
# NOTE: kwargs not allowed for now
result = ray.get(func.remote(*args))
# Inspect the stack to get calling example
caller = inspect.stack()[1][3]
print("%s: %s" % (caller, str(result)))
return result
@click.group(context_settings={"help_option_names": ["-h", "--help"]})
def cli():
"""Working with Cython actors and functions in Ray"""
@cli.command()
def example1():
"""Cython def function"""
run_func(cyth.simple_func, 1, 2, 3)
@cli.command()
def example2():
"""Cython def function, recursive"""
run_func(cyth.fib, 10)
@cli.command()
def example3():
"""Cython def function, built-in typed parameter"""
# NOTE: Cython will attempt to cast argument to correct type
# NOTE: Floats will be cast to int, but string, for example will error
run_func(cyth.fib_int, 10)
@cli.command()
def example4():
"""Cython cpdef function"""
run_func(cyth.fib_cpdef, 10)
@cli.command()
def example5():
"""Cython wrapped cdef function"""
# NOTE: cdef functions are not exposed to Python
run_func(cyth.fib_cdef, 10)
@cli.command()
def example6():
"""Cython simple class"""
ray.init()
cls = ray.remote(cyth.simple_class)
a1 = cls.remote()
a2 = cls.remote()
result1 = ray.get(a1.increment.remote())
result2 = ray.get(a2.increment.remote())
print(result1, result2)
@cli.command()
def example7():
"""Cython with function from BrainIAK (masked log)"""
run_func(cyth.masked_log, np.array([-1.0, 0.0, 1.0, 2.0]))
@cli.command()
def example8():
"""Cython with blas. NOTE: requires scipy"""
# See cython_blas.pyx for argument documentation
mat = np.array(
[[[2.0, 2.0], [2.0, 2.0]], [[2.0, 2.0], [2.0, 2.0]]], dtype=np.float32)
result = np.zeros((2, 2), np.float32, order="C")
run_func(cyth.compute_kernel_matrix, "L", "T", 2, 2, 1.0, mat, 0, 2, 1.0,
result, 2)
if __name__ == "__main__":
cli()
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/cython/setup.py | Python | import os
from setuptools import setup
from Cython.Build import cythonize
import numpy
pkg_dir = "cython_examples"
modules = ["cython_simple.pyx", "masked_log.pyx"]
install_requires = ["cython", "numpy"]
include_dirs = [numpy.get_include()]
# TODO: Need scipy to run BrainIAK example, but don't want to add additional
# dependencies
try:
import scipy # noqa
modules.append("cython_blas.pyx")
install_requires.append("scipy")
except ImportError as e: # noqa
pass
modules = [os.path.join(pkg_dir, module) for module in modules]
setup(
name=pkg_dir,
version="0.0.1",
description="Cython examples for Ray",
packages=[pkg_dir],
ext_modules=cythonize(modules),
install_requires=install_requires,
include_dirs=include_dirs)
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/doc_code/tf_example.py | Python | # flake8: noqa
"""
This file holds code for the TF best-practices guide in the documentation.
It ignores yapf because yapf doesn't allow comments right after code blocks,
but we put comments right after code blocks to prevent large white spaces
in the documentation.
"""
# yapf: disable
# __tf_model_start__
def create_keras_model():
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential()
# Adds a densely-connected layer with 64 units to the model:
model.add(layers.Dense(64, activation="relu", input_shape=(32, )))
# Add another:
model.add(layers.Dense(64, activation="relu"))
# Add a softmax layer with 10 output units:
model.add(layers.Dense(10, activation="softmax"))
model.compile(
optimizer=keras.optimizers.RMSprop(0.01),
loss=keras.losses.categorical_crossentropy,
metrics=[keras.metrics.categorical_accuracy])
return model
# __tf_model_end__
# yapf: enable
# yapf: disable
# __ray_start__
import ray
import numpy as np
ray.init()
def random_one_hot_labels(shape):
n, n_class = shape
classes = np.random.randint(0, n_class, n)
labels = np.zeros((n, n_class))
labels[np.arange(n), classes] = 1
return labels
# Use GPU wth
# @ray.remote(num_gpus=1)
@ray.remote
class Network(object):
def __init__(self):
self.model = create_keras_model()
self.dataset = np.random.random((1000, 32))
self.labels = random_one_hot_labels((1000, 10))
def train(self):
history = self.model.fit(self.dataset, self.labels, verbose=False)
return history.history
def get_weights(self):
return self.model.get_weights()
def set_weights(self, weights):
# Note that for simplicity this does not handle the optimizer state.
self.model.set_weights(weights)
# __ray_end__
# yapf: enable
# yapf: disable
# __actor_start__
NetworkActor = Network.remote()
result_object_id = NetworkActor.train.remote()
ray.get(result_object_id)
# __actor_end__
# yapf: enable
# yapf: disable
# __weight_average_start__
NetworkActor2 = Network.remote()
NetworkActor2.train.remote()
weights = ray.get(
[NetworkActor.get_weights.remote(),
NetworkActor2.get_weights.remote()])
averaged_weights = [(layer1 + layer2) / 2
for layer1, layer2 in zip(weights[0], weights[1])]
weight_id = ray.put(averaged_weights)
[
actor.set_weights.remote(weight_id)
for actor in [NetworkActor, NetworkActor2]
]
ray.get([actor.train.remote() for actor in [NetworkActor, NetworkActor2]])
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/doc_code/torch_example.py | Python | # flake8: noqa
"""
This file holds code for the Torch best-practices guide in the documentation.
It ignores yapf because yapf doesn't allow comments right after code blocks,
but we put comments right after code blocks to prevent large white spaces
in the documentation.
"""
# yapf: disable
# __torch_model_start__
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1, 20, 5, 1)
self.conv2 = nn.Conv2d(20, 50, 5, 1)
self.fc1 = nn.Linear(4 * 4 * 50, 500)
self.fc2 = nn.Linear(500, 10)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2, 2)
x = x.view(-1, 4 * 4 * 50)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return F.log_softmax(x, dim=1)
# __torch_model_end__
# yapf: enable
# yapf: disable
# __torch_helper_start__
from filelock import FileLock
from torchvision import datasets, transforms
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# This break is for speeding up the tutorial.
if batch_idx * len(data) > 1024:
return
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
def test(model, device, test_loader):
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
# sum up batch loss
test_loss += F.nll_loss(
output, target, reduction="sum").item()
pred = output.argmax(
dim=1,
keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
return {
"loss": test_loss,
"accuracy": 100. * correct / len(test_loader.dataset)
}
def dataset_creator(use_cuda):
kwargs = {"num_workers": 1, "pin_memory": True} if use_cuda else {}
with FileLock("./data.lock"):
train_loader = torch.utils.data.DataLoader(
datasets.MNIST(
"./data",
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
128,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST(
"./data",
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
128,
shuffle=True,
**kwargs)
return train_loader, test_loader
# __torch_helper_end__
# yapf: enable
# yapf: disable
# __torch_net_start__
import torch.optim as optim
class Network(object):
def __init__(self, lr=0.01, momentum=0.5):
use_cuda = torch.cuda.is_available()
self.device = device = torch.device("cuda" if use_cuda else "cpu")
self.train_loader, self.test_loader = dataset_creator(use_cuda)
self.model = Model().to(device)
self.optimizer = optim.SGD(
self.model.parameters(), lr=lr, momentum=momentum)
def train(self):
train(self.model, self.device, self.train_loader, self.optimizer)
return test(self.model, self.device, self.test_loader)
def get_weights(self):
return self.model.state_dict()
def set_weights(self, weights):
self.model.load_state_dict(weights)
def save(self):
torch.save(self.model.state_dict(), "mnist_cnn.pt")
net = Network()
net.train()
# __torch_net_end__
# yapf: enable
# yapf: disable
# __torch_ray_start__
import ray
ray.init()
RemoteNetwork = ray.remote(Network)
# Use the below instead of `ray.remote(network)` to leverage the GPU.
# RemoteNetwork = ray.remote(num_gpus=1)(Network)
# __torch_ray_end__
# yapf: enable
# yapf: disable
# __torch_actor_start__
NetworkActor = RemoteNetwork.remote()
NetworkActor2 = RemoteNetwork.remote()
ray.get([NetworkActor.train.remote(), NetworkActor2.train.remote()])
# __torch_actor_end__
# yapf: enable
# yapf: disable
# __weight_average_start__
weights = ray.get(
[NetworkActor.get_weights.remote(),
NetworkActor2.get_weights.remote()])
from collections import OrderedDict
averaged_weights = OrderedDict(
[(k, (weights[0][k] + weights[1][k]) / 2) for k in weights[0]])
weight_id = ray.put(averaged_weights)
[
actor.set_weights.remote(weight_id)
for actor in [NetworkActor, NetworkActor2]
]
ray.get([actor.train.remote() for actor in [NetworkActor, NetworkActor2]])
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/lbfgs/driver.py | Python | import numpy as np
import os
import scipy.optimize
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import ray
import ray.experimental.tf_utils
class LinearModel(object):
"""Simple class for a one layer neural network.
Note that this code does not initialize the network weights. Instead
weights are set via self.variables.set_weights.
Example:
net = LinearModel([10, 10])
weights = [np.random.normal(size=[10, 10]),
np.random.normal(size=[10])]
variable_names = [v.name for v in net.variables]
net.variables.set_weights(dict(zip(variable_names, weights)))
Attributes:
x (tf.placeholder): Input vector.
w (tf.Variable): Weight matrix.
b (tf.Variable): Bias vector.
y_ (tf.placeholder): Input result vector.
cross_entropy (tf.Operation): Final layer of network.
cross_entropy_grads (tf.Operation): Gradient computation.
sess (tf.Session): Session used for training.
variables (TensorFlowVariables): Extracted variables and methods to
manipulate them.
"""
def __init__(self, shape):
"""Creates a LinearModel object."""
x = tf.placeholder(tf.float32, [None, shape[0]])
w = tf.Variable(tf.zeros(shape))
b = tf.Variable(tf.zeros(shape[1]))
self.x = x
self.w = w
self.b = b
y = tf.nn.softmax(tf.matmul(x, w) + b)
y_ = tf.placeholder(tf.float32, [None, shape[1]])
self.y_ = y_
cross_entropy = tf.reduce_mean(
-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
self.cross_entropy = cross_entropy
self.cross_entropy_grads = tf.gradients(cross_entropy, [w, b])
self.sess = tf.Session()
# In order to get and set the weights, we pass in the loss function to
# Ray's TensorFlowVariables to automatically create methods to modify
# the weights.
self.variables = ray.experimental.tf_utils.TensorFlowVariables(
cross_entropy, self.sess)
def loss(self, xs, ys):
"""Computes the loss of the network."""
return float(
self.sess.run(
self.cross_entropy, feed_dict={
self.x: xs,
self.y_: ys
}))
def grad(self, xs, ys):
"""Computes the gradients of the network."""
return self.sess.run(
self.cross_entropy_grads, feed_dict={
self.x: xs,
self.y_: ys
})
@ray.remote
class NetActor(object):
def __init__(self, xs, ys):
os.environ["CUDA_VISIBLE_DEVICES"] = ""
with tf.device("/cpu:0"):
self.net = LinearModel([784, 10])
self.xs = xs
self.ys = ys
# Compute the loss on a batch of data.
def loss(self, theta):
net = self.net
net.variables.set_flat(theta)
return net.loss(self.xs, self.ys)
# Compute the gradient of the loss on a batch of data.
def grad(self, theta):
net = self.net
net.variables.set_flat(theta)
gradients = net.grad(self.xs, self.ys)
return np.concatenate([g.flatten() for g in gradients])
def get_flat_size(self):
return self.net.variables.get_flat_size()
# Compute the loss on the entire dataset.
def full_loss(theta):
theta_id = ray.put(theta)
loss_ids = [actor.loss.remote(theta_id) for actor in actors]
return sum(ray.get(loss_ids))
# Compute the gradient of the loss on the entire dataset.
def full_grad(theta):
theta_id = ray.put(theta)
grad_ids = [actor.grad.remote(theta_id) for actor in actors]
# The float64 conversion is necessary for use with fmin_l_bfgs_b.
return sum(ray.get(grad_ids)).astype("float64")
if __name__ == "__main__":
ray.init()
# From the perspective of scipy.optimize.fmin_l_bfgs_b, full_loss is simply
# a function which takes some parameters theta, and computes a loss.
# Similarly, full_grad is a function which takes some parameters theta, and
# computes the gradient of the loss. Internally, these functions use Ray to
# distribute the computation of the loss and the gradient over the data
# that is represented by the remote object IDs x_batches and y_batches and
# which is potentially distributed over a cluster. However, these details
# are hidden from scipy.optimize.fmin_l_bfgs_b, which simply uses it to run
# the L-BFGS algorithm.
# Load the mnist data and turn the data into remote objects.
print("Downloading the MNIST dataset. This may take a minute.")
mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
num_batches = 10
batch_size = mnist.train.num_examples // num_batches
batches = [mnist.train.next_batch(batch_size) for _ in range(num_batches)]
print("Putting MNIST in the object store.")
actors = [NetActor.remote(xs, ys) for (xs, ys) in batches]
# Initialize the weights for the network to the vector of all zeros.
dim = ray.get(actors[0].get_flat_size.remote())
theta_init = 1e-2 * np.random.normal(size=dim)
# Use L-BFGS to minimize the loss function.
print("Running L-BFGS.")
result = scipy.optimize.fmin_l_bfgs_b(
full_loss, theta_init, maxiter=10, fprime=full_grad, disp=True)
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/lm/preprocess.sh | Shell | cd ~/efs/lm
# download the dataset
wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip
unzip wikitext-103-raw-v1.zip
# encode it with the GPT-2 BPE
mkdir -p gpt2_bpe
wget -O gpt2_bpe/encoder.json https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json
wget -O gpt2_bpe/vocab.bpe https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe
wget https://raw.githubusercontent.com/pytorch/fairseq/master/examples/roberta/multiprocessing_bpe_encoder.py
for SPLIT in train valid test; do \
python multiprocessing_bpe_encoder.py \
--encoder-json gpt2_bpe/encoder.json \
--vocab-bpe gpt2_bpe/vocab.bpe \
--inputs wikitext-103-raw/wiki.${SPLIT}.raw \
--outputs wikitext-103-raw/wiki.${SPLIT}.bpe \
--keep-empty \
--workers 60; \
done
# preprocess/binarize the data using the GPT-2 fairseq dictionary
wget -O gpt2_bpe/dict.txt https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt
fairseq-preprocess \
--only-source \
--srcdict gpt2_bpe/dict.txt \
--trainpref wikitext-103-raw/wiki.train.bpe \
--validpref wikitext-103-raw/wiki.valid.bpe \
--testpref wikitext-103-raw/wiki.test.bpe \
--destdir data-bin/wikitext-103 \
--workers 60 | zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/lm/ray_train.py | Python | #!/usr/bin/env python3 -u
import math
import copy
import socket
import time
import ray
import fairseq
from fairseq import options
from fairseq_cli.train import main
from contextlib import closing
_original_save_checkpoint = fairseq.checkpoint_utils.save_checkpoint
class RayDistributedActor:
"""Actor to perform distributed training."""
def run(self, url, world_rank, args):
"""Runs the fairseq training.
We set args for different ray actors for communication,
add a checkpoint hook, and call the main function of fairseq.
"""
# Set the init_method and rank of the process for distributed training.
print("Ray worker at {url} rank {rank}".format(
url=url, rank=world_rank))
self.url = url
self.world_rank = world_rank
args.distributed_rank = world_rank
args.distributed_init_method = url
# Add a checkpoint hook to make use of new resources.
self.add_checkpoint_hook(args)
# Call the original main function of fairseq.
main(args, init_distributed=(args.distributed_world_size > 1))
def add_checkpoint_hook(self, args):
"""Add a hook to the original save_checkpoint function.
This checks if there are new computational resources available.
If so, raise exception to restart the training process and
make use of the new resources.
"""
if args.cpu:
original_n_cpus = args.distributed_world_size
def _new_save_checkpoint(*args, **kwargs):
_original_save_checkpoint(*args, **kwargs)
n_cpus = int(ray.cluster_resources()["CPU"])
if n_cpus > original_n_cpus:
raise Exception(
"New CPUs find (original %d CPUs, now %d CPUs)" %
(original_n_cpus, n_cpus))
else:
original_n_gpus = args.distributed_world_size
def _new_save_checkpoint(*args, **kwargs):
_original_save_checkpoint(*args, **kwargs)
n_gpus = int(ray.cluster_resources().get("GPU", 0))
if n_gpus > original_n_gpus:
raise Exception(
"New GPUs find (original %d GPUs, now %d GPUs)" %
(original_n_gpus, n_gpus))
fairseq.checkpoint_utils.save_checkpoint = _new_save_checkpoint
def get_node_ip(self):
"""Returns the IP address of the current node."""
return ray.services.get_node_ip_address()
def find_free_port(self):
"""Finds a free port on the current node."""
with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
s.bind(("", 0))
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
return s.getsockname()[1]
def run_fault_tolerant_loop():
"""Entrance function to the fairseq library, providing fault-tolerance."""
# Parse the command line arguments.
parser = options.get_training_parser()
add_ray_args(parser)
args = options.parse_args_and_arch(parser)
original_args = copy.deepcopy(args)
# Main loop for fault-tolerant training.
retry = True
while retry:
args = copy.deepcopy(original_args)
# Initialize Ray.
ray.init(address=args.ray_address)
set_num_resources(args)
set_batch_size(args)
# Set up Ray distributed actors.
Actor = ray.remote(
num_cpus=1, num_gpus=int(not args.cpu))(RayDistributedActor)
workers = [Actor.remote() for i in range(args.distributed_world_size)]
# Get the IP address and a free port of actor 0, which is used for
# fairseq distributed training.
ip = ray.get(workers[0].get_node_ip.remote())
port = ray.get(workers[0].find_free_port.remote())
address = "tcp://{ip}:{port}".format(ip=ip, port=port)
# Start the remote processes, and check whether their are any process
# fails. If so, restart all the processes.
unfinished = [
worker.run.remote(address, i, args)
for i, worker in enumerate(workers)
]
try:
while len(unfinished) > 0:
finished, unfinished = ray.wait(unfinished)
finished = ray.get(finished)
retry = False
except Exception as inst:
print("Ray restart because following error occurs:")
print(inst)
retry = True
ray.shutdown()
def add_ray_args(parser):
"""Add ray and fault-tolerance related parser arguments to the parser."""
group = parser.add_argument_group("Ray related arguments")
group.add_argument(
"--ray-address",
default="auto",
type=str,
help="address for ray initialization")
group.add_argument(
"--fix-batch-size",
default=None,
metavar="B1,B2,...,B_N",
type=lambda uf: options.eval_str_list(uf, type=int),
help="fix the actual batch size (max_sentences * update_freq "
"* n_GPUs) to be the fixed input values by adjusting update_freq "
"accroding to actual n_GPUs; the batch size is fixed to B_i for "
"epoch i; all epochs >N are fixed to B_N")
return group
def set_num_resources(args):
"""Get the number of resources and set the corresponding fields."""
if args.cpu:
args.distributed_world_size = int(ray.cluster_resources()["CPU"])
else:
n_gpus = int(ray.cluster_resources().get("GPU", 0))
while n_gpus == 0:
print("No GPUs available, wait 10 seconds")
time.sleep(10)
n_gpus = int(ray.cluster_resources().get("GPU", 0))
args.distributed_world_size = n_gpus
def set_batch_size(args):
"""Fixes the total batch_size to be agnostic to the GPU count."""
if args.fix_batch_size is not None:
args.update_freq = [
math.ceil(batch_size /
(args.max_sentences * args.distributed_world_size))
for batch_size in args.fix_batch_size
]
print("Training on %d GPUs, max_sentences=%d, update_freq=%s" %
(args.distributed_world_size, args.max_sentences,
repr(args.update_freq)))
if __name__ == "__main__":
run_fault_tolerant_loop()
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/lm/ray_train.sh | Shell | #!/bin/bash
TOTAL_UPDATES=125000 # Total number of training steps
WARMUP_UPDATES=10000 # Warmup the learning rate over this many updates
PEAK_LR=0.0005 # Peak learning rate, adjust as needed
TOKENS_PER_SAMPLE=512 # Max sequence length
MAX_POSITIONS=512 # Num. positional embeddings (usually same as above)
MAX_SENTENCES=8 # Number of sequences per batch on one GPU (batch size)
FIX_BATCH_SIZE=2048 # Number of batch size in total (max_sentences * update_freq * n_gpus)
SAVE_INTERVAL_UPDATES=1000 # save a checkpoint every N updates
LOG_DIR=$HOME/efs/lm/log/
DATA_DIR=$HOME/efs/lm/data-bin/wikitext-103/
mkdir -p $LOG_DIR
python $HOME/efs/lm/ray_train.py --fp16 $DATA_DIR \
--task masked_lm --criterion masked_lm \
--arch roberta_base --sample-break-mode complete --tokens-per-sample $TOKENS_PER_SAMPLE \
--optimizer adam --adam-betas '(0.9, 0.98)' --adam-eps 1e-6 --clip-norm 0.0 \
--lr-scheduler polynomial_decay --lr $PEAK_LR --warmup-updates $WARMUP_UPDATES --total-num-update $TOTAL_UPDATES \
--dropout 0.1 --attention-dropout 0.1 --weight-decay 0.01 \
--max-sentences $MAX_SENTENCES \
--fix-batch-size $FIX_BATCH_SIZE \
--max-update $TOTAL_UPDATES --log-format simple --log-interval 1 \
--save-interval-updates $SAVE_INTERVAL_UPDATES \
--save-dir $LOG_DIR --ddp-backend=no_c10d
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/newsreader/server.py | Python | import atoma
from flask import Flask, jsonify, request
from flask_cors import CORS
import requests
import sqlite3
import ray
@ray.remote
class NewsServer(object):
def __init__(self):
self.conn = sqlite3.connect("newsreader.db")
c = self.conn.cursor()
c.execute("""CREATE TABLE IF NOT EXISTS news
(title text, link text,
description text, published timestamp,
feed url, liked bool)""")
self.conn.commit()
def retrieve_feed(self, url):
response = requests.get(url)
feed = atoma.parse_rss_bytes(response.content)
items = []
c = self.conn.cursor()
for item in feed.items:
items.append({"title": item.title,
"link": item.link,
"description": item.description,
"description_text": item.description,
"pubDate": str(item.pub_date)})
c.execute("""INSERT INTO news (title, link, description,
published, feed, liked) values
(?, ?, ?, ?, ?, ?)""", (
item.title, item.link, item.description,
item.pub_date, feed.link, False))
self.conn.commit()
return {"channel": {"title": feed.title,
"link": feed.link,
"url": feed.link},
"items": items}
def like_item(self, url, is_faved):
c = self.conn.cursor()
if is_faved:
c.execute("UPDATE news SET liked = 1 WHERE link = ?", (url,))
else:
c.execute("UPDATE news SET liked = 0 WHERE link = ?", (url,))
self.conn.commit()
# instantiate the app
app = Flask(__name__)
app.config.from_object(__name__)
# enable CORS
CORS(app)
@app.route("/api", methods=["POST"])
def dispatcher():
req = request.get_json()
method_name = req["method_name"]
method_args = req["method_args"]
if hasattr(dispatcher.server, method_name):
method = getattr(dispatcher.server, method_name)
# Doing a blocking ray.get right after submitting the task
# might be bad for performance if the task is expensive.
result = ray.get(method.remote(*method_args))
return jsonify(result)
else:
return jsonify(
{"error": "method_name '" + method_name + "' not found"})
if __name__ == "__main__":
ray.init(num_cpus=2)
dispatcher.server = NewsServer.remote()
app.run()
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/plot_hyperparameter.py | Python | """
Simple Parallel Model Selection
===============================
In this example, we'll demonstrate how to quickly write a hyperparameter
tuning script that evaluates a set of hyperparameters in parallel.
This script will demonstrate how to use two important parts of the Ray API:
using ``ray.remote`` to define remote functions and ``ray.wait`` to wait for
their results to be ready.
.. image:: ../images/hyperparameter.png
:align: center
.. important:: For a production-grade implementation of distributed
hyperparameter tuning, use `Tune`_, a scalable hyperparameter
tuning library built using Ray's Actor API.
.. _`Tune`: https://ray.readthedocs.io/en/latest/tune.html
Setup: Dependencies
-------------------
First, import some dependencies and define functions to generate
random hyperparameters and retrieve data.
"""
import os
import numpy as np
from filelock import FileLock
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import ray
ray.init()
# The number of sets of random hyperparameters to try.
num_evaluations = 10
# A function for generating random hyperparameters.
def generate_hyperparameters():
return {
"learning_rate": 10**np.random.uniform(-5, 1),
"batch_size": np.random.randint(1, 100),
"momentum": np.random.uniform(0, 1)
}
def get_data_loaders(batch_size):
mnist_transforms = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
# We add FileLock here because multiple workers will want to
# download data, and this may cause overwrites since
# DataLoader is not threadsafe.
with FileLock(os.path.expanduser("~/data.lock")):
train_loader = torch.utils.data.DataLoader(
datasets.MNIST(
"~/data",
train=True,
download=True,
transform=mnist_transforms),
batch_size=batch_size,
shuffle=True)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST("~/data", train=False, transform=mnist_transforms),
batch_size=batch_size,
shuffle=True)
return train_loader, test_loader
#######################################################################
# Setup: Defining the Neural Network
# ----------------------------------
#
# We define a small neural network to use in training. In addition,
# we created methods to train and test this neural network.
class ConvNet(nn.Module):
"""Simple two layer Convolutional Neural Network."""
def __init__(self):
super(ConvNet, self).__init__()
self.conv1 = nn.Conv2d(1, 3, kernel_size=3)
self.fc = nn.Linear(192, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 3))
x = x.view(-1, 192)
x = self.fc(x)
return F.log_softmax(x, dim=1)
def train(model, optimizer, train_loader, device=torch.device("cpu")):
"""Optimize the model with one pass over the data.
Cuts off at 1024 samples to simplify training.
"""
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
if batch_idx * len(data) > 1024:
return
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
def test(model, test_loader, device=torch.device("cpu")):
"""Checks the validation accuracy of the model.
Cuts off at 512 samples for simplicity.
"""
model.eval()
correct = 0
total = 0
with torch.no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if batch_idx * len(data) > 512:
break
data, target = data.to(device), target.to(device)
outputs = model(data)
_, predicted = torch.max(outputs.data, 1)
total += target.size(0)
correct += (predicted == target).sum().item()
return correct / total
#######################################################################
# Evaluating the Hyperparameters
# -------------------------------
#
# For a given configuration, the neural network created previously
# will be trained and return the accuracy of the model. These trained
# networks will then be tested for accuracy to find the best set of
# hyperparameters.
#
# The ``@ray.remote`` decorator defines a remote process.
@ray.remote
def evaluate_hyperparameters(config):
model = ConvNet()
train_loader, test_loader = get_data_loaders(config["batch_size"])
optimizer = optim.SGD(
model.parameters(),
lr=config["learning_rate"],
momentum=config["momentum"])
train(model, optimizer, train_loader)
return test(model, test_loader)
#######################################################################
# Synchronous Evaluation of Randomly Generated Hyperparameters
# ------------------------------------------------------------
#
# We will create multiple sets of random hyperparameters for our neural
# network that will be evaluated in parallel.
# Keep track of the best hyperparameters and the best accuracy.
best_hyperparameters = None
best_accuracy = 0
# A list holding the object IDs for all of the experiments that we have
# launched but have not yet been processed.
remaining_ids = []
# A dictionary mapping an experiment's object ID to its hyperparameters.
# hyerparameters used for that experiment.
hyperparameters_mapping = {}
###########################################################################
# Launch asynchronous parallel tasks for evaluating different
# hyperparameters. ``accuracy_id`` is an ObjectID that acts as a handle to
# the remote task. It is used later to fetch the result of the task
# when the task finishes.
# Randomly generate sets of hyperparameters and launch a task to evaluate it.
for i in range(num_evaluations):
hyperparameters = generate_hyperparameters()
accuracy_id = evaluate_hyperparameters.remote(hyperparameters)
remaining_ids.append(accuracy_id)
hyperparameters_mapping[accuracy_id] = hyperparameters
###########################################################################
# Process each hyperparameter and corresponding accuracy in the order that
# they finish to store the hyperparameters with the best accuracy.
# Fetch and print the results of the tasks in the order that they complete.
while remaining_ids:
# Use ray.wait to get the object ID of the first task that completes.
done_ids, remaining_ids = ray.wait(remaining_ids)
# There is only one return result by default.
result_id = done_ids[0]
hyperparameters = hyperparameters_mapping[result_id]
accuracy = ray.get(result_id)
print("""We achieve accuracy {:.3}% with
learning_rate: {:.2}
batch_size: {}
momentum: {:.2}
""".format(100 * accuracy, hyperparameters["learning_rate"],
hyperparameters["batch_size"], hyperparameters["momentum"]))
if accuracy > best_accuracy:
best_hyperparameters = hyperparameters
best_accuracy = accuracy
# Record the best performing set of hyperparameters.
print("""Best accuracy over {} trials was {:.3} with
learning_rate: {:.2}
batch_size: {}
momentum: {:.2}
""".format(num_evaluations, 100 * best_accuracy,
best_hyperparameters["learning_rate"],
best_hyperparameters["batch_size"],
best_hyperparameters["momentum"]))
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/plot_parameter_server.py | Python | """
Parameter Server
================
The parameter server is a framework for distributed machine learning training.
In the parameter server framework, a centralized server (or group of server
nodes) maintains global shared parameters of a machine-learning model
(e.g., a neural network) while the data and computation of calculating
updates (i.e., gradient descent updates) are distributed over worker nodes.
.. image:: ../images/param_actor.png
:align: center
Parameter servers are a core part of many machine learning applications. This
document walks through how to implement simple synchronous and asynchronous
parameter servers using Ray actors.
To run the application, first install some dependencies.
.. code-block:: bash
pip install torch torchvision filelock
Let's first define some helper functions and import some dependencies.
"""
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
from filelock import FileLock
import numpy as np
import ray
def get_data_loader():
"""Safely downloads data. Returns training/validation set dataloader."""
mnist_transforms = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
# We add FileLock here because multiple workers will want to
# download data, and this may cause overwrites since
# DataLoader is not threadsafe.
with FileLock(os.path.expanduser("~/data.lock")):
train_loader = torch.utils.data.DataLoader(
datasets.MNIST(
"~/data",
train=True,
download=True,
transform=mnist_transforms),
batch_size=128,
shuffle=True)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST("~/data", train=False, transform=mnist_transforms),
batch_size=128,
shuffle=True)
return train_loader, test_loader
def evaluate(model, test_loader):
"""Evaluates the accuracy of the model on a validation dataset."""
model.eval()
correct = 0
total = 0
with torch.no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
# This is only set to finish evaluation faster.
if batch_idx * len(data) > 1024:
break
outputs = model(data)
_, predicted = torch.max(outputs.data, 1)
total += target.size(0)
correct += (predicted == target).sum().item()
return 100. * correct / total
#######################################################################
# Setup: Defining the Neural Network
# ----------------------------------
#
# We define a small neural network to use in training. We provide
# some helper functions for obtaining data, including getter/setter
# methods for gradients and weights.
class ConvNet(nn.Module):
"""Small ConvNet for MNIST."""
def __init__(self):
super(ConvNet, self).__init__()
self.conv1 = nn.Conv2d(1, 3, kernel_size=3)
self.fc = nn.Linear(192, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 3))
x = x.view(-1, 192)
x = self.fc(x)
return F.log_softmax(x, dim=1)
def get_weights(self):
return {k: v.cpu() for k, v in self.state_dict().items()}
def set_weights(self, weights):
self.load_state_dict(weights)
def get_gradients(self):
grads = []
for p in self.parameters():
grad = None if p.grad is None else p.grad.data.cpu().numpy()
grads.append(grad)
return grads
def set_gradients(self, gradients):
for g, p in zip(gradients, self.parameters()):
if g is not None:
p.grad = torch.from_numpy(g)
###########################################################################
# Defining the Parameter Server
# -----------------------------
#
# The parameter server will hold a copy of the model.
# During training, it will:
#
# 1. Receive gradients and apply them to its model.
#
# 2. Send the updated model back to the workers.
#
# The ``@ray.remote`` decorator defines a remote process. It wraps the
# ParameterServer class and allows users to instantiate it as a
# remote actor.
@ray.remote
class ParameterServer(object):
def __init__(self, lr):
self.model = ConvNet()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=lr)
def apply_gradients(self, *gradients):
summed_gradients = [
np.stack(gradient_zip).sum(axis=0)
for gradient_zip in zip(*gradients)
]
self.optimizer.zero_grad()
self.model.set_gradients(summed_gradients)
self.optimizer.step()
return self.model.get_weights()
def get_weights(self):
return self.model.get_weights()
###########################################################################
# Defining the Worker
# -------------------
# The worker will also hold a copy of the model. During training. it will
# continuously evaluate data and send gradients
# to the parameter server. The worker will synchronize its model with the
# Parameter Server model weights.
@ray.remote
class DataWorker(object):
def __init__(self):
self.model = ConvNet()
self.data_iterator = iter(get_data_loader()[0])
def compute_gradients(self, weights):
self.model.set_weights(weights)
try:
data, target = next(self.data_iterator)
except StopIteration: # When the epoch ends, start a new epoch.
self.data_iterator = iter(get_data_loader()[0])
data, target = next(self.data_iterator)
self.model.zero_grad()
output = self.model(data)
loss = F.nll_loss(output, target)
loss.backward()
return self.model.get_gradients()
###########################################################################
# Synchronous Parameter Server Training
# -------------------------------------
# We'll now create a synchronous parameter server training scheme. We'll first
# instantiate a process for the parameter server, along with multiple
# workers.
iterations = 200
num_workers = 2
ray.init(ignore_reinit_error=True)
ps = ParameterServer.remote(1e-2)
workers = [DataWorker.remote() for i in range(num_workers)]
###########################################################################
# We'll also instantiate a model on the driver process to evaluate the test
# accuracy during training.
model = ConvNet()
test_loader = get_data_loader()[1]
###########################################################################
# Training alternates between:
#
# 1. Computing the gradients given the current weights from the server
# 2. Updating the parameter server's weights with the gradients.
print("Running synchronous parameter server training.")
current_weights = ps.get_weights.remote()
for i in range(iterations):
gradients = [
worker.compute_gradients.remote(current_weights) for worker in workers
]
# Calculate update after all gradients are available.
current_weights = ps.apply_gradients.remote(*gradients)
if i % 10 == 0:
# Evaluate the current model.
model.set_weights(ray.get(current_weights))
accuracy = evaluate(model, test_loader)
print("Iter {}: \taccuracy is {:.1f}".format(i, accuracy))
print("Final accuracy is {:.1f}.".format(accuracy))
# Clean up Ray resources and processes before the next example.
ray.shutdown()
###########################################################################
# Asynchronous Parameter Server Training
# --------------------------------------
# We'll now create a synchronous parameter server training scheme. We'll first
# instantiate a process for the parameter server, along with multiple
# workers.
print("Running Asynchronous Parameter Server Training.")
ray.init(ignore_reinit_error=True)
ps = ParameterServer.remote(1e-2)
workers = [DataWorker.remote() for i in range(num_workers)]
###########################################################################
# Here, workers will asynchronously compute the gradients given its
# current weights and send these gradients to the parameter server as
# soon as they are ready. When the Parameter server finishes applying the
# new gradient, the server will send back a copy of the current weights to the
# worker. The worker will then update the weights and repeat.
current_weights = ps.get_weights.remote()
gradients = {}
for worker in workers:
gradients[worker.compute_gradients.remote(current_weights)] = worker
for i in range(iterations * num_workers):
ready_gradient_list, _ = ray.wait(list(gradients))
ready_gradient_id = ready_gradient_list[0]
worker = gradients.pop(ready_gradient_id)
# Compute and apply gradients.
current_weights = ps.apply_gradients.remote(*[ready_gradient_id])
gradients[worker.compute_gradients.remote(current_weights)] = worker
if i % 10 == 0:
# Evaluate the current model after every 10 updates.
model.set_weights(ray.get(current_weights))
accuracy = evaluate(model, test_loader)
print("Iter {}: \taccuracy is {:.1f}".format(i, accuracy))
print("Final accuracy is {:.1f}.".format(accuracy))
##############################################################################
# Final Thoughts
# --------------
#
# This approach is powerful because it enables you to implement a parameter
# server with a few lines of code as part of a Python application.
# As a result, this simplifies the deployment of applications that use
# parameter servers and to modify the behavior of the parameter server.
#
# For example, sharding the parameter server, changing the update rule,
# switch between asynchronous and synchronous updates, ignoring
# straggler workers, or any number of other customizations,
# will only require a few extra lines of code.
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/plot_pong_example.py | Python | # flake8: noqa
"""
Learning to Play Pong
=====================
In this example, we'll train a **very simple** neural network to play Pong using
the OpenAI Gym.
At a high level, we will use multiple Ray actors to obtain simulation rollouts
and calculate gradient simultaneously. We will then centralize these
gradients and update the neural network. The updated neural network will
then be passed back to each Ray actor for more gradient calculation.
This application is adapted, with minimal modifications, from
Andrej Karpathy's `source code`_ (see the accompanying `blog post`_).
.. image:: ../images/pong-arch.svg
:align: center
To run the application, first install some dependencies.
.. code-block:: bash
pip install gym[atari]
At the moment, on a large machine with 64 physical cores, computing an update
with a batch of size 1 takes about 1 second, a batch of size 10 takes about 2.5
seconds. A batch of size 60 takes about 3 seconds. On a cluster with 11 nodes,
each with 18 physical cores, a batch of size 300 takes about 10 seconds. If the
numbers you see differ from these by much, take a look at the
**Troubleshooting** section at the bottom of this page and consider `submitting
an issue`_.
.. _`source code`: https://gist.github.com/karpathy/a4166c7fe253700972fcbc77e4ea32c5
.. _`blog post`: http://karpathy.github.io/2016/05/31/rl/
.. _`submitting an issue`: https://github.com/ray-project/ray/issues
**Note** that these times depend on how long the rollouts take, which in turn
depends on how well the policy is doing. For example, a really bad policy will
lose very quickly. As the policy learns, we should expect these numbers to
increase.
"""
import numpy as np
import os
import ray
import time
import gym
##############################################################################
# Hyperparameters
# ---------------
#
# Here we'll define a couple of the hyperparameters that are used.
H = 200 # The number of hidden layer neurons.
gamma = 0.99 # The discount factor for reward.
decay_rate = 0.99 # The decay factor for RMSProp leaky sum of grad^2.
D = 80 * 80 # The input dimensionality: 80x80 grid.
learning_rate = 1e-4 # Magnitude of the update.
#############################################################################
# Helper Functions
# ----------------
#
# We first define a few helper functions:
#
# 1. Preprocessing: The ``preprocess`` function will
# preprocess the original 210x160x3 uint8 frame into a one-dimensional 6400
# float vector.
#
# 2. Reward Processing: The ``process_rewards`` function will calculate
# a discounted reward. This formula states that the "value" of a
# sampled action is the weighted sum of all rewards afterwards,
# but later rewards are exponentially less important.
#
# 3. Rollout: The ``rollout`` function plays an entire game of Pong (until
# either the computer or the RL agent loses).
def preprocess(img):
# Crop the image.
img = img[35:195]
# Downsample by factor of 2.
img = img[::2, ::2, 0]
# Erase background (background type 1).
img[img == 144] = 0
# Erase background (background type 2).
img[img == 109] = 0
# Set everything else (paddles, ball) to 1.
img[img != 0] = 1
return img.astype(np.float).ravel()
def process_rewards(r):
"""Compute discounted reward from a vector of rewards."""
discounted_r = np.zeros_like(r)
running_add = 0
for t in reversed(range(0, r.size)):
# Reset the sum, since this was a game boundary (pong specific!).
if r[t] != 0:
running_add = 0
running_add = running_add * gamma + r[t]
discounted_r[t] = running_add
return discounted_r
def rollout(model, env):
"""Evaluates env and model until the env returns "Done".
Returns:
xs: A list of observations
hs: A list of model hidden states per observation
dlogps: A list of gradients
drs: A list of rewards.
"""
# Reset the game.
observation = env.reset()
# Note that prev_x is used in computing the difference frame.
prev_x = None
xs, hs, dlogps, drs = [], [], [], []
done = False
while not done:
cur_x = preprocess(observation)
x = cur_x - prev_x if prev_x is not None else np.zeros(D)
prev_x = cur_x
aprob, h = model.policy_forward(x)
# Sample an action.
action = 2 if np.random.uniform() < aprob else 3
# The observation.
xs.append(x)
# The hidden state.
hs.append(h)
y = 1 if action == 2 else 0 # A "fake label".
# The gradient that encourages the action that was taken to be
# taken (see http://cs231n.github.io/neural-networks-2/#losses if
# confused).
dlogps.append(y - aprob)
observation, reward, done, info = env.step(action)
# Record reward (has to be done after we call step() to get reward
# for previous action).
drs.append(reward)
return xs, hs, dlogps, drs
##############################################################################
# Neural Network
# --------------
# Here, a neural network is used to define a "policy"
# for playing Pong (that is, a function that chooses an action given a state).
#
# To implement a neural network in NumPy, we need to provide helper functions
# for calculating updates and computing the output of the neural network
# given an input, which in our case is an observation.
class Model(object):
"""This class holds the neural network weights."""
def __init__(self):
self.weights = {}
self.weights["W1"] = np.random.randn(H, D) / np.sqrt(D)
self.weights["W2"] = np.random.randn(H) / np.sqrt(H)
def policy_forward(self, x):
h = np.dot(self.weights["W1"], x)
h[h < 0] = 0 # ReLU nonlinearity.
logp = np.dot(self.weights["W2"], h)
# Softmax
p = 1.0 / (1.0 + np.exp(-logp))
# Return probability of taking action 2, and hidden state.
return p, h
def policy_backward(self, eph, epx, epdlogp):
"""Backward pass to calculate gradients.
Arguments:
eph: Array of intermediate hidden states.
epx: Array of experiences (observations.
epdlogp: Array of logps (output of last layer before softmax/
"""
dW2 = np.dot(eph.T, epdlogp).ravel()
dh = np.outer(epdlogp, self.weights["W2"])
# Backprop relu.
dh[eph <= 0] = 0
dW1 = np.dot(dh.T, epx)
return {"W1": dW1, "W2": dW2}
def update(self, grad_buffer, rmsprop_cache, lr, decay):
"""Applies the gradients to the model parameters with RMSProp."""
for k, v in self.weights.items():
g = grad_buffer[k]
rmsprop_cache[k] = (decay * rmsprop_cache[k] + (1 - decay) * g**2)
self.weights[k] += lr * g / (np.sqrt(rmsprop_cache[k]) + 1e-5)
def zero_grads(grad_buffer):
"""Reset the batch gradient buffer."""
for k, v in grad_buffer.items():
grad_buffer[k] = np.zeros_like(v)
#############################################################################
# Parallelizing Gradients
# -----------------------
# We define an **actor**, which is responsible for taking a model and an env
# and performing a rollout + computing a gradient update.
ray.init()
@ray.remote
class RolloutWorker(object):
def __init__(self):
# Tell numpy to only use one core. If we don't do this, each actor may
# try to use all of the cores and the resulting contention may result
# in no speedup over the serial version. Note that if numpy is using
# OpenBLAS, then you need to set OPENBLAS_NUM_THREADS=1, and you
# probably need to do it from the command line (so it happens before
# numpy is imported).
os.environ["MKL_NUM_THREADS"] = "1"
self.env = gym.make("Pong-v0")
def compute_gradient(self, model):
# Compute a simulation episode.
xs, hs, dlogps, drs = rollout(model, self.env)
reward_sum = sum(drs)
# Vectorize the arrays.
epx = np.vstack(xs)
eph = np.vstack(hs)
epdlogp = np.vstack(dlogps)
epr = np.vstack(drs)
# Compute the discounted reward backward through time.
discounted_epr = process_rewards(epr)
# Standardize the rewards to be unit normal (helps control the gradient
# estimator variance).
discounted_epr -= np.mean(discounted_epr)
discounted_epr /= np.std(discounted_epr)
# Modulate the gradient with advantage (the policy gradient magic
# happens right here).
epdlogp *= discounted_epr
return model.policy_backward(eph, epx, epdlogp), reward_sum
#############################################################################
# Running
# -------
#
# This example is easy to parallelize because the network can play ten games
# in parallel and no information needs to be shared between the games.
#
# In the loop, the network repeatedly plays games of Pong and
# records a gradient from each game. Every ten games, the gradients are
# combined together and used to update the network.
iterations = 20
batch_size = 4
model = Model()
actors = [RolloutWorker.remote() for _ in range(batch_size)]
running_reward = None
# "Xavier" initialization.
# Update buffers that add up gradients over a batch.
grad_buffer = {k: np.zeros_like(v) for k, v in model.weights.items()}
# Update the rmsprop memory.
rmsprop_cache = {k: np.zeros_like(v) for k, v in model.weights.items()}
for i in range(1, 1 + iterations):
model_id = ray.put(model)
gradient_ids = []
# Launch tasks to compute gradients from multiple rollouts in parallel.
start_time = time.time()
gradient_ids = [
actor.compute_gradient.remote(model_id) for actor in actors
]
for batch in range(batch_size):
[grad_id], gradient_ids = ray.wait(gradient_ids)
grad, reward_sum = ray.get(grad_id)
# Accumulate the gradient over batch.
for k in model.weights:
grad_buffer[k] += grad[k]
running_reward = (reward_sum if running_reward is None else
running_reward * 0.99 + reward_sum * 0.01)
end_time = time.time()
print("Batch {} computed {} rollouts in {} seconds, "
"running mean is {}".format(i, batch_size, end_time - start_time,
running_reward))
model.update(grad_buffer, rmsprop_cache, learning_rate, decay_rate)
zero_grads(grad_buffer)
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/examples/streaming/streaming.py | Python | import argparse
from collections import Counter, defaultdict
import heapq
import numpy as np
import os
import ray
import wikipedia
parser = argparse.ArgumentParser()
parser.add_argument("--num-mappers",
help="number of mapper actors used", default=3, type=int)
parser.add_argument("--num-reducers",
help="number of reducer actors used", default=4, type=int)
@ray.remote
class Mapper(object):
def __init__(self, title_stream):
self.title_stream = title_stream
self.num_articles_processed = 0
self.articles = []
self.word_counts = []
def get_new_article(self):
# Get the next wikipedia article.
article = wikipedia.page(self.title_stream.next()).content
# Count the words and store the result.
self.word_counts.append(Counter(article.split(" ")))
self.num_articles_processed += 1
def get_range(self, article_index, keys):
# Process more articles if this Mapper hasn't processed enough yet.
while self.num_articles_processed < article_index + 1:
self.get_new_article()
# Return the word counts from within a given character range.
return [(k, v) for k, v in self.word_counts[article_index].items()
if len(k) >= 1 and k[0] >= keys[0] and k[0] <= keys[1]]
@ray.remote
class Reducer(object):
def __init__(self, keys, *mappers):
self.mappers = mappers
self.keys = keys
def next_reduce_result(self, article_index):
word_count_sum = defaultdict(lambda: 0)
# Get the word counts for this Reducer's keys from all of the Mappers
# and aggregate the results.
count_ids = [mapper.get_range.remote(article_index, self.keys)
for mapper in self.mappers]
# TODO(rkn): We should process these out of order using ray.wait.
for count_id in count_ids:
for k, v in ray.get(count_id):
word_count_sum[k] += v
return word_count_sum
class Stream(object):
def __init__(self, elements):
self.elements = elements
def next(self):
i = np.random.randint(0, len(self.elements))
return self.elements[i]
if __name__ == "__main__":
args = parser.parse_args()
ray.init()
# Create one streaming source of articles per mapper.
directory = os.path.dirname(os.path.realpath(__file__))
streams = []
for _ in range(args.num_mappers):
with open(os.path.join(directory, "articles.txt")) as f:
streams.append(Stream([line.strip() for line in f.readlines()]))
# Partition the keys among the reducers.
chunks = np.array_split([chr(i) for i in range(ord("a"), ord("z") + 1)],
args.num_reducers)
keys = [[chunk[0], chunk[-1]] for chunk in chunks]
# Create a number of mappers.
mappers = [Mapper.remote(stream) for stream in streams]
# Create a number of reduces, each responsible for a different range of
# keys. This gives each Reducer actor a handle to each Mapper actor.
reducers = [Reducer.remote(key, *mappers) for key in keys]
article_index = 0
while True:
print("article index = {}".format(article_index))
wordcounts = {}
counts = ray.get([reducer.next_reduce_result.remote(article_index)
for reducer in reducers])
for count in counts:
wordcounts.update(count)
most_frequent_words = heapq.nlargest(10, wordcounts,
key=wordcounts.get)
for word in most_frequent_words:
print(" ", word, wordcounts[word])
article_index += 1
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/kubernetes/example.py | Python | from collections import Counter
import os
import sys
import time
import ray
@ray.remote
def gethostname(x):
import time
import socket
time.sleep(0.01)
return x + (socket.gethostname(), )
def wait_for_nodes(expected):
# Wait for all nodes to join the cluster.
while True:
num_nodes = len(ray.nodes())
if num_nodes < expected:
print("{} nodes have joined so far, waiting for {} more.".format(
num_nodes, expected - num_nodes))
sys.stdout.flush()
time.sleep(1)
else:
break
def main():
wait_for_nodes(4)
# Check that objects can be transferred from each node to each other node.
for i in range(10):
print("Iteration {}".format(i))
results = [
gethostname.remote(gethostname.remote(())) for _ in range(100)
]
print(Counter(ray.get(results)))
sys.stdout.flush()
print("Success!")
sys.stdout.flush()
if __name__ == "__main__":
# NOTE: If you know you're running this on the head node, you can just
# use "localhost" here.
# redis_host = "localhost"
if ("RAY_HEAD_SERVICE_HOST" not in os.environ
or os.environ["RAY_HEAD_SERVICE_HOST"] == ""):
raise ValueError("RAY_HEAD_SERVICE_HOST environment variable empty."
"Is there a ray cluster running?")
redis_host = os.environ["RAY_HEAD_SERVICE_HOST"]
ray.init(address=redis_host + ":6379")
main()
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/site/_includes/google-analytics.html | HTML | <meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-110413294-2"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());
gtag('config', 'UA-110413294-2');
</script>
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/site/blog.html | HTML | ---
layout: default
---
<link rel="stylesheet" href="{{ "/css/main.css" | prepend: site.baseurl }}">
<embed>
<a href="https://github.com/ray-project/ray"><img style="position: absolute; top: 0; right: 0; border: 0;" src="https://camo.githubusercontent.com/365986a132ccd6a44c23a9169022c0b5c890c387/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f7265645f6161303030302e706e67" alt="Fork me on GitHub" data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png"></a>
</embed>
<div class="home">
<div>
| <a class href="index.html">Home</a> | Blog | <a href="get_ray.html">Get Ray!</a> |
</div>
<p>
<img src="https://github.com/ray-project/ray/raw/master/doc/source/images/ray_header_logo.png"/>
</p>
<h1>Ray Project Blog</h1>
<ul class="posts">
{% for post in site.posts %}
<li>
<span>{{ post.date | date: "%b %-d, %Y" }}</span>
<a class="post-link" href="{{ post.url | prepend: site.baseurl }}">{{ post.title }}</a>
{{ post.excerpt }}
</li>
{% endfor %}
</ul>
<p>Here are Ray-related posts on other sites. First, some posts that are good, first-time introductions to Ray:</p>
<ul class="posts">
<li>
<span>February 11, 2019</span>
<a class="post-link" href="https://towardsdatascience.com/modern-parallel-and-distributed-python-a-quick-tutorial-on-ray-99f8d70369b8">Modern Parallel and Distributed Python: A Quick Tutorial on Ray</a>
</li>
<li>
<span>May 16, 2019</span>
<a class="post-link" href="https://towardsdatascience.com/10x-faster-parallel-python-without-python-multiprocessing-e5017c93cce1">10x Faster Parallel Python Without Python Multiprocessing</a>
</li>
</ul>
<p>Other useful posts on Ray:</p>
<ul class="posts">
<li>
<span>November 28, 2019</span>
<a class="post-link" href="https://rise.cs.berkeley.edu/blog/using-ray-as-a-foundation-for-real-time-analytic-monitoring-framework/">Using Ray as a foundation for a real-time analytic monitoring framework - RISE Lab</a>
</li>
<li>
<span>November 25, 2019</span>
<a class="post-link" href="https://medium.com/@offercstephen/dkeras-make-keras-faster-with-a-few-lines-of-code-a1792b12dfa0">dKeras: Make Keras up to 30x faster with a few lines of code</a>
</li>
<li>
<span>September 17, 2019</span>
<a class="post-link" href="https://medium.com/riselab/functional-rl-with-keras-and-tensorflow-eager-7973f81d6345">Functional RL with Keras and Tensorflow Eager - riselab - Medium</a>
</li>
<li>
<span>August 19, 2019</span>
<a class="post-link" href="https://medium.com/riselab/cutting-edge-hyperparameter-tuning-with-ray-tune-be6c0447afdf">Cutting edge hyperparameter tuning with Ray Tune - riselab - Medium</a>
</li>
<li>
<span>July 1, 2019</span>
<a class="post-link" href="https://www.oreilly.com/radar/riselabs-autopandas-hints-at-automation-tech-that-will-change-the-nature-of-software-development/">RISELab’s AutoPandas hints at automation tech that will change the nature of software development – O’Reilly</a>
</li>
<li>
<span>February 20, 2019</span>
<a class="post-link" href="https://rise.cs.berkeley.edu/blog/ray-tips-for-first-time-users/">Programming in Ray - Tips for First-Time Users</a>
</li>
<li>
<span>August 15, 2018</span>
<a class="post-link" href="https://www.oreilly.com/ideas/notes-from-the-first-ray-meetup">Notes from the first Ray meetup - O’Reilly Media</a>
</li>
<li>
<span>February 21, 2019</span>
<a class="post-link" href="https://www.oreilly.com/radar/the-evolution-and-expanding-utility-of-ray/">The evolution and expanding utility of Ray – O’Reilly</a>
</li>
<li>
<span>January 19, 2018</span>
<a class="post-link" href="https://www.oreilly.com/ideas/introducing-rllib-a-composable-and-scalable-reinforcement-learning-library">Introducing RLlib: A composable and scalable reinforcement learning library - O’Reilly Media</a>
</li>
</ul>
</div>
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/site/community.html | HTML | ---
layout: default
---
<!-- NOTE THIS FILE IS CURRENTLY EXCLUDED - SEE _CONFIG.YML -->
<link rel="stylesheet" href="{{ "/css/main.css" | prepend: site.baseurl }}">
<embed>
<a href="https://github.com/ray-project/ray"><img style="position: absolute; top: 0; right: 0; border: 0;" src="https://camo.githubusercontent.com/365986a132ccd6a44c23a9169022c0b5c890c387/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f7265645f6161303030302e706e67" alt="Fork me on GitHub" data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png"></a>
</embed>
<div class="home">
<div>
| <a class href="index.html">Home</a> | <a href="blog.html">Blog</a> | <a href="get_ray.html">Get Ray!</a> | Community |
</div>
<p>
<img src="https://github.com/ray-project/ray/raw/master/doc/source/images/ray_header_logo.png"/>
</p>
<h1>Ray Community</h1>
<b>TIP:</b> Join our <a href="https://forms.gle/9TSdDYUgxYs8SA9e8">community slack</a> to discuss Ray!
</div>
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/site/css/main.css | CSS | .posts { list-style-type: none; }
.posts li { margin-bottom: 30px; }
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/site/get_ray.html | HTML | ---
layout: default
---
<link rel="stylesheet" href="{{ "/css/main.css" | prepend: site.baseurl }}">
<embed>
<a href="https://github.com/ray-project/ray"><img style="position: absolute; top: 0; right: 0; border: 0;" src="https://camo.githubusercontent.com/365986a132ccd6a44c23a9169022c0b5c890c387/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f7265645f6161303030302e706e67" alt="Fork me on GitHub" data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png"></a>
</embed>
<div class="home">
<div>
| <a href="index.html">Home</a> | <a class href="blog.html">Blog</a> | Get Ray! |
</div>
<p>
<img src="https://github.com/ray-project/ray/raw/master/doc/source/images/ray_header_logo.png"/>
</p>
<h1>Getting Started with Ray</h1>
<p>
To get started with Ray:
</p>
<ul>
<li>Ray Project <a href="https://ray.io">web site</a></li>
<li><a href="https://ray.readthedocs.io/en/latest/">Documentation</a></li>
<li><a href="https://github.com/ray-project/">GitHub project</a></li>
<li><a href="https://github.com/ray-project/tutorial">Tutorials</a></li>
</ul>
</div>
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/site/index.html | HTML | ---
layout: default
---
<link rel="stylesheet" href="{{ "/css/main.css" | prepend: site.baseurl }}">
<embed>
<a href="https://github.com/ray-project/ray"><img style="position: absolute; top: 0; right: 0; border: 0;" src="https://camo.githubusercontent.com/365986a132ccd6a44c23a9169022c0b5c890c387/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f7265645f6161303030302e706e67" alt="Fork me on GitHub" data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png"></a>
</embed>
<div class="home">
<div>
| Home | <a class href="blog.html">Blog</a> | <a href="get_ray.html">Get Ray!</a> |
</div>
<p>
<img src="https://github.com/ray-project/ray/raw/master/doc/source/images/ray_header_logo.png"/>
</p>
<p>
<b>Ray is a fast and simple framework for building and running distributed applications.</b>
</p>
<p>
Ray is packaged with the following libraries for accelerating machine learning workloads:
</p>
<ul>
<li><em>Tune</em>: Scalable Hyperparameter Tuning</li>
<li><em>RLlib</em>: Scalable Reinforcement Learning</li>
<li><em>Distributed Training</em></li>
</ul>
<p>
To get started, visit the Ray Project <a href="https://ray.io">web site</a>, <a href="https://ray.readthedocs.io/en/latest/">documentation</a>, <a href="https://github.com/ray-project/">GitHub project</a>, or <a href="https://github.com/ray-project/tutorial">Tutorials</a>.
</p>
</div>
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/source/_templates/breadcrumbs.html | HTML | <!-- Based off https://github.com/edx/edx-documentation/. -->
<div role="navigation" aria-label="breadcrumbs navigation">
<ul class="wy-breadcrumbs">
{% block breadcrumbs %}
<li><a href="{{ pathto(master_doc) }}" class="icon icon-home"></a> »</li>
{% for doc in parents %}
<li><a href="{{ doc.link|e }}">{{ doc.title }}</a> »</li>
{% endfor %}
<li>{{ title }}</li>
{% endblock %}
<li class="wy-breadcrumbs-aside">
<a href="{{ feedback_form_url }}" target="_blank">Doc suggestion?</a>
</li>
</ul>
<hr/>
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/source/_templates/layout.html | HTML | {% extends "!layout.html" %}
{%- block extrahead %}
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-110413294-1"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());
gtag('config', 'UA-110413294-1');
</script>
{% endblock %}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/source/conf.py | Python | # -*- coding: utf-8 -*-
#
# Ray documentation build configuration file, created by
# sphinx-quickstart on Fri Jul 1 13:19:58 2016.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import glob
import shutil
import sys
import os
import urllib
sys.path.insert(0, os.path.abspath('.'))
from custom_directives import CustomGalleryItemDirective
# These lines added to enable Sphinx to work without installing Ray.
import mock
MOCK_MODULES = [
"blist",
"gym",
"gym.spaces",
"ray._raylet",
"ray.core.generated",
"ray.core.generated.gcs_pb2",
"ray.core.generated.ray.protocol.Task",
"scipy",
"scipy.signal",
"scipy.stats",
"tensorflow_probability",
"tensorflow",
"tensorflow.contrib",
"tensorflow.contrib.all_reduce",
"tensorflow.contrib.all_reduce.python",
"tensorflow.contrib.layers",
"tensorflow.contrib.rnn",
"tensorflow.contrib.slim",
"tensorflow.core",
"tensorflow.core.util",
"tensorflow.python",
"tensorflow.python.client",
"tensorflow.python.util",
"torch",
"torch.distributed",
"torch.nn",
"torch.nn.parallel",
"torch.utils.data",
]
for mod_name in MOCK_MODULES:
sys.modules[mod_name] = mock.Mock()
# ray.rllib.models.action_dist.py and
# ray.rllib.models.lstm.py will use tf.VERSION
sys.modules["tensorflow"].VERSION = "9.9.9"
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath("../../python/"))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.viewcode',
'sphinx.ext.napoleon',
'sphinx_click.ext',
'sphinx-jsonschema',
'sphinx_gallery.gen_gallery',
'sphinx_copybutton',
]
sphinx_gallery_conf = {
"examples_dirs": ["../examples"], # path to example scripts
"gallery_dirs": ["auto_examples"], # path where to save generated examples
"ignore_pattern": "../examples/doc_code/",
"plot_gallery": "False",
# "filename_pattern": "tutorial.py",
"backreferences_dir": False
# "show_memory': False,
# 'min_reported_time': False
}
for i in range(len(sphinx_gallery_conf["examples_dirs"])):
gallery_dir = sphinx_gallery_conf["gallery_dirs"][i]
source_dir = sphinx_gallery_conf["examples_dirs"][i]
try:
os.mkdir(gallery_dir)
except OSError:
pass
# Copy rst files from source dir to gallery dir.
for f in glob.glob(os.path.join(source_dir, '*.rst')):
shutil.copy(f, gallery_dir)
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
from recommonmark.parser import CommonMarkParser
# The suffix of source filenames.
source_suffix = ['.rst', '.md']
source_parsers = {
'.md': CommonMarkParser,
}
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Ray'
copyright = u'2019, The Ray Team'
author = u'The Ray Team'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
from ray import __version__ as version
# The full version, including alpha/beta/rc tags.
release = version
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
exclude_patterns += sphinx_gallery_conf['examples_dirs']
exclude_patterns += ["*/README.rst"]
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
import sphinx_rtd_theme
html_theme = 'sphinx_rtd_theme'
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
html_sidebars = {'**': ['index.html']}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
#html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
#html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'Raydoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'Ray.tex', u'Ray Documentation', u'The Ray Team', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [(master_doc, 'ray', u'Ray Documentation', [author], 1)]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'Ray', u'Ray Documentation', author, 'Ray',
'One line description of project.', 'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
# pcmoritz: To make the following work, you have to run
# sudo pip install recommonmark
# Python methods should be presented in source code order
autodoc_member_order = 'bysource'
# Taken from https://github.com/edx/edx-documentation
FEEDBACK_FORM_FMT = "https://github.com/ray-project/ray/issues/new?title={title}&labels=docs&body={body}"
def feedback_form_url(project, page):
"""Create a URL for feedback on a particular page in a project."""
return FEEDBACK_FORM_FMT.format(
title=urllib.parse.quote(
"[docs] Issue on `{page}.rst`".format(page=page)),
body=urllib.parse.quote(
"# Documentation Problem/Question/Comment\n"
"<!-- Describe your issue/question/comment below. -->\n"
"<!-- If there are typos or errors in the docs, feel free to create a pull-request. -->\n"
"\n\n\n\n"
"(Created directly from the docs)\n"))
def update_context(app, pagename, templatename, context, doctree):
"""Update the page rendering context to include ``feedback_form_url``."""
context['feedback_form_url'] = feedback_form_url(app.config.project,
pagename)
# see also http://searchvoidstar.tumblr.com/post/125486358368/making-pdfs-from-markdown-on-readthedocsorg-using
def setup(app):
app.connect('html-page-context', update_context)
# Custom directives
app.add_directive('customgalleryitem', CustomGalleryItemDirective)
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/source/custom_directives.py | Python | # Originally from:
# github.com/pytorch/tutorials/blob/60d6ef365e36f3ba82c2b61bf32cc40ac4e86c7b/custom_directives.py # noqa
from docutils.parsers.rst import Directive, directives
from docutils.statemachine import StringList
from docutils import nodes
import os
import sphinx_gallery
try:
FileNotFoundError
except NameError:
FileNotFoundError = IOError
# This is not a top level item in the directory, so we use `../` to refer
# to images located at the top level.
GALLERY_TEMPLATE = """
.. raw:: html
<div class="sphx-glr-thumbcontainer" tooltip="{tooltip}">
.. only:: html
.. figure:: ../{thumbnail}
{description}
.. raw:: html
</div>
"""
class CustomGalleryItemDirective(Directive):
"""Create a sphinx gallery style thumbnail.
tooltip and figure are self explanatory. Description could be a link to
a document like in below example.
Example usage:
.. customgalleryitem::
:tooltip: I am writing this tutorial to focus specifically on NLP.
:figure: /_static/img/thumbnails/babel.jpg
:description: :doc:`/beginner/deep_learning_nlp_tutorial`
If figure is specified, a thumbnail will be made out of it and stored in
_static/thumbs. Therefore, consider _static/thumbs as a "built" directory.
"""
required_arguments = 0
optional_arguments = 0
final_argument_whitespace = True
option_spec = {
"tooltip": directives.unchanged,
"figure": directives.unchanged,
"description": directives.unchanged
}
has_content = False
add_index = False
def run(self):
# Cutoff the `tooltip` after 195 chars.
if "tooltip" in self.options:
tooltip = self.options["tooltip"]
if len(self.options["tooltip"]) > 195:
tooltip = tooltip[:195] + "..."
else:
raise ValueError("Need to provide :tooltip: under "
"`.. customgalleryitem::`.")
# Generate `thumbnail` used in the gallery.
if "figure" in self.options:
env = self.state.document.settings.env
rel_figname, figname = env.relfn2path(self.options["figure"])
thumb_dir = os.path.join(env.srcdir, "_static/thumbs/")
os.makedirs(thumb_dir, exist_ok=True)
image_path = os.path.join(thumb_dir, os.path.basename(figname))
sphinx_gallery.gen_rst.scale_image(figname, image_path, 400, 280)
thumbnail = os.path.relpath(image_path, env.srcdir)
else:
thumbnail = "/_static/img/thumbnails/default.png"
if "description" in self.options:
description = self.options["description"]
else:
raise ValueError("Need to provide :description: under "
"`customgalleryitem::`.")
thumbnail_rst = GALLERY_TEMPLATE.format(
tooltip=tooltip, thumbnail=thumbnail, description=description)
thumbnail = StringList(thumbnail_rst.split("\n"))
thumb = nodes.paragraph()
self.state.nested_parse(thumbnail, self.content_offset, thumb)
return [thumb]
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/tools/install-prometheus-server.sh | Shell | #!/usr/bin/env bash
set -x
set -e
TOOLS_DIR=$(cd "$(dirname "${BASH_SOURCE:-$0}")"; pwd)
pushd $TOOLS_DIR
# Download Prometheus server.
unamestr="$(uname)"
if [[ "$unamestr" == "Linux" ]]; then
echo "Downloading Prometheus server for linux system."
PACKAGE_NAME=prometheus-2.8.0.linux-amd64
elif [[ "$unamestr" == "Darwin" ]]; then
echo "Downloading Prometheus server for MacOS system."
PACKAGE_NAME=prometheus-2.8.0.darwin-amd64
else
echo "Downloading abort: Unrecognized platform."
exit -1
fi
URL=https://github.com/prometheus/prometheus/releases/download/v2.8.0/$PACKAGE_NAME.tar.gz
wget $URL
tar xvfz $PACKAGE_NAME.tar.gz
popd
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
doc/yarn/example.py | Python | from collections import Counter
import sys
import time
import ray
@ray.remote
def gethostname(x):
import time
import socket
time.sleep(0.01)
return x + (socket.gethostname(), )
def wait_for_nodes(expected):
# Wait for all nodes to join the cluster.
while True:
num_nodes = len(ray.nodes())
if num_nodes < expected:
print("{} nodes have joined so far, waiting for {} more.".format(
num_nodes, expected - num_nodes))
sys.stdout.flush()
time.sleep(1)
else:
break
def main():
wait_for_nodes(4)
# Check that objects can be transferred from each node to each other node.
for i in range(10):
print("Iteration {}".format(i))
results = [
gethostname.remote(gethostname.remote(())) for _ in range(100)
]
print(Counter(ray.get(results)))
sys.stdout.flush()
print("Success!")
sys.stdout.flush()
time.sleep(20)
if __name__ == "__main__":
DRIVER_MEMORY = 100 * 1024 * 1024
ray.init(
address="localhost:6379", driver_object_store_memory=DRIVER_MEMORY)
main()
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/Checkpointable.java | Java | package org.ray.api;
import java.util.List;
import org.ray.api.id.ActorId;
import org.ray.api.id.UniqueId;
public interface Checkpointable {
class CheckpointContext {
/**
* Actor's ID.
*/
public final ActorId actorId;
/**
* Number of tasks executed since last checkpoint.
*/
public final int numTasksSinceLastCheckpoint;
/**
* Time elapsed since last checkpoint, in milliseconds.
*/
public final long timeElapsedMsSinceLastCheckpoint;
public CheckpointContext(ActorId actorId, int numTasksSinceLastCheckpoint,
long timeElapsedMsSinceLastCheckpoint) {
this.actorId = actorId;
this.numTasksSinceLastCheckpoint = numTasksSinceLastCheckpoint;
this.timeElapsedMsSinceLastCheckpoint = timeElapsedMsSinceLastCheckpoint;
}
}
class Checkpoint {
/**
* Checkpoint's ID.
*/
public final UniqueId checkpointId;
/**
* Checkpoint's timestamp.
*/
public final long timestamp;
public Checkpoint(UniqueId checkpointId, long timestamp) {
this.checkpointId = checkpointId;
this.timestamp = timestamp;
}
}
/**
* Whether this actor needs to be checkpointed.
*
* This method will be called after every task. You should implement this callback to decide
* whether this actor needs to be checkpointed at this time, based on the checkpoint context, or
* any other factors.
*
* @param checkpointContext An object that contains info about last checkpoint.
* @return A boolean value that indicates whether this actor needs to be checkpointed.
*/
boolean shouldCheckpoint(CheckpointContext checkpointContext);
/**
* Save a checkpoint to persistent storage.
*
* If `shouldCheckpoint` returns true, this method will be called. You should implement this
* callback to save actor's checkpoint and the given checkpoint id to persistent storage.
*
* @param actorId Actor's ID.
* @param checkpointId An ID that represents this actor's current state in GCS. You should
* save this checkpoint ID together with actor's checkpoint data.
*/
void saveCheckpoint(ActorId actorId, UniqueId checkpointId);
/**
* Load actor's previous checkpoint, and restore actor's state.
*
* This method will be called when an actor is reconstructed, after actor's constructor. If the
* actor needs to restore from previous checkpoint, this function should restore actor's state and
* return the checkpoint ID. Otherwise, it should do nothing and return null.
*
* @param actorId Actor's ID.
* @param availableCheckpoints A list of available checkpoint IDs and their timestamps, sorted
* by timestamp in descending order. Note, this method must return the ID of one checkpoint in
* this list, or null. Otherwise, an exception will be thrown.
* @return The ID of the checkpoint from which the actor was resumed, or null if the actor should
* restart from the beginning.
*/
UniqueId loadCheckpoint(ActorId actorId, List<Checkpoint> availableCheckpoints);
/**
* Delete an expired checkpoint;
*
* This method will be called when an checkpoint is expired. You should implement this method to
* delete your application checkpoint data. Note, the maximum number of checkpoints kept in the
* backend can be configured at `RayConfig.num_actor_checkpoints_to_keep`.
*
* @param actorId ID of the actor.
* @param checkpointId ID of the checkpoint that has expired.
*/
void checkpointExpired(ActorId actorId, UniqueId checkpointId);
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/Ray.java | Java | package org.ray.api;
import java.util.List;
import java.util.concurrent.Callable;
import org.ray.api.id.ObjectId;
import org.ray.api.id.UniqueId;
import org.ray.api.runtime.RayRuntime;
import org.ray.api.runtime.RayRuntimeFactory;
import org.ray.api.runtimecontext.RuntimeContext;
/**
* This class contains all public APIs of Ray.
*/
public final class Ray extends RayCall {
private static RayRuntime runtime = null;
/**
* Initialize Ray runtime with the default runtime implementation.
*/
public static void init() {
try {
Class clz = Class.forName("org.ray.runtime.DefaultRayRuntimeFactory");
RayRuntimeFactory factory = (RayRuntimeFactory) clz.newInstance();
init(factory);
} catch (Exception e) {
throw new RuntimeException("Failed to initialize Ray runtime.", e);
}
}
/**
* Initialize Ray runtime with a custom runtime implementation.
*
* @param factory A factory that produces the runtime instance.
*/
public static synchronized void init(RayRuntimeFactory factory) {
if (runtime == null) {
runtime = factory.createRayRuntime();
Runtime.getRuntime().addShutdownHook(new Thread(Ray::shutdown));
}
}
/**
* Shutdown Ray runtime.
*/
public static void shutdown() {
if (runtime != null) {
runtime.shutdown();
runtime = null;
}
}
/**
* Store an object in the object store.
*
* @param obj The Java object to be stored.
* @return A RayObject instance that represents the in-store object.
*/
public static <T> RayObject<T> put(T obj) {
return runtime.put(obj);
}
/**
* Get an object from the object store.
*
* @param objectId The ID of the object to get.
* @return The Java object.
*/
public static <T> T get(ObjectId objectId) {
return runtime.get(objectId);
}
/**
* Get a list of objects from the object store.
*
* @param objectIds The list of object IDs.
* @return A list of Java objects.
*/
public static <T> List<T> get(List<ObjectId> objectIds) {
return runtime.get(objectIds);
}
/**
* Wait for a list of RayObjects to be locally available,
* until specified number of objects are ready, or specified timeout has passed.
*
* @param waitList A list of RayObject to wait for.
* @param numReturns The number of objects that should be returned.
* @param timeoutMs The maximum time in milliseconds to wait before returning.
* @return Two lists, one containing locally available objects, one containing the rest.
*/
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns,
int timeoutMs) {
return runtime.wait(waitList, numReturns, timeoutMs);
}
/**
* A convenient helper method for Ray.wait. It will wait infinitely until
* specified number of objects are locally available.
*
* @param waitList A list of RayObject to wait for.
* @param numReturns The number of objects that should be returned.
* @return Two lists, one containing locally available objects, one containing the rest.
*/
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns) {
return runtime.wait(waitList, numReturns, Integer.MAX_VALUE);
}
/**
* A convenient helper method for Ray.wait. It will wait infinitely until
* all objects are locally available.
*
* @param waitList A list of RayObject to wait for.
* @return Two lists, one containing locally available objects, one containing the rest.
*/
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList) {
return runtime.wait(waitList, waitList.size(), Integer.MAX_VALUE);
}
/**
* If users want to use Ray API in their own threads, call this method to get the async context
* and then call {@link #setAsyncContext} at the beginning of the new thread.
*
* @return The async context.
*/
public static Object getAsyncContext() {
return runtime.getAsyncContext();
}
/**
* Set the async context for the current thread.
*
* @param asyncContext The async context to set.
*/
public static void setAsyncContext(Object asyncContext) {
runtime.setAsyncContext(asyncContext);
}
/**
* If users want to use Ray API in their own threads, they should wrap their {@link Runnable}
* objects with this method.
*
* @param runnable The runnable to wrap.
* @return The wrapped runnable.
*/
public static Runnable wrapRunnable(Runnable runnable) {
return runtime.wrapRunnable(runnable);
}
/**
* If users want to use Ray API in their own threads, they should wrap their {@link Callable}
* objects with this method.
*
* @param callable The callable to wrap.
* @return The wrapped callable.
*/
public static Callable wrapCallable(Callable callable) {
return runtime.wrapCallable(callable);
}
/**
* Get the underlying runtime instance.
*/
public static RayRuntime internal() {
return runtime;
}
/**
* Update the resource for the specified client.
* Set the resource for the specific node.
*/
public static void setResource(UniqueId nodeId, String resourceName, double capacity) {
runtime.setResource(resourceName, capacity, nodeId);
}
/**
* Set the resource for local node.
*/
public static void setResource(String resourceName, double capacity) {
runtime.setResource(resourceName, capacity, UniqueId.NIL);
}
/**
* Kill the actor immediately. This will cause any outstanding tasks submitted to the actor to
* fail and the actor to exit in the same way as if it crashed.
*
* @param actor The actor to be killed.
*/
public static void killActor(RayActor<?> actor) {
runtime.killActor(actor);
}
/**
* Get the runtime context.
*/
public static RuntimeContext getRuntimeContext() {
return runtime.getRuntimeContext();
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/RayActor.java | Java | package org.ray.api;
import org.ray.api.id.ActorId;
import org.ray.api.id.UniqueId;
/**
* A handle to an actor.
*
* @param <T> The type of the concrete actor class.
*/
public interface RayActor<T> {
/**
* @return The id of this actor.
*/
ActorId getId();
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/RayCall.java | Java | // generated automatically, do not modify.
package org.ray.api;
import org.ray.api.function.RayFunc0;
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.RayFuncVoid0;
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;
import org.ray.api.options.ActorCreationOptions;
import org.ray.api.options.CallOptions;
/**
* This class provides type-safe interfaces for `Ray.call` and `Ray.createActor`.
**/
@SuppressWarnings({"rawtypes", "unchecked"})
class RayCall {
// =======================================
// Methods for remote function invocation.
// =======================================
public static <R> RayObject<R> call(RayFunc0<R> f) {
Object[] args = new Object[]{};
return Ray.internal().call(f, args, null);
}
public static <R> RayObject<R> call(RayFunc0<R> f, CallOptions options) {
Object[] args = new Object[]{};
return Ray.internal().call(f, args, options);
}
public static void call(RayFuncVoid0 f) {
Object[] args = new Object[]{};
Ray.internal().call(f, args, null);
}
public static void call(RayFuncVoid0 f, CallOptions options) {
Object[] args = new Object[]{};
Ray.internal().call(f, args, options);
}
public static <T0, R> RayObject<R> call(RayFunc1<T0, R> f, T0 t0) {
Object[] args = new Object[]{t0};
return Ray.internal().call(f, args, null);
}
public static <T0, R> RayObject<R> call(RayFunc1<T0, R> f, RayObject<T0> t0) {
Object[] args = new Object[]{t0};
return Ray.internal().call(f, args, null);
}
public static <T0, R> RayObject<R> call(RayFunc1<T0, R> f, T0 t0, CallOptions options) {
Object[] args = new Object[]{t0};
return Ray.internal().call(f, args, options);
}
public static <T0, R> RayObject<R> call(RayFunc1<T0, R> f, RayObject<T0> t0, CallOptions options) {
Object[] args = new Object[]{t0};
return Ray.internal().call(f, args, options);
}
public static <T0> void call(RayFuncVoid1<T0> f, T0 t0) {
Object[] args = new Object[]{t0};
Ray.internal().call(f, args, null);
}
public static <T0> void call(RayFuncVoid1<T0> f, RayObject<T0> t0) {
Object[] args = new Object[]{t0};
Ray.internal().call(f, args, null);
}
public static <T0> void call(RayFuncVoid1<T0> f, T0 t0, CallOptions options) {
Object[] args = new Object[]{t0};
Ray.internal().call(f, args, options);
}
public static <T0> void call(RayFuncVoid1<T0> f, RayObject<T0> t0, CallOptions options) {
Object[] args = new Object[]{t0};
Ray.internal().call(f, args, options);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, T0 t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayObject<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayObject<T0> t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, T0 t0, T1 t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, T0 t0, RayObject<T1> t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayObject<T0> t0, T1 t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayObject<T0> t0, RayObject<T1> t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, args, options);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, null);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, T0 t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, null);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, RayObject<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, null);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, RayObject<T0> t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, null);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, T0 t0, T1 t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, options);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, T0 t0, RayObject<T1> t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, options);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, RayObject<T0> t0, T1 t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, options);
}
public static <T0, T1> void call(RayFuncVoid2<T0, T1> f, RayObject<T0> t0, RayObject<T1> t1, CallOptions options) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, T1 t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, T1 t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, T1 t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, RayObject<T1> t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, T1 t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2> void call(RayFuncVoid3<T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<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().call(f, args, null);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<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().call(f, args, null);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3> void call(RayFuncVoid4<T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<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().call(f, args, null);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4> void call(RayFuncVoid5<T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5> void call(RayFuncVoid6<T0, T1, T2, T3, T4, T5> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, CallOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
Ray.internal().call(f, args, options);
}
// ===========================================
// Methods for remote actor method invocation.
// ===========================================
public static <A, R> RayObject<R> call(RayFunc1<A, R> f, RayActor<A> actor) {
Object[] args = new Object[]{};
return Ray.internal().call(f, actor, args);
}
public static <A> void call(RayFuncVoid1<A> f, RayActor<A> actor) {
Object[] args = new Object[]{};
Ray.internal().call(f, actor, args);
}
public static <A, T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, RayActor<A> actor, T0 t0) {
Object[] args = new Object[]{t0};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, RayActor<A> actor, RayObject<T0> t0) {
Object[] args = new Object[]{t0};
return Ray.internal().call(f, actor, args);
}
public static <A, T0> void call(RayFuncVoid2<A, T0> f, RayActor<A> actor, T0 t0) {
Object[] args = new Object[]{t0};
Ray.internal().call(f, actor, args);
}
public static <A, T0> void call(RayFuncVoid2<A, T0> f, RayActor<A> actor, RayObject<T0> t0) {
Object[] args = new Object[]{t0};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayActor<A> actor, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayActor<A> actor, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayActor<A> actor, T0 t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayActor<A> actor, RayObject<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
Ray.internal().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, 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().call(f, actor, args);
}
public static <A, T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayActor<A> actor, 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().call(f, actor, args);
}
// ===========================
// Methods for actor creation.
// ===========================
public static <A> RayActor<A> createActor(RayFunc0<A> f) {
Object[] args = new Object[]{};
return Ray.internal().createActor(f, args, null);
}
public static <A> RayActor<A> createActor(RayFunc0<A> f, ActorCreationOptions options) {
Object[] args = new Object[]{};
return Ray.internal().createActor(f, args, options);
}
public static <T0, A> RayActor<A> createActor(RayFunc1<T0, A> f, T0 t0) {
Object[] args = new Object[]{t0};
return Ray.internal().createActor(f, args, null);
}
public static <T0, A> RayActor<A> createActor(RayFunc1<T0, A> f, RayObject<T0> t0) {
Object[] args = new Object[]{t0};
return Ray.internal().createActor(f, args, null);
}
public static <T0, A> RayActor<A> createActor(RayFunc1<T0, A> f, T0 t0, ActorCreationOptions options) {
Object[] args = new Object[]{t0};
return Ray.internal().createActor(f, args, options);
}
public static <T0, A> RayActor<A> createActor(RayFunc1<T0, A> f, RayObject<T0> t0, ActorCreationOptions options) {
Object[] args = new Object[]{t0};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, T0 t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, T0 t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, RayObject<T0> t0, T1 t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, RayObject<T0> t0, RayObject<T1> t1) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, T0 t0, T1 t1, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, T0 t0, RayObject<T1> t1, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, RayObject<T0> t0, T1 t1, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, A> RayActor<A> createActor(RayFunc2<T0, T1, A> f, RayObject<T0> t0, RayObject<T1> t1, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, T1 t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, T1 t1, T2 t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, T1 t1, RayObject<T2> t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, RayObject<T1> t1, T2 t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, T1 t1, T2 t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, A> RayActor<A> createActor(RayFunc3<T0, T1, T2, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, T2 t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, A> RayActor<A> createActor(RayFunc4<T0, T1, T2, T3, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> 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().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, A> RayActor<A> createActor(RayFunc5<T0, T1, T2, T3, T4, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, null);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
public static <T0, T1, T2, T3, T4, T5, A> RayActor<A> createActor(RayFunc6<T0, T1, T2, T3, T4, T5, A> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, ActorCreationOptions options) {
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
return Ray.internal().createActor(f, args, options);
}
// ===========================
// Cross-language methods.
// ===========================
public static RayObject callPy(String moduleName, String functionName) {
Object[] args = new Object[]{};
return Ray.internal().callPy(moduleName, functionName, args, null);
}
public static RayObject callPy(String moduleName, String functionName, CallOptions options) {
Object[] args = new Object[]{};
return Ray.internal().callPy(moduleName, functionName, args, options);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0) {
Object[] args = new Object[]{obj0};
return Ray.internal().callPy(moduleName, functionName, args, null);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, CallOptions options) {
Object[] args = new Object[]{obj0};
return Ray.internal().callPy(moduleName, functionName, args, options);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1) {
Object[] args = new Object[]{obj0, obj1};
return Ray.internal().callPy(moduleName, functionName, args, null);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, CallOptions options) {
Object[] args = new Object[]{obj0, obj1};
return Ray.internal().callPy(moduleName, functionName, args, options);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2) {
Object[] args = new Object[]{obj0, obj1, obj2};
return Ray.internal().callPy(moduleName, functionName, args, null);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2, CallOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2};
return Ray.internal().callPy(moduleName, functionName, args, options);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2, Object obj3) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3};
return Ray.internal().callPy(moduleName, functionName, args, null);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2, Object obj3, CallOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3};
return Ray.internal().callPy(moduleName, functionName, args, options);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4};
return Ray.internal().callPy(moduleName, functionName, args, null);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4, CallOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4};
return Ray.internal().callPy(moduleName, functionName, args, options);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4, Object obj5) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4, obj5};
return Ray.internal().callPy(moduleName, functionName, args, null);
}
public static RayObject callPy(String moduleName, String functionName, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4, Object obj5, CallOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4, obj5};
return Ray.internal().callPy(moduleName, functionName, args, options);
}
public static RayObject callPy(RayPyActor pyActor, String functionName) {
Object[] args = new Object[]{};
return Ray.internal().callPy(pyActor, functionName, args);
}
public static RayObject callPy(RayPyActor pyActor, String functionName, Object obj0) {
Object[] args = new Object[]{obj0};
return Ray.internal().callPy(pyActor, functionName, args);
}
public static RayObject callPy(RayPyActor pyActor, String functionName, Object obj0, Object obj1) {
Object[] args = new Object[]{obj0, obj1};
return Ray.internal().callPy(pyActor, functionName, args);
}
public static RayObject callPy(RayPyActor pyActor, String functionName, Object obj0, Object obj1, Object obj2) {
Object[] args = new Object[]{obj0, obj1, obj2};
return Ray.internal().callPy(pyActor, functionName, args);
}
public static RayObject callPy(RayPyActor pyActor, String functionName, Object obj0, Object obj1, Object obj2, Object obj3) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3};
return Ray.internal().callPy(pyActor, functionName, args);
}
public static RayObject callPy(RayPyActor pyActor, String functionName, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4};
return Ray.internal().callPy(pyActor, functionName, args);
}
public static RayPyActor createPyActor(String moduleName, String className) {
Object[] args = new Object[]{};
return Ray.internal().createPyActor(moduleName, className, args, null);
}
public static RayPyActor createPyActor(String moduleName, String className, ActorCreationOptions options) {
Object[] args = new Object[]{};
return Ray.internal().createPyActor(moduleName, className, args, options);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0) {
Object[] args = new Object[]{obj0};
return Ray.internal().createPyActor(moduleName, className, args, null);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, ActorCreationOptions options) {
Object[] args = new Object[]{obj0};
return Ray.internal().createPyActor(moduleName, className, args, options);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1) {
Object[] args = new Object[]{obj0, obj1};
return Ray.internal().createPyActor(moduleName, className, args, null);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, ActorCreationOptions options) {
Object[] args = new Object[]{obj0, obj1};
return Ray.internal().createPyActor(moduleName, className, args, options);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2) {
Object[] args = new Object[]{obj0, obj1, obj2};
return Ray.internal().createPyActor(moduleName, className, args, null);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2, ActorCreationOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2};
return Ray.internal().createPyActor(moduleName, className, args, options);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2, Object obj3) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3};
return Ray.internal().createPyActor(moduleName, className, args, null);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2, Object obj3, ActorCreationOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3};
return Ray.internal().createPyActor(moduleName, className, args, options);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4};
return Ray.internal().createPyActor(moduleName, className, args, null);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4, ActorCreationOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4};
return Ray.internal().createPyActor(moduleName, className, args, options);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4, Object obj5) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4, obj5};
return Ray.internal().createPyActor(moduleName, className, args, null);
}
public static RayPyActor createPyActor(String moduleName, String className, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4, Object obj5, ActorCreationOptions options) {
Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4, obj5};
return Ray.internal().createPyActor(moduleName, className, args, options);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/RayObject.java | Java | package org.ray.api;
import org.ray.api.id.ObjectId;
/**
* Represents an object in the object store.
* @param <T> The object type.
*/
public interface RayObject<T> {
/**
* Fetch the object from the object store, this method will block
* until the object is locally available.
*/
T get();
/**
* Get the object id.
*/
ObjectId getId();
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/RayPyActor.java | Java | package org.ray.api;
/**
* Handle of a Python actor.
*/
public interface RayPyActor extends RayActor {
/**
* @return Module name of the Python actor class.
*/
String getModuleName();
/**
* @return Name of the Python actor class.
*/
String getClassName();
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/WaitResult.java | Java | package org.ray.api;
import java.util.List;
/**
* Represents the result of a Ray.wait call. It contains 2 lists,
* one containing the locally available objects, one containing the rest.
*/
public final class WaitResult<T> {
private final List<RayObject<T>> ready;
private final List<RayObject<T>> unready;
public WaitResult(List<RayObject<T>> ready, List<RayObject<T>> unready) {
this.ready = ready;
this.unready = unready;
}
/**
* Get the list of ready objects.
*/
public List<RayObject<T>> getReady() {
return ready;
}
/**
* Get the list of unready objects.
*/
public List<RayObject<T>> getUnready() {
return unready;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/annotation/RayRemote.java | Java | 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 {
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/exception/RayActorException.java | Java | package org.ray.api.exception;
/**
* Indicates that the actor died unexpectedly before finishing a task.
*
* This exception could happen either because the actor process dies while executing a task, or
* because a task is submitted to a dead actor.
*/
public class RayActorException extends RayException {
public RayActorException() {
super("The actor died unexpectedly before finishing this task.");
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/exception/RayException.java | Java | package org.ray.api.exception;
/**
* Base class of all ray exceptions.
*/
public class RayException extends RuntimeException {
public RayException(String message) {
super(message);
}
public RayException(String message, Throwable cause) {
super(message, cause);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/exception/RayTaskException.java | Java | package org.ray.api.exception;
/**
* Indicates that a task threw an exception during execution.
*
* If a task throws an exception during execution, a RayTaskException is stored in the object store
* as the task's output. Then when the object is retrieved from the object store, this exception
* will be thrown and propagate the error message.
*/
public class RayTaskException extends RayException {
public RayTaskException(String message, Throwable cause) {
super(message, cause);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/exception/RayWorkerException.java | Java | package org.ray.api.exception;
/**
* Indicates that the worker died unexpectedly while executing a task.
*/
public class RayWorkerException extends RayException {
public RayWorkerException() {
super("The worker died unexpectedly while executing this task.");
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/exception/UnreconstructableException.java | Java | package org.ray.api.exception;
import org.ray.api.id.ObjectId;
/**
* Indicates that an object is lost (either evicted or explicitly deleted) and cannot be
* reconstructed.
*
* Note, this exception only happens for actor objects. If actor's current state is after object's
* creating task, the actor cannot re-run the task to reconstruct the object.
*/
public class UnreconstructableException extends RayException {
public final ObjectId objectId;
public UnreconstructableException(ObjectId objectId) {
super(String.format(
"Object %s is lost (either evicted or explicitly deleted) and cannot be reconstructed.",
objectId));
this.objectId = objectId;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc.java | Java | package org.ray.api.function;
import java.io.Serializable;
/**
* Interface of all Ray remote functions.
*/
public interface RayFunc extends Serializable {
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc0.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 0 parameter.
*/
@FunctionalInterface
public interface RayFunc0<R> extends RayFunc {
R apply() throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc1.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 1 parameter.
*/
@FunctionalInterface
public interface RayFunc1<T0, R> extends RayFunc {
R apply(T0 t0) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc2.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 2 parameters.
*/
@FunctionalInterface
public interface RayFunc2<T0, T1, R> extends RayFunc {
R apply(T0 t0, T1 t1) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc3.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 3 parameters.
*/
@FunctionalInterface
public interface RayFunc3<T0, T1, T2, R> extends RayFunc {
R apply(T0 t0, T1 t1, T2 t2) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc4.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 4 parameters.
*/
@FunctionalInterface
public interface RayFunc4<T0, T1, T2, T3, R> extends RayFunc {
R apply(T0 t0, T1 t1, T2 t2, T3 t3) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc5.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 5 parameters.
*/
@FunctionalInterface
public interface RayFunc5<T0, T1, T2, T3, T4, R> extends RayFunc {
R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFunc6.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 6 parameters.
*/
@FunctionalInterface
public interface RayFunc6<T0, T1, T2, T3, T4, T5, R> extends RayFunc {
R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid.java | Java | package org.ray.api.function;
/**
* Interface of all `RayFuncVoidX` classes.
*/
public interface RayFuncVoid extends RayFunc {
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid0.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 0 parameter.
*/
@FunctionalInterface
public interface RayFuncVoid0 extends RayFuncVoid {
void apply() throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid1.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 1 parameter.
*/
@FunctionalInterface
public interface RayFuncVoid1<T0> extends RayFuncVoid {
void apply(T0 t0) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid2.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 2 parameters.
*/
@FunctionalInterface
public interface RayFuncVoid2<T0, T1> extends RayFuncVoid {
void apply(T0 t0, T1 t1) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid3.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 3 parameters.
*/
@FunctionalInterface
public interface RayFuncVoid3<T0, T1, T2> extends RayFuncVoid {
void apply(T0 t0, T1 t1, T2 t2) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid4.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 4 parameters.
*/
@FunctionalInterface
public interface RayFuncVoid4<T0, T1, T2, T3> extends RayFuncVoid {
void apply(T0 t0, T1 t1, T2 t2, T3 t3) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid5.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 5 parameters.
*/
@FunctionalInterface
public interface RayFuncVoid5<T0, T1, T2, T3, T4> extends RayFuncVoid {
void apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/function/RayFuncVoid6.java | Java | // generated automatically, do not modify.
package org.ray.api.function;
/**
* Functional interface for a remote function that has 6 parameters.
*/
@FunctionalInterface
public interface RayFuncVoid6<T0, T1, T2, T3, T4, T5> extends RayFuncVoid {
void apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) throws Exception;
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/id/ActorId.java | Java | package org.ray.api.id;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Random;
public class ActorId extends BaseId implements Serializable {
private static final int UNIQUE_BYTES_LENGTH = 4;
public static final int LENGTH = JobId.LENGTH + UNIQUE_BYTES_LENGTH;
public static final ActorId NIL = nil();
private ActorId(byte[] id) {
super(id);
}
public static ActorId fromByteBuffer(ByteBuffer bb) {
return new ActorId(byteBuffer2Bytes(bb));
}
public static ActorId fromBytes(byte[] bytes) {
return new ActorId(bytes);
}
/**
* Generate a nil ActorId.
*/
private static ActorId nil() {
byte[] b = new byte[LENGTH];
Arrays.fill(b, (byte) 0xFF);
return new ActorId(b);
}
/**
* Generate an ActorId with random value. Used for local mode and test only.
*/
public static ActorId fromRandom() {
byte[] b = new byte[LENGTH];
new Random().nextBytes(b);
return new ActorId(b);
}
@Override
public int size() {
return LENGTH;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/id/BaseId.java | Java | package org.ray.api.id;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.Arrays;
import javax.xml.bind.DatatypeConverter;
public abstract class BaseId implements Serializable {
private static final long serialVersionUID = 8588849129675565761L;
private final byte[] id;
private int hashCodeCache = 0;
private Boolean isNilCache = null;
/**
* Create a BaseId instance according to the input byte array.
*/
protected BaseId(byte[] id) {
if (id.length != size()) {
throw new IllegalArgumentException("Failed to construct BaseId, expect " + size()
+ " bytes, but got " + id.length + " bytes.");
}
this.id = id;
}
/**
* Get the byte data of this id.
*/
public byte[] getBytes() {
return id;
}
/**
* Convert the byte data to a ByteBuffer.
*/
public ByteBuffer toByteBuffer() {
return ByteBuffer.wrap(id);
}
/**
* @return True if this id is nil.
*/
public boolean isNil() {
if (isNilCache == null) {
boolean localIsNil = true;
for (int i = 0; i < size(); ++i) {
if (id[i] != (byte) 0xff) {
localIsNil = false;
break;
}
}
isNilCache = localIsNil;
}
return isNilCache;
}
/**
* Derived class should implement this function.
* @return The length of this id in bytes.
*/
public abstract int size();
@Override
public int hashCode() {
// Lazy evaluation.
if (hashCodeCache == 0) {
hashCodeCache = Arrays.hashCode(id);
}
return hashCodeCache;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (!this.getClass().equals(obj.getClass())) {
return false;
}
BaseId r = (BaseId) obj;
return Arrays.equals(id, r.id);
}
@Override
public String toString() {
return DatatypeConverter.printHexBinary(id).toLowerCase();
}
protected static byte[] hexString2Bytes(String hex) {
return DatatypeConverter.parseHexBinary(hex);
}
protected static byte[] byteBuffer2Bytes(ByteBuffer bb) {
byte[] id = new byte[bb.remaining()];
bb.get(id);
return id;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/id/JobId.java | Java | package org.ray.api.id;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
/**
* Represents the id of a Ray job.
*/
public class JobId extends BaseId implements Serializable {
public static final int LENGTH = 2;
public static final JobId NIL = genNil();
/**
* Create a JobID instance according to the given bytes.
*/
private JobId(byte[] id) {
super(id);
}
/**
* Create a JobId from a given hex string.
*/
public static JobId fromHexString(String hex) {
return new JobId(hexString2Bytes(hex));
}
/**
* Creates a JobId from the given ByteBuffer.
*/
public static JobId fromByteBuffer(ByteBuffer bb) {
return new JobId(byteBuffer2Bytes(bb));
}
public static JobId fromInt(int value) {
if (value > Math.pow(256, JobId.LENGTH)) {
throw new IllegalArgumentException(
"The integer value is invalid for a JobId. Value: " + value);
}
byte[] bytes = new byte[Integer.BYTES];
ByteBuffer wbb = ByteBuffer.wrap(bytes);
wbb.order(ByteOrder.LITTLE_ENDIAN);
wbb.putInt(value);
wbb.flip();
wbb.limit(JobId.LENGTH);
return JobId.fromByteBuffer(wbb);
}
/**
* Generate a nil JobId.
*/
private static JobId genNil() {
byte[] b = new byte[LENGTH];
Arrays.fill(b, (byte) 0xFF);
return new JobId(b);
}
@Override
public int size() {
return LENGTH;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/id/ObjectId.java | Java | package org.ray.api.id;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Random;
/**
* Represents the id of a Ray object.
*/
public class ObjectId extends BaseId implements Serializable {
public static final int LENGTH = 20;
/**
* Create an ObjectId from a ByteBuffer.
*/
public static ObjectId fromByteBuffer(ByteBuffer bb) {
return new ObjectId(byteBuffer2Bytes(bb));
}
/**
* Generate an ObjectId with random value.
*/
public static ObjectId fromRandom() {
// This is tightly coupled with ObjectID definition in C++. If that changes,
// this must be changed as well.
// The following logic should be kept consistent with `ObjectID::FromRandom` in
// C++.
byte[] b = new byte[LENGTH];
new Random().nextBytes(b);
Arrays.fill(b, TaskId.LENGTH, LENGTH, (byte) 0);
return new ObjectId(b);
}
public ObjectId(byte[] id) {
super(id);
}
@Override
public int size() {
return LENGTH;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/id/TaskId.java | Java | package org.ray.api.id;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.Arrays;
/**
* Represents the id of a Ray task.
*/
public class TaskId extends BaseId implements Serializable {
private static final int UNIQUE_BYTES_LENGTH = 8;
public static final int LENGTH = ActorId.LENGTH + UNIQUE_BYTES_LENGTH;
public static final TaskId NIL = genNil();
/**
* Create a TaskId from a hex string.
*/
public static TaskId fromHexString(String hex) {
return new TaskId(hexString2Bytes(hex));
}
/**
* Creates a TaskId from a ByteBuffer.
*/
public static TaskId fromByteBuffer(ByteBuffer bb) {
return new TaskId(byteBuffer2Bytes(bb));
}
/**
* Creates a TaskId from given bytes.
*/
public static TaskId fromBytes(byte[] bytes) {
return new TaskId(bytes);
}
/**
* Generate a nil TaskId.
*/
private static TaskId genNil() {
byte[] b = new byte[LENGTH];
Arrays.fill(b, (byte) 0xFF);
return new TaskId(b);
}
private TaskId(byte[] id) {
super(id);
}
@Override
public int size() {
return LENGTH;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/id/UniqueId.java | Java | package org.ray.api.id;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Random;
/**
* Represents a unique id of all Ray concepts, including
* workers, actors, checkpoints, etc.
*/
public class UniqueId extends BaseId implements Serializable {
public static final int LENGTH = 20;
public static final UniqueId NIL = genNil();
/**
* Create a UniqueId from a hex string.
*/
public static UniqueId fromHexString(String hex) {
return new UniqueId(hexString2Bytes(hex));
}
/**
* Creates a UniqueId from a ByteBuffer.
*/
public static UniqueId fromByteBuffer(ByteBuffer bb) {
return new UniqueId(byteBuffer2Bytes(bb));
}
/**
* Generate a nil UniqueId.
*/
private static UniqueId genNil() {
byte[] b = new byte[LENGTH];
Arrays.fill(b, (byte) 0xFF);
return new UniqueId(b);
}
/**
* Generate an UniqueId with random value.
*/
public static UniqueId randomId() {
byte[] b = new byte[LENGTH];
new Random().nextBytes(b);
return new UniqueId(b);
}
public UniqueId(byte[] id) {
super(id);
}
@Override
public int size() {
return LENGTH;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/options/ActorCreationOptions.java | Java | package org.ray.api.options;
import java.util.HashMap;
import java.util.Map;
/**
* The options for creating actor.
*/
public class ActorCreationOptions extends BaseTaskOptions {
public static final int NO_RECONSTRUCTION = 0;
public static final int INFINITE_RECONSTRUCTION = (int) Math.pow(2, 30);
// DO NOT set this environment variable. It's only used for test purposes.
// Please use `setUseDirectCall` instead.
public static final boolean DEFAULT_USE_DIRECT_CALL = "1"
.equals(System.getenv("ACTOR_CREATION_OPTIONS_DEFAULT_USE_DIRECT_CALL"));
public final int maxReconstructions;
public final boolean useDirectCall;
public final String jvmOptions;
private ActorCreationOptions(Map<String, Double> resources, int maxReconstructions,
boolean useDirectCall, String jvmOptions) {
super(resources);
this.maxReconstructions = maxReconstructions;
this.useDirectCall = useDirectCall;
this.jvmOptions = jvmOptions;
}
/**
* The inner class for building ActorCreationOptions.
*/
public static class Builder {
private Map<String, Double> resources = new HashMap<>();
private int maxReconstructions = NO_RECONSTRUCTION;
private boolean useDirectCall = DEFAULT_USE_DIRECT_CALL;
private String jvmOptions = null;
public Builder setResources(Map<String, Double> resources) {
this.resources = resources;
return this;
}
public Builder setMaxReconstructions(int maxReconstructions) {
this.maxReconstructions = maxReconstructions;
return this;
}
// Since direct call is not fully supported yet (see issue #5559),
// users are not allowed to set the option to true.
// TODO (kfstorm): uncomment when direct call is ready.
// public Builder setUseDirectCall(boolean useDirectCall) {
// this.useDirectCall = useDirectCall;
// return this;
// }
public Builder setJvmOptions(String jvmOptions) {
this.jvmOptions = jvmOptions;
return this;
}
public ActorCreationOptions createActorCreationOptions() {
return new ActorCreationOptions(resources, maxReconstructions, useDirectCall, jvmOptions);
}
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/options/BaseTaskOptions.java | Java | package org.ray.api.options;
import java.util.HashMap;
import java.util.Map;
/**
* The options class for RayCall or ActorCreation.
*/
public abstract class BaseTaskOptions {
public final Map<String, Double> resources;
public BaseTaskOptions() {
resources = new HashMap<>();
}
public BaseTaskOptions(Map<String, Double> resources) {
for (Map.Entry<String, Double> entry : resources.entrySet()) {
if (entry.getValue().compareTo(0.0) <= 0) {
throw new IllegalArgumentException(String.format("Resource capacity should be " +
"positive, but got resource %s = %f.", entry.getKey(), entry.getValue()));
}
}
this.resources = resources;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/options/CallOptions.java | Java | package org.ray.api.options;
import java.util.HashMap;
import java.util.Map;
/**
* The options for RayCall.
*/
public class CallOptions extends BaseTaskOptions {
private CallOptions(Map<String, Double> resources) {
super(resources);
}
/**
* This inner class for building CallOptions.
*/
public static class Builder {
private Map<String, Double> resources = new HashMap<>();
public Builder setResources(Map<String, Double> resources) {
this.resources = resources;
return this;
}
public CallOptions createCallOptions() {
return new CallOptions(resources);
}
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/runtime/RayRuntime.java | Java | package org.ray.api.runtime;
import java.util.List;
import java.util.concurrent.Callable;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.RayPyActor;
import org.ray.api.WaitResult;
import org.ray.api.function.RayFunc;
import org.ray.api.id.ObjectId;
import org.ray.api.id.UniqueId;
import org.ray.api.options.ActorCreationOptions;
import org.ray.api.options.CallOptions;
import org.ray.api.runtimecontext.RuntimeContext;
/**
* Base interface of a Ray runtime.
*/
public interface RayRuntime {
/**
* Shutdown the runtime.
*/
void shutdown();
/**
* Store an object in the object store.
*
* @param obj The Java object to be stored.
* @return A RayObject instance that represents the in-store object.
*/
<T> RayObject<T> put(T obj);
/**
* Get an object from the object store.
*
* @param objectId The ID of the object to get.
* @return The Java object.
*/
<T> T get(ObjectId objectId);
/**
* Get a list of objects from the object store.
*
* @param objectIds The list of object IDs.
* @return A list of Java objects.
*/
<T> List<T> get(List<ObjectId> objectIds);
/**
* Wait for a list of RayObjects to be locally available, until specified number of objects are
* ready, or specified timeout has passed.
*
* @param waitList A list of RayObject to wait for.
* @param numReturns The number of objects that should be returned.
* @param timeoutMs The maximum time in milliseconds to wait before returning.
* @return Two lists, one containing locally available objects, one containing the rest.
*/
<T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs);
/**
* Free a list of objects from Plasma Store.
*
* @param objectIds The object ids to free.
* @param localOnly Whether only free objects for local object store or not.
* @param deleteCreatingTasks Whether also delete objects' creating tasks from GCS.
*/
void free(List<ObjectId> objectIds, boolean localOnly, boolean deleteCreatingTasks);
/**
* Set the resource for the specific node.
*
* @param resourceName The name of resource.
* @param capacity The capacity of the resource.
* @param nodeId The node that we want to set its resource.
*/
void setResource(String resourceName, double capacity, UniqueId nodeId);
/**
* Kill the actor immediately.
*
* @param actor The actor to be killed.
*/
void killActor(RayActor<?> actor);
/**
* Invoke a remote function.
*
* @param func The remote function to run.
* @param args The arguments of the remote function.
* @param options The options for this call.
* @return The result object.
*/
RayObject call(RayFunc func, Object[] args, CallOptions options);
/**
* Invoke a remote function on an actor.
*
* @param func The remote function to run, it must be a method of the given actor.
* @param actor A handle to the actor.
* @param args The arguments of the remote function.
* @return The result object.
*/
RayObject call(RayFunc func, RayActor<?> actor, Object[] args);
/**
* Create an actor on a remote node.
*
* @param actorFactoryFunc A remote function whose return value is the actor object.
* @param args The arguments for the remote function.
* @param <T> The type of the actor object.
* @param options The options for creating actor.
* @return A handle to the actor.
*/
<T> RayActor<T> createActor(RayFunc actorFactoryFunc, Object[] args,
ActorCreationOptions options);
RuntimeContext getRuntimeContext();
/**
* Invoke a remote Python function.
*
* @param moduleName Module name of the Python function.
* @param functionName Name of the Python function.
* @param args Arguments of the function.
* @param options The options for this call.
* @return The result object.
*/
RayObject callPy(String moduleName, String functionName, Object[] args, CallOptions options);
/**
* Invoke a remote Python function on an actor.
*
* @param pyActor A handle to the actor.
* @param functionName Name of the actor method.
* @param args Arguments of the function.
* @return The result object.
*/
RayObject callPy(RayPyActor pyActor, String functionName, Object[] args);
/**
* Create a Python actor on a remote node.
*
* @param moduleName Module name of the Python actor class.
* @param className Name of the Python actor class.
* @param args Arguments of the actor constructor.
* @param options The options for creating actor.
* @return A handle to the actor.
*/
RayPyActor createPyActor(String moduleName, String className, Object[] args,
ActorCreationOptions options);
Object getAsyncContext();
void setAsyncContext(Object asyncContext);
/**
* Wrap a {@link Runnable} with necessary context capture.
* @param runnable The runnable to wrap.
* @return The wrapped runnable.
*/
Runnable wrapRunnable(Runnable runnable);
/**
* Wrap a {@link Callable} with necessary context capture.
* @param callable The callable to wrap.
* @return The wrapped callable.
*/
Callable wrapCallable(Callable callable);
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/runtime/RayRuntimeFactory.java | Java | package org.ray.api.runtime;
/**
* A factory that produces a RayRuntime instance.
*/
public interface RayRuntimeFactory {
RayRuntime createRayRuntime();
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/runtimecontext/NodeInfo.java | Java | package org.ray.api.runtimecontext;
import java.util.Map;
import org.ray.api.id.UniqueId;
/**
* A class that represents the information of a node.
*/
public class NodeInfo {
public final UniqueId nodeId;
public final String nodeAddress;
public final String nodeHostname;
public final boolean isAlive;
public final Map<String, Double> resources;
public NodeInfo(UniqueId nodeId, String nodeAddress, String nodeHostname,
boolean isAlive, Map<String, Double> resources) {
this.nodeId = nodeId;
this.nodeAddress = nodeAddress;
this.nodeHostname = nodeHostname;
this.isAlive = isAlive;
this.resources = resources;
}
public String toString() {
return "NodeInfo{"
+ "nodeId='" + nodeId + '\''
+ ", nodeAddress='" + nodeAddress + "\'"
+ ", nodeHostname'" + nodeHostname + "\'"
+ ", isAlive=" + isAlive
+ ", resources=" + resources
+ "}";
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/api/src/main/java/org/ray/api/runtimecontext/RuntimeContext.java | Java | package org.ray.api.runtimecontext;
import java.util.List;
import org.ray.api.id.ActorId;
import org.ray.api.id.JobId;
/**
* A class used for getting information of Ray runtime.
*/
public interface RuntimeContext {
/**
* Get the current Job ID.
*/
JobId getCurrentJobId();
/**
* Get the current actor ID.
*
* Note, this can only be called in actors.
*/
ActorId getCurrentActorId();
/**
* Returns true if the current actor was reconstructed, false if it's created for the first time.
*
* Note, this method should only be called from an actor creation task.
*/
boolean wasCurrentActorReconstructed();
/**
* Get the raylet socket name.
*/
String getRayletSocketName();
/**
* Get the object store socket name.
*/
String getObjectStoreSocketName();
/**
* Return true if Ray is running in single-process mode, false if Ray is running in cluster mode.
*/
boolean isSingleProcess();
/**
* Get all node information in Ray cluster.
*/
List<NodeInfo> getAllNodeInfo();
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/cleanup.sh | Shell | # Stop backend processes
ray stop
# Kill Java workers
ps aux | grep DefaultWorker | grep -v grep | awk '{print $2}' | xargs kill -9
# Remove temp files
rm -rf /tmp/ray
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/modify_generated_java_flatbuffers_files.py | Python | import os
import sys
"""
This script is used for modifying the generated java flatbuffer
files for the reason: The package declaration in Java is different
from python and C++, and there is no option in the flatc command
to specify package(namepsace) for Java specially.
USAGE:
python modify_generated_java_flatbuffers_file.py RAY_HOME
RAY_HOME: The root directory of Ray project.
"""
# constants declarations
PACKAGE_DECLARATION = "package org.ray.runtime.generated;"
def add_package(file):
with open(file, "r") as file_handler:
lines = file_handler.readlines()
if "FlatBuffers" not in lines[0]:
return
lines.insert(1, PACKAGE_DECLARATION + os.linesep)
with open(file, "w") as file_handler:
for line in lines:
file_handler.write(line)
def add_package_declarations(generated_root_path):
file_names = os.listdir(generated_root_path)
for file_name in file_names:
if not file_name.endswith(".java"):
continue
full_name = os.path.join(generated_root_path, file_name)
add_package(full_name)
if __name__ == "__main__":
ray_home = sys.argv[1]
root_path = os.path.join(
ray_home, "java/runtime/src/main/java/org/ray/runtime/generated")
add_package_declarations(root_path)
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/AbstractRayRuntime.java | Java | package org.ray.runtime;
import java.util.List;
import java.util.concurrent.Callable;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.RayPyActor;
import org.ray.api.WaitResult;
import org.ray.api.exception.RayException;
import org.ray.api.function.RayFunc;
import org.ray.api.function.RayFuncVoid;
import org.ray.api.id.ObjectId;
import org.ray.api.options.ActorCreationOptions;
import org.ray.api.options.CallOptions;
import org.ray.api.runtime.RayRuntime;
import org.ray.api.runtimecontext.RuntimeContext;
import org.ray.runtime.actor.NativeRayActor;
import org.ray.runtime.config.RayConfig;
import org.ray.runtime.context.RuntimeContextImpl;
import org.ray.runtime.context.WorkerContext;
import org.ray.runtime.functionmanager.FunctionDescriptor;
import org.ray.runtime.functionmanager.FunctionManager;
import org.ray.runtime.functionmanager.PyFunctionDescriptor;
import org.ray.runtime.gcs.GcsClient;
import org.ray.runtime.generated.Common.Language;
import org.ray.runtime.object.ObjectStore;
import org.ray.runtime.object.RayObjectImpl;
import org.ray.runtime.task.ArgumentsBuilder;
import org.ray.runtime.task.FunctionArg;
import org.ray.runtime.task.TaskExecutor;
import org.ray.runtime.task.TaskSubmitter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Core functionality to implement Ray APIs.
*/
public abstract class AbstractRayRuntime implements RayRuntime {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstractRayRuntime.class);
public static final String PYTHON_INIT_METHOD_NAME = "__init__";
protected RayConfig rayConfig;
protected TaskExecutor taskExecutor;
protected FunctionManager functionManager;
protected RuntimeContext runtimeContext;
protected GcsClient gcsClient;
protected ObjectStore objectStore;
protected TaskSubmitter taskSubmitter;
protected WorkerContext workerContext;
public AbstractRayRuntime(RayConfig rayConfig, FunctionManager functionManager) {
this.rayConfig = rayConfig;
this.functionManager = functionManager;
runtimeContext = new RuntimeContextImpl(this);
}
@Override
public abstract void shutdown();
@Override
public <T> RayObject<T> put(T obj) {
ObjectId objectId = objectStore.put(obj);
return new RayObjectImpl<>(objectId);
}
@Override
public <T> T get(ObjectId objectId) throws RayException {
List<T> ret = get(ImmutableList.of(objectId));
return ret.get(0);
}
@Override
public <T> List<T> get(List<ObjectId> objectIds) {
return objectStore.get(objectIds);
}
@Override
public void free(List<ObjectId> objectIds, boolean localOnly, boolean deleteCreatingTasks) {
objectStore.delete(objectIds, localOnly, deleteCreatingTasks);
}
@Override
public <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs) {
return objectStore.wait(waitList, numReturns, timeoutMs);
}
@Override
public RayObject call(RayFunc func, Object[] args, CallOptions options) {
FunctionDescriptor functionDescriptor =
functionManager.getFunction(workerContext.getCurrentJobId(), func)
.functionDescriptor;
int numReturns = func instanceof RayFuncVoid ? 0 : 1;
return callNormalFunction(functionDescriptor, args, numReturns, options);
}
@Override
public RayObject call(RayFunc func, RayActor<?> actor, Object[] args) {
FunctionDescriptor functionDescriptor =
functionManager.getFunction(workerContext.getCurrentJobId(), func)
.functionDescriptor;
int numReturns = func instanceof RayFuncVoid ? 0 : 1;
return callActorFunction(actor, functionDescriptor, args, numReturns);
}
@Override
@SuppressWarnings("unchecked")
public <T> RayActor<T> createActor(RayFunc actorFactoryFunc,
Object[] args, ActorCreationOptions options) {
FunctionDescriptor functionDescriptor =
functionManager.getFunction(workerContext.getCurrentJobId(), actorFactoryFunc)
.functionDescriptor;
return (RayActor<T>) createActorImpl(functionDescriptor, args, options);
}
private void checkPyArguments(Object[] args) {
for (Object arg : args) {
Preconditions.checkArgument(
(arg instanceof RayPyActor) || (arg instanceof byte[]),
"Python argument can only be a RayPyActor or a byte array, not {}.",
arg.getClass().getName());
}
}
@Override
public RayObject callPy(String moduleName, String functionName, Object[] args,
CallOptions options) {
checkPyArguments(args);
PyFunctionDescriptor functionDescriptor = new PyFunctionDescriptor(moduleName, "",
functionName);
// Python functions always have a return value, even if it's `None`.
return callNormalFunction(functionDescriptor, args, /*numReturns=*/1, options);
}
@Override
public RayObject callPy(RayPyActor pyActor, String functionName, Object... args) {
checkPyArguments(args);
PyFunctionDescriptor functionDescriptor = new PyFunctionDescriptor(pyActor.getModuleName(),
pyActor.getClassName(), functionName);
// Python functions always have a return value, even if it's `None`.
return callActorFunction(pyActor, functionDescriptor, args, /*numReturns=*/1);
}
@Override
public RayPyActor createPyActor(String moduleName, String className, Object[] args,
ActorCreationOptions options) {
checkPyArguments(args);
PyFunctionDescriptor functionDescriptor = new PyFunctionDescriptor(moduleName, className,
PYTHON_INIT_METHOD_NAME);
return (RayPyActor) createActorImpl(functionDescriptor, args, options);
}
@Override
public Runnable wrapRunnable(Runnable runnable) {
return runnable;
}
@Override
public Callable wrapCallable(Callable callable) {
return callable;
}
private RayObject callNormalFunction(FunctionDescriptor functionDescriptor,
Object[] args, int numReturns, CallOptions options) {
List<FunctionArg> functionArgs = ArgumentsBuilder
.wrap(args, functionDescriptor.getLanguage(), /*isDirectCall*/false);
List<ObjectId> returnIds = taskSubmitter.submitTask(functionDescriptor,
functionArgs, numReturns, options);
Preconditions.checkState(returnIds.size() == numReturns && returnIds.size() <= 1);
if (returnIds.isEmpty()) {
return null;
} else {
return new RayObjectImpl(returnIds.get(0));
}
}
private RayObject callActorFunction(RayActor rayActor,
FunctionDescriptor functionDescriptor, Object[] args, int numReturns) {
List<FunctionArg> functionArgs = ArgumentsBuilder
.wrap(args, functionDescriptor.getLanguage(), isDirectCall(rayActor));
List<ObjectId> returnIds = taskSubmitter.submitActorTask(rayActor,
functionDescriptor, functionArgs, numReturns, null);
Preconditions.checkState(returnIds.size() == numReturns && returnIds.size() <= 1);
if (returnIds.isEmpty()) {
return null;
} else {
return new RayObjectImpl(returnIds.get(0));
}
}
private RayActor createActorImpl(FunctionDescriptor functionDescriptor,
Object[] args, ActorCreationOptions options) {
List<FunctionArg> functionArgs = ArgumentsBuilder
.wrap(args, functionDescriptor.getLanguage(), /*isDirectCall*/false);
if (functionDescriptor.getLanguage() != Language.JAVA && options != null) {
Preconditions.checkState(Strings.isNullOrEmpty(options.jvmOptions));
}
RayActor actor = taskSubmitter.createActor(functionDescriptor, functionArgs, options);
return actor;
}
private boolean isDirectCall(RayActor rayActor) {
if (rayActor instanceof NativeRayActor) {
return ((NativeRayActor) rayActor).isDirectCallActor();
}
return false;
}
public WorkerContext getWorkerContext() {
return workerContext;
}
public ObjectStore getObjectStore() {
return objectStore;
}
public FunctionManager getFunctionManager() {
return functionManager;
}
public RayConfig getRayConfig() {
return rayConfig;
}
public RuntimeContext getRuntimeContext() {
return runtimeContext;
}
public GcsClient getGcsClient() {
return gcsClient;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/DefaultRayRuntimeFactory.java | Java | package org.ray.runtime;
import org.ray.api.runtime.RayRuntime;
import org.ray.api.runtime.RayRuntimeFactory;
import org.ray.runtime.config.RayConfig;
import org.ray.runtime.config.RunMode;
import org.ray.runtime.functionmanager.FunctionManager;
import org.ray.runtime.generated.Common.WorkerType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* The default Ray runtime factory. It produces an instance of RayRuntime.
*/
public class DefaultRayRuntimeFactory implements RayRuntimeFactory {
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultRayRuntimeFactory.class);
@Override
public RayRuntime createRayRuntime() {
RayConfig rayConfig = RayConfig.create();
try {
FunctionManager functionManager = new FunctionManager(rayConfig.jobResourcePath);
RayRuntime runtime;
if (rayConfig.runMode == RunMode.SINGLE_PROCESS) {
runtime = new RayDevRuntime(rayConfig, functionManager);
} else {
if (rayConfig.workerMode == WorkerType.DRIVER) {
runtime = new RayNativeRuntime(rayConfig, functionManager);
} else {
runtime = new RayMultiWorkerNativeRuntime(rayConfig, functionManager);
}
}
return runtime;
} catch (Exception e) {
LOGGER.error("Failed to initialize ray runtime", e);
throw new RuntimeException("Failed to initialize ray runtime", e);
}
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/RayDevRuntime.java | Java | package org.ray.runtime;
import java.util.concurrent.atomic.AtomicInteger;
import org.ray.api.RayActor;
import org.ray.api.id.JobId;
import org.ray.api.id.UniqueId;
import org.ray.runtime.config.RayConfig;
import org.ray.runtime.context.LocalModeWorkerContext;
import org.ray.runtime.functionmanager.FunctionManager;
import org.ray.runtime.object.LocalModeObjectStore;
import org.ray.runtime.task.LocalModeTaskExecutor;
import org.ray.runtime.task.LocalModeTaskSubmitter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class RayDevRuntime extends AbstractRayRuntime {
private static final Logger LOGGER = LoggerFactory.getLogger(RayDevRuntime.class);
private AtomicInteger jobCounter = new AtomicInteger(0);
public RayDevRuntime(RayConfig rayConfig, FunctionManager functionManager) {
super(rayConfig, functionManager);
if (rayConfig.getJobId().isNil()) {
rayConfig.setJobId(nextJobId());
}
taskExecutor = new LocalModeTaskExecutor(this);
workerContext = new LocalModeWorkerContext(rayConfig.getJobId());
objectStore = new LocalModeObjectStore(workerContext);
taskSubmitter = new LocalModeTaskSubmitter(this, (LocalModeObjectStore) objectStore,
rayConfig.numberExecThreadsForDevRuntime);
((LocalModeObjectStore) objectStore).addObjectPutCallback(
objectId -> ((LocalModeTaskSubmitter) taskSubmitter).onObjectPut(objectId));
}
@Override
public void shutdown() {
if (taskSubmitter != null) {
((LocalModeTaskSubmitter) taskSubmitter).shutdown();
taskSubmitter = null;
}
taskExecutor = null;
}
@Override
public void setResource(String resourceName, double capacity, UniqueId nodeId) {
LOGGER.error("Not implemented under SINGLE_PROCESS mode.");
}
@Override
public void killActor(RayActor<?> actor) {
throw new UnsupportedOperationException();
}
@Override
public Object getAsyncContext() {
return null;
}
@Override
public void setAsyncContext(Object asyncContext) {
}
private JobId nextJobId() {
return JobId.fromInt(jobCounter.getAndIncrement());
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/RayMultiWorkerNativeRuntime.java | Java | package org.ray.runtime;
import java.util.List;
import java.util.concurrent.Callable;
import com.google.common.base.Preconditions;
import org.ray.api.RayActor;
import org.ray.api.RayObject;
import org.ray.api.RayPyActor;
import org.ray.api.WaitResult;
import org.ray.api.function.RayFunc;
import org.ray.api.id.ObjectId;
import org.ray.api.id.UniqueId;
import org.ray.api.options.ActorCreationOptions;
import org.ray.api.options.CallOptions;
import org.ray.api.runtime.RayRuntime;
import org.ray.api.runtimecontext.RuntimeContext;
import org.ray.runtime.config.RayConfig;
import org.ray.runtime.config.RunMode;
import org.ray.runtime.functionmanager.FunctionManager;
import org.ray.runtime.generated.Common.WorkerType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* This is a proxy runtime for multi-worker support. It holds multiple {@link RayNativeRuntime}
* instances and redirect calls to the correct one based on thread context.
*/
public class RayMultiWorkerNativeRuntime implements RayRuntime {
private static final Logger LOGGER = LoggerFactory.getLogger(RayMultiWorkerNativeRuntime.class);
private final FunctionManager functionManager;
/**
* The number of workers per worker process.
*/
private final int numWorkers;
/**
* The worker threads.
*/
private final Thread[] threads;
/**
* The {@link RayNativeRuntime} instances of workers.
*/
private final RayNativeRuntime[] runtimes;
/**
* The {@link RayNativeRuntime} instance of current thread.
*/
private final ThreadLocal<RayNativeRuntime> currentThreadRuntime = new ThreadLocal<>();
public RayMultiWorkerNativeRuntime(RayConfig rayConfig, FunctionManager functionManager) {
this.functionManager = functionManager;
Preconditions.checkState(
rayConfig.runMode == RunMode.CLUSTER && rayConfig.workerMode == WorkerType.WORKER);
Preconditions.checkState(rayConfig.numWorkersPerProcess > 0,
"numWorkersPerProcess must be greater than 0.");
numWorkers = rayConfig.numWorkersPerProcess;
runtimes = new RayNativeRuntime[numWorkers];
threads = new Thread[numWorkers];
LOGGER.info("Starting {} workers.", numWorkers);
for (int i = 0; i < numWorkers; i++) {
final int workerIndex = i;
threads[i] = new Thread(() -> {
RayNativeRuntime runtime = new RayNativeRuntime(rayConfig, functionManager);
runtimes[workerIndex] = runtime;
currentThreadRuntime.set(runtime);
runtime.run();
});
}
}
public void run() {
for (int i = 0; i < numWorkers; i++) {
threads[i].start();
}
for (int i = 0; i < numWorkers; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
@Override
public void shutdown() {
for (int i = 0; i < numWorkers; i++) {
runtimes[i].shutdown();
}
for (int i = 0; i < numWorkers; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public RayNativeRuntime getCurrentRuntime() {
RayNativeRuntime currentRuntime = currentThreadRuntime.get();
Preconditions.checkNotNull(currentRuntime,
"RayRuntime is not set on current thread."
+ " If you want to use Ray API in your own threads,"
+ " please wrap your `Runnable`s or `Callable`s with"
+ " `Ray.wrapRunnable` or `Ray.wrapCallable`.");
return currentRuntime;
}
@Override
public <T> RayObject<T> put(T obj) {
return getCurrentRuntime().put(obj);
}
@Override
public <T> T get(ObjectId objectId) {
return getCurrentRuntime().get(objectId);
}
@Override
public <T> List<T> get(List<ObjectId> objectIds) {
return getCurrentRuntime().get(objectIds);
}
@Override
public <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs) {
return getCurrentRuntime().wait(waitList, numReturns, timeoutMs);
}
@Override
public void free(List<ObjectId> objectIds, boolean localOnly, boolean deleteCreatingTasks) {
getCurrentRuntime().free(objectIds, localOnly, deleteCreatingTasks);
}
@Override
public void setResource(String resourceName, double capacity, UniqueId nodeId) {
getCurrentRuntime().setResource(resourceName, capacity, nodeId);
}
@Override
public void killActor(RayActor<?> actor) {
getCurrentRuntime().killActor(actor);
}
@Override
public RayObject call(RayFunc func, Object[] args, CallOptions options) {
return getCurrentRuntime().call(func, args, options);
}
@Override
public RayObject call(RayFunc func, RayActor<?> actor, Object[] args) {
return getCurrentRuntime().call(func, actor, args);
}
@Override
public <T> RayActor<T> createActor(RayFunc actorFactoryFunc, Object[] args,
ActorCreationOptions options) {
return getCurrentRuntime().createActor(actorFactoryFunc, args, options);
}
@Override
public RuntimeContext getRuntimeContext() {
return getCurrentRuntime().getRuntimeContext();
}
@Override
public RayObject callPy(String moduleName, String functionName, Object[] args,
CallOptions options) {
return getCurrentRuntime().callPy(moduleName, functionName, args, options);
}
@Override
public RayObject callPy(RayPyActor pyActor, String functionName, Object[] args) {
return getCurrentRuntime().callPy(pyActor, functionName, args);
}
@Override
public RayPyActor createPyActor(String moduleName, String className, Object[] args,
ActorCreationOptions options) {
return getCurrentRuntime().createPyActor(moduleName, className, args, options);
}
@Override
public Object getAsyncContext() {
return getCurrentRuntime();
}
@Override
public void setAsyncContext(Object asyncContext) {
currentThreadRuntime.set((RayNativeRuntime)asyncContext);
}
@Override
public Runnable wrapRunnable(Runnable runnable) {
Object asyncContext = getAsyncContext();
return () -> {
setAsyncContext(asyncContext);
runnable.run();
};
}
@Override
public Callable wrapCallable(Callable callable) {
Object asyncContext = getAsyncContext();
return () -> {
setAsyncContext(asyncContext);
return callable.call();
};
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/RayNativeRuntime.java | Java | package org.ray.runtime;
import com.google.common.base.Preconditions;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.ray.api.RayActor;
import org.ray.api.id.JobId;
import org.ray.api.id.UniqueId;
import org.ray.runtime.actor.NativeRayActor;
import org.ray.runtime.config.RayConfig;
import org.ray.runtime.context.NativeWorkerContext;
import org.ray.runtime.functionmanager.FunctionManager;
import org.ray.runtime.gcs.GcsClient;
import org.ray.runtime.gcs.GcsClientOptions;
import org.ray.runtime.gcs.RedisClient;
import org.ray.runtime.generated.Common.WorkerType;
import org.ray.runtime.object.NativeObjectStore;
import org.ray.runtime.runner.RunManager;
import org.ray.runtime.task.NativeTaskExecutor;
import org.ray.runtime.task.NativeTaskSubmitter;
import org.ray.runtime.task.TaskExecutor;
import org.ray.runtime.util.JniUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Native runtime for cluster mode.
*/
public final class RayNativeRuntime extends AbstractRayRuntime {
private static final Logger LOGGER = LoggerFactory.getLogger(RayNativeRuntime.class);
private RunManager manager = null;
/**
* The native pointer of core worker.
*/
private long nativeCoreWorkerPointer;
static {
LOGGER.debug("Loading native libraries.");
// Expose ray ABI symbols which may be depended by other shared
// libraries such as libstreaming_java.so.
// See BUILD.bazel:libcore_worker_library_java.so
JniUtils.loadLibrary("core_worker_library_java", true);
LOGGER.debug("Native libraries loaded.");
RayConfig globalRayConfig = RayConfig.create();
resetLibraryPath(globalRayConfig);
try {
FileUtils.forceMkdir(new File(globalRayConfig.logDir));
} catch (IOException e) {
throw new RuntimeException("Failed to create the log directory.", e);
}
nativeSetup(globalRayConfig.logDir);
Runtime.getRuntime().addShutdownHook(new Thread(RayNativeRuntime::nativeShutdownHook));
}
private static void resetLibraryPath(RayConfig rayConfig) {
String separator = System.getProperty("path.separator");
String libraryPath = String.join(separator, rayConfig.libraryPath);
JniUtils.resetLibraryPath(libraryPath);
}
public RayNativeRuntime(RayConfig rayConfig, FunctionManager functionManager) {
super(rayConfig, functionManager);
// Reset library path at runtime.
resetLibraryPath(rayConfig);
if (rayConfig.getRedisAddress() == null) {
manager = new RunManager(rayConfig);
manager.startRayProcesses(true);
}
gcsClient = new GcsClient(rayConfig.getRedisAddress(), rayConfig.redisPassword);
if (rayConfig.getJobId() == JobId.NIL) {
rayConfig.setJobId(gcsClient.nextJobId());
}
// TODO(qwang): Get object_store_socket_name and raylet_socket_name from Redis.
nativeCoreWorkerPointer = nativeInitCoreWorker(rayConfig.workerMode.getNumber(),
rayConfig.objectStoreSocketName, rayConfig.rayletSocketName,
rayConfig.nodeIp, rayConfig.getNodeManagerPort(),
(rayConfig.workerMode == WorkerType.DRIVER ? rayConfig.getJobId() : JobId.NIL).getBytes(),
new GcsClientOptions(rayConfig));
Preconditions.checkState(nativeCoreWorkerPointer != 0);
taskExecutor = new NativeTaskExecutor(nativeCoreWorkerPointer, this);
workerContext = new NativeWorkerContext(nativeCoreWorkerPointer);
objectStore = new NativeObjectStore(workerContext, nativeCoreWorkerPointer);
taskSubmitter = new NativeTaskSubmitter(nativeCoreWorkerPointer);
// register
registerWorker();
LOGGER.info("RayNativeRuntime started with store {}, raylet {}",
rayConfig.objectStoreSocketName, rayConfig.rayletSocketName);
}
@Override
public void shutdown() {
if (nativeCoreWorkerPointer != 0) {
nativeDestroyCoreWorker(nativeCoreWorkerPointer);
nativeCoreWorkerPointer = 0;
}
if (null != manager) {
manager.cleanup();
manager = null;
}
LOGGER.info("RayNativeRuntime shutdown");
}
// For test purpose only
public RunManager getRunManager() {
return manager;
}
@Override
public void setResource(String resourceName, double capacity, UniqueId nodeId) {
Preconditions.checkArgument(Double.compare(capacity, 0) >= 0);
if (nodeId == null) {
nodeId = UniqueId.NIL;
}
nativeSetResource(nativeCoreWorkerPointer, resourceName, capacity, nodeId.getBytes());
}
@Override
public void killActor(RayActor<?> actor) {
if (!((NativeRayActor) actor).isDirectCallActor()) {
throw new UnsupportedOperationException("Only direct call actors can be killed.");
}
nativeKillActor(nativeCoreWorkerPointer, actor.getId().getBytes());
}
@Override
public Object getAsyncContext() {
return null;
}
@Override
public void setAsyncContext(Object asyncContext) {
}
public void run() {
nativeRunTaskExecutor(nativeCoreWorkerPointer, taskExecutor);
}
public long getNativeCoreWorkerPointer() {
return nativeCoreWorkerPointer;
}
/**
* Register this worker or driver to GCS.
*/
private void registerWorker() {
RedisClient redisClient = new RedisClient(rayConfig.getRedisAddress(), rayConfig.redisPassword);
Map<String, String> workerInfo = new HashMap<>();
String workerId = new String(workerContext.getCurrentWorkerId().getBytes());
if (rayConfig.workerMode == WorkerType.DRIVER) {
workerInfo.put("node_ip_address", rayConfig.nodeIp);
workerInfo.put("driver_id", workerId);
workerInfo.put("start_time", String.valueOf(System.currentTimeMillis()));
workerInfo.put("plasma_store_socket", rayConfig.objectStoreSocketName);
workerInfo.put("raylet_socket", rayConfig.rayletSocketName);
workerInfo.put("name", System.getProperty("user.dir"));
//TODO: worker.redis_client.hmset(b"Drivers:" + worker.workerId, driver_info)
redisClient.hmset("Drivers:" + workerId, workerInfo);
} else {
workerInfo.put("node_ip_address", rayConfig.nodeIp);
workerInfo.put("plasma_store_socket", rayConfig.objectStoreSocketName);
workerInfo.put("raylet_socket", rayConfig.rayletSocketName);
//TODO: b"Workers:" + worker.workerId,
redisClient.hmset("Workers:" + workerId, workerInfo);
}
}
private static native long nativeInitCoreWorker(int workerMode, String storeSocket,
String rayletSocket, String nodeIpAddress, int nodeManagerPort, byte[] jobId,
GcsClientOptions gcsClientOptions);
private static native void nativeRunTaskExecutor(long nativeCoreWorkerPointer,
TaskExecutor taskExecutor);
private static native void nativeDestroyCoreWorker(long nativeCoreWorkerPointer);
private static native void nativeSetup(String logDir);
private static native void nativeShutdownHook();
private static native void nativeSetResource(long conn, String resourceName, double capacity,
byte[] nodeId);
private static native void nativeKillActor(long nativeCoreWorkerPointer, byte[] actorId);
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/actor/LocalModeRayActor.java | Java | package org.ray.runtime.actor;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.concurrent.atomic.AtomicReference;
import org.ray.api.RayActor;
import org.ray.api.id.ActorId;
import org.ray.api.id.ObjectId;
import org.ray.api.id.UniqueId;
/**
* RayActor implementation for local mode.
*/
public class LocalModeRayActor implements RayActor, Externalizable {
private ActorId actorId;
private AtomicReference<ObjectId> previousActorTaskDummyObjectId = new AtomicReference<>();
public LocalModeRayActor(ActorId actorId, ObjectId previousActorTaskDummyObjectId) {
this.actorId = actorId;
this.previousActorTaskDummyObjectId.set(previousActorTaskDummyObjectId);
}
/**
* Required by FST
*/
public LocalModeRayActor() {
}
@Override
public ActorId getId() {
return actorId;
}
public ObjectId exchangePreviousActorTaskDummyObjectId(ObjectId previousActorTaskDummyObjectId) {
return this.previousActorTaskDummyObjectId.getAndSet(previousActorTaskDummyObjectId);
}
@Override
public synchronized void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(actorId);
out.writeObject(previousActorTaskDummyObjectId.get());
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
actorId = (ActorId) in.readObject();
previousActorTaskDummyObjectId.set((ObjectId) in.readObject());
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/actor/NativeRayActor.java | Java | package org.ray.runtime.actor;
import com.google.common.base.Preconditions;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.List;
import org.ray.api.Ray;
import org.ray.api.RayActor;
import org.ray.api.id.ActorId;
import org.ray.api.runtime.RayRuntime;
import org.ray.runtime.RayMultiWorkerNativeRuntime;
import org.ray.runtime.RayNativeRuntime;
import org.ray.runtime.generated.Common.Language;
/**
* RayActor abstract language-independent implementation for cluster mode. This is a wrapper class
* for C++ ActorHandle.
*/
public abstract class NativeRayActor implements RayActor, Externalizable {
/**
* Address of core worker.
*/
long nativeCoreWorkerPointer;
/**
* ID of the actor.
*/
byte[] actorId;
private Language language;
NativeRayActor(long nativeCoreWorkerPointer, byte[] actorId, Language language) {
Preconditions.checkState(nativeCoreWorkerPointer != 0);
Preconditions.checkState(!ActorId.fromBytes(actorId).isNil());
this.nativeCoreWorkerPointer = nativeCoreWorkerPointer;
this.actorId = actorId;
this.language = language;
}
/**
* Required by FST
*/
NativeRayActor() {
}
public static NativeRayActor create(long nativeCoreWorkerPointer, byte[] actorId,
Language language) {
Preconditions.checkState(nativeCoreWorkerPointer != 0);
switch (language) {
case JAVA:
return new NativeRayJavaActor(nativeCoreWorkerPointer, actorId);
case PYTHON:
return new NativeRayPyActor(nativeCoreWorkerPointer, actorId);
default:
throw new IllegalStateException("Unknown actor handle language: " + language);
}
}
@Override
public ActorId getId() {
return ActorId.fromBytes(actorId);
}
public Language getLanguage() {
return language;
}
public boolean isDirectCallActor() {
return nativeIsDirectCallActor(nativeCoreWorkerPointer, actorId);
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(nativeSerialize(nativeCoreWorkerPointer, actorId));
out.writeObject(language);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
RayRuntime runtime = Ray.internal();
if (runtime instanceof RayMultiWorkerNativeRuntime) {
runtime = ((RayMultiWorkerNativeRuntime) runtime).getCurrentRuntime();
}
Preconditions.checkState(runtime instanceof RayNativeRuntime);
nativeCoreWorkerPointer = ((RayNativeRuntime) runtime).getNativeCoreWorkerPointer();
actorId = nativeDeserialize(nativeCoreWorkerPointer, (byte[]) in.readObject());
language = (Language) in.readObject();
}
@Override
protected void finalize() {
// TODO(zhijunfu): do we need to free the ActorHandle in core worker?
}
private static native boolean nativeIsDirectCallActor(long nativeCoreWorkerPointer, byte[] actorId);
static native List<String> nativeGetActorCreationTaskFunctionDescriptor(
long nativeCoreWorkerPointer, byte[] actorId);
private static native byte[] nativeSerialize(long nativeCoreWorkerPointer, byte[] actorId);
private static native byte[] nativeDeserialize(long nativeCoreWorkerPointer, byte[] data);
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/actor/NativeRayActorSerializer.java | Java | package org.ray.runtime.actor;
import java.io.IOException;
import org.nustaq.serialization.FSTBasicObjectSerializer;
import org.nustaq.serialization.FSTClazzInfo;
import org.nustaq.serialization.FSTClazzInfo.FSTFieldInfo;
import org.nustaq.serialization.FSTObjectInput;
import org.nustaq.serialization.FSTObjectOutput;
/**
* To deal with serialization about {@link NativeRayActor}.
*/
public class NativeRayActorSerializer extends FSTBasicObjectSerializer {
@Override
public void writeObject(FSTObjectOutput out, Object toWrite, FSTClazzInfo clzInfo,
FSTClazzInfo.FSTFieldInfo referencedBy, int streamPosition) throws IOException {
((NativeRayActor) 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);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/actor/NativeRayJavaActor.java | Java | package org.ray.runtime.actor;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.io.ObjectInput;
import org.ray.runtime.generated.Common.Language;
/**
* RayActor Java implementation for cluster mode.
*/
public class NativeRayJavaActor extends NativeRayActor {
NativeRayJavaActor(long nativeCoreWorkerPointer, byte[] actorId) {
super(nativeCoreWorkerPointer, actorId, Language.JAVA);
}
/**
* Required by FST
*/
public NativeRayJavaActor() {
super();
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
Preconditions.checkState(getLanguage() == Language.JAVA);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/actor/NativeRayPyActor.java | Java | package org.ray.runtime.actor;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.io.ObjectInput;
import org.ray.api.RayPyActor;
import org.ray.runtime.generated.Common.Language;
/**
* RayActor Python implementation for cluster mode.
*/
public class NativeRayPyActor extends NativeRayActor implements RayPyActor {
NativeRayPyActor(long nativeCoreWorkerPointer, byte[] actorId) {
super(nativeCoreWorkerPointer, actorId, Language.PYTHON);
}
/**
* Required by FST
*/
public NativeRayPyActor() {
super();
}
@Override
public String getModuleName() {
return nativeGetActorCreationTaskFunctionDescriptor(nativeCoreWorkerPointer, actorId).get(0);
}
@Override
public String getClassName() {
return nativeGetActorCreationTaskFunctionDescriptor(nativeCoreWorkerPointer, actorId).get(1);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
Preconditions.checkState(getLanguage() == Language.PYTHON);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/config/RayConfig.java | Java | package org.ray.runtime.config;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigException;
import com.typesafe.config.ConfigFactory;
import com.typesafe.config.ConfigValue;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.ray.api.id.JobId;
import org.ray.runtime.generated.Common.WorkerType;
import org.ray.runtime.util.NetworkUtil;
import org.ray.runtime.util.ResourceUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Configurations of Ray runtime.
* See `ray.default.conf` for the meaning of each field.
*/
public class RayConfig {
private static final Logger LOGGER = LoggerFactory.getLogger(RayConfig.class);
public static final String DEFAULT_CONFIG_FILE = "ray.default.conf";
public static final String CUSTOM_CONFIG_FILE = "ray.conf";
public final String nodeIp;
public final WorkerType workerMode;
public final RunMode runMode;
public final Map<String, Double> resources;
private JobId jobId;
public final String logDir;
public final boolean redirectOutput;
public final List<String> libraryPath;
public final List<String> classpath;
public final List<String> jvmParameters;
private String redisAddress;
private String redisIp;
private Integer redisPort;
public final int headRedisPort;
public final int numberRedisShards;
public final String headRedisPassword;
public final String redisPassword;
public final String objectStoreSocketName;
public final Long objectStoreSize;
public final String rayletSocketName;
private int nodeManagerPort;
public final List<String> rayletConfigParameters;
public final String jobResourcePath;
public final String pythonWorkerCommand;
/**
* Number of threads that execute tasks.
*/
public final int numberExecThreadsForDevRuntime;
public final int numWorkersPerProcess;
private void validate() {
if (workerMode == WorkerType.WORKER) {
Preconditions.checkArgument(redisAddress != null,
"Redis address must be set in worker mode.");
}
}
private String removeTrailingSlash(String path) {
if (path.endsWith("/")) {
return path.substring(0, path.length() - 1);
} else {
return path;
}
}
public RayConfig(Config config) {
// Worker mode.
WorkerType localWorkerMode;
try {
localWorkerMode = config.getEnum(WorkerType.class, "ray.worker.mode");
} catch (ConfigException.Missing e) {
localWorkerMode = WorkerType.DRIVER;
}
workerMode = localWorkerMode;
boolean isDriver = workerMode == WorkerType.DRIVER;
// Run mode.
runMode = config.getEnum(RunMode.class, "ray.run-mode");
// Node ip.
String nodeIp = config.getString("ray.node-ip");
if (nodeIp.isEmpty()) {
nodeIp = NetworkUtil.getIpAddress(null);
}
this.nodeIp = nodeIp;
// Resources.
resources = ResourceUtil.getResourcesMapFromString(
config.getString("ray.resources"));
if (isDriver) {
if (!resources.containsKey("CPU")) {
int numCpu = Runtime.getRuntime().availableProcessors();
LOGGER.warn("No CPU resource is set in configuration, "
+ "setting it to the number of CPU cores: {}", numCpu);
resources.put("CPU", numCpu * 1.0);
}
}
// Job id.
String jobId = config.getString("ray.job.id");
if (!jobId.isEmpty()) {
this.jobId = JobId.fromHexString(jobId);
} else {
this.jobId = JobId.NIL;
}
// Log dir.
logDir = removeTrailingSlash(config.getString("ray.log-dir"));
// Redirect output.
redirectOutput = config.getBoolean("ray.redirect-output");
// Library path.
libraryPath = config.getStringList("ray.library.path");
// Custom classpath.
classpath = config.getStringList("ray.classpath");
// Custom worker jvm parameters.
if (config.hasPath("ray.worker.jvm-parameters")) {
jvmParameters = config.getStringList("ray.worker.jvm-parameters");
} else {
jvmParameters = ImmutableList.of();
}
if (config.hasPath("ray.worker.python-command")) {
pythonWorkerCommand = config.getString("ray.worker.python-command");
} else {
pythonWorkerCommand = null;
}
// Redis configurations.
String redisAddress = config.getString("ray.redis.address");
if (!redisAddress.isEmpty()) {
setRedisAddress(redisAddress);
} else {
this.redisAddress = null;
}
headRedisPort = config.getInt("ray.redis.head-port");
numberRedisShards = config.getInt("ray.redis.shard-number");
headRedisPassword = config.getString("ray.redis.head-password");
redisPassword = config.getString("ray.redis.password");
// Object store configurations.
objectStoreSocketName = config.getString("ray.object-store.socket-name");
objectStoreSize = config.getBytes("ray.object-store.size");
// Raylet socket name.
rayletSocketName = config.getString("ray.raylet.socket-name");
// Raylet node manager port.
nodeManagerPort = config.getInt("ray.raylet.node-manager-port");
if (nodeManagerPort == 0) {
Preconditions.checkState(this.redisAddress == null,
"Java worker started by raylet should accept the node manager port from raylet.");
nodeManagerPort = NetworkUtil.getUnusedPort();
}
// Raylet parameters.
rayletConfigParameters = new ArrayList<>();
Config rayletConfig = config.getConfig("ray.raylet.config");
for (Map.Entry<String, ConfigValue> entry : rayletConfig.entrySet()) {
String parameter = entry.getKey() + "," + entry.getValue().unwrapped();
rayletConfigParameters.add(parameter);
}
// Job resource path.
if (config.hasPath("ray.job.resource-path")) {
jobResourcePath = config.getString("ray.job.resource-path");
} else {
jobResourcePath = null;
}
// Number of threads that execute tasks.
numberExecThreadsForDevRuntime = config.getInt("ray.dev-runtime.execution-parallelism");
numWorkersPerProcess = config.getInt("ray.raylet.config.num_workers_per_process_java");
// Validate config.
validate();
LOGGER.debug("Created config: {}", this);
}
public void setRedisAddress(String redisAddress) {
Preconditions.checkNotNull(redisAddress);
Preconditions.checkState(this.redisAddress == null, "Redis address was already set");
this.redisAddress = redisAddress;
String[] ipAndPort = redisAddress.split(":");
Preconditions.checkArgument(ipAndPort.length == 2, "Invalid redis address.");
this.redisIp = ipAndPort[0];
this.redisPort = Integer.parseInt(ipAndPort[1]);
}
public String getRedisAddress() {
return redisAddress;
}
public String getRedisIp() {
return redisIp;
}
public Integer getRedisPort() {
return redisPort;
}
public void setJobId(JobId jobId) {
this.jobId = jobId;
}
public JobId getJobId() {
return this.jobId;
}
public int getNodeManagerPort() {
return nodeManagerPort;
}
@Override
public String toString() {
return "RayConfig{"
+ ", nodeIp='" + nodeIp + '\''
+ ", workerMode=" + workerMode
+ ", runMode=" + runMode
+ ", resources=" + resources
+ ", jobId=" + jobId
+ ", logDir='" + logDir + '\''
+ ", redirectOutput=" + redirectOutput
+ ", libraryPath=" + libraryPath
+ ", classpath=" + classpath
+ ", jvmParameters=" + jvmParameters
+ ", redisAddress='" + redisAddress + '\''
+ ", redisIp='" + redisIp + '\''
+ ", redisPort=" + redisPort
+ ", headRedisPort=" + headRedisPort
+ ", numberRedisShards=" + numberRedisShards
+ ", objectStoreSocketName='" + objectStoreSocketName + '\''
+ ", objectStoreSize=" + objectStoreSize
+ ", rayletSocketName='" + rayletSocketName + '\''
+ ", rayletConfigParameters=" + rayletConfigParameters
+ ", jobResourcePath='" + jobResourcePath + '\''
+ ", pythonWorkerCommand='" + pythonWorkerCommand + '\''
+ '}';
}
/**
* Create a RayConfig by reading configuration in the following order:
* 1. System properties.
* 2. `ray.conf` file.
* 3. `ray.default.conf` file.
*/
public static RayConfig create() {
ConfigFactory.invalidateCaches();
Config config = ConfigFactory.systemProperties();
String configPath = System.getProperty("ray.config");
if (Strings.isNullOrEmpty(configPath)) {
LOGGER.info("Loading config from \"ray.conf\" file in classpath.");
config = config.withFallback(ConfigFactory.load(CUSTOM_CONFIG_FILE));
} else {
LOGGER.info("Loading config from " + configPath + ".");
config = config.withFallback(ConfigFactory.parseFile(new File(configPath)));
}
config = config.withFallback(ConfigFactory.load(DEFAULT_CONFIG_FILE));
return new RayConfig(config);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/config/RunMode.java | Java | package org.ray.runtime.config;
public enum RunMode {
/**
* Ray is running in one single Java process, without Raylet backend, object store, and GCS.
* It's useful for debug.
*/
SINGLE_PROCESS,
/**
* Ray is running on one or more nodes, with multiple processes.
*/
CLUSTER,
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/context/LocalModeWorkerContext.java | Java | package org.ray.runtime.context;
import com.google.common.base.Preconditions;
import org.ray.api.id.ActorId;
import org.ray.api.id.JobId;
import org.ray.api.id.TaskId;
import org.ray.api.id.UniqueId;
import org.ray.runtime.generated.Common.TaskSpec;
import org.ray.runtime.generated.Common.TaskType;
import org.ray.runtime.task.LocalModeTaskSubmitter;
/**
* Worker context for local mode.
*/
public class LocalModeWorkerContext implements WorkerContext {
private final JobId jobId;
private ThreadLocal<TaskSpec> currentTask = new ThreadLocal<>();
public LocalModeWorkerContext(JobId jobId) {
this.jobId = jobId;
}
@Override
public UniqueId getCurrentWorkerId() {
throw new UnsupportedOperationException();
}
@Override
public JobId getCurrentJobId() {
return jobId;
}
@Override
public ActorId getCurrentActorId() {
TaskSpec taskSpec = currentTask.get();
if (taskSpec == null) {
return ActorId.NIL;
}
return LocalModeTaskSubmitter.getActorId(taskSpec);
}
@Override
public ClassLoader getCurrentClassLoader() {
return null;
}
@Override
public void setCurrentClassLoader(ClassLoader currentClassLoader) {
}
@Override
public TaskType getCurrentTaskType() {
TaskSpec taskSpec = currentTask.get();
Preconditions.checkNotNull(taskSpec, "Current task is not set.");
return taskSpec.getType();
}
@Override
public TaskId getCurrentTaskId() {
TaskSpec taskSpec = currentTask.get();
Preconditions.checkState(taskSpec != null);
return TaskId.fromBytes(taskSpec.getTaskId().toByteArray());
}
public void setCurrentTask(TaskSpec taskSpec) {
currentTask.set(taskSpec);
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/context/NativeWorkerContext.java | Java | package org.ray.runtime.context;
import java.nio.ByteBuffer;
import org.ray.api.id.ActorId;
import org.ray.api.id.JobId;
import org.ray.api.id.TaskId;
import org.ray.api.id.UniqueId;
import org.ray.runtime.generated.Common.TaskType;
/**
* Worker context for cluster mode. This is a wrapper class for worker context of core worker.
*/
public class NativeWorkerContext implements WorkerContext {
/**
* The native pointer of core worker.
*/
private final long nativeCoreWorkerPointer;
private ClassLoader currentClassLoader;
public NativeWorkerContext(long nativeCoreWorkerPointer) {
this.nativeCoreWorkerPointer = nativeCoreWorkerPointer;
}
@Override
public UniqueId getCurrentWorkerId() {
return UniqueId.fromByteBuffer(nativeGetCurrentWorkerId(nativeCoreWorkerPointer));
}
@Override
public JobId getCurrentJobId() {
return JobId.fromByteBuffer(nativeGetCurrentJobId(nativeCoreWorkerPointer));
}
@Override
public ActorId getCurrentActorId() {
return ActorId.fromByteBuffer(nativeGetCurrentActorId(nativeCoreWorkerPointer));
}
@Override
public ClassLoader getCurrentClassLoader() {
return currentClassLoader;
}
@Override
public void setCurrentClassLoader(ClassLoader currentClassLoader) {
if (this.currentClassLoader != currentClassLoader) {
this.currentClassLoader = currentClassLoader;
}
}
@Override
public TaskType getCurrentTaskType() {
return TaskType.forNumber(nativeGetCurrentTaskType(nativeCoreWorkerPointer));
}
@Override
public TaskId getCurrentTaskId() {
return TaskId.fromByteBuffer(nativeGetCurrentTaskId(nativeCoreWorkerPointer));
}
private static native int nativeGetCurrentTaskType(long nativeCoreWorkerPointer);
private static native ByteBuffer nativeGetCurrentTaskId(long nativeCoreWorkerPointer);
private static native ByteBuffer nativeGetCurrentJobId(long nativeCoreWorkerPointer);
private static native ByteBuffer nativeGetCurrentWorkerId(long nativeCoreWorkerPointer);
private static native ByteBuffer nativeGetCurrentActorId(long nativeCoreWorkerPointer);
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/context/RuntimeContextImpl.java | Java | package org.ray.runtime.context;
import com.google.common.base.Preconditions;
import java.util.List;
import org.ray.api.id.ActorId;
import org.ray.api.id.JobId;
import org.ray.api.runtimecontext.NodeInfo;
import org.ray.api.runtimecontext.RuntimeContext;
import org.ray.runtime.AbstractRayRuntime;
import org.ray.runtime.config.RunMode;
import org.ray.runtime.generated.Common.TaskType;
public class RuntimeContextImpl implements RuntimeContext {
private AbstractRayRuntime runtime;
public RuntimeContextImpl(AbstractRayRuntime runtime) {
this.runtime = runtime;
}
@Override
public JobId getCurrentJobId() {
return runtime.getWorkerContext().getCurrentJobId();
}
@Override
public ActorId getCurrentActorId() {
ActorId actorId = runtime.getWorkerContext().getCurrentActorId();
Preconditions.checkState(actorId != null && !actorId.isNil(),
"This method should only be called from an actor.");
return actorId;
}
@Override
public boolean wasCurrentActorReconstructed() {
TaskType currentTaskType = runtime.getWorkerContext().getCurrentTaskType();
Preconditions.checkState(currentTaskType == TaskType.ACTOR_CREATION_TASK,
"This method can only be called from an actor creation task.");
if (isSingleProcess()) {
return false;
}
return runtime.getGcsClient().actorExists(getCurrentActorId());
}
@Override
public String getRayletSocketName() {
return runtime.getRayConfig().rayletSocketName;
}
@Override
public String getObjectStoreSocketName() {
return runtime.getRayConfig().objectStoreSocketName;
}
@Override
public boolean isSingleProcess() {
return RunMode.SINGLE_PROCESS == runtime.getRayConfig().runMode;
}
@Override
public List<NodeInfo> getAllNodeInfo() {
return runtime.getGcsClient().getAllNodeInfo();
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/context/WorkerContext.java | Java | package org.ray.runtime.context;
import org.ray.api.id.ActorId;
import org.ray.api.id.JobId;
import org.ray.api.id.TaskId;
import org.ray.api.id.UniqueId;
import org.ray.runtime.generated.Common.TaskType;
/**
* The context of worker.
*/
public interface WorkerContext {
/**
* ID of the current worker.
*/
UniqueId getCurrentWorkerId();
/**
* ID of the current job.
*/
JobId getCurrentJobId();
/**
* ID of the current actor.
*/
ActorId getCurrentActorId();
/**
* The class loader that is associated with the current job. It's used for locating classes when
* dealing with serialization and deserialization in {@link org.ray.runtime.util.Serializer}.
*/
ClassLoader getCurrentClassLoader();
/**
* Set the current class loader.
*/
void setCurrentClassLoader(ClassLoader currentClassLoader);
/**
* Type of the current task.
*/
TaskType getCurrentTaskType();
/**
* ID of the current task.
*/
TaskId getCurrentTaskId();
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/functionmanager/FunctionDescriptor.java | Java | package org.ray.runtime.functionmanager;
import java.util.List;
import org.ray.runtime.generated.Common.Language;
/**
* Base interface of a Ray task's function descriptor.
*
* A function descriptor is a list of strings that can uniquely describe a function. It's used to
* load a function in workers.
*/
public interface FunctionDescriptor {
/**
* @return A list of strings represents the functions.
*/
List<String> toList();
/**
* @return The language of the function.
*/
Language getLanguage();
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/functionmanager/FunctionManager.java | Java | package org.ray.runtime.functionmanager;
import com.google.common.base.Strings;
import java.io.File;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.RegexFileFilter;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.objectweb.asm.Type;
import org.ray.api.function.RayFunc;
import org.ray.api.id.JobId;
import org.ray.runtime.util.LambdaUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Manages functions by job id.
*/
public class FunctionManager {
private static final Logger LOGGER = LoggerFactory.getLogger(FunctionManager.class);
static final String CONSTRUCTOR_NAME = "<init>";
/**
* Cache from a RayFunc object to its corresponding JavaFunctionDescriptor. Because
* `LambdaUtils.getSerializedLambda` is expensive.
*/
// If the cache is not thread local, we'll need a lock to protect it,
// which means competition is highly possible.
private static final ThreadLocal<WeakHashMap<Class<? extends RayFunc>, JavaFunctionDescriptor>>
RAY_FUNC_CACHE = ThreadLocal.withInitial(WeakHashMap::new);
/**
* Mapping from the job id to the functions that belong to this job.
*/
private ConcurrentMap<JobId, JobFunctionTable> jobFunctionTables = new ConcurrentHashMap<>();
/**
* The resource path which we can load the job's jar resources.
*/
private final String jobResourcePath;
/**
* Construct a FunctionManager with the specified job resource path.
*
* @param jobResourcePath The specified job resource that can store the job's
* resources.
*/
public FunctionManager(String jobResourcePath) {
this.jobResourcePath = jobResourcePath;
}
/**
* Get the RayFunction from a RayFunc instance (a lambda).
*
* @param jobId current job id.
* @param func The lambda.
* @return A RayFunction object.
*/
public RayFunction getFunction(JobId jobId, RayFunc func) {
JavaFunctionDescriptor functionDescriptor = RAY_FUNC_CACHE.get().get(func.getClass());
if (functionDescriptor == null) {
// It's OK to not lock here, because it's OK to have multiple JavaFunctionDescriptor instances
// for the same RayFunc instance.
SerializedLambda serializedLambda = LambdaUtils.getSerializedLambda(func);
final String className = serializedLambda.getImplClass().replace('/', '.');
final String methodName = serializedLambda.getImplMethodName();
final String typeDescriptor = serializedLambda.getImplMethodSignature();
functionDescriptor = new JavaFunctionDescriptor(className, methodName, typeDescriptor);
RAY_FUNC_CACHE.get().put(func.getClass(), functionDescriptor);
}
return getFunction(jobId, functionDescriptor);
}
/**
* Get the RayFunction from a function descriptor.
*
* @param jobId Current job id.
* @param functionDescriptor The function descriptor.
* @return A RayFunction object.
*/
public RayFunction getFunction(JobId jobId,
JavaFunctionDescriptor functionDescriptor) {
JobFunctionTable jobFunctionTable = jobFunctionTables.get(jobId);
if (jobFunctionTable == null) {
synchronized (this) {
jobFunctionTable = jobFunctionTables.get(jobId);
if (jobFunctionTable == null) {
jobFunctionTable = createJobFunctionTable(jobId);
jobFunctionTables.put(jobId, jobFunctionTable);
}
}
}
return jobFunctionTable.getFunction(functionDescriptor);
}
private JobFunctionTable createJobFunctionTable(JobId jobId) {
ClassLoader classLoader;
if (Strings.isNullOrEmpty(jobResourcePath)) {
classLoader = getClass().getClassLoader();
} else {
File resourceDir = new File(jobResourcePath + "/" + jobId.toString() + "/");
Collection<File> files = FileUtils.listFiles(resourceDir,
new RegexFileFilter(".*\\.jar"), DirectoryFileFilter.DIRECTORY);
files.add(resourceDir);
final List<URL> urlList = files.stream().map(file -> {
try {
return file.toURI().toURL();
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
}).collect(Collectors.toList());
classLoader = new URLClassLoader(urlList.toArray(new URL[urlList.size()]));
LOGGER.debug("Resource loaded for job {} from path {}.", jobId,
resourceDir.getAbsolutePath());
}
return new JobFunctionTable(classLoader);
}
/**
* Manages all functions that belong to one job.
*/
static class JobFunctionTable {
/**
* The job's corresponding class loader.
*/
final ClassLoader classLoader;
/**
* Functions per class, per function name + type descriptor.
*/
ConcurrentMap<String, Map<Pair<String, String>, RayFunction>> functions;
JobFunctionTable(ClassLoader classLoader) {
this.classLoader = classLoader;
this.functions = new ConcurrentHashMap<>();
}
RayFunction getFunction(JavaFunctionDescriptor descriptor) {
Map<Pair<String, String>, RayFunction> classFunctions = functions.get(descriptor.className);
if (classFunctions == null) {
synchronized (this) {
classFunctions = functions.get(descriptor.className);
if (classFunctions == null) {
classFunctions = loadFunctionsForClass(descriptor.className);
functions.put(descriptor.className, classFunctions);
}
}
}
return classFunctions.get(ImmutablePair.of(descriptor.name, descriptor.typeDescriptor));
}
/**
* Load all functions from a class.
*/
Map<Pair<String, String>, RayFunction> loadFunctionsForClass(String className) {
Map<Pair<String, String>, RayFunction> map = new HashMap<>();
try {
Class clazz = Class.forName(className, true, classLoader);
List<Executable> executables = new ArrayList<>();
executables.addAll(Arrays.asList(clazz.getDeclaredMethods()));
executables.addAll(Arrays.asList(clazz.getConstructors()));
for (Executable e : executables) {
e.setAccessible(true);
final String methodName = e instanceof Method ? e.getName() : CONSTRUCTOR_NAME;
final Type type =
e instanceof Method ? Type.getType((Method) e) : Type.getType((Constructor) e);
final String typeDescriptor = type.getDescriptor();
RayFunction rayFunction = new RayFunction(e, classLoader,
new JavaFunctionDescriptor(className, methodName, typeDescriptor));
map.put(ImmutablePair.of(methodName, typeDescriptor), rayFunction);
}
} catch (Exception e) {
throw new RuntimeException("Failed to load functions from class " + className, e);
}
return map;
}
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/functionmanager/JavaFunctionDescriptor.java | Java | package org.ray.runtime.functionmanager;
import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
import java.util.List;
import org.ray.runtime.generated.Common.Language;
/**
* Represents metadata of Java function.
*/
public final class JavaFunctionDescriptor implements FunctionDescriptor {
/**
* Function's class name.
*/
public final String className;
/**
* Function's name.
*/
public final String name;
/**
* Function's type descriptor.
*/
public final String typeDescriptor;
public JavaFunctionDescriptor(String className, String name, String typeDescriptor) {
this.className = className;
this.name = name;
this.typeDescriptor = typeDescriptor;
}
@Override
public String toString() {
return className + "." + name;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
JavaFunctionDescriptor that = (JavaFunctionDescriptor) o;
return Objects.equal(className, that.className) &&
Objects.equal(name, that.name) &&
Objects.equal(typeDescriptor, that.typeDescriptor);
}
@Override
public int hashCode() {
return Objects.hashCode(className, name, typeDescriptor);
}
@Override
public List<String> toList() {
return ImmutableList.of(className, name, typeDescriptor);
}
@Override
public Language getLanguage() {
return Language.JAVA;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/functionmanager/PyFunctionDescriptor.java | Java | package org.ray.runtime.functionmanager;
import java.util.Arrays;
import java.util.List;
import org.ray.runtime.generated.Common.Language;
/**
* Represents metadata of a Python function.
*/
public class PyFunctionDescriptor implements FunctionDescriptor {
public String moduleName;
public String className;
public String functionName;
public PyFunctionDescriptor(String moduleName, String className, String functionName) {
this.moduleName = moduleName;
this.className = className;
this.functionName = functionName;
}
@Override
public String toString() {
return moduleName + "." + className + "." + functionName;
}
@Override
public List<String> toList() {
return Arrays.asList(moduleName, className, functionName);
}
@Override
public Language getLanguage() {
return Language.PYTHON;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/functionmanager/RayFunction.java | Java | 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.
*/
public class RayFunction {
/**
* The executor object, can be either a Method or a Constructor.
*/
public final Executable executable;
/**
* This function's class loader.
*/
public final ClassLoader classLoader;
/**
* Function's metadata.
*/
public final JavaFunctionDescriptor functionDescriptor;
public RayFunction(Executable executable, ClassLoader classLoader,
JavaFunctionDescriptor functionDescriptor) {
this.executable = executable;
this.classLoader = classLoader;
this.functionDescriptor = functionDescriptor;
}
/**
* @return True if it's a constructor, otherwise it's a method.
*/
public boolean isConstructor() {
return executable instanceof Constructor;
}
/**
* @return The underlying constructor object.
*/
public Constructor<?> getConstructor() {
return (Constructor<?>) executable;
}
/**
* @return The underlying method object.
*/
public Method getMethod() {
return (Method) executable;
}
public JavaFunctionDescriptor getFunctionDescriptor() {
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.
*/
public boolean hasReturn() {
if (isConstructor()) {
return true;
} else {
return !getMethod().getReturnType().equals(void.class);
}
}
@Override
public String toString() {
return executable.toString();
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/gcs/GcsClient.java | Java | package org.ray.runtime.gcs;
import com.google.common.base.Preconditions;
import com.google.protobuf.InvalidProtocolBufferException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.lang3.ArrayUtils;
import org.ray.api.Checkpointable.Checkpoint;
import org.ray.api.id.ActorId;
import org.ray.api.id.BaseId;
import org.ray.api.id.JobId;
import org.ray.api.id.TaskId;
import org.ray.api.id.UniqueId;
import org.ray.api.runtimecontext.NodeInfo;
import org.ray.runtime.generated.Gcs;
import org.ray.runtime.generated.Gcs.ActorCheckpointIdData;
import org.ray.runtime.generated.Gcs.GcsNodeInfo;
import org.ray.runtime.generated.Gcs.TablePrefix;
import org.ray.runtime.util.IdUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* An implementation of GcsClient.
*/
public class GcsClient {
private static Logger LOGGER = LoggerFactory.getLogger(GcsClient.class);
private RedisClient primary;
private List<RedisClient> shards;
public GcsClient(String redisAddress, String redisPassword) {
primary = new RedisClient(redisAddress, redisPassword);
int numShards = 0;
try {
numShards = Integer.valueOf(primary.get("NumRedisShards", null));
Preconditions.checkState(numShards > 0,
String.format("Expected at least one Redis shards, found %d.", numShards));
} catch (NumberFormatException e) {
throw new RuntimeException("Failed to get number of redis shards.", e);
}
List<byte[]> shardAddresses = primary.lrange("RedisShards".getBytes(), 0, -1);
Preconditions.checkState(shardAddresses.size() == numShards);
shards = shardAddresses.stream().map((byte[] address) -> {
return new RedisClient(new String(address), redisPassword);
}).collect(Collectors.toList());
}
public List<NodeInfo> getAllNodeInfo() {
final String prefix = TablePrefix.CLIENT.toString();
final byte[] key = ArrayUtils.addAll(prefix.getBytes(), UniqueId.NIL.getBytes());
List<byte[]> results = primary.lrange(key, 0, -1);
if (results == null) {
return new ArrayList<>();
}
// This map is used for deduplication of node entries.
Map<UniqueId, NodeInfo> nodes = new HashMap<>();
for (byte[] result : results) {
Preconditions.checkNotNull(result);
GcsNodeInfo data = null;
try {
data = GcsNodeInfo.parseFrom(result);
} catch (InvalidProtocolBufferException e) {
throw new RuntimeException("Received invalid protobuf data from GCS.");
}
final UniqueId nodeId = UniqueId
.fromByteBuffer(data.getNodeId().asReadOnlyByteBuffer());
if (data.getState() == GcsNodeInfo.GcsNodeState.ALIVE) {
//Code path of node insertion.
NodeInfo nodeInfo = new NodeInfo(
nodeId, data.getNodeManagerAddress(),
data.getNodeManagerHostname(),
true, new HashMap<>());
nodes.put(nodeId, nodeInfo);
} else {
// Code path of node deletion.
NodeInfo nodeInfo = new NodeInfo(nodeId, nodes.get(nodeId).nodeAddress,
nodes.get(nodeId).nodeHostname, false, new HashMap<>());
nodes.put(nodeId, nodeInfo);
}
}
// Fill resources.
for (Map.Entry<UniqueId, NodeInfo> node : nodes.entrySet()) {
if (node.getValue().isAlive) {
node.getValue().resources.putAll(getResourcesForClient(node.getKey()));
}
}
return new ArrayList<>(nodes.values());
}
private Map<String, Double> getResourcesForClient(UniqueId clientId) {
final String prefix = TablePrefix.NODE_RESOURCE.toString();
final byte[] key = ArrayUtils.addAll(prefix.getBytes(), clientId.getBytes());
Map<byte[], byte[]> results = primary.hgetAll(key);
Map<String, Double> resources = new HashMap<>();
for (Map.Entry<byte[], byte[]> entry : results.entrySet()) {
String resourceName = new String(entry.getKey());
Gcs.ResourceTableData resourceTableData;
try {
resourceTableData = Gcs.ResourceTableData.parseFrom(entry.getValue());
} catch (InvalidProtocolBufferException e) {
throw new RuntimeException("Received invalid protobuf data from GCS.");
}
resources.put(resourceName, resourceTableData.getResourceCapacity());
}
return resources;
}
/**
* If the actor exists in GCS.
*/
public boolean actorExists(ActorId actorId) {
byte[] key = ArrayUtils.addAll(
TablePrefix.ACTOR.toString().getBytes(), actorId.getBytes());
return primary.exists(key);
}
/**
* Query whether the raylet task exists in Gcs.
*/
public boolean rayletTaskExistsInGcs(TaskId taskId) {
byte[] key = ArrayUtils.addAll(TablePrefix.RAYLET_TASK.toString().getBytes(),
taskId.getBytes());
RedisClient client = getShardClient(taskId);
return client.exists(key);
}
/**
* Get the available checkpoints for the given actor ID.
*/
public List<Checkpoint> getCheckpointsForActor(ActorId actorId) {
List<Checkpoint> checkpoints = new ArrayList<>();
final String prefix = TablePrefix.ACTOR_CHECKPOINT_ID.toString();
final byte[] key = ArrayUtils.addAll(prefix.getBytes(), actorId.getBytes());
RedisClient client = getShardClient(actorId);
byte[] result = client.get(key);
if (result != null) {
ActorCheckpointIdData data = null;
try {
data = ActorCheckpointIdData.parseFrom(result);
} catch (InvalidProtocolBufferException e) {
throw new RuntimeException("Received invalid protobuf data from GCS.");
}
UniqueId[] checkpointIds = new UniqueId[data.getCheckpointIdsCount()];
for (int i = 0; i < checkpointIds.length; i++) {
checkpointIds[i] = UniqueId
.fromByteBuffer(data.getCheckpointIds(i).asReadOnlyByteBuffer());
}
for (int i = 0; i < checkpointIds.length; i++) {
checkpoints.add(new Checkpoint(checkpointIds[i], data.getTimestamps(i)));
}
}
checkpoints.sort((x, y) -> Long.compare(y.timestamp, x.timestamp));
return checkpoints;
}
public JobId nextJobId() {
int jobCounter = (int) primary.incr("JobCounter".getBytes());
return JobId.fromInt(jobCounter);
}
private RedisClient getShardClient(BaseId key) {
return shards.get((int) Long.remainderUnsigned(IdUtil.murmurHashCode(key),
shards.size()));
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/gcs/GcsClientOptions.java | Java | package org.ray.runtime.gcs;
import org.ray.runtime.config.RayConfig;
/**
* Options to create GCS Client.
*/
public class GcsClientOptions {
public String ip;
public int port;
public String password;
public GcsClientOptions(RayConfig rayConfig) {
ip = rayConfig.getRedisIp();
port = rayConfig.getRedisPort();
password = rayConfig.redisPassword;
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/gcs/RedisClient.java | Java | package org.ray.runtime.gcs;
import com.google.common.base.Strings;
import java.util.List;
import java.util.Map;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* Redis client class.
*/
public class RedisClient {
private static final int JEDIS_POOL_SIZE = 1;
private JedisPool jedisPool;
public RedisClient(String redisAddress) {
this(redisAddress, null);
}
public RedisClient(String redisAddress, String password) {
String[] ipAndPort = redisAddress.split(":");
if (ipAndPort.length != 2) {
throw new IllegalArgumentException("The argument redisAddress " +
"should be formatted as ip:port.");
}
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxTotal(JEDIS_POOL_SIZE);
if (Strings.isNullOrEmpty(password)) {
jedisPool = new JedisPool(jedisPoolConfig,
ipAndPort[0], Integer.parseInt(ipAndPort[1]), 30000);
} else {
jedisPool = new JedisPool(jedisPoolConfig, ipAndPort[0],
Integer.parseInt(ipAndPort[1]), 30000, password);
}
}
public Long set(final String key, final String value, final String field) {
try (Jedis jedis = jedisPool.getResource()) {
if (field == null) {
jedis.set(key, value);
return (long) 1;
} else {
return jedis.hset(key, field, value);
}
}
}
public String hmset(String key, Map<String, String> hash) {
try (Jedis jedis = jedisPool.getResource()) {
return jedis.hmset(key, hash);
}
}
public Map<byte[], byte[]> hgetAll(byte[] key) {
try (Jedis jedis = jedisPool.getResource()) {
return jedis.hgetAll(key);
}
}
public String get(final String key, final String field) {
try (Jedis jedis = jedisPool.getResource()) {
if (field == null) {
return jedis.get(key);
} else {
return jedis.hget(key, field);
}
}
}
public byte[] get(byte[] key) {
return get(key, null);
}
public byte[] get(byte[] key, byte[] field) {
try (Jedis jedis = jedisPool.getResource()) {
if (field == null) {
return jedis.get(key);
} else {
return jedis.hget(key, field);
}
}
}
/**
* Return the specified elements of the list stored at the specified key.
*
* @return Multi bulk reply, specifically a list of elements in the specified range.
*/
public List<byte[]> lrange(byte[] key, long start, long end) {
try (Jedis jedis = jedisPool.getResource()) {
return jedis.lrange(key, start, end);
}
}
/**
* Whether the key exists in Redis.
*/
public boolean exists(byte[] key) {
try (Jedis jedis = jedisPool.getResource()) {
return jedis.exists(key);
}
}
public long incr(byte[] key) {
try (Jedis jedis = jedisPool.getResource()) {
return jedis.incr(key).intValue();
}
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/object/LocalModeObjectStore.java | Java | package org.ray.runtime.object;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import org.ray.api.id.ObjectId;
import org.ray.runtime.context.WorkerContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Object store methods for local mode.
*/
public class LocalModeObjectStore extends ObjectStore {
private static final Logger LOGGER = LoggerFactory.getLogger(LocalModeObjectStore.class);
private static final int GET_CHECK_INTERVAL_MS = 100;
private final Map<ObjectId, NativeRayObject> pool = new ConcurrentHashMap<>();
private final List<Consumer<ObjectId>> objectPutCallbacks = new ArrayList<>();
public LocalModeObjectStore(WorkerContext workerContext) {
super(workerContext);
}
public void addObjectPutCallback(Consumer<ObjectId> callback) {
this.objectPutCallbacks.add(callback);
}
public boolean isObjectReady(ObjectId id) {
return pool.containsKey(id);
}
@Override
public ObjectId putRaw(NativeRayObject obj) {
ObjectId objectId = ObjectId.fromRandom();
putRaw(obj, objectId);
return objectId;
}
@Override
public void putRaw(NativeRayObject obj, ObjectId objectId) {
Preconditions.checkNotNull(obj);
Preconditions.checkNotNull(objectId);
pool.putIfAbsent(objectId, obj);
for (Consumer<ObjectId> callback : objectPutCallbacks) {
callback.accept(objectId);
}
}
@Override
public List<NativeRayObject> getRaw(List<ObjectId> objectIds, long timeoutMs) {
waitInternal(objectIds, objectIds.size(), timeoutMs);
return objectIds.stream().map(pool::get).collect(Collectors.toList());
}
@Override
public List<Boolean> wait(List<ObjectId> objectIds, int numObjects, long timeoutMs) {
waitInternal(objectIds, numObjects, timeoutMs);
return objectIds.stream().map(pool::containsKey).collect(Collectors.toList());
}
private void waitInternal(List<ObjectId> objectIds, int numObjects, long timeoutMs) {
int ready = 0;
long remainingTime = timeoutMs;
boolean firstCheck = true;
while (ready < numObjects && (timeoutMs < 0 || remainingTime > 0)) {
if (!firstCheck) {
long sleepTime =
timeoutMs < 0 ? GET_CHECK_INTERVAL_MS : Math.min(remainingTime, GET_CHECK_INTERVAL_MS);
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
LOGGER.warn("Got InterruptedException while sleeping.");
}
remainingTime -= sleepTime;
}
ready = 0;
for (ObjectId objectId : objectIds) {
if (pool.containsKey(objectId)) {
ready += 1;
}
}
firstCheck = false;
}
}
@Override
public void delete(List<ObjectId> objectIds, boolean localOnly, boolean deleteCreatingTasks) {
for (ObjectId objectId : objectIds) {
pool.remove(objectId);
}
}
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta | |
java/runtime/src/main/java/org/ray/runtime/object/NativeObjectStore.java | Java | package org.ray.runtime.object;
import java.util.List;
import java.util.stream.Collectors;
import org.ray.api.id.BaseId;
import org.ray.api.id.ObjectId;
import org.ray.runtime.context.WorkerContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Object store methods for cluster mode. This is a wrapper class for core worker object interface.
*/
public class NativeObjectStore extends ObjectStore {
private static final Logger LOGGER = LoggerFactory.getLogger(NativeObjectStore.class);
/**
* The native pointer of core worker.
*/
private final long nativeCoreWorkerPointer;
public NativeObjectStore(WorkerContext workerContext, long nativeCoreWorkerPointer) {
super(workerContext);
this.nativeCoreWorkerPointer = nativeCoreWorkerPointer;
}
@Override
public ObjectId putRaw(NativeRayObject obj) {
return new ObjectId(nativePut(nativeCoreWorkerPointer, obj));
}
@Override
public void putRaw(NativeRayObject obj, ObjectId objectId) {
nativePut(nativeCoreWorkerPointer, objectId.getBytes(), obj);
}
@Override
public List<NativeRayObject> getRaw(List<ObjectId> objectIds, long timeoutMs) {
return nativeGet(nativeCoreWorkerPointer, toBinaryList(objectIds), timeoutMs);
}
@Override
public List<Boolean> wait(List<ObjectId> objectIds, int numObjects, long timeoutMs) {
return nativeWait(nativeCoreWorkerPointer, toBinaryList(objectIds), numObjects, timeoutMs);
}
@Override
public void delete(List<ObjectId> objectIds, boolean localOnly, boolean deleteCreatingTasks) {
nativeDelete(nativeCoreWorkerPointer, toBinaryList(objectIds), localOnly, deleteCreatingTasks);
}
private static List<byte[]> toBinaryList(List<ObjectId> ids) {
return ids.stream().map(BaseId::getBytes).collect(Collectors.toList());
}
private static native byte[] nativePut(long nativeCoreWorkerPointer, NativeRayObject obj);
private static native void nativePut(long nativeCoreWorkerPointer, byte[] objectId,
NativeRayObject obj);
private static native List<NativeRayObject> nativeGet(long nativeCoreWorkerPointer,
List<byte[]> ids, long timeoutMs);
private static native List<Boolean> nativeWait(long nativeCoreWorkerPointer,
List<byte[]> objectIds, int numObjects, long timeoutMs);
private static native void nativeDelete(long nativeCoreWorkerPointer, List<byte[]> objectIds,
boolean localOnly, boolean deleteCreatingTasks);
}
| zhuohan123/hoplite-rllib | 3 | Python | zhuohan123 | Zhuohan Li | vLLM / Meta |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.