EP2917834A1 - Method for scheduling with deadline constraints, in particular in linux, carried out in user space - Google Patents

Abstract

A method for scheduling tasks with deadline constraints, based on a model of independent periodic tasks and carried out in the user space by means of API POSIX.

Description

 METHOD OF SCHEDULING WITH DELAY CONSTRAINTS, ESPECIALLY IN LINUX, REALIZED IN USER SPACE

 The invention relates to a method for performing a single processor, multiprocessor scheduling or multi-task scheduling with time constraints. Task Scheduler with Deadline Constraints means that each task has a completion time that must not exceed. The scheduling performed supports execution on one or more processors. It is run under Linux, or any operating system that supports the POSIX standard, and in particular its POSIX.1c extension, but is not integrated with the kernel: it works in user space.

 User space is a mode of operation for user applications, as opposed to kernel space which is a supervisory mode of operation that has advanced features with all rights, especially that of accessing all the resources of a microprocessor. The manipulation of resources is nevertheless made possible in user space by so-called API ("Application Programming Interface") functions, which themselves rely on the use of Peripheral drivers. The development of a solution in user space makes it possible and facilitates the development of schedulers with temporal constraints compared to a direct integration into the operating system kernel which is made very difficult by its complexity. Another advantage is to bring increased stability because a runtime error in user space does not have a serious consequence for the integrity of the rest of the system.

In order to carry out a scheduling in user space, the method of the invention relies in particular on the mechanisms defined by the POSIX standard ("Portable Operating System Interface - X", ie "portable interface for the systems "X" expressing the Unix inheritance) and its POSIX.1c extension, including the POSIX task structure, POSIX threads ("pthreads") and POSIX task management APIs. It should be remembered that a process is a running program instance, a "task" is a division of a process and a "Thread" is the realization of a task under Linux using POSIX APIs; a thread or task can not exist without processes, but there can be multiple threads or tasks per process. We can refer to this in Robert Love's book "LINUX System programming", O'ReiNy, 2007.

 Linux is a system where time management is called "time share" as opposed to "real time" management. In this type of management, several factors related to the operation of the system such as resource sharing, input / output management, interruptions, the influence of virtual memory, etc. cause temporal uncertainties about task execution times. Therefore, it is not possible to guarantee a hard real time solution, that is to say where the execution of each task is performed within strict time limits and inviolable. The realization of the proposed scheduler is nevertheless suitable for real-time systems known as "soft" (in English "soft real time"), or "with constraints of expiry", which accept variations in the processing of data order from second to maximum. This is the case of a large number of real-time applications, for example multimedia.

Not being natively a real-time system, several technical solutions are however possible to make the Linux kernel compatible with real-time constraints. The most common solution is to associate an auxiliary real-time kernel with a real real-time scheduler (RT Linux, RTAI, XENOMAI). This auxiliary real-time kernel is a priority and deals directly with real-time tasks. Other tasks (non-real time) are delegated to the standard Linux kernel which is considered a lower priority task (or job). However, the development of a specific kernel-specific scheduler is very difficult since it requires a thorough knowledge of the kernel and involves heavy kernel developments, with all the complexity and instability that entails. In addition, Linux real-time extensions are supported by a smaller number of platforms. The proposed solution allows a realization in user space of this fact simpler, more stable and applicable to any platform supporting a standard Linux kernel. This approach does not guarantee time constraints real hard, but greatly simplifies the development of a scheduler while suitable for applications real time flexible (the vast majority of applications).

 A scheduling method according to the invention is particularly suitable for the implementation of low-consumption oriented scheduling policies, for example an EDF policy ("earliest deadline first", that is to say, priority over nearest deadline) - which is a special type of scheduling with time constraints - with dynamic voltage-frequency change (DVFS) to minimize consumption, which is important in embedded applications. See the following articles on this topic:

 R. Chéour et al. Fourth International Conference on Sensing Technology, 3 - 5 June 2010, Lecce, Italy;

 - R. Chéour et al. "Exploitation of the EDF scheduling in the wireless sensors networks," Measurement Science Technology Journal (IOP), Special Issue on Sensing Technology: Devices, Signals and Materials, 2011.

 There is much work on low-power scheduling, but it is largely theoretical and almost never integrated into an operating system because of the complexity of this work. The proposed solution, as it is entirely realized in user space, greatly facilitates this integration.

 An object of the invention is therefore a task scheduling method with deadlines constraints, based on a model of independent periodic tasks and realized in user space, in which:

 Each task to be scheduled is associated with a data structure, defined in user space and containing at least one temporal information (time and / or period) and information indicative of a state of activity of the task, said state of activity being selected from a list comprising at least:

 - a task state in execution;

- a task state waiting for the end of its execution period; and a task state ready to be executed, waiting for a recovery condition;

 During its execution, each task modifies said information indicative of its state of activity and, if necessary, according to a predefined scheduling policy, calls a scheduler that is executed in user space;

 • at each call, said scheduler:

 - establishes a queue of tasks that are ready for execution, waiting for a recovery condition;

 - sorts said queue according to a predefined priority criterion;

if necessary, preempts a task in execution by sending a signal forcing it to pass into said task state ready to be executed, waiting for a resume condition; and

 - sends said resume condition at least to the task at the head of said queue

 According to various embodiments of the method of the invention:

 Said scheduling policy may be a pre-emptive policy, for example chosen from a policy of the EDF type and its derivatives such as DSF ("Deterministic Stretch to Fit", that is to say "extension and deterministic adjustment of the frequency" ) and AsDPM ("Assertive Dynamic Power Management"), RM ("Rate Monotonic" or "Monotonic Rate Scheduling"), DM {"Deadiine Monotonic" or "Scheduling in maturity function "), LLF (" Least Laxity First "or scheduling based on the lowest laxity).

The method can be implemented in a multiprocessor platform, said data structure also comprising information relating to a processor to which the corresponding task is assigned, and wherein said scheduler assigns to a system processor each task ready to be executed. Said scheduler can change the clock frequency and the supply voltage of the or at least one processor according to a DVFS policy.

 The method may include an initialization step, during which:

 the tasks to be scheduled are created, allocated to the same processor and placed in a waiting state of a recovery condition, a global variable called an appointment being incremented or decremented during the creation of each said task;

 when said appointment variable takes a predefined value indicating that all the tasks have been created, said scheduler is executed for the first time.

 Said data structure may also contain information indicative of a pthread associated with said task and its execution time in the worst case.

 The method can be run under an operating system compatible with a POSIX.Ic standard, which can in particular be a Linux system. In that case :

 At each call of the scheduler, a "pthread" is created to ensure its execution.

 The method may include using a MUTEX to perform a single instance of the scheduler at a time.

 Assigning a task to a processor can be done using the CPU Affinity API.

 Another object of the invention is a computer program product for implementing a scheduling method according to one of the preceding claims.

 Other features, details and advantages of the invention will be apparent from the description given with reference to the accompanying drawings given by way of example and which represent, respectively:

FIG. 1, the principle of implementing a scheduling method according to the invention in Linux user space; Figure 2, an example of a set of independent periodic tasks; and

 FIG. 3, a diagram of the states and transitions of the application tasks in a scheduling method according to the invention.

 The principle of realizing a user space scheduler according to one embodiment of the invention, based on a Linux operating system, is illustrated in FIG. An application is seen as a set of tasks to be scheduled 2. The scheduler 1 controls the execution of these tasks by means of three specific functions (reference 3): "prempt (Task)", "resume (Task)" and " run_on (Task, CPU) ". These functions - whose names are arbitrary and given only as a non-limiting example - allow the preemption of a task, the recovery of a task and the allocation of a task to a processor, respectively. They rely on the use of features provided by the Linux API (reference 5) to control tasks and processors from the user space.

 For its operation, the scheduler must have specific information that derives from the task model used. For a model of periodic and independent tasks, it is at least information relating to the expiry of each task, its period and its state of activity; other temporal information can also be provided: Worst Case Execution Time (WCET), later deadline (that is, current time plus due date) to avoid confusion with "late maturity", "maturity" is sometimes referred to as "absolute maturity"), etc. In the case of a multiprocessor platform, the scheduler also requires information indicative of the processor to which the task is assigned. In addition, each task is associated with a POSIX thread {"pthread"), which must also be known to the scheduler.

 Other information that may be needed by the scheduler is: a UTEX associated with the task, a condition associated with the task, a Linux identifier of the task.

The best execution time (BCET) case and the actual execution time (AET, from "Actual Execution Time") are information that, although not essential for scheduling, are very useful for debugging because they allow (in particular ΓΑΕΤ) to set the execution time of a task (The execution time of a task normally varies from one execution to another). This makes it easier to check scheduling by comparing it to simulation results (with tasks having the same parameters and especially exactly the same execution times).

 In the POSIX Linux standard task structure (pthread) this information is not accessible in user space. For this reason, the implementation of the invention requires an extension of this task structure, by creating a custom type using a data structure.

 The application model consists of periodic and independent tasks. A periodic task model refers to the specification of homogeneous sets of jobs ("jobs") that are repeated at periodic intervals; a "work" is a particular form of task, and more precisely an independent task whose execution is strictly independent of the results of the other "works". A model of independent tasks refers to a set of tasks for which the execution of one task is not subordinate to the situation of another. This model supports synchronous and asynchronous execution of tasks, it is applicable in a large number of real applications that must respect temporal constraints. Knowledge of the temporal characteristics and constraints of the tasks (due date, period, worst execution time, etc.) is therefore necessary to apply this type of scheduling. As explained above, this information is added to a specific structure that extends the standard task type under Linux.

 Figure 2 illustrates an application model of periodic and independent tasks comprising four tasks T1 - T4. Tasks T1 and T2 must run before their deadline ("deadiine" DDLN) of 21 ms (milliseconds),

T3 before its maturity of 31 ms and T4 before its maturity of 40 ms. Each task executes in an effective time AET ("Actuai Execution Time"} f, which is between a minimum value BCET ("Best Case Execution Time") and a maximum value WCET ("Worst Case Execution Time"). At the end of its execution, a task goes on hold until it reaches its period when it becomes ready for rerun. For example, a task at any one time takes one of the following states:

 - a task state in execution;

 a task state waiting for the end of its execution period; and

 a task state ready for execution, waiting for a resume condition;

 to which one can add a state of non-existent task, before its activation.

 The example of Figure 2 refers in particular to a video application where each of the four tasks corresponds to a particular treatment of an image. These four tasks are therefore repeated every 40 ms (period) in order to process 25 frames per second.

