Server Resource Reservations for ComputationOffloading in Real-Time Embedded Systems

Anas TomaDepartment of Informatics

Karlsruhe Institute of Technology, Germanyanas.toma@student.kit.edu

Jian-Jia ChenDepartment of Informatics

Karlsruhe Institute of Technology, Germanyjian-jia.chen@kit.edu

Abstract—Mobile devices have become very popular nowadays.They are used nearly everywhere. They run complex appli-cations where the multimedia data are heavily processed. Forexample, ubiquitous applications in smart phones and differentsurveillance tasks on mobile robots. However, most of theseapplications have real-time constraints, and the resources ofthe mobile devices are limited. So, it is challenging to finishsuch complex applications on these resource-constrained deviceswithout violating the real-time constraints. One solution is toadopt the Computation Offloading concept by moving somecomputation-intensive tasks to a powerful server. In this paper,we use the total bandwidth server (TBS) as resource reservationsin the server side, and propose two algorithms based on thecomputation offloading to decide which tasks to be offloaded andhow they are scheduled, such that the utilization (i.e., bandwidth)required from the server is minimized. We consider frame-basedreal-time tasks, in which all the tasks have the same arrivaltime, relative deadline and period. The first algorithm is agreedy algorithm with low complexity based on a fast heuristic.The second one is a pseudo-polynomial-time algorithm based ondynamic programming. Finally, the algorithms are evaluated witha case study for surveillance system and synthesized benchmarks.

I. INTRODUCTION

Mobile devices are running more and more complex ap-plications that include computation-intensive data processing.For example, surveillance robots perform real-time moni-toring for security, rescue and safety purposes [4, 9, 11].Also, smart phones are increasingly used to run heavy taskssuch as 3D navigation [18, 26], ubiquitous and multimediaapplications [3, 19], etc. Google Glass [2] is an exampleof the next-generation ubiquitous systems, which performsvoice recognition, navigation, translation, video streaming andrecording, etc. Such multimedia mobile applications usuallyrequire high computation power. However, these mobile de-vices are resource-constrained. They have limited computationcapabilities and battery life. They may not be able to completethe execution of the computation-intensive tasks in time. Com-putation offloading concept has been adopted in the literatureto improve the performance of the mobile devices with thehelp of external resources, i.e., remote processing unit. Figure1 shows an example of the offloading mechanism. We use theterm client to refer to the mobile device that offloads the tasks,and the term server to refer to the remote processing unit thatexecutes the offloaded tasks.

In this paper, we exploit computation offloading to scheduleframe-based real-time tasks in a client, where all the taskshave the same arrival time, period and relative deadline. For

Google glass [2]

Surveillancerobot [1]

Smart phone

RemoteProcessingUnit

Fig. 1: Example of the offloading Mechanism.

instance, in surveillance systems once the camera capturesan image, several tasks start processing it, in which all ofthem should be completed before the next capture, whichrepresents the relative deadline of the task execution. Usually,the tasks in the surveillance systems run periodically (witheach image capture) and usually include motion detection,object recognition, behavioral analysis, and analysis of thestereo vision [24, 25]. These tasks are computation intensivefor resource-constrained devices, and may not finish before thedeadline. Therefore, our proposed algorithms use the computa-tion offloading to guarantee the execution of the tasks withoutviolating the real-time constraints. To solve this problem, twodecision-making points should be addressed: (1) which tasksto be offloaded (i.e., offloading decision), and (2) when tooffload the selected tasks for offloading (i.e., task ordering).

In real-time systems, when the client decides to offload atask to a server, such computation offloading should still makethe offloaded task meet its (hard or soft) timing constraint, i.e.,the task should be completed in time under the given (hard orsoft) timing parameters. Therefore, the server should also pro-vide some timing properties for executing the offloaded tasks.The offloading decision in the most of existing studies, e.g.,[7, 16, 27], is based on a simple comparison to check whetherit is beneficial in terms of processing time (or processing cost)to offload a task.

In our previous study in [23], we design and analyze thecomputation offloading mechanism for frame-based real-timetasks when the server provides round-trip timing information.That is, when an offloaded task arrives at the server attime t, the client can receive the computation at time tplus the provided round-trip time. However, such a round-trip timing information requires resource reservations in the

2013 IEEE 31©c978-1-4799-1284-1/13/ $31.00

server(s) before the offloading decisions are made. If a taskis not offloaded such a reservation becomes useless and thecapability of the server(s) is wasted. In another study in [22], atotal bandwidth server (TBS) [21] is used in the server side toserve a client for computation offloading. Specifically, whenthe bandwidth (utilization) of the TBS is given, the algorithmsin [22] minimize the finishing time (makespan) by using aheuristic algorithm and a dynamic programming approach.

In [22], if the given bandwidth (utilization) of the TBS fora client is too high, the capability in the server side is stillwasted. Determining the bandwidths for individual clients re-mains open. In this paper, we consider computation offloadingfor real-time embedded systems, in which the objective is tofind the minimum required bandwidth reservation for TBSin the server side to meet the timing constraint of the real-time tasks. Therefore, depending on the availability of theremaining bandwidth in the server, the server will grant theclients the required utilization (or even adjust the bandwidthsfrom other clients to make all the clients meet their timingconstraints).

