DYNAMIC LOW POWER RECONFIGURATIONS

OF REAL-TIME EMBEDDED SYSTEMS

∗

Xi Wang

, Mohamed Khalgui

1,2

School of Electro-Mechanical Engineering, Xidian University, Xi’an 710071, China

Zhiwu Li

1,2

Institute of Computer Science, Martin-Luther Universit

at, 06120 Halle (Saale), Germany

Keywords:

Embedded system, Reconﬁguration, Low power, Real-time scheduling, Agent-based architecture.

Abstract:

This paper deals with low power dynamic reconﬁgurations of real-time embedded systems. A reconﬁguration

scenario means the addition, removal or update of tasks in order to save the whole system at the occurrence

of hardware/software faults, or also to improve its performance at run-time. When such a scenario is applied,

the energy consumption can be increased or some real-time constraints can be violated. An agent-based

architecture is deﬁned where an intelligent software agent is proposed to check each dynamic reconﬁguration

scenario and to suggest for users useful technical solutions that minimize the energy consumption. It proposes

ﬁrst of all to modify periods, or to reduce execution times of tasks or ﬁnally to remove some of them. Users

should choose one of these solutions in order to guarantee a low power consumption satisfying limitations in

capacities of used batteries. We developed and tested a tool supporting all these services to be evaluated in the

research work.

1 INTRODUCTION

Nowadays, the minimization of the energy consump-

tion is an important criterion for the development of

real-time embedded systems due to limitations in the

capacity of their batteries, in addition to their tasks

which become more and more complex than ever.

Several interesting studies have been proposed in re-

cent years for their real-time and low power schedul-

ing (Shin and Choi, 1999; Quan and Hu, 2002; Yun

and Kim, 2003; Yao et al., 1995; Gaujal and Navet,

2007). We classically distinguish two reconﬁgura-

tion policies: static and dynamic reconﬁgurations.

Static reconﬁgurations are applied off-line to apply

changes before the system’s cold start (Angelov et al.,

2005), whereas dynamic reconﬁgurations are dynam-

ically applied at run-time. Two cases exist in the lat-

ter: manual reconﬁgurations applied by users (Rooker

et al.

, 2007) and automatic reconﬁgurations applied

by Intelligent Agents (Khalgui et al., 2010; Al-Saﬁ

and Vyatkin, 2007). In this paper

, we assume em-

∗

Research Laboratory: http://sca.xidian.edu.cn

Detailed descriptions are available in our website:

http://sca.xidian.edu.cn/

∼

wangx/SCATR201012004.pdf.

bedded real-time systems based on CMOS processors

(Sarvar, 1997), such that the power consumption (P)

of a processor is assumed to be quadratically depen-

dent on supply voltage V

. Similar to (Shin and

Choi, 1999) and (Yao et al., 1995), we assume that

the energy consumption is quadratically dependent on

the supply voltage V

, and the processor speed can

be adjusted according to the processor utilization U.

This idea is interesting and will be used to allow low

power reconﬁgurations of embedded real-time sys-

tems to be implemented by sets of independent, pe-

riodic and synchronous tasks. To reach this goal, we

deﬁne an agent-based architecture in which an intel-

ligent software agent is proposed to check each dy-

namic (manual or automatic) reconﬁguration scenario

at run-time, and to allow feasible and low power adap-

tive systems. The agent proposes ﬁrst of all to modify

periods and deadlines of tasks in order to decrease the

processor speed. It suggests as a second solution to

modify execution times of tasks in order to decrease

the processor utilization. Finally it proposes for users

to remove some of them according to their static prior-

ities or also according to their processor utilizations.

The next section analyzes previous work on low

415

Wang X., Khalgui M. and Li Z. (2011).

DYNAMIC LOW POWER RECONFIGURATIONS OF REAL-TIME EMBEDDED SYSTEMS.

