def test_wait(ray_start_regular_shared): server = ray_client_server.serve("localhost:50051", test_mode=True) ray.connect("localhost:50051") objectref = ray.put("hello world") ready, remaining = ray.wait([objectref]) assert remaining == [] retval = ray.get(ready[0]) assert retval == "hello world" objectref2 = ray.put(5) ready, remaining = ray.wait([objectref, objectref2]) assert (ready, remaining) == ([objectref], [objectref2]) or \ (ready, remaining) == ([objectref2], [objectref]) ready_retval = ray.get(ready[0]) remaining_retval = ray.get(remaining[0]) assert (ready_retval, remaining_retval) == ("hello world", 5) \ or (ready_retval, remaining_retval) == (5, "hello world") with pytest.raises(Exception): # Reference not in the object store. ray.wait([ClientObjectRef("blabla")]) with pytest.raises(AssertionError): ray.wait("blabla") with pytest.raises(AssertionError): ray.wait(ClientObjectRef("blabla")) with pytest.raises(AssertionError): ray.wait(["blabla"]) ray.disconnect() server.stop(0)
def test_put_get(shutdown_only): ray.init(num_cpus=0) for i in range(100): value_before = i * 10**6 object_ref = ray.put(value_before) value_after = ray.get(object_ref) assert value_before == value_after for i in range(100): value_before = i * 10**6 * 1.0 object_ref = ray.put(value_before) value_after = ray.get(object_ref) assert value_before == value_after for i in range(100): value_before = "h" * i object_ref = ray.put(value_before) value_after = ray.get(object_ref) assert value_before == value_after for i in range(100): value_before = [1] * i object_ref = ray.put(value_before) value_after = ray.get(object_ref) assert value_before == value_after
def test_duplicate_args(ray_start_regular_shared): @ray.remote def f(arg1, arg2, arg1_duplicate, kwarg1=None, kwarg2=None, kwarg1_duplicate=None): assert arg1 == kwarg1 assert arg1 != arg2 assert arg1 == arg1_duplicate assert kwarg1 != kwarg2 assert kwarg1 == kwarg1_duplicate # Test by-value arguments. arg1 = [1] arg2 = [2] ray.get( f.remote( arg1, arg2, arg1, kwarg1=arg1, kwarg2=arg2, kwarg1_duplicate=arg1)) # Test by-reference arguments. arg1 = ray.put([1]) arg2 = ray.put([2]) ray.get( f.remote( arg1, arg2, arg1, kwarg1=arg1, kwarg2=arg2, kwarg1_duplicate=arg1))
def test_wait(ray_start_regular_shared): with ray_start_client_server() as ray: objectref = ray.put("hello world") ready, remaining = ray.wait([objectref]) assert remaining == [] retval = ray.get(ready[0]) assert retval == "hello world" objectref2 = ray.put(5) ready, remaining = ray.wait([objectref, objectref2]) assert (ready, remaining) == ([objectref], [objectref2]) or \ (ready, remaining) == ([objectref2], [objectref]) ready_retval = ray.get(ready[0]) remaining_retval = ray.get(remaining[0]) assert (ready_retval, remaining_retval) == ("hello world", 5) \ or (ready_retval, remaining_retval) == (5, "hello world") with pytest.raises(Exception): # Reference not in the object store. ray.wait([ClientObjectRef("blabla")]) with pytest.raises(AssertionError): ray.wait("blabla") with pytest.raises(AssertionError): ray.wait(ClientObjectRef("blabla")) with pytest.raises(AssertionError): ray.wait(["blabla"])
def test_illegal_api_calls(ray_start_regular): # Verify that we cannot call put on an ObjectRef. x = ray.put(1) with pytest.raises(Exception): ray.put(x) # Verify that we cannot call get on a regular value. with pytest.raises(Exception): ray.get(3)
def test_putting_object_that_closes_over_object_ref( ray_start_shared_local_modes): # This test is here to prevent a regression of # https://github.com/ray-project/ray/issues/1317. class Foo: def __init__(self): self.val = ray.put(0) def method(self): f f = Foo() ray.put(f)
def test_passing_arguments_by_value_out_of_the_box( ray_start_shared_local_modes): @ray.remote def f(x): return x # Test passing lambdas. def temp(): return 1 assert ray.get(f.remote(temp))() == 1 assert ray.get(f.remote(lambda x: x + 1))(3) == 4 # Test sets. assert ray.get(f.remote(set())) == set() s = {1, (1, 2, "hi")} assert ray.get(f.remote(s)) == s # Test types. assert ray.get(f.remote(int)) == int assert ray.get(f.remote(float)) == float assert ray.get(f.remote(str)) == str class Foo: def __init__(self): pass # Make sure that we can put and get a custom type. Note that the result # won't be "equal" to Foo. ray.get(ray.put(Foo))
def test_fetch_local(ray_start_cluster_head): cluster = ray_start_cluster_head cluster.add_node(num_cpus=2, object_store_memory=75 * 1024 * 1024) signal_actor = ray.test_utils.SignalActor.remote() @ray.remote def put(): ray.wait([signal_actor.wait.remote()]) return np.random.rand(5 * 1024 * 1024) # 40 MB data local_ref = ray.put(np.random.rand(5 * 1024 * 1024)) remote_ref = put.remote() # Data is not ready in any node (ready_ref, remaining_ref) = ray.wait([remote_ref], timeout=2, fetch_local=False) assert (0, 1) == (len(ready_ref), len(remaining_ref)) ray.wait([signal_actor.send.remote()]) # Data is ready in some node, but not local node. (ready_ref, remaining_ref) = ray.wait([remote_ref], fetch_local=False) assert (1, 0) == (len(ready_ref), len(remaining_ref)) (ready_ref, remaining_ref) = ray.wait([remote_ref], timeout=2, fetch_local=True) assert (0, 1) == (len(ready_ref), len(remaining_ref)) del local_ref (ready_ref, remaining_ref) = ray.wait([remote_ref], fetch_local=True) assert (1, 0) == (len(ready_ref), len(remaining_ref))
def test_put_get(ray_start_regular_shared): with ray_start_client_server() as ray: objectref = ray.put("hello world") print(objectref) retval = ray.get(objectref) assert retval == "hello world"
def _ensure_ref(self): if self._ref is None: # As before, set the state of the reference to be an # in-progress self reference value, which # the encoding can detect and handle correctly. self._ref = SelfReferenceSentinel() self._ref = ray.put(self.actor_cls)
def _prepare_client_task(self) -> ray_client_pb2.ClientTask: if self._ref is None: self._ref = ray.put(self.actor_cls) task = ray_client_pb2.ClientTask() task.type = ray_client_pb2.ClientTask.ACTOR task.name = self._name task.payload_id = self._ref.handle return task
def _prepare_client_task(self) -> ray_client_pb2.ClientTask: if self._ref is None: self._ref = ray.put(self._func) task = ray_client_pb2.ClientTask() task.type = ray_client_pb2.ClientTask.FUNCTION task.name = self._name task.payload_id = self._ref.handle return task
def test_profiling_api(ray_start_2_cpus): @ray.remote def f(): with ray.profile("custom_event", extra_data={"name": "custom name"}): pass ray.put(1) object_ref = f.remote() ray.wait([object_ref]) ray.get(object_ref) # Wait until all of the profiling information appears in the profile # table. timeout_seconds = 20 start_time = time.time() while True: profile_data = ray.timeline() event_types = {event["cat"] for event in profile_data} expected_types = [ "task", "task:deserialize_arguments", "task:execute", "task:store_outputs", "wait_for_function", "ray.get", "ray.put", "ray.wait", "submit_task", "fetch_and_run_function", # TODO (Alex) :https://github.com/ray-project/ray/pull/9346 # "register_remote_function", "custom_event", # This is the custom one from ray.profile. ] if all(expected_type in event_types for expected_type in expected_types): break if time.time() - start_time > timeout_seconds: raise RayTestTimeoutException( "Timed out while waiting for information in " "profile table. Missing events: {}.".format( set(expected_types) - set(event_types))) # The profiling information only flushes once every second. time.sleep(1.1)
def test_wait(ray_start_regular_shared): @ray.remote def f(delay): time.sleep(delay) return object_refs = [f.remote(0), f.remote(0), f.remote(0), f.remote(0)] ready_ids, remaining_ids = ray.wait(object_refs) assert len(ready_ids) == 1 assert len(remaining_ids) == 3 ready_ids, remaining_ids = ray.wait(object_refs, num_returns=4) assert set(ready_ids) == set(object_refs) assert remaining_ids == [] object_refs = [f.remote(0), f.remote(5)] ready_ids, remaining_ids = ray.wait( object_refs, timeout=0.5, num_returns=2) assert len(ready_ids) == 1 assert len(remaining_ids) == 1 # Verify that calling wait with duplicate object refs throws an # exception. x = ray.put(1) with pytest.raises(Exception): ray.wait([x, x]) # Make sure it is possible to call wait with an empty list. ready_ids, remaining_ids = ray.wait([]) assert ready_ids == [] assert remaining_ids == [] # Test semantics of num_returns with no timeout. obj_refs = [ray.put(i) for i in range(10)] (found, rest) = ray.wait(obj_refs, num_returns=2) assert len(found) == 2 assert len(rest) == 8 # Verify that incorrect usage raises a TypeError. x = ray.put(1) with pytest.raises(TypeError): ray.wait(x) with pytest.raises(TypeError): ray.wait(1) with pytest.raises(TypeError): ray.wait([1])
def test_get_multiple(ray_start_regular_shared): object_refs = [ray.put(i) for i in range(10)] assert ray.get(object_refs) == list(range(10)) # Get a random choice of object refs with duplicates. indices = list(np.random.choice(range(10), 5)) indices += indices results = ray.get([object_refs[i] for i in indices]) assert results == indices
def test_put_get(ray_start_regular_shared): server = ray_client_server.serve("localhost:50051") ray.connect("localhost:50051") objectref = ray.put("hello world") print(objectref) retval = ray.get(objectref) assert retval == "hello world" ray.disconnect() server.stop(0)
def _ensure_ref(self): if self._ref is None: # While calling ray.put() on our function, if # our function is recursive, it will attempt to # encode the ClientRemoteFunc -- itself -- and # infinitely recurse on _ensure_ref. # # So we set the state of the reference to be an # in-progress self reference value, which # the encoding can detect and handle correctly. self._ref = SelfReferenceSentinel() self._ref = ray.put(self._func)
def test_system_config_when_connecting(ray_start_cluster): config = {"object_pinning_enabled": 0, "object_timeout_milliseconds": 200} cluster = ray.cluster_utils.Cluster() cluster.add_node( _system_config=config, object_store_memory=100 * 1024 * 1024) cluster.wait_for_nodes() # Specifying _system_config when connecting to a cluster is disallowed. with pytest.raises(ValueError): ray.init(address=cluster.address, _system_config=config) # Check that the config was picked up (object pinning is disabled). ray.init(address=cluster.address) obj_ref = ray.put(np.zeros(40 * 1024 * 1024, dtype=np.uint8)) for _ in range(5): put_ref = ray.put(np.zeros(40 * 1024 * 1024, dtype=np.uint8)) del put_ref # This would not raise an exception if object pinning was enabled. with pytest.raises(ray.exceptions.ObjectLostError): ray.get(obj_ref)
def test_object_id_backward_compatibility(ray_start_shared_local_modes): # We've renamed Python's `ObjectID` to `ObjectRef`, and added a type # alias for backward compatibility. # This test is to make sure legacy code can still use `ObjectID`. # TODO(hchen): once we completely remove Python's `ObjectID`, # this test can be removed as well. # Check that these 2 types are the same. assert ray.ObjectID == ray.ObjectRef object_ref = ray.put(1) # Check that users can use either type in `isinstance` assert isinstance(object_ref, ray.ObjectID) assert isinstance(object_ref, ray.ObjectRef)
def test_ray_recursive_objects(ray_start_shared_local_modes): class ClassA: pass # Make a list that contains itself. lst = [] lst.append(lst) # Make an object that contains itself as a field. a1 = ClassA() a1.field = a1 # Make two objects that contain each other as fields. a2 = ClassA() a3 = ClassA() a2.field = a3 a3.field = a2 # Make a dictionary that contains itself. d1 = {} d1["key"] = d1 # Create a list of recursive objects. recursive_objects = [lst, a1, a2, a3, d1] # Serialize the recursive objects. for obj in recursive_objects: ray.put(obj)
def test_basic_log_stream(ray_start_regular_shared): with ray_start_client_server() as ray: log_msgs = [] def test_log(level, msg): log_msgs.append(msg) ray.worker.log_client.log = test_log ray.worker.log_client.set_logstream_level(logging.DEBUG) # Allow some time to propogate time.sleep(1) x = ray.put("Foo") assert ray.get(x) == "Foo" time.sleep(1) logs_with_id = [msg for msg in log_msgs if msg.find(x.id.hex()) >= 0] assert len(logs_with_id) >= 2 assert any((msg.find("get") >= 0 for msg in logs_with_id)) assert any((msg.find("put") >= 0 for msg in logs_with_id))
def background_thread(self, wait_objects): try: # Test wait ready, _ = ray.wait( wait_objects, num_returns=len(wait_objects), timeout=1000.0, ) assert len(ready) == len(wait_objects) for _ in range(20): num = 10 # Test remote call results = [echo.remote(i) for i in range(num)] assert ray.get(results) == list(range(num)) # Test put and get objects = [ray.put(i) for i in range(num)] assert ray.get(objects) == list(range(num)) time.sleep(random.randint(0, 10) / 1000.0) except Exception as e: with self.lock: self.thread_results.append(e) else: with self.lock: self.thread_results.append("ok")
return 1 # This hits the "nested tasks" issue # https://github.com/ray-project/ray/issues/3644 # So we're on the right track! return ray.get(fact.remote(x - 1)) * x @ray.remote def get_nodes(): return ray.nodes() # Can access the full Ray API in remote methods. print("Cluster nodes", ray.get(get_nodes.remote())) print(ray.nodes()) objectref = ray.put("hello world") # `ClientObjectRef(...)` print(objectref) # `hello world` print(ray.get(objectref)) ref2 = plus2.remote(234) # `ClientObjectRef(...)` print(ref2) # `236` print(ray.get(ref2)) ref3 = fact.remote(20) # `ClientObjectRef(...)`
def test_put_and_get(): value = random.randint(0, 1000000) result = ray.get(ray.put(value)) assert value == result
def __init__(self): self.val = ray.put(0)