Energy-Aware Scheduling of Task Graphs with Imprecise Computations and End-to-End Deadlines

TL;DR

This paper introduces an energy-aware scheduling method for task graphs with imprecise computations, optimizing quality of service within deadlines and energy limits, validated by MILP and experiments on multiprocessor platforms.

Contribution

It proposes a novel scheduling approach that accounts for imprecise inputs and provides optimal solutions via MILP for energy-efficient task graph management.

Findings

Feasible schedules can use less than 50% of the minimum energy for precise execution.

The method effectively balances energy consumption and output quality.

Experimental results validate the approach on randomly generated task graphs.

Abstract

Imprecise computations provide an avenue for scheduling algorithms developed for energy-constrained computing devices by trading off output quality with the utilization of system resources. This work proposes a method for scheduling task graphs with potentially imprecise computations, with the goal of maximizing the quality of service subject to a hard deadline and an energy bound. Furthermore, for evaluating the efficacy of the proposed method, a mixed integer linear program formulation of the problem, which provides the optimal reference scheduling solutions, is also presented. The effect of potentially imprecise inputs of tasks on their output quality is taken into account in the proposed method. Both the proposed method and MILP formulation target multiprocessor platforms. Experiments are run on 10 randomly generated task graphs. Based on the obtained results, for some cases, a feasible schedule of a task graph can be achieved with the energy consumption less than 50% of the minimum energy required for scheduling all tasks in that task graph completely precisely.

Figures

Equations

$$M_u^{\prime }=M_u+M_u^x.$$

$$M_u^x=m_u\times E_u^i,$$

$$E_u^i=\min \{1,\sum _{j\in par(u)}{E}_j^o\},$$

$$E_j^o=\frac{O_j-o_j}{O_j}=1-\frac{o_j}{O_j},0\le E_j^o\le 1.$$

$$W_u=M_u^{\prime }+o_u.$$

$$\rho =\alpha f^{\beta }+\gamma f+\delta ,$$

$${ϵ}_{cycle}=\alpha f^{\beta -1}+\gamma +\frac{\delta }{f}.$$

$$QoS=\frac{{\sum }_{u\in exit(G)}{P}_u}{|exit(G)|},0\le QoS\le 1,$$

$$P_u=P_u^T+(1-P_u^T)(\frac{o_u}{O_u}),$$

$$\left[\sum _{\text{for u ∈ non-exit tasks}}{W}_u\right]+\left[\sum _{\text{for v ∈ exit tasks}}{M}_v^{\prime }\right].$$

$$[M_p^{\prime }+o_p]+[\sum _{i=1}^b{M}_i+\sum _{i=1}^b{m}_i\times (1-\frac{o_p}{O_p})],$$

$$[M_p^{\prime }+\sum _{i=1}^b(M_i+m_i)]+[o_p\times (1-\frac{{\sum }_{i=1}^b{m}_i}{O_p})].$$

$$\begin{array}{rl}& [\sum _{i=1}^b(M_i^{\prime }+o_i)]+\\ & [M_c+m_c\times min\left(1,\sum _{i=1}^b(1-\frac{o_i}{O_i})\right)],\end{array}$$

$$\begin{array}{rl}& [\sum _{i=1}^b{M}_i^{\prime }+M_c]+\\ & [\sum _{i=1}^b{o}_i+m_c\times min\left(1,\sum _{i=1}^b(1-\frac{o_i}{O_i})\right)].\end{array}$$

$$W_u^{imp\_label}=M_u^{\prime imp\_label}+o_u^{imp\_label}.$$

$$D_u=\sum _{i=1}^m\frac{N_{u,i}}{f_i},N_{u,i}\ge 0$$

$$\sum _{i=1}^m{N}_{u,i}=W_u^{imp\_label}.$$

$$M_u^{\prime imp\_label}\le \sum _{i=1}^m{N}_{u,i}\le M_u^{\prime imp\_label}+O_u.$$

$${ϵ}_{task}(u)=\sum _{i=1}^m(N_{u,i}.(\alpha f_i^{\beta -1}+\gamma +\frac{\delta }{f_i})).$$

$$\sum _{u=1}^n{ϵ}_{task}(u)\le {ϵ}_{max}.$$

$$S_u+D_u\le T_d,u=1,2,...,n,S_u\ge 0,$$

$$S_u+D_u+\overline{C_{u,v}}\le S_v,\forall e(u,v)\in E.$$

$$\begin{array}{rl}{S}_u+D_u\le S_v,& \text{For tasks u and v which are}\\ & \text{assigned to the same processor}\\ & \text{and task v is the immediate task}\\ & \text{after task u based on HEFT}\end{array}$$