The considered problem is a dual problem of the problemstudied in [22]. That is, the bandwidth (utilization) of the TBSis a given constraint and the minimization of the finishing timeof the tasks is the objective for the problem studied in [22],whereas the finishing time of the tasks is a constraint and theminimum required bandwidth (utilization) of the TBS is theobjective in this paper. It has been shown in [22] that thedecision version for studied problem in this paper and also in[22] is also NP -complete in the weak sense.

Our Contribution: Our contribution can be summarizedas follows:

• In our model, we consider the scheduling on both clientand server sides, where the server can serve more thanone client.

• We propose two computation offloading algorithms, agreedy algorithm with low time complexity, and a dy-namic programming algorithm with pseudo-polynomialtime complexity. The algorithms schedule the real-timetasks on the client side, and decide which tasks to beoffloaded to the server, such that the real-time constraintsare satisfied and the required utilization is minimized.

• We evaluate our algorithms using a surveillance systemas a case study and randomly synthesized benchmarks.

II. RELATED WORK

In this section, we provide a summary for the recent studiesin the field of computation offloading. Also, we discuss thelimitations of the existing approaches.

Nimmagadda et al. [16] use the computation offloading toimprove the performance and satisfy the real-time constraintsfor a mobile robot. The robot performs real-time moving objectrecognition and tracking. For each task, the offloading decisionis taken if the summation of the communication time and theserver execution time is less than the local execution timeon the robot. The computation offloading is also consideredby Wolski et al. [27] and Gurun et al. [7] to improve theperformance for computational grid settings. The offloading

decision in their work is based on the prediction of the clientexecution time, the transfer time and the server execution time.They assume that the offloading of a task is beneficial only ifthe expected cost of the remote execution, including the serverexecution time and the data transfer time, is less than the costof the local execution.

The Offloading problem is represented as a graph partition-ing problem in [6, 14, 15, 17, 29] and has been solved usingdifferent approaches. Each vertex of the graph represents acomputational component, such as program class in [6, 17, 29]or a task in a program as in [14, 15]. An edge between twovertices represents the communication cost between them. Themain idea is to partition the graph into two parts, client sideand server side.

A middleware for mobile Android platforms is proposed in[12] to offload the computation intensive tasks to a remoteclouds. The offloading problem is represented as an optimiza-tion problem and solved using integer linear programming. Toreduce the energy consumption in battery-powered systems,the computation offloading is adopted in [28] based on atimeout mechanism, and also adopted in Hong et al. [8] fora system that performs content-based image retrieval. Ferreiraet al. [5] explore the computation offloading to improve thequality of service in the adaptive real-time systems.

The offloading decision in the most of existing studies isbased on either simple comparison for each task alone, orrepresenting a program as a graph and then partition it [13].In both approaches, the task scheduling is not consideredneither on the client nor on the server. For example, the clientremains idle during offloading until the result returns backfrom the server. Instead, an independent local task can beexecuted during the offloading of another task to improvethe performance. Also, it is important to consider the servermodel, and how it schedules the tasks to serve more than oneclient. Based on the existing approaches, the powerful serveris always ready to execute the offloaded tasks from the clientimmediately, which means that the server is dedicated for oneclient.

III. SYSTEM MODEL

This section presents the system model of the paper. Asthe problem is a dual problem of [22], the terminologies andsystem architecture are similar to our previous work in [22].However, the problem definition here is different from [22].We say that a schedule for a set of tasks is feasible if the totalfinishing time for all of the tasks is within the deadline D.

A. Client Side

On the client side, a set T of n independent frame-basedreal-time tasks arrive periodically at the same time t = 0,have the same period D, and require execution within thesame relative deadline D. The client schedules the tasks anddecides which of them to be offloaded to the server in orderto satisfy the real-time constraints. Each task τi ∈ T (fori = 1, 2, . . . , n) is characterized by the following timingparameters:

• Ci: Local execution time on the client side.

32

Server

dScheduler

(EDF) RRSRRS

RRSServers

CPU

Task set

Deadline

Client

dTask

orderingOffloading

decision

Local Tasks

OffloadedTasks

CPU

Required USOffloading

Scheduler

For other clients

Fig. 2: Offloading System Architecture.

• Si: Setup time. The execution time required on the clientside to be ready for offloading. It includes any prepro-cessing operations such as encoding and compression. Italso includes the sending time of the data of the task fromthe client to the server.

• Ri: Remote execution time. The execution time on theserver side.

A task is said locally executed if it is executed with atmost Ci amount of time only on the client side. A task issaid offloaded if it is executed on the server side after settingup on the client side. That is, if a task is offloaded, it hasto be executed (at most) Si amount of time on the client,and then executed with (at most) Ri amount of time on theserver. The timing information Ci, Si, and Ri can be eithersoft based on profiling or hard based on static timing analysiswith predictable communication fabrics. When the informationis soft, we provide soft real-time guarantees, and vice versa.

B. Server Side

