class MultiWebsocketPolicy:
"""Query one policy server per logical environment while OmniGibson steps them together."""
def __init__(
self, endpoints: list[dict], allow_reconnect: bool = True, action_chunk_size: int = 0, scheme: str = "ws"
) -> None:
self.clients = [
WebsocketClientPolicy(
host=endpoint["host"],
port=endpoint["port"],
scheme=scheme,
allow_reconnect=allow_reconnect,
action_chunk_size=action_chunk_size,
)
for endpoint in endpoints
]
self.executor = ThreadPoolExecutor(max_workers=len(self.clients))
self.action_dim = None
self.failures = {}
self.time_budget = None
# Charged wall-clock seconds per environment: elapsed = policy_time + sim_time.
self.elapsed = [0.0] * len(self.clients)
self.policy_time = [0.0] * len(self.clients)
self.sim_time = [0.0] * len(self.clients)
def set_action_dim(self, action_dim: int) -> None:
self.action_dim = action_dim
def set_time_budget(self, seconds: Optional[float]) -> None:
self.time_budget = seconds
self.elapsed = [0.0] * len(self.clients)
self.policy_time = [0.0] * len(self.clients)
self.sim_time = [0.0] * len(self.clients)
for client in self.clients:
client.set_deadline(None)
def _run_client(self, env_idx: int, method, *args):
start = time.monotonic()
if self.time_budget is not None:
remaining = self.time_budget - self.elapsed[env_idx]
if remaining <= 0:
raise PolicyTimeoutError("Rollout time budget expired")
self.clients[env_idx].set_deadline(start + remaining)
try:
result = method(*args)
finally:
duration = time.monotonic() - start
self.elapsed[env_idx] += duration
self.policy_time[env_idx] += duration
if self.time_budget is not None and self.elapsed[env_idx] >= self.time_budget:
raise PolicyTimeoutError("Rollout time budget expired")
return result
def reset(self) -> None:
self.failures = {}
futures = {
self.executor.submit(self._run_client, env_idx, client.reset): env_idx
for env_idx, client in enumerate(self.clients)
}
for future in as_completed(futures):
try:
future.result()
except Exception as e:
self.failures[futures[future]] = e
def forward(self, obs: list[dict], active_env_indices: list[int]) -> PolicyBatchResult:
assert self.action_dim is not None
actions = th.zeros((len(self.clients), self.action_dim), dtype=th.float32)
failures = {env_idx: self.failures[env_idx] for env_idx in active_env_indices if env_idx in self.failures}
futures = {
self.executor.submit(
self._run_client,
env_idx,
self.clients[env_idx].act,
{key: value.unsqueeze(0) for key, value in obs[env_idx].items()},
): env_idx
for env_idx in active_env_indices
if env_idx not in failures
}
for future in as_completed(futures):
env_idx = futures[future]
try:
action = future.result()
if action.ndim == 2 and action.shape[0] == 1:
action = action[0]
if action.shape != (self.action_dim,):
raise ValueError(f"Policy {env_idx} returned action shape {tuple(action.shape)}")
actions[env_idx] = action
except Exception as e:
self.failures[env_idx] = failures[env_idx] = e
return PolicyBatchResult(actions=actions, failures=failures)
def charge_simulation(self, seconds: float, active_env_indices: list[int]) -> dict[int, Exception]:
# Finished environments remain in the shared simulation, so the divisor stays fixed.
share = seconds / len(self.clients)
failures = {}
for env_idx in active_env_indices:
self.elapsed[env_idx] += share
self.sim_time[env_idx] += share
if self.time_budget is not None and self.elapsed[env_idx] >= self.time_budget:
error = PolicyTimeoutError("Rollout time budget expired")
self.failures[env_idx] = failures[env_idx] = error
return failures
def close(self) -> None:
for client in self.clients:
client.close()
self.executor.shutdown(wait=True, cancel_futures=True)