# Ray function

###### November 8, 2022

To parallelize a function with the Ray framework, decorate the function with `@ray.remote` to run the function remotely. Call the function with `.remote()` instead of calling it normally. The remote call yields a future that must be fetched with `ray.get`. The example below compares a parallel Ray function to a standard non-parallel function. A computationally expensive task is simulated by using the `sleep()` function.

``````import ray
import time

@ray.remote
def squared(x):
time.sleep(1)
y = x**2
return y

def squared2(x):
time.sleep(1)
y = x**2
return y

def run_ray():
"""
Execute a Python function in parallel using Ray. Compare elapsed time to
the non-parallel example `run_noray()`.
"""
ray.init()

tic = time.perf_counter()

lazy_values = [squared.remote(x) for x in range(8)]
values = ray.get(lazy_values)

toc = time.perf_counter()

print(f'Elapsed time {toc - tic:.2f} s')
print(values)

ray.shutdown()

def run_noray():
"""
Execute a Python function in series, not in parallel. Compare elapsed time
to the Ray parallel example `run_ray()`.
"""
tic = time.perf_counter()

values = [squared2(x) for x in range(8)]

toc = time.perf_counter()

print(f'Elapsed time {toc - tic:.2f} s')
print(values)

def main():
"""
Run the Ray example or the non-Ray example.
"""
# run_ray()
run_noray()

if __name__ == '__main__':
main()
``````

Results from running the above example on a 6-core MacBook Pro are shown below. As expected, the example that uses the parallel Ray function has the fastest elapsed time.

``````# Results from running the parallel Ray function
Elapsed time 1.02 s
[0, 1, 4, 9, 16, 25, 36, 49]

# Results from running the non-parallel function
Elapsed time 8.02 s
[0, 1, 4, 9, 16, 25, 36, 49]
``````