One or more queues are used to store tasks. At least one queue is required for the execution of a scheduling with deadlines, to memorize the list of ready tasks. A priority is also assigned to each task to define their order of execution. The priority criterion depends on the scheduling policy. For the EDF (Earliest Deadline First) policy, for example, the priority criterion is the proximity of the deadline: the task with the most expiry date. near is the highest priority. The queue of ready tasks is generally sorted in descending order of priority. The priority criterion considered here is different from the priority criteria used in native Linux schedulers (timesharing). The scheduler is called at specific times, called scheduling instants, which are triggered by the tasks themselves at characteristic moments of their execution. These moments are called task events (reference 2 in figure 1), they correspond for example to their activation ("onActivate"), their end of execution ("onBlock"), their reactivation ("onUnBlock") or their termination ("onTerminate") - these names being arbitrary and given only by way of non-limiting example. The events are triggered, at the appropriate moments of the execution of an application task, by calls to functions "onActivate ()", "onBlock ()", "onUnBlock ()", "onTerminate ()", inserted in his code. Each task event updates the fields of the task structure for the task concerned (state, future due date, period, etc.) and calls the scheduler if necessary. The scheduler's non-scheduling call by a task event depends on the scheduling policy. For an EDF policy for example, the scheduler is called on the events "onActivate", "onBlock" and "onUnBlock".

 The event "onActivate" corresponds to the creation of a task. It marks the transition from "nonexistent" to "ready". For reasons of synchronization when creating tasks (explained in 15.), the onActivate event increments, at the end of its execution, an "appointment" variable, then puts the task on hold for a condition of activation of the scheduler, for example by calling the "pthread_cond_wait" function of the "Pthread Condition Variable" of the POSiX.lc standard.

 The onBlock event is triggered when a task completes its effective execution (AET). It then goes to the "waiting" state where elie waits until reaching its period. When it reaches its period, the task triggers the "onUnBlock" event, which makes it "ready", and then puts it on hold for a recovery condition, for example by calling the POSIX function pthread_cond_wait. This condition will be signaled by the scheduler by means of the function "pthread_cond_broadcast" which also belongs to the "Pthread Condition Variable" of the POSiX.lc standard.

 At any time during its execution, a task can be pre-empted by another task that has become more priority (in the case of an EDF algorithm, because its deadline has become closer to that of the task being executed). Preemption of a task changes it from "running" to "ready". Conversely, the task that resumes following a preemption goes from the "ready" state to the "in execution" state.

State transitions triggered by task events are shown in Figure 3. To avoid the phenomena of interbiocage, the scheduler is not called directly by the events of tasks but by means of a "pthread". In other words, the function that performs a task event (onActivate, onBlock, onUnBlock, onTerminate) calls another function "cail_scheduler" (name given by way of non-limiting example), which creates a "pthread" of scheduling to execute the scheduler.

 At each call, the scheduler performs, by means of a main function "select_" (name given as a non-limiting example) the following actions: establishment of a queue of ready tasks, sorting of the queue priority in decreasing order of priority (highest priority task at the beginning of the list), preemption of non-priority tasks in progress, allocation of eligible tasks to free processors and start of eligible tasks by sending a recovery condition . The determination of eligible tasks requires the scheduler to know the status of all existing tasks. The action list given here corresponds to an EDF scheduling, but can be modified - and in particular enriched - for the realization of other scheduling policies.

 Due to multithreaded and multiprocessor execution, multiple instances of the scheduler might be required to run at the same time. To prevent such a possibility, a Mutex (MUTual Exclusion Device) is used to protect certain shared variables such as the queue of ready tasks. The Mutex is locked at the beginning of the scheduler run, and released at the end of the scheduler call. This process ensures that only one instance of the scheduler executes at a time, allowing the shared variables to be changed without risk.

The first execution of the scheduler occurs just after the creation of the tasks. To ensure scheduler control of tasks, a synchronization must be performed to ensure that all tasks have finished being created before running the scheduler and that tasks do not start running until the job is completed. the scheduler did not give them the order. For this, first of all, a global variable of is initialized to 0 before creating jobs. Then all the tasks are created and placed on the first processor of the system. At the very beginning of their creation, in other words when the onActivate () event is executed, each task increments the "rendezvous" variable and immediately suspends its execution by waiting for a restart condition ( use of the POSIX function "pthread_cond_wait"). When the value of the variable "appointment" is equal to the number of tasks, the scheduler can be executed. During this execution, the scheduler resumes the execution of the eligible tasks by informing them of their recovery condition (function "pthread_cond_broadcast").

To control the execution of the application tasks, the scheduler requires the use of two specific functions for the suspension and the resumption of a task, called respectively "preempt (Task)" and "resume (Task)" in figure 1 (reference 3), these names being given solely by way of non-limiting example. The preempt function (Task) is based on the use of ΑΡΙ "Signa! Of the POSIX standard. To preempt a task, the signal S1GUSR1 is sent to the corresponding pthread (POSIX function "pthread_kill"). The associated signal handler ("sigusrl") puts the job on hold for a resume condition ("pthread _" cond_wait ") upon receipt of the signal. There is a recovery condition for each task in the application. The resume function (Task) reports the proper resume condition to the task in question to resume execution. It is therefore strictly equivalent to calling the Linux function pthread_cond_broadcast; in fact, the creation of a specific function is essentially justified for the sake of legibility of the code. This mechanism exploits the fact that in practice, the signal handler SIGUSR1 is executed by the Linux "pthread" which receives the signal. Thus, the signai manager can identify the "pthread" to suspend (necessary to send the waiting condition to the "pthread" concerned by the function pthread_cond_wait) by comparing for example its own process identifier (tid) with that of all "Pthreads" of the application. It is important to note that the scheduler does not use the preemption and job recovery mechanisms provided by the kernel because they are not accessible in user space. To control the execution of application tasks in a multiprocessor platform, the scheduler requires an explicit function to fix the execution of a task on a given processor. Although there is an API for controlling Linux "pthreads" by the CPUs of a CPU Affinity, there is no specific function for allocating a task to a processor. The realization of this function (indicated by "run_on" in FIG. 1, reference 3, this name being given as a non-limiting example) assigns the "CPU" processor to the execution of the "Task" task in its entirety. pressing ΓΑΡΙ Linux "CPU affinity". This is based on the specification of the CPU processor (only) in the affinity mask of the Task task, this affinity mask is then assigned to the task (by the function pthread_setaffinity_np of the APi "CPU affinity"). Then, to guarantee that the scheduler never executes more than one task per processor, all other application tasks are prevented from using the processor CPU. It is also verified that a task is never assigned to more than one task. a single processor.

A specific function "change_freq" (name given only as a non-limiting example) is used in the case of a scheduler using DVFS techniques to control the dynamic change of voltage / frequency of the processors (Figure 1, reference 3). This function uses a Linux APi called "CPUFreq" which allows to change the frequency of each processor via the virtual file system "sysfs". For example, simply write the desired frequency to a file - the file "/ sys / devices / system / cpu / cpuO / cpufreq / scaling_setspeed" on Linux - to change the frequency of processor 0. The scheduler can use the function change_freq to allow the modification of the frequency by writing back to the file system. It also requires the prior use of the "Userspace" governor which is the only DVFS mode under Linux that allows a user or an application to change the processor frequency at will. "Userspace" is one of the five DVFS Unix governors and its name indicates that the frequency (and therefore the voltage) can be modified at will by the user. A possible low-power scheduling technique is to exploit the dynamic "siack" (time provided by a task after execution) to adjust the frequency and operating voltage of the processor (s) (DVFS) to save power while offering time guarantees. For example, the scheduler of the invention has been applied to the realization of a "DSF"("Deterministic Stretch ~ to-Fit" type scheduling, in which the frequency of the processors (and therefore the voltage, which depends on it) ) is recalculated at each scheduling event, using Actual Execution Time (AET) for completed tasks and Worst Execution Time (WCET) for others. , to allocate the beat time of the previous task to the next task, which reduces the operating frequency of the processor concerned.

 The appendix contains the source code, written in C language, of a computer program for implementing a scheduling method according to the invention, using the DSF-DVFS technique described above. This code is given only by way of non-limiting example.

 The code consists of a plurality of files contained in two directories: DSF_Scheduler and pm_drivers.

 The DSF_Scheduler directory contains the core of the DSF scheduler code. It includes, in particular, the N_scheduler prototype file, h which contains the definition of the necessary types (task structure, processor structure, etc.), the global variables (task list, processor list, scheduler parameters, etc.), and your prototypes of the exported functions.

The DSF_Scheduler.c file then describes the main functions of the scheduler. The most important is the select_ function, which describes the entire scheduling process performed at each scheduling time. OnActivate, onBlock, onUnBlock, and onTerminate task events that trigger scheduling times are also described in this file. The scheduling function relies on a slow_down function that calculates and applies the frequency change. Finally, the particularities of the scheduler at the start of the application required the development of a specific function start_sched. This one does not run only once at the very beginning of the launch of the application and is largely based on the code of the main scheduler (select_). For all other scheduling times, the select_ function is called via the call_scheduter function. The Makefile file is used for compilation,

 The application to schedule is described in the file

N_application.c. It is also the file containing the "hand" of the program. This one carries out the necessary initializations, creates the POSIX tasks, launches the scheduler and synchronizes the whole thing. It should be noted here that an application is viewed as a set of tasks, each with temporal characteristics such as the worst case run time (WCET), period, deadlines, and so on. The tasks used perform a simple processing (multiplication of the elements of an array of integers) until a certain execution time (AET) - which is described by the function usertask_actualexec - then go into standby mode until 'to their reactivation (usertask_sieepexec) when they reach their period.

 Finally, to keep the code structure as clear as possible by keeping only the essential functions of the scheduler in the file N_Schedu! Er.c, the necessary secondary functions have been grouped together in another in a file: N_utiis.c. This contains for example functions of initialization, preemption of tasks, allocation of tasks to the processors, sorting, display, etc.

 The pmjdrivers directory contains the lowest level functions on which the scheduler relies. More specifically, these are the prototype files inte__ core 5_m520.h, pm_typedef.h and the file pm_cpufreq.c.

 The prototype file intel_core_i5_m520.h contains the description of the target platform whose name it bears. This is information about the number of processors in the platform and the possible frequencies for each of the cores, represented as states. The types used (e.g. the processor states) are defined in the file pm_typedef.h,

The pm_cpufreq.c file contains in particular the functions allowing the effective dynamic frequency change on the runtime platform, relying on Linux CPUfreq, The dynamic change of frequency voltage is managed by policies called governors (governors) under Linux, known in themselves. More precisely, to be able to change the frequency (s) processor (s), one must first use a governor said userspace. A first function set_governor is present for this. Then, the interaction with the Linux frequency change driver is done via exchange files located in / sys / devices / system / cpu / cpuX / cpufreq / where X represents the number of the concerned processor. The open_cpufreq and close_cpufreq functions allow you to open and close the scaling_set $ peed interchange file. The change of frequency is done by the function CPU_state_manager_apply_state.

 The various functions use the following POSIX APIs:

^■ Pthreads API:

 • pthread_creaie, for the creation of a Pthread,

• pthread Join, to synchronize the termination of Pthreads,

 • pthread_exit, at the end of the execution of a Pthread,

• pthread_cancel, to force the termination of a Pthread.

 - Signal API:

 • pthread_kill

 Variables API

 • pthread_cond_wait

 • pthread cond broadcast

 "Mutex API

 • pthread mutexjock

 • pthread_mutex_unlock

 The different functions also use the following non-POSIX APis:

^" CPU Affinity API":

 • CPU ZERO to empty the list of processors allocated to a task,

• CPU_SET to add a processor to the list of allocated processors, • CPU_CLR to remove a processor from the list of allocated CPUs,

 * CPU_ISSET to test if a task is assigned to a given processor and

 · Pthread_setaffinity_np to set the affinity mask to a task.