The server is able to serve more than one client. TotalBandwidth Server (TBS) is considered in our server model[20, 21]. The client finds the feasible schedule that requiresthe minimum utilization (or bandwidth) Us from the server.If it is possible, the server assigns a TBS for each requestingclient such that the total utilization of all given TBS’s are lessthan or equal to 100%. Figure 2 shows the architecture of theoffloading system. The TBS of each client assigns an absolutedeadline ds(t) for each incoming (offloaded) task τi from thatclient, where τi arrives at the server side at time t. Let ds(t−)be the absolute deadline of the previous offloaded task, andds(0

−) is equal to 0. Then, the absolute deadline ds(t) can becalculated as follows:

ds(t) = max{t, ds(t−)}+Ri

Us

The server schedules the offloaded tasks according to theEarliest Deadline First (EDF) algorithm based on the assignedTBS deadlines. By having at most 100% total utilization,the server guarantees that all the offloaded tasks meet their

assigned deadlines [21].

C. Problem Definition

The problem addressed in this paper can be defined asfollows: Given a set T of n frame-based real-time tasks and adeadline D. The problem is to find a schedule that meets thedeadline D, and the offloading decisions for the tasks in Twith the minimum required TBS utilization Us from the server.

IV. KNOWN RESULTS FOR MINIMIZING MAKESPAN

In this subsection, we summarize the technique used inour previous work in [22] to find the optimal ordering ofthe tasks for a given Utilization Us. We define the vector�x = (x1, x2, . . . , xn) to represent the offloading decisions ofthe tasks in T = {τ1, τ2, . . . , τn}. xi = 1 means that thetask τi is assigned for offloading, and xi = 0 means that it isassigned for local execution. We suppose that the offloadingdecisions �x are known for all the tasks (i.e., what to offload),and we want to determine here the ordering of the tasks (i.e.,when to offload). The makespan of a task set T is the totalcompletion time of the tasks in T on both client and serversides.

For each task τi, let Pi,c be its execution time on theclient side, and Pi,s its remote execution time divided bythe utilization of the TBS. The two terms can be defined asfollows:

Pi,c = xiSi + (1− xi)Ci, (1)

Pi,s = xiRi

Us. (2)

Based on Johnson’s rule [10] we divide the tasks into twosets T1 and T2 as follows:

• T1 = {τi|Pi,c ≤ Pi,s}.• T2 = {τi|Pi,c > Pi,s}.First, we schedule the tasks in the set T1 in increasing order

according to Pi,c. Then, the tasks in the set T2 in decreasingorder according to Pi,s.

Lemma 1: For a given �x and utilization Us, the orderingof the tasks execution based on Johnson’s rule is optimal forminimizing the makespan of the execution.

Proof: The proof is in the paper [22].Corollary 1: All the local tasks belong to the set T2 and

scheduled at the end.Proof: This comes from the definition that Pi,s = 0 if τi

is locally executed.For a given set of tasks T , the proposed dynamic pro-

gramming algorithm F (T , D, Us) in [22] returns true ifthere exists a schedule, under a given utilization Us, with amakespan less than or equal to D. Otherwise it returns false.

V. OPTIMAL TASK ORDERING

As we discussed in Section I, the offloading decision and thetask ordering are important to solve our offloading problem.In this paper, we use the optimal ordering from our previouswork in [22] to minimize the makespan of the execution. InSection IV we discussed the optimal ordering of the tasks for

33

a given Us. But in our problem, we want to minimize therequired utilization from the server. Changing the utilizationmay also changes the execution order of the tasks. In Sub-section V-A we determine all the possible utilization levelsthat may change the ordering of the tasks. In Subsection V-Bwe find the interval that contains the minimum requiredutilization.

A. Utilization Levels

Lemma 2: For any given 0 ≤ Us ≤ 1, and according to theincreasing order of the tasks by Ri

Si, if i < j and the task τj

is in the set T2 then τi is also in the same set.Proof: By the definition of the set T2, τj ∈ T2 implies

that Sj >Rj

Us⇒ Us >

Rj

Sj. But we know that Ri

Si<

Rj

Sj

(because of the ordering and i < j). Then, Us > Ri

Si⇒ Si >

Ri

Us⇒ τi ∈ T2.

Based on the definition of the sets T1 and T2, changing theutilization Us may change the relation between Si and Ri

Usand

then moves a tasks(s) from one set to another, which will resultin a new combination of T1 and T2. The following theoremdetermines the maximum number of possible combinations forT1 and T2.

Theorem 1: The combinations of the sets T1 and T2 are atmost n+ 1 combinations.

Proof: Let task τi be the task with the maximum Ri

Si

in the set T2. According to Lemma 2 and the increasingorder of the tasks by Ri

Si, T2 = {τ1, τ2, . . . , τi} and T1 =

{τi+1, τi+2, . . . , τn}, which are at most n − 1 combinationsfor i = {1, 2, . . . , n − 1}. Clearly, by considering also thetwo cases when T1 and T2 are empty, we have in total n+ 1combinations.

Theorem 2: The decreasing of the utilization Us from 1 to0 moves the tasks from the set T2 to the set T1.

Proof: Assume that Us1 and Us2 are two different uti-lization values, such that Us1 ≥ Us2 . Also, let T1(Us) andT2(Us) be the two sets T1 and T2 for a given utilization Us.We want to proof that if Us1 ≥ Us2 , T1(Us1) ⊆ T1(Us2) andT2(Us1) ⊇ T2(Us2).

