{"id":"1cefcd38-a145-4552-9af4-07a08bf9dc52","arxiv_id":"2412.01799","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":1,"one_line_summary":"HPRM, a Lingua Franca-based middleware using shared-memory object stores and adaptive serialization, reports up to 173x lower broadcast latency than the tested ROS2 configuration and 91.1% lower latency in a CARLA driving benchmark.","lead":"This paper introduces HPRM, a robotics middleware built on the Lingua Franca coordination language, and reports benchmarks showing it sends large messages up to 173 times faster than a standard ROS2 setup. It also runs a CARLA autonomous-driving demo with 91.1% lower latency than ROS2, suggesting that combining deterministic scheduling with shared-memory transfers could make robot communication faster and more predictable.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Headline '173x vs ROS2' is measured against rclpy plus a manual shared-memory workaround, not ROS2's C++ zero-copy path; the central performance claim is therefore configuration-dependent.","rationale":"The paper's central, headline-level claim is the 173x latency improvement over ROS2 and the 91.1% reduction in the CARLA benchmark. For that claim to hold as stated, HPRM must beat ROS2's strongest reasonable configuration, not merely the Python client with default serialization plus a manually layered shared-memory workaround. The reader identified exactly this weak spot, and the manuscript text supports it: Section III-A says zero-copy exists in rclcpp but not rclpy; Section V-A defines the Shared Memory variant as pickle plus the Python shared_memory module and labels it inefficient; Section V-B acknowledges the performance gap is smaller when I/O is not the bottleneck. HPRM's internal evidence for the underlying mechanisms is credible: Figure 2 shows Plasma writes are faster than Python shared memory, and Figure 3 shows out-of-band serialization is faster than in-band serialization, both of which are plausible and independently checkable. The problem is external validity of the 'vs ROS2' framing, not the internal construction. A rclcpp zero-copy baseline is a concrete, feasible addition and would settle whether the advantage is architectural or configuration-dependent. Because the reader already marked the paper CONDITIONAL on this exact issue, I do not recommend moving the verdict; the paper can be accepted conditional on adding a fair baseline and supporting details such as variance and repository access.","tokens_in":10457,"tokens_out":5056,"duration_ms":52569,"concrete_test":"Re-run the Section V-A 4-node broadcast/gather benchmark on the same workstation using rclcpp C++ nodes with rmw_cyclonedds shared-memory loaned messages (or Fast DDS data-sharing), object sizes 1-50 MB, recording mean and median latency over at least 100 trials, and compare the 50 MB value with HPRM's 44.6 ms. Also re-run the CARLA benchmark's communication path with rclcpp nodes and report communication-only latency separately from inference. If rclcpp zero-copy 50 MB broadcast is substantially below 7,723 ms (for example under 500 ms), the paper must add that baseline and restate the claimed advantage as being against rclpy rather than ROS2 generically; if the rclcpp value remains near 7,723 ms, the objection is refuted.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section V-A compares HPRM to 'ROS2 Humble' and 'ROS2 Humble (Shared Memory)', where the latter uses rclpy with pickle serialization plus Python's shared_memory module, a workaround the authors themselves call inefficient. Section III-A states that zero-copy loaned messages are only available in rclcpp, not in the Python client. The 173x figure therefore compares HPRM (Plasma object store plus out-of-band serialization) against a Python baseline that serializes into bytes and copies those bytes through point-to-point sockets once per subscriber. That ratio partly measures Python/rclpy overhead and an unsupported manual workaround, not the ROS2 middleware as a whole. The CARLA 91.1% result uses the same rclpy baseline, and Section V-B concedes the gap shrinks when I/O is not the bottleneck. If the benchmark were repeated with best-configured rclcpp using loaned-message zero-copy over Cyclone DDS or Fast DDS, the serialization and copy penalties that dominate the ROS2 numbers would largely disappear, and the 'up to 173x' claim would shrink dramatically. This is not an internal inconsistency, but it makes the abstract's comparison to 'ROS2' overbroad and is the load-bearing weakness for the headline claim.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents HPRM, a robotic middleware built on the Lingua Franca reactor model, and claims that it reduces communication latency relative to ROS2 while preserving deterministic coordination semantics. HPRM uses a Plasma in-memory object store for large payloads, adaptive/out-of-band serialization for NumPy-style buffers, an eager protocol, and real-time sockets. The evaluation measures broadcast/gather latency for 1-50 MB objects on four nodes, reporting up to 173x lower mean latency than ROS2 Humble and its shared-memory variant (Section V-A, Fig. 4), and reports a 91.1% lower inference latency in a CARLA autonomous-driving benchmark with PPO and YOLO (Section V-B, Fig. 6). The paper also contrasts centralized and decentralized coordination and argues that both preserve deterministic ordering, citing prior work on LF determinism.","tokens_in":10790,"tokens_out":2825,"duration_ms":29528,"significance":"If the performance claims withstand a stronger baseline, the paper is a useful systems contribution: it shows concretely how a deterministic reactor-based middleware can integrate an object store and adaptive serialization to substantially reduce large-message IPC overhead, and it validates the approach on a realistic CARLA workload with dockerized, repeatable benchmarks. The authors provide an independent comparison against an external ROS2 baseline rather than only benchmarking their own system, and they include a real application beyond microbenchmarks. However, the headline quantitative claims currently rest on a ROS2 Python-client baseline without native zero-copy, and the determinism guarantee is inherited from prior LF publications rather than verified in this paper, so the significance is conditional on those points being addressed.","major_comments":[{"comment":"The headline 'up to 173x lower latency than ROS2' is computed against ROS2 Humble using the Python client rclpy and a manual shared-memory workaround, not against rclcpp with native zero-copy loaned-message transport. Section III-A itself states that zero-copy is only available in rclcpp, and Section V-A describes the shared-memory variant as a workaround requiring manual management. Because the ROS2 numbers include Python serialization and per-subscriber socket copies, the ratio partly measures rclpy overhead. Please add a baseline using rclcpp with Cyclone DDS or Fast DDS zero-copy (or, failing that, explicitly scope all claims as 'vs. rclpy') and report the ratios against that baseline.","section":"Section V-A, Fig. 4"},{"comment":"The CARLA result of 91.1% lower latency uses the same rclpy-based ROS2 Humble default as the comparison point, and the text itself concedes that the performance gap is larger when I/O is the bottleneck and smaller in the application where inference dominates. This does not invalidate the result, but it makes the abstract's unqualified comparison to 'ROS2' overbroad. Please either include the rclcpp zero-copy configuration in the application benchmark or decompose the measured latency into communication vs. inference time so readers can see how much of the 91.1% is middleware-specific.","section":"Section V-B, Fig. 6"},{"comment":"The paper claims that HPRM preserves Lingua Franca's deterministic coordination semantics, but this claim is not experimentally verified for the optimized HPRM IPC paths. Section IV-B cites prior work [28] for zero out-of-order events under centralized coordination, and the deterministic properties are inherited from LF's design rather than demonstrated for the Plasma object-store, adaptive-serialization, and real-time-socket mechanisms introduced here. Please add a determinism stress test (e.g., injected STP violations, out-of-order detection counts, or a reproducibility of ordering test) or explicitly state that determinism is inherited from the underlying LF runtime and not re-validated in this work.","section":"Section VI and Section IV-B"},{"comment":"Figure 4 reports only mean latency values, with no error bars, percentiles, or number of repetitions. Given that the central claims are ratios such as 173x and 77x, the absence of distribution information makes it impossible to assess the stability of those ratios. Please report median and p95 (or at least standard deviation) across repeated runs and state the number of trials.","section":"Section V-A, Fig. 4"}],"minor_comments":[{"comment":"The 64KB threshold for switching to the Plasma object store is presented without justification; a sentence explaining the choice or a sensitivity analysis across thresholds would be helpful.","section":"Section IV-C.1"},{"comment":"The name 'ROS2 Humble (Shared Memory)' is potentially misleading because the variant uses rclpy with pickle serialization and Python's shared_memory module; consider renaming it 'ROS2 (rclpy + shared memory workaround)' for clarity.","section":"Section V-A"},{"comment":"The sentence 'HPRM with decentralized coordination has the best performance with the note that frame rates, slightly outperforming HPRM with centralized coordination' contains a grammatical error and unclear meaning; please revise.","section":"Section V-B"},{"comment":"The paper states that HPRM is open-source, but no repository URL is given in the manuscript; providing one, together with the Docker artifact link, would improve reproducibility.","section":"Section I"},{"comment":"The discussion of TZC ends with 'not compatible with ROS2,' which is ambiguous (it could mean TZC is not compatible with current ROS2 versions); please clarify.","section":"Section III-A"}],"recommendation":"major_revision","confidential_remarks":"The paper fits the scope of a robotics/embedded-systems venue and the core idea is interesting, but the reviewers should be aware that the abstract's two headline numbers (173x and 91.1%) are both measured against rclpy without a native zero-copy rclcpp baseline. The determinism claim also rests on prior papers rather than on experiments in this manuscript. These are fixable within a revision, but they are load-bearing for the paper's central claims."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague,\n\nThe headline is real but narrower than the abstract suggests. HPRM combines Plasma object store, out-of-band pickle serialization, and eager sockets with LF's deterministic coordination to get low-latency Python-based middleware. The broadcast benchmark shows 44.6 ms vs 7,723 ms for ROS2 at 50 MB, which is plausible for what it measures. The CARLA numbers are more modest and the paper admits it.\n\nWhat is actually new: the integration. Each piece exists (Ray/Plasma, out-of-band serialization, Nagle disable), but combining them under LF's deterministic coordination and benchmarking the whole is a legitimate systems contribution. The paper is well-structured and cites prior work honestly, including the limitations of ROS2 Python zero-copy support.\n\nThe soft spots are real. The 'vs ROS2' framing is overbroad: the ROS2 baseline is rclpy with default serialization plus a manual shared-memory workaround the authors themselves call inefficient. The 173x figure partly measures Python client overhead and an unsupported workaround, not ROS2 as a whole. A fair comparison against rclcpp with loaned-message zero-copy over Fast DDS or Cyclone would shrink that number dramatically. The paper should either compare against the best ROS2 configuration or label the claim as 'vs rclpy.' This is the load-bearing weakness but it is fixable.\n\nAlso, Figure 4 reports means without error bars; determinism preservation is inherited from prior LF papers, not tested here; and despite saying 'open-source' and 'provided docker images,' there is no repo link or artifact appendix. Those are minor-to-moderate and addressable.\n\nThe central claim holds for what it is: if you write robotics middleware in Python, HPRM is likely much faster than rclpy. That is a useful result for a specific audience. The determinism claim is plausible but not demonstrated in this paper.\n\nWho is this for? People building Python-based robotic and RL pipelines who care about latency and deterministic scheduling. It deserves a serious referee; with a fair baseline, error bars, and an artifact link, the paper would be solid. I'd accept for review as is, with the expectation of substantial revision.","headline":"A useful Python-focused robotics middleware with a headline latency claim that overstates the comparison because it benchmarks against rclpy and a manual shared-memory workaround, not ROS2's C++ zero-copy path.","tokens_in":11221,"tokens_out":1592,"would_cite":true,"duration_ms":15228,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"A robotic middleware built on the deterministic coordination language Lingua Franca moves large messages between processes up to 173 times faster than a ROS2 baseline while preserving deterministic event ordering.","keywords":["robotic middleware","Lingua Franca","ROS2","inter-process communication","zero-copy","deterministic coordination","autonomous driving","in-memory object store"],"falsifier":"A rerun of the 50 MB broadcast to four nodes on one machine using rclcpp with Cyclone DDS zero-copy enabled, measuring mean latency; if that baseline comes close to HPRM's 44.6 ms rather than the reported 7,723 ms, the central 'up to 173x' claim would be falsified as stated.","tokens_in":10227,"feed_emoji":"🤖","tokens_out":6659,"duration_ms":61749,"temperature":0.7,"pith_summary":"This paper claims that a robotics middleware built on the deterministic coordination language Lingua Franca can eliminate most of the latency ROS2 pays when large sensor messages are broadcast to several processes on one machine. The central assertion is that HPRM's combination of an in-memory object store, adaptive out-of-band serialization, and an eager socket protocol moves a 50 MB payload among four nodes in 44.6 ms versus 7,723 ms for the ROS2 baseline—a 173x improvement—while preserving LF's tag-ordered, deterministic event handling. The same machinery yields a 91.1% lower inference latency than ROS2 in a CARLA autonomous-driving benchmark that runs a reinforcement-learning policy and an object detector in parallel. If correct, this would make large-image and LiDAR data practical to share between perception, planning, and control modules without giving up predictable timing.","feed_headline":"Robotic middleware cuts 50 MB message latency 173x vs ROS2","feed_subtitle":"It keeps deterministic scheduling while moving large sensor payloads between processes with far less delay.","key_machinery":"The load-bearing mechanism is the split between small control messages and large data payloads. Object references travel over pre-allocated eager sockets with Nagle's algorithm disabled, while the payloads themselves live in a Plasma in-memory object store that every process maps into its address space; adaptive serialization decides which path each data type takes, using out-of-band buffers for NumPy arrays and tensors. The LF runtime's tag-advance bookkeeping—tag advance grants, logical tag complete reports, and next-event tags—keeps the logical order deterministic around this fast path, and the decentralized mode replaces the central coordinator with per-federate safe-to-process offsets to reduce synchronization overhead.","core_discovery":"On its own terms, the paper establishes that the coordination guarantees of Lingua Franca need not come at the cost of slow local communication. HPRM keeps LF's reactor model and its global tag order—centralized through a runtime infrastructure, or decentralized through user-set safe-to-process offsets—and adds three optimizations: a Plasma in-memory object store that maps large payloads into each process's address space for zero-copy transfer; adaptive serialization that switches NumPy arrays and tensors to out-of-band PickleBuffer transfer while keeping small data in-band; and an eager protocol with Nagle's algorithm disabled on real-time sockets. Measured consequences are up to 173x lower mean latency than ROS2 Humble for 50 MB broadcasts and a 91.1% lower inference latency in a CARLA autonomous-driving workload running a PPO agent and YOLO detector in parallel.","pith_inferences":["Beyond the paper: the comparison excludes ROS2's C++ client (rclcpp) with native zero-copy; rerunning the broadcast benchmark against that baseline could substantially shrink the 173x and 91.1% numbers.","Beyond the paper: the same adaptive-serialization and object-store techniques could be lifted into other Python middleware stacks, so the measured gains are not necessarily tied to Lingua Franca; a testable extension would add the Plasma path to a plain rclpy node.","Beyond the paper: because the authors note the application gain (91.1%) is smaller than the microbenchmark gain (173x), the optimization is most valuable when I/O dominates; control loops with tiny messages are unlikely to see comparable benefits."],"forward_implications":["Broadcasting large camera or LiDAR frames to several subscribers on one multicore machine no longer forces developers to choose between deterministic ordering and usable latency; HPRM delivers both.","Autonomous driving pipelines that interleave a reinforcement-learning policy with object detection can run with 91.1% lower inference latency than the same pipeline on the ROS2 Python baseline.","ROS2 programs can be ported to HPRM with modest changes, since the publisher-subscriber structure maps onto reactors and federates.","The paper cites evidence that centralized LF coordination yields zero out-of-order message sequences over 300k tests, whereas ROS2 shows 0.2% out-of-order sequences even under minimal stress, so the deterministic semantics carry over to the optimized IPC path."],"supporting_citations":[{"why":"Defines Lingua Franca and the reactor model; this is the deterministic coordination substrate HPRM is built on.","marker":"[8]"},{"why":"Plasma in-memory object store; the mechanism HPRM uses for zero-copy transfer of large payloads.","marker":"[30]"},{"why":"Ray framework; the inspiration for using an in-memory object store to move large objects between processes.","marker":"[31]"},{"why":"Kronauer et al. latency analysis of ROS2; documents the large-message latency problem that motivates HPRM's design.","marker":"[16]"},{"why":"Evidence of ROS2 nondeterminism and LF's deterministic coordination; underlies the claim that determinism is preserved without sacrificing performance.","marker":"[28]"},{"why":"PTIDES; the programming model that the decentralized coordination scheme with safe-to-process offsets extends.","marker":"[25]"},{"why":"CARLA simulator; the autonomous driving environment used in the application benchmark.","marker":"[11]"},{"why":"The pre-trained PPO agent used as the reinforcement-learning policy in the CARLA benchmark.","marker":"[35]"},{"why":"YOLO object detector; the workload run in parallel with the PPO agent to measure end-to-end inference latency.","marker":"[36]"}],"fun_headline_variants":["HPRM middleware slashes large-message latency 173x vs ROS2","Middleware achieves 173x lower latency than ROS2 for 50MB messages","Zero-copy middleware: 173x faster large-message delivery vs ROS2","LF-based middleware: 173x faster than ROS2 for large payloads","HPRM cuts robot sensor latency 173x vs ROS2 in large-burst tests"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The headline comparison assumes the ROS2 Python client with default serialization, plus a manual shared-memory workaround, is the right baseline; ROS2's C++ client with native zero-copy is not measured, so the 173x and 91.1% figures could shrink if that stronger baseline were used.","fun_headline_variants_meta":{"raw":{"variants":["HPRM middleware slashes large-message latency 173x vs ROS2","Middleware achieves 173x lower latency than ROS2 for 50MB messages","Zero-copy middleware: 173x faster large-message delivery vs ROS2","LF-based middleware: 173x faster than ROS2 for large payloads","HPRM cuts robot sensor latency 173x vs ROS2 in large-burst tests"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000636,"raw_usage":{"total_tokens":2935,"prompt_tokens":951,"completion_tokens":1984,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":567,"completion_tokens_details":{"reasoning_tokens":1878}},"tokens_in":567,"tokens_out":1984,"duration_ms":16778,"temperature":1.0,"reasoning_tokens":1878,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T00:55:14.153035+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"A rerun of the 50 MB broadcast to four nodes on one machine using rclcpp with Cyclone DDS zero-copy enabled, measuring mean latency; if that baseline comes close to HPRM's 44.6 ms rather than the reported 7,723 ms, the central 'up to 173x' claim would be falsified as stated.","supporting_citations":[{"cited_title":"Toward a lingua franca for deterministic concurrent systems,","cited_arxiv_id":null,"evidence_quote":"Defines Lingua Franca and the reactor model; this is the deterministic coordination substrate HPRM is built on."},{"cited_title":"A cross-language development platform for in-memory data,","cited_arxiv_id":null,"evidence_quote":"Plasma in-memory object store; the mechanism HPRM uses for zero-copy transfer of large payloads."},{"cited_title":"Ray: A distributed framework for emerging {AI} applications,","cited_arxiv_id":null,"evidence_quote":"Ray framework; the inspiration for using an in-memory object store to move large objects between processes."},{"cited_title":"Latency analysis of ROS2 multi-node systems,","cited_arxiv_id":null,"evidence_quote":"Kronauer et al. latency analysis of ROS2; documents the large-message latency problem that motivates HPRM's design."},{"cited_title":"Risk and mitigation of nondeterminism in distributed cyber-physical systems,","cited_arxiv_id":null,"evidence_quote":"Evidence of ROS2 nondeterminism and LF's deterministic coordination; underlies the claim that determinism is preserved without sacrificing performance."},{"cited_title":"Ptides: A programming model for distributed real-time embedded systems,","cited_arxiv_id":null,"evidence_quote":"PTIDES; the programming model that the decentralized coordination scheme with safe-to-process offsets extends."}],"review_version":1}