Three Processor Allocation Approaches towards EDF Scheduling for Performance Asymmetric Multiprocessors

Abstract

With the rapid development of high-performance computing and parallel computing technology, by virtue of its cost-effectiveness, strong scalability, and easy programming, the multiprocessor system has gradually become the mainstream computing platform. Meanwhile, a growing number of researchers pay attention to the performance of multiprocessor systems, especially the task scheduling problem, which has an important impact on the system performance. Most of the current research works on task scheduling algorithms are based on the homogeneous computing environment. On the contrary, research works focusing on more complex performance asymmetric multiprocessor environments still remain rare. In this paper, we compare the effects of three earliest deadline first algorithms under different processor allocation strategies on performance asymmetric multiprocessors. We propose an efficient schedulability analysis for an allocation strategy that assigns high-priority tasks to the slowest idle processor. Experimental results show that the strategy of allocating processors with optimum speeds for high-priority tasks can schedule more task sets than the other two allocation strategies. The strategy that prioritizes the slowest processors for high-priority tasks has the smallest number of task migrations, and the strategy has the highest effective processor utilization.

1. Introduction

With the continuous increase in people’s requirements for computing power, traditional single-processor systems cannot satisfy the needs of users. Real-time systems are applied on performance asymmetric multiprocessor platforms to meet the high computing needs of users effectively [1]. A performance asymmetric multiprocessor architecture allows the system to allocate computing resources according to demand and make full use of available fast and slow cores to handle dynamic workload demands; hence, it can improve the performance and reduce the power consumption [2]. Moreover, it has shown strong performance advantages in some specific applications, such as smartphones, high-end digital cameras, and other electronic devices [3]. All these high-level products can boost our lives in different aspects. This has also led to the emergence of services such as the Internet of Things, intelligent transportation, and health monitoring, and people’s high computing needs continue to increase. Researchers have conducted a lot of research on this. Irtija et al. proposed an efficient edge computing solution to meet the computing needs of Internet of Things nodes [4]. Experiments show that the number of satisfied users increases by $40\%$ with only a $1\%$ drop in maximum accuracy.

Ensuring the real-time performance of tasks is the most important goal in real-time systems. For real-time systems, optimizing resources and power consumption is important. However, the most important aspect is to ensure the real-time nature of the task. However, current research is still unable to guarantee real-time requirements. This means that the performance asymmetric multiprocessors cannot make full use of the performance in the real-time system [5].

To track this challenge, researchers have proposed some works. The earliest deadline first (EDF) scheduling algorithm was proposed by Liu et al. [6]. It is optimal on a single processor. EDF’s computable schedulability test was demonstrated by Baker et al. on homogeneous multiprocessors [7]. On symmetric multiprocessors, an algorithm that improves the schedulability of non-preemptive tasks was proposed by Lee et al. [8]. For the global EDF, Zhou et al. obtained a more accurate response time analysis method [9]. Jiang et al. improved the schedulability of the DAG task system [10]. Their new approach combines federated scheduling and global EDF.

Now, the field of unmanned vehicle research is very popular, and many large companies have also invested a lot of energy in the research of unmanned vehicles. The Linux kernel is used in many companies’ unmanned vehicle operating systems, such as Tesla’s operating system. The scheduling strategy of the Linux kernel has used scheduling algorithms such as Completely Fair Scheduling (CFS) and EDF. Thus, the study of EDF is very important.

The processor allocation strategy used in previous EDF scheduling algorithms studies on performance asymmetric multiprocessors aims to assign the high-priority tasks to the fastest processors. However, few researchers take the allocation of processors into consideration. To address this issue, we believe that it is possible to assign the high-priority tasks to a suitable or slow-speed processor.

In this paper, we study the different processor allocation strategies of EDF in performance asymmetric multiprocessor platforms. The EDF scheduling algorithm assigns priority according to the deadline of the task, and assigns the processor according to the priority. The fastest speed fit earliest deadline first (FSF-EDF) scheduling algorithm assigns high-priority tasks to the fastest processors. The best speed fit earliest deadline first (BSF-EDF) scheduling algorithm seeks to assign high-priority tasks to the most suitable speed processor. The slowest speed fit earliest deadline first (SSF-EDF) scheduling algorithm seeks to assign high-priority tasks to the slowest speed processor first. Thus, we propose a schedulability test for SSF-EDF. Below are the main contributions of this paper.

• We place three EDF scheduling algorithms with different processor allocation strategies together and propose a novel schedulability test strategy for the SSF-EDF algorithm.
• Extensive experiments are described to fully explore the performance of these three EDF scheduling algorithms.

