rosotacom-dev 2.5.dev76__tar.gz → 2.5.dev78__tar.gz

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev76
+Version: 2.5.dev78
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/docs/findings/neither-a-queue-nor-a-burst-tilts-the-size-law.md

@@ -10,6 +10,7 @@ were emulated against the same measurement chain, and none of them produces it.
 | | 300 B | 1.1 kB | 3.1 kB | 6.1 kB | 12.1 kB | 38.1 kB |
 |---|---:|---:|---:|---:|---:|---:|
 | independent per packet | 1.05 % | 1.47 % | 3.47 % | 6.28 % | 11.23 % | 31.92 % |
+| a two-state process, same mean, 105 ms bad runs | 1.47 % | 1.76 % | 2.76 % | 5.09 % | 10.00 % | **21.98 %** |
 | + a token bucket a burst can fill (4 Mbit/s) | 1.14 % | 1.33 % | 2.57 % | 4.99 % | 13.43 % | 32.92 % |
 | a serialisation constraint (1.5 Mbit/s) | — | 1.62 % | — | — | 11.60 % | **97.54 %** |
 
@@ -17,6 +18,16 @@ were emulated against the same measurement chain, and none of them produces it.
   law is reproduced with residuals of 1.20, 0.85, 1.01, 1.06, 0.97 and 1.00 —
   flat over three decades of size. Whatever tilts the field, it is not the
   wrapper, the join, or the way the fit is taken.
+- **Clustered loss is not the cause, and it bends the curve the other way.**
+  A two-state process at the same 1 % mean, with its chain rescaled per cell so
+  that a bad run is the same 105 ms of wall clock in every one of them, makes
+  the largest class lose **31 % less** than the independent law rather than
+  more: 21.98 % against 31.92 %, intervals 20.3–23.8 against 30.0–33.9. The
+  reason is the one that makes it a mechanism rather than a coincidence — a
+  38-packet message occupies about the length of one bad run, so its packets
+  share a fate and the message is lost once instead of thirty-eight times
+  independently. The field's residual has the opposite sign, so burstiness at
+  this scale does not explain it; it makes it harder to explain.
 - **A burst meeting a queue is not the cause.** A token bucket at 4 Mbit/s —
   above the largest class's mean offered rate of 3.0 Mbit/s and far below its
   instantaneous one, so a 38-packet message meets a queue and a 1-packet
@@ -81,17 +92,30 @@ The queued arm on the same ladder: 24, 28, 54, 105, 283 and 693 losses of about
 2100 offered, giving the second row of the claim table. The tight arm: 34 of
 2104, 244 of 2103, and 1826 of 1872.
 
-**A two-state loss process could not be measured on this ladder, and the reason
-is worth recording.** `netem`'s Gilbert–Elliott model advances its chain once
-per *packet*, not once per second, so a size ladder at a fixed message rate runs
-the chain at a different speed in every cell — 10 packets/s for a one-fragment
+**Measuring the two-state arm took two attempts, and the reason is worth
+recording.** `netem`'s Gilbert–Elliott model advances its chain once per
+*packet*, not once per second, so a size ladder at a fixed message rate runs the
+chain at a different speed in every cell — 10 packets/s for a one-fragment
 message against 380 for a 38-fragment one. The cells then do not share a loss
-process and cannot be compared; the arm measured at a fixed 10 Hz duly reported
-a per-packet mean of 0.33 % in its smallest cell and 0.69 % fitted over the
-ladder, against a stationary 1.00 %, because the small cells never sampled
-enough of the chain. Holding the offered *packet* rate constant is what makes
-such a ladder one experiment, and the profiles file says so beside the fitted
-parameters.
+process. The arm measured that way duly reported a per-packet mean of 0.33 % in
+its smallest cell against a stationary 1.00 %, because that cell never sampled
+enough of the chain.
+
+Holding the offered *packet* rate constant instead was the obvious fix and it
+measured something else entirely: **the pipeline serves messages, not packets.**
+At 60 messages/s the one-packet cell lost 10.774 % under the bursty profile and
+10.626 % under the independent one, and at 380 messages/s 48.391 % and 48.430 %.
+Two different loss processes cannot agree to three digits; what both were
+reporting is the depth-1 OTA queue overwriting its own backlog before the link
+sees it. That is the depth-1 overwrite of bundled publications, which the
+operator harness's ledger records against a real drive, reached here by
+accident and against a synthetic one.
+
+What works is to leave the message rate at the field's 10 Hz and rescale the
+chain: multiplying `p` and `r` by `380/(N × 10)` in each cell leaves the
+stationary bad fraction at 3.92 % and the mean loss at 1 % while making the bad
+run 105 ms of wall clock everywhere, which is the drive's own figure. The six
+`bp-frag-*` profiles are that ladder.
 
 Verification: manual, from a source checkout with Docker:
 
