scripts/hybrid_concurrent_server.py

"""Isolated hybrid_v1 sessions sharing one serial, FIFO inference executor.

The unchanged loader's instance-level controlled_infer closes over its original
policy. We deliberately rebind the class method for each independent wrapper,
then reproduce that control context. Merely shallow-copying the wrapper would
silently execute every session on the original object.
"""
import asyncio
from concurrent.futures import ThreadPoolExecutor
import copy
import hashlib
import os
from pathlib import Path
import random
import threading
import time
import uuid

import numpy as np

from hybrid_transport import (HybridPolicyServer, InfrastructureError, Packer,
                              PROTOCOL, ProtocolSession, append_record,
                              infer_with_noise, unpackb)

CONCURRENCY_PROTOCOL = 'hybrid_concurrency_v1'
GEOMETRY_FIELDS = ('pos_embeds', 'position_embeddings', 'cu_seqlens',
                   'visual_split_sizes', 'visual_max_seqlen')


def infer_fixed_robotwin(policy, observation, noise):
    """Retain the frozen single-observation geometry used by offline warmup."""
    if not observation.get('reset'):
        if 'batch' in observation:
            raise InfrastructureError('Concurrent service does not support dynamic batching')
        for name in ('cam_high', 'cam_left_wrist', 'cam_right_wrist'):
            value = observation.get('observation.images.' + name)
            if (not isinstance(value, np.ndarray) or value.dtype != np.uint8 or
                    value.shape != (240, 320, 3)):
                raise InfrastructureError('Expected three raw uint8 240x320 RGB images')
    return infer_with_noise(policy, observation, noise)


class SessionRNG:
    """Global generators are switched only by the dedicated inference thread."""
    def __init__(self, torch_module=None):
        self.torch = torch_module

    def capture(self):
        state = {'python': random.getstate(), 'numpy': np.random.get_state(),
                 'hash_seed': os.environ.get('PYTHONHASHSEED')}
        if self.torch is not None:
            state['torch'] = self.torch.get_rng_state().clone()
            state['cuda'] = [x.clone() for x in self.torch.cuda.get_rng_state_all()]
        return state

    def restore(self, state):
        random.setstate(state['python'])
        np.random.set_state(state['numpy'])
        if state['hash_seed'] is None:
            os.environ.pop('PYTHONHASHSEED', None)
        else:
            os.environ['PYTHONHASHSEED'] = state['hash_seed']
        if self.torch is not None:
            self.torch.set_rng_state(state['torch'])
            self.torch.cuda.set_rng_state_all(state['cuda'])


def clone_official_policy(original, torch_module=None):
    """Independent wrapper/transform/tokenizer state, shared parameter tensors.

    This audited adapter supports the frozen RoboTwin policy, batch=1, chunk_ret
    and no compilation. All copies and inference execute on the same thread.
    The neural model is shared; its per-call KV cache is local in sample_actions.
    The small persistent visual-geometry cache is separately switched below.
    """
    if torch_module is None:
        import torch as torch_module
    if not original.chunk_ret or original.use_compile:
        raise InfrastructureError('Concurrency requires chunk_ret=True and compile=False')
    replica = copy.copy(original)
    shared = {'vla', 'sample_actions_fn', 'infer'}
    cleared = {'last_action_chunk', 'last_normalized_action_chunk'}
    for name, value in vars(original).items():
        if name in cleared:
            setattr(replica, name, None)
        elif name not in shared:
            setattr(replica, name, copy.deepcopy(value))
    replica.global_step = 0
    # nn.Module shallow copies otherwise share these registration containers.
    replica.vla = copy.copy(original.vla)
    for name in ('_modules', '_buffers', '_parameters'):
        if hasattr(original.vla, name):
            setattr(replica.vla, name, dict(getattr(original.vla, name)))
    if hasattr(replica.vla, '_modules'):
        replica.vla._modules.pop('feature_transform', None)
    replica.vla.__dict__.pop('feature_transform', None)
    replica.vla.feature_transform = None
    # Keep the copied processor and tokenizer coherent; both are CPU objects.
    if hasattr(replica, 'processor'):
        replica.language_tokenizer = replica.processor.tokenizer
    if hasattr(replica.vla, 'config'):
        replica.vla.config = replica.config
    raw_infer = type(original).infer.__get__(replica, type(replica))

    def controlled_infer(observation):
        if observation.get('reset'):
            from deploy.lingbot_vla_v2_policy import set_seed_everywhere
            set_seed_everywhere(int(observation.get('policy_seed', 42)))
        with torch_module.inference_mode(), torch_module.autocast('cuda', enabled=False):
            return raw_infer(observation)

    replica.infer = controlled_infer
    return replica


