Fuzzy Dynamic Load Balancing for Real-Time Systems on Heterogeneous Multiprocessors

The following section presents the existing body of related work, providing a background for the current research effort.

Alam and Varshney [3] proposed a dynamic load balancing strategy for a homogeneous multiprocessor system and apply it on a cube-based interconnect network called Folded Crossed Cube network. The experimental results show that a lower load imbalance factor has been achieved as well as the execution time. Parallel tasks are solved with the largest number of tasks. As the number of tasks increases, the execution time decreases with a lower load imbalance factor.

Efficient architecture for running thread (EARTH) is a multithreaded programming and execution model that supports fine-grained and non-preemptive threads in a distributed memory environment. In this paper, the authors present the load balancing strategies for the runtime of a multithreaded system. They describe the design and implementation of a set of dynamic load balancing algorithms and study their performance in divide-and-conquer, regular, and irregular applications. The experimental study on the distributed memory multiprocessor IBP SP-2 indicates that a random load balancer performs as well as, and often better than, history-based load balancers [4].

Tan et al. [5] proposed a high-performance, real-time, dynamic multicore load balancing method for microkernel operating system. It has been implemented and tested on a microkernel operating system named Mginkgo. The results show that in case of load imbalance in the system, load balancing can be performed automatically so that all processors in the system can try to achieve the maximum throughput and resource utilization.

A real-coded genetic algorithm has been proposed by Panwar et al. [6] to balance the load on each processor. To achieve the specified objective, a dual function is used here; first, the fitness function is used to reduce the execution time, while the second is used to maximize the load on the individual processor. The proposed algorithm is tested on a total of 12 problems from the literature as well as three additional benchmark problems. The analysis shows that the proposed algorithm is efficient compared to what was previously known.

Nirmala and Girijamma [7] proposed a hybrid genetic algorithm (HGA) combined with a stochastic development process to designate and order real-time tasks with priority requirements, the proposed algorithm works on the CPU utilization, the CPU queue length and the distance to its current load as linguistic inputs while framing the fuzzy set. The proposed algorithm has been evaluated with similar existing methods to prove its efficiency. The results prove that FLLBHGATS outperforms other techniques with respect to the quality of the solution.

Ali and Suleman [8] presented various dynamic load balancing algorithms including round-robin, minimal connections, and weighted load balancing in real-time scenarios. This paper explores the implementation of dynamic load balancing strategies that adapt to different workloads in real-time, thereby improving user experience while minimizing latency and resource waste. By using adaptive techniques that consider both current workloads and future demand forecasts, distributed systems can achieve more balanced load distribution, resulting in improved performance and user satisfaction.

The works that use static load balancing are often insufficient in real-time systems, leading to inefficient resource utilization. Dynamic load balancing addresses these challenges by continuously monitoring system performance metrics such as CPU utilization, energy consumption and redistributing tasks across processors based on real-time data, ensuring that no processor is overloaded while others remain underutilized. Most of the existing works do not consider very important constraints such as energy consumption and timing constraints while solving the load balancing problem. And in real-time systems, both of these constraints play a very important role for the system efficiency. In order to guarantee the processing of uncertain information (task arrival, expected completion date, etc.) of tasks across a set of tasks that run on multiple processors and satisfy certain constraints, the use of fuzzy logic is more than necessary.

Generally, current systems must respect temporal constraints. A system is called real-time when the data it collects and processes remains relevant for a well-defined duration. These systems are mainly used in the field of process control, where the execution of programs must be completed before a specific deadline. In other words, a system is real-time if it is able to respect temporal deadlines [17].

Real-time scheduling algorithm is an algorithm that can provide a sequence of the work performed by the processor(s); if the task deadlines are respected, the sequence is considered valid. Single-processor and multiprocessor scheduling algorithms are presented in this subsection [18].

• “Rate-monotonic” (RM): Scheduling algorithm: is a static method that gives the highest priority to the task with the highest frequency (i.e., the shortest period). The disadvantage of this algorithm is that it is only used for periodic tasks with deadlines on request.

• “Inverse deadline” (ID): In this static scheduling algorithm, the highest priority is given to the task with the shortest deadline. Inverse Deadline is a method where the priorities of tasks are determined based on their respective deadlines.

• “Least laxity first” (LLF): The “least laxity first” algorithm grants, at time t, the highest priority to the task with the smallest laxity. The calculation of the laxities of the tasks can be done in two ways: The laxity of a task represents its maximum deviation from its deadline to (re)start its execution, when the task is executed alone.

