Real-Time Linux and Its Application Programming Interface

The Real-Time Linux Application Programming Interface

Due to its conformity with the POSIX standards, the Real-Time Linux API for creating and managing real-time threads is available through the Linux C headers sched.h, time.h, and pthread.h.¹ Functions for scheduling, threads, semaphores (including mutexes), real-time timers, and other real-time utilities are available.

Consider a simple program in which the main function creates a thread. The thread can be started by calling the pthread_create() function and providing it with a function to be run in the new thread. The function then can terminate itself and its own thread by calling pthread_exit(). The main function will wait for the thread to end when pthread_join() is called.

These functions are part of a standardized (IEEE) threading language in C called POSIX threads (pthreads). In our programs in lab 5, lab 6, lab 7, lab 8, we will use these functions in the following order.

1. pthread_create(), for which the prototype is (Group 2018a),

   int pthread_create(
     pthread_t *thread,              // a pointer to the thread
     const pthread_attr_t *attr,     // running/scheduling parameters
     void *(*start_routine)(void*),  // function to run in the thread
     void *arg);                     // argument for start_routine

   is used to start the thread. This function prototype is in the pthread.h header, which also defines the thread type (pthread_t) and thread attribute type (pthread_attr_t). The supplied start_routine() function is executed at the start of the thread with argument arg. The thread attributes attr can be used to set scheduling policies and parameters (e.g., priority). If attr == NULL, the default attributes will be used.

2. When the thread is no longer needed, a function within the pthread—for instance, the start_routine() function—can terminate the thread with the pthread_exit() function (Group 2018b). This function’s prototype is

   void pthread_exit(void *value_ptr);

   the only argument of which is a pointer void *value_ptr. The pointer allows information to be passed from the terminating thread to the thread that called pthread_join(), see below. After pthread_exit() is called, the start_routine() function should end, stopping the thread.

3. While this thread has been running, the main function that invoked pthread_create() has continued on in its original thread. At some point, before the end of the program, we should wait for the thread to end. This is usually done with the pthread_join() function, for which the prototype is

   int pthread_join(pthread_t thread,
                    void **value_ptr);

   Here, thread is the same as that used in pthread_create(), and value_ptr is the pointer from the pthread_exit() function.

The Real-Time Linux scheduler can be configured for task deadlines (section 1.7, section 5.2) with the struct sched_attr and the function sched_setattr()—see realtimelinux-deadlines for more information. Here, we have focused on managing real-time threads. There are many more possibilities, some of which we will see as we proceed.