Skip to main content
Log in

A formalized framework for mobile cloud computing

  • Special Issue Paper
  • Published:
Service Oriented Computing and Applications Aims and scope Submit manuscript

Abstract

Mobile Cloud Computing (MCC) is an emerging paradigm to transparently provide support for demanding tasks on resource-constrained mobile devices by relying on the integration with remote cloud services. Research in this field is tackling the multiple conceptual and technical challenges (e.g., how and when to offload) that are hindering the full realization of MCC. The Networked Autonomic Machine (NAM) framework is a tool that supports and facilitates the design networks of hardware and software autonomic entities, providing or consuming services or resources. Such a framework can be applied, in particular, to MCC scenarios. In this paper, we focus on NAM’s features related to the key aspects of MCC, in particular those concerning code mobility capabilities and autonomic offloading strategies. Our first contribution is the definition of a set of high-level actions supporting MCC. The second contribution is the proposal of a formal semantics for those actions, which provides the core NAM features with a precise formal characterization. Thus, the third contribution is the further development of the NAM conceptual framework and, in particular, the partial re-engineering of the related Java middleware. We show the effectiveness of the revised middleware by discussing the implementation of a Global Ambient Intelligence case study.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7

Similar content being viewed by others

Notes

  1. We use a version of Klaim enriched with high-level features, such as assignments, standard control flow constructs, and non-blocking retrieval actions, that simplify the modeling task. All such constructs are directly supported by Klaim  related tools (such as, e.g., the analysis tool SAM [26]).

  2. It is worth noticing that an offload request as received by the offload action handler contains more information (in particular, the identity of the destination NAM) with respect to the corresponding actions specified in the policies (see Sect. 3). We assume indeed that this level of transparency is properly managed by the processes modeling the execution of policy actions (i.e., processes \(P_{act}\) within \( PMH \)).

  3. https://code.google.com/p/nam4j/source/browse/.

  4. For the sake of simplicity, the formalization does not consider the possibility of copying a functional module without the associated services. However, we do not envisage any difficulties on modeling this feature.

  5. https://www.jboss.org/drools/.