$$\Pi_{k,u}=\left\{\begin{array}[]{cc}1&\hskip 14.22636pt\textrm{if task u is assigned to processor k}\\ 0&\hskip 14.22636pt\textrm{otherwise}\\ \end{array}\right..$$

$$\sum _{k=1}^K{\Pi }_{k,u}=1,\text{for }u=1,2,...,n.$$

$$Y_{k,u,v}=\left\{\begin{array}[]{ll}1&\hskip 2.84526pt\textrm{if task u is scheduled immediately}\\ &\hskip 2.84526pt\textrm{ before task v on processor k}\\ &\\ 0&\hskip 2.84526pt\textrm{otherwise}\\ \end{array}\right..$$

$$\sum _{\begin{array}{c}v=1\\ v\ne u\end{array}}^{n+1}{Y}_{k,u,v}={\Pi }_{k,u},\text{for }u=0,1,...,n$$

$$\sum _{\begin{array}{c}u=0\\ u\ne v\end{array}}^n{Y}_{k,u,v}={\Pi }_{k,v},\text{for }v=1,2,...,n+1.$$

$$\begin{array}{r}{S}_u+D_u-(1-Y_{k,u,v})\times T_d\le S_v,\\ \text{for }u=1,2,...,n,\\ \text{for }v=1,2,...,n,v\ne u,\\ \text{for }k=1,2,...,K.\end{array}$$

$$M_u+m_u\times E_u^i\le \sum _{i=1}^m{N}_{u,i}\le M_u+m_u\times E_u^i+O_u,$$

Full text

Task Scheduling, Imprecise Computations, Real-time MPSoCs, Input Error

††journalyear: 2018††copyright: acmlicensed††conference: Woodstock ’18: ACM Symposium on Neural Gaze Detection; June 03–05, 2018; Woodstock, NY††booktitle: Woodstock ’18: ACM Symposium on Neural Gaze Detection, June 03–05, 2018, Woodstock, NY††price: 15.00††doi: 10.1145/1122445.1122456††isbn: 978-1-4503-9999-9/18/06

1. Introduction

In many real-time applications, it is often preferred for a task to produce an approximate (aka imprecise) result by its deadline rather than producing an exact (aka precise) result late (ASPDAC2008, ). Imprecise computations increase the flexibility of scheduling algorithms developed for real-time systems by allowing them to trade off output quality with utilization of system resources, such as processor cycles.

In imprecise computations, a real-time task is allowed to return intermediate and imprecise results of poorer quality as long as it processes a predefined chunk of work that defines its baseline quality. The number of processor cycles required for the task to provide this baseline quality is referred to as the mandatory workload of the task. Assigning a larger number of processor cycles to a task beyond its mandatory workload leads to an increase in its quality of results. In other words, output quality of each task is a monotonic non-decreasing function of processor cycles assigned to it (Greece2010, ).

The workload of a task beyond its mandatory workload is referred to as the optional workload, which can be executed partially. The quality of service (QoS) is usually evaluated as a linear or concave function of the number of processor cycles assigned to optional workload of tasks (Greece2010, ). When the full workload of a task, both mandatory and optional, is entirely completed, the produced results by that task are considered precise.

Furthermore, an energy consumption budget may also be one of the main design constraints for energy-constrained computing devices such as embedded systems. Some of the prior work have focused on scheduling task graphs with imprecise computations and energy and deadline constraints on single processor platforms (vlsi2006, ; ASPDAC2008, ) and multiprocessor platforms (DATE2017, ; CSE2013, ). In the said prior work, the effect of potentially imprecise inputs of tasks on the their output quality is not considered, and thus QoS can be obtained solely based on the number of processor cycles assigned to optional workload. However, in many real-time applications such as video compression or speech recognition (1997, ) where tasks are interdependent, there is a set of dependent tasks represented by a task graph. Therefore, the input to a task can be dependent on the output of one or more other tasks which may have imprecise results. In the literature, the effect of imprecise input of a task is usually modeled with an extension in the workload of that task where this extension is responsible for compensating the quality degradation due to imprecise inputs.

This work proposes a method for scheduling task graphs with potentially imprecise computations, with the goal of maximizing QoS subject to a hard deadline and an energy bound. The proposed method takes into account the effect of potential extension in the workload of each task based on the quality of its inputs. The proposed method considers task dependencies within a given task graph in order to find tasks (aka nodes) which can be performed imprecisely without having a negative impact on QoS. In addition, for evaluating the efficacy of the proposed method, a mixed integer linear program formulation of the problem, which provides the optimal reference scheduling solutions, is also presented. Both the proposed method and MILP formulation target multiprocessor system-on-chip (MPSoC) platforms due to their increasing popularity for many real-time applications. To the best of our knowledge, this is the first work that takes into account the effect of workload extension based on input quality in scheduling task graphs on MPSoC platforms where the goal is to maximize QoS subject to a hard deadline and an energy bound.

The rest of the paper is organized as follows. Section 2 explains models used in the paper, formally characterizes tasks with potentially imprecise computations, and presents the problem statement. Next, Section 3 explains the proposed method for scheduling task graphs with imprecise computation on an MPSoC platform. It also presents a comprehensive MILP formulation of the same problem, which allows comparing the proposed method with an exact solution. After that, Section 4 details experimental results. Finally, Section 5 concludes the paper.

2. Models and Problem Definition

2.1. Task Model and Imprecise Computation

Tasks to be scheduled are modeled as a directed acyclic graph (DAG) represented by $G(V,E,T_{d})$ in which $V$ denotes the set of $n$ tasks, $E$ denotes data dependencies among tasks, and $T_{d}$ denotes the period of the task graph. $T_{d}$ acts as a hard deadline for scheduling and each repetition of the task graph should be scheduled before the arrival of the next one.

Each task with the possibility of imprecise computation consists of two parts: a mandatory part and an optional part. In order for a task to produce an acceptable result, its mandatory part must be completed. The optional part refines the result produced by the mandatory part. If the optional part of a task is not executed entirely, the result of the task is imprecise and the task has an output error. In a task graph, if one or more parent tasks of each task $u$ have an output error, task $u$ will have an input error. Similar to prior work (Greece2010, ; end-to-end-QoS, ), we assume only the execution of mandatory part of task $u$ will be extended to compensate for the input error and optional part of task $u$ remains the same. This is a valid assumption for many applications such as weather forecasting systems (Greece2010, ), image and video processing, and Newton’s root finding method (1997, ). In other words, mandatory part of a certain task can be thought of as the minimum amount of processor cycles required for the task to produce a result with an acceptable quality, and the mandatory part grows when the quality of a task’s inputs decrease (end-to-end-QoS, ). In order for a task graph to be considered feasibly scheduled, at least the potentially extended mandatory workload of each task must be completed before the deadline $T_{d}$.

The number of processor cycles required to finish the mandatory part of task $u$ when its inputs are error-free is represented by $M_{u}$. For a task $u$ with nonzero input error, its mandatory workload is extended such that it is capable of producing correct results. The number of processor cycles required to process the extension added to $M_{u}$, which depends on the quality of its inputs, is represented by $M^{x}_{u}$. Therefore, the total mandatory workload, represented by $M^{\prime}_{u}$, is obtained as follows:

[TABLE]

The total optional workload of task $u$, which can be executed partially, is represented by $O_{u}$. The number of processor cycles actually assigned to the optional workload of task $u$ is represented by $o_{u}$ ($o_{u}\leq O_{u}$). According to (1997, ), the general mandatory extension function of a task can be estimated by a straight line, which provides an upper bound on the amount of required extension. Therefore, the slope of this line, which is represented by $m_{u}$ and referred to as the task-specific scaling factor (1997, ; Greece2010, ), quantifies the dependency between $E^{i}_{u}$ and $M^{x}_{u}$ as follows:

[TABLE]

in which $E^{i}_{u}$ indicates the input error of task $u$. Similar to (Greece2010, ), $E^{i}_{u}$ in a task graph is defined as follows:

[TABLE]

where $par(u)$ is the set of immediate parents of task $u$ and $E^{o}_{j}$ represents output error of parent task $j$. $E^{o}_{j}$ is defined as the portion of discarded optional workload of task $j$ (1997, ), and thus obtained as follows:

[TABLE]

Based on (3) and (4), we have $0\leq E^{i}_{u}\leq 1$. According to (2), when the input of task $u$ is error-free (i.e. $E^{i}_{u}=0$), $M^{x}_{u}=0$ and thus $M^{\prime}_{u}=M_{u}$. On the other hand, when task $u$ has the maximum input-error (i.e. $E^{i}_{u}=1$), $M^{x}_{u}=m_{u}$ and thus $M^{\prime}_{u}=M_{u}+m_{u}$. In this case, the mandatory workload extension for task $u$ reaches its maximum.

Note the assumption that workload extension can always compensate input error is not true in general. However, based on (1997, ), we can transform the given mandatory and optional portions of a task workload such that in the worst case, where all transformed optional workloads of parent tasks are discarded, the extension amount obtained by (2) would be able to compensate the input error. Therefore, $M_{u}$ and $O_{u}$ used in our proposed method are transformed versions of given mandatory and optional workloads of tasks.

The total number of processor cycles assigned to task $u$ is represented by $W_{u}$ and is obtained as follows:

[TABLE]

2.2. Energy Model

To model power consumption of a processor when operating at clock frequency $f$, we use the following equation borrowed from (gerards-global, ):

[TABLE]

in which $\rho$ represents the total power consumption, and $\alpha$, $\beta$, $\gamma$, and $\delta$ are the power model constants. $\alpha f^{\beta}$ represents the dynamic power consumption, and $\gamma f+\delta$ represents the static power consumption. $\alpha$ is a constant that depends on the average switched capacitance and the average activity factor, and $\beta$ indicates the technology-dependent dynamic power exponent, which is usually $\approx$ 3. Therefore, energy consumption in one clock cycle ($\epsilon_{cycle}$), when executing a task at clock frequency $f$, is obtained from the following equation:

[TABLE]

2.3. Problem Statement

We seek to schedule a task graph with the possibility of imprecise computations represented by $G(V,E,T_{d})$ on a platform comprising of $K$ homogeneous processors in order to maximize QoS subject to a hard deadline and an energy bound. Each processor supports a set of $m$ distinct clock frequencies: $\{f_{1},f_{2},...,f_{m}\}$. QoS highly correlates with how many processor cycles are assigned to the execution of optional workloads of exit tasks, which are the tasks in the task graph with no child tasks. The reason is that the discarded optional workload of tasks other than exit tasks are compensated with extensions in the mandatory workload of their child tasks. Consequently, QoS is quantitatively defined as follows:

[TABLE]

where $exit(G)$ represents the set of exit tasks of task graph $G$, and $P_{u}$ represents the precision of task $u$. $P_{u}$ is a non-decreasing function of number of processor cycles assigned to the optional workload of task $u$. Similar to (Greece2010, ), $P_{u}$ is defined as follows:

[TABLE]

in which $P^{T}_{u}$ indicates the minimum precision acceptable from task $u$, aka precision threshold of task $u$. $P^{T}_{u}$ assumes values between 0 and 1. $P^{T}_{u}$ indicates the precision of task $u$ when only its (extended) mandatory part is completed (Greece2010, ). Based on (9), executing only the extended mandatory workload of task $u$ ($o_{u}=0$) results in $P_{u}=P^{T}_{u}$. On the other hand, executing the entire optional workload of task $u$ ($o_{u}=O_{u}$) in addition to its extended mandatory workload leads to $P_{u}=1$. For other values of $o_{u}$, $P^{T}_{u}<P_{u}<1$.

3. Proposed Framework

The proposed framework comprises of two main steps:

1. (1)

determining the number of processor cycles assigned to optional workload of non-exit tasks, and 2. (2)

scheduling tasks on an MPSoC for maximizing QoS subject to energy and deadline constraints.

3.1. Determining the Number of Processor Cycles Assigned to Optional Workload of Non-Exit Tasks

The first step of the proposed method tries to minimize the summation of total workload of non-exit tasks plus the total (extended) mandatory workloads of exit tasks. The intuition behind choosing such objective function is the fact that minimizing the total number of processor cycles associated with the aforementioned portions of tasks leads to having more processor cycles available for executing optional workloads of exit tasks as there are fixed deadline and energy budget constraints. This can result in increased QoS according to (8). Therefore, we aim to minimize the following expression:

[TABLE]

We first explain our approach for minimizing (10) for two simple task graphs that constitute base cases. Then, we explain our proposed algorithm for a general task graph.

**Base Case 1: **Consider the task graph demonstrated in Fig. 1a. It consists of a parent task $p$, alongside $b$ child tasks. The workload defined in (10) for this simple task graph can be written as follows:

[TABLE]

in which subscripts $p$ and $i$ are used for referring to workload components of the parent task and child tasks in Fig. 1a, respectively. (11) can be rewritten as:

[TABLE]

In (12), the first term in the summation does not depend on how many processor cycles are assigned to $o_{p}$ (note that the actual workload of $M^{\prime}_{p}$ depends on the input error of the parent task and not $o_{p}$). However, the second term is a function of $o_{p}$ and minimizing this term leads to minimization of (12). Two possible scenarios are postulated in this case:

1. (1)

if $\sum_{i=1}^{b}m_{i}\leq O_{p}$, $o_{p}$ should be minimized as much as possible, i.e., $o_{p}=0$. This means the optional workload of parent task must be discarded. 2. (2)

if $\sum_{i=1}^{b}m_{i}>O_{p}$, $o_{p}$ should be maximized as much as possible, i.e., $o_{p}=O_{p}$. This means that the parent task should be executed precisely. A large number of child tasks and/or high values of their $m_{i}$ values lead to a higher chance of this scenario occurring.

**Base Case 2: **Consider the task graph demonstrated in Fig. 1b. It consists of a child task $c$, alongside $b$ parent tasks. The workload of (10) for this simple task graph can be written as follows:

[TABLE]

in which subscripts $c$ and $i$ are used for referring to workload components of the child task and parent tasks in Fig. 1b, respectively. (13) can be rewritten as:

[TABLE]

In (14), the first term in the summation does not depend on how many processor cycles are assigned to $o_{1},o_{2},...,o_{b}$. However, the second term is a function of how many processor cycles are assigned to optional workloads of parent tasks and therefore, this term should be minimized for minimizing (14). Two possible scenarios are postulated in this case:

1. (1)

If $\sum_{i=1}^{b}O_{i}\leq m_{c}$, in order to minimize (14), all optional workloads of $b$ parent tasks should be executed completely, i.e., $\sum_{i=1}^{b}o_{i}=\sum_{i=1}^{b}O_{i}$. The proof is beyond the scope of this paper. 2. (2)

If $\sum_{i=1}^{b}O_{i}>m_{c}$, in order to minimize (14), all optional workloads of $b$ parent tasks should be discarded, i.e., $\sum_{i=1}^{b}o_{i}=0$. The proof is beyond the scope of this paper. A large number of parent tasks and/or high values of their $O_{i}$ values lead to a higher chance of this scenario occurring.

General Task Graphs: While base cases 1 & 2 help determine the number of processor cycles assigned to optional workload of tasks in simple task graphs, similar conclusions cannot be drawn for complicated tasks graphs with interdependence of tasks. For instance, consider an example where two parent tasks share a few child tasks and the goal is to either fully discard or execute the optional workload of tasks within this task graph. Because a few child tasks are potentially shared between the two parent tasks, applying base case 1 or base case 2 without considering the interdependence of tasks may lead to conflicting decisions about execution of optional workloads. As the number of such parent tasks increases, depending on the interdependencies among them and their shared child tasks, the number of possible permutations that should be explored in terms of fully executing or discarding the optional workloads of those parent tasks can grow exponentially. However, presented base cases can guide us in developing a heuristic that determines the number of processor cycles assigned to optional workload of non-exit tasks.

Note that in the proposed heuristic, it is assumed that the input task graph has only one source task (i.e. a task with in-degree of zero), but potentially many exit tasks. In task graphs where the number of source tasks is larger than one, a dummy task with zero workload is introduced and connected to all source tasks. The steps of proposed heuristic are as follows:

Step 1 (Forward Pass): This step starts traversing tasks in the task graph $G$ from the source task and labels each task as precise (fully executing its optional workload) or imprecise (fully discarding its optional workload) based on the task’s optional workload and the total maximum extension of its child tasks if the task is executed imprecisely. This step of the proposed heuristic is similar to base case 1. The difference, though, is the fact that if a child task is encountered more than once due to being a shared child of multiple parent tasks and its mandatory part is extended because one of its parents is labeled as imprecise, it is not considered when writing (12) for its other parent tasks. After exploring all paths in the task graph, tasks with multiple parents and extended workloads are marked. For these tasks, their parent tasks are evaluated again while their marked child tasks are removed from (12). This may lead to an update in deciding whether the parent task should be executed precisely or imprecisely. The same process is repeated until no decisions are further updated. Note that each child task with multiple parents is visited only once during this update pass.

Step 2 (Backward Pass): This step starts traversing tasks in the task graph $G$ in the reverse order from exit tasks back to the source task. For a task with multiple parents, those which are labeled as precise are added to a list and sorted in increasing order of the number of child tasks with intact (not extended) mandatory workloads. The resulting list is called sorted_precise_parents, which includes $b$ tasks. Next, a subset of tasks in sorted_precise_parents is chosen such that transforming those tasks to imprecise tasks and extending the mandatory workload of their child tasks leads to the highest reduction in (10). However, instead of exploring all $2^{b}$ possible subsets, we only explore $b$ subsets which are: the subset containing the first task in the sorted list, the subset containing the first and second tasks in the sorted list, …, and for the $b^{th}$ subset, the subset containing all tasks in the sorted list. The rationale behind such decision is that according to base case 1, labeling a task with fewer number of intact child tasks as imprecise is more likely to eventually increase QoS. Such tasks are explored more often in proposed subsets due to the sorting strategy.

Step 2 (Backward Pass) is inspired by base case 2 where multiple parents with shared child tasks can be labeled as imprecise. In other words, the first step of proposed heuristic looks at parent tasks independently while the second step studies their combined effect on overall QoS.

The presented heuristic determines which tasks in a given task graph should be executed imprecisely. Therefore, we refer to this heuristic as imp_label. The optional workload of each non-exit task $u$ marked as imprecise is $o^{imp\_label}_{u}=0$ while the optional workload of a precise task is $o^{imp\_label}_{u}=O_{u}$. Furthermore, if a non-exit task $u$ has a parent which is labeled imprecise, $M^{\prime~{}imp\_label}_{u}=M_{u}+m_{u}$, otherwise $M^{\prime~{}imp\_label}_{u}=M_{u}$. Therefore, the total workload of each non-exit task $u$ is determined by imp_label, is represented by $W^{imp\_label}_{u}$, and obtained as follows:

[TABLE]

Note that imp_label also determines whether the mandatory workload of an exit task $v$ is extended ($M^{\prime~{}imp\_label}_{v}=M_{v}+m_{v}$) or not ($M^{\prime~{}imp\_label}_{v}=M_{v}$).

3.2. Scheduling Tasks on an MPSoC for Maximizing QoS Subject to Energy and Deadline Constraints.

In this section, we seek to schedule the task graph obtained from imp_label on an MPSoC platform for maximizing QoS subject to energy and time constraints. For this purpose, we determine a proper processor assignment for each task alongside the ordering of tasks on each processor in order to minimize the finish time while operating at the maximum clock frequency (we temporarily ignore energy budget constraint). This is achieved by deploying a minimal-delay list scheduling algorithm, which is a variant of Heterogeneous Earliest Finish Time (HEFT) (heft, ). HEFT assigns a rank to each task in the task graph based on the length of the critical path from that task to exit tasks. While HEFT is designed for heterogeneous platforms, it can be applied to a homogeneous platform as well. For HEFT, we provide workloads obtained from imp_label for non-exit tasks and for exit tasks, their (extended) mandatory workloads obtained from imp_label plus their total optional workloads. Next, we pick tasks in decreasing order of their ranks and schedule each selected task on its “best” processor, which is the processor that minimizes the finish time of the task under the maximum available frequency.

Note that HEFT is only used to just obtain a processor assignment for each task alongside the ordering of tasks on each processor. The obtained start times for tasks from HEFT just show relative ordering of tasks on each processor. Furthermore, we used the maximum frequency in HEFT and included the total optional workloads of all exit tasks since we were temporarily ignoring the energy budget constraint. Therefore, in the next step, the actual number of processor cycles assigned to optional workload of exit tasks, the actual distribution of workload of each task among $m$ available frequencies of the processors, and the actual execution start time of each task should be obtained.

For this purpose, we demonstrate that maximizing QoS for a task graph obtained from imp_label subject to energy and time constraints, and processor assignment and task ordering obtained from HEFT, will be reduced to a linear programming (LP) formulation. In the following formulation, $u$ and $v$ are used to refer to any of the tasks in the task graph.

Duration of task $u$, $u=1,2,...,n$, is formulated as follows:

[TABLE]

where $N_{u,i}$ indicates the number of processor cycles of task $u$ processed at clock frequency $f_{i}$ ($i=1,2,...,m$). If task $u$ is a non-exit task, the following constraint is introduced:

[TABLE]

On the other hand, if task $u$ is an exit task, we have:

[TABLE]

According to (6) and (16), energy consumption during the execution of task $u$ can be formulated as follows:

[TABLE]

To ensure the total energy consumption of tasks is less than or equal to the given energy bound, represented by $\epsilon_{max}$, we have:

[TABLE]

To ensure time and precedence constraints, by representing start time of each task $u$ with $S_{u}$, we should have:

[TABLE]

[TABLE]

In (22), $\overline{C_{u,v}}$ represent the average communication cost associated with $e_{u,v}$ for sending output of task $u$ to input of task $v$.

Finally, we need to ensure tasks assigned to the same processor do not overlap:

[TABLE]

Maximizing the objective function of (8), with the constraints introduced in (16) to (23), forms an LP over positive real variables of $S_{u}$, $N_{u,i}$, and optional workload of exit tasks ($o_{u}$ for $u$ $\in$ exit tasks).

3.3. MILP formulation

In order to evaluate the performance of our 2-step proposed method in Sections 3.1 and 3.2 compared to the optimal solution, we present a comprehensive mixed-integer linear programming (MILP) formulation of the problem statement in Section 2.3. By solving the MILP, we obtain the optimal values for the number of processor cycles assigned to the optional workload of each task, processor assignment for each task alongside the ordering of tasks on each processor, task execution start time, and distribution of the total number of processor cycles associated with the execution of each task among $m$ available frequencies. For this purpose, the following variables are defined:

Denoting the number of processors with $K$, for the processor assignment of task $u$ to processor $k$, $k=1,2,...,K$, we use the decision variable $\Pi_{k,u}$, defined as follows:

[TABLE]

Consequently, we have the following constraint for $\Pi_{k,u}$:

[TABLE]

In order to prevent the overlap of execution of tasks assigned to the same processor with each other, we use the decision variable $Y_{k,u,v}$ indicating ordering of the tasks. For $k=1,2,...,K$; $u=1,2,...,n$; $v=1,2,...,n,v\neq u;$ we define:

[TABLE]

In addition, if task $v$ is the first task assigned to processor $k$, $Y_{k,0,v}$ is defined to be 1 (and is 0 otherwise). On the other hand, if task $u$ is the last task assigned to processor $k$, $Y_{k,u,n+1}$ is defined to be 1 (and is 0 otherwise). Furthermore, if there is no task assigned to processor $k$, $Y_{k,0,n+1}$ is defined to be 1 (and is 0 otherwise). Accordingly, using (26) and the definitions provided for $Y_{k,0,v}$, $Y_{k,u,n+1}$ and $Y_{k,0,n+1}$, we have the following constraints for $k=1,2,...,K$:

[TABLE]

[TABLE]

According to (27), if task $u$ is assigned to processor $k$ ($\Pi_{k,u}=1$), either there is one and only one task scheduled immediately after task $u$ on processor $k$ or task u is the last task assigned to processor $k$. Similarly, according to (28), if task $v$ is assigned to processor $k$ ($\Pi_{k,v}=1$), either there is one and only one task scheduled immediately before task $v$ on processor $k$ or task $v$ is the first task assigned to processor $k$. In both (27) and (28), $\Pi_{k,0}$ and $\Pi_{k,n+1}$ are defined as 1 for all $k=1,2,...,K$. Using $Y_{k,u,v}$, we rewrite the constraint in (23) as the following:

[TABLE]

Finally, instead of using imp_label algorithm to determine the workload of non-exit and exit tasks in (17) and (18), the following constraint is used for all the tasks:

[TABLE]

where $E^{i}_{u}$ is obtained by (3). In order to present the minimum formulation existing in (3) as a linear constraint, we rewrite (3) using an auxiliary decision variable, represented by $X_{u}$, as the following:

[TABLE]

in which $X_{u}$ is a decision variable which is 1 when $\sum_{j\in par(u)}{E^{o}_{j}}>1$ and is 0 otherwise. According to (esmaili, ), the corresponding constraint for $X_{u}$ can be written as follows:

[TABLE]

in which $n$ serves as an upper bound for $\sum_{j\in par(u)}{E^{o}_{j}}$. Furthermore, we use the lemma presented in (esmaili, ) for linearization of multiplication of a Boolean decision variable and a bounded real-valued variable for the second term of (31).

Consequently, maximizing the objective function of (8) with the constraints introduced in (16), (19) to (22), (25), (27) to (32), and the lemma mentioned in (esmaili, ) for linearization of the second term of (31), forms an MILP yielding the optimal values for the desired variables mentioned in the beginning of this section.

3.4. Complexity Analysis

The time complexity of the proposed labeling heuristic described in Section 3.1 is $\mathcal{O}(|E|+|V|)$ where $|E|$ denotes the number of edges in the task graph while $|V|$ represents the number of vertices. Furthermore, the time complexity of HEFT, which is used for obtaining the processor assignment of tasks in the labeled graph and ordering of them on each processor for an MPSoC platform, is $\mathcal{O}(K\times|E|)$ where $K$ denotes the number of processors.

4. Results

4.1. Simulation Setup

For solving the formulated MILP in Section 3.3 and the LP part of the porposed method in Section 3.2, we use IBM ILOG CPLEX Optimization Studio(cplex, ). The platform on which simulations are performed is a computer with a 3.2 GHz Intel Core i7-8700 Processor and 16 GB RAM. For obtaining energy model parameters, we employ (chen2014energy, ) which uses a classical energy model of a 70nm technology processor that supports 5 discrete frequencies. The frequency-independent component of processor power consumption, which is represented by $\delta$ in (6), is obtained as $276\,mW$. Each processor can operate independently of other processors at either $f_{1}=1.01\,GHz$, $f_{2}=1.26\,GHz$, $f_{3}=1.53\,GHz$, $f_{4}=1.81\,GHz$, $f_{5}=2.1\,GHz$. For these frequencies, frequency-dependent component of processor power consumption, which is represented by $\alpha f^{\beta}+\gamma f$ in (6), is $430.9\,mW$, $556.8\,mW$, $710.7\,mW$, $896.5\,mW$, and $1118.2\,mW$, respectively. Using curve fitting, we obtain $\alpha=23.8729$, $\gamma=401.6654$, and $\beta=3.2941$ in (6). We consider an architecture with 4 processors. Simulations are performed for 10 task graphs randomly generated using TGFF(tgff, ), which is a randomized task graph generator widely used in the literature to evaluate the performance of scheduling algorithms. These task graphs are named as TGFF0 to TGFF9. The number of tasks in studied random task graphs ranges from 23 (in TGFF0) to 57 (in TGFF9). The maximum in-degree and out-degree for each task in our randomly generated task graphs are set to 6. For each task $u$, the amount of workload required to be assigned to produce precise results when input is error-free is referred to as the initial workload of the task, and is represented by $W^{initial}_{u}$. Therefore: $W^{initial}_{u}=M_{u}+O_{u}$. For studied task graphs, the average value for $W^{initial}_{u}$ of each task $u$ is set to $2\times 10^{6}$ cycles. For each task $u$, based on what portion of $W^{initial}_{u}$ is for its base mandatory workload ($M_{u}$), we consider 3 cases:

1. (1)

$man\_low$: $M_{u}\sim U(0.2,~{}0.4)\times W^{initial}_{u}$ (low portion of $W^{initial}_{u}$ is for the base mandatory). 2. (2)

$man\_med$: $M_{u}\sim U(0.4,~{}0.6)\times W^{initial}_{u}$ (medium portion of $W^{initial}_{u}$ is for the base mandatory). 3. (3)

$man\_high$: $M_{u}\sim U(0.6,~{}0.8)\times W^{initial}_{u}$ (high portion of $W^{initial}_{u}$ is for the base mandatory).

In each of 3 cases, similar to(Greece2010, ), $m_{u}$ is set as $m_{u}\sim U(0,~{}2\times M_{u})$ for each task $u$. For having a fair comparison among these 3 cases, each task graph uses the same random seed for all the above uniform distributions, where this random seed is different in each task graph. In all 3 cases, $P^{T}_{u}$ for all the tasks are uniformly chosen from [0, 1]. Average communication costs associated with edges of task graphs are chosen uniformly from 0.4 ms to 0.6 ms. $T_{d}$ of each task graph is set to twice the length of the longest path from its source task to an exit task (including communication costs), when executing the total workload along the path, including all optional workloads, with the maximum frequency.

4.2. Evaluating the Effect of Energy Budget on the obtained QoS

In this section, for each of the studied task graphs, we evaluate the effect of the $\epsilon_{max}$ value on the obtained QoS, defined in (8), using the proposed method in Sections 3.1 and 3.2. In order to obtain a proper value for $\epsilon_{max}$, first, we derive the minimum energy required for scheduling the task graph in one $T_{d}$ without the possibility of imprecise computations. We refer to this energy value as $\epsilon^{*}$. For obtaining $\epsilon^{*}$, HEFT is again used to obtain the processor assignment for each task and the ordering of tasks on each processor. Then, we solve the LP which minimizes the objective function of $\sum_{u=1}^{n}\epsilon_{task}(u)$, with the constraints described in (16), (19), (21) to (23), and the constraint imposing that the workload of each task $u$, whether non-exit task or exit task, should be executed precisely: $\sum_{i=1}^{m}N_{u,i}=W^{initial}_{u}$. By solving this LP, $\epsilon^{*}$ of each task graph will be obtained. Optionally, one can use an MILP formulation to obtain $\epsilon^{*}$.

For the case of imprecise computations, for each task graph, if its $\epsilon^{*}$ is used as the value for $\epsilon_{max}$, QoS is obtained as its maximum value (QoS = 100%, if QoS in (8) is shown with percentage). Therefore, for each task graph, we reduce $\epsilon_{max}$ gradually, starting from its $\epsilon^{*}$ with the resolution of $0.05\times\epsilon^{*}$, and observe QoS obtained using our proposed method for each value of $\epsilon_{max}$, as presented in Fig. 2. In Fig. 2, for each task graph, existence of a QoS $\geq$ 0 for a ratio of its $\epsilon^{*}$ as $\epsilon_{max}$, shows that our proposed method can generate a feasible schedule for that task graph and $\epsilon_{max}$, which produces that value of QoS. A feasible schedule manes at least (extended) mandatory workloads of all tasks are completed before $T_{d}$, and the total energy consumption is below the $\epsilon_{max}$.

According to Fig. 2, by reducing $\epsilon_{max}$, we observe the sharpest drop in the obtained QoS by our proposed method in the $man\_high$ case, while the slowest drop in QoS is observed in the $man\_low$ case. This reflects the fact that when lower portion of initial task workloads are mandatory, feasible results can be achieved with lower values of $\epsilon_{max}$, compared to the case that higher portion of initial task workloads are mandatory. For instance, in the $man\_low$ case, our proposed method can generate a feasible schedule for TGFF8 even with using 45% of its $\epsilon^{*}$ as the value for $\epsilon_{max}$, while in the $man\_high$ case, it can only generate a feasible schedule for TGFF8 when $\epsilon_{max}$ is reduced to at most 85% of its $\epsilon^{*}$.

4.3. Evaluating the Performance of the Proposed Method versus MILP

In this section, we compare the the performance of the proposed method in Sections 3.1 and 3.2 with the MILP formulation presented in Section 3.3, in terms of their obtained QoS in different values of $\epsilon_{max}$. We consider our comparison in a case where $M_{u}$ of tasks in a task graph can be chosen uniformly from 20% to 80% of $W_{u}^{initial}$ (a mix of 3 aforementioned cases in Section 4.1; we refer to this case as the $man\_mixed$ case). For each task graph and $\epsilon_{max}$ value, we impose a time limit of 60 minutes for MILP to find the optimal scheduling solutions. For evaluating the performance of our proposed method, we only consider those task graphs for which MILP found the optimal solutions for each value of $\epsilon_{max}$ within the time limit (This comparison is actually in the favor of MILP. We elaborate more on this later). Using this setup, MILP could find solutions for 7 of 10 studied task graphs within the time limit (TGFF0 to TGFF3, TGFF5, TGFF6 , and TGFF9). For these task graphs, the obtained QoS values for different $\epsilon_{max}$ values by the proposed method and MILP are shown in Fig. 3. According to Fig. 3, QoS values found by our proposed method are completely equal to those found by MILP for 4 task graphs (TGFF0, TGFF3, TGFF6, and TGFF9). Furthermore, for other task graphs, the average QoS difference found by the proposed method versus MILP for different $\epsilon_{max}$ values is 1.63% (up to 6.64%). Consequently, the proposed method yeilds close QoS values compared to the optimal MILP formulation.

Comparing the runtime of the proposed method and MILP, we see a clear advantage for the proposed method. On the platform we performed simulations, the average runtime of the proposed method for each task graph and $\epsilon_{max}$ value was 99.38% lower compared to MILP. This is without considering the cases that MILP did not find the optimal solutions within the time limit. for many real-world applications, as the task graphs can have higher number of nodes and more complex interdependencies compared to studied task graphs, the runtime of using MILP for those task graphs can grow exponentially. Therefore, employing the proposed method, as it provided close estimations to MILP, can be an efficient alternative.

4.4. Evaluating the Effect of imp_label algorithm

In order to evaluate the effect of imp_label algorithm presented in Section 3.1, which traverses the graph and labels some tasks as the ones that should be executed imprecisely before feeding that graph to the scheduling method presented in Section 3.2, we compare the results obtained from our proposed method with a baseline approach in which we feed the task graph with their initial workloads ($W^{initial}$) for non-exit tasks to the scheduling method presented in Section 3.2, and assign as much as processor cycles possible to exit tasks in order to maximize QoS. Therefore, In the baseline approach, we solve the same LP as the one formulated in Section 3.2, however, the constraint in (17) for non-exit task $u$ will be transformed to the following constraint:

[TABLE]

and the constraint in (18) for exit task $u$ will be transformed to the following constraint:

[TABLE]

Fig. 4 presents QoS values obtained via the proposed method and the baseline approach for the studied task graphs for different values of $\epsilon_{max}$. The base mandatory portion of initial workload of tasks is set based on the $man\_mixed$ case, similar to Section 4.3. According to Fig. 4, using the baseline approach, QoS for all task graphs immediately drops from 100% as soon as $\epsilon_{max}$ is reduced from $\epsilon^{*}$. However, in the corresponding $man\_mixed$ case of our proposed method, as shown in Fig. 4, QoS can be maintained as 100% even for values lower than $\epsilon^{*}$ for our studied task graphs. For instance, as presented in Fig. 4, our proposed method can generate QoS of 100% for TGFF8 with 85% of its $\epsilon^{*}$. Furthermore, for each task graph, the minimum $\epsilon_{max}$ with which our proposed method can generate a feasible schedule for that task graph is lower in comparison to the baseline approach. For those $\epsilon_{max}$ values that both the proposed method and the baseline approach can provide a feasible schedule for, QoS values obtained via our proposed method are on average 12.82% (up to 43.40%) higher than QoS values obtained via the baseline approach.

5. Conclusion

In this paper, we presented a method for time and energy constrained scheduling of task graphs on MPSoC platforms, with the possibility of imprecise computation of each task of the task graph. We took into the account the effect of the extension in the workload of each task when the input to that task is not precise. For this purpose, we presented an algorithm which by traversing the task graph, determines the optional workload of each non-exit task should be executed or discarded, and then scheduled the labeled graph on a MPSoC platform. For evaluating the efficacy of the proposed method, we also presented a MILP formulation of the problem which provided us the optimal reference scheduling solutions. Our results shows the effectiveness of our proposed method in terms of obtaining promising QoS values even with low energy budgets.