tr

zance

Article history:Received 10 November 2012Received in revised form

Available online 15 March 2013

Keywords:Mobile applicationsEnergy savingApplication partitioningBandwidth-adaptiveWeighted object relation graphs

Mobile applications are becoming increasingly ubiquitous and provide ever richer functionality onmobile devices, while such applications drain increasingly more battery power of mobile devices.Ofoading some parts of the application running on mobile devices onto remote servers/clouds is a

he work of Yangthat can seam-lication from ans). SociableSenseby computation

nergy consump-the same codes

usually execute faster on servers than on mobile devices), trans-

and delay. Therefore, we aim at nding the optimal application

Contents lists available at ScienceDirect

journal homepage: www.e

Journal of Network and C

E-mail addresses: niujianwei2008@gmail.com, niujianwei@buaa.edu.cn (J. Niu),

Journal of Network and Computer Applications 37 (2014) 334347et al., 2010; Cuervo et al., 2010) heavily depend upon programmersunder Grant no. NECT-09-0028.partitioning (determining which parts of the application to run onmobile devices and which parts on servers) to trade off theenergy/time savings against transmission costs and delay.

Some application partitioning solutions (Ou et al., 2007; Kemp

1084-8045/$ - see front matter & 2013 Elsevier Ltd. All rights reserved.http://dx.doi.org/10.1016/j.jnca.2013.03.007

This work was supported by the Research Fund of the State Key Laboratory ofSoftware Development Environment under Grant no. BUAA SKLSDE-2012ZX-17, theNational Natural Science Foundation of China under Grant nos. 61170296 &60873241 & 61190120, the Program for New Century Excellent Talents in University

wfsong@cse.buaa.edu.cn (W. Song), atiq@ou.edu (M. Atiquzzaman).mitting codes/data by Wi-Fi or 3G results in transmission costsn Corresponding author. Tel.: 86 13801164109.platform. However, as mobile devices have increasingly powerfulcapabilities and ever richer functionality, battery capacity hasbecome the bottleneck for further proliferation of mobile applica-tions (Banerjee et al., 2007; Li et al., 2012). Recently, computationofoading in the mobile computing environment, which ofoadsparts of application codes from mobile devices onto remoteservers, has become a promising approach to ease the energy

codes from mobile devices onto servers/clouds. Tet al. (2008) proposes a novel ofoading servicelessly ofoad some of the tasks of a mobile appMH to nearby, resource-rich PCs (called surrogate(Kiran et al., 2011) also enhances social sensingofoading.

Although computation ofoading can reduce etion and execution time for mobile devices (As mobile devices have become more powerful and affordable,they are increasingly becoming the most popular computing

have proposed to reduce the energy consumption or executiontime by ofoading computation-intensive or resource-intensive1. Introductionpromising approach to extend the battery life of mobile devices. However, as data transmission ofofoading causes delay and energy costs for mobile devices, it is necessary to carefully design applicationpartitioning/ofoading schemes to weigh the benets against the transmission delay and costs. Due tobandwidth uctuations in the wireless environment, static partitionings in previous work are unsuitablefor mobile platforms with a xed bandwidth assumption, while dynamic partitionings result in highoverhead of continuous partitioning for mobile devices. Therefore, we propose a novel partitioningscheme taking the bandwidth as a variable to improve static partitioning and avoid high costs of dynamicpartitioning. Firstly, we construct application Object Relation Graphs (ORGs) by combining static analysisand dynamic proling to propose partitioning optimization models. Then based on our novel execution-time and energy optimization partitioning models, we propose the Branch-and-Bound based ApplicationPartitioning (BBAP) algorithm and Min-Cut based Greedy Application Partitioning (MCGAP) algorithm.BBAP is suited to nding the optimal partitioning solutions for small applications, while MCGAP isapplicable to quickly obtaining suboptimal solutions for large-scale applications. Experimental resultsdemonstrate that both algorithms can adapt to bandwidth uctuations well, and signicantly reduceapplication execution time and energy consumption by optimally distributing components betweenmobile devices and servers.

& 2013 Elsevier Ltd. All rights reserved.

consumption bottleneck for mobile devices. Some previous works(Chun and Maniatis, 2009; Kemp et al., 2009; Kumar and Lu, 2010)1 March 2013Accepted 8 March 2013Bandwidth-adaptive partitioning for disoptimization of mobile applications$

Jianwei Niu a,n, Wenfang Song a, Mohammed Atiquza State Key Laboratory of Software Development Environment, School of Computer Scieb School of Computer Science, University of Oklahoma, Norman, OK 73019-6151, USA

a r t i c l e i n f o a b s t r a c tibuted execution

man b

and Engineering, Beihang University, Beijing 100191, China

lsevier.com/locate/jnca

omputer Applications

(Diaconescu et al., 2003, 2005) cannot work well on mobile

1.

2.

decide the parts of codes to be ofoaded. Similarly, MAUI

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347 335three different targets.3. In order to obtain the optimal partitioning based on the

models, we investigate two bandwidth-adaptive applicationpartitioning algorithms: Branch-and-Bound based ApplicationPartitioning (BBAP) and Min-Cut based Greedy ApplicationPartitioning (MCGAP), which can obtain the optimal solutionsfor small applications and the suboptimal solutions for large-scale applications, respectively. Experimental results demon-strate that both algorithms effectively decrease applicationenergy consumption and execution time with goodbandwidth-adaptability.

The rest of this paper is organized as follows. Section 2 presentsthe work related to application partitioning. Section 3 gives a briefdescription of WORG construction. The partitioning models andapplication partitioning algorithms are proposed in Section 4.Section 5 reports the experimental evaluation of our work fol-lowed by concluding remarks in Section 6.

2. Related work

Application partitioning is necessary for ofoading codes fromresource-constrained devices onto powerful servers/clouds.Previous works consider application partitioning at different levelsof granularity: classes (Wang and Franz, 2008), objects (Sinha andKulkarni, 2011), tasks (Semchedine et al., 2011; Kremer et al.,

20for application partitioning on resource-limited mobileplatforms.Considering the bandwidth as a variable in the mobile envir-onment, we propose three partitioning models based on theWORGs: execution-time optimization model, energy optimiza-tion model, and execution-time and energy weighted optimi-zation model, which aim to obtain the optimal solutions forThe major contributions of this paper include:

By combining static analysis and dynamic proling, we con-struct the application Weighted Object Relation Graphs(WORGs), which can precisely extract the real structure ofapplications with low complexity, and are manageable in sizeresplatforms with a xed bandwidth assumption. Dynamic partition-ing approaches (Xian et al., 2007; Chun and Maniatis, 2010) resultin high overhead by continuously determining application parti-tioning online whenever the bandwidth changes. Based on theseobservations, our aim is to improve static partitioning perfor-mance by taking bandwidth changes into consideration, and avoidthe high overhead of dynamic partitioning. We propose a novelpartitioning scheme for mobile applications by considering thebandwidth as a variable to design novel partitioning models. Basedon the partitioning models, we also propose two partitioningalgorithms to obtain the optimal partitioning solution with goodbandwidth-adaptivity. The main difference between our researchwork and others is that we consider the bandwidth as a variable todesign the partitioning models in terms of execution time andenergy consumption. Thus, we propose two bandwidth-adaptivepartitioning algorithms for small and large-scale applications,

pectively.and middlewares to partition the applications, which limits theiruses. Hence, automatic application partitioning has become a hotresearch topic recently. In this paper, we mainly focus on auto-matically object-oriented mobile applications partitioning basedon the Object Relation Graphs (ORGs) of applications (Wang andFranz, 2008). Due to frequent bandwidth uctuations in themobile environment, static application partitioning solutions01), functions (Li et al., 2001) and threads (Chun et al., 2011).(Cuervo et al., 2010) also requires programmers to annotate themethods which can be executed remotely as REMOTABLE. Thesesolutions are limited since they depend upon middlewares orprogrammers to accomplish application partitioning. Therefore,automatic partitioning methods were proposed to determineapplication partitioning. For example, CloneCloud (Chun et al.,2011) conducts code ofoading automatically at the threadgranularity.

The object-oriented application partitioning problem can becast as the Object Relation Graph (ORG) partitioning problem(Wang and Franz, 2008). In some previous work (Dahm, 2000;Messer et al., 2002), ORGs are constructed via purely static analysisor purely dynamic proling methods. As purely static analysis(Dahm, 2000; Spiegel, 2002) constructs ORGs which cannotprovide accurate information of applications (such as loop countsand conditional branches in the application), a meaningful parti-tioning can rarely be achieved. However, purely dynamic prolingmethods (Messer et al., 2002; Bialek et al., 2004) generate moreaccurate but signicantly complex ORGs with mass unnecessarysystem library classes, incurring high overhead of partitioning formobile devices. Hence, we propose to combine static analysis anddynamic proling to construct Weighted Object Relation Graphs(WORGs) with high accuracy and a manageable size for mobileapplication partitioning.

As mobile devices usually use a wireless channel for datatransmission with the bandwidth changing frequently, staticapplication partitioning solutions (Wang and Franz, 2008;Diaconescu et al., 2003, 2005), which compute communicationcosts ofine and adopt partitioning schemes ignoring bandwidthuctuations, are unsuitable for mobile platforms. Therefore,dynamic partitioning approaches (Xian et al., 2007; Chun andManiatis, 2010) were proposed to determine the applicationpartitioning in runtime. Xian et al. (2007) proposed to collect thestatistics of computation time and dynamically obtain the optimalofoading decisions online. Chun and Maniatis (2010) introducedthe notion of dynamic application partitioning between weakdevices and clouds to better support applications running ondiverse devices in different environments. However, there areserious challenges on system support for dynamic partitioningand it also results in high costs of determining the partitioning inruntime. Targeting these problems, we propose execution-time/energy-cost optimization partitioning models where the band-width is considered as a variable and two bandwidth-adaptiveapplication partitioning algorithms.

3. Construction of weighted object relation graphs

3.1. Application partitioning process

Figure 1 shows the workow of bandwidth-adaptive applica-tion partitioning. First of all, we construct the correspondingWeighted Object Relation Graph (WORG) of the mobile applicationvia static analysis and dynamic proling. Then, taking bandwidthchanges into consideration, we build partitioning models forAs mobile devices are becoming the primary computing plat-form for many users, object-oriented application partitioning hasattracted considerable interest among researchers. Some solutionsmainly rely on middleware tools (Ou et al., 2007) or programmers(Kemp et al., 2010; Cuervo et al., 2010) to make partitions. Thework of Ou et al. (2007) depends on the ofoading middleware toprovide runtime ofoading services for resource-constrainedmobile devices. Kemp et al. (2010) provides a computation off-loading framework for Android systems, where programmersexecution-time/energy optimization. Based on the partitioning

3.2.2. Dynamic prolingThe application WORG is constructed by dynamical proling to

obtain the weights of nodes and edges in the ORG. The authors inBinder and Hulaas (2006) have proven that there is a certain ratioof execution time to the total bytecode instruction count (con-sidering loop counts) for Java programs. Therefore, execution timeof objects can be evaluated by the corresponding bytecode

Fig. 2. An example of Java application.

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347336models, partitioning algorithms are proposed to make properapplication partitioning. Finally, the application executes in adistributed fashion (Aderounmu, 2004) according to the partition-ing results, i.e., parts of the application run locally on mobiledevices, and the rest runs remotely on servers.

3.2. Construction of weighted object relation graph

As shown in Fig. 1, the WORG construction is critical forapplication partitioning. We combine static analysis and dynamicproling to construct the application WORG, which we call asCombined Static and Dynamic Program Analysis based Construc-tion (CSDPAC). Static analysis obtains objects and relationsbetween objects according to method invocations of applicationsto construct the ORG, with nodes representing objects and edgesrepresenting relations between objects. Then we adopt dynamicproling to obtain the execution time for each object and thetransmission data for each invocation to construct the WORG.

To illustrate the construction of WORG in Sections 3.2.1 and 3.2.2,we introduce a Java program as an example shown in Fig. 2 and ourapproach also applies to other object-oriented language based

Fig. 1. Workow of bandwidth-adaptive application partitioning.applications. As shown in Fig. 2, there are four classes (i.e., FacePre-view, ImageCapture, FaceDetection and FaceDetectionLib) in the Javaexample. The main method of FacePreview class creates one Image-Capture object and two FaceDetection objects. The FaceDetectionobjects then execute their DetectFace methods which invoke theProcessBlock method of the FaceDetectionLib class.

3.2.1. Static analysisWith Points-to technology (Lhotk, 2002), static analysis

obtains the control ow graph of the application by analyzingthe bytecode. Then, by traversing the graph, we can get all theobjects and the relations between objects based on methodinvocations to construct the ORG. However, the initial ORGscontain mass extra system library objects, resulting in an extre-mely large size and high partitioning overhead (the initial ORG ofthe Java example in Fig. 2 totally contains 1500 nodes and 4800edges). Since system library objects have few impacts on applica-tion partitioning, it is reasonable to cut down ORGs by deletingthose system library objects. Figure 3(a) is the corresponding ORGof the Java example. The objects in the graph are either staticobjects or dynamic objects, which are annotated with the S_ or D_prex, respectively.instruction count. Transmission data between objects includeparameters and return values of method invocations. With Javabytecode rewriting, dynamic proling can obtain the executiontime for each object and the transmission data for each invocation,which are respectively the weight of a node (denoted by tnli fornode i in the following section) and the weight of an edge(denoted by Wij for an edge between node i and j in the followingsection) in the WORG. Figure 3(b) shows the constructed WORG ofthe Java example.

4. Partitioning models and application partitioningalgorithms

4.1. Notations and assumptions

The notations of our partitioning models are listed in Table 1.To simplify the partitioning models, we assume that the server

is always available, and mobile devices are in the Wi-Fi environ-ment with symmetrical uplink and downlink bandwidths. Inaddition, since the receiving power of Wi-Fi interfaces is close totheir sending power, we denote both of them by Pw.

va e

licaoders, iich isolu

s sub

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347 337Labels Parameters

n Number of nodes (objects) in the appxi Partitioning result of node i, xi1: n

xi0: node i runs remotely on serveX Application partitioning solution, whX The optimal application partitioningb (kb/s) Current bandwidthbl (kb/s) The largest bandwidth value which iFig. 3. ORG and WORG of the Ja

Table 1Notations of partitioning models.4.2. Partitioning models

Mobile application partitioning aims at nding the optimalpartitioning solution to make the best tradeoff between time/energy savings and transmission costs/delay. In this subsection, wepresent our application partitioning models with respect toexecution time and energy consumption.

4.2.1. Execution time optimization modelThe aim of our execution time optimization model is to nd the

optimal application partitioning X under the bandwidth of b,satisfying X arg minXXP TX,b. Application execution timeTX,b of partitioning X under the bandwidth of b is dened asTX,b

1inxi tnli1xi tnsi

1io jnjxixjj tij 1

where the remote execution time (tnsi) of node i running onservers is dened as

tnsi tnli=k 2With the bandwidth b and transmission data Wij, the transmissiontime tij between node i and node j is dened as

tij Wij=b 3

Pbbl Probability that the bandwidth is not lesPc Threshold probabilityXP Model solution spacea Empirical constant to limit the upper bouk Ratio of execution-time for a node runninWij (Byte) Transmission data between node i and ntnli (s) Local execution time of node i running otnsi (s) Remote execution time of node i runningtij (s) Transmission time between node i and nTX,b (s) Execution time of partitioning X under thEi (J) Energy consumption of node i running loEij (J) Energy consumption of data communicatPcpu (W) CPU power of mobile devicesPw (mW) Sending and receiving power of Wi-Fi inEX,b (J) Energy consumption of partitioning X unTLocal (s) Execution time when the whole applicatiELocal (J) Energy consumption when the whole apwt Weight of execution time in the partitionwe Weight of energy consumption in the paWX,b Weighted model value of partitioning X uxample. (a) ORG and (b) WORG.

tion ORGi runs locally on mobile devices;1n

s dened as X fx1 ,,xngtion

ject to PbblPcThe model solution space XP is dened as

XP fXjTX,blTXoptbl ,bl 1ag 4

where TXoptbl ,bl is the corresponding application execution time ofthe optimal partitioning Xoptbl under the bandwidth of bl. The

empirical constant a (a > 0) limits the execution time TX,bl tothe upper bound TXoptbl ,bl 1a.

As XXP , therefore TX ,blTXoptbl ,bl 1a. When the band-width bbl, we have TX ,bTX ,blTXoptbl ,bl 1a. SincePbblPc , with the bandwidth b ranging from b to bl, it holdsthat

PTX ,bTXoptbl ,bl 1aPc 5

That is, when the bandwidth varies from the current value b to thelower bandwidth bl, the optimal partitioning X can satisfy theconstraint condition in XP with the threshold probability of Pc.

4.2.2. Energy optimization modelThe energy optimization model aims at nding the optimal

partitioning X under the bandwidth of b which satisesX arg minXXP EX,b. Energy consumption EX,b of partitioning

s than bl

nd of the model value WX,blg locally to running remotelyode j when one runs on mobile devices and the other on serversn mobile deviceson serversode je bandwidth of bcally on mobile devicesion between node i and j

terfacesder the bandwidth of bon runs locallyplication runs locallying modelrtitioning model, satisfying wtwe 1nder the bandwidth of b

as constants for a certain application running on mobile devices.

viV

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347338Therefore, when wt1 and we0, the weighted optimiza-tion model corresponds to the execution time optimization model.And when wt0 and we1, it corresponds to the energyoptimization model. Therefore, we denote the value of all thethree models as WX,b to present the partitioning algorithms inSection 4.4.

4.3. Min-cut problem

In this subsection, we prove that the minimal of the modelvalue is equivalent to the capacity of the WORG min-cut. Hence,we apply the min-cut of WORG to application partitioning algo-rithms in Section 4.4. We denote the Weighted Object RelationGraph as WORG fV ,E,Wv,Weg, with V, E, Wv and We representingthe node set, edge set, weight set of nodes and weight set of edges,respectively. Firstly, the Weighted Object Relation Graph (WORG) istransformed into a target one (WORG) as follows. WORGfV ,E,W eg has the same node set V, a new edge set E, a new setWe of edge weights, but no node weights.

(1) For execution time optimization model, we get the targetX under the bandwidth of b is dened as

EX,b 1in

xi Ei 1io jn

jxixjj Eij 6

where Ei and Eij are dened as

Ei tnli Pcpu 7

Eij tij Pw 8And the solution space XP is dened as

XP fXjEX,blEXoptbl ,bl 1ag 9

where EXoptbl ,bl indicates the corresponding energy consumptionof the optimal partitioning Xoptbl under the bandwidth of bl. Theempirical constant a (a > 0) limits the energy consumption EX,blto the upper bound EXoptbl ,bl 1a.

Similar to the execution time optimization model, with thebandwidth b ranging from b to bl, it holds that

PEX ,bEXoptbl ,bl 1aPc 10

4.2.3. Execution time and energy weighted optimization modelThe aim of the weighted optimization model is to nd the

optimal partitioning X under the bandwidth of b which satisesX arg minXXP WX,b. The weighted modelWX,b is dened asWX,b wt TX,b=TLocalwe EX,b=ELocal 11The model solution space XP is dened as

XP fXjWX,blWXoptbl ,bl 1ag 12

where WXoptbl ,bl is the corresponding model value of the optimalpartitioning Xoptbl under the bandwidth of bl. The empirical constanta (a > 0) limits the model value WX,bl to the upper boundWXoptbl ,bl 1a. With the bandwidth ranging from b to bl, justas it does for the execution time optimization model, it also holdsthat

PWX ,bWXoptbl ,bl 1aPc 13

The weights of execution time (wt) and energy consumption(we) can be set according to the user requirements for applicationexecution time and the remaining energy of mobile devices. TLocaland ELocal are the execution time and energy consumption whenthe application runs locally, respectively, which are usually takenWORG (WORG) by the following three steps:

EXcording to Eqs. (22)(24), we have

,b tnli Pcpu wec,vi wij 25

Ac2

vjNL

Eij viV2

vjNL

Wij=b Pw viV2

wec,vitnli Pcpu 24viV Initialize: V VNL, NL is the set of nodes which must runlocally, E, We . Combine all nodes in NL into one node c. For viV , create anedge e c,vi, wec,vi tnsivjNLWij=btnli, E Efeg,W e Wefweeg. For vi,vjV , if e vi,vjE, then wij Wij=b, E Efeg,W e Wefwijg.

Based on the WORG, we can prove Theorem 1.

Theorem 1. The minimal application execution time equals themin-cut capacity of WORG.

Proof. Assume V1 V 1NL, a cut V1,V2 is a partitioning ofWORG. F is the capacity of the cut. Based on Eq. (1), we havethat

TX,b viV1

tnli viV2

tnsi viV 1

vjN2

tij viV2

vjNL

tij 14

According to the construction of WORG, it holds that

viV 1

vjN2

tij viV 1

vjN2

Wij=b viV 1

vjN2

wij 15

viV2

vjNL

tij viV2

vjNL

Wij=b

viV2

wec,vitnsitnli 16

From Eqs. (14) to (16), we can get

TX,b viV

tnli viV2

wec,vi viV 1

vjN2

wij 17

According to the capacity of the cut , we have

F viV2

wec,vi viV 1

vjN2

wij 18

Therefore,

TX,b TLocalFV1,V2 19Because TLocal is a constant for a certain application running locallyon mobile devices, the minimal application execution time isequivalent to the min-cut of WORG (the minimum of F).

(2) For the energy optimization model, the difference from theexecution time optimization model of WORG construction is that,wec,vi and wij are replaced bywec,vi

vjNLWij=b Pwtnli Pcpu 20

wij Wij=b Pw 21Then we can prove Theorem 2 based on the WORG.

Theorem 2. The minimal application energy consumption is equiva-lent to the min-cut capacity of WORG.

Proof. According to the energy optimization model, we can get

EX,b viV1

tnli Pcpu viV 1

vjV2

Eij viV2

vjNL

Eij 22

Based on the construction of WORG, it holds that

1

vjV2Eij

viV 1

vjV2Wij=b Pw

viV 1

vjV2wij 23viV viV2 viV 1vjV2

EX,b ELocalF 27ELocal is a constant when the whole application runs locally onmobile devices. Therefore, the minimal application energy con-sumption is the corresponding min-cut capacity of WORG.

The weighted optimization model combines the execution timeoptimization model and the energy consumption optimizationmodel by appending the corresponding weights wt and we,respectively. Therefore, the optimal partitioning of the weightedoptimization model also corresponds to the min-cut of WORG.Hence, we adopt the min-cut StoerWagner algorithm (Stoer andWanger, 1997) to solve the optimal application partitioning undera certain static bandwidth.

4.4. Bandwidth-adaptive application partitioning algorithms

Based on the Weighted Object Relation Graph constructed inSection 3.2 and the optimization models presented in Section 4.2,we propose the Branch-and-Bound based Application Partitioning(BBAP) algorithm and Min-Cut based Greedy Application Parti-tioning (MCGAP) algorithm in this subsection.

4.4.1. BBAP algorithm

Algorithm 1. BBAP algorithm.

xi 1 (a node to be partitioned). The bounding function, whichprovides an upper bound for a better partitioning solution inBBSearch, includes two constraint conditions:

the model value WX,b of the partitioning X under thebandwidth of b is less than the currently stored minimal valueminValue;

when the bandwidth is bl, the model value WX,bl cannot belarger than the upper bound minV.

The branching rule of BBSearch divides the space considered intotwo subspaces to be investigated in the subsequent iterations bytrying xi0 (node i runs on the server) and xi1 (node i runslocally), respectively.

Since the time complexity of BBSearch is O2n (n is the numberof nodes/objects) at the worst case, BBAP is computationallyintensive and unsuitable for large-scale applications. Therefore,we propose the heuristic MCGAP algorithm in Section 4.4.2.

4.4.2. MCGAP algorithmWe denote b Cb,Sb as the optimal application partitioning

when the bandwidth is b, where Cb and Sb represent the node setrunning on the mobile device and that running on the server,respectively. Theorem 3 demonstrates that the nodes running onthe mobile device will still run locally when the bandwidthdecreases, and the nodes running on the server will still run

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347 339The pseudocode of BBAP is shown in Algorithm 1. In thisalgorithm, WORG V ,E,Wv,We is the Weighted Object RelationGraph of the application, with V, E,Wv andWe representing nodes,edges, the weights of nodes and the weights of edges, respectively.As the capacity of the cut is

F viV2

wec,vi viV 1

vjN2

wij 26

Hence, it holds thatWe denote NL as nodes (objects) that must run locally, i.e.,Theorem 3. If B CB,SB, b Cb,Sb, then we have:(i) B > bCBDCb; (ii) B > bSbDSB.

Proof. With C1b fvjvCbvCBg, C2b fvjvCbvSBg,1 2Sbremotely when the bandwidth increases.viNL,xi 1. Similar to the Branch-and-Bound algorithm,BBSearch consists of three main parts: a search strategy, a bound-ing function and a branching rule. BBSearch adopts the depth-rstsearch strategy to partition these nodes that are labeled as fvjvSbvCBg, Sb fvjvSbvSBg, then we have

Cb C1bC2b , Sb S1bS2b , CB C1bS1b , SB C2bS2b . We provide theproof of Theorem 3 by contradiction as follows:(1) As for application execution time, we denote T(V) as the local

execution time of nodes in set V, and TbV1,V2 as the datacommunication time between nodes separately in set V1 and setV2 under the bandwidth of b.Assume that vCB, vCb (or vSb, vSB for Theorem 3 (ii)), i.e.,

S1b. We denote t (t0) as the remote execution time of all nodesin set S1b running on the server. The preconditions are b Cb,Sband B CB,SB. Let b fC1bC2bS1bg,S2b, B C1b ,fC2bS1bS2bg, then

Tbb TbbTS1bTbS1b ,S2btTbS1b ,C1bTbS1b ,C2b 28

TBB TBBTS1bTBS1b ,S2btTBS1b ,C1bTBS1b ,C2b 29

Since B is the optimal partitioning under the bandwidth of B, wehave TBBoTBB, hence

TBS1b ,C1b > TS1bTBS1b ,S2btTBS1b ,C2b 30

As B > b, let B p b (p > 1), then

TbS1b ,C1b p TBS1b ,C1b> p TS1bTBS1b ,S2bTBS1b ,C2bt p TS1bTbS1b ,S2bTbS1b ,C2bp t> TS1bTbS1b ,S2bTbS1b ,C2bt> TS1bTbS1b ,S2bTbS1b ,C2bt 31

So we get TbboTbb, which contradicts the precondition

(2) As for application energy consumption, we denote E(V) as thelocal energy consumption of nodes in set V and EbV1,V2 as theenergy consumption of transmission between nodes separately inset V1 and set V2 under the bandwidth of b. Assume that vCB,vCb (or vSb, vSB for Theorem 3(ii)), i.e., S

1b. b Cb,Sb,

B CB,SB. Let b fC1bC2bS1bg,S2b, B C1b ,fC2bS1bS2bg,then

Ebb EbbES1bEbS1b ,S2bEbS1b ,C1bEbS1b ,C2b 32

EBB EBBES1bEBS1b ,S2bEBS1b ,C1bEBS1b ,C2b 33Since B is the optimal partitioning when the bandwidth is B, wehave EBBoEBB, so there isEBS1b ,C1b > ES1bEBS1b ,S2bEBS1b ,C2b 34As B > b, let B p b (p > 1), thenEbS1b ,C1b p EBS1b ,C1b

> p ES1bEBS1b ,S2bEBS1b ,C2b p ES1bEbS1b ,S2bEbS1b ,C2b> ES1bEbS1b ,S2bEbS1b ,C2b> ES1bEbS1b ,S2bEbS1b ,C2b 35

So EbboEbb, which contradicts the precondition that bis the optimal application partitioning under the bandwidth of b.Hence, CBDCb (or SbDSB).In conclusion, for both execution time and energy consumption,

it holds that

B > bCBDCb, SbDSB 36

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347340that b is the optimal partitioning under the bandwidth of b.Therefore, it holds that CBDCb (or SbDSB). Algorithm 2. MCGAP algorithm.

Analysis based Construction (PSPAC), Purely Dynamic Program

Table 3Program AET and PET comparison of CSDPAC, PSPAC and PDPAC.

Programs AET(ms)

CSDPAC PSPAC PDPAC

BIC (byte) PET(ms)

BIC(byte)

PET(ms)

BIC(byte)

PET(ms)

avrora 6414 360 846 6014 325 800 5430 390 780 6513h2 34 964 2 054 820 34 247 665 280 11 088 2 146 866 35 781luindex 7266 421 082 7018 371 940 6199 454 983 7583lusearch 1887 115 208 1920 52 560 876 118 505 1975pmd 5125 323 465 5391 230 400 3840 321 660 5361sunow 9733 580 381 9673 404 460 6741 617 584 10 293tomcat 7350 443 164 7386 319 260 5321 454 980 7583xalan 1443 76 680 1278 31 380 523 98 826 1647

Table 4Parameters of simulation testbed.

Parameters Variables Values

CPU power (w) Pcpu 7Wi-Fi power (mw) Pw 88Bandwidth (kb/s) b 100Computation ratio k 3

Table 2ORG sizes comparison of CSDPAC, PSPAC and PDPAC.

Programs Classes Methods CSDPAC PSPAC PDPAC

Nodes Edges Nodes Edges Nodes Edges

avrora 8812 22 240 200 5430 208 5430 10 098 25 289h2 10 264 14 494 4900 11 088 4912 11 088 13 257 16 237luindex 6530 8199 1027 6199 1027 6199 6974 10 299lusearch 7812 10 148 1238 7148 1238 7148 7976 10 278pmd 12 673 17 360 2312 9360 2320 9360 13 879 18 002sunow 9796 12 506 2615 8506 2615 8506 9820 12 623tomcat 9760 12 446 2718 8246 2718 8246 9772 12 453xalan 11 074 14 933 1896 9347 1896 9347 11 076 14 935

Table 5Parameters of graphs constructed in our simulation.

GraphNames Nodes Edges

RandomGraph1 15 60RandomGraph2 30 350RandomGraph3 50 948RandomGraph4 100 3238avrora 200 5430h2 4900 11088luindex 1027 6199lusearch 1238 7148

Table 6Partitioning time of BBAP(s).

Programs Model_T Model_E Model_W

RandomGraph1 0.022 0.032 0.028RandomGraph2 0.056 0.049 0.058RandomGraph3 0.375 0.389 0.392RandomGraph4 0.897 1.003 0.974avrora 2.062 2.232 2.182lusearch 200 217 209

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347 341Analysis based Construction (PDPAC) and our Combined Static andDynamic Program Analysis based Construction (CSDPAC)described in Section 3.2. PSPAC constructs ORGs with only thestatic analysis method while PDPAC constructs ORGs with only thedynamic proling. With the Soot framework and bytecode rewrit-ing, we evaluate the performance of the ORGs constructed byCSDPAC, PSPAC and PDPAC on a set of Dacapo Benchmarks. Thetestbed is the ThinkPad X201i notebook with 3.0 GB memory,2.53 GHz CPU frequency, and the Ubuntu10.10 operating system.

The benchmark suite is intended as a tool for Java benchmark-ing, which consists of a set of open source, real world applicationswith non-trivial memory loads. We choose eight different bench-marks covering both small and large scale applications shown inTable 2 to evaluate our ORG construction. Table 2 gives thedescription of ORGs constructed by CSDPAC, PSPAC and PDPAC.We can observe that ORGs constructed by CSDPAC and PSPAC aresmaller in size than those constructed by PDPAC. The reason is thatORGs can be cut down into manageable size via static analysis ofCSDPAC and PSPAC. However, PDPAC obtains more applicationinformation including mass unnecessary system library classes bypurely dynamic analysis, resulting in extremely complex ORGs andhigh overhead of partitioning.

Table 3 shows the comparison of application's actual executiontime and predicted execution time by CSDPAC, PSPAC and PDPAC.We predict application execution time according to applicationBytecode Instructions Count (BIC) (Binder and Hulaas, 2006). If theWe denote X Copt ,Sopt as the optimal partitioning of MCGAP,where Copt and Sopt are the node sets running on the mobile deviceand the server, respectively. According to Theorem 3, consideringthe bandwidth ranging from b to bl, we have CbDCopt andSblDSopt . Since Cb and Sbl can be easily obtained by the min-cutStoerWagner algorithm (Stoer and Wanger, 1997), we just need toconsider the optimal partitioning of the node set V VCbSbl (Vis the set of all nodes).

Algorithm 2 is the pseudocode of MCGAP. In Algorithm 2, theMA_Order function is used to nd the node (vm) most tightlyconnected and the node (vm1) second most tightly connectedwith Sbl , which is similar to the maximum adjacency searchfunction in the StoerWagner algorithm (Stoer and Wanger,1997). Formally, a node z most tightly connected with Sbl satiseszSbl and wSbl ,z maxfwSbl ,yjySbl g, where wSbl ,y is the sumof the weights of all the edges between Sbl and y. The Contractfunction means that the two nodes are merged and then replacedby a new node, and edges from the two nodes to any other nodeare replaced by an edge weighted by the sum of the weights of theprevious two edges. What's more, MCGAP also has the sameconstraint conditions as BBAP to update and store a betterpartitioning solution. Similar to the StoerWagner algorithm,MCGAP has the time complexity of OjEjjV jlogjV j, which canquickly obtain the partitioning solution for large-scaleapplications.

5. Evaluation

In this section, we present an evaluation of the performance ofORG construction in Section 5.1 and the performance of partition-ing algorithms in terms of execution time and energy consumptionin Section 5.2.

5.1. Construction of weighted object relation graph

In this subsection, we present the evaluation of ORG construc-tion by comparing the performance of Purely Static ProgramPredicted Execution Time (PET) is closer to the Actual Execution

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347342Time (AET), it means that the ORG is more accurate for applicationpartitioning. As shown in Table 3, as compared to PSPAC, thepredicted execution times of CSDPAC and PDPAC are closer to their

Fig. 4. Application execution time with different bandwidths by partitioning of BBAP, Sand (d) lusearch.

Fig. 5. Application energy consumption with different bandwidths by partitioning of(c) avrora and (d) lusearch.actual execution times. This indicates that CSDPAC and PDPACconstruct more accurate ORGs than PSPAC, and dynamic prolingis effective for ORG construction. However, with only static

toerWagner, Minimal and Local. (a) RandomGraph1, (b) RandomGraph2, (c) avrora

BBAP, StoerWagner, Minimal and Local. (a) RandomGraph1, (b) RandomGraph2,

StoerWagner, Minimal and Local. (a) RandomGraph1, (b) RandomGraph2, (c) avrora

Table 7

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347 343analysis, PSPAC cannot obtain enough application information and

Fig. 6. Weighted model value with different bandwidths by partitioning of BBAP,and (d) lusearch.con

CSDconcon

5.2

MCsumtes2.5Tabofonproin

MCdin(2)(wBBban

structs ORGs with low accuracy.Therefore, combining static analysis and dynamic proling,PAC can construct ORGs with higher accuracy than thosestructed by PSPAC and with more manageable scale than thosestructed by PDPAC.

. Bandwidth-adaptive application partitioning algorithms

In this subsection, we evaluate the performance of BBAP andGAP algorithms in terms of execution time and energy con-ption for the case of bandwidth uctuations. The simulation

tbed is a ThinkPad X201i notebook with 3.0 GB memory,3 GHz CPU frequency, and Windows 7 operating system.le 4 shows the experimental parameters, where k is the ratiothe execution time for a node running on mobile devices to thatservers. Table 5 describes the WORGs of four customizedgrams and four Dacapo Benchmarks constructed by CSDPACSection 5.1.To systematically evaluate the performance of BBAP andGAP, we conduct three groups of experiments correspon-g to three different cases: (1) execution-time optimization;energy-consumption optimization; (3) balanced optimization

t 0:5,we 0:5). We compare the following three schemes withAP/MCGAP (their partitioning solutions are obtained under thedwidth of 100 kb/s):

StoerWagner: the static partitioning obtained by the StoerWagner algorithm under the bandwidth of 100 kb/s.Minimal: the dynamic partitioning, recalculating the optimalpartitioning whenever the bandwidth changes by a step of10 kb/s.Local: the local running on the mobile device without applica-tion partitioning.In fact, when the application has been running and thebandwidth changes, the Minimal approach may make differentpartitioning determinations for application objects, but it makesno sense to ofoad the objects which have been executed andrerun them. Therefore, when the bandwidth changes, the optimalpartitioning obtained by Minimal may not be adopted by theapplication in most cases. Hence, Minimal is usually used as a

Comparison of average execution time and energy consumption (BBAP).

Programs Execution time Energy consumption

TR1 (%) TR2 (%) ER1 (%) ER2 (%)

RG1 25.89 70.88 23.93 25.59RG2 18.80 50.50 21.99 24.96avrora 32.16 25.23 30.64 32.23lusearch 28.67 30.06 26.97 55.10

Average 26.38 44.17 25.88 34.47

Table 8Partitioning time of MCGAP(s).

GraphNames Model_T Model_E Model_W

RandomGraph1 0.019 0.022 0.023RandomGraph2 0.054 0.051 0.055RandomGraph3 0.392 0.396 0.398RandomGraph4 0.913 0.915 0.908avrora 1.662 1.583 1.592h2 52.28 51.30 54.29lusearch 20.52 20.45 20.79luindex 20.42 20.32 20.61

kb/s

)

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347344Table 9Application execution time comparison of BBAP and MCGAP.

Programs b20 kb/s b60

B (ms) M (ms) A B (ms

RandomGraph1 17 17 1.000 12RandomGraph2 71 72 1.014 40RandomGraph3 105 107 1.019 70RandomGraph4 167 181 1.084 113avrora 4900 4950 1.010 3712h2 31 410 31771 1.011 20 112lusearch 5693 5712 1.003 4392luindex 1904 1995 1.048 1119performance benchmark of partitioning and cannot be adopted inthe real world.

5.2.1. Evaluation of BBAP performanceTable 6 shows partitioning time of BBAP, i.e., the time BBAP

takes to obtain the optimal partitioning solutions for threepartitioning models: execution time optimization model(Model_T), energy optimization model (Model_E) and thebalanced weight optimization model with wt 0:5,we 0:5 (Mod-el_W). As shown in Table 6, we can observe that BBAP can obtainthe optimal solution in a short time for simple applications (fromRandomGraph1 to avrora), but for large-scale applications (such aslusearch), the partitioning-time cost becomes much higher. Just asthe description in Section 4.4.1, BBAP is able to nd the optimalpartition, which by itself is computationally quite intensive andunsuitable for large-scale applications.

We choose four applications (RandomGraph1, RandomGraph2,avrora and lusearch) to evaluate the performance of BBAP. Figure 4shows the performance comparison of StoerWagner, Minimal,Local and BBAP with respect to execution time. As shown in

Fig. 7. Application execution time with different bandwidths by partitioning of MCGAPb80 kb/s

M (ms) A B (ms) M (ms) A

13 1.083 11 12 1.09141 1.025 33 35 1.06172 1.029 62 62 1.000114 1.009 97 98.6 1.016

3716 1.001 3300 3324 1.00720 143 1.002 18 352 18 553 1.0114424 1.007 4087 4213 1.0311135 1.014 1030 1072 1.041Fig. 4, we can observe that BBAP and Minimal outperform Local.StoerWagner also performs better than Localwhen the bandwidthis relatively high, which demonstrates that the partitioningapproach can signicantly improve the application performance.However, as the bandwidth decreases, it will cost more time totransfer the same data, resulting in the increase of applicationexecution time, especially for StoerWagner. Moreover, comparedwith StoerWagner, the execution time of BBAP is much closer tothat of Minimal, and its curve is more smooth with bandwidthuctuations. Although Minimal slightly outperforms BBAP, itscomputational cost is much higher than that of BBAP becauseMinimal needs to recalculate the application partitioning when-ever the bandwidth changes by 10 kb/s.

Figures 5 and 6 compare the performance of the four schemesfor energy optimization model and weighted optimization model(the weights of running time and energy consumption are both0.5), respectively. As shown in both Figs. 5 and 6, BBAP outper-forms StoerWagner and Local. The performance of BBAP is close tothat of Minimal. However, since Minimal recalculates the applica-tion partitioning each time the bandwidth varies, its computa-tional cost is much higher than that of BBAP. With partitioning

, StoerWagner, Minimal and Local. (a) avrora, (b) lusearch, (c) luindex and (d) h2.

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347 345only once, BBAP can adapt to bandwidth uctuations and hasbetter efciency on application execution speedup or energyconservation.

Fig. 8. Application energy consumption with different bandwidths by partitioning ofMCG

Fig. 9. Weighted model value with different bandwidths by partitioning of MCGAP, STable 7 shows the average speedup and energy savings of BBAPagainst StoerWagner and local running. RG1 and RG2 refer toRandomGraph1 and RandomGraph2. TR1 and ER1 respectively

AP, StoerWagner,Minimal and Local. (a) avrora, (b) lusearch, (c) luindex and (d) h2.

toerWagner, Minimal and Local. (a) avrora, (b) lusearch, (c) luindex and (d) h2.

to large-scale applications.Figures 79 show the performance of MCGAP on four bench-

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347346marks (avrora, lusearch, luindex and h2) in terms of executiontime, energy consumption and the weighted total cost(wt 0:5,we 0:5), respectively. As shown in Figs. 79, bothMinimal and MCGAP outperform Local. Since the low bandwidthresults in much higher costs for data transmission, StoerWagnerperforms better than Local only when the bandwidth is relativelyhigh. The results demonstrate that the partitioning approach canimprove the application performance when the bandwidth is notindicate the speedup and energy savings of BBAP against StoerWagner, while TR2 and ER2 are respectively the speedup andenergy saving of BBAP against the local running. As shown inTable 7, compared with the local running, the average timespeedup ratio and energy saving ratio by BBAP are respectively44.17% and 34.47%, while average execution time and energyconsumption by BBAP are respectively reduced by 26.38% and25.88% against StoerWagner.

5.2.2. Evaluation of MCGAP performanceTable 8 shows the partitioning time of MCGAP, i.e., the time

MCGAP takes to obtain the partitioning solutions for three models.Compared with BBAP in Table 6, the partitioning time of BBAP issimilar to that of MCGAP for simple applications. However, MCGAPspends signicantly less time than BBAP for large ones. That is,heuristic MCGAP can obtain the partitioning results much fasterthan BBAP for large-scale applications, because BBAP is based onthe Branch-and-Band algorithm which is computationallyintensive.

We compare the application execution time of the optimalpartitioning solutions by MCGAP and BBAP at the bandwidths of20 kb/s, 60 kb/s, and 80 kb/s in Table 9, where B, M and Arepresent BBAP, MCGAP and the accuracy of MCGAP, respectively.The accuracy is dened as the execution time ratio of thepartitioning obtained by MCGAP to the optimal partitioningobtained by BBAP. As shown in Table 9, MCGAP performs as wellas BBAP with the high accuracy close to 1, which demonstratesthat MCGAP is effective in application partitioning and applicable

Table 10Comparison of average execution time and energy consumption (MCGAP).

Programs Execution time Energy consumption

TR3% TR3% ER4% ER4%

avrora 30.67 23.59 31.18 32.75lusearch 27.83 29.24 26.96 55.09luindex 20.54 51.20 14.12 53.66h2 28.92 45.71 50.07 42.87

Average 26.99 37.44 30.58 46.09too low and MCGAP performs better than StoerWagner with goodbandwidth-adaptivity. With partitioning only once, the perfor-mance of MCGAP is close to that of Minimal which is an optimalbenchmark of partitioning and needs to make the partitioningrepeatedly whenever the bandwidth changes by a step of 10 kb/sin our experiment.

Table 10 shows the average application execution speedup andenergy savings of MCGAP against StoerWagner and the localrunning. TR3 and ER3 are respectively the speedup ratio and energysaving ratio by MCGAP against the StoerWagner algorithm, whileTR4 and ER4 are respectively the speedup ratio and energy savingratio by MCGAP against the local running, respectively. As shownin Table 10, compared with the local running, MCGAP reduces theexecution time and energy consumption by 37.44% and 46.09%,

Kiran KR, Cecilia M, Mirco M, Peter JR. Sociablesense: exploring the trade-offs ofadaptive sampling and computation ofoading for social sensing. In: Proceed-

ings of the 17th international conference on mobile computing and networking(Mobicom'11). Las Vegas, Nevada, USA; September 2011. p. 1923.

Kremer U, Hicks J, Rehg J. A compilation framework for power and energymanagement on mobile computers. In: Proceedings of international workshopon languages and compilers for parallel computing. Cumberland Falls,Kentucky, USA; August 2001.

Kumar K, Lu YH. Cloud computing for mobile users: can ofoading computationrespectively. Compared with static StoerWagner algorithm,MCGAP reduces the execution time and energy consumption by26.99% and 30.58%, respectively. This further demonstrates thatour proposed MCGAP is able to effectively reduce applicationenergy consumption as well as execution time.

6. Conclusion

In this paper, we rst construct the WORGs of mobile applica-tions by combining static analysis and dynamic proling methods.To tackle the problem of bandwidth uctuations in a mobileenvironment, we propose the optimization models in terms ofexecution-time and energy-consumption for mobile applicationpartitioning based on the WORGs. We consider the bandwidth as avariable and propose two bandwidth-adaptive application parti-tioning algorithms: BBAP and MCGAP. BBAP is applicable fornding the optimal solutions for small applications, while MCGAPis suited to quickly obtain the suboptimal solutions for large-scaleapplications. Experimental results demonstrate that both algo-rithms adapt well to bandwidth uctuations, and effectivelyreduce the energy consumption and execution time of mobileapplications.

References

Aderounmu GA. Performance comparison of remote procedure calling and mobileagent approach to control and data transfer in distributed computing environ-ment. Journal of Network and Computer Applications 2004;27(2):11329.

Banerjee N, Rahmati A, Corner MD, et al. Users and batteries: interactions andadaptive energy management in mobile systems. In: Proceedings of the ninthinternational conference on ubiquitous computing. Innsbruck, Austria;September 2007. p. 21734.

Bialek R, Schneider JG, Yan J. Partitioning of Java application to support dynamicupdates. In: Proceedings of the 11th Asia-Pacic software engineering con-ference. Busan, Korea; November 2004. p. 61623.

Binder W, Hulaas J. Using bytecode instruction counting as portable CPU consump-tion metric. Electronic Notes in Theoretical Computer Science 2006;153(2):5777.

Chun BG, Maniatis P. Augmented smartphone applications through clone cloudexecution. In: Proceedings of the eighth conference on hot topics in operatingsystems. Monte Verita, Switzerland; May 2009. p. 15.

Chun BG, Maniatis P. Dynamically partitioning applications between weak devicesand clouds. In: Proceeding of the rst ACM workshop on mobile cloudcomputing & services: social networks and beyond. San Francisco, CA, USA;June 2010. p. 15.

Chun BG, Ihm S, Maniatis P, Naik M, Patti A. Clonecloud: elastic execution betweenmobile device and cloud. In: Proceedings of the sixth conference on computersystems. Salzburg, Austria; April 2011. p. 30114.

Cuervo E, Balasubramanian A, Cho D. MAUI: making smart phone last longer withcode ofoading. In: Proceedings of the eighth international conference onmobile systems, applications, and services. San Francisco, California, USA; June2010. p. 4962.

Dahm M. Doorastha: a step towards distribution transparency. In: Proceedings ofJava-Informations-Tage/Net.ObjectDays 2000. Erfurt, Germany; October 2000.

Diaconescu RE, Wang L, Franz M. Automatic distribution of Java Byte-code based ondependence analysis. Technical report, University of California; 2003.

Diaconescu RE, Wang L, Mouri Z, et al. A compiler and runtime infrastructure forautomatic program distribution. In: Proceedings of the 19th IEEE internationalparallel and distributed processing symposium. Denver, Colorado, USA; April2005. p. 52a.

Kemp R, Palmer N, Kielmann T, et al. eyeDentify: multimedia cyber foraging from asmartphone. In: Proceedings of the 11th IEEE international symposium onmultimedia. San Diego, California, USA; December 2009. p. 3929.

Kemp R, Palmer N, Kielmann T, et al. Cuckoo: a computation ofoading frameworkfor smartphones. In: Proceedings of the second international conference onmobile computing, applications, and services, ad hoc and wireless networks.Santa Clara, CA, USA; October 2010. p. 6281.save energy?. IEEE Computer 2010;43(4):516.

Lhotk O. Spark: a exible points-to analysis framework for Java. Master's thesis.McGill University; December 2002.

Li Z, Wang C, Xu R. Computation ofoading to save energy on handheld devices: apartition scheme. In: Proceedings of the 2001 international conference oncompilers, architecture, and synthesis for embedded systems (CASES'01).Atlanta, Georgia, USA; November 2001. p. 23846.

Li F, Khan MK, Alghathbar K, Takagi T. Identity-based online/ofine signcryption forlow power devices. Journal of Network and Computer Applications 2012;35(1):3407.

Messer A, Greenberg I, Bernadat P, et al. Towards a distributed platform forresource-constrained devices. In: Proceedings of the 22nd international con-ference on distributed computing systems. Vienna, Austria; July 2002. p. 4351.

Ou S, Yang K, Zhang J. An effective ofoading middleware for pervasive services onmobile devices. Pervasive and Mobile Computing 2007;3(4):36285.

Semchedine F, Bouallouche-Medjkoune L, Assani D. Task assignment policies indistributed server systems: a survey. Journal of Network and ComputerApplications 2011;43(4):112330.

Sinha K, Kulkarni M. Techniques for ne-grained, multi-site computation ofoading.In: Proceedings of the 11th IEEE/ACM international symposium on cluster, cloudand grid computing. Newport Beach, CA, USA; May 2011. p. 18494.

Spiegel A. Automatic distribution of object-oriented programs. PhD thesis, FreieUniversitat Berlin, FB Mathematik und Informatik; December 2002.

Stoer M, Wanger F. A simple min-cut algorithm. Journal of the ACM 1997;44(4):58591.

Wang L, Franz M. Automatic partitioning of object-oriented programs for resource-constrained mobile devices with multiple distribution objectives. In: Proceed-ings of the 14th IEEE international conference on parallel and distributedsystems. Melbourne, Victoria, Australia; December 2008. p. 36976.

Xian CJ, Lu YH, Li ZY. Adaptive computation ofoading for energy conservation onbattery-powered systems. In: Proceeding of 2007 international conference onparallel and distributed systems. Hsinchu, Taiwan; December 2007. p. 18.

Yang K, Ou S, Chen H. On effective ofoading services for resource-constrainedmobile devices running heavier mobile internet applications. IEEE Commu-nication Magazine 2008;46(1):5663.

J. Niu et al. / Journal of Network and Computer Applications 37 (2014) 334347 347

Bandwidth-adaptive partitioning for distributed execution optimization of mobile applicationsIntroductionRelated workConstruction of weighted object relation graphsApplication partitioning processConstruction of weighted object relation graphStatic analysisDynamic profiling

Partitioning models and application partitioning algorithmsNotations and assumptionsPartitioning modelsExecution time optimization modelEnergy optimization modelExecution time and energy weighted optimization model

Min-cut problemBandwidth-adaptive application partitioning algorithmsBBAP algorithmMCGAP algorithm

EvaluationConstruction of weighted object relation graphBandwidth-adaptive application partitioning algorithmsEvaluation of BBAP performanceEvaluation of MCGAP performance

ConclusionReferences