def test_placement_group_client_option_serialization(): """Tests conversion of placement group to json-serializable dict and back. Tests conversion placement_group -> dict -> placement_group and dict -> placement_group -> dict with and without non-null bundle cache. """ # Tests conversion from dict to placement group and back. def dict_to_pg_to_dict(pg_dict_in): pg = PlacementGroup.from_dict(pg_dict_in) pg_dict_out = pg.to_dict() assert pg_dict_in == pg_dict_out # Tests conversion from placement group to dict and back. def pg_to_dict_to_pg(pg_in): pg_dict = pg_in.to_dict() pg_out = PlacementGroup.from_dict(pg_dict) assert pg_out.id == pg_in.id assert pg_out.bundle_cache == pg_in.bundle_cache pg_id = PlacementGroupID(id=bytes(16)) id_string = bytes(16).hex() bundle_cache = [{"CPU": 2}, {"custom_resource": 5}] pg_with_bundles = PlacementGroup(id=pg_id, bundle_cache=bundle_cache) pg_to_dict_to_pg(pg_with_bundles) pg_no_bundles = PlacementGroup(id=pg_id) pg_to_dict_to_pg(pg_no_bundles) pg_dict_with_bundles = {"id": id_string, "bundle_cache": bundle_cache} dict_to_pg_to_dict(pg_dict_with_bundles) pg_dict_no_bundles = {"id": id_string, "bundle_cache": None} dict_to_pg_to_dict(pg_dict_no_bundles)
def test_remove_placement_group(ray_start_cluster, connect_to_client): cluster = ray_start_cluster cluster.add_node(num_cpus=4) ray.init(address=cluster.address) @ray.remote def warmup(): pass # warm up the cluster. ray.get([warmup.remote() for _ in range(4)]) with connect_to_client_or_not(connect_to_client): # First try to remove a placement group that doesn't # exist. This should not do anything. random_group_id = PlacementGroupID.from_random() random_placement_group = PlacementGroup(random_group_id) for _ in range(3): ray.util.remove_placement_group(random_placement_group) # Creating a placement group as soon as it is # created should work. placement_group = ray.util.placement_group([{"CPU": 2}, {"CPU": 2}]) assert placement_group.wait(10) ray.util.remove_placement_group(placement_group) wait_for_condition(lambda: is_placement_group_removed(placement_group)) # # Now let's create a placement group. placement_group = ray.util.placement_group([{"CPU": 2}, {"CPU": 2}]) assert placement_group.wait(10) # Create an actor that occupies resources. @ray.remote(num_cpus=2) class A: def f(self): return 3 # Currently, there's no way to prevent # tasks to be retried for removed placement group. # Set max_retrie=0 for testing. # TODO(sang): Handle this edge case. @ray.remote(num_cpus=2, max_retries=0) def long_running_task(): print(os.getpid()) import time time.sleep(50) # Schedule a long running task and actor. task_ref = long_running_task.options( placement_group=placement_group).remote() a = A.options(placement_group=placement_group).remote() assert ray.get(a.f.remote()) == 3 ray.util.remove_placement_group(placement_group) # Subsequent remove request shouldn't do anything. for _ in range(3): ray.util.remove_placement_group(placement_group) # Make sure placement group resources are # released and we can schedule this task. @ray.remote(num_cpus=4) def f(): return 3 assert ray.get(f.remote()) == 3 # Since the placement group is removed, # the actor should've been killed. # That means this request should fail. with pytest.raises(ray.exceptions.RayActorError, match="actor died"): ray.get(a.f.remote(), timeout=3.0) with pytest.raises(ray.exceptions.WorkerCrashedError): ray.get(task_ref)