The rest of this paper is organized as follows. Section 2 illustrates the system model and related definitions. Section 3 describes the schedulability tests for the SSF-EDF. Section 4 compares EDF scheduling algorithms with three different processor allocation strategies. Section 5 draws conclusions about the proposed strategy.

2. System Models and Definitions

2.1. Sporadic Task Systems

Let ${\tau }_i$ denote sporadic real-time tasks. The execution time of ${\tau }_i$ on the slowest processor is denoted as $E_i$. The relative deadline of ${\tau }_i$ is denoted as $D_i$. The minimum interval time between two task requests is denoted as $T_i$. Let the set of n tasks be denoted as $\Lambda =\left({\tau }_1,{\tau }_2,{\tau }_3,\dots ,{\tau }_n\right)$. If the task satisfies the conditions of $E_i\le D_i\le T_i$, then $\Lambda$ is considered a restricted set. The $jth$ job of task ${\tau }_i$ is denoted as ${\tau }_{i,j}$, and its arrival time is denoted as $A_{i,j}$.

Note that an understanding of the relationship between the execution time and processor speed is critical. The worst execution time $E_i$ is the execution time required by ${\tau }_i$ on the processor with speed $s_1$, which is a fixed value. Since we conduct research on performance asymmetric multiprocessor platforms, different processors do not have the same speed. Processors with different speeds perform differently at the same time. Therefore, the actual execution time required by ${\tau }_i$ on different processors is not the same. In the following, we need to take into account the effect of processor speed when calculating the execution time.

The processor utilization of task ${\tau }_i$ is defined as $U_i=E_i/T_i$. $U_{max}(\Lambda )$ represents the maximum utilization among all tasks:

$$\begin{array}{c}\hfill U_{max}(\Lambda )=\underset{{\tau }_i\in \Lambda }{max}\left(U_i\right).\end{array}$$

(1)

The density of task ${\tau }_i$ is defined as ${\delta }_i=E_i/D_i$. ${\delta }_{max}(\Lambda )$ represents the maximum density among all tasks:

$$\begin{array}{c}\hfill {\delta }_{max}(\Lambda )=\underset{{\tau }_i\in \Lambda }{max}\left({\delta }_i\right).\end{array}$$

(2)

$\mathrm{DBF}\left({\tau }_i,\Delta t\right)$ is used to represent the upper limit of the maximum cumulative processing time required for task ${\tau }_i$’s job to arrive at and within a time interval of length $\Delta t$. Among them, the size of $\Delta t$ can be arbitrary. This has been proven by Baruah [11]:

$$\mathrm{DBF}\left({\tau }_i,\Delta t\right)\stackrel{\mathrm{def}}{=}max\left(0,\left(⌊\frac{\Delta t-D_i}{T_i}⌋+1\right)E_i\right).$$

(3)

The load parameters based on the DBF function are defined as follows [12]:

$$\mathrm{LOAD}(\Lambda )\stackrel{\mathrm{def}}{=}\underset{\Delta t>0}{max}\left(\frac{{\sum }_{{\tau }_i\in \Lambda }\mathrm{DBF}\left({\tau }_i,\Delta t\right)}{\Delta t}\right).$$

(4)

2.2. Performance Asymmetric Multiprocessor Platform

Let $\pi =\left(p_1,p_2,p_3,\dots ,p_m\right)$ be a performance asymmetric multiprocessor platform. The processing speed of the processors increases from small to large; that is, the processing speed of $p_i$ is equal to or slower than that of $p_{i+1}$. The processor speed of the processor is denoted by $s_i$. For ease of understanding, the slowest processor speed is set to 1, which is $s_1=1$. The other, faster processors $p_i$ are multiples of $p_1$, such as $s_i=3$. The sum of the speeds of the first k processors in $\pi$ is denoted as $S_k$, i.e.,

$$S_k\left(\pi \right)\stackrel{\mathrm{def}}{=}\sum _{i=1}^k{s}_i.$$

(5)

The “lambda” parameter was defined by Funk et al. in their research on a uniform multiprocessor [13,14]:

$$\lambda \left(\pi \right)\stackrel{\mathrm{def}}{=}\underset{1\le i<m}{max}\frac{{\sum }_{j=i+1}^m{s}_j}{s_i}.$$

(6)

The value range of $\lambda$ is $\left(0,m-1\right]$. When all processors are the same, $\lambda$ takes the maximum value $(m-1)$.

The main symbols used in this article and their meanings are summarized in

Table 1. The symbols.

