Evaluate ROS component performance with qrb_ros_benchmark

qrb_ros_benchmark builds on ros2_benchmark and extends it with specialized components for benchmarking QRB ROS transport types, including:

QRB transport types (Image, IMU, PointCloud2)
DMABuf transport types (Image, PointCloud2)
Standard ROS message types

Software structure

The following figure shows the software structure of qrb_ros_benchmark.

Layered stack with the QRB ROS benchmark monitor and playback nodes above the ROS2 benchmark nodes, QRB transport components, and ROS2. — Software structure of qrb_ros_benchmark.

The basic usage is similar to ros2_benchmark and the following are the exclusive message types supported by qrb_ros_benchmark: QRB transport types:

qrb_ros/transport/type/Image
qrb_ros/transport/type/Imu
qrb_ros/transport/type/PointCloud2
qrb_ros_tensor_list_msgs::msg::TensorList

DMABuf transport types:

dmabuf_transport/type/Image
dmabuf_transport/type/PointCloud2

Prerequisites

You have set up the device, installed ROS2 Jazzy and the Qualcomm Intelligent Robotics (QIR) SDK on the device according to Install the QIR SDK.

Run out-of-the-box `qrb_ros_benchmark`

Install the qrb_ros_benchmark packages

Install the packages

sudo apt install ros-jazzy-qrb-ros-benchmark

Create a minimum template for evaluating qrb_ros/transport/type/Image

Create the launch file

vim qrb-ros-transport-image-type_launch.py

qrb-ros-transport-image-type_launch.py

  from launch_ros.actions import ComposableNodeContainer
  from launch_ros.descriptions import ComposableNode
  from ros2_benchmark import ImageResolution
  from ros2_benchmark import ROS2BenchmarkConfig, ROS2BenchmarkTest
  def launch_setup(container_prefix, container_sigterm_timeout):
      data_loader_node = ComposableNode(
          name='DataLoaderNode',
          namespace=TestQrbNode.generate_namespace(),
          package='ros2_benchmark',
          plugin='ros2_benchmark::DataLoaderNode',
      )
      # QrbPlaybackNode
      playback_node = ComposableNode(
          name='QrbPlaybackNode',
          namespace=TestQrbNode.generate_namespace(),
          package='qrb_ros_benchmark',
          plugin='qrb_ros::benchmark::QrbPlaybackNode',
          parameters=[{
              'data_formats': [
                  'qrb_ros/transport/type/Image'
              ],
          }],
          remappings=[
              ('buffer/input0', '/data_loader_image'),
              ('input0', '/playback_image')
          ]
      )
      # Insert QRB ROS nodes
      # QrbMonitorNode
      monitor_node = ComposableNode(
          name='QrbMonitorNode',
          namespace=TestQrbNode.generate_namespace(),
          package='qrb_ros_benchmark',
          plugin='qrb_ros::benchmark::QrbMonitorNode',
          parameters=[{
              'monitor_data_format': 'qrb_ros/transport/type/Image',
          }]
      )
      composable_node_container = ComposableNodeContainer(
          name='container',
          namespace=TestQrbNode.generate_namespace(),
          package='rclcpp_components',
          executable='component_container_mt',
          prefix=container_prefix,
          sigterm_timeout=container_sigterm_timeout,
          composable_node_descriptions=[
              data_loader_node,
              playback_node,
              monitor_node,
              # Insert QRB ROS nodes
          ],
          output='screen'
      )
      return [composable_node_container]
  def generate_test_description():
      return TestQrbNode.generate_test_description_with_nsys(launch_setup)
  class TestQrbNode(ROS2BenchmarkTest):
      config = ROS2BenchmarkConfig(
          benchmark_name='Qrb_ros_transport image Test Benchmark',
          input_data_path='/path/to/rosbag',
          publisher_upper_frequency=100.0,
          publisher_lower_frequency=10.0,
          playback_message_buffer_size=10
      )
      def test_benchmark(self):
          self.run_benchmark()

Start the qrb-ros-transport-image-type benchmark

Start the benchmark

source /opt/ros/jazzy/setup.bash
launch_test qrb-ros-transport-image-type_launch.py

Build from source

Install dependencies

Install the dependencies

sudo apt install ros-jazzy-qrb-ros-transport-image-type

Download the source code and build with colcon

Clone the repositories and build

mkdir -p ~/ros-ws/src
cd ~/ros-ws/src
git clone https://github.com/qualcomm-qrb-ros/ros2_benchmark.git
git clone https://github.com/qualcomm-qrb-ros/qrb_ros_transport.git
git clone https://github.com/qualcomm-qrb-ros/lib_mem_dmabuf.git
git clone https://github.com/qualcomm-qrb-ros/qrb_ros_imu.git
git clone https://github.com/qualcomm-qrb-ros/dmabuf_transport.git
git clone https://github.com/qualcomm-qrb-ros/qrb_ros_benchmark.git
cd ~/ros-ws/
colcon build

Run and debug

Source the workspace

source install/setup.bash

Run the qrb-ros-benchmark

Run the qrb-ros-benchmark according to step 2 of Run out-of-the-box qrb_ros_benchmark.

​Software structure

​Prerequisites

​Run out-of-the-box qrb_ros_benchmark

​Build from source

Software structure

Prerequisites

Run out-of-the-box `qrb_ros_benchmark`

Build from source