Pith. sign in

REVIEW 4 major objections 5 minor 36 references

HPRM: High-Performance Robotic Middleware for Intelligent Autonomous Systems

T0 review · 4 major / 5 minor · reviewed 2026-08-12 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read 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.

desk verdict 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. read the letter →

arxiv 2412.01799 v1 pith:YOSREXEK submitted 2024-12-02 cs.RO cs.AIcs.DC

Jacky Kwok , Shulu Li , Marten Lohstroh , Edward A. Lee This is my paper · ORCID
classification cs.ROcs.AIcs.DC
keywords roboticmiddlewareLinguaFrancaROS2inter-processcommunicationzero-copydeterministiccoordinationautonomousdrivingin-memoryobjectstore
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

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.

What carries the argument

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.

What would settle it

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.

Watch

Extended reading notes

Core claim

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.

Load-bearing premise

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.

Editorial extensions

If this is right

  • 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.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • 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.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

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.

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 (4)
  1. [Section V-A, Fig. 4] 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.
  2. [Section V-B, Fig. 6] 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.
  3. [Section VI and Section IV-B] 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.
  4. [Section V-A, Fig. 4] 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.
minor comments (5)
  1. [Section IV-C.1] 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.
  2. [Section V-A] 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.
  3. [Section V-B] 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.
  4. [Section I] 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.
  5. [Section III-A] 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.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: HPRM's headline latency results are direct measurements against an external ROS2 baseline, and its determinism claims rest on prior published LF semantics rather than on the benchmark outputs.

full rationale

The paper's central claims are empirical: Figure 4 reports measured broadcast and gather latencies for HPRM versus ROS2 Humble and a shared-memory variant, and Figure 6 reports measured inference latency in a CARLA benchmark. These are external comparisons, not quantities derived from HPRM's own definitions. No parameter is fitted to the benchmark outcome, and no ROS2 number is computed from HPRM equations. The optimizations (Plasma object store, out-of-band serialization, eager protocol, disabling Nagle) are engineering mechanisms with directly measured effects. The deterministic-coordination feature is inherited from Lingua Franca and supported by citations to prior work ([22], [28]) that includes its own formal semantics and stress-test results; although several of those citations share authors with this paper, they are independent published results with external experimental content, not definitions of HPRM's performance. The paper therefore does not reduce any prediction to its inputs by construction. The benchmark-baseline concern (rclpy versus rclcpp zero-copy) is a question of comparison fairness, not circularity.

Assumptions & free parameters 1 free parameters · 4 assumptions · 0 invented entities

No new physical or mathematical entities are postulated; HPRM is a system built from existing components (Plasma, LF, eager protocols). The central claims rest on measurement setup and the correctness of integrations, which are captured in free_parameters and axioms.

free parameters (1)
  • 64KB threshold for activating Plasma object store = 64 KB
    Hand-chosen size above which payloads are routed through the in-memory object store; not tuned or justified, but it determines which messages use the zero-copy path.
assumptions (4)
  • domain assumption Lingua Franca's reactor model provides deterministic, tag-ordered event processing.
    The paper builds HPRM's determinism claim on prior LF work ([8],[22],[28]) and does not re-verify the semantics in this paper.
  • domain assumption Network latency, clock synchronization error, and execution times are bounded so that a user-set STP offset can guarantee tag-ordered processing.
    Section IV-B states that if the STP offset is greater than the sum of these delays, events are handled in tag order; this is an assumption about the environment, not a result.
  • domain assumption The Plasma in-memory object store maintains correct read/write ordering and does not evict objects still needed by receivers.
    HPRM integrates Plasma for zero-copy transfers (Section IV-C1) but does not describe a lifecycle or eviction protocol that prevents premature deletion.
  • domain assumption Python out-of-band serialization via PickleBuffer preserves the data and does not introduce ordering or corruption issues.
    Section IV-C2 relies on out-of-band serialization to avoid copies; correctness is assumed rather than tested.

how reviews work

0 comments
Cite this review

Pith. "Pith review of HPRM: High-Performance Robotic Middleware for Intelligent Autonomous Systems." pith.science (2026). https://pith.science/paper/YOSREXEK

@misc{pith2026241201799,
  author       = {Pith},
  title        = {Pith review of: HPRM: High-Performance Robotic Middleware for Intelligent Autonomous Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YOSREXEK}},
  note         = {Machine review of arXiv:2412.01799}
}
read the original abstract