Suppose for contradiction that there exists a task τi suchthat τi ∈ T1(Us1) and τi /∈ T1(Us2). Clearly, if τi ∈ T1(Us1)we have:

Si ≤Ri

Us1

⇒ Us1 ≤ Ri

Si(3)

Also, if τi /∈ T1(Us2) we have:

Si >Ri

Us2

⇒ Us2 >Ri

Si(4)

From Equations 3 and 4, we have Us1 < Us2 which contradictsour assumption that Us1 ≥ Us2 . The same argument appliesfor T1(Us1) ⊇ T1(Us2).

Algorithm 1 finds all possible utilization levels that maychange the ordering of the tasks; i.e., the ordering of the taskswill never change if the utilization changes within the sameinterval (between two consecutive utilization levels). Startingfrom Us = 1, we order the tasks according to Lemma 1 byoffloading all of them, to construct the sets T1 and T2 (Lines 1

Algorithm 1 Utilization levels

1: T1 = {τi|Si <= Ri};2: T2 = {τi|Si > Ri};3: ∀τi ∈ T2, order them according to Ri

Si;

4: Initialize a vector V [|T2|+ 2];5: k ← 1, Vk ← 0, Vsize(V ) ← 1;6: while T2! = ∅ do7: pick the task τj from T2 with the maximum Rj

Sj;

8: k ← k + 1;9: Vk ← Rj

Sj;

10: T2 ← T2 \ {τj};11: T1 ← T1 ∪ {τj};12: end while13: return �V ;

and 2). A vector �V is initialized to store the utilization levels,including Us = 0 and Us = 1 (Lines 4 and 5). Accordingto Theorem 1, all the combinations of T1 and T2 are known.The next combination happens by decreasing the utilizationaccording to Theorem 2, which moves the task τi with themaximum Ri

Sifrom T2 to T1 (Lines 6-12). This task moves

once its Si = Ri

Us, which implies that Us = Ri

Siis the next

utilization level.Clearly, the time complexity of the ordering (Line 3) is

O(n log n), and the while loop (Lines 6-12) is O(n). So, thetime complexity of the algorithm is O(n log n).

B. Minimum Utilization Interval

We determine the utilization intervals in subsection V-A,where the execution order does not change by changing theutilization within the same interval. Now, we want to findthe utilization interval that contains the minimum utilizationrequired from the server such that the schedule is feasible. Wecall it here the minimum utilization interval.

The function F (T , D, Us), from our previous work in [22],is used in Algorithm 2 to check if there exists a feasibleschedule. The algorithm returns NULL, if there is no fea-sible schedule under the highest possible utilization Us = 1(Lines 2-4). We use the binary search (Lines 5-12) to find theminimum utilization interval (Vl, Vh]. This interval is betweentwo utilization levels Vi and Vi+1, such that there exists afeasible schedule under the utilization Us = Vi+1, and thereis no feasible schedule under the utilization Us = Vi. The timecomplexity of the function F (T , D, Us) is O(nD2), and thebinary search is O(log n). Therefore, the total time complexityof Algorithm 2 is O(D2n log n).

VI. HARDNESS OF THE OFFLOADING PROBLEM

Theorem 3: The offloading problem is NP-hard.Proof: The current offloading problem is an optimization

problem to minimize the required utilization. The decisionversion of this problem is the same as the COTBS problem inour previous paper [22], which has been proved that it is anNP-complete problem.

34

Algorithm 2 Minimum utilization interval

1: l ← 1, h ← size(V )2: if !F (T , D, Vh) then3: retrun NULL;4: end if5: while h− l > 1 do6: i ←

⌊h+l2

⌋7: if !F (T , D, Vi) then8: l ← i;9: else

10: h ← i;11: end if12: end while13: return (Vl, Vh];

VII. OUR APPROACH

The solution of our offloading problem is composed of twoparts: the task ordering (from Section V) and the offloadingdecision. In this section, we propose two algorithms to deter-mine the offloading decision.

Algorithm 2 is used to determine the minimum utilizationinterval (Vl, Vh]. Then, the binary search within this intervalcan be used to find the minimum required utilization in orderto be feasible. The time complexity to check if there exists afeasible schedule under a given utilization is O(nD2), andthe binary search complexity is O(log Vh−Vl

ε ), where ε isthe tolerance of the search. So, the total time complexity isO(nD2 log Vh−Vl

ε ). Our proposed algorithms in this sectionprovide solutions that are close to the optimal, and faster thanthe binary search.

In our system, the client finds the minimum required utiliza-tion from the server that guarantees a feasible schedule. Thefollowing theorem shows that the feasibility is also guaranteedif the server provides the client with a utilization value that ismore than the required.

Theorem 4: A feasible schedule based on the minimumrequired utilization remains feasible even if a higher utilizationis provided from the server.

Proof: If the given utilization from the server does notaffect the ordering (i.e., the ordering remains according toLemma 1), the schedule remains feasible. If the order ofthe tasks changes after the given utilization, the makespandecreases due to the optimality of the ordering of Lemma 1,and then the schedule remains also feasible. In both cases theresponse time from the server decreases.

A. Greedy algorithm