• “Earliest deadline first” (EDF): Grants, at time t, the highest priority to the task with the earliest deadline. The EDF* notation is used to denote the EDF algorithm, where among the tasks with the same deadline, the one that comes first is selected [19].

If the tasks of our system can be executed on several available processors then the scheduling is of the multiprocessor type. Real-time systems must respect their constraints, particularly in strict real-time systems. Thus, the scheduling algorithm must be shared the tasks between the processors in an equitable manner to meet the load balancing needs. Our objective is to provide a new solution for load balancing, non-penalizing in terms of time constraint with minimized energy consumption. To achieve this objective in this work we must propose a real-time scheduling algorithm on a multiprocessor machine that estimates the workload of a system and distributes the load equally between the processors that are either overloaded or underloaded using a load balancing scheme.

6.1 The proposed approach

Our approach explores the implementation of dynamic load balancing strategies that adapt to real-time systems. Figure 4 presents the proposed approach to solve the load balancing problem for real-time systems. The proposed dynamic load balancing continuously monitors system performance metrics, such as CPU utilization, energy consumption, and allows the system to redistribute workloads across available processors based on real-time data, ensuring that no processor is overloaded while others remain underutilized. The paper presents a dynamic load balancing algorithm that uses the EDF* real-time scheduling algorithm to schedule tasks in 03 different queues; namely, the high-speed processor queue HSPQ, the medium-speed processor queue MSPQ, and the low-speed processor queue LSPQ. The assignment of tasks to queues is done by the proposed fuzzy approach based on the task deadline and the utilization factor of each processor category. We examine the impact of our approach on system performance metrics such as response time, throughput and energy consumption. By using adaptive techniques that take into account workloads to achieve a more balanced load distribution.

Figure 4. The proposed approach

In this section, fuzzy logic is used to balance the load in order to share the load equally among the processors and to minimize the energy consumption in the real-time task scheduling algorithm for the multiprocessor environment. The proposed model expresses the different steps to be followed to solve the load balancing problem for multiprocessor real-time systems. The model we propose is based on the load balancing mechanism to make it capable of meeting all the constraints. Once the scheduling is triggered, it complies with the scheduling policy, which defines which resources to assign in priority to a given task.

This paper proposes a dynamic load balancing algorithm that addresses the common problems that can reduce the efficiency of a multiprocessor system. These problems are response time, failure rate and processor utilization.

(a) Response time: This is the time required for a task to be processed by the system. A good load balancer should reduce this time, ensuring that critical tasks are executed in the required time.

(b) CPU utilization: This metric measures how much CPU resources are being used. An effective balancer should maximize this utilization while avoiding overloading certain processors.

(c) Task failure rate: This indicates the percentage of tasks that fail to be processed in the expected time. A high failure rate may signal poor load management and requires adjustments in the balancing mechanism.

6.2 Assumptions and considerations

Some considerations and assumptions are made regarding the multiprocessor system for which the algorithm is designed. The main assumptions characterizing this multiprocessor system:

the use of a system with homogeneous processors is not always the case in reality, but most of the current systems use heterogeneous processors to meet the needs of our system or the needs of users, which allows us to propose an approach on a system with heterogeneous processors (at the characteristic point the maximum execution speed).

in reality most of the systems are multiprocessor systems (heterogeneous) which process dependent or independent tasks, periodic or aperiodic and in order not to complicate our approach by several parameters, we assumed that our system processes only independent tasks, periodic or aperiodic. In the context of real-time systems running on multiprocessor architectures, load balancing is crucial to ensure optimal performance, minimize response times, and maximize the utilization of processor resources. In this paper, the multiprocessor system is assumed to be configured using heterogeneous processors.

Migrating a task to another processor makes the cache contents invalid for the first processor and the cache of the second processor must be repopulated. When executing a task on a specific processor, the most recently accessed data of the task is stored in the processor cache and successive memory accesses of the task are often satisfied in the cache. Due to the high cost of cache invalidation and repopulation, most SMP systems try to avoid process migration from one processor to another and try to keep a process running on the same processor.

Unlike many existing works that use static methods, in our proposed approach, we used dynamic techniques that adjust the distribution of running tasks, often in response to load variations, to balance the load across different processors. This can increase the efficiency of the system, but requires careful management to avoid frequent interruptions and that can dynamically react to load changes. Dynamic load balancing algorithms have shown particular promise, allowing optimized redistribution of tasks in response to load variations.