In Proceedings of the 1st International Conference on Pervasive and Embedded Computing and Communication Systems, pages 415-420

DOI: 10.5220/0003308304150420

 SciTePress

power and real-time scheduling as well as reconﬁgu-

rations of embedded architectures. Section 3 formal-

izes reconﬁgurable real-time systems and their power

consumptions. In Section 4, we deﬁne an agent-based

architecture for the minimization of the energy con-

sumption. This architecture is implemented, simu-

lated and analyzed in Section 5. Section 6 concludes

this work.

2 STATE OF THE ART

Although these rich and useful contributions of (Shin

and Choi, 1999; Quan and Hu, 2002; Yun and Kim,

2003; Yao et al., 1995; Gaujal and Navet, 2007)

provide interesting results, they do not address dy-

namic reconﬁgurations with low power consump-

tions of embedded systems such that real-time so-

lutions are automatically computed for users when

the system’s behavior is dynamically reconﬁgured.

Real-time scheduling has been extensively studied in

the last three decades (Baruah and Goossens, 2004)

where several Feasibility Conditions (FC) for the di-

mensioning of a real-time system are deﬁned to en-

able a designer to grant that timeliness constraints

associated with an application are always met for

all possible conﬁgurations. Among all scheduling

policies, Earliest Deadline First (EDF) is an optimal

uniprocessor scheduling algorithm in the following

sense: if a collection of independent periodic jobs

characterized by arrival times equal to zero and by

deadlines equal to corresponding periods are feasi-

ble with another scheduling policy, then it is feasi-

ble with EDF. Nowadays, several research works have

been proposed to develop reconﬁgurable embedded

systems. The work in (Angelov et al., 2005) proposes

reusable tasks to implement a broad range of sys-

tems where each task is statically reconﬁgured with-

out any re-programming. Rooker et al. propose in

(Rooker et al., 2007) a complete methodology based

on the human intervention to dynamically reconﬁg-

ure tasks. The research in (Brennan et al., 2001)

proposes an agent-based reconﬁguration approach to

save the whole system when faults occur at run-time.

In (Al-Saﬁ and Vyatkin, 2007), an ontology-based

agent is proposed to perform system’s reconﬁgura-

tions that adapt changes in requirements and also in

environment. As far as the authors know, no work

is reported to address the problem of dynamic re-

conﬁgurations of embedded systems under real-time

and low-power constraints. Our current research ad-

dresses low-power reconﬁgurations of real-time em-

bedded systems when additions-removals-updates of

tasks are dynamically applied at run-time to save the

system or improve its performance.

3 FORMALIZATION

OF RECONFIGURABLE

REAL-TIME SYSTEMS

A reconﬁguration scenario is assumed in this paper to

be an operation allowing the addition-removal-update

of tasks from/into the system. Each scenario should

be applied while reducing the energy consumption

which is a very important criterion. We deﬁne a

real-time embedded system Sys as a set of tasks that

should meet real-time constraints deﬁned in user re-

quirements: Sys = {τ

,τ

,. .. ,τ

}. When a reconﬁg-

uration scenario is applied, a subset of tasks can be

added/removed into/from the system. Each task τ

Sys describes: i) a function F

deﬁning its function,

ii) the static priority S

among all the system’s (new

and old) tasks, iii) the release time R

deﬁning the ex-

ecution start time of the task, iv) the WCET C

, v) the

period T

, and vi) the deadline D

. It is assumed in

addition that a) all the system’s tasks are periodic and

synchronous, and b) the period of each task is equal

to the corresponding deadline. The system Sys is dy-

namically reconﬁgured at run-time such that its new