Notation	Meaning
$\Lambda$	Set of tasks
$\pi$	Asymmetric multiprocessor platform
${\tau }_i$	Task $i\in \Lambda$
${\tau }_{i,j}$	The $j_{th}$ job of task ${\tau }_i$
$E_i$	Worst-case execution time of ${\tau }_i$
$D_i$	Relative deadline of ${\tau }_i$
$T_i$	Period of ${\tau }_i$
$p_i$	$i_{th}$ processor
$s_i$	Speed of the $i_{th}$ processor
$S_k$	Sum of the first k processor speeds
$U_i$	Utilization of ${\tau }_i$
${\delta }_i$	Density of ${\tau }_i$
$W(t_p,t_q)$	The total amount of work done within $\left[t_p,t_q\right)$
$Q(t_p,t_q)$	The total amount of time required in $\left[t_p,t_q\right)$
$J_v$	The time at which v processors are executing
$\beta$	The number of carry-in jobs

.

2.3. SSF-EDF Scheduling

SSF-EDF assigns high priority to tasks with early deadlines. We also chose a global scheduling strategy. We establish a global ready task queue and extract tasks for scheduling according to demand. Our algorithm allows the preemption of tasks and allows tasks to be migrated between processors of different speeds. In reality, this migration introduces additional overhead. We measure this overhead by considering the number of task migrations in our experiments. The time complexity of the SSF-EDF scheduling algorithm is O(mn), where n is the number of tasks and m is the number of processors. According to the time complexity, it can be seen that SSF-EDF is used in real-time systems.

The SSF-EDF scheduling algorithm operates on a performance asymmetric multiprocessor as follows: (1) when there is an active job waiting to be executed, no processor is idle; (2) fast processors are idled when the number of processors is greater than the number of active jobs; (3) we execute higher-priority jobs on slower processors.

A given set of sporadic tasks is SSF-EDF schedulable if SSF-EDF scheduling is able to meet the deadlines of all jobs for the given set of sporadic tasks on a given platform. We will derive a schedulability test for SSF-EDF in Section 3. This can guarantee the schedulability of SSF-EDF.

Example 1. 

Figure 1 is an example of SSF-EDF on the performance asymmetric multiprocessors. Task ${\tau }_i$ is represented by a triple $\left(E_i,D_i,T_i\right)$. Consider $\pi =\left(1,1.5\right)$ and $\Lambda =\{{\tau }_1(1.5,1.5,1.5),$${\tau }_2(6,6,6),{\tau }_3(3,6,6)\}$. Different colors indicate different tasks. First, ${\tau }_{1,1}$ obtains the highest priority, ${\tau }_{1,1}$ executes on the slowest processor $p_1$, and ${\tau }_{2,1}$ executes on $p_2$. At $t=1.5$, job ${\tau }_{1,1}$ is done. However, ${\tau }_{1,2}$ makes another request, which is still executed on $p_1$. Up to time $t=4$, job ${\tau }_{2,1}$ is done. Since ${\tau }_{3,1}$ does not have a higher priority than ${\tau }_{1,3}$, ${\tau }_{3,1}$ is assigned to processor $p_2$ for execution until the $t=6$ job is done. It is easy to see that under the framework of SSF-EDF, all tasks will meet their deadlines and the processor will reach $100\%$ utilization.

3. SSF-EDF Schedulability Analysis

We derive a schedulability test for SSF-EDF scheduling. Our derivation process follows the following idea: under SSF-EDF scheduling, the necessary conditions for task missed deadlines are derived. In negating this condition, the sufficient schedulability condition is obtained.

Suppose that job ${\tau }_{i,j}$ of task ${\tau }_i$ first misses the deadline at $A_{i,j}+D_i$ (see Figure 2). Under SSF-EDF scheduling, jobs with late deadlines will not affect jobs with early deadlines. Therefore, we give up the legitimate job sequence whose deadline is later than $A_{i,j}+D_i$, and only consider the SSF-EDF scheduling of the job request of the remaining legitimate sequence. Thus, ${\tau }_i$ missed deadline occurs at time $A_{i,j}+D_i$ (which is the earliest task missed deadline to occur).

For a given task set $\Lambda$, let $Q\left(t_p,t_q\right)$ be the amount of processor time required within $\left[t_p,t_q\right)$, and let $W\left(t_p,t_q\right)$ be the amount of work done in $\left[t_p,t_q\right)$.