A single load manager monitors and distributes tasks across processors. This provides a holistic view of the system, which facilitates optimization, and to avoid inconsistencies and inefficiencies if communications between processors are not well managed.

In our multiprocessor system, multiple tasks must be executed on multiple processors, each with specific timing constraints. The scheduling of these tasks is crucial to ensure that all tasks meet their deadlines (hard real-time system), especially in critical applications such as embedded systems or real-time control systems.

6.3 Task modeling

Each task will have a set of properties, including its period, execution time, and deadline.

- ri: The wake-up date $r i$ of the kth instance: $r i=r 0+i^* P$

- Pi: Period

- Di: Critical delay

- Di: The deadline of the ith instance:

$d i=r i+D=r 0+i^* P+D$       (1)

- Ci: induced load (execution time)

It is clear that $C i$ depends on the processor used, so the duration of each instruction must be configurable. In the following we denote a real-time task system composed of n tasks $\mathrm{Ti}(\mathrm{i}=1 \ldots \mathrm{n})$ by $\{\mathrm{T} 1(\mathrm{r} 1, \mathrm{C} 1, \mathrm{D} 1, \mathrm{P} 1), \mathrm{T} 2(\mathrm{r} 2, \mathrm{C} 2, \mathrm{D} 2, \mathrm{P} 2), \ldots$, $\mathrm{Tn}(\mathrm{mn}, \mathrm{Cn}, \mathrm{Dn}, \mathrm{Pn})\}$ or more briefly by $\{\mathrm{Ti}(\mathrm{ri}, \mathrm{Ci}, \mathrm{Di}, \mathrm{Pi})\} \mathrm{i}=1 . \mathrm{n}$.

Study period: If $H$ is the length of such an interval, then the program in $[0, H]$ is the same as that in $[k H,(k+1)]$ for any integer $k>0$. This is the minimum time interval after which the program repeats itself. For a set of periodic tasks activated synchronously at time $t=0$, the study period is given by the least common multiple of the periods: $H=P(T 1, \ldots, T n)$.

6.4 Feasibility

The CPU utilization factor U is the fraction of CPU time spent on the task set execution. Since Ci/Pi is the fraction of CPU time spent on task i execution, the utilization factor for n tasks is given by:

$U=\sum_{i=0}^n C i / P i$     (2)

Processor heterogeneity: allows to integrate multiple processor types and computing units within our system to achieve optimized performance and efficiency. In such an environment, various processors collaborate to execute various computational tasks. The essence of processor heterogeneity lies in its ability to distribute workloads based on the strengths of each processor type. In our proposed approach, we group processors according to their execution speed into 03 different categories. Each processor class excels at handling specific types of tasks: high-speed (PHV) processors are well suited for tasks with close deadlines, medium-speed (PMV) processors for processing tasks with medium-term deadlines, and low-speed (PBV) processors for tasks with long-term deadlines. This distribution improves performance, as tasks are processed faster and more efficiently by the most suitable processors. In addition, it improves energy efficiency by reducing the computational load on less suitable processors, thereby reducing energy consumption. If the number of processors in a category I is defined by the term nbrPr (PIV), then the utilization factor of a category of processors $U(PIV)$ is given by:

$U(P I V)=\left(\sum_{i=0}^n C i / P i\right) / n b r P r(P I V)$          (3)

To assign a task Ti to a free processor $\operatorname{Pr}(\mathrm{j})$ of category k that belongs to the set $\{\mathrm{PHV}, \mathrm{PMV}, \mathrm{PBV}\}$ we must calculate UMin (k) which represents the processor of category k with a minimal utilization factor.

UMin $(\mathrm{k})=$ Prj knowing that

$U(\operatorname{Pr} j)={Min}\{U(\operatorname{Pr} i), \forall i \in K\}$        (4)

The EDF algorithm is a dynamic scheduling rule that selects tasks according to their absolute deadlines. More precisely, tasks with closer deadlines will be executed at higher priorities.

The arrival of a task Ti in the system is an event that requires a feasibility test to ensure that the insertion of this task does not exceed the capacity of all the processors available in our system.

According to the reference [20], the feasibility test is defined by a sufficient condition and a second necessary condition. if these two conditions are verified, we ensure the existence of a real-time scheduling of the tasks.