implementation is Sys = {τ

,τ

,. .. ,τ

,τ

n+1

,. .. ,τ

The subset {τ

n+1

,. .. ,τ

} is added to the initial im-

plementation {τ

,τ

,. .. ,τ

}. The processor utiliza-

tion before and after the reconﬁguration scenario is as

follows:

be f

∑

i=1

(1)

a f t

∑

i=1

(2)

The energy consumption is assumed quadratically

dependent on processor utilization U (Wang et al.,

2004), the equation can be described as:

P = kU

(3)

Proposition 1. Let U

a f t

and U

be f

denote the proces-

sor utilization after and before a reconﬁguration sce-

nario is applied, respectively. If U

a f t

≤ U

be f

, then the

processor speed after the reconﬁguration scenario is

not greater than that before. In this case the power

consumption is stable or minimized.

Proof : Due to Eq. (3), the energy consumption is

quadratically dependent on U . If U

a f t

≤ U

be f

, substi-

tuting it into Eq. (3) leads to P

a f t

= kU

a f t

≤ kU

be f

. Then the power will be stable or minimized. ⋄

PECCS 2011 - International Conference on Pervasive and Embedded Computing and Communication Systems

416

4 AGENT-BASED

ARCHITECTURE FOR LOW

POWER RECONFIGURATIONS

OF EMBEDDED SYSTEMS

We deﬁne an agent-based architecture for dynamic

low-power reconﬁgurations of an embedded real-time

system. When automatic or manual reconﬁgurations

are applied at run-time to add, remove or update tasks,

the agent should check if the power consumption is

increased. If a reconﬁguration scenario is dynami-

cally applied at run-time to add new tasks, the pro-

cessor utilization U

rec

of the system will be certainly

increased as follow:

rec

∑

i=1

(4)

4.1 Modiﬁcation of Periods and

Deadlines

The agent proposes as a ﬁrst technical solution to

modify the periods and deadlines of tasks in order

to decrease the processor utilization U

a f t

to be lower

than U

be f

. For the reconﬁgured system, it is assumed

that T

′

, T

′

, . .., and T

′

are the modiﬁed periods of m

tasks, and T

′

= T

′

= ... = T

′

= T

′

In order to minimize the energy consumption,

based on Eq. (3), the processor utilization should be

reduced. Proposition 1 leads to:

a f t

∑

i=1

′

≤ U

be f

(5)

where

′

= ⌈

∑

i=1

be f

⌉ (6)

In Eq. (6), T

′

is the modiﬁed period of each task.

The processor utilization after reconﬁguration of the

processor is as follows:

a f t

∑

i=1

′

(7)

4.2 Modiﬁcation of WCETs

For the low-power reconﬁguration of embedded sys-

tems, the agent proposes as a second technical solu-

tion to reduce the WCETs of tasks in order to decrease

the processor utilization U

a f t

∑

i=1

′

(8)

where C

′

, C

′

, .. ., and C

′

are the new WCETs of

tasks. Suppose that C

′

= C

′

= · · · = C

′

= C

′

, Similar

to Eq.(5), we can get:

a f t

∑

i=1

′

≤ U

be f

(9)

′

can be solved as:

′

= ⌊

be f

∑

i=1

⌋ (10)

The actual utilization of the processor is as fol-

lows:

a f t

= C

′

∑

i=1

(11)

4.3 Removal of Tasks

The third solution proposed by the agent allows the

removal of tasks in order to minimize the energy con-

sumption after any reconﬁguration scenario of an em-

bedded system. Two policies are proposed: the agent

suggests to remove tasks according to their functional

priorities or to their processor utilization.

4.3.1 First Policy: Static Priority Criterion

By deﬁning for each task τ

a static priority S

, the

agent suggests to remove tasks with lower static pri-

orities because their removal can be useful for a low

power reconﬁguration of the system. Let List be the

list of tasks of S ys in descending order of static prior-

ities. The most unimportant tasks should be removed

to keep the new utilization of the system U

a f t

lower

than U

be f

. Speciﬁcally, we have

a f t

∑

≤ U

be f

(12)

where m − k is the number of removed tasks with k ≤

m. The agent should look for the highest value of U

a f t

such that U

a f t

≤ U

be f

. The total energy consumption

can be calculated by Eq. (3).

4.3.2 Second Policy: Processor Utilization

Criterion

It is similar to the ﬁrst policy. Their difference is that

the second policy does not to arrange tasks due to their

static priorities, but due to their processor utilization.

In this case, the List is the list of tasks of Sys in as-

cending order of processor utilization of each task τ

If the system is not feasible or consumes more energy,

the tasks with highest processor utilizations should be

DYNAMIC LOW POWER RECONFIGURATIONS OF REAL-TIME EMBEDDED SYSTEMS

417

removed to keep as many tasks as possible remaining

in the system.

5 EXPERIMENTAL STUDIES

This section presents an experimental study applying

low power reconﬁgurations of embedded real-time

systems. We present ﬁrst of all the implementation

of the agent-based architecture, before showing the

simulations and analysis that are made to evaluate the

beneﬁts of our contributions.

5.1 Implementation of the

Reconﬁguration Agent

In this paper, the agent’s goal is to check dynamic

(automatic or manual) reconﬁguration scenarios, and

suggest useful solutions for the minimization of the

energy consumption. Each solution is generated as an

input ﬁle from the agent to the well-known simulator

Cheddar (Singhoff et al., 2004) to check its feasibility.

This implementation is tested in our research labora-

tory at Xidian University by assuming several cases of

systems. Note that Eqs. (1), (3), (6), and (10) can be

used to calculate U

be f

, P

be f

, T

′

, and C

′

, respectively.

According to Eqs. (4) and (11), the utilization U

a f t

computed after the modiﬁcation of periods (and dead-

lines), and the utilization U

a f t

after the modiﬁcation

of WCETs, respectively. Note in addition that U

a f t

and U

a f t

correspond to the utilization after tasks are

removed according the two ﬁxed policies, as shown in

Eq. (12). We use P

a f t

, P

a f t

, P

a f t

, and P

a f t

to indicate

the power consumption after the modiﬁcation of peri-

ods (and deadlines), after the modiﬁcation of WCET,

after the removal of tasks by considering their static

priorities, and after the removal of tasks by consider-

ing their utilizations, respectively. All of them can be

calculated by Eq. (3).

In the ﬁrst two technical solutions, the algorithm’s

complexity is O(n), and in the third one, it costs

O(n

5.2 Simulations

This section presents simulation results by applying

low-power reconﬁgurations of an embedded real-time

system that is initially composed of 50 tasks and dy-

namically reconﬁgured at run-time to add 30 new

ones. We assume the following temporal character-

istics of the system under consideration:

• Initial System’s Tasks & Addition Tasks. All

the initial tasks of the system and the addition

Algorithm 1: Low-Power Reconﬁgurations.

input “system.txt” ﬁle;

input “add.txt” ﬁle;

input “priority.txt” ﬁle;

compute (U

be f

);

calculate period T

′

;

for (i = 1, i = size(sys) + size(add),i + +)

= C

′

;

∑

a f t

+ = U

;

endfor;

Evaluate energy(U

be f

, U

a f t

);

calculate execution time C

′

;

for (i = 1, i = size(sys) + size(add),i + +)

= C

′

;

∑

a f t

+ = U

;

endfor;

Evaluate energy(U

be f

, U

a f t

);

Sort all the tasks by a descending order based on their

static priorities;

Loop1 remove tasks priority (Sys

new1

);

for (i = 1, i = size(Sys

new1

),i + +)

∑

a f t

+ = U

;

endfor;

keep minimal(U

min a f t

);

EndLoop1

Evaluate energy(U

be f

, U

min a f t

);

sort all the tasks by a ascending order based on their

utilization;

Loop2 remove tasks utilization(Sys

new2

);//solution 3

to remove possible tasks (second criterion)

for (i = 1,i = size(Sys

new2

),i + +)//to compute the

new utilization when tasks are removed (second cri-

terion)

∑

a f t

+ = U

;

endfor;

keep minimal(U

min a f t

);

Evaluate energy(U

be f

, U

min a f t

);

EndLoop2

end;

tasks are in the ﬁle “system.txt” and “add.txt”, re-

spectively. (F

deﬁnes the function. R

, C

, T

, and

deﬁne the temporal parameters of each task.

• Static Priorities. All the functional priorities of

the system’s tasks are deﬁned in the ﬁle prior-

ity.txt (F

and S

deﬁne functional and static pri-

orities of each task, respectively.

All the related ﬁles and experimental data are

shown in the technical report of our laboratory(Wang

et al., 2004).

PECCS 2011 - International Conference on Pervasive and Embedded Computing and Communication Systems

418



Figure 1: Energy decrease by modify periods.



Figure 2: Energy decrease by modify WCETs.

5.3 Analysis

We present some analysis that proves the advantages

of the different proposed solutions.

5.3.1 First Solution

Due to Eqs. (6) and (3), the power minimization is

proven to be dependent on the WCETs. If all the 30

tasks are added, their WCETs are equal to 165. We

made several simulations for

∑

= 3,4,5,...,165.

The result is shown in Fig. 1 in which we ﬁnd a de-

crease of consumption between 0 and 0.45%. The en-

ergy reduction is piecewise approximately linear de-

pending on the

∑

= 3,4,5,...,165.

5.3.2 Second Solution

From Eqs. (10) and (3), the power minimization is

proven to be dependent on periods. If all the 30 tasks

are added, the value of

∑

i=1

1/T

is equal to 0.131684.



Figure 3: Comparing the number of removed task between

two remove strategies.



Figure 4: Comparing energy decrease between two remove

strategies.

Simulations are made for subsets of tasks with the

range of

∑

1/T

between 0 and 0.131684. The result is

shown in Fig. 2 where the minimization of the energy

consumption is between 0 and 35%. This simulation

result proves the beneﬁts of the second solution than

the ﬁrst. Nevertheless, sometimes, the modiﬁcation of

periods is more simpler that minimization of WCET.

It is unclear whether the second solution is deﬁnitely

better than the ﬁrst.

5.3.3 Third Solution

In the third solution where tasks are removed at run-

time to minimize the energy consumption after recon-

ﬁguration scenarios, several simulations are applied

to evaluate the beneﬁts. In Fig. 3, the continuous line

presents the ﬁrst policy where the priority function is

used as a criterion to remove tasks. In this case, the

number of removed tasks is equal to or greater than

the added one: the tasks remaining in the system are

DYNAMIC LOW POWER RECONFIGURATIONS OF REAL-TIME EMBEDDED SYSTEMS

419

less than 50. The dotted line corresponds to the re-

moval of tasks due to their processor utilizations. The

number of removed tasks is smaller than the addition

number. This second policy is more useful than the

ﬁrst. Fig. 4 shows the minimization of the energy

consumption when the ﬁrst (continuous line) and the

second (dotted line) policies are applied. It indicates

that the energy consumption stills minimal when we

apply the second solution where WCETs of tasks are

modiﬁed.

6 CONCLUSIONS

This paper deals with low power and real-time dy-

namic reconﬁgurations of embedded systems to be

implemented by sets of tasks that should meet real-

time constraints while satisfying limitations in the ca-

pacity of batteries. A reconﬁguration scenario means

the addition, removal or update of tasks in order to

save the system when faults occur or to improve its

performance. The energy consumption can often be

increased or real-time constraints can often be vio-

lated when tasks are added. To allow a stable energy

consumption before and after the application of each

reconﬁguration scenario, an agent-based architecture

is deﬁned where an intelligent software agent is pro-

posed to check each dynamic reconﬁguration scenario

and to suggest for users effective solutions in order

to minimize the energy consumption. It proposes to

modify periods, reduce execution times of tasks or re-

move some of them. A tool is developed and tested to

support all these services. In our future work, we plan

to study low power and real-time reconﬁgurations of

asynchronous tasks that can be loaded in a uniproces-

sor or can be distributed on different calculators.

ACKNOWLEDGEMENTS

This work was supported in part by the Natural Sci-

ence Foundation of China under Grant No. 60773001

and 61074305, the Fundamental Research Funds for

the Central Universities under Grant No. 72103326,

the National Research Foundation for the Doctoral

Program of Higher Education, the Ministry of Educa-

tion, P. R. China, under Grant No. 20090203110009,

“863” High-tech Research and Development Program

of China under Grant No. 2008AA04Z109, the Re-

search Fellowship for International Young Scientists,

National Natural Science Foundation of China, and

Alexander von Humboldt Foundation.

REFERENCES

Al-Saﬁ, Y. and Vyatkin, V. (2007). An ontology-based

reconﬁguration agent for intelligent mechatronic sys-

tems. In Third International Conference on Indus-

trial Applications of Holonic and Multi-Agent Sys-

tems. Springer-Verlag.

Angelov, C. Sierszecki, K. and Marian, N. (2005). De-

sign models for reusable and reconﬁgurable state ma-

chines. In L.T. Yang, et al. (Eds.), EUC, LNCS, 3824.

International Federation for Information Processing.

Baruah, S. and Goossens, J. (2004). Scheduling real-time

tasks: Algorithms and complexity. In In Handbook

of Scheduling: Algorithms, Models, and Performance

Analysis. Chapman Hall/ CRC Press.

Brennan, R. W. Fletcher, M. and D. H. Norrie, (2001). A

holonic approach to reconﬁguring realtime distributed

control systems. In Multi-Agent Systems and Applica-

tions. Springer-Verlag.

Gaujal, B. and Navet, N. (2007). Dynamic voltage scaling

under edf revisited, real-time systems. In Some re-

sults are available as research report INRIA RR-5125.

Springer Verlag.

Khalgui, M. Mosbahi, O. Li, Z. W. and Hanisch, H.-M.

(2010). Reconﬁgurable multi-agent embedded con-

trol systems: From modelling to implementation. In

IEEE Transactions on Computers.

Quan, G. and Hu, X. (2002). Minimum energy ﬁxed-

priority scheduling for variable voltage processors,

design, automation and test. In Europe Conference

and Exhibition.

Rooker, M. N. Sunder, C. et al. (2007). Zero downtime

reconﬁguration of distributed automation systems: the

ε cedac approach. In Third International Conference

on Industrial Applications of Holonic and Multi-Agent

Systems. Springer-Verlag.

Sarvar, A. (1997). CMOS power consumption and C

cal-

culation. Texas Insruments.

Shin, Y. and Choi, K. (1999). Power conscious ﬁxed priority

scheduling for hard real-time systems. In 36th Design

Automation Conference.

Singhoff, F. Legrand, J. Nana, L. and Marce, L. (2004).

Cheddar: A ﬂexible real time scheduling framework.

In Atlanta, GA, United states, Association for Com-

puting Machinery.

Wang, X. Khalgui, M. and Li, Z. W. (2004). Dynamic low

power reconﬁgurations of embedded real-time sys-

tems. In Technical Report TR-201012004. Available:

http://sca.xidian.edu.cn/

∼

wangx/SCATR201012004.pdf.

Yao, F. Demers, A. and Shenker, S. (1995). A scheduling

model for reduced cpu energy. In Proceedings of IEEE

annual foundations of computer science.

Yun, H. and Kim, J. (2003). On energy-optimal voltage

scheduling for ﬁxed-priority hard real-time systems.

In ACM Transactions on Embedded Computing Sys-

tems(TECS).

PECCS 2011 - International Conference on Pervasive and Embedded Computing and Communication Systems

420