Our derivation process has the following three steps: (1) to derive the lower bound of $Q\left(t_0,A_{i,j}+D_i\right)$ in $\left[t_0,A_{i,j}+D_i\right)$, (2) to derive the upper bound of $Q\left(t_0,A_{i,j}+D_i\right)$ in $\left[t_0,A_{i,j}+D_i\right)$, (3) combining (1) and (2) yields the necessary condition. $t_0$ in the figure is a special time point, which we will explain later.

3.1. Lower Bound

Consider that ${\tau }_{i,j}$ first misses the deadline at $A_{i,j}+D_i$. Assume that under SSF-EDF scheduling, there are exactly v processors in $\left[A_{i,j},A_{i,j}+D_i\right)$ whose execution time is denoted by $J_v$, $0\le v\le m$. For example, $J_1$ represents the time at which only one processor is executing, and $J_2$ represents the time at which two processors are executing. Please note that the value of $J_0$ is not necessarily zero, because there are situations where all processors are idle. However, this work has already assumed that ${\tau }_{i,j}$ missed the deadline. Thus, within $\left[A_{i,j},A_{i,j}+D_i\right)$, at least one processor will be processing ${\tau }_{i,j}$. In this case, the value of $J_0$ must be zero.

Above, we have mentioned the need to consider the effects of processors of different speeds. Let the execution time $J_v$ of the v processors being executed be multiplied by the sum $S_v$ of the speeds of these processors. We have obtained the actual workload performed by v processors through $J_v{S}_v$. For example, there are two tasks assigned to the processors $s_1=1$ and $s_2=2$, respectively. Let the execution time $J_2=t$, and then the actual workload is $3t$. Then, we can write

$$W\left(A_{i,j},A_{i,j}+D_i\right)=\sum _{v=1}^m{S}_v{J}_v.$$

(7)

Because of ${\sum }_{v=1}^m{S}_v{J}_v=S_m{J}_m+{\sum }_{v=1}^{m-1}{S}_v{J}_v$ and $S_m{J}_m=S_m\left(D_i-{\sum }_{v=1}^{m-1}{J}_v\right)$, we obtain

$$\begin{array}{cc}\hfill W\left(A_{i,j},A_{i,j}+D_i\right)& =S_m{D}_i-\sum _{v=1}^{m-1}\left(S_m{J}_v-S_v{J}_v\right)\hfill \\ \hfill & =S_m{D}_i-\sum _{v=1}^{m-1}\frac{S_m-S_v}{s_1}{s}_1{J}_v.\hfill \end{array}$$

(8)

As defined by $\lambda \left(\pi \right)$ in Section 2.2, when $1\le v\le m-1$, it is obvious that

$$\lambda \left(\pi \right)\ge \frac{S_m-S_v}{s_1}.$$

(9)

From (8) and (9) above, we can draw a conclusion

$$W\left(A_{i,j},A_{i,j}+D_i\right)\ge S_m{D}_i-\lambda \left(\pi \right)\sum _{v=1}^{m-1}{s}_1{J}_v.$$

(10)

Due to the nature of SSF-EDF, except when all processors are busy, during time interval $\left[A_{i,j},A_{i,j}+D_i\right)$, ${\tau }_{i,j}$ will be assigned to a processor with speed $s_i$, $s_i\ge s_1$. Then, the worst execution time $E_i\ge {\sum }_{v=1}^{m-1}{s}_1{J}_v$ of ${\tau }_{i,j}$. Moreover, since ${\tau }_{i,j}$ missed the deadline, it cannot receive more execution time than $E_i$; otherwise, ${\tau }_{i,j}$ can finish before the deadline, which contradicts the previous assumption. Therefore, we obtain

$$E_i>\sum _{v=1}^{m-1}{s}_1{J}_v.$$

(11)

Combining (10) and (11) gives

$$\begin{array}{cc}\hfill W\left(A_{i,j},A_{i,j}+D_i\right)& >S_m{D}_i-\lambda \left(\pi \right)E_i,\hfill \\ \hfill \frac{W\left(A_{i,j},A_{i,j}+D_i\right)}{D_i}& >S_m-\lambda \left(\pi \right){\delta }_i,\hfill \\ \hfill \frac{W\left(A_{i,j},A_{i,j}+D_i\right)}{D_i}& >S_m-\lambda \left(\pi \right){\delta }_{max}(\Lambda ).\hfill \end{array}$$

(12)

Let

$$\mu =S_m-\lambda \left(\pi \right){\delta }_{max}(\Lambda ).$$

(13)

From (12) and (13), it follows that

$$W\left(A_{i,j},A_{i,j}+D_i\right)>\mu D_i.$$

(14)