$\begin{aligned} & \sum_{\substack{i=0 \\ n}}^n C i / P i \leq 1 \\ & \sum_{i=0}^n C i / D i \leq 1\end{aligned}$        (5)

When our system consists of R processors and N concurrent periodic tasks with individual timing constraints, the operating system must guarantee that each periodic instance is regularly activated at its own pace and completed within deadlines. The feasibility test becomes as follows:

$\sum_{i=0}^n C i / P i \leq R$           (6)

6.5 The fuzzy approach

In our proposed approach, each task is inserted into one of the existing queues (queue of high-speed processors (HSPQ), queue of medium-speed processors (MSPQ), queue of low-speed processors (LSPQ)) according to the following fuzzy inference rules (Figure 5):

1)- If Di=Soon and U(PHV)≠Hight then insert Ti into HSPQ

2)- If Di=Soon and U(PHV)=Hight and U(MSPQ)≠Hight then insert Ti into MSPQ

3)- If Di=Soon and U(PHV)=Hight and U(MSPQ)=Hight and U(LSPQ)≠Hight then insert Ti into LSPQ

4)- If Di=Soon and U(PHV)=Hight and U(MSPQ)=Hight and U(LSPQ)=Hight then insert Ti in HSPQ

5)- If Di=medium and U(PMV)≠Hight then insert Ti in MSPQ

6)- If Di=medium and U(PMV)=Hight and U(PHV)≠Hight then insert Ti in HSPQ

7)- If Di=medium and U(PMV)=Hight and U(PHV)=Hight and U(PBV)≠Hight then insert Ti in LSPQ

8)- If Di=medium and U(PMV)=Hight and U(PHV)=Hight and U(PBV)=Hight then insert Ti in MSPQ

9)- If Di=far and U(PBV)≠Hight then insert Ti in LSPQ

10)- If Di=far and U(PBV)=Hight and U(PMV)≠Hight then insert Ti in MSPQ

11)- If Di=far and U(PBV)=Hight and U(PMV)=Hight and U(PHV)≠raise then insert Ti into HSPQ

12)- If Di=far and U(PBV)=Hight and U(PMV)=Hight and U(PHV) = raise then insert Ti into LSPQ

Fuzzy control plays a major role in solving problems that involve inaccurate and uncertain information. As shown in Figure 6, the proposed fuzzy approach uses 04 input variables and one output variable: U(PHV), U(PMV), U(PBV), task deadline Di and the output variable FAPiV which represents the 03 categories of queues (HSPQ, MSPQ and LSPQ). Fuzzification is the transformation of numerical inputs Xi into a set of membership values in the interval [0, 1] in corresponding fuzzy sets. Fuzzification can be seen as a conversion of real variables into fuzzy variables (also called linguistic variables) defined on a representation space related to the inputs. The number of membership functions to be defined for each language variable is defined using human expertise [21]. The rules are formulated on the expert's knowledge of the system. These rules express the relationship between the fuzzy input sets and the corresponding fuzzy control sets. This representation space is normally a fuzzy subset.

In our approach, each task is described with a 4tuple: Ti=Ti(ri,Ci,Di,Pi) where each linguistic variable corresponds to the triplet (X, T(X), U); X is a variable (U(PHV), U(PMV), U(PBV), Di). T(X) is the range of values of the variable and U is a finite or infinite set of fuzzy subsets. Figure 7 shows the fuzzification of the input variable U(PHV) that models the utilization factor of the high-speed processor category (PHV). It is presented as follows: X=U(PHV), T(X)=[0, 1], U={Hight, medium, low}.

05.png

Figure 5. Fuzzy inference rules

06.png

Figure 6. The approach fuzzy

We have chosen 03 linguistic values {High, medium, low} of the input variable U(PHV) to express the utilization rate of the high-speed processor category that allow us to decide to which queue our task should be assigned according to the linguistic values, knowing that if the utilization factor U(PHV) is high then we avoid assigning the task Ti to their queue. Our approach uses fuzzy inference rules that use 04 fuzzy input variables and one output variable, based on the idea of assigning the task to the queue reserved for processors with the lowest utilization factor considering the task deadline. i.e. avoid assigning a task with a very close deadline, to the category of processors with medium or low speed to ensure the execution of this task before their deadline.

Figure 8 shows the structure of the decision space of our fuzzy approach. The decision space shows how these decisions influence each other. To evaluate the proposed algorithms, we performed simulations under MATLAB 7.9.0.529.

