Px4 module design part 13: workqueue design

1. WorkQueue start-up

WorkQueue yes PX4 Flight control software Common( public ) Components , By function px4::WorkQueueManagerStart It started , Please refer to PX4 Module design ten ：PX4 The boot process .

board_app_initialize
 └──> px4_platform_init
     └──> px4::WorkQueueManagerStart

notes 1：Nuttx The system is supported WorkQueue Of . however PX4 stay common( public ) The component layer implements a similar WorkQueue The function of , Instead of directly using Nuttx Systematic WorkQueue. It is preliminarily suspected that this result was caused by historical time .
notes 2：Nuttx The first version is in 2007 Released in , Start supporting 2-3 individual MCU((i.e. 8051 and ARM7);PX4-AutoPilot yes 2009 The project started in ,2013 year ETH Zurich ( Federal Polytechnic University of Zurich ) Computer vision and geometry Laboratory Lorenz Meier , Released the first generation of experimental version ： Dual flight control processors PX4FMU/PX4IO Hardware .

So to sum up , For the following reasons
1） Its historical reasons ,PX4-AutoPilot Common components of WorkQueue Independent implementation ;
2） Flight control mode adopts C++ Class inheritance for development and management ;
3）uORB Message component adopts C++ Class to manage ;
4）HRT High precision timing acquisition trigger management ;

WorkQueue The overall management of the company combines the above historical reasons , take C/C++ Design , class , Inherit , And kernel mode / User mode . The overall feeling is extremely complex , This part of the content is really not flattering ！！！(—AnyWay, Historical reasons !!!—)

2. WorkQueue Interface

2.1 Basic interface

The most basic WorkQueue The management interface is not responsible , Mainly Start/Stop/Status Three .

int WorkQueueManagerStart() //WorkQueue Manage startup tasks 

int WorkQueueManagerStop() // As a basic component, it basically does not need Stop, At least there is no Stop The place of .

int WorkQueueManagerStatus() //WorkQueue State query 

2.2 Auxiliary interface

const wq_config_t & device_bus_to_wq(uint32_t device_id_int)  //device_bus  turn  wq To configure 

const wq_config_t & serial_port_to_wq(const char *serial)     //serial_port  turn  wq To configure 

const wq_config_t & ins_instance_to_wq(uint8_t instance)      //instance  turn  wq To configure 

static WorkQueue * FindWorkQueueByName(const char *name)      // Check by name WorkQueue

WorkQueue * WorkQueueFindOrCreate(const wq_config_t &new_wq)   // Find or create WorkQueue

2.3 WorkQueue Task function

WorkQueue At present, it is in support of Flat and Protected Build Two compilation modes , The most significant difference between different compilation modes is Flat Build Use pthread_create Set up tasks , and Protected Build Use px4_task_spawn_cmd Set up tasks .

2.3.1 Flat Build

static void * WorkQueueRunner(void *context)

2.3.2 Protected Build

The internal implementation of this function will call again Flat Build Function of （ At this time, the running code space will be in kernel mode ）.

inline static int WorkQueueRunner(int argc, char *argv[])

2.4 Key interface analysis

2.4.1 WorkQueueManagerStart

WorkQueueManagerStart
 ├──> <_wq_manager_should_exit.load() && (_wq_manager_create_queue == nullptr)>
 │   ├──> _wq_manager_should_exit.store(false);
 │   ├──> int task_id = px4_task_spawn_cmd("wq:manager",SCHED_DEFAULT,SCHED_PRIORITY_MAX,PX4_STACK_ADJUSTED(1280),(px4_main_t)&WorkQueueManagerRun,nullptr);
 │   └──> <task_id < 0>
 │       ├──> _wq_manager_should_exit.store(true);
 │       ├──> PX4_ERR("task start failed (%i)", task_id);
 │       └──> return -errno;
 ├──> else
 │   ├──> PX4_WARN("already running");
 │   └──> return PX4_ERROR;
 └──> return PX4_OK;

2.4.2 WorkQueueManagerRun

WorkQueueManagerRun
 ├──> _wq_manager_wqs_list = new BlockingList<WorkQueue *>();
 ├──> _wq_manager_create_queue = new BlockingQueue<const wq_config_t *, 1>();
 ├──> <while (!_wq_manager_should_exit.load())>
 │   ├──> const wq_config_t *wq = _wq_manager_create_queue->pop();  // When there is no work queue When , Management tasks are always blocked here .
 │   └──> <wq != nullptr> // It should not be empty , Fault tolerance in case of segment errors , Inside is the establishment of new work queue
 │       ├──> [stack, priority, etc]  // A little ....
 │       ├──> [Flat Build, pthread_create WorkQueueRunner]
 │       ├──> [Protected Build, px4_task_spawn_cmd WorkQueueRunner]
 │       ├──> <pid > 0>
 │       │   └──> PX4_DEBUG("starting: %s, priority: %d, stack: %zu bytes", wq->name, sched_priority, stacksize);
 │       └──> <else>
 │           └──> PX4_ERR("failed to create thread for %s (%i): %s", wq->name, pid, strerror(pid));
 └──> return 0;

2.4.3 WorkQueueRunner

WorkQueueRunner
 ├──> wq_config_t *config = static_cast<wq_config_t *>(context);
 ├──> WorkQueue wq(*config);
 ├──> _wq_manager_wqs_list->add(&wq);    // add to work queue list
 ├──> wq.Run();                          //  Here is the 
 ├──> _wq_manager_wqs_list->remove(&wq); // remove from work queue list
 └──> return nullptr;

2.4.4 WorkQueue::Run

WorkQueue::Run
 ├──> <while (!should_exit())>
 │   ├──> do {} while (px4_sem_wait(&_process_lock) != 0); // loop as the wait may be interrupted by a signal
 │   ├──> work_lock();
 │   └──> <while (!_q.empty())>
 │       ├──> WorkItem *work = _q.pop();
 │       ├──> work_unlock();         // unlock work queue to run (item may requeue itself)
 │       ├──> work->RunPreamble();
 │       ├──> work->Run();           //  What really needs to be implemented Run function , It's usually inheritance WorkItem The object of 
 │       ├──> work_lock();           // re-lock
 │       └──> work_unlock();
 └──> PX4_DEBUG("%s: exiting", _config.name);

2.4.5 WorkQueueFindOrCreate

WorkQueueFindOrCreate
 ├──> <_wq_manager_create_queue == nullptr>
 │   ├──> PX4_ERR("not running");
 │   └──> return nullptr;
 ├──> WorkQueue *wq = FindWorkQueueByName(new_wq.name); // search list for existing work queue
 ├──> <wq == nullptr>
 │   ├──> _wq_manager_create_queue->push(&new_wq);  // It's important here , Only push 了 ,WorkQueueManagerRun It can only be carried out inside .
 │   ├──> _uint64_t t = 0;
 │   └──> _<while (wq == nullptr && t < 10_s)>  // we wait until new wq is created, then return
 │       ├──> t += 1_ms;
 │       ├──> px4_usleep(1_ms);
 │       ├──> wq = FindWorkQueueByName(new_wq.name);
 │       └──> <wq == nullptr>
 │           └──> PX4_ERR("failed to create %s", new_wq.name);
 └──> return wq;

3. summary

Work queue , Actually, I'm not responsible . and PX4 Why does your work queue look complex , Mainly work queues and actual business coupling . Here we haven't put uORB Put your subscription content inside , If you combine this part , Plus the mutual switching of multiple inherited businesses , It seems more complicated .

So we especially emphasize that the design needs loose coupling , Try to be modular , Clear interface design , Define the frame design .

4. Reference material

【1】PX4 A brief introduction to the open source software framework
【2】Nuttx WorkQueue