Status Update: 2023-10-25

[haixuanTao]

👍

[haixuanTao]

Dora Course: Tsinghua and CentraleSupelec Partnership

Finalize the partnership and just spend tuesday at CentraleSupelec meeting students will work with ~10 Student in Sept-Jan 2023 and maybe more in Jan-May 2024, hoping to have even more in Sept 2024. Huge interest from Students!

Made two presentations that can be reused within Online Course:

• A quick introduction to dora-rs
• Getting Started to dora-rs
• How to contribute to dora-rs

List of cool Standalone features project

Title	Description
Rust hot-reloading	Enabling to code rust operator in real time just like for Python
Arrow tensor Type	arrow-rs: extension type for Tensor Type enables multi-dimensional array to be better handle in Rust. See:apache/arrow-rs#4472
Rust-Python binding	It could be worth looking at rye as a way to automate the creation of virtual environment and making sure to ship dora operator in a way that is safe and sound. To do this it could be worth looking into making rye a library or else, but find a way to automate python package management. See: astral-sh/rye#113
Hardware acceleration	In Python, we don't really have a way to automatically target the current hardware at hand. It could be interesting to have a very broad reach compiler such as iree or tvm or else, and look if we can automatically, compile a DL model for the hardware at hand and provide GPU-acceleration . In Rust, we can check how to do acceleration at compile time, such as Candle: https://github.com/huggingface/candle and https://github.com/raviqqe/melior
CLI	Currently the CLI is separated into 3 binaries. It could be good to merge them into a single binary.
CLI	CLI could value standardising its argument for stop and logs and use dynamic argument to choose dataflow. I think we can get inspiration for docker and reuse their syntax
CLI	Can check up embedded nushell for a better column based cli application, for printingdataflows for exemple
Test bench harness	Currently we have a quick test harness to measure performance but it would be great to improve it and use new tooling such as criterion, hyperfine
C/C++ API	C/C++ API has not been our priority but could be a great first issue to learn about FFIs
Opentelemetry logs implementation	Opentelemetry recently stabilised the log feature enabling distributed logging. It could be great to use it. Currently we have a simple write to file implementation. Check out: https://docs.rs/tracing-for-pyo3-logging/latest/tracing_for_pyo3_logging/fn.setup_logging.html Or https://crates.io/crates/pyo3-pylogger
Opentelemetry metrics implementation	Last year we experimented with opentelemetry metrics and automatically collected data about, CPU, Memory, Disk usage. It could be interesting to see if more can be done in automated telemetry
Opentelemetry tracing otlp	Currently we use a jaeger specific provider for tracing but it could be interesting to change it for the generic otlp format
ROS/ROS 2 runtime bridge optimization	There might be optimization in the way data are being serialize/deserialize, especially for byte, that are currently handle one element at a time instead of being memory copied
dora-daemon	Heartbeat protocol for detecting crashed nodes/operators
Windows Testing/Support	Windows has couples of CI/CD issues has it does not share UNIX syntax. A quick fix could be to investigate the reason and fix it.
Improvement	Improve performance by redoing part of Python in dora-drives in Rust
Improve documentation in Chinese	Our current website can handle both english and chinese so feel free to add chinese

Online Dora Course

Title
Motivation and Basic Usage
Advanced features and how to contribute
On data format
On writing command line interface and tokio runtime
On writing a Python extension
On writing shared library
On distributed tracing, metrics, logs and Opentelemetry
On Zero Copy optimization and benchmark
On writing a Ser/de custom allocator
On writing custom Shared Memory server, TCP Stream
On Async runtime and CPU-bound task
Recap, planned features, questions, etc

-> Registering will be: https://os2edu.cn/course/163

[haixuanTao]

dora-robomaster

Hired an intern to work on dora-drives and hardware support such as DJI robomaster S1 which is a cheap ~500$ small robot that can be controlled with Python from a remote computer.

• Finished the build ( 3 days )
• Jailbreak DJI dora Sandbox. ( Some closed source code )
• Testing out dora with Yolov5 object detection and Midas Depth perception for obstacle avoidance on the robot.

[haixuanTao]

Rust Arrow API

Recap:

• The arrow data format defines a cross-language memory layout for various types
• Enables Python code to read data from shared memory regions without copying (see Share events to Python without copying via arrow crate #228)

Current state:

• We now use arrow as the main data format for all dora messages
  • Python API is entirely based on arrow, which can be converted to/from numpy and pandas formats
  • ROS2 Bridge uses arrow to represent typed ROS2 messages
  • Rust API is currently being updated to arrow in Start to make Rust node API typed using arrow #353
• The Rust/C/C++ APIs still mostly use byte array as message types (converted to arrow arrays behind the scenes)
  • Goal: Make it easy to construct and use higher-level arrow types
  • We try to figure out a way to enable zero-copy construction of arrow types
• Future idea: Make arrow schema part of node metadata and dataflow YAML

[haixuanTao]

dora-record

First POC build on top of dora-rs to log data in order to replay it later using arrow format.

Advantage of this format

• Being zero-copy and memory mapped that gives unprecedented read speed. See: https://huggingface.co/docs/datasets/about_arrow
• Can use plenty of tools such as hadoop, pandas, torch, R, matlab and so on, very quickly without preprocessing
• Does not need to be serialized-deserialized which can be handy when partially reading data.
• Should benefit any column-based computation of data such as DL training.

[bigdaronlee163]

Hello, I have just graduated and am working in the system-related field of the autonomous driving industry. I am interested in this project and would like to get involved to familiarize myself with it, specifically by participating in the "Test bench harness". Afterwards, I would like to take on other projects. However, I am also open to your suggestions on where to start.

[haixuanTao]

Hey @bigdaronlee163 :) Thanks for your interest and dropping a message!

So, currently our way of testing the speed of performance of dora-rs is through the following repo: https://github.com/dora-rs/dora-benchmark

Which runs 2 custom operators with a message containing a timestamp and measure the latency between sending and receiving.

We run this 100 times with 8 different message size and then we have a csv table with the latency.

Ultimately, this could be much more.

I am currently working on using dora-record and Jaeger to automate the measurement of times spent between sending and receiving. I'll drop the code later today!

This is a proof of concept but ultimately, it could be used to automatically generate latency report for all based on opentelemetry :D

So, I can leave the creation of this tool to you if that interest you :)

[haixuanTao]

Feel free to reach out on discord as well for more flexible communication: https://discord.gg/d66rKccK

[bigdaronlee163]

I will spend some time familiarizing myself with dora-rs

[LyonRust]

Is Rust hot-reloading what I understand like as "cargo run" automatically runs after writing rust code and saving it?

[haixuanTao]

So this features is only available in Python Operators at the moment but basically it allows you to modify your code in real time and keep the current state intact :)

See Demo:

Screencast.from.2023-11-22.14-07-43.webm