Real-time scheduler that can simultaneously run multiple periodic tasks. Parameters for each task are configured independently.
More...
#include <scheduler.hpp>
|
| | Scheduler () |
| | [Blocking] Create an instance and initialize the real-time scheduler. More...
|
| |
| void | AddTask (std::function< void(void)> &&callback, const std::string &task_name, int interval, int priority, int cpu_affinity=-1) |
| | [Non-blocking] Add a new periodic task to the scheduler's task pool. Each task in the pool is assigned to a dedicated thread with independent thread configuration. More...
|
| |
| void | Start () |
| | [Blocking] Start all added tasks. A dedicated thread will be created for each added task and the periodic execution will begin. More...
|
| |
| void | Stop () |
| | [Blocking] Stop all added tasks. The periodic execution will stop and all task threads will be closed with the resources released. More...
|
| |
| int | max_priority () const |
| | [Non-blocking] Get maximum available priority for user tasks. More...
|
| |
| int | min_priority () const |
| | [Non-blocking] Get minimum available priority for user tasks. More...
|
| |
| size_t | num_tasks () const |
| | [Non-blocking] Get number of tasks added to the scheduler. More...
|
| |
◆ Scheduler()
| flexiv::rdk::Scheduler::Scheduler |
( |
| ) |
|
[Blocking] Create an instance and initialize the real-time scheduler.
- Exceptions
-
| std::runtime_error | if the initialization sequence failed. |
- Warning
- This constructor blocks until the initialization sequence is successfully finished.
◆ AddTask()
| void flexiv::rdk::Scheduler::AddTask |
( |
std::function< void(void)> && |
callback, |
|
|
const std::string & |
task_name, |
|
|
int |
interval, |
|
|
int |
priority, |
|
|
int |
cpu_affinity = -1 |
|
) |
| |
[Non-blocking] Add a new periodic task to the scheduler's task pool. Each task in the pool is assigned to a dedicated thread with independent thread configuration.
- Parameters
-
| [in] | callback | Callback function of user task. |
| [in] | task_name | A unique name for this task. |
| [in] | interval | Execution interval of this periodic task [ms]. The minimum available interval is 1 ms, equivalent to 1 kHz loop frequency. |
| [in] | priority | Priority for this task thread, can be set to min_priority()–max_priority() for real-time scheduling, or 0 for non-real-time scheduling. When the priority is set to use real-time scheduling, this thread becomes a real-time thread and can only be interrupted by threads with higher priority. When the priority is set to use non-real-time scheduling (i.e. 0), this thread becomes a non-real-time thread and can be interrupted by any real-time threads. The common practice is to set priority of the most critical tasks to max_priority() or near, and set priority of other non-critical tasks to 0 or near. To avoid race conditions, the same priority should be assigned to only one task. |
| [in] | cpu_affinity | CPU core for this task thread to bind to, can be set to 2–(num_cores
- 1). This task thread will only run on the specified CPU core. If left with the default value (-1), then this task thread will not bind to any CPU core, and the system will decide which core to run this task thread on according to the system's own strategy. The common practice is to bind the high-priority task to a dedicated spare core, and bind low-priority tasks to other cores or just leave them unbound (cpu_affinity = -1).
|
- Exceptions
-
| std::logic_error | if the scheduler is already started or is not fully initialized yet. |
| std::invalid_argument | if the specified interval/priority/affinity is invalid or the specified task name is duplicate. |
| std::runtime_error | if an error is triggered by the client computer. |
- Note
- Setting CPU affinity on macOS has no effect, as its Mach kernel takes full control of thread placement so CPU binding is not supported.
- Warning
- Calling this function after start() is not allowed.
-
For maximum scheduling performance, setting CPU affinity to 0 or 1 is not allowed: core 0 is usually the default core for system processes and can be crowded; core 1 is reserved for the scheduler itself.
- Examples
- intermediate1_realtime_joint_position_control.cpp, intermediate2_realtime_joint_impedance_control.cpp, intermediate3_realtime_joint_torque_control.cpp, intermediate4_realtime_joint_floating.cpp, intermediate5_realtime_cartesian_pure_motion_control.cpp, and intermediate6_realtime_cartesian_motion_force_control.cpp.
◆ max_priority()
| int flexiv::rdk::Scheduler::max_priority |
( |
| ) |
const |
◆ min_priority()
| int flexiv::rdk::Scheduler::min_priority |
( |
| ) |
const |
[Non-blocking] Get minimum available priority for user tasks.
- Returns
- The minimum priority that can be set for a user task with real-time scheduling policy when calling AddTask().
◆ num_tasks()
| size_t flexiv::rdk::Scheduler::num_tasks |
( |
| ) |
const |
[Non-blocking] Get number of tasks added to the scheduler.
- Returns
- Number of added tasks.
◆ Start()
| void flexiv::rdk::Scheduler::Start |
( |
| ) |
|
◆ Stop()
| void flexiv::rdk::Scheduler::Stop |
( |
| ) |
|
The documentation for this class was generated from the following file:
1.9.1