The rise of intelligent autonomous systems, especially in robotics and autonomous agents, has created a critical need for robust communication middleware that can ensure real-time processing of extensive sensor data. Current robotics middleware like Robot Operating System (ROS) 2 faces challenges with nondeterminism and high communication latency when dealing with large data across multiple subscribers on a multi-core compute platform. To address these issues, we present High-Performance Robotic Middleware (HPRM), built on top of the deterministic coordination language Lingua Franca (LF). HPRM employs optimizations including an in-memory object store for efficient zero-copy transfer of large payloads, adaptive serialization to minimize serialization overhead, and an eager protocol with real-time sockets to reduce handshake latency. Benchmarks show HPRM achieves up to 173x lower latency than ROS2 when broadcasting large messages to multiple nodes. We then demonstrate the benefits of HPRM by integrating it with the CARLA simulator and running reinforcement learning agents along with object detection workloads. In the CARLA autonomous driving application, HPRM attains 91.1% lower latency than ROS2. The deterministic coordination semantics of HPRM, combined with its optimized IPC mechanisms, enable efficient and predictable real-time communication for intelligent autonomous systems.

Figures

Figures reproduced from arXiv: 2412.01799 by the authors.

Figure 2
Figure 2. Comparison of delay in writing NumPy arrays to shared memory [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. The serialization and deserialization throughput of ROS2 Numpy [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 5
Figure 5. Dataflow diagram of the autonomous driving application [PITH_FULL_IMAGE:figures/full_fig_p006_5.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

36 extracted references · 29 canonical work pages

  1. [28]

    Risk and mitigation of nondeterminism in distributed cyber-physical systems,

    S. Bateni, M. Lohstroh, H. S. Wong, H. Kim, S. Lin, C. Menard, and E. A. Lee, “Risk and mitigation of nondeterminism in distributed cyber-physical systems,” in 2023 21st ACM-IEEE International Sym- posium on F ormal Methods and Models for System Design (MEM- OCODE), 2023, pp. 1–11

    work page 2023

  2. [1]

    Autonomous systems–an architectural characterization,

    J. Sifakis, “Autonomous systems–an architectural characterization,” Models, Languages, and Tools for Concurrent and Distributed Pro- gramming: Essays Dedicated to Rocco De Nicola on the Occasion of His 65th Birthday , pp. 388–410, 2019

    work page 2019

  3. [2]

    Inter-process communication (IPC) in distributed environ- ments: An investigation and performance analysis of some middleware technologies

    H. Dinari, “Inter-process communication (IPC) in distributed environ- ments: An investigation and performance analysis of some middleware technologies.” International Journal of Modern Education & Com- puter Science , vol. 12, no. 2, 2020

    work page 2020

  4. [3]

    Evaluation of inter-process communication mechanisms,

    A. Venkataraman and K. K. Jagadeesha, “Evaluation of inter-process communication mechanisms,” Architecture, vol. 86, p. 64, 2015

    work page 2015

  5. [4]

    ROS: an open-source robot operating system,

    M. Quigley, K. Conley, B. Gerkey, J. Faust, T. Foote, J. Leibs, R. Wheeler, A. Y . Ng, et al. , “ROS: an open-source robot operating system,” in ICRA workshop on open source software , vol. 3, no. 3.2. Kobe, Japan, 2009, p. 5

    work page 2009

  6. [5]

    A survey on MQTT: a protocol of internet of things (IoT),

    D. Soni and A. Makwana, “A survey on MQTT: a protocol of internet of things (IoT),” in International conference on telecommunication, power analysis and computing techniques (ICTPACT-2017) , vol. 20, 2017, pp. 173–177

    work page 2017

  7. [6]

    DDOS: taming nondeterminism in distributed systems,

    N. Hunt, T. Bergan, L. Ceze, and S. D. Gribble, “DDOS: taming nondeterminism in distributed systems,” ACM SIGPLAN Notices , vol. 48, no. 4, pp. 499–508, 2013

    work page 2013

  8. [7]

    Automatic latency management for ROS2: Benefits, challenges, and open problems,

    T. Blass, A. Hamann, R. Lange, D. Ziegenbein, and B. B. Branden- burg, “Automatic latency management for ROS2: Benefits, challenges, and open problems,” in 2021 IEEE 27th Real-Time and Embedded Technology and Applications Symposium (RTAS) . IEEE, 2021, pp. 264–277

    work page 2021

Show all 36 references
  1. [8]

    Toward a lingua franca for deterministic concurrent systems,

    M. Lohstroh, C. Menard, S. Bateni, and E. A. Lee, “Toward a lingua franca for deterministic concurrent systems,” ACM Transactions on Embedded Computing Systems (TECS) , vol. 20, no. 4, pp. 1–27, 2021

    2021

  2. [9]

    Reactors: A deterministic model for composable reactive systems,

    M. Lohstroh, ´I. ´I. Romeo, A. Goens, P. Derler, J. Castrillon, E. A. Lee, and A. Sangiovanni-Vincentelli, “Reactors: A deterministic model for composable reactive systems,” in Cyber Physical Systems. Model- Based Design: 9th International Workshop, CyPhy 2019, and 15th Intern...

    2019

  3. [10]

    Performance evaluation of real-time ROS2 robotic control in a time-synchronized distributed network,

    L. Puck, P. Keller, T. Schnell, C. Plasberg, A. Tanev, G. Heppner, A. Roennau, and R. Dillmann, “Performance evaluation of real-time ROS2 robotic control in a time-synchronized distributed network,” in 2021 IEEE 17th International Conference on Automation Science and Engineeri...

    2021

  4. [11]

    Carla: An open urban driving simulator,

    A. Dosovitskiy, G. Ros, F. Codevilla, A. Lopez, and V . Koltun, “Carla: An open urban driving simulator,” in Conference on robot learning . PMLR, 2017, pp. 1–16

    2017

  5. [12]

    A middle way for robotics middleware,

    P. Fitzpatrick, E. Ceseracciu, D. E. Domenichelli, A. Paikan, G. Metta, and L. Natale, “A middle way for robotics middleware,” Journal of Software Engineering for Robotics , vol. 5, no. 2, pp. 42–49, 2014

    2014

  6. [13]

    Extremely slow message creation for large arrays in python,

    “Extremely slow message creation for large arrays in python,” https: //github.com/ros2/rosidl python/issues/156

  7. [14]

    Publishing large data is 30x-100x slower than for rclcpp,

    “Publishing large data is 30x-100x slower than for rclcpp,” https:// github.com/ros2/rclpy/issues/763

  8. [15]

    Very slow publishing of large messages,

    “Very slow publishing of large messages,” https://github.com/ros2/ ros2/issues/1242

  9. [16]

    Latency analysis of ROS2 multi-node systems,

    T. Kronauer, J. Pohlmann, M. Matth ´e, T. Smejkal, and G. Fettweis, “Latency analysis of ROS2 multi-node systems,” in 2021 IEEE In- ternational Conference on Multisensor Fusion and Integration for Intelligent Systems (MFI) . IEEE, 2021, pp. 1–7

    2021

  10. [17]

    Omg data-distribution service: Architectural overview,

    G. Pardo-Castellote, “Omg data-distribution service: Architectural overview,” in23rd International Conference on Distributed Computing Systems Workshops, 2003. Proceedings. IEEE, 2003, pp. 200–206

    2003

  11. [18]

    Memory leak in subscription when using zero-copy with rmw cyclonedds,

    “Memory leak in subscription when using zero-copy with rmw cyclonedds,” https://github.com/ros2/rclpy/issues/833

  12. [19]

    A robotic communica- tion middleware combining high performance and high reliability,

    W. Liu, H. Wu, Z. Jiang, Y . Gong, and J. Jin, “A robotic communica- tion middleware combining high performance and high reliability,” in 2020 IEEE 32nd International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD) . IEEE, 2020, pp. 217–224

    2020

  13. [20]

    Zoro: A robotic middleware combining high performance and high reliability,

    W. Liu, J. Jin, H. Wu, Y . Gong, Z. Jiang, and J. Zhai, “Zoro: A robotic middleware combining high performance and high reliability,” Journal of Parallel and Distributed Computing , vol. 166, pp. 126–138, 2022

    2022

  14. [21]

    Tzc: Efficient inter-process communication for robotics middleware with partial serialization,

    Y .-P. Wang, W. Tan, X.-Q. Hu, D. Manocha, and S.-M. Hu, “Tzc: Efficient inter-process communication for robotics middleware with partial serialization,” in 2019 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2019, pp. 7805–7812

    2019

  15. [22]

    Consistency vs. availability in distributed cyber-physical systems,

    E. A. Lee, R. Akella, S. Bateni, S. Lin, M. Lohstroh, and C. Menard, “Consistency vs. availability in distributed cyber-physical systems,” ACM Transactions on Embedded Computing Systems , vol. 22, no. 5s, pp. 1–24, 2023

    2023

  16. [23]

    High- performance deterministic concurrency using lingua franca,

    C. Menard, M. Lohstroh, S. Bateni, M. Chorlian, A. Deng, P. Dono- van, C. Fournier, S. Lin, F. Suchert, T. Tanneberger, et al. , “High- performance deterministic concurrency using lingua franca,” ACM Transactions on Architecture and Code Optimization , vol. 20, no. 4, pp. 1–29, 2023

    2023

  17. [24]

    Efficient parallel reinforcement learning framework using the reactor model,

    J. Kwok, M. Lohstroh, and E. A. Lee, “Efficient parallel reinforcement learning framework using the reactor model,” in Proceedings of the 36th ACM Symposium on Parallelism in Algorithms and Architectures, ser. SPAA ’24. New York, NY , USA: Association for Computing Machinery, ...

    2024

  18. [25]

    Ptides: A programming model for distributed real-time embedded systems,

    P. Derler, T. H. Feng, E. A. Lee, S. Matic, H. D. Patel, Y . Zhao, and J. Zou, “Ptides: A programming model for distributed real-time embedded systems,” May 2008. [Online]. Available: http: //www2.eecs.berkeley.edu/Pubs/TechRpts/2008/EECS-2008-72.html

    2008

  19. [26]

    Distributed simulation: A case study in design and verification of distributed programs,

    K. M. Chandy and J. Misra, “Distributed simulation: A case study in design and verification of distributed programs,” IEEE Transactions on software engineering , no. 5, pp. 440–452, 1979

    1979

  20. [27]

    Distributed simulation of networks,

    K. M. Chandy, V . Holmes, and J. Misra, “Distributed simulation of networks,” Computer Networks (1976) , vol. 3, no. 2, pp. 105–113, 1979

    1976

  21. [29]

    T. E. Oliphant et al., Guide to numpy . Trelgol Publishing USA, 2006, vol. 1

    2006

  22. [30]

    A cross-language development platform for in-memory data,

    A. Arrow, “A cross-language development platform for in-memory data,” 2022

    2022

  23. [31]

    Ray: A distributed framework for emerging {AI} applications,

    P. Moritz, R. Nishihara, S. Wang, A. Tumanov, R. Liaw, E. Liang, M. Elibol, Z. Yang, W. Paul, M. I. Jordan, et al. , “Ray: A distributed framework for emerging {AI} applications,” in 13th USENIX sym- posium on operating systems design and implementation (OSDI 18) , 2018, pp. 561–577

    2018

  24. [32]

    ROS2 NumPy, Tooling for converting ROS messages to and from NumPy arrays,

    “ROS2 NumPy, Tooling for converting ROS messages to and from NumPy arrays,” https://github.com/Box-Robotics/ros2 numpy

  25. [33]

    Evaluation of an eager protocol optimization for mpi,

    R. Brightwell and K. Underwood, “Evaluation of an eager protocol optimization for mpi,” in European Parallel Virtual Machine/Message Passing Interface Users’ Group Meeting . Springer, 2003, pp. 327– 334

    2003

  26. [34]

    Application performance pitfalls and tcp’s nagle algorithm,

    G. Minshall, Y . Saito, J. C. Mogul, and B. Verghese, “Application performance pitfalls and tcp’s nagle algorithm,” ACM SIGMETRICS Performance Evaluation Review , vol. 27, no. 4, pp. 36–44, 2000

    2000

  27. [35]

    End-to- end urban driving by imitating a reinforcement learning coach,

    Z. Zhang, A. Liniger, D. Dai, F. Yu, and L. Van Gool, “End-to- end urban driving by imitating a reinforcement learning coach,” in Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2021

    2021

  28. [36]

    YOLOv5 by Ultralytics,

    G. Jocher, “YOLOv5 by Ultralytics,” May 2020. [Online]. Available: https://github.com/ultralytics/yolov5

    2020

Pith tools

Reviewed August 12, 2026 · model on record in the stance chip above.