We can find many time points t that satisfy condition $t_0\le A_{i,j}$. $t_0$ is the earliest one among all time points t that satisfy the condition. At $t_0$, $W\left(A_{i,j},A_{i,j}+D_i\right)>\mu \left(A_{i,j}+D_i-A_{i,j}\right)$ still holds. This leads to $W\left(t_0,A_{i,j}+D_i\right)>\mu \left(A_{i,j}+D_i-t_0\right)$. Hence, the lower bound of $Q\left(t_0,A_{i,j}+D_i\right)$ has been deduced. Let $\Delta =A_{i,j}+D_i-t_0$. Then, we obtain

$$W\left(t_0,A_{i,j}+D_i\right)>\mu \Delta .$$

(15)

According to the previous assumption, job ${\tau }_{i,j}$ misses the deadline $A_{i,j}+D_i$. That is, the total workload W is less than or equal to the time requirement Q. It can be concluded

$$Q\left(t_0,A_{i,j}+D_i\right)\ge W\left(t_0,A_{i,j}+D_i\right)>\mu \Delta .$$

(16)

Now, we find that the lower bound of $Q\left(t_0,A_{i,j}+D_i\right)$ is $\mu \Delta$.

3.2. Upper Bound

Before derivation, we need to classify the job. Carry-in jobs are jobs that arrive before $t_0$ and are not completed before $t_0$. The total processor time requirement caused by these jobs is denoted by $R_c$. Other jobs are regular jobs. The total processor time requirement caused by this job is denoted by $R_c$. The sum of these two time demands is the $Q\left(t_0,A_{i,j}+D_i\right)$ that we need.

The study of Baruah et al. shows that $\Delta \times \mathrm{LOAD}(\Lambda )$ can calculate the upper bound of $R_r$ [11,12]. LOAD and DBF are defined as follows:

$$\begin{array}{cc}\hfill \mathrm{DBF}\left({\tau }_i,\Delta t\right)\stackrel{\mathrm{def}}{=}max& \left(0,\left(⌊\frac{\Delta t-D_i}{T_i}⌋+1\right)E_i\right),\hfill \\ \hfill \mathrm{LOAD}(\Lambda )\stackrel{\mathrm{def}}{=}\underset{\Delta t>0}{max}& \left(\frac{{\sum }_{{\tau }_i\in \Lambda }\mathrm{DBF}\left({\tau }_i,\Delta t\right)}{\Delta t}\right).\hfill \end{array}$$

(17)

Let us calculate the upper bound of $R_c$ again.

Lemma 1. 

The remaining execution requirement at time $t_0$ for any carry-in job is lower than $\Delta {\delta }_{max}(\Lambda )$.

Proof. 

Let us analyze the carry-in job ${\tau }_{p,q}$ whose arrival time is $A_{p,q}<t_0$ and whose execution is not completed at time $t_0$ (see Figure 2). Let ${\phi }_{p,q}=t_0-A_{p,q}$. Let $E_{p,q}^{\prime }$ be the execution time of ${\tau }_{p,q}$ within time interval $\left[A_{p,q},t_0\right)$. $J_v$ continues to use the same definition as in Section 3.1. $W\left(A_{p,q},t_0\right)$ can be calculated from $S_m{\phi }_{p,q}-{\sum }_{v=1}^{m-1}\left(S_m{J}_v-S_v{J}_v\right)$. Since job ${\tau }_{p,q}$ did not complete execution at time $t_0$, we can conclude

$$E_{p,q}^{\prime }>S_m{\phi }_{p,q}-\sum _{v=1}^{m-1}\left(S_m{J}_v-S_v{J}_v\right).$$

(18)

Since $W\left(A_{p,q},t_0\right)=W\left(A_{p,q},A_{i,j}+D_i\right)-W\left(t_0,A_{i,j}+D_i\right)$, there is

$$W\left(A_{p,q},A_{i,j}+D_i\right)-W\left(t_0,A_{i,j}+D_i\right)=E_{p,q}^{\prime }.$$

(19)

It is given by (18) and (19)

$$W\left(A_{p,q},A_{i,j}+D_i\right)-W\left(t_0,A_{i,j}+D_i\right)>S_m{\phi }_{p,q}-\sum _{v=1}^{m-1}\left(S_m{J}_v-S_v{J}_v\right).$$

(20)

According to the definition of $t_0$ (see (15)), it must satisfy

$$W\left(t_0,A_{i,j}+D_i\right)>\mu \Delta .$$

(21)

Since $t_0$ is the earliest time t satisfying such conditions, any time t before $t_0$ does not satisfy the above formula, i.e.,