^■ CPUfreq API for dynamic voltage-frequency change.

 The invention has been described in detail with reference to a particular embodiment: multiprocessor system under Linux, EDF scheduling policy with dynamic voltage-frequency change (DVFS). These are not, however, essential limitations.

 Thus, the scheduling method of the invention can be applied to a single-processor platform and / or not implement mechanisms for reducing consumption.

 The implementation of the invention is particularly easy under LINUX because the APIs described above are available. However, a scheduler according to the invention can be implemented under another operating system compatible with the POSIX standard and more specifically with the IEEE POSIX 1c standard (or, which is equivalent, POSIX 1003.1c), provided that it supports an equivalent of APis CPU Affinity (for multiprocessor applications) and CPUfreq (for applications using dynamic frequency voltage change).

 Other scheduling policies with deadline constraints can be implemented, such as "Rate Monotonicity" (monotonic rate scheduling, RM), "Deadline Monotonic" (scheduling according to the maturity of the processes). , DM) or "Latest Laxity First" (LLF).

Similarly, various techniques for reducing consumption can be implemented. As non-limiting examples, DSF ("Deterministic Stretch ~ to ~ Fit", that is "deterministic extension and adjustment of frequency"), exploiting the dynamic change of frequency voltage (this is the technique used in the example just described) and AsDPM ("Assertive Dynamic Power Management" ie "assertive policy dynamic management of rest modes") exploiting processor idle modes.

 It should be noted that the reproduction of a task scheduler under user space deadlines constraints as described above is only feasible under certain conditions that depend on the operating system (called OS for Operating System). System). These conditions are for example the following. The method according to the invention must support the notion of preemptive scheduling in user space. The explicit preemption of a task from user space is a feature that is not feasible in all OSs. The task template must include maturity and state constraint attributes. The ability to extend the task template with these attributes, accessible in user mode, depends on the OS.

 It should also be noted that the realization of low consumption consumption oriented scheduling policies in user space is only feasible under certain conditions that depend on the OS. The ability to sleep or dynamically change frequency of a processor in user space is not feasible in all operating systems, especially Windows.

 It should also be noted that the method according to the invention does not require any explicit intervention of the supervisor mode and is based exclusively on user mode mechanisms in the form of APis.

The standard POS! X Linux (pthread) task structure, described in the particular embodiment of Figure 1, can be generalized to a standard POSIX (thread) task structure under an OS that enables it to be realized. The implementation of the invention for this generalized task structure requires, like the POSIX Linux standard task structure (pthread) of Figure 1, their extension by parameters accessible in user space. Similarly, like the application model described for Figure 1, the information concerning the temporal characteristics and constraints of the tasks are added in a specific structure that extends the type of POSIX standard task by parameters made accessible in user space.

It should be noted that the method of preemption of POSIX tasks in user space implemented in the invention does not exist in so-called "general public" OS, that is to say devoid of real-time constraints. According to the invention and in general, to control the execution of the application tasks, the scheduler requires an explicit preemption function for POSIX tasks in user space, which is based on the use of two specific functions for the suspension. and the resumption of a task.

APPENDIX: SOURCE CODE

1. DSF_Scheduler

N scheduler.h

#ifndef N_SCHEDULER

#define N _^ SCHEDULER

#include <stdbool.h>

#include <unistd.h>

#snclude <sys / types.h>

#include <sys / time.h>

#inciude <pthread.h>

#include <semaphore.h> // MAXIMUM PRIORITY FOR SCHED_FIFO POLICY

 // USED TO GIVE MAXIMUM PRIORITY TO THE ORDERER

#define MAX_PR! 0 99

// NUMBER OF TASKS OF THE APPLICATION

#define NU _THREADS 4

// NUMBER OF PROCESSORS USED BY THE ORDERER

 // (MAY BE LESS THAN OR EQUAL TO THE NUMBER OF TOTAL PROCESSOR AVAILABLE) #define CPU size 2

// DEFINITION OF THE TYPE LISTED STATE_T: STATUS OF A TASK

 enum state_t {unexisting, running, waiting, ready};

// unexisting = nonexistent; running = in execution; waiting = waiting; ready = ready // TYPE TASK DEFINITION (PTHREAD TYPE EXTENSION)

 typedef struct task

 {

 short id; // job ID used only for ftoat wcet debugging; // worst case execution time

 fioat bcet; // execution time at the best case

 fioat aet; // effective execution time (wcet <aet <bcet) fioat ret; // RET: execution time, remaining

fioat deadline; // absolute deadline float next_deadiine; // relative (deadiine)

unsigned int cpu; // processor running this task

float period; // task period = deadline

float nexLperiod; // relative period

double begintime; // start time of work

double endtime; // end of work time

int preemption; // 1: preempted; 0: not preempted.

double preempidelay; // duration of the last preemption

double last_preemp _time; // time the last double preemption total_preempt_duration occurred; // total pre-emption time if the job is pre-empted

// many times - can be calculated from preemptdelay // and last_preempt _" time

enum statej state; // task status: waiting, ready, running, unexisting pthread_mutex_t mut_wait; // Mutex used to suspend and resume a task pthread_cond_t cond_resume; / Variable condition used to suspend and resume

 // a spot

pthread__t * pthread; // posix thread associated with a task

pid J thread_pid; // linux id {process ID, or pid) of the associated posix thread

 // to the job

 } Task;

// DEFINITION OF TYPE LISTED STATE_P: STATUS OF A PROCESSOR

enum state_p {RUNNING, STAND_BY, IDLE, SLEEP, DEEP_SLEEP};

// DEFINITION OF CPU TYPE (current state, CPU number)

typedef struct cpu

 {

 enum state__p state;

 int cpu Jd;

Cpu};

// DECLARATION OF GLOBAL VARIABLES OF THE ORDERER

// LIST OF PROCESSORS USED FOR LORDONNANCMENT

cpu CPUs [CPU_size];

 // LIST OF APPLICATION TASKS TO BE ORDERED

task * T [NUM_THREADS];

// LIST OF TASKS READY

task * list_ready [NUM_THREADS];

int list_ready_size; // LIST OF UNLATCHED TASKS

task * lisi_noready [NU _THREADS];

int list_noready_size;

struct timevai start_time, current_time;

 int rdv; // to synchronize threads to their creation

OTE bool;

// PARAMETERS FOR CALCULATING THE SLOW DOWN FACTOR IN THE // SLOW DOWN FUNCTION

float wcei_Fn_1 [NUM_THREADS]; // WCET before calculating a new float frequency aet_Fn_1 [NUM_THREADS]; // AET before calculating a new float frequency abs_eet [NUM_THREADSJ; // execution time (absolute) of the task since

 // the moment of activation

float total_eet [N U M__TH READS]; // total elapsed time of task execution

 // (considered at Fmax) since the activation of the task {required // in case of preemption)

float total_abs_eet [NU _THREADSÎ; J; // total time (absolute) elapsed execution

 // the task since its activation

double task_durationJNU _THREADS]; // duration (absolute) of the task since the moment

 // activation

float last__resume_time [NUM_THREADS]; // Last time the task was resumed (at the

 // following a preemption). This time is reset at each task period

float siackJocal [CPU _" size]; // "slack": remaining time due to the fact that the task

 // previous is finished before WCET float t_available_Fn_1 [CPU_size]; // slack before calculating a new float frequency estimated_WCET_Fn_1 [CPU_size]; // WCET estimated considering the previous slack and

 // before calculating a new float frequency estimated_AET_Fn_1 [CPU_sizej; // AET estimated considering the previous slack and

 // before calculating a new float frequency SRJocal [CPU_size]; // local slowdown factor (relative to the

 // previous frequency)

float SRJotal [CPU_size]; // Total deceleration factor (relative to the

 // maximum frequency)

 double Fn_1; // previous frequency

double Fn; // current frequency

float offset_delaylNUM_THREADSI; // Additional time to consider for

 // the execution of the task, due to the possibility of offset // (given a task which normally starts at T0, the offset starts the // task at T0 + offset).

exec | NUM_THREADSJ; // PARAMETERS FOR TIME MANAGEMENT

 double schedjsme;

 double begin__sched_time;

 double end_sched_time;

 double sched_duration [150];

 short nb_sched_call;

 double simulation;

// UTEX TO PREVENT THE PARALLEL EXECUTION OF 2 INSTANCES THE ORDERER

 pthread_mutex_t sched_mut_write;

 pthread_co nd_t sched_con d_res urne;

// VARIABLES TO CALCULATE THE NUMBER OF PROCESSOR STATE TRANSITIONS int STAND_BY_to_RUNNING;

 int DEEP_SLEEP_to_RUNNING;

 int SLEEP_to_RUNNiNG;

 int! DLE_to_RUNNING;

 int Preemption_counter;

// PROTOTYPES OF EXPORTED FUNCTIONS

 void start_sched {);

 void slow_down (task * T, cpu * P); void o n Activa te (heap k * T);

 void onUnBiock (task * T);

 void onBlock {task * T);

 void onTerminateftask * T);

#endif

DSF__Scheduler, c

#define _GNU_SOURCE ffinclude <stdlib.h> # inc1ude <sidio.h>

#include <signal.h>

#include <sîring.h>

#tnclude <math.h>

#include <sched.h>

 #include <semaphore.h>

#include <sys / syscall.h> #include "N_utils.h"

 #include "../p m_dn to / i n te l_co re j 5_m 520, h"

// # define DEBUG

// THE PRINCIPAL FUNCTION OF THE ORDERER, CALLED FROM "CALL _^ SCHEDULER" // THE HEART OF THE TREATMENT OF THE ORDERER IS IN THIS FUNCTION void * select_ () {

 int i, j, rc;

 double r__nxt;

schedjime = get_time ();

OTE == false;

// DEFINITION OF THE LIST OF TASKS READY (LIST_READY)

 // DEFINITION OF THE LIST OF NON-READY TASKS (LiST_NO_READY) iist_ready_size = 0;

 Hst_noready_size - 0;

 for (i = 0; i <NUM_THREADS; {

 if ((T [i] -> state => ready) H {T [i] -> state ~ running)) {

 list__ready [list_ready_size] - T [i];

 list_ready_size ++;

 }

 else {

list _" noready [iist_noready__sizeJ = Tji];

 list_noready_size ++;

 }

> // SORTING THE TASKS LISTS BY GROWING ORDER (NEAREST FIRST FIRST)

 so rt (I i st_re ad y, I i sf_ready_s ize);

 sort (list_noready, list_noready_size);

printf ("\ n ^* * ^******* **** Sched ροίη¾:%. 4Γ ^* * ^** ******** ^** \ η", 8θΙΐΘά_ίίΓηβ);

 // DEBUG MESSAGES WHICH DISPLAYS THE LIST OF TASKS READY

 prin f ("Sor ed eady List: \");

 Display_list (list_ready, list_ready_size);

// DEBUG MESSAGES WHICH DISPLAYS THE LIST OF UNLEATED TASKS

 #ifdef DEBUG

 printf ("Sorted No_Ready ListAt");

 DisplayJist (list_noready, list_noready_size);

 #endif

// PREEMPTION OF NON-PRIORITY TASKS OF THE LIST OF TASKS READY AND IN // COURSE OF EXECUTION

 for (i = CPU_size; i <list_ready_size; {

 task * job = list_readyEi];

 if (job-> state == running) {

 abs_eet [job-> id-1j = schedjime - iast_resume_time [job-> id-1]; total_abs_eet | job-> id-1] = total_abs_eetrjob-> id-1] + abs_eet [job -> (d-1];

 total_eet [job-> id-1] = total_eetjjob-> id-1] + (abs_eet [job-> id-1] / SRjotalfjob-

> Cpu]);

 if {! {sched_time <job-> begintime + job-> offset))

 T_preempt (job);

 }

 }

// UPDATE OF THE "RET" OF EACH TASK (REMAINING EXECUTION TIME)

 for (i = 0; i <NUM_THREADS; i ++) {

 task * job = T [i];

 if Gob-> preemption == 1) {

 job-> preemptdelay = sched_time - job-> last__preempt_time;

 job-> totai_j) reempt_duration ~ job-> total_preempt_duraiion + job-> preem tdelay;

 }

