^{1}

^{*}

^{1}

^{1}

^{2}

This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution license (http://creativecommons.org/licenses/by/3.0/).

In control devices for the Internet of Things (IoT), energy is one of the critical restriction factors. Dynamic voltage scaling (DVS) has been proved to be an effective method for reducing the energy consumption of processors. This paper proposes an energy-efficient scheduling algorithm for IoT control devices with hard real-time control tasks (HRCTs) and soft real-time tasks (SRTs). The main contribution of this paper includes two parts. First, it builds the Hybrid tasks with multi-subtasks of different function Weight (HoW) task model for IoT control devices. HoW describes the structure of HRCTs and SRTs, and their properties, e.g., deadlines, execution time, preemption properties, and energy-saving goals,

The term IoT first appeared in the white papers of Auto-ID Center about the Electronic Product Code (EPC) by Brock in 2001 [

Today, the IoT is regarded as an extension of ubiquitous computing [

The existing energy-saving research usually aims at only hard real-time systems [

The work in this paper is suitable for IoT control devices for the following reasons:

HoW simplifies task modeling and describes tasks' importance levels, energy characteristics and execution order. For example, besides algorithms, peripherals (such as integrated actuators and communication modules) can be modeled as interface tasks with spcific function weight and energy-saving goals. A process including information-acquiring, information-processing and command-sending can be modeled as a task with multiple subtasks.

Energy can be saved by using HTDVS, which enhances the availability of SANs and improves the continuity of information from sensors.

HTDVS reduces response time jitters, and improves the control quality for actuators.

HTDVS guarantees the real-time requirements of tasks when there are both HRCTs and SRTs, which makes it meet the real-time requirements of control tasks.

HTDVS tries its best to meet the speed requirements of subtasks, which makes it suitable for different speeds in communication links and peripherals.

The rest of this paper is organized as follows: Section 2 summarizes the related work. Section 3 presents the task model and processor model. The timing analysis technique is proposed in Section 4. In Section 5 we describe the implementation of energy-efficient speed control in design time and run time. Experiment results and analysis are given in Section 6. We conclude this paper in Section 7.

This paper focuses on the energy-saving problem of IoT control devices, which is applied to ubiquitous sensing and controlling, and involves energy-saving and real-time requirements. In this section, we first introduce the research in ubiquitous sensing and controlling, and then review the energy-saving work in real-time systems.

Sensor networks are the information sources of IoT control devices. Currently, many research efforts have been made on the energy-saving problems in Wireless Sensor Networks (WSNs). Chamam and Pierre presented a method to optimally plan the states of sensors in cluster-based sensor networks [

With the development of IoT, more and more research efforts are made on the ubiquitous sensing and controlling. Yoerger

In this paper, although we focus on the energy-saving problem of single processor with powerful performance by using DVS technique, the method presented in this paper can be easily integrated to a network with multiple controller and actuator nodes.

Till now, there have been a large number of research efforts on applying DVS to real-time systems. The running voltages of tasks can be determined at design time (in a static manner) or run time (in a dynamic manner), or by combining the static and dynamic manners. On one hand, static DVS algorithms make use of tasks' information such as periods, deadlines, Worst-Case Execution Time (WCET), and other information to decide the supply voltages of tasks offline. On the other hand, dynamic DVS algorithms make use of runtime information of tasks to decide the supply voltages of tasks online.

In hard real-time systems, the timing requirements of tasks must be respected when energy is saved. Saewong and Rajkumar provided three static DVS algorithms [

Energy-saving problem has also been widely researched in soft real-time systems where there are usually the requirements of DMR. Kargahi and Movaghar presented a method for reducing the long run power consumption of a soft real-time system using DVS [

In this paper, we present an energy-saving method for IoT control devices with hybrid tasks. Our research is different from the existing ones in the following points. First, it is required to meet both hard real-time requirements and soft real-time requirements, rather than merely one of them. Second, tasks have two energy-saving goals, rather than merely the lowest, the best as usual. Third, tasks have different function weight, and they are not so important as each other. Fourth, HRCTs have the requirements for reducing response time jitters.

In this section, we introduce the task model and processor model that will be used throughout this paper.

In this subsection, we define the HoW task model. Under HoW, a system is composed of _{1}_{n}_{i}_{i}, D_{i}, C_{i}, C_{B}, TY_{i}_{i}_{i}_{i}_{B}_{i}

HRCTs. If _{i}_{∈} HRCTs, its worst-case response time (WCRT) _{i}_{i}_{i}

SRTs. If _{i}_{∈} SRTs, _{i}_{i}_{i}_{i}

The set of all HRCTs is denoted as ^{H}^{S}_{i}_{i}_{i}

A task _{i}_{(i,1)}_{(i,m)}_{(i,k)}_{(i,k)}

The subtask _{(i,k)}_{(i,k)}, C_{B(i,k)}, P_{(i,k)}, PP_{(i,k)}, W_{(i,k)}, EG_{(i,k)}, S_{idl(i,k)}_{(i,k)}_{B(i,k)}_{(i,k)}_{(i,k)}_{(i,k)}_{(i,k)}

The energy-saving goals of subtasks are classified into two classes:

Optimal speed first, _{(i,k)}_{idl(i,k)}

Lower speed better, _{(i,k)}_{idl(i,k)}

If _{i}_{(i,m)}_{(i,m)}_{(i,m)}_{B(i,m)}_{(i,m)}_{B(i,m)}_{(i,k)}, PP_{(i,k)}_{(i,k)}_{i}_{i}_{i}_{(i,k)}_{i}_{i}_{i}_{i}_{(i,k + 1)}_{(i,k)}^{st}_{i}^{th}_{i}

Note that two points should be put forward. First, in IoT control devices, although the majority of tasks are periodic ones, there are some aperiodic tasks and sporadic tasks triggered by external physical events or commands. In our current research, we do not consider the aperiodic tasks and sporadic tasks. Although aperiodic tasks and sporadic tasks can be modeled as SRTs and HRCTs respectively, it will lead to pessimistic results in scheduling and energy savings because of the using of their minimal trigger intervals. In scheduling, combining bandwidth reservation with slack stealling may be a promising solution in our future research. Second, although we do not limit the DMR of SRTs in this paper, DMR can be controlled by monitoring the runtime DMR of SRTs and adjusting the slowdown factors of SRTs.

Currently, the vast majority of modern processors are made using Complementary Metal-Oxide-Semiconductor (CMOS) technology. The power consumption of a processor consists of two parts. One is the dynamic power consumption _{D}_{D}_{dd}_{t}^{2}/_{dd}_{eff}, V_{dd}, V_{t}_{dd}_{t}_{eff}_{L}_{L}_{L}

In this paper, we use the periodic task model and assume the processor is never shutdown. We ignore the influence of leakage power, and simplify the CPU power consumption to be:

A wide range of processors can run at a sequence of discrete operating frequencies with corresponding supply voltages. Changing the supply voltage of a processor will lead to the corresponding changes of the processor's operating frequency. We assume a processor _{i}_{1}_{1}_{max}_{max}_{j}_{j}_{i}_{i}_{i}^{2}f_{i}_{max}^{2}f_{max}_{(i,j)}_{(i,j)}

In this section, we first introduce the analysis method of tasks' schedulability and some basic notations used in the schedulability analysis, and then present the strategies for controlling the response time jitters of HRCTs and prove the upper bound of tasks' WCRT in HoW.

We call the timing analysis algorithm presented by Harbour, Klein, and Lehoczky the HKL algorithm [

Let's assume _{min(j)}_{j}_{min(j)}_{(i,k}_{)}, _{j}_{(i,k)}_{j}_{(i,k)}_{(i,k)}_{(i,k)}_{j}_{(i,k)}_{(i,k)}_{(i,k)}_{j}_{(i,k)}_{j}_{(i,k)}_{j}_{(i,k}_{)}, they are called an _{j}_{(i,k}_{)}, they are called an

The canonical form of a task _{i}_{i}_{i}_{i}_{i}_{(i,k)}

Type-1 tasks, _{(i,k)}_{(i,k)}

Type-2 tasks, ^{+}_{(i,k)}

Type-3 tasks, ^{+}_{(i,k)}_{(i,k)}

Type-4 tasks, ^{+}^{0}_{(i,k)}

Type-5 tasks, _{(i,k)}_{(i,k)}

The WCRT of _{i}_{i}_{i}_{i}_{i}_{i}_{i}

Many of the current embedded operating systems (OSs) (e.g., Windows CE, Linux, VxWorks, Android, iOS) provide self-suspension mechanisms to control the execution of tasks flexibly. In order to reduce the response time jitter of _{i}_{(i,m)}_{i}_{i}_{(i,m)}_{(i,m)}

The response time before the release of _{(i,m)}

There is no task preemption between the end of the self-suspension and the end of _{(i,m)}_{(i,m)}

Self-suspension time length can be set.

After using the self-suspension mechanism before the last subtasks of HRCTs, the response time of HRCTs and SRTs will change in comparison to that without the self-suspension mechanism. In this paper, we do not analyze the exact response time of a HRCT with a specific suspension time segment, and only give an upper bound of WCRT in order to guarantee the hard real-time requirements of HRCTs and try to meet the soft real-time requirements of SRTs.

In the following discussion, we call the task set where there is no suspension time segment ^{N}_{i}^{N}_{i}^{H}, τ_{i}^{N}_{i}_{i}^{S}, τ_{i}^{N}_{i}_{i}^{N}_{i}_{i}^{N}_{i}^{N}_{i}_{i}_{i}^{N}^{N}_{i}

The interference time _{i}_{i}_{i}^{N}

Without losing generality, we compare the interference effect from a HRCT _{j}_{j}^{N}_{j}_{i}, τ_{j}^{N}_{i}_{j}_{i}, τ_{j}^{N}_{i}_{j}_{i}, τ_{j}^{N}_{i}_{i}_{i}^{N}_{i}_{i}_{i}_{i}^{N}_{i}_{i}_{i}^{N}_{j}_{i}_{i}_{i}_{i}_{i}^{N}_{i}_{i}_{i}_{i}_{i}_{i}^{N}_{i}_{i}_{i}_{i}^{N}_{i}_{i}_{i}^{N}_{i}_{i}_{i}^{N}_{i}_{i}^{N}_{i}

In ^{N}_{i}^{N}_{i}_{i}^{N}_{i}

Because the suspension time lies before the last subtask _{(i,m)}_{i}_{i}_{i}^{N}. τ_{i}_{i}^{N}_{i}_{i}^{N}_{i}_{i}_{i} − C_{(i,m)} − R_{(i,m-1)}_{i}^{N}_{i}_{i}^{N}_{i}_{i}_{i}^{N}_{i}_{i}^{N}_{i}_{i}_{i}^{N}_{i}_{i}^{N}^{N}_{i}^{N}_{i}_{i}^{N}_{i}

From Lemma 1 and Lemma 2, we can easily derive theorem 1.

Under the HoW model, the upper bound of WCRT of any task _{i}_{i}^{N}^{N}_{i}

Hence, we can use the method in [

Aiming at the energy-saving problem under the HoW task model, we present an energy-saving scheduling algorithm—the HTDVS algorithm. The HTDVS algorithm includes two phases, as shown in

In [_{i}_{i}

From the definition of TSFS-EN, we know that the TSFS-EN of _{i}_{i}_{i}_{i}_{i}'s_{i}_{i}

In the following discussion, we denote the TSFS-EN of τ_{i} TSFS-EN(τ_{i}). If τ_{(i,k)} has not been given an individual TSFS-EN, it uses the TSFS-EN of τ_{i} as its TSFS-EN. From the response time analysis of the HKL algorithm, we know all the multiply preemptive tasks and singly preemptive tasks of τ_{j} must fall into the set of MP_{(j,1)} (x0222A) SP_{(j,1)}, that is to say, we can analyze the interference tasks of τ_{j} according to P_{(j,1)}′. For the convenience of understanding, we introduce some notations in [_{(i,k)}'s execution speed, we call the maximum allowable execution time of τ_{(i,k)} its maximum time extension. For an H/L task segment, its maximum time extension is equal to the sum of the maximum time extension of all its subtasks. The slowdown factor of τ_{(i,k)}, denoted as S_{(i,k)}, is defined as (τ_{(i,k)}'s maximum time extension)/C_{(i,k)}. Under the fixed priority scheduling and discrete voltage levels, assigning the optimal slowdown factors of tasks is an NP-hard problem [_{(j,1)}′, T23(j) denotes the set of (^{+}^{+}H_{(j,1)}′, and T234(j) is the set of (^{+}^{+}H^{+}L^{0}_{(j,1)}′;
_{i} against P_{(j,1)}′; denotes the internal H segment to which τ_{(i,k)} belongs against P_{(j,1)}′;
_{i} against P_{(j,1)}′;
_{i}^{h} denote the WCET of the initial H segment of τ_{i}; B_{i} denotes the maximum blocked time that τ_{i} can suffers from. For τ_{i ∈}Γ, we set down the following three rules to restrict the interference time of τ_{i} on other task τ_{j} where _{j}_{i}^{S}

Rule 1: if _{i}_{∈}_{(i,k)}, S_{(i,k)}_{j})

Rule 2: if _{i}_{∈}_{(i,k)}_{∈}
_{(i,k)} ≤ TSFS-EN(τ_{j});

Rule 3: if _{i}_{∈}_{(i,k)}_{j})_{i}^{h} + _{j}_{(i,k)}_{∈}

_{(i,k)}_{j})_{(i,k)}_{∈}
_{i}_{∈}^{S}

_{(i,k)}_{i}_{(i,m)}_{(i,m)}_{(i,k)}_{∈}
_{i}_{∈}^{H}

After that, we use the hierarchical tree method in [^{H}

In [

Because real-time properties are not mandatory in SRTs, we only consider the jump points in HRCTs. From the classification of task types, we know the jump points of a task τ_{j} only appear in type-2, type-3, and type-4 tasks of τ_{j},

If τ_{(i,k)} is a jump point of the internal H segment H_{(i,k),j}^{M}, the maximum reusable slack time (MRS) of τ_{(i,k)} is

If τ_{(i,k)} is a jump point of the final H segment H_{i,j}^{L}, the maximum reusable slack time of τ_{(i,k)} is

We adopt the method in [

The slack time requirements of τ_{(i,k)} are characterized by STIDL_{(i,k)}, STMIN_{(i,k)}, and STMAX_{(i,k)}. STIDL_{(i,k)} denotes the ideal slack time that τ_{(i,k)} needs, STMIN_{(i,k)} denotes the minimum slack time that τ_{(i,k)} needs, and STMAX_{(i,k)} denotes the maximum slack time that τ_{(i,k)} needs. If τ_{(i,k)} is a G1-type subtask, STIDL_{(i,k)}, STMIN_{(i,k)}, and STMAX_{(i,k)} are all set to 0 if its ideal slowdown factor S_{idl(i,k)} is between 1 and S_{(i,k)}. Otherwise, STIDL_{(i,k)} and STMAX_{(i,k)} are set to C_{(i,k)}*(S_{idl(i,k)} − S_{(i,k)}), and STMIN_{(i,k)} is set to C_{B(i,k)}*(S_{idl(i,k)} − S_{(i,k)}). If τ_{(i,k)} is a G2-type subtask, STIDL_{(i,k)} is set to 1/2*(C_{B(i,k)} + C_{(i,k)})*(S_{min(i,k)} − S_{(i,k)}), STMIN_{(i,k)} is set to 0, and STMAX_{(i,k)} is set to C_{(i,k)}*(S_{min(i,k)} − S_{(i,k)}), where S_{min(i,k)} is the slowdown factor which is corresponding to the slowest speed of the processor.

In order to meet the real-time requirements and energy-saving requirements of tasks in HoW, it is necessary to mark the minimum reserved slack time (LRST), the ideal reserved slack time (IRST) and the maximum reserved slack time (MRST) of a subtask for its subsequent subtasks before using the runtime slack reclamation and reuse. For a subtask τ_{(i,k)}, its LRST is:
_{(i,k)} is the LRST of τ_{(i, k)}. _{(i,k)} is the sum of the STMIN of its subsequent subtasks with larger function weight. Similarly, IRST and MRST are defined as

By scanning each subtask of all tasks, we can obtain their LRST, IRST, and MRST, and mark these information into the corresponding subtasks in order to reserve slack time for the following subtasks of a task.

In this section, we present two energy reclamation and reuse algorithms, _{i}, denoted as GST(i), is the slack time which is reclaimed in the executed subtasks of τ_{i} and can be used by all its subsequent subtasks. LST of τ_{i}, denoted as LST(i), is the slack time which comes from GST(i) or is reclaimed in an H/L segment and can be reused in the same H/L segment.

The initialization, use and conversion rulers of LST and GST are as follows:

Both LST and GST of a task are set to 0 before a task runs.

LST are set in the first subtask of the first

Before the first subtask of an

On the basis of slack time reservation, the HTDVS-HRCT algorithm decides whether the subtask to be run can reuse the reclaimed slack time, and how much slack time the subtask can reuse. We define the following five rules when reusing slack time. Note that Rule 1 takes precedence over Rule 2.≥

_{(i, k)}_{(i, k)}

_{(i, k)}_{(i, k)}_{(i, k)}

_{(i, k)}_{(i, k)}_{(i, k)}

_{(i, k)}_{(i, k)}_{(i, k)}

An HRCT can use the above five rules to reuse slack time. For a G1-type subtask τ_{(i, k)}, using Rule 1, τ_{(i, k)} reserves LRST time for its subsequent subtasks and it runs at its ideal speed. Using Rule 2, τ_{(i, k)} reserves LRST time for its subsequent subtasks and it runs at a lower speed. By using Rule 1 and Rule 2, τ_{(i, k)} tries its best to work at its ideal speed or a lower speed above its ideal speed. For a G2-type subtask τ_{(i, k)}, using Rule 3, τ_{(i, k)} in an H segment reserves IRST time for its subsequent subtasks and it runs at a lower speed. Because a subtask in an H segment is usually restricted in slack time reuse, it tries its best to reuse more slack time. Using Rule 4, τ_{(i, k)} in an L segment reserves MRST time for its subsequent subtasks, and τ_{(i, k)} runs at a lower speed. Because a subtask in an L segment is usually not restricted during slack time reuse, it tries its best to reserve more slack time. By using Rule 3 and Rule 4, τ_{(i, k)} will work at a lower speed after reserving enough slack time. Even if Rule 1–4 are not met, a subtask can reduce its running speed by using its slowdown factor. The HTDVS-HRCT algorithm is shown in Algorithm 1.

In Algorithm 1, Line 3–Line 47 are the pseudo code before releasing a subtask τ_{(i, k)}, and Line 49 is the pseudo code upon τ_{(i, k)} ends. Line 3–Line 5 suspend the last subtask of τ_{i} for a specific time segment R_{i} − C_{(i, m)} − R_{(i, m-1)} according to the difference between R_{i} and R_{(i, m − 1)} in order to reduce the response time jitter of τ_{i}. Line 7–Line 14 set the LST of τ_{(i, k)}. If τ_{(i, k)} is in a jump point, _{(i, k)}. Line 21 sets the runtime slowdown factor of τ_{(i, k)} to its static slowdown factor by default. If τ_{(i, k)} is a G1-type subtask, Rule 1 (Line 23–Line 24) or Rule 2 (Line 25–Line 29) can be used to calculate its runtime slowdown factor. If τ_{(i, k)} is a G2-type subtask, Rule 3 (Line 33–Line 37) or Rule 4 (Line 40–Line 43) can be used to calculate its runtime slowdown factor. The runtime voltage of τ_{(i, k)} is set in Line 46–Line 47. Upon task completion, LST is recalculated according to the running speed and AET of τ_{(i, k)} in Line 49.

On the basis of slack time reservation, the HTDVS-SRT algorithm decides whether the subtask to be run can reuse the reclaimed slack time, and how much slack time the subtask can reuse. We define the following four rules when reusing slack time.

_{(i, k)}_{(i,k)}

_{(i, k)}_{(i, k)}_{(i, k)}

_{(i, k)}_{(i, k)}_{(i, k)}

_{(i,k)}

_{(i,m)}

_{i}

_{(i,k)}

_{(i,k)}′)

_{(i,k)}′; AET

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}. S

_{(i,k)}′

_{i}

_{(i,m)}

_{(i,m-1}

_{)}> 0)) { 4

_{i}

_{(i,m)}

_{(i,m-1)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′ = S

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{idl(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}> GST(i)

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)})

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{i}

_{i}

_{max}

_{(i,k)}′

_{(i,k)}′

_{i}

_{(i,k)}

_{(i,k)}

_{max}

_{(i,k)}′)

_{(i,k)}

In Rule 1 and Rule 2, the purpose of setting a lower threshold for reserved slack time is to use more slack time to lower the running speed of a G1-type SRT's subtask. By using Rule 1 and Rule 2, a G1-type SRT's subtask τ_{(i, k)} will try its best to work at its ideal speed or a lower speed. Using Rule 3, a G2-type SRT's subtask τ_{(i, k)} reserves IRST time for its subsequent subtasks, and τ_{(i, k)} runs at a lower speed.

The HTDVS-SRT algorithm is shown in Algorithm 2. In Algorithm 2, Line 3–Line 35 are the pseudo code before releasing τ_{(i, k)}, and Line 37 is the pseudo code upon τ_{(i, k)} ends. Line 3–Line 16 set the LST of τ_{(i, k)}. Line 17 sets the runtime slowdown factor of τ_{(i, k)} to its static slowdown factors by default. If τ_{(i, k)} is a G1-type subtask, Rule 1 (Line 19–Line 20) or Rule 2 (Line 21–Line 25) can be used to calculate its runtime slowdown factor. If τ_{(i, k)} is a G2-type subtask, Rule 3 (Line 29–Line 32) can be used to calculate its runtime slowdown factor. The runtime voltage of τ_{(i, k)} is set in Line 34–Line 35. Upon task completion, LST is recalculated according to the running speed and AET of τ_{(i, k)} in Line 37.

1

_{(i,k)}

_{(i,m)}

_{i}

_{(i,k)}

_{(i,k)}′)

_{(i,k)}′; AET

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}. S

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′= S

_{(i,k)}

_{(i,k)}

_{(i,k)}≥

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{idl(i,k)}

_{(i,k)}≥

_{(i,k)}

_{(i,k)}

_{(i,k)}> GST(i)

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{(i,k)}′

_{(i,k)}

_{(i,k)}

_{(i,k)}

_{i}

_{i}

_{max}

_{(i,k)}′

_{(i,k)}′

_{i}

_{i})

_{i})

_{(i,k)}

_{(i,k)}

_{max}

_{(i,k)}′)

_{(i,k)}

We developed a simulator using Visual C++ to test the HTDVS algorithm presented in this paper. This simulator can accept the speed/energy consumption function of a processor in its processor model and tasks' parameters in its task model as input, and analyze the energy consumption when using the HTDVS algorithm. In the following experiments, we use the method presented in [_{i}_{(i,k)}_{B(i,k)}

Because the task model and scheduling model in this paper are different from those of the existing works in energy-saving research, we are not able to compare our method to other known DVS algorithms, such as the RT-DVS algorithm [

In this experiment, after generating the task set, we randomly changed the properties of task type and made the HRCTs have the following ratio: 0, 33%, 50%, 66%, and 100%, corresponding to T0, T33, T50, T66 and T100 respectively. Under each utilization, we measured the energy consumption and the DMR of SRTs (deadline-missing task number of SRTs/total number of SRTs) at different HRCT ratio when using the HTDVS algorithm. The experiment results are shown in

The greedy algorithm is a widely used dynamic energy reclamation and reuse algorithm [

In this experiment, we use a randomly generated task set with 50% HRCTs and 50% SRTs. After generated the task set, we randomly change the energy-saving goals of subtasks and make the tasks with G2-type energy-saving goals have the following ratio: 0, 33%, 50%, 66%, and 100%, corresponding to T0-100 respectively. Under each utilization, we measure the energy consumption when using the HTDVS algorithm. The experimental results are shown in

Aiming at the energy-saving problem for IoT control devices, we present the HoW task model and an energy-saving method called HTDVS. Experimental results show the HTDVS algorithm is influenced by the ratio of HRCTs and the energy-saving goals of subtasks, and it has similar energy-saving effect with the greedy algorithm. Our future work will focus on: (1) how to extend HoW to model aperiodic tasks and sporadic tasks, extend the processor model to multiple core processors, and integrate the new system model into HTDVS; (2) how to accelerate specific SRTs to meet their DMR under a given threshold; and (3) how to integrate other constraints, such as temperature, into energy-saving algorithm in order to avoid errors when software runs in extreme environment.

This work has been supported by the National Natural Science Foundation of China (No. 60773042 and No. 60903167), the sub-foundation of Zhejiang Provincial Key Innovation Team on Sensor Networks (No. 2009R50046-3), the Zhejiang Provincial Key Science and Technology Program (No. 2009C14013), the Zhejiang Provincial Natural Science Found (No. Y1101336) and the Scientific Research Found (No. KYS055608107).

Structure of a HRCT _{i}

Process of assigning tasks' speeds.

Task level tree in [

Normalized energy consumption at different task type ratio.

DMR of SRTs at different task type ratio.

Normalized unweighted energy consumption when using different energy-saving algorithms.

Normalized weighted energy consumption when using different energy-saving algorithms.

Normalized energy consumption at different subtask type ratio.