class IsolatedSession:
    def __init__(self, original, noise_shape, synchronize, policy_factory,
                 infer_adapter, rng):
        self.original = original
        self.synchronize = synchronize
        self.policy_factory = policy_factory
        self.infer_adapter = infer_adapter
        self.rng = rng
        self.rng_state = None
        self.policy = None
        self.geometry = None
        self.protocol = ProtocolSession(self.infer, noise_shape, synchronize)
        self.closed = threading.Event()
        self.connection_id = uuid.uuid4().hex

    def infer(self, observation, noise):
        return self.infer_adapter(self.policy, observation, noise)

    def process(self, request, digest, enqueued_at, fifo_index, pending):
        started = time.perf_counter()
        if self.closed.is_set():
            raise InfrastructureError('Connection closed before queued request execution')
        queue_ms = (started - enqueued_at) * 1000
        init_ms = 0.0
        if self.policy is None:
            init_started = time.perf_counter()
            self.policy = self.policy_factory(self.original)
            init_ms = (time.perf_counter() - init_started) * 1000
        switch_started = time.perf_counter()
        ambient_rng = self.rng.capture()
        if self.rng_state is not None:
            self.rng.restore(self.rng_state)
        # Precompute geometry is not episode history. Still save/restore it so
        # a reset or later cache allocation cannot affect another connection.
        model = getattr(getattr(self.policy, 'vla', None), 'model', None)
        geometry_owner = getattr(model, 'qwenvl_with_expert', None)
        original_geometry = None
        if geometry_owner is not None:
            original_geometry = {key: getattr(geometry_owner, key)
                                 for key in GEOMETRY_FIELDS}
            if self.geometry is None:
                self.geometry = dict(original_geometry)
            for key, value in self.geometry.items():
                setattr(geometry_owner, key, value)
        switch_ms = (time.perf_counter() - switch_started) * 1000
        try:
            # ProtocolSession performs identity/noise validation and measures
            # CUDA-synchronized inference, excluding queue and state switching.
            response, duplicate = self.protocol.process(request, digest)
        finally:
            switch_started = time.perf_counter()
            self.rng_state = self.rng.capture()
            self.rng.restore(ambient_rng)
            if geometry_owner is not None:
                self.geometry = {key: getattr(geometry_owner, key)
                                 for key in GEOMETRY_FIELDS}
                for key, value in original_geometry.items():
                    setattr(geometry_owner, key, value)
            switch_ms += (time.perf_counter() - switch_started) * 1000
        # Preserve cached actions, while reporting the actual cost of this
        # delivery. A duplicate never executes infer or advances RNG/state.
        response = dict(response)
        if duplicate:
            response['server_cached_infer_ms'] = response['server_infer_ms']
            response['server_infer_ms'] = 0.0
        response.update(concurrency_protocol=CONCURRENCY_PROTOCOL,
                        server_queue_ms=queue_ms,
                        server_state_switch_ms=switch_ms,
                        server_session_init_ms=init_ms,
                        server_fifo_index=fifo_index,
                        server_pending_at_enqueue=pending,
                        server_execution_thread_id=threading.get_ident(),
                        duplicate=duplicate)
        return response, duplicate

    def release(self):
        self.closed.set()
        if self.policy is not None:
            # Break controlled_infer -> bound method -> replica cycles now,
            # without waiting for GC to reclaim large CPU tokenizer copies.
            self.policy.__dict__.pop('infer', None)
            self.policy.last_action_chunk = None
            self.policy.last_normalized_action_chunk = None
            self.policy.vla.feature_transform = None
        self.policy = self.geometry = self.rng_state = None
        self.protocol.cache.clear()
        self.protocol.seen_sessions.clear()
        self.protocol.infer = None