if (job-> state == running) job-> rei = job-> aet - total__eet [job->id-1];

 else if {job-> state == ready) {

 if (job-> preemption == 1)

 job-> ret = G ° b-> aet - totai_eet [job-> id-1]);

 else

 job-> ret = job-> aet;

 }

 else if (job-> state == waiting)

 job-> ret = 0.0;

 }

// The following mutex avoids running multiple instances of the scheduler

 // simultaneously, which would lead to competing and conflicting access to certain variables

// shared

 pthread_mutex_lock {& sched jnut_wait);

 // ALLOCATION OF TASKS READY TO FREE PROCESSORS

 for (i = 0; (i <CPU_size) && (i <list_ready_size); i ++) {

 task *] ob = list_ready [i];

 if (job-> state! = running) {

 cpu * P = NULL;

 for (j = 0; j <CPU_size; j ++) {

 P = & CPUs [jJ;

 if (PjsRunning (P-> cpuJd) == 0) {

if (P-> state == DEEP_SLEEP) DEEP _^ SLEEPJo_ _" RUNNING ++;

 if (P-> state == IDLE)! DLE_to_RUNNING ++;

 if (P-> staie == STAND_BY) STAND_BY to RUNNING ++;

 if (P-> state == SLEEP) SLEEPJoJ¾UNNING ++;

 // CALCULATION OF SLOW DOWN (MINIMUM FREQUENCY) OF PROCESSOR ALLOCATED

 if (nb_exec [P-> cpujd]! = 0) {

 siow_down (job, P);

 OTE = peak;

 >

 and this

 {

 SR_local [P-> cpu_id] = 1 .0;

 SR_total [P-> cpu_id3 - 1 .0;

 }

 pthread_mutex_lock (& job-> mut_wait); // without this, mutex,

// sometimes a job would be started again before being assigned to a processor.

T_runningOn (job, P->cpu_id); pthread_mutex_unlock (&job->mut_wait);

 #ifdef DËBUG

 printf {'T% d is assigned to CPU% d \ n', job ~> id, P-> cpu_id);

 #endif

 if (job-> preemption == 1) {

 job-> preemption = 0;

 iast__resume_time [job-> id-1] - sched_time;

 }

 eise if {job-> preemption == 0) {

 job-> begintime = sched_time;

 job-> last_preempt_time = job-> begintime;

 last_resume_time [job-> id-1] = job-> begintime;

 }

 // START THE TASK READY ON THE PROCESSOR ALLOWED pthread_mutexJock (¾ob-> mut_wait);

 pthread_cond_broadcast (& job-> cond_resume);

 pthread_mutex_unlock (& job-> mut_wait);

 break;

 }

 }

 }

 }

pthread_m utex_u n lock (& sched_m u t_wa it); int nb = 0;

 // DEBUG MESSAGES QU! POST STATE FOR EACH PROCESSOR (ACTIVITY // AND / OR ALLOCATED TASK)

#ifdef DEBUG

printf ("StaieAn Processors");

#endif

for 0 = 0; i <CPU_size; i ++) {

 cpu * P = & CPUs [i];

 #ifdef DEBUG

 printf ("CPU% d ->", P-> cpujd);

 if (P-> state == RUNNING) {

 printf {"RUNN! NG");

 for (j = 0; j <NU _THREADS; j ++)

 if ((T [j] -> state == running) && (T] -> cpu == P-> cpujd)) printf ("T% d", T [j] -> id); printf ( "\ n");

} if (P-> state STAND _" BY) phntffSTAND BY \ n");

 eise if (P-> state IDLE) printf ("IDLE \ n");

 eise if (P-> state SLEEP) prinif ("SLEEP \ n");

 else if (P-> sta † e DEEPJ3LEEP) printf ("DEEP SLEEPVn");

 else prinîf ("UNDEFINED \ n");

 #endif

 if (PjsRunning (P-> cpu_id) == 1) {

 nb ++;

 }

 else {

 slackJocai [P-> cpu_id] = 0;

 #ifdef DEBUG

 prinif ("-> slack_local [CPU% d] = 0 \ n", P-> cpu_id);

 #endif

 }

 }

 #ifdef DEBUG

 printf ("Total Preemptions =% d \ n" reemption_counter);

 #endif

 >

// APPEAL FUNCTION OF THE ORDEROR

 // CREATE A THREAD WITH THE PREVIOUS SELECT_ FUNCTION

