Map overlap GPUs through infer placement

[TianyeGGBond]

Context

_wait_for_overlap_engines_offloaded receives physical GPU IDs from the scheduler, while the rollout manager expects local engine indices within the pipeline's inference placement. The previous conversion assumed the inference GPUs were contiguous and derived engine indices by subtracting the first GPU ID.

Change

• add _resolve_overlap_infer_engines under the file's Helpers section
• resolve overlapping train GPUs through the configured actor_infer placement
• return explicit overlap_engine_indices and overlap_gpu_ids for the wait logic
• reject inference mappings whose length is not divisible by rollout_num_gpus_per_engine

Validation

• python -m py_compile rlix/pipeline/miles_pipeline.py
• git diff --check

[JunzheJoe]

Verified against HEAD and the coordinator's mapping convention:

• The gpu_to_engine grouping (placement order, per_engine GPUs per engine) matches the C6 first-build contiguous-mapping convention the coordinator uses (device_mapping[dp_rank*tp_size : ...]), so local indices agree across both consumers.
• The filter semantics are the actual bug fix: old code computed arithmetic indices for train GPUs even when they were outside the infer pool (M11.2 P2 pool [2,3] → bogus local index → states.get(i, '?') never converges → full timeout burned). Now non-overlap GPUs are excluded and fully-disjoint topologies return early — correct, since there is nothing to wait for.
• Fallback range(rollout_num_gpus) preserved; the divisibility raise is a fail-fast improvement over silently mis-grouping.
• The "actor_infer" literal is consistent with what HEAD still does at the other cluster_device_mappings sites (the merged #30 rename covered cluster IDs, not these mapping keys), so no regression — the literal cleanup can stay a separate batch.

Sequencing note: #19/#20/#21 all edit _wait_for_overlap_engines_offloaded and #19/#20 collide on the same warn-block lines. Suggest landing this one first (it's the refactor), then #20 rebases its raises onto it, then #21. LGTM.

[JunzheJoe]

Follow-up after learning (via #21's closure) that _wait_for_overlap_engines_offloaded was rewritten on the base branch (howard989, 4af2fc4 — Phase 2 is now a whole-GPU residual used hard gate instead of the free-mem wait loop). Reconciled this PR against the current HEAD:

• The bug this PR fixes is still live on HEAD: the rewritten function kept the old arithmetic conversion (g - infer_first) // per_engine (lines 541-543), so the M11.2 bogus-local-index problem this PR solves is not superseded — the fix is still wanted.
• But the diff no longer applies (GitHub reports CONFLICTING): the Phase-2 hunks here target the removed free-mem loop. After a rebase the new _resolve_overlap_infer_engines helper actually plugs in cleanly — Phase 1 consumes overlap_engine_indices, and the new residual gate consumes overlap_gpu_ids in place of target_gpu_ids.

My approval stands for the mapping fix itself; needs the rebase onto the rewritten function before it can land.

[Kynnet]

I agree with Joe, MILES_MAX_RESIDUAL_GPU_MEM_GB causes merge conflicts, but the fix is good