class ConcurrentHybridPolicyServer(HybridPolicyServer):
    def __init__(self, *args, max_clients=4, policy_factory=None,
                 infer_adapter=None, rng=None, **kwargs):
        if type(max_clients) is not int or not 1 <= max_clients <= 8:
            raise ValueError('max_clients must be an integer between 1 and 8')
        super().__init__(*args, **kwargs)
        if self.log_path is not None:
            self.log_path = Path(self.log_path).resolve()
        self.max_clients = max_clients
        self.policy_factory = policy_factory or clone_official_policy
        self.infer_adapter = infer_adapter or infer_fixed_robotwin
        if rng is None:
            import torch
            rng = SessionRNG(torch)
        self.rng = rng
        self.executor = ThreadPoolExecutor(max_workers=1,
                                           thread_name_prefix='hybrid-policy-fifo')
        self.connections = set()
        self._fifo = self._pending = 0
        self.metadata.update(
            concurrency_protocol=CONCURRENCY_PROTOCOL,
            max_clients=max_clients,
            scheduler='FIFO_single_inference_thread_no_batching',
            session_isolation='independent_policy_vla_facade_processor_transform_chunks_and_RNG',
            shared_weights=True, model_replicas=1,
            geometry_cache='session_switched_fixed_3x240x320_RGB_batch1',
            queue_timing='from_decoded_request_enqueue_to_executor_entry',
            inference_timing='ProtocolSession_CUDA_synchronized_excludes_queue_and_state_switch',
            duplicate_timing='cached_result_no_execution_server_infer_ms_zero')

    async def run(self):
        try:
            await super().run()
        finally:
            self.executor.shutdown(wait=True, cancel_futures=True)

    async def submit(self, session, request, digest):
        if session.closed.is_set():
            raise InfrastructureError('Connection is closed')
        self._fifo += 1
        self._pending += 1
        enqueued_at = time.perf_counter()
        future = asyncio.get_running_loop().run_in_executor(
            self.executor, session.process, request, digest, enqueued_at,
            self._fifo, self._pending)
        try:
            # Handler cancellation must not release session state while CUDA
            # still uses it. Shield preserves completion of in-flight work.
            return await asyncio.shield(future)
        except asyncio.CancelledError:
            session.closed.set()
            # Multiple shutdown/cancellation signals still must not let a
            # handler release its replica while the worker is using it.
            while not future.done():
                try:
                    await asyncio.shield(future)
                except asyncio.CancelledError:
                    continue
                except Exception:
                    break
            if not future.cancelled():
                future.exception()  # consume a discarded worker exception
            raise
        finally:
            self._pending -= 1

    async def _handler(self, websocket):
        from websockets.exceptions import ConnectionClosed
        if len(self.connections) >= self.max_clients:
            append_record(self.log_path, {'timestamp': time.time(),
                          'event': 'client_limit_rejected', 'max_clients': self.max_clients})
            await websocket.close(code=1013, reason='Concurrent policy client limit reached')
            return
        session = IsolatedSession(self.policy, self.noise_shape, self.synchronize,
                                  self.policy_factory, self.infer_adapter, self.rng)
        self.connections.add(session)
        packer = Packer()
        disconnected = asyncio.create_task(websocket.wait_closed())
        # Flag queued work immediately on disconnect. In-flight GPU execution
        # completes in the same worker; its response is then discarded.
        disconnected.add_done_callback(lambda _: session.closed.set())
        append_record(self.log_path, {'timestamp': time.time(), 'event': 'client_connected',
                      'connection_id': session.connection_id,
                      'active_clients': len(self.connections)})
        try:
            await websocket.send(packer.pack(self.metadata))
            while True:
                raw = await websocket.recv()
                if not isinstance(raw, bytes):
                    raise InfrastructureError('Expected a binary request')
                started = time.perf_counter()
                request = unpackb(raw)
                unpack_ms = (time.perf_counter() - started) * 1000
                digest = hashlib.sha256(raw).hexdigest()
                response, duplicate = await self.submit(session, request, digest)
                started = time.perf_counter()
                payload = packer.pack(response)
                pack_ms = (time.perf_counter() - started) * 1000
                started = time.perf_counter()
                if not session.closed.is_set():
                    await websocket.send(payload)
                send_ms = (time.perf_counter() - started) * 1000
                append_record(self.log_path, {
                    'timestamp': time.time(), 'connection_id': session.connection_id,
                    'active_clients': len(self.connections),
                    'session_id': response['session_id'],
                    'episode_id': response['episode_id'], 'sequence_id': response['sequence_id'],
                    'operation': request['operation'], 'duplicate': duplicate,
                    'request_sha256': digest, 'noise_sha256': response['noise_sha256'],
                    'request_bytes': len(raw), 'response_bytes': len(payload),
                    'server_unpack_ms': unpack_ms, 'server_pack_ms': pack_ms,
                    'server_send_ms': send_ms,
                    **{key: value for key, value in response.items()
                       if key.startswith('server_') or key == 'concurrency_protocol'},
                    'response_discarded_after_disconnect': session.closed.is_set()})
                if session.closed.is_set():
                    break
        except ConnectionClosed:
            pass
        except Exception as error:
            append_record(self.log_path, {'timestamp': time.time(),
                          'connection_id': session.connection_id,
                          'event': 'infrastructure_error', 'error': str(error)})
            try:
                if not session.closed.is_set():
                    await websocket.send(packer.pack({'protocol': PROTOCOL, 'error': str(error)}))
                    await websocket.close(code=1011, reason='Episode invalidated')
            except ConnectionClosed:
                pass
        finally:
            disconnected.cancel()
            session.release()
            self.connections.discard(session)
            append_record(self.log_path, {'timestamp': time.time(), 'event': 'client_disconnected',
                          'connection_id': session.connection_id,
                          'active_clients': len(self.connections)})