void call_scheduler {) {

 int i, rc;

 pid__t pid;

 pthread__t schedjhread;

 begin__sched_time = get_time ();

 / * Creation of the pthread of the scheduler * /

if (pthread_create {& schedjhread, NULL, seiect _" ," 4 ") <0) {

 printf ("pihread_create: error setting sched thread \ n");

 exit {1);

 }

 end__sched_time = get_time ();

 // TIME OF EXECUTION OF THE ORDERER IS MEASURE FOR TIME ANALYSIS

 // ANSWER

 sched_duration [nb_sched_call ++ J = end_sched_time - begin__sched_time;

ffifdef DEBUG printffSCHEDULATE DURATION #% d% f \ n ", nb_sched_call, sched ___ duration [nb_sched__ca! i - 1]);

 #endif

 }

// THE FOLLOWING FUNCTIONS CORRESPOND TO THE EVENTS OF TASKS:

// - ONACTIVATE

// - ONBLOCK

// - ONUNBLOCK

// - ONTERMINATE

// ONACTIVATE

 // THIS EVENT INTERVENES WITH THE CREATION OF A TASK

void onActivate (task * task) {

 double randomvalue;

 schedjime = 0 .;

 task-> next__period = schedjime + task-> period;

 task-> next_deadline = task-> deadline;

 // THE TIME OF EXECUTION (AET) IS TIRE AT RANDOM BETWEEN BCET AND WCET

 randomvalue = {doub! e) rand () / RAND_MAX;

 task-> aet = (randomvalue * (task-> wcei-task-> bcet) + task-> bcet);

 // INITIALIZATION OF ALL VARIABLES NECESSARY TO THE ORDERER

// (DECLARED / DETAILED IN N_SCHEDULER, H)

 aet_Fn_1 [task-> id-1] ~ task-> aet;

 abs_eet [task-> id-1] = 0 .;

 task-> ret ~ task-> aet;

 task-> preemptde! ay = 0 .;

 task-> state = ready;

 printf ("T% d \ t% .4ftt \ t% .4f \ I% .4f \ t% .4f \ n", task-> id, task-> wcei, iask-> deadline, task-

> Period, task-> offset);

 // SYNCHRONIZATION BY APPOINTMENT: ONCE CREATED, THE INCREASED TASK RDV THEN // WAIT FOR THE ACTIVATION SIGNAL task-> cond_resume

 // THIS SIGNAL IS SENT WHEN ALL TASKS ARE CREATED (RDV = // NB_THREADS)

 appointment ++;

 pthread_∞nd_wait (& task-> cond_resume, & task-> mut_wait); task-> begintime = sched_time;

 task-> last_preempt_time = task-> begintime;

last_resume_time [task-> id-1] = task->begintime; }

// ONBLOCK

 // THIS EVENT INTERVENES AT THE END OF THE EXECUTION OF A TASK

void onBlock (task * task) {sched_time = get_time ();

 task-> endtime = sched_time; task-> state = waiting;

 slack_local [task-> cpu] - task-> wcet - task-> aeî;

 #ifdef DEBUG

 printf ("T% d is terminated at iime =% .4f and generated slackJoca! [CPU% d] =% .4f \ n", task-> id, task-> endiime, task-> cpu, slack_locai [iask- > cpu]);

 #endif

 CPUs [iask-> cpu] .state = IDLE;

 task-> cpu ~ -1;

 #ifdef DEBUG

 printf ("T% d FINISHES EXECUTION AT% .2ftn ^ iask-> id, schedjime);

 #endif

// SCHEDULSNG POINT: CALL FOR THE ORDERER

 ! Ca l_scheduier {); }

// ONUNBLOC

 // THIS EVENT INTERVENES AT THE END OF THE PERIOD OF A TASK (REACTIVATION) void onUnBlock (task * task) {

 double randomvalue; sched_time = get_time ();

// TIME OF EXECUTION (AET) IS RUNNING BETWEEN BCET AND WCET randomvalue = (double) rand () / RAND_MAX;

 task-> aet = (randomvalue * {task-> wcet-task-> bcet) + task-> bcet);

// RESET ALL VARIABLES NECESSARY TO THE ORDERER // (DECLARED / DETAILED IN N_SCHEDULER.H)

aet_FnJ [task-> id-1] = task->aet; wcet_Fn_1 [task-> id-1] = task->wcet; abs__eet [task-> id-1] = 0 ,;

 total__eet [task-> id-1] = 0 .;

 total_abs_eet [task-> id-1] = 0 .;

 task-> preemptdelay = 0 .;

 task-> state = ready;

 task-> next_deadline = task-> next__persod + task-> deadline;

 task-> next_period = task-> nexi_period + task-> period; task-> preemptdelay - 0 .;

 task-> total_preempt_duration = 0 .;

 #ifdef DEBUG

 printf ("T% d REACHES PERIOD AT% .2f \ n", task-> id, sched_time);

 #endif

// SCHEDULING POINT: CALL FOR THE ORDERER

 call_scheduler ();

 // THE TASK IS STOPPED, IT WILL BE REIMBURSED BY THE ORDERER AT THE MOMENT // OPPORTUN

 pthreadjtill {* {task-> pthread), SIGUSR1);

// ONTERMINATE

// THIS EVENT INTERVENES AT THE TERMINATION OF A TASK (END OF LAST // EXECUTION)

void onTerminate (task * task) {

 int i;

 sched_time = get_time ();

 heap k-> state = a n ex ist in g;

 #ifdef DEBUG

 printf ("T% d IS TERMINATED AT% .4f and generated at slack_local [CPU% d] =% .4f n", task-> id, sched_time, task-> cpu, slackJocal [task-> cpu]);

 #endif

// THIS STAGE SIMULATION IS COMPLETE. ON FORCE THE STOP OF ALL // TASKS

 for (i = 0; i <NU _THREADS; i ++)

 pthread_cancel (* (T [i] -> pthread));

} // THE FIRST APPEAL TO THE ORDERER IS PARTICULAR BY CREATING AND // INITIALIZING TASKS

// THIS SPECIFIC TREATMENT IS GIVEN TO THE START_SCHED FUNCTION, CORRESPONDING // TO THE FIRST CALL OF THE ORDERER

void start_sched () {

 int i, j, err, rc;

pid_t pid; printff \ n ^******* ** ^** ** Sched point:%. 4f ^** ****** ^******* \ n ", sched_iime); gettimeofday (& start_time, NULL) // ALL TASKS ARE AFFECTED AT THE CPUO

 cpu_set_t mask;

 for (j = 0; j <NUM_THREADS; j ++) {

 CPU_ZERO (&mask);

 CPU_SET (0, &mask);

/ ^* PREVENT TASK TO USE OTHER CPUs 7

 // PREVENT CURRENT TASK FROM EXECUTING THE PROCESSORS

OTHER

 // THAT CPUO

 for (i-1; i <CPU_size;

 CPU _CLR (i, &mask);

 err = pthread_setaffinity_np (* (T [j] -> pthread), sizeof {cpu__set_t), &mask);

 }

// DEFINITION OF LOSS OF TASKS READY {LSST_READY)

 iist_ready_size - 0;

 for {i = 0; i <NUM_THREADS; {

 lisi_ready [i] = T [i];

 lisi_ready_size ++;

 }

// SORT OF READY_ LIST BY NEAREST ORDER OF EASE (lisi_ready, list_ready_size);

 #ifdef DEBUG

 printf ("Sorted Ready ListAt");

Displayjist (lisi__ready, lisi_ready_size); #endsf

// ALLOCATION OF TASKS READY TO FREE PROCESSORS

 for (i = 0; {i <CPU_size) && (i <listjready_size); i ++) {

 task * job = list_ready {i];

 T_runningOn (job, i);

 job-> begintime = sched_time;

 ] ob-> last_preempt__time = job-> begintime;

lastj ^* esumeJirne [job-> id-1] = job->begintime;

// STARTING TASKS READY ON PROCESSORS ALLOWED

 for (i = 0; (i <list_ready_size) && (i <CPU_size); i ++) {

 ! Pthread_mutex_ ock (& list_ready [i] -> mut_wait);

 pthread_cond_broadcast (& ist_ready [i] -> cond_resume!);

 pihread_mutex_unlock {& list_ready [i] -> mut_waii);

 }

}

// THIS FUNCTION IS CALLED BY THE ORDERER TO CALCULATE THE

// FREQUENCY CHANGE FROM SLOW DOWN FACTOR

// FOR A TASK ALLOCATED ON A PROCESSOR, CALCULATE THE FREQUENCY TO WHICH

 // THE TASK CAN BE EXECUTED, AND THE PROCESSOR FREQUENCY CHANGES TO THIS VALUE

void slow_down {task * job, cpu * P) {

 int i;

 int procjd = P-> cpu_id;

 char * setspeed__cpu_filename;

 FILE * setspeed_cpu;

// RECOVER THE CURRENT FREQUENCY OF THE CONCERNED CPU

 Fn = {double) CPU_state_manager_query_current_freq {procjd);

 #ifdef DEBUG

 printff'Frequency Adjusfment on CPU% d before executing T% d: \ n ", proc_id, job-> id);

 #endif

 // CALCULATION OF DECELERATION FACTOR (SRjotal and SRJocal)

 estimated_WCET_FnJ [procjd] = wcet_Fn_1 [job-> id-1] * SR_totalIproc_id];

estimated_AET_Fn_1 [procjd] = aet_Fn_1 [job-> id-1] * S _total [proc_id]; #ifdef DEBUG

printf ( '' slack_local [CPU% d] \ t ^{* *} \ t \ t \ t \ t \ t \ i \ t * ⁱ * \ t \ t \ t =% .4f \ n ", proc jd, siack_local [proc_id]); prinif ( "SRJocal [CPU% d] \ t \ t ^** * \ t \ t \ t \ t \ t \ t \ t ^*** \ t \ t \ t =% n .4f" , proc_id, SR_local [proc_id]);

printf ( "SRJotal [CPU% d] \ t \ i ^*** \ t \ t \ t \ i \ t \ t \ i ^*** \ t \ t \ t =% .4f \ n", proc jd, SRJotal [proc_id]);

printf ("esiimated_WCET_Fn_1 [CPU% d] = WCET [T% d] ^* SR_total [CPU% d] \ t \ t \ t \ t =

% .4f "%. 4f \ t \ t =% .4f \ n",

 proc_id, job-> id, proc_id, wcet_Fn_1 rjob-> id-1], SRJotaifprocjd], estimated__WCET_Fn_1 [procjd]);

printf ("estimated_AET_Fn_1 [CPU% dd = AET [T% d] ^* SRJoial [CPU% d] \ t \ t \ t \ t =% .4f *%. 4f \ t \ t =% .4f \ n",

 procjd, job-> id, procjd, aet_Fn_1 [job-> id-1], SR_totai [proc_id], estimated_AET_Fn_1 [proc_id]);

 #endif if {OTE ~ false) {

 t_available_Fn_1 [proc_id] = wcet_Fn_1 [job-> id-1] + slack_local [proc_id];

 #ifdef DEBUG

 printf ("t_available_Fn_1 [CPU% d] \ t = WCET [T% d] + stackJocal [CPU% d] \ t \ t \ t \ t =% .4f +%. 4f \ t =% .4f \ n",

 proc_id, job-> id, procjd, wcetJFn_1 [job-> id-1], slackjocalfprocjd], t_avaHable_FnJ [procjd]);

 #endif

 if (job-> preemption ~~ false) {

 SR_loca! [Proc_id] = (float) {t_availabie_Fn_1 [procjd] / estimated_WCET_Fn_1 [procjd]);

 #ifdef DEBUG

 printf ("NEW SR_local [CPU% d] \ t = t_available_Fn_1 [CPU% dJ / estimated_WCET_Fn_1 [CPU% d] \ i =% .4f /%. 4ftttt =% .4f \ n",

 procjd, proc_id, procjd, t_available_Fn_1 [proc_id], estimated_WCET_Fn J [procjd], SRJocal [proc_idj);

 #endif

 >

 else if (job-> preemption == true) {

 / * Update slack, SR, ret. CPU set to maximum frequency * / siackJocal [proc_id] = 0.0;

 SRJocal [proc_id] = 1.0;

 SR_totai [proc_id] = 1.0;

 Fn = (double) _CPU_STATE [proc_id] [0] .freq;

#ifdef DEBUG printfi "PREEMPTION BY T% d OCCURED AT TIME =%. 4f, slackjoca! = 0.0, SR_local = 1.0, SR_total = 1.0, Fn = maxfreq \ n", job-> id, sched_iirne);

 #endif

 }

 }

 if <SRJocal [procjd]> = 1.00) {

 #ifdef DEBUG

printffNEW WCET (T% d] \ t \ t = WCET_Fn_1 [T% d] * SRJocal [CPU% d] \ t \ t \ t \ t =% .4f ^* % .4ftt \ t = ",

 job-> id, job-> id, procjd, wceî_Fn_1 [job-> id-13, SRJocal [proc_id]); #endif

wceLFnJ [job ->! d-1] = (float) (wcel_Fn _^ 1 [job-> id-1] * SR_local (proc_id));

 #ifdef DEBUG

 printf ("%. 4f \ n", wcet_Fn_1 jjob-> id-1]);

 #endif

 #ifdef DEBUG

printf ("NEW AET [T% d] \ t \ t = AET_Fn _^ 1 [T% d] * SRJocal [CPU% d] \ t \ i \ t \ t =% .4f ^* % .4Mt = job-> id, job-> td, procjd, aet_Fn_1Dob-> id-1], SRJocal [procjd]);

 #endif

aet_Fn_1 [job-> id-1] = (double) (aet_Fn_1 [job-> id-1] ^* SRJocal [proc_id]);

 #ifdef DEBUG

 printf ("%. 4f n", aet_Fn_1 [job-> id-1]);

 #endif

 }

 else if (S RJocal [procjd] <1 .00) {

 #ifdef DEBUG

printffNEW WCET [T% d] \ t \ t = esi_WCET_Fn_1 [CPU% dfSRJocal [CPU% d] \ t \ t \ t =% .4f ^* % .4f \ t \ t = ",

 job-> id, procjd, procjd, estimated_WCET_Fn_1 [procjd], SR_iocai [procjd]); #endif

 wcet_Fn_1 [job-> id-1] - (estimated_WCET_Fn_1 [procjd] * SRJocal [procjd]);

 #ifdef DEBUG

 printf {"%. 4f \ n", wcet_Fn_1 [job-> id-1]);

 #endif

 #ifdef DEBUG

printf ("NEW AET [T% d] \ t \ i = is_AET_Fn_1 [CPU% d] * SR_local [CPU% d] \ t \ t \ t =% .4f ^* % .4f \ t \ t =",

 job-> id, procjd, procjd, estimated_AET_Fn_1 [procjd], SRJocal [proc_id]); #endif

aet_Fn_1 [job-> id-1J = (estimated__AET_Fn_1 [procjd] * SRJocalJprocJdj); #ifdef DEBUG

printf ("%. 4f \ n", aet_Fn_1 | j ^" ob-> id-1]):

 #endif

 }

/ ^* CALCULATION OF THE NEW "THEORETICAL" FREQUENCY

 double Fn_1 = (double) (Fn / SRJocal [proc_idJ);

// SEARCH FOR THE NEW EFFECTIVE FREQUENCY {THE PROCESSOR FREQUENCY // ARE PREDEFINED, THEREFORE DIFFERENT FROM THEORETICAL FREQUENCY)

 Elementary_state State;

State = __CPU_STATE [proc _" id] fO];

 for (i-0; i <NB_STATES_ CPU-1; i ++)

if ((int) Fn_K = _CPU "STATE [proc_id] [i] .freq) && ((int) Fn _m 1 <= _ CPU_STATE [proc_id] [i + 1] .freq))

 State = _CPU_STATE [proc_id] [i + 1 ï;

#ifdef DEBUG

 printf ("FREQUENCY TO SWiTCH (% .0f):% d \ t", Fn_1, (int) State.freq);

 #endif

 // CALL FOR FREQUENCY CHANGE FUNCTION

 CPU_state_manager apply_state {proc_id, &State);

 // THE SLOW DOWN FACTOR MUST BE RECALCULATED WITH EFFECTIVE CHANGE IN FREQUENCY PROCESSOR

 S RJocal [procjd] = Fn / State.freq;

 SRJotallproc jd] = SR_total [proc_id] * SR_local [procjd];

 #ifdef DEBUG

 printf ("NEW SRJocal [CPU% d] \ t = Fn / State.freq =% .0f /% d =% .4f n", proc jd, Fn, (int) State.freq, SRJocal [proc_idJ);

printf ("NEW SR_total [CPU% d] \ t = SR_total [CPU% d] ^* SRJocal [CPU% d] =% .4f \ n", procjd, procjd, procjd, SR_totai [proc_id]);

 #endif

// REMOVE THE SLACK TO ZERO BECAUSE YOU SAVE THE PREVIOUS SLACK TO // DECREASE FREQUENCY

slackjocalfprocj ^' d] = 0.0;

} N_utifs.c

 #define _GNU_SOURCE

#inciude <stdio.h>

#include <unistd.h>

#inciude <sys / time.h>

#include <signal.h>

#include <sched.h>

#include <time.h>

#include <errno.h>

#include <pthread.h>

#include "N_utils.h"

#define TARGET_CPU_DEFINED

#i ncl ude ".. / p m_d ri to / i ntel_coreJ5_m 520. h"

#define DEBUG

// INITIALIZATION FUNCTION OF PROCESSORS OF THE PLATFORM

void init_CPUs ()

 {

 printf ("\ nlntializing CPUs ... \ n");

 int i;

 // MAKE THE LIST OF PROCESSORS AVAILABLE AND UPDATE THE CPU STATES for (i = 0; i <CPU_size; ı ++) {

 CPUs [i] .cpu_id = i;

 CPUs [i] .state = IDLE;

 }

 printffSystem has% d processor (s) \ n ", NB_CPU_MAX);

 printf {"System uses% d processor (s) \ n", CPU_size);

 #ifdef DEBUG

 for (i = 0; i <CPU_size; {

 printf ("CPU% d is", CPUs [i] .cpu_id);

 if (CPUs [i] .state == RUNNING) printf ("RUNNING \ n");

 else if (CPUs [i] .store == STAND_BY) printf ("STAND BY \ n");

 else if (CPUsfsJ.state == IDLE) printf ("IDLE \ n");

 efse if (CPUs [i] .state == SLEEP) printf ("SLEEP \ n");

else if (CPUs [i] .state == DEEP _^ SLEEP) printf ("DEEP_SLEEP \ n");

else printf {"UNDEF! NED \ n"); #endif

// OPEN FILES FOR FREQUENCY CHANGE (CPUfreq API) printffSetting cpufreq \ n "); for (i = 0; i <CPU__size; {

 setjgovernor (CPUs [i] .cpu_id, "userspace");

 open_cpufreq (i);

 }

// START MAX FADE (SPECIFIC TO DSF ALGORITHM) printff'Setting CPUs to maximum frequency \ n ");

 for (i = 0; i <CPU_size; i ++)

 CPU_state_manager_apply__state {i, & _CPU_STATE [i] [0]); printf ("End CPUs initializationAn");

}

// FUNCTION OF RELEASE OF PLATFORM PROCESSORS

void exit_CPUs ()

 {

 int i;

 // CLOSURE FILES FOR FREQUENCY CHANGE (CPUfreq API) for {i = 0; i <CPU_size; i ++)

 close cpufreq (i);

 }

// FUNCTION OF INITIALIZATION OF APPLICATIVE TASKS

void init_TASKs (task_tool [NUM_THREADS], pthreadj thread [NUM_THREADS])

 {

 int i, rc;

 struct sched__param my_sched_params; printi ("\ ninitiaHzing tasks.,. \ n");

 printff'Application has% d task (s) \ n ", NUM_THREADS);

 // SAVING THE WCET FOR CURRENT FREQUENCY

for (i = 0; i <NUMJ ^" HREADS; i ++) wcet_Fn_1 [i] = task [i] .wcet;

// INITIALIZATION OF MUTEX, USED AS PREEMPTION MECHANISM pi h read_m utexj nit (& s ched_m ut_wait, ULL);

for (F0; i <NUM "THREADS;

 pthread__mutex_inii (& task [i], mut_wait, NULL);

 pt read_cond_init (& task [r] .cond_resume, NULL);

 }

 // INITIALIZING THE PARAMETERS OF TASKS

for (i = 0; i <NUM_THREADS; i ++)

 {

 T [i] = & task | i];

 T [i] -> pthread = & thread [i];

 nb_exec [i] = 0;

 tota [_eet [i] = 0.0;

 total_abs_eet [i] = 0.0;

 }

 // INITIALIZING THE ORDER PARAMETERS

for (i = 0; i <CPU_size; i ++)

 {

 s [ack_local [i] ~ 0.0;

 SRJocalfi] = 1.0;

 SR_total [i] = 1.0;

 Lavailable_Fn_1 [i] = 0.0;

 estimaied_WCET_Fn_1 [i] = 0.0;

 estimated_AET_Fn_1 [i] = 0.0;

 }

STAND_BY_to_RUNNING = 0;

 SLEEPjo_RUNNiNG = 0;

 DEEP_SLEEPJo_RUNNING = 0;

 IDLE_to_RUNN NG! = 0;

 Preemption_counter = 0; nb_sched_call = 0;

rdv = 0; printf ("End tasks irtitializationAn"); // FUNCTION TO PREPARE A TASK

void T_preempt (task * task)

 {

 int i, rc;

struct sched__param my _m sched_params; printf ("T% d [CPU% d] preempted at% .4f with ABS_EET =%. 4f \ n", iask-> id, task-> cpu, sched_time, abs__eet [task->id-1]);

 Preemption_counter ++;

 task-> lastj? reempt_time = sched_time;

 task-> preemption = 1;

 task-> preemptdelay = 0 .;

 task-> state = ready;

 CPUs [task-> cpu] .state = IDLE;

 task-> cpu = -1;

// THE PRECAUTION MECHANISM CONSISTS TO SEND A SIGNAL WITH A DESTINATION OF // THE TASK

pthread_kil! (* (task-> pthread) _J SIGUSR1);

 // WHEN THIS RECEIVES IT, THE SIGNAL HANDLER sigusri EXECUTE

 // PTHREAD_COND_WAIT THAT HAS THE EFFECT OF SUSPENDING THE TASK

 // SEE sigusri in APPLiCATiON.C

 }

// ALLOWS A TASK TO A PROCESSOR

void T_runningOn {task * task, int cpujd)

{int i, j, err;

 cpu_set_t mask;

CPU _ZERO (&mask);

Γ SET TASK TO CPUJD ^* /

 // Allocate the 'task' task to processor 'cpujd'

 CPU_SET (cpujd, &mask);

/ ^* PREVENT TASK TO USE OTHER CPUs 7

 // Make sure that the 'task' task can not run on any other processor for (i = 0; i <CPU_size; i ++)

 if (i! = cpujd) CPU jOLRii, &mask);

 err = pthread_setaffinity__np (* (iask-> pthread), sizeof (cpu_set__t), &mask);

tf (err! = 0) {printf (1) PTH RE AD_S AND AFFI ITY RETURNED; % d \ n ", err); exit (0); task-> cpu = cpujd;

 task-> state = running;

 CPUs [cpujd] .state = RUNNING;

 nbj3xec | cpujd] ++;

/ ^* PREVE ALL OTHER TASK TO USE CPUJD ^* /

 // Make sure that any task other than 'task' can not run

 // on the processor number cpu_id

 for {i = 0; i <NUM_THREADS; i ++)

 if (T [i] -> id! = task-> id) {

 err = pthread_getaffinity_np {* {T [!] -> pthread), sizeof {cpu_set_i), &mask);

if (err! = 0) {printf (" ^**** (2) PTHREAD_SETAFFINITY RETURNED:% d \ n", err); exit (0); }

 if ((T [i] -> id! = task-> id))

 CPlLCLR (cpu_td, &mask);

/ ^* CHECK THAI EACH THREAD CAN NOT USE

 MORE THAN ONE CPU (default: CPUO) * /

 // Check that each task can not use more than one CPU {default, CPUO) short cpu_aiiocated = 0;

for (j = 0; j <CPU _" size; j ++)

 if (CPUJSSET (j, & mask)} cpu_allocated ++;

 if (cpu_allocaied == 0) CPU_SET (0, &mask);

 else if {cpu_allocated> 1) printffWARNiNG: T% d IS ALLOCATED MORE THAN ONE CPU \ n ", T [i] -> id);

 err = pthread_setaffinity_np (* (T [i] -> pthread), sizeof (cpu_setJ), &mask);

if (err! = 0) {printf (" ^**** (3) PTH RE AD_S AND AF F! ITY RETURNED:% d \ n", err); exit (0); }

 }

}

// FUNCTION TO TEST IF A PROCESSOR IS USED {1) OR NOT (0) int P_isRunning (int cpujd)

 {

 int i; int cpu_isRunning = 0;

 if (CPUs [cpu_id] .state == RUNNiNG) cpujsRunning = 1;

 return cpujsRunning;

} // SORTING A LIST OF TASKS BY ORDER OF INCREASING DEATH (NEAREST IN // FIRST)

void sort {iask * list [J, int list_size)

 {

 task * temp;

int i, j _t min;

 for (i = 0; i <list__size-1;

 {

 min = i;

 for (j = i + 1; j <list_size; j ++)

 {

 if (Hst [j] -> next_deadline <! ist [min] -> next_deadline)

 {

 m.in = j;

 }

 >

 if (i! = min)

 {

 temp = list [i];

 iist [i] = iist [min];

 iist [minj = Temp;

 }

 }

// FUNCTION THAT RETURNS THE TIME SPENT FROM THE BEGINNING OF THE SIMULATION double get_time {)

 {

 double;

 struct ismeval currenijime; ïf {gettimeofday (& currentJirne, NULL) == -1)

 {

 putsfERROR: getJime_ ofday ");

return -1; }

 time = current_time.tv_.sec - start_time.iv_sec \

 +0.000001 * (current_time.tv_usec - start_tirr¾e.tv_usec); return time;

 }

// APPLICATION TASKS:

 // THE APPLICATIVE TASKS DIVIDE INTO TWO PHASES:

// - AN EFFECTIVE EXECUTION PHASE (CORRESPONDING TO usertask_actualexec)

 // - A WAIT PHASE (CORRESPONDING TO usertask_sleepexec). THE TASK MUST EXPECT // THE TIME OF ITS PERIOD BEFORE I CAN BE READYED FOR RE-EXECUTION

int usertask_actualexec (task * task)

{

 double duration;

 double data [262144J;

 int i = 0;

 tickCount ++; task-> begintime - sched_time;

 #ifdef DEBUG

printf ("T% d Starts run on CPU% d with AET =% .4f ( ^* % .4f =%. 4f) at% .4An",

task-> id, task-> cpu, task-> ret, SR_total [task-> cpu], task-> ret * SRJotal [task-> cpu], get_time () / * task-> begintime ^* /);

 #endif

 // TASKS MAKE A SIMPLE ACCESS TABLE / COMPLETE MULTIPLICATION // UP TO REACH ΙΆΕΤ

 // (TAKING INTO ACCOUNT POSSIBLE PRE-OPTIONS AND FREQUENCY CHANGE)

 {

 duration - get_ime () - task-> begintime;

 daia [i% 262144j = duration * i ++;

} while (duration <iotal_abs _" eet [task-> id-1] + task-> total_preempt_duraiion + (task-> ret * SR_totai [task-> cpu3) + offset_delay [task->id-1]);

 task_duration [task-> id-1J = duration; return 0;

} int usertask_s! eepexec (task * îask) double sleep - task-> next_period - schedjime;

 if (sleep <0)

 sleep = 0.0;

 usleep ({unsigned iong) (1000000 * sleep));

 task-> preemptdelay = 0; return 0;

 }

// DISPLAY FUNCTIONS USED FOR DEBUG

void DispiayQ

 {

 int i; sched_time getjime = ();

 printf ("Scheduling point:% .4f, sched_time);

 printf ("\ nTask \ t cpu \ t ihread_pid \ t nxt ddlne \ t prio \ t starts at \ t stops at \ t idle until \ t state \ n");

 for (i = 0; i <NUM_THREADS; i ++)

 printf ("T% d \ t% d \ t% d \ t% .4f \ t \ t% d \ t%, 4f \ t \ t% .4f \ t \ t% .4f \ t \ t% d \not",

 T [i] -> id, T [i] -> cpu, T [i] -> thread_pid, T [t] -> next_dead! Ine,

 T [i] -> prio, T [i3-> begintime, T [i] -> endtime, sched_time, T [i] -> state);

printf ( "

* ^* \ n ");

} void Dispiayjist {task * listfl. i ^nt list_size)

{

 int i;

 printf ("\ t Task \ t Next_deadline \ n");

 for (i = 0; i <list_size; i ++)

 printf ("\ i \ t \ t \ t% d \ t (% .4f) \ n", list [i] -> id, list [i] -> next_deadline);

 printf ( "\ n");

} N application. vs

 #define _GNU_SOURCE

#include <sched.h>

#include <time.h>

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#inciude <sys / time.h>

#include <signal.h>

#include <string.h>

#include <sched.h>

#include <sys / types.h>

#include <sys / syscaSi.h> #include "N utils h"

// THE APLICATIVE EXAMPLE USED HERE IS TAKEN FROM A VIDEO APPLICATION H264 ENCODER r

 4 TASKS / 2 CPUS

 - T1 -> Motion Estimation # 1 Motion estimation on half-image number 1

 - T2 -> Motion Estimation # 2 Motion estimation on half-image number 2

 - T3 -> Inv. Prediction + Texture Encoding + Syntax Writing Reverse Prediction + Texture Encoding + Syntax Writing

 - T4 -> Loop Filter Unlock filter

 TH! S VERSION REQUIRES 2 CPUs This example requires 2 CPUS

 * / statis task task [NUM_THREADS] = {

 / * Task [0] = * / {

 1, // id

 20.63e-1, // wcet

 5.65e-1, // bcet

 10.40e-1, // aet

 0, // ret

 21 .0e-1, // deadline

 0, // nex_deadline

 -1, // cpu

 40.0e-1, // period

 0, // next_period

-1, // begintime -1, // endtime

 0, // preemption

 0, // preemptdeiay

 0.0, // last_preemp_time

0.0, // totaLpreempt_duration unexisting, // stale

 PTHREAD_ UTEXJNITIALIZER,

 PT H READ_CONDJ NIT! ALIZER,

 NULL, // associated pthread address

0 // t read_pid

 }.

/ ^* Task [1] = 7 {

 2, // id

20.63e-1, // wcet

 5.65e-1, // bcet

 10.50e-1, // aet

 0, / ret

 21.0Θ-1, // deadline

 0, // next dead! Ine

 -1, // cpu

40.0e-1, // period

 0, // next_period

 -1, // beginttme

 -1, // endtime

 0, // preemption

 0, // preemptdelay

 0.0, // tast_preempt__time

 0.0, // total_preempt_from the unexisting ration, // state

 PTHREAD__MUTEX_! NITIALÎZER,

 PTHREAD_CONDJN! TIALIZER,

 NULL, // associated pthread address

0 // threadjaid

 }.

Γ Task [2] = {

3, // id 8.25e-1, // wcet

 3.38e-1, // bcet

 5.96e-1, // aet

 0, // ret

 31.0e-1, // deadline

 0, // next deadline

 -1, // cpu

40.0e-1, // period

 0, // next_period

 -1, // begintime

 -1, // endtime

 0, // preemption

 0, // preemptdelay

 0.0, //! Ast_preempt_time

0.0, // total_preempt_duration unexisting, // state

 PTHREAD_MUTEX_iN! T) ALIZER,

 PTHREAD_CONDJNITIALIZER,

 NULL, // associated pthread address

0 // ihread_pid

 }

/ ^* Task [3] = ^* / {

 4, // id

5.78e-1, // wcet

 1.81Θ-1, / bcet

 3.27Θ-1, // aet

 0, // ret

 40.0e-1, // deadiine

 0, // next deadline

 -1, // cpu

40.0e-1, // period

 0, // rsext_period

 -1, // beg intime

 -1, // endtime

 0, // preemption

0, // preemptdelay 0.0, // last _" preempt_time

 0.0, // total_preempt_duration

 unexisting, // state

 PTHREADJvlUTEXJNlTIALIZER,

 PTHREAD_COND_INITiAUZER,

 NULL, // associated pthread address

 0 // thread_pid

 }};

// MECHANISM USED TO PREPARE A TASK

void sigusrl (int dummy)

 {

 int i;

 pidj pid;

 // Get the current thread's pid

 pid = (long) syscal! (SYS_gettid);

// Compare the pid of the current thread with that of all the threads of the application

 // to identify the thread to suspend. We exploit here the fact that the signal handier (sigusrl) // executes with the pid of the thread which received it,

 for {F0; i <NUM_THREADS; i ++) {

 if (Task [iJ.thread_pid == pid) {

 Task [i] .state = ready;

 pthread_cond_wait {& Task [i] .cond_resume, & Task {iî.mut_waiî);

 // TO REDEMPT THE JOB: pthread_cond_broadcast (& Task [i] .cond__resume)

TaskfiJ.staie = running;

 }

 }

// DECLARATION OF APPLICATIVE TASKS, WITH THEIR TASK EVENTS

// - OIMACTIVATE AT THE BEGINNING OF THE EXECUTION

// - ONOFFSET: NOT USED

 // - ONBLOCK: AT THE END OF THE EFFECTIVE EXECUTION OF A TASK

 // - ONUNBLOCK: WHEN A TASK REACHES ITS PERIOD

 // - ONTERMINATE: WHEN A TASK IS COMPLETELY COMPLETE

// EVERY TASK MATCHES A FUNCTION, WHICH WILL BE ENCAPSULATED IN A THREAD // POSIX FOLLOWING:

void * task0 {void * arg)

 {

int i; task identifier required by the scheduler ^* / TaskjO] .thread_pid = (long) syscall (SYS_gettid); OnActivate (& Task [0]);

 do

 {if (usertask_actualexec (& Task [0]) == -1) {puts ("ERROR: usertask_actualexec"); pthread_exit (0);

 }

 onBlock (& Task [0]);

 if (usertask_sleepexec (& Task [0]) == -1) {puts ("ERROR: usertask_sleepexec"); pthread_exit {0);

 }

 onUnBlock (& Task {0]);

 } whiie (sched_time <simulation_time);

 OnTerminate (& Task {0]);

 pthread_exit {0);

}

void * iask1 (void * arg)

{

 int i;

Γ Job ID required by the scheduler * / Task [1] .threadj) id = (tong) syscall (SYS_gettid); onActivate (& Task [1]);

 do

{if (usertask_actualexec {& Task [1]) == -1) {putsfERROR: usertask_actualexec "); pthread_exit (0); }

 onBlock (Task &[1]);

 if {usertask_sleepexec {& Task [1]) == -1) {puts {"ERROR: usertask_sleepexec"); pthread_exit (0);

 }

 onUnBlock (& Task [13);

 } while (sched_time <simulation_time);

 onTerminate (& Task [1]);

 pthread_exit (0);

} void * task2 (void * arg)

{

 int i;

/ * Task ID required by the scheduler * / Task [2J.thread _" pid = (tong) syscall (SYS_gettid); OnActivate (& Task [2J);

 do

 {if (usertask_actua! exec (& Task [2]) == -1) {puts {"ERROR: usertask_aciualexec"); pthread_exit (0);

 }

 onBlock (& Task [2]);

 if (usertask_sleepexec {& Task [2]) == -1) {putsfERROR: usertask_sieepexec "); pthread_exit (0);

 }

 onUnBlock (& Task [2]);

 } while (sched__time <simulation_time_time);

 OnTerminate (& Task [2]);

pthread _m exii (0);

} void * task3 (void * arg)

{

int i; / * task ID required by the scheduler ^* /

 Task [3] .thread_pid = (long) syscall {SYS_gettid);

 OnActivate (& Task [3]);

 do

 {if (usertask_actuaiexec (& Task [3]) == -1) {

 putsfERROR: usertask_actualexec ");

 pthread_exit (0);

 }

 onBlock {& Task [3]);

 if (usertask_sleepexec (& Task [3]) "- -1) puts (" ERROR: usertask_sleepexec ");

 pt read_exit (0);

 }

 onUnBlock (& Task [3]);

 } whiie (sched_time <simulation_time);

 OnTerminate (& Task [3]);

 pthread_exit (0);

rnt hand {)

{

 int i, n;

 void * ret;

 pthreadj Thread [NUM_THRt = ADS]; simuiaiionjime = 80e ~ 1;

 // INITIALIZATIONS RELATED TO PROCESSORS init_CPUs ();

 // INITIALIZATIONS RELATING TO APPLICATIVE TASKS init_TASKs (Task, Thread);

// Initiaiisaiion of the signal manager sigusrl

 if (signaUSIGUSRI, sigusrl) == SIG_ERR) {

perror ("signal ⁿ );

 exit (1);

} printf ("\ nTask \ t WCET \ t \ t Deadline \ t Period \ t Offset \ n");

// CREATING POSIX THREADS

if (pthread_create (& Thread [OJ, NULL, taskO, "0") <0)

 {

 printf {"pthread_create: error creating thread 1 \ n");

 exit (1);

 }

if (pthread _" create (& Thread [1], NULL, taskl, Ί") <0)

 {

 printf {"pthread_create: error creating thread 2 \ n");

 exit (1);

 }

if (pthread_create (& Thread [2], NULL, task2, "2") <0)

 {

 printf {"pthread_create: error creating thread 3 \ n");

 exit (1);

 }

if (pthread_create (& Thread [3], NULL, task3, "3") <0)

 {

 printf ("pthread_create: error creating thread 4 \ n");

 exit (1);

 }

Γ SYNCHRONIZATION: WAIT FOR THE EFFECTIVE END OF CREATION

 FROM ALL THREADS BEFORE LAUNCHING START_SCHED

while (rdv! = NUM _" THREADS) {} start_sched ();

(Void) pthreadJoin (Thread [0], &rei);

(void) pthreadJoin (Thread [1], &ret);

(Void) pthread_join (Thread [2], &ret);

(Void) pthreadJoin (Thread [3], and rei);

// CLOSE THE FREQUENCY CHANGE FILES

exst_CPUs ();

// MEASURE PROCESSOR TIME (AVERAGE PER CALL, TOTAL) double average__sched_duration; double total_sched_duration = 0;

 prinîf ("NUMBER OF SCHEDULER CALLS:% d \ n", nb_sched_call);

for (i = 0; i <nb _m sched_cal !; {totai_sched_duration + = sched_of the ration [ij; printf ("% f", sched_duration [i]);}

 printf ("\ nTOTAL SCHEDULER CALL DURATION:% f n", total_sched_duration);

 average_sched__duration = total_sched_duration / nb_sched_call;

 FIRST SCHEDULER CALL DURATION:% f n ", average_sched_duration); return 0;

2. pm_drivers

in such_core_i5_m 520. h

* intel_core_i5_m520.h

7

#ifndef INTEL_CORE_I5_M520

#define! NTEL_CORE_I5_M520

#include "pm_typedef.h"

#define NB_CPU_MAX 4

Γ available frequencies

/ * IMPORTANT: list of available frequencies in descending order 2400000 2399000 2266000 2133000 1999000 1866000 1733000 1599000 1466000 1333000 1199000 * /

/ * definition of possible states of CPU07

#define NB_STATES_CPU 1 #ifdef TARGET_ CPU_DEFINED

 Elementary_state CPU_STATE [NB_CPU_MAX] [NB__STATES_CPU];

#else Bementary_state _CPU_STATE [NB_CPU_MAX] INB_STATES_CPU]

freq / elementary_state_id / core_id

 {2400000, 0, 0}, // CPU0 [0]

 {2399000, 1.0}, // CPU0 [1]

 {2266000, 2, 0}, // CPU0 [2]

 {2133000, 3.0}, // CPU0 [3]

 {1999000, 4.0}, // CPU0 [4]

 {1866000, 5, 0}, // CPU0 [5]

 {1733000, 6, 0}, // CPU0 [6]

 {1599000, 7, 0}, // CPU0 [7]

 {1466000, 8, 0}, // CPU0 [8]

 {1333000, 9, 0}, // CPU0 [9]

 {1199000, 10.0}}, // CPU0 [10]

{// frequency / number of the elementary state (frequency) concerned

// / CPU number concerned - These fields are defined in

 // pm_typedf.h

 {2400000, 0, 1}, // CPU1 [0]

 {2399000, 1, 1}, // CPU1 [1]

 {2266000, 2, 1}, // CPU1 [2]

 {2133000, 3, 1}, // CPU1 [3]

 {1999000, 4, 1}, // CPU1 [4J

 {1866000, 5, 1}, // CPU1 [5]

 {1733000, 6, 1}, // CPU1 [6]

 {1599000, 7, 1}, // CPU1 (7)

 {1466000, 8, 1}, // CPU1 [8]

 {1333000, 9, 1}, // CPU1 {9}

 {1199000, 10, 1}}, // CPU1 [10]

// frequency / number of the elementary state (frequency) concerned

// / number of the CPU concerned

 {2400000, 0, 2}, // CPU2 (0)

 {2399000, 1,2}, // CPU2I1]

 {2266000, 2, 2}, // CPU2 [2]

 {2133000, 3.2}, // CPU2Î3]

 {1999000, 4.2}, // CPU2 [4]

 {1866000, 5.2}, // CPU2 [5]

 {1733000, 6.2}, // CPU2 [6]

{1599000, 7.2}, // CPU2 [7] {1466000,8,2}, // CPU2 [8]

 {1333000, 9, 2}, // CPU2 [9]

 {1199000, 10, 2}}, // CPU2 [10]

// frequency / number of the elementary state (frequency) concerned

/ number of the CPU concerned

 {2400000, 0, 3}, // CPU3 [0]

 {2399000, 1, 3}, // CPU3 [1]

 {2266000, 2, 3}, // CPU3 [2]

 {2133000, 3.3}, // CPU3 [3]

 {1999000, 4.3}, // CPU3 [4]

 {1866000, 5, 3}, // CPU3 [5]

 {1733000, 6.3}, // CPU3 [6]

 {599000, 7, 3}, it CPU3 [7]

 {1466000, 8, 3}, // CPU3 [8]

 {1333000, 9, 3}, // CPU3 [9]

 {1199000, 10.3}} // CPU3 [10]

#endif

#endif

pm typedef.h

 #ifndef PM TYPEDEF

#define PM_TYPEDEF

/ * - Data Structures- ^* / typedef unsigned long long Core_freq; typedef struct Elemeniary_state {

 Core_freq freq;

 unsigned long elementary statejd;

 unsigned long corejd;

} Elementary__state; typedef struct Global_state {

Elementary_state * state; unsigned int nb values;

 f! oat curr;

 float sees;

} Globai_state; typedef struct

 Global_state_and_transition {

 float delay;

 float energy;

 Global_state target;

 } Globai_state_and_transition;

typedef struct Global_states_and_Jransitiorts {

 Global_state_and_transition * values;

 unsigned long nb values;

} Global_states_andJransitions; typedef struct Corejds {

 unsigned long * values;

 unsigned long nb_yalues;

} Corejds;

/ ^* - Interface Operations- ^* /

/ ^*

 Co re jds * CP U_state_m to swim_q u ery_core_i ds ();

Global_siates_and_transitions * CPU_statejianager jueryjiext __. Possible_states (); void CPU_state_manager_apply_staie {Globai_state ^* s);

#endif

pm_cpufreq.c

! ^*

^* pm_cpufreq.c

 * functions to change the frequency of processors using cpufreq

7

#include <stdio.h> #inc! ude <string.h>

#inciude <fcntt.h>

#include "pm_typedef.h"

#define DEBUG

#define CPUFREQPATH "/ sys / devices / system / cpu / cpu"

#define GOVPATH "/ cpufreq / scaling _^ governor"

#define FREQPATH "/ cpufreq / scaling_setspeed"

FILE * setspeed_cpu [4]; void itoa (int n, char * u) {

 int i = 0J;

 tanks [17]; do {

 s [i ++] = (char) (n% 10 + 48);

 n = n% 10;

 } while ((n / = 10)> 0); for {p0; j <i; j ++)

 u [i-1 -j] = s [j]; u [j] = '\ 0';

} void set_governor (int cpu.char * ¾ ° v) {

F (LE * cpu_governor;

 char cpu_gov filename

// initialization of the complete file name (including the path) for the number governor

'cpu' char cpu_gov_sir [17J;

 tioa {cpu, cpu_gov_str);

 strcpy (cpu_gov_filename, CPUFREQPATH);

 sircat (cpu_gov_ftlename, cpu_gov__str);

strcat (cpu_gov_f i lena me, GO VPAT H); char strbufOI [20];

 char strbuf02 [20]; // POSTER THE CURRENT CPU GOVERNOR

 cpu_governor = fopen {cpu_gov_filename, "r");

 fscanf (cpu_governor, "% s", strbufOI);

 #ifdef DEBUG

 printf ("For CPU% d \ t", cpu);

 prinif {"CPU% d current governor:% s \ t", cpu, strbufOI};

 #endif

 fclose (cpu__governor);

 // AMEND THE CURRENT CPU GOVERNOR

 cpu_governor = fopen (cpu_gov_filename, "w");

 fprintf (cpu_governor, "% s", gov);

 fclose (cpu_governor);

// INSERT NEW CURRENT GOVERNOR {FOR VERIFICATION} cpu_governor = fopen {cpu_gov_filename, "r");

 fscanf (cpu_govemor, "% s", strbuf02);

 #ifdef DEBUG

 printf ("-> \ iCPU% d new governor:% s \ n", cpu, strbuf02);

 #endif

 fclose (cpu_governor);

void open_cpufreq (int cpu) {

 char cpu_freq_filename [60];

#ifdef DEBUG

 printf ('Opening \ t \ t \ t \ t \ t / sys / devices / system / cpu / cpu% d / cpufreq / scaling_setspeed \ n' ', cpu); #endif

 // initialization of the complete file name {including the path)

 // for the frequency specification file (scaling_setspeed) of the core number 'cpu' char cpu_freq_str [17J;

 itoa (cpu, cpu_jfreq_str);

 strcpy (cpujreqjilename, CPUFREQPATH);

 strcat (cpu_freq_filename, cpu_freq_str);

 strcat (cpu_freq_filename, FREQPATH);

setspeed_cpu [cpu] = fopen (cpu_freq_filename _I "r + w"); > void CPU_state__rnanager_apply_state {int cpu, E [ementary_state * s) {// FILE * setspeed_cpu;

 int freqO, freql;

// POST THE CURRENT CPU FREQUENCY

 fscanf (setspeed_cpu [cpu], "% d", &freqO);

 fseek (setspeed_cpu {cpu], 0, SEEK_SET);

 #ifdef DEBUG

 printf {"CPU% d CURRENT FREQUENCY:% d \ t", cpu, freqO);

 #endif fprintf (setspeed_cpu [cpu], "% llu", s-> freq);

 fseek (setspeed__cpu [cpu], 0, SEEKJ3ET);

freql = -1;

 fscanf (setspeed_cpu [cpuî, "% d", &freq1);

 fseek (setspeed_cpu [cpu], 0, SEEKJ3ET);

 #ifdef DEBUG

 printf ("-> \ tCPU% d NEW FREQUENCY:% d \ n", cpu, freql);

 #endif

} int CPU_statejianager_query_current_freq {int cpu) {

 int freqO; fscanf (setspeed_cpu [cpu], "% d", &freqO);

 fseek {setspeed_cpu [cpu], 0, SEEK_SET);

 return freqO;

 } void close_cpufreq (int cpu) {

 #ifdef DEBUG

 printf ('Olossng \ t \ i \ t \ t / sys / devices / system / cpu / cpu% d / cpufreq / scaling_setspeed \ n ", cpu); #endif

 f close (s andspeed__cpu [cpu]);

}

Claims

1. A task scheduling method with time constraints, based on a model of independent periodic tasks and realized in user space, in which:

 Each task to be scheduled is associated with a data structure, defined in user space and containing at least one temporal information and information indicative of a state of activity of the task, said activity state being chosen from a list comprising at least :

 - a task state in execution;

 a task state waiting for the end of its execution period; and

 a task state ready for execution, waiting for a resume condition;

 · During its execution, each task modifies said information indicative of its activity state and, where appropriate, according to a predefined scheduling policy, calls a scheduler which is executed in user space;

 • at each call, said scheduler:

 - establishes a queue of tasks that are ready for execution, waiting for a recovery condition;

 sorts said queue according to a predefined priority criterion;

 if necessary, preempt an executing task by sending a signal forcing it to pass to said job state ready to execute, waiting for a resume condition; and

 sends said resume condition at least to the task at the head of said queue.

2. scheduling method according to claim 1 wherein said scheduling policy is a preemptive policy, such as EDF, RM, DM or LLF.

The scheduling method according to one of the preceding claims, implemented in a multiprocessor platform, wherein said data structure also comprises information relating to a processor to which the corresponding task is assigned, and wherein said scheduler assigns to a system processor every task ready to be executed.

4. Scheduling method according to one of the preceding claims, wherein said scheduler modifies the clock frequency and the supply voltage of the or at least one processor according to a DVFS policy.

5. A scheduling method according to one of the preceding claims including an initialization step, during which:

 the tasks to be scheduled are created, allocated to the same processor and placed in a waiting state of a recovery condition, a global variable called an appointment being incremented or decremented during the creation of each said task;

 when said appointment variable takes a predefined value indicating that all the tasks have been created, said scheduler is executed for the first time.

The scheduling method according to one of the preceding claims, wherein said data structure also contains information indicative of a thread associated with said task and its worst execution time.

7. scheduling method according to one of the preceding claims, executed under an operating system compatible with a POSiX standard.

The scheduling method according to claim 7, wherein said operating system is a Linux system.

9. The scheduling method according to one of claims 7 or 8 wherein, at each call of the scheduler, a "pthread" is created to ensure its execution.

10. scheduling method according to one of claims 7 to 9, comprising the use of a MUTEX to ensure the execution of a single instance of both the scheduler.

1 1. A scheduling method according to one of claims 9 or 10 when dependent on claims 3 and 8, wherein assignment of a task to a processor is performed by means of ΑΡΙ CPU Affinity.

12. Computer program product for implementing a scheduling method according to one of the preceding claims.