We propose a greedy algorithm that requires only lowcomplexity, where its time complexity is O(n log2 n). Thealgorithm is faster than the binary search. Based on theoffloading decision from this algorithm, and the ordering ofthe tasks according to Lemma 1, the next utilization level thatachieves a feasible solution can be easily determined using theutilization levels from Algorithm 1. For notational brevity, weuse the following notations in this subsection:

Client Y∑

τi∈T (1− xi)ai

ServerD

(a)

Client Y∑

τi∈T (1− xi)aiaj

Server∑

τi∈T xiRi

D

(b)

Client Y∑

τi∈T (1− xi)ai

Server∑

τi∈T xiRi Rj

D

(c)

Client Y∑

τi∈T (1− xi)ai

Server∑

τi∈T xiRi

D

(d)Fig. 3: Illustration of Algorithm 3.

• Y =∑

τi∈T Si: the summation of the setup time for allof the tasks.

• ai = (Ci − Si) for τi: the difference between the localexecution time and the setup time.

We know that a schedule is feasible if the following twoconditions hold:

1) the offloaded tasks finish their setup time and the localtasks finish their local execution time within the deadline,i.e., Y +

∑τi∈T (1− xi)ai ≤ D, and

2) the last TBS deadline of the offloaded tasks, which is atleast

∑τi∈T xi

Ri

Us, is less than or equal to the deadline.

Where xi is equal to 1 if task τi is decided to be offloaded;otherwise, xi is equal to 0. Our algorithm minimizes the valueof

∑τi∈T xiRi without violating the first feasibility condition

mentioned above (we will use the term condition 1), which canbe represented by the following integer linear programming(ILP):

minimize∑τi∈T

xiRi (5a)

s.t Y +∑τi∈T

(1− xi)ai ≤ D (5b)

xi ∈ {0, 1} ∀i = 1, 2, . . . , n. (5c)

The utilization Us =∑

τi∈T xiRi

D is a lower bound of theminimum required utilization from the server. Here, we presenta heuristic to decide whether a task is locally executed oroffloaded by using the heuristic presented in Algorithm 3.

The greedy algorithm, which is described in Algorithm 3,works as follows:

• At the beginning, all the tasks are assigned for localexecution. Only the tasks that may be beneficial foroffloading, their Si < Ci, are ordered in the list L

35

Algorithm 3 Greedy Algorithm

1: ∀τi ∈ T , xi ← 0, Y =∑

τi∈T Si, ai = (Ci − Si);2: ∀τi ∈ T |Si < Ci, order them according to Ri

aiin a list L;

3: while (Y +∑

τi∈T (1− xi)ai) > D do4: pick the task τj from L with the minimum Rj

aj;

5: xj ← 1;6: L ← L \ {τj};7: end while8: min ← ∑

τi∈T xiRi, ind ← j;9: xj ← 0;

10: while L! = ∅ do11: pick the task τj from L with the minimum Rj

aj;

12: xj ← 1;13: if (

∑τi∈T xiRi < min)∧(Y +

∑τi∈T (1−xi)ai ≤ D)

then14: min ← ∑

τi∈T xiRi, ind ← j;15: end if16: xj ← 0;17: L ← L \ {τj};18: end while19: xind ← 1;20: return min

D ;

(Lines 1 and 2).• As long as condition 1 is not satisfied (as represented in

Figure 3a), the algorithm keeps picking the task τj withthe maximum value of Rj

ajfrom the list L and assigns it

for offloading, as illustrated in Figures 3b and 3c (Lines 3and 7).

• The algorithm stores the index of the first task τj thatmakes the condition 1 satisfied as soon as it is assignedfor offloading, and also stores the value of

∑τi∈T xiRi as

a minimum possible value. Then, it is assigned for localexecution without returning it back to the list L (Lines 8and 9).

• For the remaining tasks in the list L, the algorithmsearches for a task τj , such that if it is assigned foroffloading we gain the minimum possible

∑τi∈T xiRi

value, without violating the condition1. The resultingvalue min

D returned in Line 20 provides a lower boundof the utilization for this decision of xis.

The time complexity for deciding whether a task τi isoffloaded or not for all the tasks is O(n log n), which isdominated by the sorting of Rj

aj. After the decision is done, we

still have to find a suitable utilization to ensure the feasibilityfor this offloading decision. Here, we incrementally check theutilization levels defined in Section V-A, by considering theutilization levels that are larger than min

D . The algorithm stopswhen a certain utilization returns a feasible schedule. Verifyingthe feasibility of a schedule under a given utilization levelrequires O(n log n) time complexity, whereas the search ofthe minimum utilization levels defined in Section V-A for theoffloading decision to be feasible takes O(log n) iterations.Therefore, the overall time complexity is O(n log2 n).

tset

S10

Client

Server R1 / US1

τ1

τ1D

DF(1,tset ,tloc)

(a)

S10

Client

Server

C2

R1 / US1

tlocτ1

τ1

τ2

D

DF(2,tset ,tloc)

tset

(b)tset

S10

C3Client

Server

C2

R1 / US2

S4

R4 / US2

tlocτ1 τ4

τ1

τ2 τ3

τ4D

DF(4,tset ,tloc)

(c)Fig. 4: Illustration of the dynamic programming algorithm.

B. Dynamic Programming Algorithm