$$W\left(A_{p,q},A_{i,j}+D_i\right)\le \mu (\Delta +{\phi }_{p,q}).$$

(22)

We immediately have

$$\mu (\Delta +{\phi }_{p,q})-\mu \Delta >W\left(A_{p,q},A_{i,j}+D_i\right)-W\left(t_0,A_{i,j}+D_i\right).$$

(23)

This is given by (20) and (23)

$$\begin{array}{cc}\hfill \mu (\Delta +{\phi }_{p,q})-\mu \Delta & >S_m{\phi }_{p,q}-\sum _{v=1}^{m-1}\left(S_m{J}_v-S_v{J}_v\right),\hfill \\ \hfill \mu {\phi }_{p,q}& >S_m{\phi }_{p,q}-\sum _{v=1}^{m-1}\frac{S_m-S_v}{s_1}{s}_1{J}_v.\hfill \end{array}$$

(24)

By combining (6), we have

$$\mu {\phi }_{p,q}>S_m{\phi }_{p,q}-\lambda \left(\pi \right)\sum _{v=1}^{m-1}{s}_1{J}_v.$$

(25)

With the exception of the case wherein all processors are busy, the carry-in job ${\tau }_{p,q}$ must be executed on one of the processors. Since ${\tau }_{p,q}$ is not completed before $t_0$, the worst execution time of ${\tau }_{p,q}$ is not less than the execution time in $\left[A_{p,q},t_0\right)$. Among them, the execution time of ${\tau }_{p,q}$ in $\left[A_{p,q},t_0\right)$ is at least ${\sum }_{v=1}^{m-1}{s}_1{J}_v$. Thus, we have

$$E_{p,q}^{\prime }\ge \sum _{v=1}^{m-1}{s}_1{J}_v.$$

(26)

It is given by (25) and (26) that

$$\mu {\phi }_{p,q}>S_m{\phi }_{p,q}-\lambda \left(\pi \right)E_{p,q}^{\prime }.$$

(27)

It is also given by (13) and (27) that

$$\begin{array}{cc}\hfill (S_m-\lambda \left(\pi \right){\delta }_{max}(\Lambda )){\phi }_{p,q}& >S_m{\phi }_{p,q}-\lambda \left(\pi \right)E_{p,q}^{\prime },\hfill \\ \hfill {E^{\prime }}_{p,q}& >{\delta }_{max}(\Lambda ){\phi }_{p,q}.\hfill \end{array}$$

(28)

Since $E_{p,q}=D_p{\delta }_p$, there is

$$E_{p,q}-E_{p,q}^{\prime }<D_p{\delta }_p-{\delta }_{max}(\Lambda ){\phi }_{p,q}.$$

(29)

Because ${\tau }_{p,q}$ missed the deadline at $A_{i,j}+D_i$, ${\tau }_{p,q}$’s absolute deadline is no greater than $A_{i,j}+D_i$. We can write $D_p-{\phi }_{p,q}\le \Delta$. Thus, we have

$$\begin{array}{cc}\hfill E_{p,q}-E_{p,q}^{\prime }& <D_p{\delta }_p-{\delta }_{max}(\Lambda ){\phi }_{p,q},\hfill \\ \hfill E_{p,q}-E_{p,q}^{\prime }& <D_p{\delta }_{max}(\Lambda )-{\delta }_{max}(\Lambda ){\phi }_{p,q},\hfill \\ \hfill E_{p,q}-E_{p,q}^{\prime }& <(D_p-{\phi }_{p,q}){\delta }_{max}(\Lambda ),\hfill \\ \hfill E_{p,q}-E_{p,q}^{\prime }& <\Delta {\delta }_{max}(\Lambda ).\hfill \end{array}$$

(30)

□

Therefore, any carry-in job ${\tau }_{p,q}$ contributes no more to $R_c$ than $\Delta {\delta }_{max}(\Lambda )$.

Lemma 2. 

The number of carry-in jobs depends on

$$\beta =max\left\{\omega :S_{\omega }<\mu \right\}.$$

(31)

Proof. 

Suppose that an arbitrarily small positive number is represented by $ϵ$, as shown by (21) and (22),

$$\begin{array}{cc}\hfill W\left(t_0,A_{i,j}+D_i\right)& >\mu \Delta ,\hfill \\ \hfill W\left(t_0-ϵ,A_{i,j}+D_i\right)& \le \mu (\Delta +ϵ),\hfill \\ \hfill W\left(t_0-ϵ,A_{i,j}+D_i\right)-W\left(t_0,A_{i,j}+D_i\right)& <\mu ϵ.\hfill \end{array}$$

(32)