07.png

Figure 7. The input variable U (PHV)

08.png

Figure 8. The set of decisions

6.6 Simulation

The simulation of our proposed approach is based on the implementation of our proposed scheduling algorithm under MATLAB 7.9.0.529 and by using a HP ProBook 4530s laptop with an Intel(R) Core TM i7 processor and a 09 GB RAM. Our goal in this simulation is to describe the execution scenario of tasks to meet the load balancing needs, and not the actual execution of tasks.

In our approach, each task is described with a 4-tuple: Ti(ri,Ci,Di,Pi); ri : The wake-up date ri of the k-th instance, Ci: induced load (execution time), Pi: period, Di: critical delay. The choice of values for these criteria in our case study is based on scenarios that can apply in real machines.

To demonstrate the effectiveness of our proposed approach, we propose a case study presented in Table 1.

In our case study, our system consists of 09 processors grouped in 03 different categories:

PHV: category of high speed processors which contains 03 processors (Pr 02, Pr 05 and Pr 07) with an execution speed Vi=1.

PMV: category of medium speed processors which contains 04 processors (Pr 01, Pr 04, Pr 06 and Pr 08) with an execution speed Vi=0.9.

PBV: category of low speed processors which contains 02 processors (Pr 03 and Pr 09) with an execution speed Vi=0.8.

And 20 periodic tasks; each task described with a 4-tuple: Ti = (DA, Ci, Di, Pi).

Table 1. Tasks description

09.png

Figure 9. Execution of tasks by PHV category processors

010.png

Figure 10. Execution of tasks by PMV category processors

011.png

Figure 11. Execution of tasks by PBV category processors

Figures 8 and 9 represent the execution of tasks in the two categories of PHV and PMV processors respectively. Figure 10 present the execution of tasks in the category of PBV processors.

6.7 Discussion of case study results

The feasibility test is a necessity in our approach for each arrival of a task Ti; this requires calculating Ptot first (the global period of all tasks), Ptot=PPCM (6,10.15, 30, 5, 10, 15, 6, 10, 15, 15, 30, 15, 15, 10, 15, 15, 30, 30, 30)=30. Calculating feasibility after each task arrives is an important step. The 03 tasks T1, T2, T3 arrived in the system at time t=0. After the positive feasibility test, the proposed fuzzy approach associates for each task their appropriate queue (HSPQ, MSPQ, LSPQ) according to the utilization factor of each category of processors and the deadline of the task. then the 03 tasks are inserted into the 03 queues in the following manner:

- T1 insert into the HSPQ queue.

- T2 insert into the MSPQ queue.

- T3 insert into the LSPQ queue.

After inserting the tasks into the queues in the order calculated by the EDF* real-time scheduling algorithm, the first task of each queue must be assigned to the available processor with a low utilization factor.

With an execution speed V2=1, the task T1 uses the processor Pr 02 from the date t=0 for an execution duration C1=1, at the same time the task T2 uses the processor Pr 01 with C2=4 and the execution speed V1=0.9, the task T3 used the processor Pr 03 from the date t=0 with C3=3 and the execution speed V3=0.8. In date t=task T1 completes execution for its first period and the arrival of tasks T4, T5, T6, T7 in the system. then the 04 tasks are inserted into the 03 queues in the following manner:

- T4 insert into the LSPQ queue.

- T5 insert into the MSPQ queue.

- T6 insert into the HSPQ queue.

- T7 insert into the MSPQ queue.

Task T4 used processor Pr 09 from date t=1 with C4=8 and execution speed V9=0.8, Task T5 used processor Pr 04 from date t=1 with C5=2 and execution speed V1=0.9, Task T6 used processor Pr 05 from date t=1 with C6=5 and execution speed V3=1 and Task T7 used processor Pr 06 from date t=1 with C7=6 and execution speed V3=0.9. In date t=2 it is the arrival of task T8 in the system and inserted into the MSPQ queue. Processor Pr 08 is available, then task T8 is executed by Pr 08 with C8=2 and execution speed V8=0.9. In date t= 3, arrival of tasks T9, T10, T11 in the system. then the 03 tasks are inserted into the 03 queues in the following manner:

- T9 insert into the HSPQ queue.

- T10 insert into the MSPQ queue.

- T11 insert into the HSPQ queue.

