async def create(cls, address: str, **kw):
dones, _ = await asyncio.wait([
mo.create_actor(SupervisorPeerLocatorActor,
'fixed',
address,
uid=SupervisorPeerLocatorActor.default_uid(),
address=address),
mo.create_actor(MockNodeInfoCollectorActor,
uid=NodeInfoCollectorActor.default_uid(),
address=address),
mo.create_actor(NodeInfoUploaderActor,
NodeRole.WORKER,
interval=kw.get('upload_interval'),
band_to_slots=kw.get('band_to_slots'),
use_gpu=kw.get('use_gpu', False),
uid=NodeInfoUploaderActor.default_uid(),
address=address),
])
for task in dones:
try:
task.result()
except mo.ActorAlreadyExist: # pragma: no cover
pass
api = await super().create(address=address)
await api.mark_node_ready()
return api
async def test_slot_assign(actor_pool: ActorPoolType):
pool, slot_manager_ref = actor_pool
call_logs = dict()
group_size = 4
delay = 1
await asyncio.gather(*(mo.create_actor(TaskActor,
call_logs,
slot_id=slot_id,
uid=TaskActor.gen_uid(slot_id),
address=pool.external_address)
for slot_id in range(group_size)))
assert len((await slot_manager_ref.dump_data()).free_slots) == group_size
async def task_fun(idx):
slot_id = await slot_manager_ref.acquire_free_slot(
('session_id', 'subtask_id'))
ref = await mo.actor_ref(uid=TaskActor.gen_uid(slot_id),
address=pool.external_address)
await ref.queued_call(idx, delay)
tasks = []
start_time = time.time()
for idx in range(group_size + 1):
tasks.append(asyncio.create_task(task_fun(idx)))
await asyncio.gather(*tasks)
log_series = pd.Series(call_logs).sort_index() - start_time
assert len(log_series) == group_size + 1
assert log_series.iloc[:group_size].max() < delay / 4
assert log_series.iloc[group_size:].min() > delay / 4
call_logs.clear()
tasks = []
start_time = time.time()
for idx in range(group_size * 2 + 1):
tasks.append(asyncio.create_task(task_fun(idx)))
await asyncio.sleep(delay / 10)
tasks[group_size].cancel()
await asyncio.wait(tasks)
with pytest.raises(asyncio.CancelledError):
tasks[group_size].result()
log_series = pd.Series(call_logs).sort_index() - start_time
assert len(log_series) == group_size * 2
assert log_series.iloc[:group_size].max() < delay / 4
assert log_series.iloc[group_size:].min() > delay / 4