References

  1. Amoretti M, Grazioli A, Senni V, Tiezzi F, Zanichelli F (2014) Towards a formal approach to mobile cloud computing. In: Parallel, distributed, and network-based processing (4PAD session), pp 743–750. IEEE

  2. Amoretti M, Laghi MC, Tassoni F, Zanichelli F (2010) Service migration within the cloud: code mobility in SP2A. In: High performance computing and simulation (HPCS), 2010 international conference on, pp 196–202

  3. Amoretti M, Picone M, Zanichelli F (2012) Global ambient intelligence: an autonomic approach. In: Pervasive computing and communications workshops (PERCOM), pp 842–847. IEEE

  4. Andrei O, Kirchner H (2009) A higher-order graph calculus for autonomic computing. In: Graph theory, computational intelligence and thought, volume 5420 of LNCS, pp 15–26. Springer

  5. Banâtre JP, Radenac Y, Fradet P (2004) Chemical specification of autonomic systems. In: Intelligent and adaptive systems and software engineering (IASSE), pp 72–79. ISCA

  6. Bigus JP, Schlosnagle DA, Pilgrim JR, Mills WN III, Diao Y (2002) ABLE: a toolkit for building multiagent autonomic systems. IBM Syst J 41(3):350–371

    Article  Google Scholar 

  7. Bouchenak S, Hagimont D, Krakowiak S, De Palma N, Boyer F (2002) Experiences implementing efficient java thread serialization, mobility and persistence. In: I.N.R.I.A., Research report no. 4662

  8. Cabri G, Leonardi L, Quitadamo R (2006) Enabling java mobile computing on the IBM jikes research virtual machine. In: Principles and practice of programming in java (PPPJ), volume 178 of ACM international conference proceeding series, pp 62–71. ACM

  9. Carzaniga A, Picco GP, Vigna G (2007) Is code still moving around? Looking back at a decade of code mobility. In: ICSE companion volume, pp 9–20. IEEE Computer Society

  10. Da Silva D (2013) Opportunities for autonomic behavior in mobile cloud computing, 2013. Keynote talk at ICAC’13. Available at https://www.usenix.org/conference/icac13/title-tba-0

  11. Dayal U, Hanson EN, Widom J (1994) Active database systems. In: Modern database systems, pp 434–456. ACM

  12. De Nicola R, Ferrari GL, Pugliese R (1998) KLAIM: a kernel language for agents interaction and mobility. IEEE Trans Softw Eng 24(5):315–330

  13. De Nicola R, Katoen JP, Latella D, Loreti M, Massink M (2007) Model checking mobile stochastic logic. Theor Comput Sci 382(1):42–70

  14. De Nicola R, Loreti M, Pugliese R, Tiezzi F (2014) A formal approach to autonomic systems programming: the SCEL language. ACM Trans Auton Adapt Syst (To appear)

  15. Dinh HT, Lee C, Niyato D, Wang P (2013) A survey of mobile cloud computing: architecture, applications, and approaches. Wirel Commun Mob Comput 13(18):1587–1611

    Article  Google Scholar 

  16. Fernando N, Loke SW, Rahayu W (2013) Mobile cloud computing: a survey. Future Gener Comput Syst 29(1):84–106

    Article  Google Scholar 

  17. Ferrari GL, Pugliese R, Tuosto E (2000) Calculi for network aware programming. In : Workshop “from objects to agents”: evolutive trends of software systems (WOA), pp 23–28. Pitagora Editrice Bologna

  18. Gamma E, Helm R, Johnson R, Vlissides J (1995) Design patterns: elements of reusable object-oriented software. Addison-Wesley Longman Publishing

  19. Gelernter D (1985) Generative communication in Linda. ACM Trans Program Lang Syst 7(1):80–112

    Article  MATH  Google Scholar 

  20. Gjondrekaj E, Loreti M, Pugliese R, Tiezzi F (2012) Modeling adaptation with a tuple-based coordination language. In: Symposium on applied computing (SAC), pp 1522–1527. ACM

  21. Grazioli A, Picone M, Zanichelli F, Amoretti M (2013) Code migration in mobile clouds with the NAM4J middleware. In: Mobile data management (MDM), 2013 IEEE 14th international conference on

  22. IBM (2005) An architectural blueprint for autonomic computing. Technical report, IBM Corporation, Third edition

  23. Kaiser G, Parekh J, Gross P, Valetto G (2003) Kinesthetics eXtreme: an external infrastructure for monitoring distributed legacy systems. In: Active middleware services (AMS), pp 22–30. IEEE Computer Society

  24. Kovachev D, Klamma R (2012) Beyond the client-server architectures: a survey of mobile cloud techniques. In: Communications in China workshops (ICCC), pp 20–25. IEEE Computer Society

  25. Kumar K, Lu Y-H (2010) Cloud computing for mobile users: can offloading computation save energy? IEEE Comput 43(4):51–56

  26. Loreti M (2010) SAM: stochastic analyser for mobility, 2010. Available at http://rap.dsi.unifi.it/SAM/

  27. Margheri A, Masi M, Pugliese R, Tiezzi F (2013) A formal software engineering approach to policy-based access control. Technical report, DiSIA, Univ. Firenze, 2013 Available at http://rap.dsi.unifi.it/facpl/research/Facpl-TR.pdf

  28. Melcher B, Mitchell B (2004) Towards an autonomic framework: self-configuring network services and developing autonomic applications. Intel Technol J 8(4):279–290

    Google Scholar 

  29. Milner R, Parrow J, Walker D (1992) A calculus of mobile processes, I and II. Inf Comput 100(1):1–40, 41–77

  30. Oasis WSRF TC (2006) Web services resource framework (WSRF) v1.2, April 2006. https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wsrf

  31. OASIS XACML TC (2013) eXtensible access control markup language (XACML) version 3.0, January 2013. https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=xacml

  32. Parekh J, Kaiser G, Gross P, Valetto G (2003) Retrofitting autonomic capabilities onto legacy systems. Tech. Rep. CUCS-026-03, Columbia University

  33. Stoica I, Morris R, Karger D, Kaashoek MF, Balakrishnan H (2001) Chord: a scalable peer-to-peer lookup service for Internet applications. In: Applications, technologies, architectures, and protocols for computer communications (SIGCOMM), pp 149–160. ACM

  34. Suri N, Bradshaw JM, Breedy MR, Groth PT, Hill GA, Jeffers R, Mitrovich TS (2000) An overview of the NOMADS mobile agent system. In: ECOOP workshop on mobile object systems

  35. Viroli M, Pianini D, Montagna S, Stevenson G (2012) Pervasive ecosystems: a coordination model based on semantic chemistry. In: Symposium on applied computing (SAC), pp 295–302. ACM

Download references

Author information

Authors and Affiliations

Authors

Corresponding author

Correspondence to Michele Amoretti.

Additional information

This work has been partially sponsored by the EU projects ASCENS (257414) and QUANTICOL (600708), and by the Italian MIUR PRIN project CINA (2010LHT4KM).

Appendix

Appendix

In this appendix we report and briefly comment the entire Klaim specification of the NAM framework formalization. We start by reviewing the various kinds of tuples used to synchronize the NAMs and to realize mobility actions.

1.1 Control tuples

Service identifiers are bound to functional modules that can offer those services and may be located in a local or remote NAM; services are implemented within a functional module by a process \(Proc\):

Services are accessed through a service request and then dispatched to a specific functional module \( fid \) by a service assignment, if it is a local module, or by a remote service assignment if it is an offloaded module:

Whenever a functional module is offloaded, the host NAM is aware of the identity \(nid\) of the offloading NAM so that it is able to send the module back to the owner on need:

Mobility actions are initiated by (five possible) mobility requests, issued by (NAM or functional module) policies:

When the mobility handler reacts to mobility requests, it sends appropriate mobility commands to the service handler of the corresponding functional module:

and to its policy handler:

Running threads are associated with a functional module and have their own unique identifier \(tid\), used when migrating or offloading the module:

When a migrate/offload action is performed, move requests are issued for each thread:

We expect that thread code is suitably instrumented to handle these move requests and threads behave accordingly.

1.2 NAM control

On arrival of a service request, the dispatcher chooses the appropriate functional module to provide the service:

The policy and mobility handler runs policies and realizes mobility actions:

The copy action handler, on arrival of a copy request, copies all binders by setting the remote NAM as the \( fid \) location, copies the implementations, and sends copy requests to the service and policy handler:

The migrate action handler, on arrival of a migrate request, moves all binders by setting the remote NAM as the \( fid \) location, moves the implementations, the service assignments, and the threads, and sends migrate requests to the service and policy handler:

The offload action handler has been discussed in the paper:

The back action handler \( BH \), on arrival of a back request, sends to the remote NAM a go request with destination \(\mathbf {self}\):

The go action handler has two possible behaviors. The first is performed on the remote NAM and, on arrival of a go request, retrieves the identity of the offloader NAM, sends a notification (\(\mathsf {goNotification}\)) to the offloader NAM with the new location (NAM\(_2\)) so that it can update service bindings accordingly, and moves implementation and threads to the new location. If the new destination NAM\(_2\) is the offloader itself, then it is indeed a back action, and it simply sends back requests to the service and policy handler, and translates remote service assignments to local ones. Otherwise, it performs three sub-steps: (i) it informs NAM\(_2\) of the offloader identity using the \(\mathsf {offloaderNAM}\) tuple, (ii) it sends go requests to the service and policy handler, and (iii) it moves remote (not yet served) service assignments. The second behavior of \( GH \) is performed on the local NAM and reacts to \(\mathsf {goNotification}\) messages by updating service binders to point to the new NAM (possibly, \(\mathbf {self}\)).

1.3 Functional module control

The service assignment handler, in its normal mode operation, has been described in the paper:

In the paper, we have also discussed the behavior of the service assignment handler in its offloaded mode operation:

Similar to the service assignment handler, the policy handler has a normal mode operation, where policies in \(P_N\) are executed on local events and mobility actions are handled in a similar way:

In offloaded mode, the policy handler splits into a local and a remote handler, reacting to local and remote events:

Also in this case, mobility actions are handled similarly to the service handler.

1.4 Macros

We now illustrate some macro code that helps improving code readability and performs crucial operations of the mobility handling process. In these macros, we use the \(\mathbf {while}\) construct with the non-blocking variants of \(\mathbf {in}/\mathbf {read}\) as argument, so we are ensured to consider each tuple of interest at least once. In case of \(\mathbf {read}\) argument, we assume that the semantics of \(\mathbf {while}\) ensures that each tuple is considered at most once. Notably, the \(\mathbf {while}\) loops in our macros code are ensured to terminate, due to a disciplined use of the considered tuples and appropriate boolean conditions on some of their fields.

Service binders can be moved, copied, and updated:

In the first case, each binder is deleted locally and written in the remote location, with a pointer to the remote implementation (we move implementations accordingly). In the second case, we do not consume local binders, but we still update the implementation location in the copy. In the third case, we change the implementation location by replacing those binders that still point to the local implementation (we assume \(nid_{ IMP }\) and \(nid_{ DST }\) are different).

Service assignments can be moved (in their local and remote variants) and also translated from local to remote and back:

Local to remote translation is necessary to move not-yet-served requests in offloading/migration, so that no request is lost. Similarly, remote to local translation is used when offloading is terminated, in a back action.

Implementations can simply be moved or copied:

Finally, we consider macros to handle threads. These can only be moved or started (forced termination is not allowed):

Moving threads of a functional module during offloading or migration is performed by retrieving (and deleting) each thread identifier associated with that module, sending a \(\mathsf {moveThread}\) message (thus relying on the thread ability to react to these requests), and registering the thread in the remote location.

Rights and permissions

Reprints and permissions

About this article

Check for updates. Verify currency and authenticity via CrossMark

Cite this article

Amoretti, M., Grazioli, A., Senni, V. et al. A formalized framework for mobile cloud computing. SOCA 9, 229–248 (2015). https://doi.org/10.1007/s11761-014-0169-3

Download citation

  • Received:

  • Revised:

  • Accepted:

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s11761-014-0169-3

Keywords

Navigation