Infer $\mu \le S_m$ from the definition of $\mu$. Thus, we obtain the conclusion of $W\left(t_0-ϵ,t_0\right)<ϵS_m$. Therefore, some processors are idle during $\left[t_0-ϵ,t_0\right)$. All the carry-in jobs are being executed. Thus, the number of carry-in jobs does not exceed $\beta$. □

Consequently, the upper bound of $R_c$ is $\beta \Delta {\delta }_{max}(\Lambda )$.

Therefore, the upper bound of $Q\left(t_0,A_{i,j}+D_i\right)$ can be expressed as

$$Q\left(t_0,A_{i,j}+D_i\right)\le \mathrm{LOAD}(\Lambda )\Delta +\beta \Delta {\delta }_{max}(\Lambda ).$$

(33)

3.3. SSF-EDF Schedulability Test

Theorem 1. 

Sporadic task set Λ is SSF-EDF schedulable on a performance asymmetric multiprocessor platform π, provided that

$$\mathrm{LOAD}(\Lambda )\le \mu -\beta {\delta }_{max}(\Lambda ),$$

(34)

where μ and β are defined in (13) and (31), respectively.

Proof. 

A sufficient condition for SSF-EDF schedulability arises by negating the necessary condition for ${\tau }_{i,j}$ missing the deadline.

From the previous discussion, the bounds for $Q\left(t_0,A_{i,j}+D_i\right)$ are as follows:

$$\begin{array}{cc}\hfill Q\left(t_0,A_{i,j}+D_i\right)& >\mu \Delta ,\hfill \\ \hfill Q\left(t_0,A_{i,j}+D_i\right)& \le \mathrm{LOAD}(\Lambda )\Delta +\beta \Delta {\delta }_{max}(\Lambda ).\hfill \end{array}$$

(35)

From this, the necessary conditions for ${\tau }_{i,j}$ to miss the deadline are as follows:

$$\begin{array}{cc}\hfill \mathrm{LOAD}(\Lambda )\Delta +\beta {\delta }_{max}(\Lambda )\Delta & >\mu \Delta ,\hfill \\ \hfill \mathrm{LOAD}(\Lambda )& >\mu -\beta {\delta }_{max}(\Lambda ).\hfill \end{array}$$

(36)

Therefore, negation of (36) gives

$$\mathrm{LOAD}(\Lambda )\le \mu -\beta {\delta }_{max}(\Lambda ).$$

(37)

This is Theorem 1. □

4. Experimental Evaluation

In this section, we implement several schedulability tests and compare their performance through extensive simulations. In the first set of experiments, we demonstrate that BSF-EDF has the best schedulability. Then, we further verify that BSF-EDF schedules more task sets than the other two processor assignment strategies. Then, we find that as the proportion of fast processors increases, so does the proportion of the task set that the algorithm can schedule. We also compare the number of task migrations and effective processor utilization (EPU), where SSF-EDF performs best.

We randomly generate various parameters on a performance asymmetric multiprocessor platform $\pi$. The total number m of processors is randomly selected from a range of $\left[1,10\right]$. While satisfying $q\le m$, the number q of the slowest processors is also selected from the same range. The speed of the processor is randomly generated within $\left[1,10\right]$.

Table 2. Task parameters.

Parameter	Parameter Range
$T_i$	$10\le T_i\le 100$
$D_i$	$D_i=T_i$
$E_i$	$0\le E_i\le 50$ and $E_i\le D_i$

is the parameter range for each task. We generated $10,000$ task sets, and each task set contained $2(m+1)$ tasks.

Figure 3 shows that BSF-EDF performs better than FSF-EDF and SSF-EDF on four-core performance asymmetric multiprocessors. The results show that the schedulability of BSF-EDF is the highest for different system utilization cases. The X-axis represents the system utilization rate, and the system utilization rate is defined as $U_{sum}/S_m$. When the system utilization rate reaches 40–50%, the task set that can be scheduled by the three processor allocation strategies begins to decrease. When the system utilization reaches 80–90%, BSF-EDF can still schedule up to $93\%$ task sets, while the other two processor allocation strategies can only schedule $81.4\%$ and $75.1\%$ task sets. After this, the proportion that the algorithm can schedule decreases rapidly. When the system utilization reaches 90–100%, the three processor allocation strategies can only schedule $8.9\%$, $0\%$, and $0\%$ task sets.