Based on dynamic programming, we present a pseudo-polynomial-time scheduling algorithm to minimize the re-quired utilization from the server, without violating the timingconstraints. To construct the dynamic programming table, weneed to order the tasks first. We consider the ordering of thetasks according to Lemma 1 when all of them are offloaded.We use Lemma 1 just for ordering. The offloading decision isdetermined using the dynamic programming algorithm.

For a given set of tasks T = {τ1, τ2, . . . , τn}, considerthe subproblem for the first i tasks, i.e., {τ1, τ2, . . . , τi}. LetU(i, tset, tloc) be the minimum required utilization from theserver, such that the schedule of the tasks is feasible, underthe following constraints:

• The total setup time for the offloaded tasks among thefirst i tasks is less than or equal to tset.

• The total execution time for the local tasks among thefirst i tasks is less than or equal to tloc.

Also, let F (i, tset, tloc) be the setup time of the first offloadedtask under the same constraints above. Figure 4c showsan example for a schedule of four tasks to illustrate thedynamic programming parameters, where the tasks {τ1, τ4}are offloaded, and the tasks {τ2, τ3} are executed locally.

We construct two tables U and F , with three dimensionsand size n × D × D. All the elements in U(0, tset, tloc) andF (0, tset, tloc) are initialized to zero. For 1 ≤ i ≤ n, we fillthe table U according to the following recursion:

U(i, tset, tloc) =