Task T9 used processor Pr 07 from date t=3 with C9=3 and execution speed V7=1, Task T11 used processor Pr 02 from date t=3 with C11=6 and execution speed V2=1, Task T10 used processor Pr 04 from date t=3.22 (end of execution of the T5 task for its first period) with C10=7 and execution speed V4=0.9. In date t=4, arrival of tasks T12, T13, T14 in the system. then the 03 tasks are inserted into the 03 queues in the following manner:

- T12 insert into the LSPQ queue.

- T13 insert into the MSPQ queue.

- T14 insert into the MSPQ queue.

Task T12 used processor Pr 03 from date t=4 with C12=13 and execution speed V3=0.8, Task T13 used processor Pr 01 from date t=4.44(end of execution of the T2 task for its first period) with C13=4 and execution speed V1=0.9, Task T14 used processor Pr 08 from date t=4.22 (end of execution of the T8 task for its first period) with C14=3 and execution speed V8=0.9.

Similarly, all tasks complete their execution and meet their deadlines using our proposed approach. The scheduling of tasks by our proposed approach on different processor categories are shown in Figures 9-11.

Table 2. Case study statistics

The results presented in Table 2 express that the proposed approach for dynamic load balancing is efficient by the fair distribution of load between the different processors and the respect of deadline for all the tasks. The utilization factor of each processor is very close for the average utilization factor and that the average response time is very low equal to 0.43. Without using the migration our proposed approach allows the optimization of the performances and the use of the resources in an efficient way.

The most studied energy calculation model in the literature is defined as follows: if the speed of a machine is equal to a value ‘V’ for a given duration ∆, then the energy consumption power is given by Vα for a constant α>1, and the total energy consumed is Vα×∆. If we now assume that the speed of the machine is given by a function of time, V(t), then the total energy consumed during the duration ∆ is calculated by integrating the power over the duration ∆: ∫∆ S(t)αdt (15) [FAD 12]:

Energy (Pr 02)=1*(1)2+6*(1)2+2*(1)2+2*(1)2+7*(1)2+ 2*(1)2=20 joules.

Energy (Pr 05)=5*(1)2+2*(1)2+4*(1)2+6*(1)2+1*(1)2+ 2*(1)2=20 joules.

Energy (Pr 07)=3*(1)2+2*(1)2+2*(1)2+1*(1)2+2*(1)2+ 1*(1)2+6*(1)2+1*(1)2+2*(1)2=20 joules.

Energy (Pr 01)=4.44*(0.9)2+4.44*(0.9)2+5.55*(0.9)2+ 4.44*(0.9)2+2.22*(0.9)2=17.08 joules.

Energy (Pr 04)=1.11*(0.9)2+7.77*(0.9)2+3.33*(0.9)2+ 3.33*(0.9)2+2.22*(0.9)2+ 1.11*(0.9)2=15.28 joules

Energy (Pr 06)=6.66*(0.9)2+1.11*(0.9)2+2.22*(0.9)2+ 2.22*(0.9)2+4.44*(0.9)2+ 4.44*(0.9)2=17.08 joules

Energy (Pr 08)=2.22*(0.9)2+3.33*(0.9)2+2.22*(0.9)2+ 3.33*(0.9)2+2.22*(0.9)2+6.66*(0.9)2=16.18 joules.

Energy (Pr 03)=3.75*(0.8)2+16.25*(0.8)2=12.80 joules.

Energy (Pr 09)=10*(0.8)2+10*(0.8)2=12.80 joules.

Total energy our approach=20+20+20+17.08+15.28+ 17.08+16.18+12.80+12.80= 151.22 joules

Total energy by EDF*.=5+12+6+8+12+15+12+ 10+9+14+ 12+13+8+6+6+2+4+8+3+1=166 joules

Table 3 compares between our work and some pertinent related works. We defined nine comparison criteria that are:

• Level: at what level, load balancing is considered (managed) (RTOS for Real Time Operating System)

• TP: Tasks Periodicity (P: periodic/ A: aperiodic/ S: sporadic/ M: Mix)

• TD: Tasks Dependency (I: independent, D: dependent)

• TC: Temporal Constraints (H: hard, S: soft, F: firm, M: Mix)

• SP: HM: homogeneous, HT: heterogeneous

• EC: Energy consumption reduction

• LB: Load balancing (D: dynamic, S: static)

• UD: Uncertain Data support

Table 3. Comparison between our work and some pertinent related works