Figure 4 shows the experimental results on seven-core performance asymmetric multiprocessors. When the system utilization is low, the three algorithms perform well. BSF-EDF performs better than the other two processor allocation strategies at high system utilization. When the system utilization reaches 80–90%, the BSF-EDF can schedule up to $88.9\%$ of the task set, which is lower than the performance on four-core processors. However, it still schedules $10.5\%$ and $20.8\%$ more task sets than the other two processor allocation strategies. When the system utilization reaches 90–100%, the three processor allocation strategies can only schedule $8.7\%$, $0\%$, and $0\%$ task sets.

When $m=10$, the experiment further verifies the leading position of BSF-EDF. In Figure 5, BSF-EDF outperforms the other two processor allocation strategies at high system utilization. When the system utilization reaches 80–90%, the BSF-EDF can schedule $82.6\%$ of the task set, which is lower than the performance on seven-core processors. However, it still schedules $9.8\%$ and $29.5\%$ more task sets than the other two processor allocation strategies. When the system utilization reaches 90–100%, the three processor allocation strategies can only schedule $8.3\%$, $0\%$, and $0\%$ task sets.

In the first set of simulation experiments, we did not limit the number of high-utilization tasks in the task set, and the data were generated randomly. Now, we limit the proportion of high-utilization tasks in the task set, in which we define high-utilization tasks as a utilization rate of 80–100%. When the proportion of high-utilization tasks is high, the range of system utilization is bound to be limited by its definition. It is difficult to compare the performance of the three different processor allocation strategies under different system utilization values. Therefore, we choose $30\%$ of high-utilization tasks to conduct experiments on 10-core performance asymmetric multiprocessors. In Figure 6, the performance of the three different processor allocation strategies is again degraded, but BSF-EDF still schedules more task sets than the other two processor allocation strategies. When the system utilization reaches 80–90%, the three processor allocation strategies can only schedule $73.8\%$, $34.2\%$, and $20.9\%$ task sets. When the system utilization reaches 90–100%, the three processor allocation strategies can only schedule $6.1\%$, $0.9\%$, and $0\%$ task sets.

We compare the three processor allocation strategies by modifying the proportion of fast processors on a 10-core performance asymmetric multiprocessor. In Figure 7, with the increasing proportion of fast processors, the schedulable task set ratio of the three processor allocation strategies also increases, among which BSF-EDF increases the fastest. When the fast processor ratio reaches $100\%$, all processors are at the same speed. In this case, the scheduling process of the three different processor allocation strategies is not different, so the three algorithms can schedule $99.9\%$ of the task set.

Since we allow the preemption of tasks, it is important to consider the overhead of task migration. We measure this overhead by the number of task migrations. We conduct experiments on a 10-core performance asymmetric multiprocessor. In Figure 8, the number of migrations of SSF-EDF is the least for different system utilization cases. BSF-EDF has the most migrations when the system utilization is low. When the system utilization exceeds 70–80%, FSF-EDF has the most migrations.

Effective processor utilization (EPU) is defined as $EPU={\sum }_{i\in \Lambda }^{}{V}_i/P$ [15]. If the job is completed within its deadline, the value of V is equal to the execution time of the job; if the job misses the deadline, $V=0$. $\Lambda$ is the set of tasks that the processor executes. P is the total time of execution. The level of EPU reflects the level of effective utilization of the processor by the scheduling algorithm. In Figure 9, for different system utilization rates, the EPU of SSF-EDF is the highest. This means that SSF-EDF is more efficient for processor utilization.

5. Conclusions

We first obtain the schedulability test of SSF-EDF. Then, we study three different processor allocation strategies of the EDF scheduling algorithm on the performance asymmetric multiprocessor platform. The experiments show that BSF-EDF can schedule more task sets than the other two processor allocation strategies. SSF-EDF has the lowest number of task migrations, indicating that it has less preemption latency. SSF-EDF has the highest effective processor utilization, indicating that it utilizes the processor more efficiently.

The design of the best scheduling strategy for performance asymmetric multiprocessors still remains unsolved and is an important research problem. In this paper, inspired by the global EDF scheduling strategy, we select the best or slowest processor for EDF scheduling [16]. The purpose of this consideration is to reserve fast processors for later tasks. This provides an opportunity to improve schedulability. The simulation results illustrate that the idea of reserving fast processors with a certain strategy for subsequent tasks is useful, which is what BSF-EDF achieves. Specifically, it rationally allocates the current task according to its need for resources. In this way, the processor resources can be fully utilized while the on-time completion of the current task is guaranteed. Thus, BSF-EDF can schedule the most task sets. The number of schedulable task sets of SSF-EDF is less than that of BSF-EDF. However, SSF-EDF has the smallest number of task migrations and the highest effective processor utilization.