@@ -109,9 +133,19 @@ rosotacom benchmark probe --project src/rosotacom/resources/examples/rosotacom.y
   --repeats 1 --sudo-mode container --no-plot
 ```
 
+```bash
+for pair in 200:one 1000:two 3000:four 6000:six 12000:twelve 38000:thirtyeight; do
+  rosotacom benchmark probe \
+    --project src/rosotacom/resources/examples/rosotacom.yaml \
+    --profile "bp-frag-${pair##*:}" --size "${pair%%:*}" --rate-hz 10 \
+    --duration 240 --repeats 1 --sudo-mode container --no-plot
+done
+```
+
 The independent ladder must fit one `(p, F)` to within about ten per cent at
-every point; the queued ladder must not differ from it systematically; and the
-tight cell at 38 kB must be near-total loss while its 1 kB cell is not.
+every point; the queued ladder must not differ from it systematically; the
+rescaled two-state ladder must fall below it at the large end and not above; and
+the tight cell at 38 kB must be near-total loss while its 1 kB cell is not.
 
 ## Status
 
@@ -126,11 +160,20 @@ the tilt is not an artefact of the accounting, it is not what a queue does to a
 burst, and it is not a serialisation limit, because a serialisation limit does
 not tilt a curve, it truncates it.
 
-What is left to attack is correlation *inside* one message's own burst on a
-real radio — loss events shorter than the time a large message spends on the
-wire, which `netem`'s per-packet chain cannot express at all. The
-Gilbert–Elliott note above is the reason: the tool models a process in packets,
-and the candidate mechanism lives in milliseconds.
+The clustered arm is the one that changes the reading rather than confirming
+it. A reviewer's first guess for a size-systematic residual is burstiness, and
+burstiness at the drive's own time scale produces the **opposite sign**: it
+protects large messages, because a message long enough to span a bad run is lost
+once rather than in each of its packets. So the field's residual is not
+explained by the mechanism that the field's own two-layer model already
+contains, which is worth saying out loud.
+
+What is left to attack is correlation at a scale *shorter* than a large
+message's own time on the wire — short enough that a message straddles a loss
+event more often than a single packet does, without its packets sharing one.
+`netem` cannot express that at all: its chain advances per packet, so a run is
+always measured in packets rather than in milliseconds, and the two coincide
+only at one message size.
 
 The serialisation row deserves one sentence wherever a duty-cycled uplink is
 discussed. It shows that the observable signature of such a link — small

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/src/rosotacom/cli.py

@@ -293,6 +293,12 @@ class OtaSmokePlan:
     peers: dict[str, OtaSmokePeer]
     install_mode: str = "source"
     install_pin: str | None = None
+    #: Where the peers write session instances, relative to the project file's
+    #: own directory. `session-instances` is the default a project that says
+    #: nothing gets; a project that sets `session_instances_dir` to anything
+    #: else -- `../instances`, say -- used to have its artifacts looked for in a
+    #: directory nothing writes to, and the miss was silent.
+    instances_rel: str = "session-instances"
 
 
 @dataclass(frozen=True)
@@ -1835,6 +1841,26 @@ def _ota_checkout_project_path(project_config: Path) -> tuple[Path, str]:
     )
 
 
+def _ota_instances_rel(runtime: RuntimeConfig) -> str:
+    """Where this project writes session instances, relative to its own file.
+
+    The peers resolve the project from their own checkout, so the *relative*
+    answer is the one that travels; an absolute path is the orchestrator's and
+    means nothing on the far side. A project that says nothing gets
+    `session-instances`, which is what the collection used to assume for every
+    project -- and a project that says `../instances` had its artifacts looked
+    for in a directory nothing writes to.
+    """
+    default = "session-instances"
+    if not runtime.rosotacom_config:
+        return default
+    raw = _load_yaml_file(runtime.rosotacom_config)
+    value = raw.get("session_instances_dir")
+    if not value:
+        return default
+    return str(value)
+
+
 def _ota_plan_from_bindings(
     bindings: dict[str, PeerBinding],
     *,
@@ -1845,6 +1871,7 @@ def _ota_plan_from_bindings(
     project: str | None = None,
     exec_commands: Mapping[str, str] | None = None,
     cpusets: Mapping[str, str] | None = None,
+    instances_rel: str = "session-instances",
 ) -> OtaSmokePlan:
     _ota_validate_install_mode(install_mode)
     if cpusets:
@@ -1923,6 +1950,7 @@ def _ota_plan_from_bindings(
         peers=peers,
         install_mode=install_mode,
         install_pin=install_pin,
+        instances_rel=instances_rel,
     )
 
 
@@ -1935,6 +1963,7 @@ def _ota_write_state(instance: SessionInstance, plan: OtaSmokePlan) -> OtaSmokeP
         "project": plan.project,
         "install_mode": plan.install_mode,
         "install_pin": plan.install_pin,
+        "instances_rel": plan.instances_rel,
         "peers": {
             name: {
                 "address": peer.address,
@@ -1979,6 +2008,7 @@ def _ota_load_state(path_arg: str) -> OtaSmokePlan:
         peers=peers,
         install_mode=_ota_validate_install_mode(str(raw["install_mode"])),
         install_pin=str(install_pin) if install_pin else None,
+        instances_rel=str(raw.get("instances_rel") or "session-instances"),
     )
 
 
@@ -2404,12 +2434,26 @@ def _ota_stop_parts(
     return parts
 
 
+#: How a benchmark's load maps onto `publish-test-topics` flags. The keys are
+#: `_sized_publisher_param_args`'s own, so a load dict travels from the
+#: benchmark to the peer's publisher without being rewritten on the way.
+_OTA_LOAD_FLAGS: tuple[tuple[str, str], ...] = (
+    ("size", "--load-size"),
+    ("pattern", "--load-size-pattern"),
+    ("rate", "--load-rate-hz"),
+    ("streams", "--load-streams"),
+    ("interval_jitter_ms", "--load-interval-jitter-ms"),
+    ("interval_jitter_seed", "--load-interval-jitter-seed"),
+)
+
+
 def _ota_publish_parts(
     target: InteractiveSmokeTarget,
     identity: str,
     peer_args: list[str],
     *,
     stop: bool = False,
+    load: Mapping[str, Any] | None = None,
 ) -> list[str]:
     parts = [
         "publish-test-topics",
@@ -2421,6 +2465,13 @@ def _ota_publish_parts(
     ]
     if stop:
         parts.append("--stop")
+    else:
+        merged = dict(load or {})
+        if "size" not in merged and merged.get("size_a") is not None:
+            merged["size"] = merged["size_a"]
+        for key, flag in _OTA_LOAD_FLAGS:
+            if merged.get(key) is not None:
+                parts.extend([flag, str(merged[key])])
     for override in peer_args:
         parts.extend(["--peer-address", override])
     return parts
@@ -2769,6 +2820,7 @@ def _resolve_ota_smoke_context(
             project=project,
             exec_commands=exec_commands,
             cpusets=_parse_peer_cpuset_overrides(getattr(args, "peer_cpuset", None)),
+            instances_rel=_ota_instances_rel(runtime),
         )
     plan_peers = set(plan.peers)
     target_peers = set(_peer_keys_from_cfg(target.cfg))
@@ -3732,14 +3784,41 @@ def _resolve_ota_profile(
     return name, profile
 
 
-def _profile_directions(plan: OtaSmokePlan, cfg: dict[str, Any]) -> dict[str, str]:
+def _loaded_peer(cfg: dict[str, Any]) -> str | None:
+    """Which peer's egress carries this session's dominant direction.
+
+    A profile's ``uplink`` leg is the impaired one in almost every profile this
+    project ships, so which peer it lands on decides what the run measures. The
+    session already says: `topics.a_to_b` and `topics.b_to_a` are its two
+    directions, and the one with more topics is the one the load runs over.
+    Reading it here is what keeps a one-host and a two-host run of the *same*
+    session under the *same* profile from shaping opposite directions -- which
+    they did, silently, until 2026-08-31.
+    """
+    topics = cfg.get("topics")
+    if not isinstance(topics, dict):
+        return None
+    a_to_b = len(topics.get("a_to_b") or ())
+    b_to_a = len(topics.get("b_to_a") or ())
+    if a_to_b == b_to_a:
+        return None
+    return "a" if a_to_b > b_to_a else "b"
+
+
+def _profile_directions_for(peers: list[str], cfg: dict[str, Any]) -> dict[str, str]:
     """Map each peer to the profile direction its egress carries (RFC 0004).
 
-    Default for the a/b convention: the first peer (center / receiver) shapes
-    ``downlink``, the second (vehicle / sender) shapes ``uplink`` — the dominant
-    telemetry direction. Override with ``shared.profile_directions: { a: …, b: … }``."""
-    peers = sorted(plan.peers)
-    directions: dict[str, str] = {peers[0]: "downlink", peers[1]: "uplink"} if len(peers) == 2 else {}
+    The sender of the session's dominant direction shapes ``uplink``; the other
+    peer shapes ``downlink``. Where the two directions carry the same number of
+    topics the session does not say, and the a/b convention decides: the first
+    peer is the centre and receives, the second is the vehicle and sends.
+    ``shared.profile_directions: { a: …, b: … }`` overrides either.
+    """
+    directions: dict[str, str] = {}
+    if len(peers) == 2:
+        sender = _loaded_peer(cfg) or peers[1]
+        other = next(name for name in peers if name != sender)
+        directions = {sender: "uplink", other: "downlink"}
     shared = cfg.get("shared")
     override = shared.get("profile_directions") if isinstance(shared, dict) else None
     if isinstance(override, dict):
@@ -3751,6 +3830,11 @@ def _profile_directions(plan: OtaSmokePlan, cfg: dict[str, Any]) -> dict[str, st
     return directions
 
 
+def _profile_directions(plan: OtaSmokePlan, cfg: dict[str, Any]) -> dict[str, str]:
+    """`_profile_directions_for` against a plan's peers."""
+    return _profile_directions_for(sorted(plan.peers), cfg)
+
+
 def _ota_resolve_interfaces(peer: OtaSmokePeer, peer_addr: str, *, dry_run: bool) -> tuple[str, str | None]:
     """Discover ``(OTA egress, control)`` interfaces on ``peer`` from the kernel, not
     guesses: the OTA interface is the route to the other peer's data address; the
@@ -3935,6 +4019,7 @@ def _ota_start_session_publishers(
     plan: OtaSmokePlan,
     *,
     dry_run: bool,
+    load: Mapping[str, Any] | None = None,
 ) -> None:
     if target.target_type != "session":
         print("OTA smoke: target is a scenario; using its application publishers.")
@@ -3942,7 +4027,7 @@ def _ota_start_session_publishers(
     peer_args = _ota_peer_address_args(plan)
     for peer_name in sorted(plan.peers):
         peer = plan.peers[peer_name]
-        command = _ota_rosotacom_command(plan, _ota_publish_parts(target, peer_name, peer_args), peer)
+        command = _ota_rosotacom_command(plan, _ota_publish_parts(target, peer_name, peer_args, load=load), peer)
         result = _ota_run(peer, command, label=f"{peer_name}: start synthetic publishers", dry_run=dry_run, check=False)
         _print_completed_output(result)
         if result.returncode != 0:
@@ -4068,21 +4153,44 @@ def _ota_collect_logs(
     dry_run: bool,
 ) -> None:
     project = shlex.quote(plan.project)
+    instances_rel = shlex.quote(plan.instances_rel)
     instance_suffix = shlex.quote(f"*_{instance.instance_id}")
+    collected = 0
     for peer in plan.peers.values():
         script = (
             f"cd {shlex.quote(_ota_peer_workdir(plan, peer))} && "
             f"project_dir=$(dirname {project}) && "
-            f'instance_dir=$(find "$project_dir/session-instances" -mindepth 2 -maxdepth 2 '
+            f'instances_root=$(cd "$project_dir" && cd "$(dirname {instances_rel})" 2>/dev/null '
+            f'&& printf %s "$PWD/$(basename {instances_rel})") && '
+            f'instance_dir=$(find "$instances_root" -mindepth 2 -maxdepth 2 '
             f"-type d -name {instance_suffix} -print -quit 2>/dev/null) && "
             'if [ -n "$instance_dir" ]; then '
-            'relative=${instance_dir#"$project_dir"/}; '
-            'tar cz -C "$project_dir" "$relative" 2>/dev/null | base64; fi'
+            'root=$(dirname "$(dirname "$instance_dir")"); '
+            'relative=${instance_dir#"$root"/}; '
+            'tar cz -C "$root" "$relative" 2>/dev/null | base64; fi'
         )
         result = _ota_run(peer, script, label=f"{peer.name}: collect session-instances", dry_run=dry_run, check=False)
-        if dry_run or not result.stdout.strip():
+        if dry_run:
+            continue
+        if not result.stdout.strip():
+            # Silence here used to end as "no status/events.jsonl files found"
+            # after the run was already over, which describes the symptom and
+            # not the cause. Say which peer, and where it was looked for.
+            print(
+                f"OTA smoke: peer {peer.name} returned no session instance matching "
+                f"*_{instance.instance_id} under its {plan.instances_rel!r} "
+                f"(relative to {plan.project!r}).",
+                file=sys.stderr,
+            )
             continue
         _ota_extract_peer_artifacts(instance, peer, result.stdout)
+        collected += 1
+    if not dry_run and not collected:
+        print(
+            "OTA smoke: nothing was collected from any peer -- the run produced no local records. "
+            "Check that the project's session_instances_dir is the one the peers write to.",
+            file=sys.stderr,
+        )
 
 
 def _ota_extract_peer_artifacts(instance: SessionInstance, peer: OtaSmokePeer, encoded: str) -> None:
@@ -7372,9 +7480,30 @@ def _smoke_topic_pub_qos_args(qos: dict[str, Any] | None) -> str:
     return " ".join(shlex.quote(arg) for arg in args) + (" " if args else "")
 
 
-def _smoke_publisher_command(spec: SmokeTopicSpec, ros_setup: str, duration: float) -> str:
+def _smoke_publisher_command(
+    spec: SmokeTopicSpec,
+    ros_setup: str,
+    duration: float,
+    load: Mapping[str, Any] | None = None,
+) -> str:
+    """The publisher command for one crossed topic.
+
+    `load` overrides what the session's own `expect` says, and only for a
+    `SizedPayload` stream: a benchmark chooses its load, and a session that also
+    declares one is describing what it expects to see rather than what a
+    measurement should offer. Without this the benchmark's `--size` and
+    `--rate-hz` reached the local runner and stopped there, so a two-host run
+    measured the session's defaults while reporting the load that was asked for.
+    """
     assert spec.publish_topic is not None and spec.publish_type is not None
     if spec.publish_type == "com_msgs/msg/SizedPayload":
+        from .cli_benchmark import _sized_publisher_param_args
+
+        if load:
+            args = " ".join(
+                shlex.quote(str(part)) for part in _sized_publisher_param_args(spec.publish_topic, dict(load))
+            )
+            return f"{ros_setup} && timeout {duration} ros2 run com_py sized_publisher --ros-args {args}"
         size = spec.expected_size or SMOKE_SIZED_PAYLOAD_BYTES
         return (
             f"{ros_setup} && timeout {duration} ros2 run com_py sized_publisher --ros-args "
@@ -7427,16 +7556,18 @@ def _start_smoke_topic_publishers(
     log_line: Callable[[str], None] = print,
     duration: float = 180.0,
     source_peer_key: str | None = None,
+    load: Mapping[str, Any] | None = None,
 ) -> list[SmokeTopicSpec]:
     started: list[SmokeTopicSpec] = []
     for spec in _smoke_publish_specs(cfg, source_peer_key=source_peer_key):
         assert spec.publish_topic is not None and spec.publish_type is not None
         container = containers[spec.source_peer_key]
         ros_setup = ros_setups[spec.source_peer_key]
-        cmd = _smoke_publisher_command(spec, ros_setup, duration)
+        cmd = _smoke_publisher_command(spec, ros_setup, duration, load)
+        offered = f" at {load.get('rate', spec.publish_rate)} Hz (benchmark load)" if load else ""
         log_line(
             f"Starting smoke publisher {spec.source_peer_key}->{spec.receiver_peer_key} "
-            f"{spec.publish_topic} ({spec.publish_type}) in {container}"
+            f"{spec.publish_topic} ({spec.publish_type}) in {container}{offered}"
         )
         subprocess.run(
             ["docker", "exec", "-d", container, "bash", "-c", cmd],
@@ -7801,6 +7932,30 @@ def probe_content_command(args: argparse.Namespace) -> int:
     return 0 if ok else 1
 
 
+def _publish_load_override(args: argparse.Namespace) -> dict[str, Any] | None:
+    """The benchmark's load as `_sized_publisher_param_args` wants it, or None.
+
+    None means "use what the session expects", which is what an ordinary smoke
+    run wants. A benchmark always passes something, because choosing the load is
+    the whole point of it.
+    """
+    load: dict[str, Any] = {}
+    if getattr(args, "load_size", None) is not None:
+        load["size"] = int(args.load_size)
+        load["size_a"] = int(args.load_size)
+    if getattr(args, "load_size_pattern", None):
+        load["pattern"] = args.load_size_pattern
+    if getattr(args, "load_rate_hz", None) is not None:
+        load["rate"] = float(args.load_rate_hz)
+    if getattr(args, "load_streams", None) is not None:
+        load["streams"] = int(args.load_streams)
+    if getattr(args, "load_interval_jitter_ms", None) is not None:
+        load["interval_jitter_ms"] = float(args.load_interval_jitter_ms)
+    if getattr(args, "load_interval_jitter_seed", None) is not None:
+        load["interval_jitter_seed"] = int(args.load_interval_jitter_seed)
+    return load or None
+
+
 def publish_test_topics_command(args: argparse.Namespace) -> int:
     """Start or stop synthetic local app publishers for the peer's crossed topics.
 
@@ -7826,6 +7981,7 @@ def publish_test_topics_command(args: argparse.Namespace) -> int:
             cfg,
             duration=args.duration,
             source_peer_key=args.identity,
+            load=_publish_load_override(args),
         )
     except RuntimeError as exc:
         print(f"ERROR: {exc}", file=sys.stderr)
@@ -10357,6 +10513,16 @@ def main(argv: list[str] | None = None) -> int:
     publish_test_topics_parser.add_argument(
         "--stop", action="store_true", help="Stop running synthetic test topic publishers."
     )
+    # The benchmark's load, for the peer that publishes it. Without these a
+    # two-host benchmark offered the session's own expected load and reported
+    # the one that was asked for -- a run that reads as a success and measures
+    # something else.
+    publish_test_topics_parser.add_argument("--load-size", type=int, help=argparse.SUPPRESS)
+    publish_test_topics_parser.add_argument("--load-size-pattern", help=argparse.SUPPRESS)
+    publish_test_topics_parser.add_argument("--load-rate-hz", type=float, help=argparse.SUPPRESS)
+    publish_test_topics_parser.add_argument("--load-streams", type=int, help=argparse.SUPPRESS)
+    publish_test_topics_parser.add_argument("--load-interval-jitter-ms", type=float, help=argparse.SUPPRESS)
+    publish_test_topics_parser.add_argument("--load-interval-jitter-seed", type=int, help=argparse.SUPPRESS)
     publish_test_topics_parser.set_defaults(func=publish_test_topics_command)
 
     list_parser = subparsers.add_parser("list-sessions", help="List configured sessions.")

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/src/rosotacom/cli_benchmark.py

@@ -5163,6 +5163,7 @@ def _make_live_run_point(args: argparse.Namespace, session_name: str) -> RunPoin
         _peer_command_runner,
         _peer_watchdog_launcher,
         _profile_directions,
+        _profile_directions_for,
         _remove_smoke_network,
         _resolve_ota_profile,
         _resolve_ota_smoke_context,
@@ -5327,7 +5328,10 @@ def _make_live_run_point(args: argparse.Namespace, session_name: str) -> RunPoin
                 _ota_start_peers(target, plan, instance.instance_id, dry_run=dry_run)
                 if not dry_run:
                     time.sleep(12)
-                _ota_start_session_publishers(target, plan, dry_run=dry_run)
+                # The load is the benchmark's, not the session's expectation:
+                # without this the peer published what its own `expect` declares
+                # and the run reported the load that was asked for.
+                _ota_start_session_publishers(target, plan, dry_run=dry_run, load=load)
 
                 if not dry_run:
                     if profile_obj is not None and profile_obj.is_timeline:
@@ -5651,34 +5655,36 @@ def _make_live_run_point(args: argparse.Namespace, session_name: str) -> RunPoin
                                 print(
                                     f"  netem distribution {table_name!r} installed in {dist_container}: {dist_target}"
                                 )
+                    # Which peer's egress carries `uplink` is the session's
+                    # answer, not the runner's: the same session under the same
+                    # profile must be shaped identically here and across two
+                    # machines, and hard-coding a=uplink here while the OTA path
+                    # hard-coded b=uplink meant it was not.
+                    lab_directions = _profile_directions_for(["a", "b"], cfg)
+                    lab_containers = {"a": a_container, "b": b_container}
                     if profile_obj.is_timeline:
-                        # Peer A shapes uplink (egress to B)
-                        shaper_a = ProfileShaper("eth0", make_container_runner(a_container))
-                        lab_shapers.append(shaper_a)
-                        steps_a = expand_timeline(profile_obj, "eth0", direction="uplink")
-                        lab_peer_steps["a"] = (shaper_a, steps_a)
-
-                        # Peer B shapes downlink (egress to A)
-                        shaper_b = ProfileShaper("eth0", make_container_runner(b_container))
-                        lab_shapers.append(shaper_b)
-                        steps_b = expand_timeline(profile_obj, "eth0", direction="downlink")
-                        lab_peer_steps["b"] = (shaper_b, steps_b)
+                        for peer_name in ("a", "b"):
+                            shaper = ProfileShaper("eth0", make_container_runner(lab_containers[peer_name]))
+                            lab_shapers.append(shaper)
+                            steps = expand_timeline(profile_obj, "eth0", direction=lab_directions[peer_name])
+                            lab_peer_steps[peer_name] = (shaper, steps)
 
                         for shaper in lab_shapers:
                             shaper.arm([])
                     else:
-                        if profile_obj.uplink and not profile_obj.uplink.is_empty:
-                            shaper_a = ProfileShaper("eth0", make_container_runner(a_container))
-                            lab_shapers.append(shaper_a)
-                            shaper_a.arm(shaping_commands("eth0", profile_obj.uplink))
-                        if profile_obj.downlink and not profile_obj.downlink.is_empty:
-                            shaper_b = ProfileShaper("eth0", make_container_runner(b_container))
-                            lab_shapers.append(shaper_b)
-                            shaper_b.arm(shaping_commands("eth0", profile_obj.downlink))
+                        for peer_name in ("a", "b"):
+                            leg = profile_obj.uplink if lab_directions[peer_name] == "uplink" else profile_obj.downlink
+                            if leg is None or leg.is_empty:
+                                continue
+                            shaper = ProfileShaper("eth0", make_container_runner(lab_containers[peer_name]))
+                            lab_shapers.append(shaper)
+                            shaper.arm(shaping_commands("eth0", leg))
 
                 # 4. Verify shaping was applied (diagnostic)
                 if profile_obj is not None and not getattr(args, "dry_run", False):
-                    for label, container in [("A (uplink)", a_container), ("B (downlink)", b_container)]:
+                    for peer_name in ("a", "b"):
+                        label = f"{peer_name.upper()} ({lab_directions[peer_name]})"
+                        container = lab_containers[peer_name]
                         tc_binary = container_tc_overrides.get(container, "tc")
                         res = subprocess.run(
                             ["docker", "exec", "-u", "root", container, tc_binary, "qdisc", "show", "dev", "eth0"],

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/src/rosotacom/resources/examples/profiles.yaml

@@ -245,3 +245,74 @@ profiles:
       distribution_file: dist/field-20260817.dist
       loss: 1%
     downlink: { delay: 7ms, jitter: 5ms }
+
+  # B1-prime -- the two-state process with its chain rescaled per cell.
+  #
+  # netem advances a Gilbert-Elliott chain once per *packet*, so the fitted p
+  # and r describe a process in packets and not in time. At the drive's own
+  # 380 fragments/s they mean a bad run of about 105 ms; on a size ladder at a
+  # fixed 10 Hz the packet rate is N x 10, so the same p and r stretch the bad
+  # run by 380/(N x 10) and every cell meets a different link. Forcing the
+  # packet rate constant instead was tried and measured the wrong thing: the
+  # pipeline serves messages, not packets, and at 60 messages/s the depth-1 OTA
+  # queue overwrites its own backlog -- both loss processes then reported
+  # 10.7 % to two digits.
+  #
+  # So the chain is rescaled instead: p and r are multiplied by 380/(N x 10) in
+  # each cell, which leaves the stationary bad fraction at 3.92 % and the mean
+  # loss at 1 % while making the bad run 105 ms of wall clock everywhere. The
+  # comparison against `tilt-iid` is then a comparison of one thing.
+
+  bp-frag-one:
+    uplink:
+      delay: 25ms
+      jitter: 18ms
+      distribution: field-20260817
+      distribution_file: dist/field-20260817.dist
+      loss_gemodel: { p: 3.876%, r: 95%, loss_bad: 13.5%, loss_good: 0.49% }
+    downlink: { delay: 7ms, jitter: 5ms }
+
+  bp-frag-two:
+    uplink:
+      delay: 25ms
+      jitter: 18ms
+      distribution: field-20260817
+      distribution_file: dist/field-20260817.dist
+      loss_gemodel: { p: 1.938%, r: 47.5%, loss_bad: 13.5%, loss_good: 0.49% }
+    downlink: { delay: 7ms, jitter: 5ms }
+
+  bp-frag-four:
+    uplink:
+      delay: 25ms
+      jitter: 18ms
+      distribution: field-20260817
+      distribution_file: dist/field-20260817.dist
+      loss_gemodel: { p: 0.969%, r: 23.75%, loss_bad: 13.5%, loss_good: 0.49% }
+    downlink: { delay: 7ms, jitter: 5ms }
+
+  bp-frag-six:
+    uplink:
+      delay: 25ms
+      jitter: 18ms
+      distribution: field-20260817
+      distribution_file: dist/field-20260817.dist
+      loss_gemodel: { p: 0.646%, r: 15.83%, loss_bad: 13.5%, loss_good: 0.49% }
+    downlink: { delay: 7ms, jitter: 5ms }
+
+  bp-frag-twelve:
+    uplink:
+      delay: 25ms
+      jitter: 18ms
+      distribution: field-20260817
+      distribution_file: dist/field-20260817.dist
+      loss_gemodel: { p: 0.323%, r: 7.917%, loss_bad: 13.5%, loss_good: 0.49% }
+    downlink: { delay: 7ms, jitter: 5ms }
+
+  bp-frag-thirtyeight:
+    uplink:
+      delay: 25ms
+      jitter: 18ms
+      distribution: field-20260817
+      distribution_file: dist/field-20260817.dist
+      loss_gemodel: { p: 0.102%, r: 2.5%, loss_bad: 13.5%, loss_good: 0.49% }
+    downlink: { delay: 7ms, jitter: 5ms }

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/src/rosotacom_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev76
+Version: 2.5.dev78
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/src/rosotacom_dev.egg-info/SOURCES.txt

@@ -373,6 +373,7 @@ tests/unit/test_netem_dist.py
 tests/unit/test_network_preflight.py
 tests/unit/test_network_profiles.py
 tests/unit/test_network_shaper.py
+tests/unit/test_ota_benchmark_peer_exec.py
 tests/unit/test_ota_link_configs.py
 tests/unit/test_ota_pcap.py
 tests/unit/test_ota_unwrapper.py

{rosotacom_dev-2.5.dev76 → rosotacom_dev-2.5.dev78}/src/rosotacom_dev.egg-info/scm_file_list.json

@@ -368,6 +368,7 @@
     "tests/unit/test_network_preflight.py",
     "tests/unit/test_network_profiles.py",
     "tests/unit/test_network_shaper.py",
+    "tests/unit/test_ota_benchmark_peer_exec.py",
     "tests/unit/test_ota_link_configs.py",
     "tests/unit/test_ota_pcap.py",
     "tests/unit/test_ota_unwrapper.py",