{ Equation 7 tset + tloc ≤ D.

∞ otherwise (6)

36

min

{max{U(i− 1, tset − Si, tloc) +

Ri

D−F (i−1,tset−Si,tloc), Ri

D−tset} Si < Ci ∧ tset ≥ Si

U(i− 1, tset, tloc − Ci) tloc ≥ Ci

}(7)

Where 0 ≤ tset ≤ D and 0 ≤ tloc ≤ D.For any given tset and tloc, such that tset + tloc ≤ D,

the algorithm determines the offloading decision for the taskτi that achieves the minimum required utilization for thesubproblem {τ1, τ2, . . . , τi}. If tset + tloc > D, there is nofeasible solution and ∞ is stored in the table.

According to Equation 7, the task τi can be offloaded if itis beneficial (i.e., Si < Ci), and there is enough setup timetset (i.e., tset ≥ Si). Also, it can be executed locally if thereis enough local execution time tloc (i.e., tloc ≥ Ci). If the taskτi is assigned for local execution, the utilization remains thesame as of the previous subproblem U(i− 1, tset, tloc − Ci).Also, the the value of F (i, tset, tloc) remains the same as F (i−1, tset, tloc−Ci), because the setup time of the first offloadedtasks does not change by adding local tasks. Figure 4b showsan example where assigning the task τ2 for local executiondoes not change the utilization Us1 of the previous subproblemshown in Figure 4a (where tloc is equal to 0).

If the task τi is assigned for offloading, the value ofF (i, tset, tloc) also remains the same as F (i − 1, tset −Si, tloc). It only changes if τi is the first offloaded task,where F (i − 1, tset − Si, tloc) = 0. Then, we considerF (i − 1, tset − Si, tloc) = Si, which leads the utilization tobe equal to Ri

D−Si. Therefore, the two parameters that change

the system utilization by offloading τi (where it is not the firstoffloaded task) are: its remote execution time Ri and the timeat which the server start executing it. So, the new value of thesystem utilization U(i, tset, tloc), in the case of offloading, isthe maximum of the following:

• U(i−1, tset−Si, tloc)+Ri

D−F (i−1,tset−Si,tloc): where the

utilization of the task τi in the period D−F (i−1, tset−Si, tloc) is added to the system utilization of the previoussubproblem.

• Ri

D−tset: In this case, the tset is too long such that the

utilization above violates the system feasibility. Then, theutilization of task τi in the period D − tset restricts thesystem utilization to maintain the feasibility.

The algorithm stores the offloading decisions combined withall elements of the table U .

Finally, to minimize the required utilization, we find theminimum of U(n, tset, tloc) for all possible values of tset andtloc, such that their summation is less than or equal to D. Then,we backtrack the table starting from the location that achievesthe minimum value above. If the task τi is assigned for offload-ing, we backtrack to U(i− 1, tset − Si, tloc). If it is assignedfor local execution, we backtrack to U(i− 1, tset, tloc − Ci).The time complexity of the algorithm is O(nD2).

VIII. EXPERIMENTAL EVALUATION AND SIMULATION

In this section, we evaluate our algorithms using a casestudy of surveillance system, and synthesis workload simu-lation. The terms Greedy and DP refer to the greedy and

TABLE I: Timing parameters of case study tasks (ms)τi Description Ci Si Ri

τ1 Motion Detection 30 7 21τ2 Object Recognition 220 2 102τ3 Stereo Vision 88 16 41τ4 Motion Recording 18 7 14

0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

127 148 169 190 211 232 253 274 295 316 337 358

Min

imum

requ

ired

utili

zatio

n

D (ms)

GreedyDPSearch

Fig. 5: Case study results.

the dynamic programming algorithms respectively. Also, theterm Search is used to refer to the binary search for theminimum required utilization. The search is performed withinthe minimum utilization interval from Subsection V-B. TheSearch algorithm is used here as a baseline to evaluate theefficiency of the other algorithms.

A. Case Study of a Surveillance System

The surveillance system consists of a client and a server.The client performs four frame-based real-time tasks on theinput video. The server processes the offloaded tasks from theclient, and returns the results back. The tasks are independentof execution and can be described as follows:

• Motion Detection: to detect any moving objects.• Object Recognition: to recognize and track the object of

the interest.• Stereo Vision: to construct a depth map of the view.• Motion Recording: to record the detected video for fur-

ther examination.All the tasks can be executed either on the client or onthe server. Table I shows the timing parameters of the tasksin milliseconds (ms). The algorithms are implemented onthe client to find the schedule that minimizes the requiredutilization from the server without violating the real-timeconstraints.

Figure 5 shows the minimum required utilization using eachalgorithm for different deadlines. We observe that there existsa feasible solution for deadline D ≥ 127, where the requiredutilization is close to 1 at D = 127. As the deadline increases,

37

the required utilization decreases, because the possibility ofexecuting more local tasks increases. For D ≥ 356, therequired utilization is equal to 0 because there is enough timeto execute all of the tasks locally.

B. Simulation Setup and Results

A synthetic workload is also used to evaluate our al-gorithms. Timing parameters of the tasks are generated asfollows:

• Ci: Randomly generated integer values from 1 to 50 mswith uniform distribution.

• Si: Randomly generated integer values from 1 to Ci mswith uniform distribution.

• Ri: Ri =Ci

α , where α is the speed-up factor of the server.For each value of α = {0.5, 2, 4}, we perform 20 rounds. In

each round, a set of 10 frame-based real-time tasks is randomlygenerated and evaluated for different deadline values.

Figure 6 shows the average minimum required utilization forthe generated tasks above. If the deadline increases, the clientuses the additional time for local execution, which reduces thenumber of offloaded tasks and then the required utilization.Also, the speed-up factor of the server affects the requiredutilization. For a specific deadline (among Figures 6a, 6b and6c), the utilization decreases if the speed-up factor of theserver (α) increases, because the response time of the offloadedtasks becomes shorter. The figures also show that the dynamicprogramming and the search algorithms have nearly the sameresults.

In Figure 6a, the server is two times slower than the client.Nevertheless, our system offloads tasks to the server. Becausethe local tasks are executed during the offloading of the othertasks, instead of remaining idle until the results return backfrom the server.

IX. CONCLUSION

In this paper, we explore the computation offloading tosatisfy the real-time constraints in mobile devices. We adoptthe total bandwidth server (TBS) on the server side forresource reservation. There are two challenges to performcomputation offloading: which tasks to offload, and at whattime each task should be offloaded. Therefore, the clientuses the proposed algorithms to schedule frame-based real-time tasks and decide what to offload to the server, suchthat the required utilization from the server is minimized.The time complexity of the greedy algorithm is less thanthe time complexity of the dynamic programming algorithm,but our experimental evaluation and simulation show thatthe dynamic programming is more efficient in the term ofminimizing the required utilization. We plan to extend ourwork to consider periodic/sporadic real-time tasks and otherresource reservation servers.

Acknowledgement This work is supported in parts bythe German Research Foundation (DFG) as part of thepriority program “Dependable Embedded Systems”, byBaden Wurttemberg MWK Juniorprofessoren-Programms andDeutscher Akademischer Austauschdienst (DAAD).

0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

255

260

265

270

275

280

285

290

295

300

305

310

315

320

325

330

335

Ave

rage

min

imum

requ

ired

utili

zatio

n D (ms)

GreedyDPSearch

(a) α = 0.5

0

0.1

0.2

0.3

0.4

0.5

0.620

2

209

216

223

230

237

244

251

258

265

272

279

286

293

300

307

314

Ave

rage

min

imum

requ

ired

utili

zatio

n

D (ms)

GreedyDPSearch

(b) α = 2

0

0.05

0.1

0.15

0.2

0.25

0.3

202

209

216

223

230

237

244

251

258

265

272

279

286

293

300

307

314

Ave

rage

min

imum

requ

ired

utili

zatio

n

D (ms)

GreedyDPSearch

(c) α = 4

Fig. 6: Minimum required utilization for all algorithms.

38

REFERENCES

[1] Wall-e robot. URLhttp://pixarplanet.com/blog/the-ultim-ate-walle-robot.

[2] Google glass project. URLhttp://www.google.com/glass/start/.

[3] R. Ballagas, J. Borchers, M. Rohs, and J. Sheridan.The smart phone: a ubiquitous input device. PervasiveComputing, IEEE, 5(1):70–77, 2006.

[4] J. Fernandez, D. Losada, and R. Sanz. Enhancing build-ing security systems with autonomous robots. In IEEEInternational Conference on Technologies for PracticalRobot Applications, pages 19 –24, 2008.

[5] L. Ferreira, G. Silva, and L. Pinho. Service offloadingin adaptive real-time systems. In IEEE Conferenceon Emerging Technologies Factory Automation (ETFA),pages 1 –6, 2011.

[6] X. Gu, K. Nahrstedt, A. Messer, I. Greenberg, andD. Milojicic. Adaptive offloading inference for deliveringapplications in pervasive computing environments. InIEEE International Conference on Pervasive Computingand Communications (PerCom), pages 107 – 114, 2003.

[7] S. Gurun, R. Wolski, C. Krintz, and D. Nurmi. Onthe efficacy of computation offloading decision-makingstrategies. Int. J. High Perform. Comput. Appl., 22(4):460–479, 2008.

[8] Y.-J. Hong, K. Kumar, and Y.-H. Lu. Energy efficientcontent-based image retrieval for mobile systems. InIEEE International Symposium on Circuits and Systems(ISCAS), pages 1673 –1676, 2009.

[9] K. S. Hwang, K. J. Park, D. H. Kim, S.-S. Kim, andS. H. Park. Development of a mobile surveillance robot.In International Conference on Control, Automation andSystems (ICCAS), pages 2503 –2508, 2007.

[10] S. M. Johnson. Optimal two- and three-stage productionschedules with setup times included. Naval ResearchLogistics Quarterly, 1(1):61–68, 1954.

[11] K. Kim, S. Bae, and K. Huh. Intelligent surveillance andsecurity robot systems. In IEEE Workshop on AdvancedRobotics and its Social Impacts (ARSO), pages 70 –73,2010.

[12] D. Kovachev, T. Yu, and R. Klamma. Adaptive com-putation offloading from mobile devices into the cloud.In IEEE 10th International Symposium on Parallel andDistributed Processing with Applications (ISPA), pages784 –791, 2012.

[13] K. Kumar, J. Liu, Y.-H. Lu, and B. Bhargava. A survey ofcomputation offloading for mobile systems. Mob. Netw.Appl., 18(1):129–140, Feb. 2013.

[14] Z. Li, C. Wang, and R. Xu. Computation offloading tosave energy on handheld devices: a partition scheme. InInternational conference on Compilers, architecture, andsynthesis for embedded systems (CASES), pages 238–246, 2001.

[15] Z. Li, C. Wang, and R. Xu. Task allocation for distributedmultimedia processing on wirelessly networked handhelddevices. In Parallel and Distributed Processing Sympo-

sium., Proceedings International, IPDPS 2002, pages 79–84, 2002.

[16] Y. Nimmagadda, K. Kumar, Y.-H. Lu, and C. Lee.Real-time moving object recognition and tracking usingcomputation offloading. In IEEE/RSJ International Con-ference on Intelligent Robots and Systems (IROS), pages2449 –2455, 2010.

[17] S. Ou, K. Yang, and A. Liotta. An adaptive multi-constraint partitioning algorithm for offloading in per-vasive systems. In IEEE International Conference onPervasive Computing and Communications (PerCom),pages 10 –125, 2006.

[18] L. Pei, R. Chen, J. Liu, Z. Liu, H. Kuusniemi, Y. Chen,and L. Zhu. Sensor assisted 3d personal navigationon a smart phone in gps degraded environments. InGeoinformatics, 2011 19th International Conference on,pages 1–6, 2011.

[19] N. Ravi, P. Stern, N. Desai, and L. Iftode. Accessingubiquitous services using smart phones. In PervasiveComputing and Communications, 2005. PerCom 2005.Third IEEE International Conference on, pages 383–393,2005.

[20] M. Spuri and G. Buttazzo. Efficient aperiodic serviceunder earliest deadline scheduling. In Real-Time SystemsSymposium, pages 2 –11, 1994.

[21] M. Spuri and G. Buttazzo. Scheduling aperiodic tasks indynamic priority systems. Real-Time Systems, 10:179–210, 1996.

[22] A. Toma and J.-J. Chen. Computation offloading forframe-based real-time tasks with resource reservationservers. In Euromicro Conference on Real-Time Systems(ECRTS), page to appear, 2013.

[23] A. Toma and J.-J. Chen. Computation offloading forreal-time systems. In Proceedings of the 28th AnnualACM Symposium on Applied Computing, SAC ’13, pages1650–1651. ACM, 2013.

[24] M. Valera and S. Velastin. Intelligent distributed surveil-lance systems: a review. Vision, Image and SignalProcessing, IEE Proceedings -, 152(2):192 – 204, 2005.

[25] X. Wang. Intelligent multi-camera video surveillance: Areview. Pattern Recognition Letters, 34(1):3 – 19, 2013.

[26] Y. Wang, K. Virrantaus, L. Pei, R. Chen, and Y. Chen.3d personal navigation in smart phone using geocodedimages. In Position Location and Navigation Symposium(PLANS), 2012 IEEE/ION, pages 584–589, 2012.

[27] R. Wolski, S. Gurun, C. Krintz, and D. Nurmi. Usingbandwidth data to make computation offloading deci-sions. In IEEE International Symposium on Parallel andDistributed Processing (IPDPS), pages 1 –8, 2008.

[28] C. Xian, Y.-H. Lu, and Z. Li. Adaptive computationoffloading for energy conservation on battery-poweredsystems. In Parallel and Distributed Systems, Interna-tional Conference on, pages 1–8, 2007.

[29] K. Yang, S. Ou, and H.-H. Chen. On effective offloadingservices for resource-constrained mobile devices runningheavier mobile internet applications. IEEE Communica-tions Magazine, 46(1):56 –63, 2008.

[1]

39