No version for distro humble showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

No version for distro jazzy showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

No version for distro kilted showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

No version for distro rolling showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

No version for distro galactic showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

No version for distro iron showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

No version for distro melodic showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file

No version for distro noetic showing github. Known supported distros are highlighted in the buttons above.

Repository Summary

Description
Checkout URI https://github.com/ekxide/rmw_iceoryx2.git
VCS Type git
VCS Version main
Last Updated 2025-03-28
Dev Status UNKNOWN
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

rmw_iceoryx2

  1. Introduction
  2. Feature Completeness
  3. Performance
  4. Setup
  5. FAQ
  6. Commercial Support
  7. Maintainers
  8. Contributors

Introduction

[!IMPORTANT] The implementation is still in an “alpha” stage. Not all functionality is implemented/stable so surprises are to be expected.

If encountering problems, please create an issue so we can converge to stability :).

ROS 2 rmw implementation for iceoryx2.

iceoryx2 is a shared memory IPC middleware written in Rust for improved memory safety and easier safety certifiability. The implementation leverages the C++ bindings to the Rust core.

Feature Completeness

Feature Status
Node :white_check_mark:
Guard Condition :white_check_mark:
Event :construction:
Publish-Subscribe :white_check_mark:
Server-Client :construction:
Message Serialization :white_check_mark:
Waitset :white_check_mark:
Graph :construction:
QoS :construction:
Logging :white_check_mark:

Performance

[!NOTE]

  • The latency measurement can be reproduced with these instructions
  • The measurements were taken on a Ryzen 3950X without a fine-tuned OS - lower latency could be expected on a fine-tuned target
  • The performance_test tool uses rmw_iceoryx2 through the ROS 2 stack, which naturally introduces some overhead compared to pure iceoryx2
  • The minimal possible latency achievable with iceoryx2 is in the nanosecond range

Latency vs. Message Size v0.1.0

Setup

  1. Set up your environment for building ROS 2 from source

  2. Create a ROS 2 workspace:

    mkdir -p ~/workspace/src
    
  1. Clone the ROS 2 source:
    vcs import --input https://raw.githubusercontent.com/ros2/ros2/rolling/ros2.repos ~/workspace/src
    
  1. Clone iceoryx and iceoryx2 source:
    vcs import --force --input https://raw.githubusercontent.com/ekxide/rmw_iceoryx2/refs/heads/main/iceoryx.repos ~/workspace/src
    
  1. Clone rmw_iceoryx2:
    1. Either main or a specific version tag e.g. v0.1.0
    git clone -b main https://github.com/ekxide/rmw_iceoryx2.git ~/workspace/src/rmw_iceoryx2/
    
  1. Build ROS 2 with rmw_iceoryx2 and the demo nodes:
    cd ~/workspace/
    RMW_IMPLEMENTATION=rmw_iceoryx2_cxx colcon build --symlink-install --packages-up-to ros2cli_common_extensions rmw_iceoryx2_cxx rmw_iceoryx2_cxx_demo_nodes
    
  1. Verify the build:
    source ~/workspace/install/setup.zsh # or setup.bash
    ros2 doctor --report
    
The middleware should be properly set:

``` RMW MIDDLEWARE middleware name : rmw_iceoryx2_cxx

File truncated at 100 lines see the full file