References

Lecture 9

ENPM605 – L9: Launch Files & Executors

Covers Python launch files (anatomy, generate_launch_description, two configuration patterns), advanced launch features (including other launch files, conditional launching with IfCondition, node grouping with GroupAction, and parameterized launch arguments), executors (single-threaded vs. multi-threaded, the concurrency-vs-parallelism distinction, the Python GIL and its impact on ROS 2), and callback groups (MutuallyExclusiveCallbackGroup and ReentrantCallbackGroup with execution timelines and comparison table).

ROS 2 Official Documentation

Launch Files Tutorials

ROS 2 Jazzy: Launch

Complete tutorial series for Python launch files, from basic node startup through substitutions and events.

• Creating launch files

• Passing arguments

• Using substitutions

https://docs.ros.org/en/jazzy/Tutorials/Intermediate/Launch/Launch-Main.html

About Executors

ROS 2 Executors Concept

In-depth conceptual explanation of how executors manage thread pools and dispatch callbacks.

• Single-threaded executor

• Multi-threaded executor

• Callback scheduling model

https://docs.ros.org/en/jazzy/Concepts/Intermediate/About-Executors.html

Using Callback Groups

Callback Groups How-To

Practical guide to creating and assigning callback groups, with examples for both group types.

• MutuallyExclusiveCallbackGroup

• ReentrantCallbackGroup

• When to use each

https://docs.ros.org/en/jazzy/How-To-Guides/Using-callback-groups.html

Launch File API

launch Python API

launch package reference

Full API documentation for LaunchDescription, DeclareLaunchArgument, IncludeLaunchDescription, GroupAction, and substitution classes.

• Actions reference

• Substitutions reference

• Conditions reference

https://docs.ros.org/en/jazzy/p/launch/

launch_ros Python API

launch_ros package reference

API for Node, FindPackageShare, and PushRosNamespace used in ROS 2 launch files.

• Node action

• FindPackageShare substitution

• Namespace management

https://docs.ros.org/en/jazzy/p/launch_ros/

Launch File Formats

XML, YAML, and Python

Comparison of all three launch file formats with equivalent examples, useful as a reference when reading third-party packages that use XML or YAML launch files.

• Format equivalence table

• When to use each format

• Migration notes

https://docs.ros.org/en/jazzy/How-To-Guides/Launch-file-different-formats.html

Python Threading and the GIL

Python threading module

Python Standard Library: threading

Reference for Thread, Lock, RLock, Event, and Condition – the synchronization primitives used when callbacks share mutable state.

• threading.Lock

• Thread lifecycle

• thread.daemon

https://docs.python.org/3/library/threading.html

Python GIL Explained

Real Python: The Python GIL

Practical explanation of what the GIL is, why it exists, and when it is and is not released.

• GIL history and rationale

• Impact on multi-threaded code

• When GIL is released (I/O, C extensions)

https://realpython.com/python-gil/

Python multiprocessing module

Python Standard Library: multiprocessing

For cases where true Python parallelism is required, multiprocessing bypasses the GIL by using separate OS processes instead of threads.

• Process vs Thread

• Pool for parallel work

• Shared memory options

https://docs.python.org/3/library/multiprocessing.html

External Tutorials

Articulated Robotics: Launch Files

Articulated Robotics

Video and written tutorials for ROS 2 launch files and executors with practical robot examples.

• Launch file deep dives

• Executor comparisons

https://articulatedrobotics.xyz/category/ros2-tutorials/

The Construct: ROS 2 Executors

The Construct

Browser-based interactive environment with guided exercises on executors and callback groups.

• Interactive executor exercises

• Callback group demos

• No local install required

https://www.theconstructsim.com/ros2-for-beginners/

Recommended Reading

Anis Koubaa (Ed.)

Robot Operating System (ROS): The Complete Reference (Vol. 1-7)

Relevant chapters cover ROS 2 launch systems and the executor concurrency model.

Open Robotics

Programming Robots with ROS 2

Chapters on launch files and the threading model provide applied coverage of this lecture’s topics.

Silberschatz, Galvin, and Gagne

Operating System Concepts (10th Edition)

Chapter 4 (Threads) provides the OS-level background for understanding the multi-threaded executor, thread pools, scheduling, and the synchronization primitives that prevent race conditions.

David Beazley

Python Concurrency from the Ground Up (PyCon Talk)

Classic conference talk (available on YouTube) explaining the GIL, threads, asyncio, and multiprocessing in CPython with clear timing diagrams that map directly to the executor timelines covered in this lecture.