| Ahnn J and Potkonjak M (2013), "mHealthMon: Toward Energy-Efficient and Distributed Mobile Health Monitoring Using Parallel Offloading", Journal of Medical Systems. Vol. 37(5), pp. 1-11. Springer US. |
| Abstract: Although mobile health monitoring where mobile sensors continuously gather, process, and update sensor readings (e.g. vital signals) from patient's sensors is emerging, little effort has been investigated in an energy-efficient management of sensor information gathering and processing. Mobile health monitoring with the focus of energy consumption may instead be holistically analyzed and systematically designed as a global solution to optimization subproblems. This paper presents an attempt to decompose the very complex mobile health monitoring system whose layer in the system corresponds to decomposed subproblems, and interfaces between them are quantified as functions of the optimization variables in order to orchestrate the subproblems. We propose a distributed and energy-saving mobile health platform, called mHealthMon where mobile users publish/access sensor data via a cloud computing-based distributed P2P overlay network. The key objective is to satisfy the mobile health monitoring application's quality of service requirements by modeling each subsystem: mobile clients with medical sensors, wireless network medium, and distributed cloud services. By simulations based on experimental data, we present the proposed system can achieve up to 10.1 times more energy-efficient and 20.2 times faster compared to a standalone mobile health monitoring application, in various mobile health monitoring scenarios applying a realistic mobility model. |
| Review: The paper makes many claims with no backup data but I will only look at the architecture aspects. From an architecture perspective, it does present at least a proposal for an optimization engine that runs on the mobile devices and a proxy that is invoked locally but that connects to the cloud. My main criticism of the paper, as just mentioned, is that although it proves that offloading consumes less energy and improves performance, it does not really show a scenario where it chooses to execute locally or remotely because the code that it is invoking doesn't really exist on the phone. The number has to do more with the network aspects. |
BibTeX:
@article{Ahnn2013,
author = {Ahnn, JongHoon and Potkonjak, Miodrag},
title = {mHealthMon: Toward Energy-Efficient and Distributed Mobile Health Monitoring Using Parallel Offloading},
journal = {Journal of Medical Systems},
publisher = {Springer US},
year = {2013},
volume = {37},
number = {5},
pages = {1-11},
url = {http://dx.doi.org/10.1007/s10916-013-9957-0}
}
|
| Angin P and Bhargava B (2013), "An Agent-based Optimization Framework for Mobile-Cloud Computing", Journal of Wireless Mobile Networks, Ubiquitous Computing, and Dependable Applications (JoWUA). Vol. 4, pp. 1-17. |
| Abstract: The proliferation of cloud computing resources in the recent years offers a way for mobile devices with limited resources to achieve computationally intensive tasks in real-time. The mobile-cloud computing paradigm, which involves collaboration between mobile and cloud resources, is expected to become increasingly popular in mobile application development. Dynamic partitioning of applications between mobile and cloud platforms based on resource availability is crucial in achieving the best performance for any computationally intensive mobile application. In this paper, we propose a dynamic performance optimization framework for mobile-cloud computing utilizing mobile agent-based application partitions. The proposed framework imposes minimal infrastructural requirements on the cloud servers, therefore exhibiting widespread applicability, as opposed to previous approaches with stricter requirements. Experiments with two real-world mobile applications serve as an initial feasibility study of the proposed framework and demonstrate the superiority of the proposed approach over monolithic execution of resource-intensive applications on mobile devices. |
| Review: The paper proposes a dynamic performance optimization framework for mobile-cloud computing utilizing mobile agent-based application partitions. It does not impose any requirements on the cloud platform other than providing isolated execution containers. The claim is that mobile agents are better suited for mobile-cloud computing because they are a better fit for intermittent network connectivity -- a mobile agent is shipped to the service provider and returns to the client only when it has collected all the requested data. Agent applications are developed using JADE (Java Agent Development Environment). Each agent execution environment is a Java Virtual Machine (JVM) and communication between different virtual machines (VMs) as well as event signaling within a single VM is achieved with Java Remote Method Invocation (RMI). Applications are manually partitioned into components (classes and/or methods) that have to be executed locally and components that can be executed remotely (set up as mobile agents). When a mobile application is launched, the execution manager contacts the cloud directory service to get a list of available machine instances in the cloud and selects the instance(s) with the highest communication link speed as well as the highest computing power. To make the decision, each application has execution time metadata for each application partition that was measured with a static application profiler. If the execution plan requires offloading a particular application partition, a bridge is formed between the caller of that partition and the cloud host selected by the execution manager, through which the offloaded partition migrates to the container in the host, carrying along its input parameters. Upon migration, the partition starts executing and communicates its output data to the caller through the same bridge. |
BibTeX:
@article{Angin2013,
author = {Angin, Pelin and Bhargava, Bharat},
title = {An Agent-based Optimization Framework for Mobile-Cloud Computing},
journal = {Journal of Wireless Mobile Networks, Ubiquitous Computing, and Dependable Applications (JoWUA)},
year = {2013},
volume = {4},
pages = {1--17},
url = {http://isyou.info/jowua/papers/jowua-v4n2-1.pdf?}
}
|
| Armstrong T, Trescases O, Amza C and de Lara E (2006), "Efficient and transparent dynamic content updates for mobile clients", In Proceedings of the 4th international conference on Mobile systems, applications and services. , pp. 56-68. |
| Abstract: We introduce a novel infrastructure supporting automatic updates for dynamic content browsing on resource constrained mobile devices. Currently, the client is forced to continuously poll for updates from potentially different data sources, such as, e-commerce, on-line auctions, stock and weather sites, to stay up to date with potential changes in content. We employ a pair of proxies, located on the mobile client and on a fully-connected edge server, respectively, to minimize the battery consumption caused by wireless data transfers to and from the mobile device. The client specifies her interest in changes to specific parts of pages by highlighting portions of already loaded web pages in her browser. The edge proxy polls the web servers involved, and if relevant changes have occurred, it aggregates the updates as one batch to be sent to the client. The proxy running on the mobile device can pull these updates from the edge proxy, either on-demand or periodically, or can listen for pushed updates initiated by the edge proxy. We also use SMS messages to indicate available updates and to inform the user of which pages have changed. Our approach is fully implemented using two alternative wireless networking technologies, 802.11 and GPRS. Furthermore, we leverage our SMS feature to implement and evaluate a hybrid approach which chooses either 802.11 or GPRS depending on the size of the update batch. Our evaluation explores the data transfer savings enabled by our proxy-based infrastructure and the energy consumption when using each of the two networking capabilities and the hybrid approach. Our results show that our proxy system saves data transfers to and from the mobile device by an order of magnitude and battery consumption by up to a factor of 4.5, compared to the client-initiated continuous polling approach. Our results also show that the batching effect of our proxy reduces energy consumption even in the case where the user never visits the same page twice. |
| Review: The paper proposes an infrastructure for supporting automatic updates for dynamic content browsing on resource-constrained mobile devices. It uses a pair of proxies, located on the mobile client and on a fully-connected edge server, to minimize the battery consumption caused by wireless data transfers to and from the mobile device. Client specifies interest in changes to specifc parts of pages by highlighting portions of already loaded web pages in the browser. The edge proxy polls the web servers involved, and if relevant changes have occurred, it aggregates the updates as one batch to be sent to the client. The proxy running on the mobile device can pull these updates from the edge proxy, either on-demand or periodically, or can listen for pushed updates initiated by the edge proxy. Also uses SMS messages to indicate available updates and to inform the user of which pages have changed. Leverages the SMS feature to implement and evaluate a hybrid approach which chooses either 802.11 or GPRS depending on the size of the update batch. The SMS shows the most promise in terms of energy savings, network usage, and data freshness. However, it assumes that there is the posibility to receive SMS messages. |
BibTeX:
@inproceedings{Armstrong2006,
author = {Armstrong, Trevor and Trescases, Olivier and Amza, Cristiana and de Lara, Eyal},
title = {Efficient and transparent dynamic content updates for mobile clients},
booktitle = {Proceedings of the 4th international conference on Mobile systems, applications and services},
year = {2006},
pages = {56--68},
url = {http://dl.acm.org/citation.cfm?id=1134687}
}
|
| Aucinas A, Crowcroft J and Hui P (2012), "Energy efficient mobile M2M communications", In Proceedings of ExtremeCom '12. |
| Abstract: Energy effcient communications are extremely important in challenging environments, where access to mains power is diffcult and sporadic. We propose a new approach of Machine-to-Machine (M2M) communication: augmenting the traditional model with cloud computing capabilities in the communication network to save energy and improve system availability. We propose that clones of the physical machines should be put on the network to create the Clone-to-Clone (C2C) communication and computation model. C2C has the potential to reduce traffic between end-points, reduce device power consumption and improve network performance. In the paper we present the architecture, focusing on performance improvement of a highly heterogeneous network, analyse the benefits and discuss potential drawbacks. |
| Review: Computation offload systems targeted at Intelligent Transport System and Mobile Mutiplayer Online games. Offload to a virtual clone of the device that resides on a network. Runtime decision between local or remote execution but it is not clear what the optimization algorithm is. Because the same code exists on the device and the clone, it is simply a method invocation. In the case of data, it remains in the cloud and what is sent to the mobile device is only what is necessary. (1) Virtual clones are networked (overlay network), (2) Virtual clones contain equivalent code, which also means that the code must be able to run locally and remotely (3) Virtual clones also maintain the master data set for the application. |
BibTeX:
@inproceedings{Aucinas2012,
author = {Aucinas, Andrius and Crowcroft, Jon and Hui, Pan},
title = {Energy efficient mobile M2M communications},
booktitle = {Proceedings of ExtremeCom '12},
year = {2012},
url = {http://extremecom2012.ee.ethz.ch/papers/3-extremecom2012-Aucinas.pdf}
}
|
| Bahrami A, Wang C, Yuan J and Hunt A (2006), "The workflow based architecture for mobile information access in occasionally connected computing", In Services Computing, 2006. SCC'06. IEEE International Conference on. , pp. 406-413. |
| Abstract: We describe a novel architecture for supporting mobile information access in the occasionally connected computing environment. By utilizing user workflow, profiles, and environmental information, information from various sources published to the system will be prioritized, cached and synchronized in the staging server, and eventually disseminated to mobile devices. Furthermore, workflow and user profile can help in predicting near future data needs and therefore can enable intelligent data charging. |
| Review: By using user workflow, profiles, and environmental information, information from various sources that is published to the system is prioritized, cached and synchronized in a staging server, and eventually disseminated to mobile devices. In addition, workflow and user profile data can help to predicting near future data needs and therefore enable intelligent data charging (pre-fetching). Key elements of the architecture are: (1) Intelligent forward caching (intelligently charge data to mobile devices during strong connection periods to account for weak (or no) connection periods), (2) use workflow together with access history, preference, profile, time, location, and other environmental aspects, (3) Collect and aggregate data from stationary and mobile sources, prioritize and pre-fetch data, and deliver information proactively. |
BibTeX:
@inproceedings{Bahrami2006,
author = {Bahrami, Ali and Wang, Changzhou and Yuan, Jun and Hunt, Anne},
title = {The workflow based architecture for mobile information access in occasionally connected computing},
booktitle = {Services Computing, 2006. SCC'06. IEEE International Conference on},
year = {2006},
pages = {406--413},
url = {http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=04026958}
}
|
| Balan RK, Gergle D, Satyanarayanan M and Herbsleb J (2007), "Simplifying cyber foraging for mobile devices", In Proceedings of the 5th international conference on Mobile systems, applications and services. New York, NY, USA , pp. 272-285. ACM. |
| Abstract: Cyber foraging is the transient and opportunistic use of compute servers by mobile devices. The short market life of such devices makes rapid modification of applications for remote execution an important problem. We describe a solution that combines a “little language” for cyber foraging with an adaptive runtime system. We report results from a user study showing that even novice developers are able to successfully modify large, unfamiliar applications in just a few hours. We also show that the quality of novice-modified and expert-modified applications are comparable in most cases. |
| Review: The goal is to enable rapid modification of applications for cyber foraging. The first part of the solution is a “little language” called Vivendi for expressing application-specific information that is relevant to cyber foraging. The tactics file contains the function prototype of each procedure deemed worthy of remote execution, and specifies how these procedures can be combined to produce a result. The second part of the solution is Chroma, a runtime system that provides support for resource monitoring, adaptation, and learning-based prediction. Chroma also supports history-based predictive resource management. Chroma has to be ported once to each new mobile device, and is then available to all applications. The third part is the Vivendi stub generator, which uses the tactics file as input and creates a number of stubs. Some of these stubs perform the well-known packing and unpacking function used in remote procedure calls. Other stubs are wrappers for Chroma calls. Calls to stubs are manually placed in application source code by the developer. The idea is that a domain expert creates the Vivendi file and then runs it through a stub generator that creates the calls to Chroma. These APIs have to then be invoked by the application. Even though it does not present a complete solution for cyber-foraging, it has enough information to infer the architecture components of the solution. It assumes that all components exist locally and remotely and that the decision on which to invoke is performed at runtime based on historical and current environment information. |
BibTeX:
@inproceedings{Balan2007,
author = {Balan, Rajesh Krishna and Gergle, Darren and Satyanarayanan, Mahadev and Herbsleb, James},
title = {Simplifying cyber foraging for mobile devices},
booktitle = {Proceedings of the 5th international conference on Mobile systems, applications and services},
publisher = {ACM},
year = {2007},
pages = {272--285},
url = {http://doi.acm.org/10.1145/1247660.1247692}
}
|
| Chang Y-S and Hung S-H (2011), "Developing Collaborative Applications with Mobile Cloud-A Case Study of Speech Recognition", Journal of Internet Services and Information Security (JISIS). Vol. 1(1), pp. 18-36. |
| Abstract: While the combination of cloud computing and mobile computing, termed mobile cloud computing, started to show its effects recently with many seemingly innovative smartphone applications and cloud services surfacing to the market today, we believe that the real potentials of mobile cloud computing is far from been fully explored due to several practical issues. The quality of the mobile networks is not adequate for delivering satisfactory user experiences via close collaboration over mobile networks. A dynamic workload partitioning scheme would help solve this problem, but the distribution of computation and data storage geographically can lead to serious security and privacy concerns, which makes user to take the risk of exposing the data to eavesdroppers in the middle of the network. Since we have yet to see collaborative mobile cloud applications which could dynamically migrate the workload to efficiently take advantage of the resources in the cloud, in this paper, we present a paradigm to guide the design of the following: the system architecture, the principle for partitioning applications, the method for offloading computation, and the control policy for data access. We argue that the proposed paradigm provides a unified solution to the performance and privacy issues, with a case study, a cloud-assisted speech recognition application, to illustrate our experimental results. |
| Review: The paper proposes a mobile cloud computing application development and execution solution that can dynamically migrate workloads to the cloud (they call these collaborative applications). The paper presents guidelines for system architecture, principles for partitioning applications, method for offloading computation, and the control policy for data access. Developers mark the kernel functions (functions that can be offloaded) in their code. At runtime, an offloading advisor uses a performance model, a power model, a model and status of the servers, the locations of files, and the condition of the network to determine if a kernel function should be executed remotely in the cloud. If the decision is to offload, then it migrates the kernel function to the server (input of the kernel function and the global application state) with the help from the request handler on the server. In essence, it implements a suspend/resume approach, while the VM on the mobile device is suspended, state is transferred to the server, and then resumed on the server. The accesses to file storage are handled by a user-space distributed filesystem. Communication between offloading advisors and request handlers is done through a secure channel. It suggests using TPM to establish trust or to only offload to personal or trusted servers (seems to be circumventing the privacy issue). It is not clear whether this is a vison paper or if something has actually been implemented. |
BibTeX:
@article{Chang2011,
author = {Chang, Yu-Shuo and Hung, Shih-Hao},
title = {Developing Collaborative Applications with Mobile Cloud-A Case Study of Speech Recognition},
journal = {Journal of Internet Services and Information Security (JISIS)},
year = {2011},
volume = {1},
number = {1},
pages = {18--36},
url = {http://isyou.info/jisis/vol1/no1/jisis-2011-vol1-no1-02.pdf}
}
|
| Chen G, Kang B-T, Kandemir M, Vijaykrishnan N, Irwin MJ and Chandramouli R (2004), "Studying energy trade offs in offloading computation/compilation in java-enabled mobile devices", Parallel and Distributed Systems, IEEE Transactions on. Vol. 15(9), pp. 795-809. IEEE. |
| Abstract: Java-enabled wireless devices are preferred for various reasons. For example, users can dynamically download Java applications on demand. The dynamic download capability supports extensibility of the mobile client features and centralizes application maintenance at the server. Also, it enables service providers to customize features for the clients. In this work, we extend this client/server collaboration further by offloading some of the computations (i.e., method execution and dynamic compilation) normally performed by the mobile client to the resource-rich server in order to conserve energy consumed by the client in a wireless Java environment. In the proposed framework, the object serialization feature of Java is used to allow offloading of both method execution and bytecode-to-native code compilation to the server when executing a Java application. Our framework takes into account communication, computation, and compilation energies to decide where to compile and execute a method (locally or remotely), and how to execute it (using interpretation or just-in-time compilation with different levels of optimizations). As both computation and communication energies vary based on external conditions (such as the wireless channel state and user supplied inputs), our decision must be done dynamically when a method is invoked. Our experiments, using a set of Java applications executed on a simulation framework, reveal that the proposed techniques are very effective in conserving the energy of the mobile client. |
| Review: This is an early paper that studies ways to make Java applications energy efficient when executed on Java-enabled wireless devices. It compares seven different approaches: execute bytecode locally, execute remotely, execute native locally with three different compilation optimization strategies, adaptive execution with local compilation, and adaptive execution with adaptive compilation. The approach requires the developer to determine which code could be executed remotely and then proxies have to be created for each of these pieces of code. The proxies contain information about energy consumption that has been obtained via profiling that it uses in combination with input/output size and wireless channel conditions to determine at runtime whether the code should be executed locally or remotely. Becuase it assumes that the same code exists both locally and remotely, in the case of remote execution it simply sends the method name and parameters and receives back the result. |
BibTeX:
@article{Chen2004a,
author = {Chen, Guangyu and Kang, B-T and Kandemir, Mahmut and Vijaykrishnan, Narayanan and Irwin, Mary Jane and Chandramouli, Rajarathnam},
title = {Studying energy trade offs in offloading computation/compilation in java-enabled mobile devices},
journal = {Parallel and Distributed Systems, IEEE Transactions on},
publisher = {IEEE},
year = {2004},
volume = {15},
number = {9},
pages = {795--809},
url = {http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=01333651}
}
|
| Cheng B and Probst M (2013), "HBB-NEXT I D4.4.1: Intermediate Middleware Software Components for Cloud Service Offloading" |
| Abstract: This document is the second deliverable for Task 4.3 in HBB-NEXT. In Task 4.3, HBB-NEXT explored the terminal functionalities to be offloaded to the cloud and designed and developed a cloud-based media processing platform (called media cloud) for handling them dynamically and efficiently. It is one of two Milestone 7 deliverables created by WP4 and thus presents Milestone 7 for the Cloud Offloading Enabler Part of WP4: “MS7: The intermediate version of the software components of WP3, 4 and 5 is in place”. |
| Review: The media cloud is able to receive media content from broadcasters or other content providers via different sources. it then detects the capability of the end-user devices, in terms of device type, browser type, supported codecs, screen size, and also network bandwidth and latency, then accordingly launches appropriate processing components to generate adaptive streams suitable for the devices, allocates those tasks over different virtual machines in the cloud, and finally delivers the generated streams to the user devices over the network. Media tasks are implemented as VMs in OpenStack. Media pipelines are defined as a composition of media tasks. There is an interface so that content providers can publish services and also put together media piplelines (workflows) in the cloud in order to deliver content more efficiently to mobile users. |
BibTeX:
@techreport{Cheng2013,
author = {Cheng, Bin and Probst, Michael},
title = {HBB-NEXT I D4.4.1: Intermediate Middleware Software Components for Cloud Service Offloading},
year = {2013},
url = {www.hbb-next.eu/documents/HBB-NEXT_D4.4.1.pdf}
}
|
| Chu H-h, Song H, Wong C, Kurakake S and Katagiri M (2004), "Roam, a seamless application framework", Journal of Systems and Software. Vol. 69(3), pp. 209-226. Elsevier. |
| Abstract: One of the biggest challenges in future application development is device heterogeneity. In the future, we expect to see a rich variety of computing devices that can run applications. These devices have different capabilities in processors, memory, networking, screen sizes, input methods, and software libraries. We also expect that future users are likely to own many types of devices. Depending on users’ changing situations and environments, they may choose to switch from one type of device to another that brings the best combination of application functionality and device mobility (size, weight, etc.). Based on this scenario, we have designed and implemented a seamless application framework called the Roam system that can both assist developers to build multi-platform applications that can run on heterogeneous devices and allow a user to move/migrate a running application among heterogeneous devices in an effortless manner. The Roam system is based on partitioning of an application into components and it automatically selects the most appropriate adaptation strategy at the component level for a target platform. To evaluate our system, we have created several multi-platform Roam applications including a Chess game, a Connect4 game, and a shopping aid application. We also provide measurements on application performance and describe our experience with application development in the Roam system. Our experience shows that it is relatively easy to port existing applications to the Roam system and runtime application migration latency is within a few seconds and acceptable to most non-real-time applications. |
| Review: The focus of the Roam system is therefore to address the device heterogeneity problem in runtime application migration. The application framework is resource-aware, meaning that it is aware of the characteristics on the device on which it is running (Java VM configuration and profile, display size, input method, memory, network, etc.) so that it can migrate computation to a different device. To adapt, it uses dynamic instantiation (component is implemented/re-implemented for different platforms; right component is instantiated at runtime), computation offload (if the device cannot run the component, it finds a remote server capable of running it and offloads that software component to that remote server), and transformation (device-independent components are transformed at runtime to fit the target device capabilities). At design time, a developer must make the decision on how to partition an application into separate components, and for each component, whether to provide multiple device-dependent implementations (MDD), a single device-dependent implementation (S-DD), or a single device-independent presentation (S-DI). In order to suspend and resume the execution of mobile applications across heterogeneous devices, the Roam system must be able to capture execution state on the source device, serialize and transfer it to the target device, and then restore it. The Roam agent on the source device first negotiates with the Roam agent on the target device. The negotiation involves exchanges of the target device capabilities, the device capabilities needed by each application component, and the code base URL where the Roamlet component byte code can be downloaded from. Roamlets are based on a component-based programming model: they are built as components that can be distributed across multiple devices, and can be composed together into a working application through well-defined interfaces. Roamlets and Roam agents use resource specifications to describe the device requirements for each component implementation, and the capabilities of a host device, respectively. For offloading computation, both the Roamlet users and the Roam agent can specify a list of servers that can accept offloadable components. |
BibTeX:
@article{Chu2004,
author = {Chu, Hao-hua and Song, Henry and Wong, Candy and Kurakake, Shoji and Katagiri, Masaji},
title = {Roam, a seamless application framework},
journal = {Journal of Systems and Software},
publisher = {Elsevier},
year = {2004},
volume = {69},
number = {3},
pages = {209--226},
url = {http://www.sciencedirect.com/science/article/pii/S0164121203000529}
}
|
| Chun B-G and Maniatis P (2009), "Augmented smartphone applications through clone cloud execution", In Proceedings of the 12th conference on Hot topics in operating systems. , pp. 8-8. |
| Abstract: Smartphones enable a new, rich user experience in pervasive computing, but their hardware is still very limited in terms of computation, memory, and energy reserves, thus limiting potential applications. In this paper, we propose a novel architecture that addresses these challenges via seamlessly - but partially - off-loading execution from the smartphone to a computational infrastructure hosting a cloud of smartphone clones.We outline new augmented execution opportunities for smartphones enabled by our CloneCloud architecture. |
| Review: The idea is to augment the smartphone’s capabilities by seamlessly offloading some tasks to a nearby computer, where they are executed in a cloned whole-system image of the device, reintegrating the results in the smartphone’s execution upon completion. It distinguishes between 5 types of augmented execution: (1) Primary functionality outsourcing is when computation-intensive code is synchronously offloaded to a server, similar to what is done in a typical client-server application, (2) Background augmentation is when the tasks that are offloaded do not need to interact with the user in the short-term and therefore can run in the background, (3) Mainline augmentation is when an application runs in a "wrapped" fashion and therefore offload is interspersed in the application, (4) Hardware augmentation is when you offload to a more powerful virtual machine, (5) Augmentation through multiplicity is when there are multiple copies of the same image and the application is offloaded totally or partially to multiple clones. In CloneCloud, augmented execution is performed in four steps: 1) Initially, a clone of the smartphone is created within the cloud (laptop, desktop, or server nodes); 2) The state of the primary (phone) and the clone is periodically or on-demand synchronized; 3) Application augmentations (whole applications or augmented pieces of applications) are executed in the clone, automatically or upon request; and 4) Results from clone execution are re-integrated back into the smartphone state. Once a computation block for remote execution is specified, first, the smartphone application process enters a sleep state. The process transfers its state to the clone VM. The VM allocates a new process state and overlays what it received from the phone with hardware description translation. The clone executes from the beginning of the computation block until it reaches the end of the computation block. The clone transfers its process state back to the phone. The phone receives the process state and reintegrates it, and wakes up the sleeping process to continue its execution. |
BibTeX:
@inproceedings{Chun2009,
author = {Chun, Byung-Gon and Maniatis, Petros},
title = {Augmented smartphone applications through clone cloud execution},
booktitle = {Proceedings of the 12th conference on Hot topics in operating systems},
year = {2009},
pages = {8--8},
url = {https://www.usenix.org/legacy/events/hotos09/tech/full_papers/chun/chun.pdf}
}
|
| Cuervo E (2012), "Enhancing Mobile Devices through Code Offload". Thesis at: Duke University. |
| Abstract: In this dissertation I characterize two frameworks that reduce the amount of developer effort required to improve the performance of mobile apps through code offload. The first, MAUI, is designed for computationally intensive general-purpose apps such as speech and facial recognition. The second, Kahawai, is designed for graphics-intensive apps like fastiv action video games. MAUI continuously monitors the device, network, and app, and uses its measurements to compute an energy-efficient program partition. MAUI reduces the burden on developers by taking advantage of core features of the managed code environments common to mobile platforms: code portability, serialization, reflection, and type safety. These features allows MAUI to automatically instrument and potentially offload methods that the developer has tagged as suitable for offload. MAUI is particularly effective on applications composed by operations whose computational cost is large compared to the transfer cost of their input parameters and their output results. Kahawai is designed for graphics-intensive apps such as console-style games and takes advantage of two features of today's mobile gaming platforms: capable mobile GPUs and reusable game engines. Even though today's mobile devices cannot duplicate the sophisticated graphical detail provided by gaming consoles and high-end desktop GPUs, devices have seen rapid improvements in their GPU processing capabilities. Kahawai leverages a device's GPU to provide collaborative rendering. Collaborative rendering relies on a mobile GPU to generate low-fidelity output, which when combined with server-side GPU output allows a mobile device to display a high-fidelity result. The benefits of collaborative rendering are substantial: mobile clients can experience high-quality graphical output using relatively little bandwidth. Fortunately, because most modern games are built on top of reusable game engines, developers only have to identify the sources of non-determinism in the game logic to take advantage collaborative rendering. Together, MAUI and Kahawai demonstrate that code offload can provide substantial benefits for mobile apps without overburdening app developers. |
| Review: The thesis statement is "It is possible for mobile developers to obtain significant benefits from code offload by identifying a small number of properties of their applications." He presents two different offloading systems. MAUI is targeted at operations that consume and produce small amounts of information compared to their computational requirements. Kahauai is targeted at graphics applications that require continuous updates and inputs, such as games. In MAUI, developers annotate their code to mark which methods are offloadable. Every time one of these methods is invoked, an optimization algorithm based on profiling decides whether the method should be executed locally or remotely. Once the method executes, profiling data is updated. In addition, only delta states are transferred each time the method is invoked, which is useful if inputs from one call to another are similar. Kahawai is targeted at applications that require high-end GPU rendering such as video games. It offloads a portion of the GPU computation to server-side infrastructure. Kahawai uses collaborative rendering: the low-fidelity output of the mobile GPU and the high-fidelity output of the server-side GPU are combined into the displayed output. |
BibTeX:
@phdthesis{Cuervo2012,
author = {Cuervo, Eduardo},
title = {Enhancing Mobile Devices through Code Offload},
school = {Duke University},
year = {2012},
url = {http://dukespace.lib.duke.edu/dspace/handle/10161/5768}
}
|
| Duga N (2011), "Optimality Analysis and Middleware Design for Heterogeneous Cloud HPC in Mobile Devices". Thesis at: Addis Ababa University. |
| Abstract: Mobile and embedded devices such as smartphones, wireless sensor nodes, and other ubiquitous consumer and industrial electronic systems play increasingly significant roles in our lives. Those devices provision a range of functionalities despite their limitations in terms of size, processing capacity and power constraints. The advent of ubiquitous systems like those finds itself in par with another emerging trend – cloud computing, wherein computational resources like storage, processing hardware and software systems are provisioned to clients as services via the Internet. Mobile cloud computing and the cloud in general could allow for yet more use cases while saving the otherwise limited battery power and augmenting the comparatively small computational workhorse available in mobile devices. Such a scenario of cloud HPC in mobile devices needs supporting middleware for transparent end-to-end (i.e. mobile-to/from-cloud) service oriented communication. In so doing the middleware abstracts and exposes heterogeneous cloud resources like general-purpose CPUs; GPU and FPGA clusters; raw and relational datastores; etc. In addition, such middleware should be able to provide runtime support and a brokerage mechanism for the mobile devices in order to consume an abstract cloud HPC service. In this thesis, a number of novel and existing techniques are explored towards lightweight middleware architecture and an end-to-end mobile-cloud infrastructure is introduced. A case study is done with Android powered mobile devices, a GPU-accelerated algorithm, a Wi-Fi network and said infrastructure towards an experimental evaluation and model driven optimality analysis of the envisioned system. Results showed that middleware-supported cloud HPC in mobile devices is indeed promising and results in significant energy savings, faster response times and paves way for more mobile computing use cases. |
| Review: The focus of this thesis is HPC-as-a-service. The idea is that a system has runtime support on the mobile device for service discovery, binding, and consumption; a service abstraction framework that runs in the cloud and provides a standardized interface to HPC services, and a Cloud Resource Broker that has a service repository (could run on the mobile device, the cloud, or an external server). It has an interesting classification of applications as unimodal (real time reponses), bi-modal (data capured via UI and then sent for processing), and multimodal (portions of both). Ideally, one could take a multimodal application and partition it so that the unimodal part is not offloaded and the bimodal part is offloaded. One of the very few papers that has an architectural focus and discusses throughput as a performance metric (response time affected by server load). |
BibTeX:
@mastersthesis{Duga2011,
author = {Duga, Naod},
title = {Optimality Analysis and Middleware Design for Heterogeneous Cloud HPC in Mobile Devices},
school = {Addis Ababa University},
year = {2011},
url = {http://etd.aau.edu.et/dspace/handle/123456789/2227}
}
|
| Endt H and Weckemann K (2011), "Remote Utilization of OpenCL for Flexible Computation Offloading using Embedded ECUs, CE Devices and Cloud Servers", In Volume 22: Applications, Tools and Techniques on the Road to Exascale Computing. Vol. 22, pp. 133-140. IOS Press EBooks. |
| Abstract: In this paper, we present an approach that allows to downsize on-board ECUs to support the typical case of running a specified number of applications while featuring the opportunity to back-off computational power in worst case scenarios. Furthermore, this concept enables car manufacturers to offer new functionality to customers over the complete product-lifetime without the need to upgrade the hardware of ECUs or to have cost -intensive automotive high performance hardware available on-board. This is achieved by enabling automotive applications to utilize either built-in computational power, Consumer Electronics (CE) devices like the customer's smartphone or the computational power of cloud servers. Therefore we extend OpenCL, an industry standard that is supported by many different companies, to work locally on automotive platforms as well as remotely over the network. This becomes possible with the emergence of IP-based in-car networks. |
| Review: The motivation behind computation offloading is to minimize the size of on-board ECUs on automobiles and to minimize hardware upgrades due to greater computation needs. They extended OpenCL, which is a language for parallel programming, to work over IP networks. The idea is that tasks/program parts that are parallelizable are called kernels and can be offloaded to other Open-CL capable devices for execution. In their conceptual implementation the decision to run locally or to offload is made at runtime based on available devices, current capacity of the devices, and link quality. Even though the formula is clear, how they obtain the values is not clear. |
BibTeX:
@incollection{Endt2011,
author = {Holger Endt and Kay Weckemann},
title = {Remote Utilization of OpenCL for Flexible Computation Offloading using Embedded ECUs, CE Devices and Cloud Servers},
booktitle = {Volume 22: Applications, Tools and Techniques on the Road to Exascale Computing},
publisher = {IOS Press EBooks},
year = {2011},
volume = {22},
pages = {133-140},
note = {This paper was not available online. I got it from the library.},
url = {http://ebooks.iospress.nl/publication/26516}
}
|
| Esteves RG, McCool MD and Lemieux C (2011), "Real options for mobile communication management", In GLOBECOM Workshops (GC Wkshps), 2011 IEEE. , pp. 1241-1246. |
| Abstract: Mobile computing devices have become pervasive in modern life. They provide applications that greatly enhance user activities, especially when several devices are used cooperatively. This communication, however, must be carefully orchestrated to make effective use of available network resources. In this work, we present a principled way for a mobile node to determine if and when it is cost-effective to offload computation to a remote server. This approach is based on the framework of Real Options, which provides well-understood optimization methods that are fundamentally extensible, being able to accommodate a great number of restrictions and utility models. We validate our design on a simulated wireless system under changing network conditions and limited battery life. |
| Review: It basically finds the most cost-effective choice a mobile computing node can make when it comes to offload computation to advance its assigned task. It states that applications that, while designed to run on mobile nodes, make routine use of remote resources are sometimes called “elastic.” Posits that mobile nodes require a framework to weigh the advantages of offloading to remote servers, including how, when and to which remote server to offload. This requires programs with the ability to measure current operating conditions against present or forecasted resource demand, and to adapt themselves to those conditions. Their approach uses the ROA framework to improve the operation of a workload running on a mobile computing node by having it delegate some of that workload to whatever server the ROA has determined most effective. As servers come online, they broadcast their availability as well as their current load. Each mobile node maintains a list of accessible servers and estimates the network delay to each of them using the default routing. The algorithm for option pricing is run with the network behavior model to determine the cost/benefit of offloading. If offloading is the best choice, the offloader module sends the necessary input data to the specified remote server. The network traffic model is updated based on real data. As servers prepare go offline they broadcast their intention so that the server list is updated. Even though it is not clear how or how feasible the network behavior model is created, I am interested only in the architectural aspects. |
BibTeX:
@inproceedings{Esteves2011,
author = {Esteves, Rodolfo G and McCool, Michael D and Lemieux, Christiane},
title = {Real options for mobile communication management},
booktitle = {GLOBECOM Workshops (GC Wkshps), 2011 IEEE},
year = {2011},
pages = {1241--1246},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6162380&tag=1}
}
|
| Fjellheim T, Milliner S and Dumas M (2005), "Middleware support for mobile applications", International Journal of Pervasive Computing and Communications. Vol. 1(2), pp. 75-88. Emerald Group Publishing Limited. |
| Abstract: Mobile devices have received much research interest in recent years. Mobility raises new issues such as more dynamic context, limited computing resources, and frequent disconnections. A middleware infrastructure for mobile computing must handle all these issues properly. In this project we propose a middleware, called 3DMA, to support mobile computing. We introduce three requirements, distribution, decoupling and decomposition as central issues for mobile middleware. 3DMA uses a space based middleware, which facilitates the implementation of decoupled behavior and support for disconnected operation and context awareness. This is done by defining a set of “workers” which are able to act on the users behalf either: to reduce load on the mobile device, and/or to support disconnected behavior. In order to demonstrate aspects of the middleware architecture we then consider the development of a commonly used mobile application. |
| Review: 3DMA uses a space-based middleware (combination of tuple space, JavaSpaces and blackboard architectural paradigms), which facilitates the implementation of decoupled behavior and support for disconnected operation and context awareness.JavaSpaces implements an object space, which is a distributed shared memory space used for decoupled communication via sending and receiving objects. It defines a set of “workers” which are able to act on the users behalf either: to reduce load on the mobile device, and/or to support disconnected behavior (non-autonomous). Applications are decomposed into decoupled parts. Claim that a middleware supporting adaptation should allow applications to specify their non-core behavior dynamically at runtime, to allow this functionality to change according to changing requirements or context. Workers are divided into four main categories: 1) triggers (elements that react to specific events), 2) advisors (maintain preferences and policies of users), 3) connectors (promote connectivity and support multi-channel delivery methods, makes decisions based on device settings or capabilities) and 4) context facets (storage and dissemination point for context information regarding one context element). Workers can be seen as coordination entities which act independently of components, applications, services and other workers. |
BibTeX:
@article{Fjellheim2005,
author = {Fjellheim, Tore and Milliner, Stephen and Dumas, Marlon},
title = {Middleware support for mobile applications},
journal = {International Journal of Pervasive Computing and Communications},
publisher = {Emerald Group Publishing Limited},
year = {2005},
volume = {1},
number = {2},
pages = {75--88},
url = {http://www.emeraldinsight.com/journals.htm?articleid=1615695&show=html}
}
|
| Flinn J, Park S and Satyanarayanan M (2002), "Balancing Performance, Energy, and Quality in Pervasive Computing", In In Proceedings of the 22nd International Conference on. Distributed Computing Systems. , pp. 217-226. |
| Abstract: We describe Spectra, a remote execution system for battery-powered clients used in pervasive computing. Spectra enables applications to combine the mobility of small devices with the greater processing power of static compute servers. Spectra is self-tuning: it monitors both application resource usage and the availability of resources in the environment, and dynamically determines how and where to execute application components. In making this determination, Spectra balances the competing goals of performance, energy conservation, and application quality. We have validated Spectra’s approach on the Compaq Itsy v2.2 and IBMThinkPad 560X using a speech recognizer, a document preparation system, and a natural language translator. Our results confirm that Spectra almost always selects the best execution plan, and that its few suboptimal choices are very close to optimal. |
| Review: The major drawback of Spectra is that applications have to be modified to use Spectra. Chroma is based on Spectra. Spectra targets applications that perform relatively coarse-grained operations—currently a second or more in duration. Spectra clients maintain a database of servers willing to host computation. For each server in the list, Spectra iterates through the set of resource monitors. The solver selects the alternative that maximizes an input utility function. Application code components executed on Spectra servers are referred to as services. Its measurement functionality is implemented as a set of resource monitors, code components that measure a single resource or a set of related resources. The monitors are contained within a modular framework shared by Spectra clients and servers. Currently, Spectra has six types of monitors: CPU, network, battery, file cache state, remote CPU, and remote file cache state. Even though it does not present an architecture, it has enough information to infer it. |
BibTeX:
@inproceedings{Flinn2002,
author = {Jason Flinn and Soyoung Park and M. Satyanarayanan},
title = {Balancing Performance, Energy, and Quality in Pervasive Computing},
booktitle = {In Proceedings of the 22nd International Conference on. Distributed Computing Systems},
year = {2002},
pages = {217--226},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1022259&tag=1}
}
|
| Flinn J, Sinnamohideen S, Tolia N and Satyanarayanan M (2003), "Data Staging on Untrusted Surrogates", In Proceedings 2nd USENIX Conference on File and Storage Technologies (FAST03), Mar 31-Apr 2, 2003, San Francisco, CA.. |
| Abstract: We show how untrusted computers can be used to facilitate secure mobile data access. We discuss a novel architecture, data staging, that improves the performance of distributed file systems running on small, storage-limited pervasive computing devices. Data staging opportunistically prefetches files and caches them on nearby surrogate machines. Surrogates are untrusted and unmanaged: we use end-to-end encryption and secure hashes to provide privacy and authenticity of data and have designed our system so that surrogates are as reliable and easy to manage as possible. Our results show that data staging reduces average file operation latency for interactive applications running on the Compaq iPAQ handheld by up to 54%. |
| Review: Data staging opportunistically prefetches files and caches them on nearby surrogate machines. The untrusted computer, called a surrogate, plays the role of a second-level file cache for a mobile client. By prefetching files and staging them on the surrogate, cache misses from a nearby mobile client can be serviced at low latency (typically one wireless hop) instead of full Internet latency. When servicing a cache miss, the client decrypts file data received from the surrogate, calculates the hash, and verifies the computed hash against its cached copy. Staging is expedited by a data pump that typically executes on a user’s idle desktop computer located near the file server. When the client proxy wishes to stage a file, it sends a message to the pump through a secure channel. The pump authenticates the message, reads the file from the file system, encrypts the file, and generates a cryptographic hash of the data. The pump transmits the encrypted file to the surrogate and sends the file key and hash to the client through the secure channel. The client proxy implements two prediction algorithms (role-based and user-driven clustering) that try to predict the files that will need to be staged. |
BibTeX:
@inproceedings{Flinn2003,
author = {Jason Flinn and Shafeeq Sinnamohideen and Niraj Tolia and Mahadev Satyanarayanan},
title = {Data Staging on Untrusted Surrogates},
booktitle = {Proceedings 2nd USENIX Conference on File and Storage Technologies (FAST03), Mar 31-Apr 2, 2003, San Francisco, CA.},
year = {2003},
url = {https://www.usenix.org/conference/fast-03/data-staging-untrusted-surrogates}
}
|
| Giurgiu I, Riva O, Juric D, Krivulev I and Alonso G (2009), "Calling the Cloud: Enabling Mobile Phones as Interfaces to Cloud Applications", In Middleware 2009. Vol. 5896, pp. 83-102. Springer Berlin Heidelberg. |
| Abstract: Mobile phones are set to become the universal interface to online services and cloud computing applications. However, using them for this purpose today is limited to two configurations: applications either run on the phone or run on the server and are remotely accessed by the phone. These two options do not allow for a customized and flexible service interaction, limiting the possibilities for performance optimization as well. In this paper we present a middleware platform that can automatically distribute different layers of an application between the phone and the server, and optimize a variety of objective functions (latency, data transferred, cost, etc.). Our approach builds on existing technology for distributed module management and does not require new infrastructures. In the paper we discuss how to model applications as a consumption graph, and how to process it with a number of novel algorithms to find the optimal distribution of the application modules. The application is then dynamically deployed on the phone in an efficient and transparent manner. We have tested and validated our approach with extensive experiments and with two different applications. The results indicate that the techniques we propose can significantly optimize the performance of cloud applications when used from mobile phones. |
| Review: The paper presents a middleware platform that can automatically distribute different layers of an application between the phone and the server, and optimize a variety of objective functions (latency, data transferred, cost, etc.). It abstracts an application’s behavior as a data flow graph of several inter-connected software modules. Modules encapsulate small functional units supplied by the application developer. Each module provides a set of services, and modules are connected through the corresponding service dependencies. Through offline application profiling, modules and service dependencies are characterized in terms of their resource consumption (data exchange, memory cost, code size), thus providing the knowledge base for the optimization process. Given this graph, in the second step, a partitioning algorithm finds the optimal cut that maximizes (or minimizes) a given objective function. The objective function expresses a user’s goal such as to minimize the interaction latency or the data traffic. Moreover, the optimization also takes into account a mobile phone’s resource constraints such as memory and network resources available. It uses AlfredO to carry out the physical distribution of an application’s modules between a mobile phone and a server. AlfredO is based on OSGi. Upon explicit discovery or by direct connection to a known address the connection is established and the client requests a selected application. Using one of the available partitioning algorithms AlfredOCore computes the optimal deployment for such an application, and then returns to AlfredOClient the application’s descriptor (also explained later) and the list of services to be fetched. The application’s descriptor is used by the Renderer to generate the corresponding AWT or SWT user interface, while AlfredOClient fetches the specified services via R-OSGi. In the general case, a server provides bundles offering services. If a client wants to use a server’s service, the server provides the client with the service interface of such a service. Then the R-OSGi framework residing on the client side generates from the service interface a local proxy. The local proxy delegates service calls of the client to the remote server and each proxy is registered with the local R-OSGi service registry as an implementation of the particular service. |
BibTeX:
@inproceedings{Giurgiu2009,
author = {Giurgiu, Ioana and Riva, Oriana and Juric, Dejan and Krivulev, Ivan and Alonso, Gustavo},
editor = {Bacon, JeanM. and Cooper, BrianF.},
title = {Calling the Cloud: Enabling Mobile Phones as Interfaces to Cloud Applications},
booktitle = {Middleware 2009},
publisher = {Springer Berlin Heidelberg},
year = {2009},
volume = {5896},
pages = {83-102},
url = {http://dx.doi.org/10.1007/978-3-642-10445-9_5}
}
|
| Goyal S (2011), "A Collective Approach to Harness Idle Resources of End Nodes". Thesis at: School of Computing, University of Utah. |
| Abstract: We propose a collective approach for harnessing the idle resources (cpu, storage, and bandwidth) of nodes (e.g., home desktops) distributed across the Internet. Instead of a purely peer-to-peer (P2P) approach, we organize participating nodes to act collectively using collective managers (CMs). Participating nodes provide idle resources to CMs, which unify these resources to run meaningful distributed services for external clients. We do not assume altruistic users or employ a barter-based incentive model; instead, participating nodes provide resources to CMs for long durations and are compensated in proportion to their contribution. In this dissertation we discuss the challenges faced by collective systems, present a design that addresses these challenges, and study the effect of selfish nodes. We believe that the collective service model is a useful alternative to the dominant pure P2P and centralized work queue models. It provides more effective utilization of idle resources, has a more meaningful economic model, and is better suited for building legal and commercial distributed services. We demonstrate the value of our work by building two distributed services using the collective approach. These services are a collective content distribution service and a collective data backup service. |
| Review: Rather than a purely P2P solution, it introduces collective managers (CMs) that manage the resources of large pools of untrusted, selfish, and unreliable participating nodes (PNs). PNs contact CMs to make their resources available, in return for which they expect to receive compensation. After registering with a CM, each PN runs a virtual machine (VM) image provided by the CM. CMs remotely control these VMs (root access) and use their processing, storage, and network resources to build distributed services. Section 9.4 has an example where the PNs are surrogates on which mobile devices can offload expensive computation. The idea is that the mobile device contacts a CM to ask for a surrogate. Once it is located, the mobile devices sends a small program to a daemon listening on a well-known port on the virtual server and the daemon runs the program on behalf of the client. Typically, this program is a shell script that downloads the real application over the Internet, installs it, and runs it. |
BibTeX:
@phdthesis{Goyal2011,
author = {Goyal, Sachin},
title = {A Collective Approach to Harness Idle Resources of End Nodes},
school = {School of Computing, University of Utah},
year = {2011},
url = {http://content.lib.utah.edu/cdm/ref/collection/etd3/id/37}
}
|
| Guan T (2008), "A System Architecture to Provide Enhanced Grid Access for Mobile Devices". Thesis at: University of Southampton. |
| Abstract: More integration and computing power are required to support the proliferation of mobile devices. While new-generation mobile devices improve their absolute capabilities, there is no doubt that creating complicated applications remains a challenging objective because mobile devices are typically resource-constrained, relative to their static counterparts. One possible solution is that mobile devices use Grid services to enable users to access various distributed resources automatically on demand. The combination of mobile and Grid computing has the potential to establish a new field where high performance Grid facilities are accessed through resource-limited mobile devices. A great number of challenges must be solved to realize the vision of building the bridge between Grid services and mobile devices. This thesis presents the author's research work that aims to enable users to accomplish complex tasks through their handheld devices by utilizing distributed resources in service-oriented Grid environments. A context-aware framework has been built with Semantic Web technologies to support intelligent interaction between mobile users and Grid services and a semantic matching framework has been implemented to facilitate effective Grid service discovery. Based on the above, a system architecture has been developed to provide enhanced Grid access for mobile devices. The middleware in the system architecture hides the diversity of heterogeneous mobile devices, enables the required Grid services to be discovered in a flexible way, and provides a reliable task execution mechanism. The performance of the system architecture has been evaluated using both comparison and simulation. Although there is no doubt that there are still a number of challenges that must be overcome before the long-term vision of bringing Grid services into the world of ambient intelligence comes into existence, the system architecture designed, implemented, and evaluated in this thesis represents an important step to realize a variety of new computing models (in particular Grid computing) in the mobile computing world. |
| Review: Users send task requests to the Grid Gateway, which is a server in single-hop proximity that executes the mobile deputy middleware. This middleware creates a deputy object for each user of the system that interacts with distributed resources on behalf of the mobile device. The system architecture hides the diversity of heterogeneous mobile devices The middleware has capabilities to discover Grid services to complete the task, and provides a reliable task execution mechanism. The thesis provides a LOT of background information (relevant content does not start until Chapter 6). The scope of the proposed middleware is beyond cyber-foraging (for example, includes context-awareness on both sides to determine when it is OK to send back results). It also proposes that mobile devices can be service providers or consumers. |
BibTeX:
@phdthesis{Guan2008,
author = {Guan, Tao},
title = {A System Architecture to Provide Enhanced Grid Access for Mobile Devices},
school = {University of Southampton},
year = {2008},
url = {http://eprints.soton.ac.uk/264489/1/Thesis.pdf}
}
|
| Ha K, Lewis G, Simanta S and Satyanarayanan M (2011), "Cloud Offload in Hostile Environments" |
| Abstract: Selective offloading of resource-intensive execution from a mobile device to the cloud can extend battery life and broaden the range of supported applications. Unfortunately, the success of this approach is critically dependent on a reliable end-to-end network. This dependence is a serious vulnerability in hostile environments, especially those involving wireless components in their long-haul network segments. We describe an architectural approach to reducing this vulnerability. Using a hierarchical cloud structure, offload is performed on stateless elements that are typically one wireless hop away from a mobile device. The proximity of offload reduces synchronous dependence on vulnerable long-haul network segments. We present experimental results that reflect on key design tradeoffs from a prototype implementation of this architecture. |
| Review: It compares different strategies for delivering the VM to the cloudlets and compares the different approaches in terms of application-ready time as well as energy consumption on the mobile device. |
BibTeX:
@techreport{Ha2011,
author = {Ha, Kiryong and Lewis, Grace and Simanta, Soumya and Satyanarayanan, Mahadev},
title = {Cloud Offload in Hostile Environments},
year = {2011},
url = {http://elijah.cs.cmu.edu/DOCS/CMU-CS-11-146.pdf}
}
|
| Hung S-H, Shieh J-P and Lee C-P (2011), "Migrating Android Applications to the Cloud", International Journal of Grid and High Performance Computing (IJGHPC). Vol. 3(2), pp. 14-28. IGI Global. |
| Abstract: Recently, smartphone technologies have evolved quickly and offered end users the computing power and networking capabilities required to perform useful network and multimedia applications. However, due to limited physical sizes and battery capacities, the current generation of smartphones cannot yet fulfill the requirements of sophisticated applications of which personal computers are capable. One way to solve this problem is to minimize the workload on a smartphone as much as possible by offloading portions of an application to a server. The solution is particularly attractive today as cloud computing provides the needed server resources at relatively low costs. This paper proposes a novel, lightweight application migration mechanism for the users of smartphones to suspend the execution of applications and offload them to the cloud. The authors also developed a framework to perform Android applications efficiently with virtual phones in the cloud with a virtual storage. This paper discusses the migration mechanism and evaluates its effectiveness on the Android smartphone. This approach may effectively offload workload for Android applications even with low-speed mobile network. |
| Review: It presents a framework for facilitating a virtual environment, called virtual phone, to execute smartphone applications via IaaS. It leverages Android's application pause-resume scheme in the application migration mechanism. The mobile device uses an agent to set up a virtual phone in the cloud. The virtual phone is set up to match the Android OS version of the mobile device by loading the appropriate image that contains an agent that interacts with the agent on the mobile phone. The application’s activity data is sent back and forth between the physical phone and the virtual phone, triggered by the pause-resume cycle. Application states are saved and restored via synchronized file storage. |
BibTeX:
@article{Hung2011,
author = {Hung, Shih-Hao and Shieh, Jeng-Peng and Lee, Chen-Pang},
title = {Migrating Android Applications to the Cloud},
journal = {International Journal of Grid and High Performance Computing (IJGHPC)},
publisher = {IGI Global},
year = {2011},
volume = {3},
number = {2},
pages = {14--28},
url = {http://www.igi-global.com/article/migrating-android-applications-cloud/54193}
}
|
| Imai S (2012), "Task Offloading between Smartphones and Distributed Computational Resources". Thesis at: Rensselaer Polytechnic Institute. |
| Abstract: Smartphones have become very popular. While people enjoy various kinds of applications, some computation-intensive applications cannot be run on the smartphones since their computing power and battery life are still limited. We tackle this problem from two categories of applications. Applications in the first category are single-purpose and moderately slow (more than 10 seconds) to process on a single smartphone, but can be processed reasonably quickly by offloading a single module to a single computer (e.g., a face detection application). Applications in the second category are extremely slow (a few minutes to hour) to process on a single smartphone, but their execution time can be dramatically reduced by offloading computationally heavy modules to multiple computers (e.g., a face recognition application). In this category of applications, management of the server-side computation becomes more important since the intensity of computation is much stronger than in the first category. For the first category, we propose a light-weight task offloading method using runtime profiling, which predicts the total processing time based on a simple linear model and offloads a single task to a single server depending on the current performance of the network and server. Since this model’s simplicity greatly reduces the profiling cost at run-time, it enables users to start using an application without pre-computing a performance profile. Using our method, the performance of face detection for an image of 1.2 Mbytes improved from 19 seconds to 4 seconds. For the second category, we present a middleware framework called the Cloud Operating System (COS) as a back-end technology for smartphones. COS implements the notion of virtual machine (VM) malleability to enable cloud computing applications to effectively scale up and down. Through VM malleability, virtual machines can change their granularity by using split and merge operations. We accomplish VM malleability efficiently by using application-level migration as a reconfiguration strategy. Our experiments with a tightly-coupled computation show that a completely application-agnostic automated load balancer performs almost the same as human-driven VM-level migration; however, human-driven application-level migration outperforms (by 14% in our experiments) human-driven VM-level migration. These results are promising for future fully automated cloud computing resource management systems that efficiently enable truly elastic and scalable workloads |
| Review: Applications in the first category are single-purpose and moderately slow (more than 10 seconds) to process on a single smartphone, but can be processed reasonably quickly by offloading a single module to a single computer. Applications in the second category are extremely slow (a few minutes to hours) to process on a single smartphone, but their execution time can be dramatically reduced by offloading computationally heavy modules to multiple computers. For the first category, it proposes a light-weight task offloading method using runtime profiling, which predicts the total processing time based on a simple linear model and offloads a single task to a single server depending on the current performance of the network and server (no need to pre-compute a performance profile). Local execution time, remote execution time and offload time are calculated once and used as the initial values for the offload decision algorithm. These values are updated at runtime based on real data using the least squares method, only if the prediction error is greater than a certain threshold. For the second category, it presents a middleware framework called the Cloud Operating System (COS) as a back-end technology that implements the notion of virtual machine (VM) malleability to enable cloud computing applications to effectively scale up and down -- middleware for autonomous virtual machine malleability through application-level workload migration. VM malleability is defined as the ability to change the granularity of VM instances dynamically. It uses SALSA (Simple Actor Language System and Architecture), an actor-oriented programming language that simplifies dynamic reconfiguration for mobile and distributed computing through features such as universal naming and transparent migration. Applications composed of SALSA actors can be easily reconfigured at run time by using actor migration, which is similar to splitting and merging VMs. An actor is an isolated application (workload) written in SALSA that runs on top of a SALSA runtime environment on top of a VM and encapsulates its state and does not share memory with other actors. This latter part is a load balancing solution that could be implemented to support multiple offloading clients and applications. |
BibTeX:
@mastersthesis{Imai2012,
author = {Imai, Shigeru},
title = {Task Offloading between Smartphones and Distributed Computational Resources},
school = {Rensselaer Polytechnic Institute},
year = {2012},
url = {http://wcl.cs.rpi.edu/theses/imaishigeru-master.pdf}
}
|
| Iyer AN and others (2012), "Extending Android Application Programming Framework for Seamless Cloud Integration", In Mobile Services (MS), 2012 IEEE First International Conference on. , pp. 96-104. |
| Abstract: Two major trends have dominated the computing world in recent times: Mobile systems and Cloud computing. A mobile device leveraging the capabilities of cloud can address many use case scenarios that were not practical earlier. In the recent past, several architectures were proposed aimed at supporting "mobile-cloud" applications but their implementation is challenging without an intuitive programming model. In this paper we present an innovative programming model that allows the mobile applications developer to view the cloud in terms of the familiar Android application components, thus obviating the need for familiarity with vendor specific web services or client libraries. |
| Review: Third-party cloud services as well as any user-written code as a part of computation offloading are treated as application components of Android - that is activities, services, content providers and broadcast receivers. A Mobile Cloud Manager runs on the mobile device and is introduced as part of the Android stack. A Mobile Cloud Server acts as a proxy to the cloud and communicates with the mobile system. It is also bi-directional, meaning that mobile device components can invoke cloud components and viceversa. In essence, the programming model provides a set of libraries that can be used to invoke cloud services as if they were local services. As far as offloading, the paper indicates that a developer would simply write complex-computation components that run in the Mobile Cloud Server |
BibTeX:
@inproceedings{Iyer2012,
author = {Iyer, Anantharaman Narayana and others},
title = {Extending Android Application Programming Framework for Seamless Cloud Integration},
booktitle = {Mobile Services (MS), 2012 IEEE First International Conference on},
year = {2012},
pages = {96--104},
url = {http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=6263815}
}
|
| Jarabek C, Barrera D and Aycock J (2012), "ThinAV: truly lightweight mobile cloud-based anti-malware", In Proceedings of the 28th Annual Computer Security Applications Conference. , pp. 209-218. |
| Abstract: This paper introduces ThinAV, an anti-malware system for Android that uses pre-existing web-based file scanning services for malware detection. The goal in developing ThinAV was to assess the feasibility of providing real-time antimalware scanning over a wide area network where resource limitation is a factor. As a result, our research provides a necessary counterpoint to many of the big-budget, resourceintensive idealized solutions that have been suggested in the area of cloud-based security. The evaluation of ThinAV shows that it functions well over a wide area network, resulting in a system which is highly practical for providing anti-malware security on smartphones. |
| Review: The goal in developing ThinAV was to assess the feasibility of providing real-time anti-malware scanning over a wide-area network where resource limitation is a factor. ThinAV consists of two main components: (1) an Android client, which submits applications for scanning and (2) a server which submits received files to third-party scanning services and notifies the client in the event of malware detection. The client software consists of modifications to the Android OS package manager as well as a client app for user notification of the scan result. A Killswitch module acts as a periodic post-installation scanner for installed apps. Even though the focus of the paper is on malware detection, there is an architecture that can be extracted from their solution. In this case, the ThinAV server has to be connected to the third party services that perform the computation-intensive tasks. The ThinAV server also stores results until mobile devices become available and also for performance reasons. |
BibTeX:
@inproceedings{Jarabek2012,
author = {Jarabek, Chris and Barrera, David and Aycock, John},
title = {ThinAV: truly lightweight mobile cloud-based anti-malware},
booktitle = {Proceedings of the 28th Annual Computer Security Applications Conference},
year = {2012},
pages = {209--218},
url = {http://dl.acm.org/citation.cfm?id=2420983}
}
|
| Kemp R, Palmer N, Kielmann T and Bal H (2012), "Cuckoo: a computation offloading framework for smartphones", In Mobile Computing, Applications, and Services. , pp. 59-79. Springer. |
| Abstract: Offloading computation from smartphones to remote cloud resources has recently been rediscovered as a technique to enhance the performance of smartphone applications, while reducing the energy usage. In this paper we present the first practical implementation of this idea for Android: the Cuckoo framework, which simplifies the development of smartphone applications that benefit from computation offloading and provides a dynamic runtime system, that can, at runtime, decide whether a part of an application will be executed locally or remotely. We evaluate the framework using two real life applications. |
| Review: Cuckoo is a framework for computation offloading for Android, including a runtime system, a resource manager application for smartphone users and a programming model for developers, which integrates into the Eclipse build system. The runtime system supports custom remote implementations optimized for remote resources and can be configured to maximize computation speed or minimize energy usage. The programming model is prepared for connectivity drops, supports local and remote execution and bundles all code in a single package. A developer can specify per service, whether the service is optimized for speed or for energy usage.The first Cuckoo builder is called the Cuckoo Service Rewriter and has to be invoked after the Android Pre Compiler, but before the Java Builder. The Cuckoo Service Rewriter will rewrite the generated Stub for each AIDL interface, so that at runtime Cuckoo can decide whether a method will be invoked locally or remote. The second Cuckoo builder is called the Cuckoo Remote Service Deriver and derives a dummy remote implementation from the available AIDL interface. This remote interface has to be implemented by the programmer -- the developer can decide to use the same implementation or have a lighter implementation for the phone and a heavier one for remote execution. At runtime, method invocations to services are intercepted at the service side of the Stub/Proxy pair, which is at the Stub. The Cuckoo framework will then decide whether or not this method should be invoked locally or remotely -- the implemented heuristic is that it executes remotely if a resource is reachable. The Cuckoo framework will query the Cuckoo Resource Manager for any available resources to see whether these resources are reachable and, if so, use them. Each smartphone has to register the remote resources that it wants to use, either by adding a resource file or by scanning the QR code on the screen of the resource (resource discovery). It uses the Ibis communication middleware for communication with remote resources. If the resource already has the service, it simply invokes it. If not, it sends it the jar file for installation. The developer can also decide how many registered resources to try before deciding to execute locally. |
BibTeX:
@inproceedings{Kemp2012,
author = {Kemp, Roelof and Palmer, Nicholas and Kielmann, Thilo and Bal, Henri},
title = {Cuckoo: a computation offloading framework for smartphones},
booktitle = {Mobile Computing, Applications, and Services},
publisher = {Springer},
year = {2012},
pages = {59--79},
url = {http://link.springer.com/chapter/10.1007%2F978-3-642-29336-8_4}
}
|
| Kosta S, Aucinas A, Hui P, Mortier R and Zhang X (2012), "Thinkair: Dynamic resource allocation and parallel execution in the cloud for mobile code offloading", In INFOCOM, 2012 Proceedings IEEE. , pp. 945-953. |
| Abstract: Smartphones have exploded in popularity in recent years, becoming ever more sophisticated and capable. As a result, developers worldwide are building increasingly complex applications that require ever increasing amounts of computational power and energy. In this paper we propose ThinkAir, a framework that makes it simple for developers to migrate their smartphone applications to the cloud. ThinkAir exploits the concept of smartphone virtualization in the cloud and provides method-level computation offloading. Advancing on previous work, it focuses on the elasticity and scalability of the cloud and enhances the power of mobile cloud computing by parallelizing method execution using multiple virtual machine (VM) images. We implement ThinkAir and evaluate it with a range of benchmarks starting from simple micro-benchmarks to more complex applications. First, we show that the execution time and energy consumption decrease two orders of magnitude for a N-queens puzzle application and one order of magnitude for a face detection and a virus scan application. We then show that a parallelizable application can invoke multiple VMs to execute in the cloud in a seamless and on-demand manner such as to achieve greater reduction on execution time and energy consumption. We finally use a memory-hungry image combiner tool to demonstrate that applications can dynamically request VMs with more computational power in order to meet their computational requirements. |
| Review: The paper proposes ThinkAir, which exploits the concept of smartphone virtualization in the cloud and provides method-level computation offloading. In addition, it does on-demand resource allocation and exploits parallelism by dynamically creating, resuming, and destroying VMs in the cloud as needed. It relies on resource consumption profilers as well as library and compiler support to make it easy for developers to exploit the framework with minimal modification of existing code. Developers annotate any method to be considered for offloading with @Remote. The compiler then generates the appropriate remotable wrappers and utility functions in case the code is to be executed remotely using Java reflection. On the server side, the framework obtains a copy of the code from the client and creates a clone of the app (VM). The Execution Controller decides whether to offload execution of a particular method, or to allow it to continue locally on the phone. Local execution is also the fallback policy if the remote execution fails. The decision depends on data collected about the current environment as well as that learned from past executions by using profiles for hardware, software, and network. Users can also select policies that prioritize between execution time and energy. If the created clone does not have enough resources or if the client asks for more computational power, a larger clone is created. A client can also indicate that a task is parallelizable, which means that clones are created to execute each part (although this part is not clear). |
BibTeX:
@inproceedings{Kosta2012,
author = {Kosta, Sokol and Aucinas, Andrius and Hui, Pan and Mortier, Richard and Zhang, Xinwen},
title = {Thinkair: Dynamic resource allocation and parallel execution in the cloud for mobile code offloading},
booktitle = {INFOCOM, 2012 Proceedings IEEE},
year = {2012},
pages = {945--953},
url = {http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=6195845}
}
|
| Kovachev D and Klamma R (2012), "Framework for computation offloading in mobile cloud computing", International Journal of Interactive Multimedia and Artificial Intelligence. Vol. 1(7), pp. 6-15. IMAI software. |
| Abstract: The inherently limited processing power and battery lifetime of mobile phones hinder the possible execution of computationally intensive applications like content-based video analysis or 3D modeling. Offloading of computationally intensive application parts from the mobile platform into a remote cloud infrastructure or nearby idle computers addresses this problem. This paper presents our Mobile Augmentation Cloud Services (MACS) middleware which enables adaptive extension of Android application execution from a mobile client into the cloud. Applications are developed by using the standard Android development pattern. The middleware does the heavy lifting of adaptive application partitioning, resource monitoring and computation offloading. These elastic mobile applications can run as usual mobile application, but they can also use remote computing resources transparently. Two prototype applications using the MACS middleware demonstrate the benefits of the approach. The evaluation shows that applications, which involve costly computations, can benefit from offloading with around 95% energy savings and significant performance gains compared to local execution only. |
| Review: The middleware does adaptive application partitioning, resource monitoring and computation offloading. Offloadable code is implemented as an Android service. The following metadata is obtained by monitoring application execution and the environment: memory consumption, compiled code size, dependency information on other services (transfer size = send size + receive size). Based on this data, at runtime MACS makes the decision to execute locally, or to transfer and execute remotely (or simply execute remotely if it is already there). MACS hooks into the Android compile system, makes modifications of generated Java files from AIDL in the pre-compile stage. The cloud-side MACS middleware is written in J2SE. If files are needed to be accessed on the remote cloud, MACS file transmission (MACS-FTM) transfers automatically the non-existing files from the local device and vice versa. It is one of the few papers that measures the overhead of the middleware. |
BibTeX:
@article{Kovachev2012,
author = {Kovachev, Dejan and Klamma, Ralf},
title = {Framework for computation offloading in mobile cloud computing},
journal = {International Journal of Interactive Multimedia and Artificial Intelligence},
publisher = {IMAI software},
year = {2012},
volume = {1},
number = {7},
pages = {6--15},
url = {http://www.ijimai.org/journal/node/361}
}
|
| Kristensen MD (2010), "Empowering Mobile Devices Through Cyber Foraging". Thesis at: Aarhus University. |
| Abstract: Cyber foraging is the opportunistic use of available computing resources by small, mobile devices. Put in another way, cyber foraging allows small, resource constrained devices, such as e.g., smart phones or small tablets, to offload some of their resource intensive work to stronger surrogate computers that are reachable on the local network. While cyber foraging may be used to forage for a number of different resources, the focus in this thesis is purely on foraging for CPU power. A number of cyber foraging systems have been proposed in the past decade, most of them offering a complete cyber foraging solution pursuing different goals—some offering high physical mobility within a constrained area by using pre-installed tasks and shared file systems, and others offering non-mobile usage in unprepared environments. In this thesis an approach is presented that offers both kinds of mobility; i.e., the user can be physically mobile while using cyber foraging, and when this mobility takes him into unknown territory, his applications will still be able to utilise cyber foraging. This thesis presents the definition and design of a cyber foraging system supporting such highly mobile cyber foraging. Furthermore, the design has been realised in an implementation of a complete cyber foraging framework, and experimental data collected while working with this is presented. An important aspect of cyber foraging is scheduling or task placement. Given a number of potential surrogate machines the mobile client must be able to select the best possible place to perform a given task. This scheduling is complicated by the heterogeneous nature of the surrogate machines, and a peer centric profile based approach collecting information about the performance of individual peers would therefore seem to be the obvious choice. While peer centric profiling works well when working within a small, constrained space, it is of no real use when the mobility of the user takes him away from that physical location. In this thesis a solution to this problem is presented, leveraging, amongst other things, task centric profiling that may be used to assess the running time of a task on any surrogate. Cyber foraging involves mobile, distributed, and in some cases parallel computing—all fields within computer science known to be hard for programmers to grasp. This thesis presents a development model where applying cyber foraging to a resource intensive function can be done by adding a single line of code. |
| Review: Two additional research questions are related to the design of a scheduler that supports this high degree of mobility while still utilizing multiple surrogates in an efficient manner and the simplification of the development process for cyber-foraging-enabled applications. Defines the cyber-foraging process as: surrogate discovery, application partitioning, cost assessment, trust establishment, task execution, and environment monitoring. It uses a broadcast mechanism called Presence for service discovery. It uses a scheduler for task placement that minimizes total execution time, so as to minimize the likelihood that the mobile device has left the range of the surrogate before the task has been performed. The scheduler uses information measured through profiling (estimated running time), information statically defined by the participating peers (bandwidth), information given at runtime (input size), and information estimated by the developer of the task (output size) -- this makes it a task-centric and peer-centric scheduler. It uses a mobile code strategy for task execution. The developer creates small, remote executable tasks, and how these tasks are interconnected is handled entirely by the scheduler. A Scavenger task is a self-contained piece of Python code adhering to a simple interface. The @scavenge tag (decorator) indicates that the task is offlodable, meaning that at runtime If no surrogates are available the local function is simply called on the input and if surrogates are available the scheduling algorithm determines whether it should execute locally or remotely. If the code is not available on the surrogate, the code is shipped to the surrogate. The evaluation considers the overhead of the scheduler. Scavenger consists of two independent software components: the daemon running on surrogates enabling them to receive and perform tasks (Stackless Python), and the library used by client applications. Scavenger gives each task a unique identifier,and upon invoking a task the client initially asks the surrogate whether that task is already installed. |
BibTeX:
@phdthesis{Kristensen2010,
author = {Kristensen, Mads Daro},
title = {Empowering Mobile Devices Through Cyber Foraging},
school = {Aarhus University},
year = {2010},
url = {http://users-cs.au.dk/madsk/files/phd-thesis/phdthesis_madsk.pdf}
}
|
| Kundu S, Mukherjee J, Majumdar AK, Majumdar B and Sekhar Ray S (2007), "Algorithms and heuristics for efficient medical information display in PDA", Computers in Biology and Medicine. Vol. 37(9), pp. 1272-1282. Elsevier. |
| Abstract: Accessing medical information in mobile devices such as PDAs and mobile phones is becoming widespread. Since these devices do not have the same rendering capabilities as of desktop computers, it is necessary for medical information to be fragmented for proper presentation on these types of devices. In this paper, we propose an architecture for displaying medical information in PDA. In the proposed system, a server extracts the information, categorizes the information in order of its relevance for diagnosis, and dynamically generates a hierarchical view of the relevant information based on certain medical domain knowledge. Displaying image and graphics data in PDA poses several challenges. The proposed system supports an image visualization tool, which interactively displays an image or a portion of an image in user’s PDA. This visualization tools increases the resource utilization of PDA by offloading a part of the computation to the server. A suitable caching scheme is incorporated for optimum utilization of communication channel bandwidth. |
| Review: A “context sensitive priority based text fragmentation algorithm” dynamically determines the relevance of a field of a test report to the doctor and presents the most relevant fields of a test report to the doctor first. The medical knowledge base consists of a medical dictionary and a priority vector matrix. |
BibTeX:
@article{Kundu2007,
author = {Kundu, Suman and Mukherjee, Jayanta and Majumdar, Arun K and Majumdar, Bandana and Sekhar Ray, Sirsendu},
title = {Algorithms and heuristics for efficient medical information display in PDA},
journal = {Computers in Biology and Medicine},
publisher = {Elsevier},
year = {2007},
volume = {37},
number = {9},
pages = {1272--1282},
url = {http://www.sciencedirect.com/science/article/pii/S0010482506002137}
}
|
| Kwon Y-W and Tilevich E (2013), "Reducing the Energy Consumption of Mobile Applications Behind the Scenes", In Proceedings of the 29th IEEE International Conference on Software Maintenance (ICSM 2013). |
| Abstract: As energy efficiency has become a key consideration in the engineering of mobile applications, an increasing number of perfective maintenance tasks are concerned with optimizing energy consumption. However, optimizing a mobile application to reduce its energy consumption is non-trivial due to the highly volatile nature of mobile execution environments. Mobile applications commonly run on a variety of mobile devices over mobile networks with divergent characteristics. Therefore, no single, static energy consumption optimization is likely to yield across-the-board benefits, and may even turn to be detrimental in some scenarios. In this paper, we present a novel approach to perfective maintenance of mobile applications to reduce their energy consumption. The maintenance programmer declaratively specifies the suspected energy consumption hotspots in a mobile application. Based on this input, our approach then automatically transforms the application to enable it to offload parts of its functionality to the cloud. The offloading is highly adaptive, being driven by a runtime system that dynamically determines both the state-to-offload and its transfer mechanism based on the execution environment in place. In addition, the runtime system continuously improves its effectiveness due to a feedback-loop mechanism. Thus, our approach flexibly reduces the energy consumption of mobile applications behind the scenes. Applying our approach to third-party Android applications has shown that it can effectively reduce the overall amount of energy consumed by these applications, with the actual numbers ranging between 25% and 50%. These results indicate that our approach represents a promising direction in developing pragmatic and systematic tools for the perfective maintenance of mobile applications. |
| Review: The maintenance programmer declaratively specifies the suspected energy consumption hotspots in a mobile application (@OffloadingCandidate). In AMCO, components can be defined at any level of program granularity, with the smallest being individual methods and the largest a collection of packages.Based on this input, it automatically transforms the application to enable it to offload parts of its functionality to the cloud. The offloading is highly adaptive, being driven by a runtime system that dynamically determines both the state-to-offload and its transfer mechanism based on the execution environment in place. In addition, the runtime system continuously improves its effectiveness due to a feedback-loop mechanism. The approach is realized as the following two major technical solutions: (1) a multi-target offloading program transformation that automatically rewrites a centralized program into a distributed program, whose local/remote distribution is determined dynamically at runtime; (2) a runtime system that determines the required local/remote distribution of the resulting distributed program based on the current execution environment. The offloading strategy is determined by the runtime system, whose responsibilities include: (1) managing a connection between the client and the server, (2) continuously estimating the energy consumed by the mobile device, (3) calculating which offloading strategy should be followed, (4) synchronizing the checkpointed state transferred between the server and client, and (5) ensuring resilience in the presence of failure due to network disconnections. The Cloud Offloading Energy Consumption Graph (CO-ECG), is a program analysis data structure that models how much energy will be consumed under different offloading scenarios. The nodes of the COECG represent program components, encapsulated units of functionality that can be offloaded to the cloud. Each node is labeled with an approximate amount of energy consumed by the CPU to execute the functionality of the component and its successor components in the graph. The edges represent the communication between the components, with the labels showing how much energy will be consumed by the mobile device to transmit the data between the connected components. Because it takes more energy to transfer data across limited networks, an optimal offloading strategy needs to trade the energy potentially saved by moving the execution to the cloud with the energy consumed by moving the data (i.e., program state) to support the offloading. The AMCO adaptive runtime system has three main components: (1) cloud offloading prediction and steering, (2) energy consumption estimation, and (3) cloud offloading processing. Evaluation considers system overhead. |
BibTeX:
@inproceedings{Kwon2013,
author = {Kwon, Young-Woo and Tilevich, Eli},
title = {Reducing the Energy Consumption of Mobile Applications Behind the Scenes},
booktitle = {Proceedings of the 29th IEEE International Conference on Software Maintenance (ICSM 2013)},
year = {2013},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6676888&tag=1}
}
|
| Lee B-D (2012), "A Framework for Seamless Execution of Mobile Applications in the Cloud", In Recent Advances in Computer Science and Information Engineering. , pp. 145-153. Springer. |
| Abstract: Limited resources of battery-operated mobile devices are a major obstacle for mobile applications. An obvious solution to this limitation is to leverage cloud computing, which offers virtually infinite resources on demand through the virtualization of physically distributed computing resources. A mobile device could offload a resource-intensive application to the cloud and support thin client interaction with the application over the Internet. As such, cloud computing enhances the computing capability of mobile devices, as well as saving energy of mobile devices. In this paper, therefore, we propose a framework supporting the seamless execution of mobile applications on the cloud. In particular, the novel aspect of our approach is that a mobile cloud application, itself, is treated as data, so it can be replicated within the cloud, thus being able to reduce both latency and energy consumption of the communication. This paper is a work-in-progress report of our research. |
| Review: Computation offload system for Java applications. Offload of Java classes to cloud servers composed of multiple Master Nodes and Worker Nodes. Always offload (paper talks about an algorithm, but it is never presented. However, because the classes are already on the mobile device they could run locally of no Master Node is found). Master nodes connected to worker nodes. Master Nodes are the front-ends that receive computation offloading requests from mobile devices and forward the requests to appropriate Worker Nodes, on which migrated classes actually run. Master nodes need to maintain a list of its worker nodes. |
BibTeX:
@incollection{Lee2012,
author = {Lee, Byoung-Dai},
title = {A Framework for Seamless Execution of Mobile Applications in the Cloud},
booktitle = {Recent Advances in Computer Science and Information Engineering},
publisher = {Springer},
year = {2012},
pages = {145--153},
url = {http://link.springer.com/chapter/10.1007%2F978-3-642-25766-7_20}
}
|
| Matthews J, Chang M, Feng Z, Srinivas R and Gerla M (2011), "PowerSense: power aware dengue diagnosis on mobile phones", In Proceedings of the First ACM Workshop on Mobile Systems, Applications, and Services for Healthcare. , pp. 6. |
| Abstract: Dengue is a flu-like viral disease found mostly in the tropical regions, and is spread by infected mosquitoes. Dengue hemorrhagic fever is a severe and often fatal manifestation if left untreated. In 2009, India reported 899 cases of dengue fever. PowerSense is an extensible module for the Dengue Detector Mobile Application (DDMA) that proactively facilitates management of processes for web service assisted mobile applications. PowerSense uses measured power consumption and application processing delay metrics from the smartphone device to dispatch image processing jobs locally or remotely to the DDMA .NET web service (DDMA-WS) at runtime. This work is the first step towards an application level middle-ware framework for power conscious computing. |
| Review: PowerSense uses measured power consumption and application processing delay metrics from the smartphone device to dispatch image processing jobs locally or remotely to the DDMA .NET web service (DDMA-WS) at runtime. There is an option for the user to decide what to optmize (energy or response time). The Image Processing Decision Engine uses a database that stores data collected pertaining to the resource footprint and processing time of function code blocks (in this case the dengue processor). The Energy Optimizer uses the information to invoke the proper object to minimize power consumption or save processing time. If the image is processed locally, a lower resolution image is used. |
BibTeX:
@inproceedings{Matthews2011,
author = {Matthews, Jerrid and Chang, Max and Feng, ZhiNan and Srinivas, Ravi and Gerla, Mario},
title = {PowerSense: power aware dengue diagnosis on mobile phones},
booktitle = {Proceedings of the First ACM Workshop on Mobile Systems, Applications, and Services for Healthcare},
year = {2011},
pages = {6},
url = {http://dl.acm.org/citation.cfm?id=2064951}
}
|
| Messer A, Greenberg I, Bernadat P, Milojicic D, Chen D, Giuli T and Gu X (2002), "Towards a distributed platform for resource-constrained devices", In Distributed Computing Systems, 2002. Proceedings. 22nd International Conference on. , pp. 43-51. |
| Abstract: Many visions of the future predict a world with pervasive computing, where computing services and resources permeate the environment. In these visions, people will want to execute a service on any available device without worrying about whether the service has been tailored for the device. We believe that it will be difficult to create services that can execute well on the wide variety of devices that are being developed because of problems with diversity and resource constraints. We believe that these problems can be greatly reduced by using an ad-hoc distributed platform to transparently offload portions of a service from a resource-constrained device to a nearby server. We have implemented a preliminary prototype and emulator to study this approach. Our experiments show the beneficial use of nearby resources to relieve both memory and processing constraints, when it is appropriate to do so. We believe that this approach will reduce the burden on developers by masking more device details. |
| Review: The term ‘distributed platform’ is used to refer to a system-level layer that provides a shared execution environment across two or more machines. When a user executes an application on a client. and a trigger event occurs, such as resources running low or a periodic re-evaluation, the client platform would analyze the information it has collected and decide whether offloading should occur. If it is beneficial to offload, the client platform will offload selected components (Java classes) to one or more surrogates running the distributed platform. If the application tries to access what is now remote data or to invoke what is now a remote method, the client side of the distributed platform transparently communicates requests to the surrogate, and vice versa. JVMs were modified so that objects can be transparently migrated between clients and surrogates. In a JVM, an object is uniquely identified by an object reference. To support remote execution, the JVM was modified to flag references to remote objects and then intercept accesses to remote objects. It then converts these remote accesses into transparent RPCs between two JVMs. It determines whether a beneficial offloading exists by finding an appropriate partitioning of the application’s execution history graph. Information is collected at run time about an application’s execution by augmenting the JVM’s code for method invocations, data field accesses, object creation, and object deletion. To simplify the platform, it assumes that both VMs have access to the application’s Java bytecodes. In a real-world implementation, the surrogate would have to acquire the necessary bytecodes from the client or another device, or have them installed. |
BibTeX:
@inproceedings{Messer2002,
author = {Messer, Alan and Greenberg, Ira and Bernadat, Philippe and Milojicic, Dejan and Chen, Deqing and Giuli, TJ and Gu, Xiaohui},
title = {Towards a distributed platform for resource-constrained devices},
booktitle = {Distributed Computing Systems, 2002. Proceedings. 22nd International Conference on},
year = {2002},
pages = {43--51},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1022241}
}
|
| Messinger D and Lewis GA (2013), "Application Virtualizaton as a Strategy for Cyber Foraging in Resource-Constrained Environments" |
| Abstract: Modern mobile devices create new opportunities to interact with their surrounding environment, but their computational power and battery capacity is limited. Code offloading to external servers located in clouds or data centers can help overcome these limitations. However, in hostile environments, it is not possible to guarantee reliable networks, and thus stable cloud accessibility is not available. Cyber foraging is a technique for offloading resource-intensive tasks from mobile devices to resource-rich surrogate machines in close wireless proximity. One type of such surrogate machines is a cloudlet—a generic server that runs one or more virtual machines (VMs) located in single-hop distance to the mobile device. Cloudlet-based cyber foraging can compensate for missing cloud access in the context of hostile environments. One strategy for cloudlet provisioning is VM synthesis. Unfortunately, it is time consuming and battery draining due to large file transfers. This technical note explores application virtualization as a more lightweight alternative to VM synthesis for cloudlet provisioning. A corresponding implementation is presented and evaluated. A quantitative analysis describes performance results in terms of time and energy consumption; a qualitative analysis compares implementation characteristics to VM synthesis. The evaluation shows that application virtualization is a valid strategy for cyber foraging in hostile environments. |
| Review: Computation offload of application packages that correspond to computation-intensive code to cloudlets. Requires VMs that match the application platform to exist on the cloudlet. Mobile applications are partitioned as client-server |
BibTeX:
@techreport{Messinger2013,
author = {Messinger, Dominik and Lewis, Grace A},
title = {Application Virtualizaton as a Strategy for Cyber Foraging in Resource-Constrained Environments},
year = {2013},
url = {http://resources.sei.cmu.edu/library/asset-view.cfm?assetID=53234}
}
|
| Mohapatra S and Venkatasubramanian N (2003), "Optimizing Power using a Reconfigurable Middleware" |
| Abstract: In distributed environments, generic middleware services(e.g. caching, location management etc.) are widely used to satisfy application needs in a cost-effective manner. Such middleware services consume system resources such as storage, computation and communication and can be sources of significant power overheads when executed on low-power devices. Our goal is to develop a distributed middleware framework that is inherently power-aware and reconfigures itself to adapt to diminishing power levels of low-power devices in distributed systems. This paper presents and evaluates a methodology for optimizing the power consumption of low-power devices using a reflective and customizable middleware framework. It introduces a power-aware middleware framework ( parm) and identifies some of the intrinsic requirements for the framework to be effective. Specifically, we determine when middleware components can be dynamically stopped or migrated away from a low-power device operating, in order to maximize the remaining service time for the device. In this paper, we 1) determine whether a reconfigurable component-based middleware framework can be utilized to achieve energy gains on low-power devices in distributed environments, while preserving the semantics of the middleware services, 2) design and evaluate a graph theoretic approach for dynamically determining middleware component reconfigurations, and ascertaining the optimal frequency at which the restructuring should take place, for maximal energy and service time gains at the device. We use extensive profiling to chart the energy usage patterns of middleware components and applications, and use the profiled data to drive our reconfiguration decisions. Our extensive simulation results demonstrate that our framework is able to save 5% to 45% of energy depending on the nature and class of applications and middleware components used. |
| Review: The idea is to determine when middleware components can be dynamically stopped or migrated away from a low-power device, in order to maximize the remaining service time for the device. The adaptation decisions are shifted to an external entity with cross-application knowledge and overall system information. In PARM, the power broker determines the set of middleware components that can be offloaded from a device onto a proxy, to minimize the energy consumption at the device. Policies dictate the instants (when), as well as the frequency (how often) at which the broker reconfigures the devices. Based on the current system state, information from the device/proxy and one or more PARM policies, the broker runs the PARM algorithm to determine a new configuration (if any) for reassignment of middleware components between the device and proxy. PARM applications are developed using a set of programming interfaces exported by the middleware. A component stub on the local machine enables remote invocation as the component migrates to the proxy. All services running on the device are replicated on the proxy so that migration costs do not involve transfer of the process image over the network. When invoked, a migrated service is started (if not already running) at the proxy and the state information is transmitted from the device to the proxy. The component stub is retained at the device and handles all messages received from the remotely executing component and routes them back to the application. Some middleware components cannot be migrated. In such a case the service is either stopped or degraded. Upon startup, the device registers itself with the nearest proxy and the PARM runtime on the device records the residual power of the device, the current set of active applications and components and updates this information with the directory service. The broker implements the PARM algorithm and policies. It retrieves the individual state information for each device from the directory service and determines the optimal reconfiguration of components for the device. It then announces the new configuration to the device and the proxy. |
BibTeX:
@techreport{Mohapatra2003,
author = {Mohapatra, Shivajit and Venkatasubramanian, Nalini},
title = {Optimizing Power using a Reconfigurable Middleware},
year = {2003},
url = {http://www.ics.uci.edu/~dsm/dyn/pub/DSM_TR03-04.pdf}
}
|
| O'Sullivan MJ and Grigoras D (2013), "The Cloud Personal Assistant for Providing Services to Mobile Clients", In Service Oriented System Engineering (SOSE), 2013 IEEE 7th International Symposium on. , pp. 478-485. |
| Abstract: This paper introduces the original concept of a cloud personal assistant, a cloud service that manages the access of mobile clients to cloud services. The cloud personal assistant works in the cloud on behalf of its owner: it discovers services, invokes them, stores the results and history, and delivers the results to the mobile user immediately or when the user requests them. Preliminary experimental results that demonstrate the concept are included. |
| Review: The cloud personal assistant works in the cloud on behalf of its owner: it discovers services, invokes them, stores the results and history, and delivers the results to the mobile user immediately or when the user requests them. There is no need for a permanent connection between the mobile and the cloud, and the results can be delivered when the mobile user needs them. CPA is given information by the user on some task he/she is interested in carrying out. This information can be the type of service they are looking for, and some parameters related to the task. |
BibTeX:
@inproceedings{OSullivan2013,
author = {O'Sullivan, Michael J and Grigoras, Dan},
title = {The Cloud Personal Assistant for Providing Services to Mobile Clients},
booktitle = {Service Oriented System Engineering (SOSE), 2013 IEEE 7th International Symposium on},
year = {2013},
pages = {478--485},
url = {http://www.ucc.ie/en/misl/publications/pub_research/mobilecloudcomputin/The_Cloud_Personal_Assistant.pdf}
}
|
| Ok M, Seo J-W and Park M-s (2007), "A distributed resource furnishing to offload resource-constrained devices in cyber foraging toward pervasive computing", In Network-Based Information Systems. , pp. 416-425. Springer. |
| Abstract: Mobile devices are pursuing the succession of desktop PCs these days. Cyber Foraging is the project that investigated overcoming scarce computing resources and reducing the power consumptions of mobile devices. In this paper, we propose a framework for remote execution of mobile devices in the way of delivering user data and invoking and manipulating the software of a surrogate with VNC-style interface. This resource furnishing system has the merits of remote application execution, and automatic file transfer. Remote execution is provided via VNC-style interface that is user-friendly. Performance evaluation shows the feasibility of the resource furnishing system, for both data transfers over wired and wireless network. |
| Review: The mobile device is a thin client that only receives the screen of the software running at a computing facility over wireless network by VNC. The difficulty in adapting the VNC concept is its frequent screen refresh. It relies on Versatile Surrogate Discovery (VERSUDS). A dispatching surrogate maintains the software list of known application servers, selects an application server by parsing the contents of request packet, and manages the loads of application servers. Users first login to their storage system so that the application servers can use the user's data. User data that resides on the mobile device is uploaded to the storage server. |
BibTeX:
@inproceedings{Ok2007,
author = {Ok, MinHwan and Seo, Ja-Won and Park, Myong-soon},
title = {A distributed resource furnishing to offload resource-constrained devices in cyber foraging toward pervasive computing},
booktitle = {Network-Based Information Systems},
publisher = {Springer},
year = {2007},
pages = {416--425},
url = {http://link.springer.com/chapter/10.1007%2F978-3-540-74573-0_43}
}
|
| Park S, Choi Y, Chen Q and Yeom H (2012), "SOME: Selective Offloading for a Mobile Computing Environment", In Cluster Computing (CLUSTER), 2012 IEEE International Conference on. , pp. 588-591. |
| Abstract: As the popularity of mobile devices increase, more and more smart phones are being utilized as main computing devices in recent years. Applications for mobile devices have been widely developing even more prevalent than those for PCs. Most mobile applications also integrate with web browsers, with JavaScript serving as an important framework for web-based mobile applications. However, these applications require great amounts of computational power and energy. In addition, relatively lowend mobile devices that pose some limitations in supporting complicated web resource are widely used in developing countries. In this paper, we propose SOME architecture, which is an offloading system for mobile applications, in an effort to reduce the computational cost of mobile devices. We design and implement a delegated system that splits the original JavaScriptbased application codes into two parts: a lightweight code for the client and a computationally heavy code to run on a server machine. In our evaluation, our system shows better performance in casual turn-based applications. Overall, the SOME architecture creates a new mobile computing environment that increases the total performance and overcomes resource limitation without platform dependence of mobile clients. |
| Review: The paper presents the SOME (Selective Offloading for a Mobile computing Environment) architecture, which is an offloading system for mobile applications, in an effort to reduce the computational cost of mobile devices. The idea is that the developer annotates the JavaScript in HTML5 code to indicate that it should run on the server side because it is computationally intensive. The client runs a Content Adapter (CA) which intercepts all calls to a web server. If the web page contains annotated code, the content adapter creates a lightweight version of the page and creates a process on an offloading server to execute the annotated JavaScript code. |
BibTeX:
@inproceedings{Park2012,
author = {Sehoon Park and Youngil Choi and Qichen Chen and Yeom, H.Y.},
title = {SOME: Selective Offloading for a Mobile Computing Environment},
booktitle = {Cluster Computing (CLUSTER), 2012 IEEE International Conference on},
year = {2012},
pages = {588-591},
url = {http://ieeexplore.ieee.org/xpl/abstractAuthors.jsp?arnumber=6337829}
}
|
| Phokas T, Efstathiades H, Pallis G and Dikaiakos M (2013), "Feel the World: A Mobile Framework for Participatory Sensing", In Mobile Web Information Systems. Vol. 8093, pp. 143-156. Springer Berlin Heidelberg. |
| Abstract: Nowadays, smartphones have almost replaced basic feature phones all over the world. Today’s smartphones come equipped with an increasing set of embedded sensors, computational and communication resources. All these gave developers the ability to design and implement a wide variety of applications in the domains of healthcare, social networking, safety, environmental monitoring and transportation. This paper presents a novel middleware platform, called Feel the World (FTW) which provides third party programmers, with little phone programming experience, the ability to develop applications that enable people to sense, visualize and share information about the world they live in |
| Review: The client-side component allows the collection of values from sensors embedded on the smartphone or from external sensors connected to the device via Bluetooth. Collected values can be aggregated and/or transformed locally on the client and uploaded to the server-side component in real-time or at a later moment. The server-side component gathers, processes and visualizes the retrieved values. FTW has a common interface for each unique data type. Specifically, each type of sensor data collected by the system is encapsulated as a conceptual “IData” object. Sensor data are saved by default as CSV values and stored locally in the phone. Each write is made on a different file in order to prevent complete data loss in case of file corruption and to allow periodic data upload to the back-end server. When server connection is established (for example a participant connects to Wi-Fi), the system attempts to upload files in order to be further processed. |
BibTeX:
@inproceedings{Phokas2013,
author = {Phokas, Theophilos and Efstathiades, Hariton and Pallis, George and Dikaiakos, MariosD.},
editor = {Daniel, Florian and Papadopoulos, GeorgeA. and Thiran, Philippe},
title = {Feel the World: A Mobile Framework for Participatory Sensing},
booktitle = {Mobile Web Information Systems},
publisher = {Springer Berlin Heidelberg},
year = {2013},
volume = {8093},
pages = {143-156},
url = {http://dx.doi.org/10.1007/978-3-642-40276-0_12}
}
|
| Pu L, Xu J, Jin X and Zhang J (2013), "SmartVirtCloud: virtual cloud assisted application offloading execution at mobile devices' discretion", In 2013 IEEE Wireless Communications and Networking Conference (WCNC): SERVICES and APPLICATIONS. |
| Abstract: Many mobile applications such as games and social applications are emerging for mobile devices. These powerful applications consume more and more running time and energy. So they are badly confined by mobile device with limited resource. Since cloud infrastructure has great potential to benefit task execution, this paper presents SmartVirtCloud (SmartVC). A system can offload methods in applications to achieve better performance in indoor environment. SmartVC decides at runtime whether and when the methods in application should be executed remotely. And two types of cloud service models, namely load-balancing and application-isolation, are constructed for concurrent requests. The empirical results show that, by using SmartVC, the CPU-intensive calculation application consumes two orders of magnitude less energy on average; the processing speed of latency-sensitive image translation application gets doubled; the performance of network-intensive picture download application is improved with the increase of picture amount. In addition, the proposed two cloud models support concurrent requests from smartphones very well. |
| Review: SmartVC decides at runtime whether and when the methods in an application should be executed remotely. It provides elastic application execution to augment smartphone capability and improve the quality of service by using a method-level offloading mechanism. Relies on manual partitioning of applications. An encapsulation tool is designed for developers to encapsulate their original application as a SmartVC application. An Execution Controller decides at runtime whether and when the methods in the application should be executed remotely. The task offloading decision is made based on the tradeoff between energy and latency. First, the system determines whether the method ‘can’ be run on remote server. The Execution Controller will invoke the Offloading Decision Maker to determine whether it needs to run remotely by collecting current power status and historical records. If a method needs to be offloaded, the Execution Controller will retrieve the proxy address from that local file and pass it to Cloud Handler to exchange information. Then, the mobile device sends a remote execution request. The proxy receives and checks whether it supports this application. If this application has never been run in the cloud, the cloud will retrieve the whole application. Otherwise, the mobile device will send a Message that contains information concerning this method. When the proxy gets the Message, it will invoke ‘Server Profiler’ to choose an appropriate server and transfer the Message to it. That server will run the method by Java reflection mechanism and send back results. At last, the system records the execution time and power consumption as historical data to make Offloading Decision Maker smarter. |
BibTeX:
@inproceedings{Pu2013,
author = {Pu, Lingjun and Xu, Jingdong and Jin, Xing and Zhang, Jianzhong},
title = {SmartVirtCloud: virtual cloud assisted application offloading execution at mobile devices' discretion},
booktitle = {2013 IEEE Wireless Communications and Networking Conference (WCNC): SERVICES and APPLICATIONS},
year = {2013},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6555286}
}
|
| Ra M-R, Sheth A, Mummert L, Pillai P, Wetherall D and Govindan R (2011), "Odessa: enabling interactive perception applications on mobile devices", In Proceedings of the 9th international conference on Mobile systems, applications, and services. New York, NY, USA , pp. 43-56. ACM. |
| Abstract: Resource constrained mobile devices need to leverage computation on nearby servers to run responsive applications that recognize objects, people, or gestures from real-time video. The two key questions that impact performance are what computation to offload, and how to structure the parallelism across the mobile device and server. To answer these questions, we develop and evaluate three interactive perceptual applications. We find that offloading and parallelism choices should be dynamic, even for a given application, as performance depends on scene complexity as well as environmental factors such as the network and device capabilities. To this end we develop Odessa, a novel, lightweight, runtime that automatically and adaptively makes offloading and parallelism decisions for mobile interactive perception applications. Our evaluation shows that the incremental greedy strategy of Odessa converges to an operating point that is close to an ideal offline partitioning. It provides more than a 3x improvement in application performance over partitioning suggested by domain experts. Odessa works well across a variety of execution environments, and is agile to changes in the network, device and application inputs. |
| Review: Odessa relies on two techniques: offloading one or more of the compute-intensive application components to an Internet-connected server, and using parallelism on multi-core systems to improve responsiveness and accuracy of the applications. The goal of Odessa is to decide when and to what degree to apply these techniques to improve both the makespan (time taken to execute all stages of a data flow graph for a single frame -- responsiveness) and throughput (rate at which frames are processed -- accuracy) of interactive perception applications. Odessa is built on Sprout, a distributed stream processing system. Applications are structured as data flow graphs. Odessa uses a greedy algorithm that periodically acquires information from a lightweight application profiler to estimate the bottleneck in the current configuration. Then, its decision engine uses simple predictors based on nominal processor frequencies, and a recent history of network measurements, to estimate whether offloading or increasing the level of parallelism of the bottleneck stage would improve performance. |
BibTeX:
@inproceedings{Ra2011,
author = {Ra, Moo-Ryong and Sheth, Anmol and Mummert, Lily and Pillai, Padmanabhan and Wetherall, David and Govindan, Ramesh},
title = {Odessa: enabling interactive perception applications on mobile devices},
booktitle = {Proceedings of the 9th international conference on Mobile systems, applications, and services},
publisher = {ACM},
year = {2011},
pages = {43--56},
url = {http://doi.acm.org/10.1145/1999995.2000000}
}
|
| Rachuri KK (2012), "Smartphones based Social Sensing: Adaptive Sampling, Sensing and Computation Offloading". Thesis at: University of Cambridge. |
| Abstract: In recent years the number of smartphone users has been increasing at an unprecedented rate. Smartphones are carried by billions of people every day, and are equipped with many sensors such as accelerometer, microphone, and GPS. These sensors can be used to capture various social and behavioural aspects of the users, which we refer to as social sensing. An important application area of social sensing is the support to experimental social psychology. However, smartphones have limited battery and processing power, which pose challenges to the capture of data from the sensors and to data processing. In this dissertation we present techniques to efficiently capture and process data from the smartphone sensors and show that smartphones can be effective tools to perform social sensing and to conduct social psychological studies. The sensors embedded in the phone have to be sampled often in order to capture the user's behaviour. This, however, may lead to faster depletion of the battery. If the sensors are sampled at a slower rate, then it may not be possible to accurately capture the user's behaviour. To meet the challenges posed by phone sensing, we design three adaptive schemes. First, we design an adaptive sampling framework that samples the data from the sensors considering the user's context to conserve energy, while providing the required accuracy to the applications. Second, to further increase the energy effciency of capturing data, we design a framework that exploits the sensors in buildings and dynamically distributes the sensing tasks between the local phone and the infrastructure sensors. When the data from the sensors are captured, they need to be classified to derive high-level inferences. Third, to effciently process the data we design a computation offoading scheme that decides whether to compute the classification tasks locally on the phone or remotely in the cloud by considering various dimensions such as energy, latency, and data traffic. We then demonstrate the ability of smartphones to perform social sensing and to conduct social psychological studies by designing and deploying three applications that use the services of the proposed schemes. First, we present EmotionSense, a passive monitoring application that captures the user's emotions and speech patterns automatically by using the sensors in off-the-shelf mobile phones. Second, we present WorkSense, a workplace behavioural monitoring application that can detect the collaboration and interaction patterns of the workers. Third, we present SociableSense, a persuasive and behavioural monitoring application that aims to foster interaction and relations between the users at the workplace. We also report on the deployment of these applications in real environments. |
| Review: It uses three adaptive strategies: (1) an adaptive sampling framework that samples the data from the sensors considering the user's context to conserve energy, while providing the required accuracy to the applications, (2) the framework exploits the sensors in buildings and dynamically distributes the sensing tasks between the local phone and the infrastructure sensors, (3) a computation offloading scheme that decides whether to compute sensed data classifcation tasks locally on the phone or remotely in the cloud by considering various dimensions such as energy, latency, and data traffic. This latter adaptive scheme is the one related to cyber-foraging. Once data from the sensors is sampled, it needs to be processed to infer higher-level activities. Classification tasks are critical to the functioning of social sensing applications on mobile phones but can be computationally-intensive. The system uses a computation distribution scheme based on multi-criteria decision theory that decides where to perform the computations by considering various dimensions such as energy, latency, and data to be sent over the network (it assumes that these values are known for each classification task). It also assumes that classifiers are preloaded both locally on the phone and remotely in the server/cloud and that it is possible for there to be a local version and a remote version of the same task/subtask. It also assumes that the users of the social sensing systems provide the weights for energy, latency, and total data sent over the network based on the requirements of the participants of social sensing studies. Tasks and weights are configured in an XML file that is used by the offloading API at runtime. |
BibTeX:
@phdthesis{Rachuri2012,
author = {Rachuri, Kiran K},
title = {Smartphones based Social Sensing: Adaptive Sampling, Sensing and Computation Offloading},
school = {University of Cambridge},
year = {2012},
url = {http://www.cl.cam.ac.uk/~cm542/phds/kiranrachuri.pdf}
}
|
| Rahimi MR, Venkatasubramanian N, Mehrotra S and Vasilakos AV (2012), "MAPCloud: mobile applications on an elastic and scalable 2-tier cloud architecture", In Proceedings of the 2012 IEEE/ACM Fifth International Conference on Utility and Cloud Computing. , pp. 83-90. |
| Abstract: The rise in popularity of mobile applications creates a growing demand to deliver richer functionality to users executing on mobile devices with limited resources. The availability of cloud computing platforms has made available unlimited and scalable resource pools of computation and storage that can be used to enhance service quality for mobile applications. This paper exploits the observation that using local resources in close proximity to the user, i.e. local clouds, can increase the quality and performance of mobile applications. In contrast, public cloud offerings (e.g. Amazon Web Services) offer scalability at the cost of higher delays, higher power consumption and higher price on the mobile device. In this paper we introduce MAPCloud, a hybrid, tiered cloud architecture consisting of local and public clouds and show how it can be leveraged to increase both performance and scalability of mobile applications. We model the mobile application as a workflow of tasks and aim to optimally decompose the set of tasks to execute on the mobile client and 2-tier cloud architecture considering multiple QoS factors such as power, price, and delay. Such an optimization is shown to be NP-Hard; we propose an efficient simulated annealing based heuristic, called CRAM that is able to achieve about 84% of optimal solutions when the number of users is high. We evaluate CRAM and the 2-tier approach via implementation (on Android G2 devices and Amazon EC2, S3 and CloudFront) and extensive simulation using two rich mobile applications (Video-Content Augmented Reality and Image processing). Our results indicate that MAPCloud provides improved scalability as compared to local clouds, improved efciency (power/delay) (about 32% lower delays and power) and about 40% decrease in price in comparison to only using public cloud. |
| Review: A mobile application is modeled as a workflow that is optimally decomposed as a set of tasks to execute on the mobile client and 2-tier cloud architecture considering multiple QoS factors such as power consumption, service price, and delay (utility metric). It proposes a heuristic called CRAM (Cloud Resource Allocation for Mobile Applications) to achieve a near-optimal solution to the tiered-cloud resource allocation problem. MAPCloud performs task/resource mapping at a middleware broker node. The broker maintains a registry of resources and services in both tiers of the cloud. For each incoming application request (modeled as a workflow of tasks) from a mobile device, the broker consults the registry of available resources/services and executes admission control that determines whether the task is schedulable or not. Once admitted, the broker runs a scheduling policy to schedule the various workflow tasks onto specific nodes in the 2-tier cloud architecture. This middleware could be located mainly in the second tier to warranty the efficiency of the system (low delay). Assumes values are known for each workflow task. The broker and scheduler modules consult the directory service (which keeps accurate state of the resources based on information gathered by the mobile client and cloud monitoring modules). The allocation of services to nodes is returned back as a service plan (encoded in XML) - the associated XML file also contains the URL of each service in the application workflow. A lot of implementation details are missing: service description, service invocation, service registry. |
BibTeX:
@inproceedings{Rahimi2012,
author = {Rahimi, M Reza and Venkatasubramanian, Nalini and Mehrotra, Sharad and Vasilakos, Athanasios V},
title = {MAPCloud: mobile applications on an elastic and scalable 2-tier cloud architecture},
booktitle = {Proceedings of the 2012 IEEE/ACM Fifth International Conference on Utility and Cloud Computing},
year = {2012},
pages = {83--90},
url = {http://dl.acm.org/citation.cfm?id=2415709}
}
|
| Satyanarayanan M, Bahl P, Caceres R and Davies N (2009), "The Case for VM-Based Cloudlets in Mobile Computing", Pervasive Computing, IEEE. Vol. 8(4), pp. 14-23. |
| Abstract: Mobile computing is at a fork in the road. After two decades of sustained effort by many researchers, we’ve finally developed the core concepts, techniques, and mechanisms to provide a solid foundation for this still fast-growing area. The vision of “information at my fingertips at any time and place” was just a dream in the mid 1990s; today, ubiquitous email and Web access is a reality that millions of users worldwide experience through BlackBerries, iPhones, Windows Mobile, and other mobile devices. On one path of the fork, mobile Web-based services and location-aware advertising opportunities have begun to appear, and companies are making large investments in anticipation of major profits. Yet, this path also leads mobile computing away from its true potential. Awaiting discovery on the other path is an entirely new world in which mobile computing seamlessly augments users’ cognitive abilities via compute-intensive capabilities such as speech recognition, natural language processing, computer vision and graphics, machine learning, augmented reality, planning, and decision making. By thus empowering mobile users, we could transform many areas of human activity (see the sidebar for an example). This article discusses the technical obstacles to this transformation and proposes a new architecture for overcoming them. In this architecture, a mobile user exploits virtual machine (VM) technology to rapidly instantiate customized service software on a nearby cloudlet and then uses that service over a wireless LAN; the mobile device typically functions as a thin client with respect to the service. A cloudlet is a trusted, resource-rich computer or cluster of computers that’s well-connected to the Internet and available for use by nearby mobile devices. Our strategy of leveraging transiently customized proximate infrastructure as a mobile device moves with its user through the physical world is called cloudlet-based, resource-rich, mobile computing. Crisp interactive response, which is essential for seamless augmentation of human cognition, is easily achieved in this architecture because of the cloudlet’s physical proximity and one-hop network latency. Using a cloudlet also simplifies the challenge of meeting the peak bandwidth demand of multiple users interactively generating and receiving media such as high-definition video and high-resolution images. Rapid customization of infrastructure for diverse applications emerges as a critical requirement, and our results from a proof-of-concept prototype suggest that VM technology can indeed help meet this requirement. |
| Review: This is the paper that coined the term cloudlets. The idea is that cloudlets are in single-hop proximity of mobile devices. Cloudlets can be provisioned via VM migration or VM synthesis, which is the focus of this paper. Mobile devices carry with them a VM overlay that corresponds to the difference between a base VM and the same VM with the application installed (the idea is to separate the application from the infrastructure). The VM overlay is transferred to the cloudlet at runtime and applied to the base VM. |
BibTeX:
@article{Satyanarayanan2009,
author = {Mahadev Satyanarayanan and Bahl, P. and Caceres, R. and Davies, N.},
title = {The Case for VM-Based Cloudlets in Mobile Computing},
journal = {Pervasive Computing, IEEE},
year = {2009},
volume = {8},
number = {4},
pages = {14-23},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=5280678}
}
|
| Shi C, Pandurangan P, Ni K, Yang J, Ammar M, Naik M and Zegura E (2013), "IC-Cloud: Computation Offloading to an Intermittently-Connected Cloud" Georgia Institute of Technology. |
| Abstract: Offloading computation-intensive components of mobile applications to the cloud is of great potential to speedup the execution and reduce the energy consumption for mobile devices. The gain from computation offloading is typically counterbalanced by communication costs and delays. It is, therefore, important to undertake offloading decisions based on future prediction of Internet access timeliness and quality. Previous approaches have considered this question under the assumption that network connectivity is relatively stable. In this paper, we present IC-Cloud, a computation offloading system for mobile environments where Internet access to remote computation resources is of highly variable quality and often intermittent. IC-Cloud uses three key ideas: lightweight connectivity prediction, lightweight execution prediction and prediction use in a risk controlled manner tomake offloading decisions. Our connectivity-prediction method only uses the signal strength and user historical information to obtain a coarse-grained estimation of the network access quality. Our execution-prediction mechanism uses machine learning on dynamic program features to automatically, efficiently, and accurately predict the execution time of offloadable tasks, both on the phone and in the cloud. Acknowledging the uncertainties in these predictions, we propose a risk-control mechanism to reduce the impact of inaccurate predictions. We implemented IC-Cloud on Android and tested the system with different applications in various types of mobile environment. Results we obtained from the prototype show speedup and energy consumption reduction benefits in many computational contexts and intermittent connectivity environments. |
| Review: The connectivity-prediction method uses the signal strength and user historical information to obtain a coarse-grained estimation of the network access quality. The execution-prediction mechanism uses machine learning on dynamic program features to automatically, efficiently, and accurately predict the execution time of offloadable tasks, both on the phone and in the cloud. A risk-control mechanism is used to reduce the impact of inaccurate predictions. On the mobile device, IC-Cloud consists of six major components: 1) a connectivity predictor that monitors the network states and maintains a database of the historical information of the network states; 2) a connectivity manager that handles data transfer between the mobile device and the cloud; 3) an execution predictor that collects program features from the applications and predicts the execution time of tasks considered for offloading; 4) a set of application trackers each of which monitors the offloaded tasks for an application and adjusts its strategy based on the connectivity over time; 5) an offloading controller that uses the information from the connectivity predictor and the execution predictor to decide if a task should be offloaded to the cloud; 6) local workers that may execute some offloaded tasks in the case that they cannot return the results in time. On the server, IC-Cloud consists of four major components: 1) an execution predictor that tracks the program features of the applications and sends them back to the mobile device; 2) a set of application trackers that monitor the execution of offloaded tasks; 3) an execution controller that controls the execution of the offloaded tasks; 4) a connectivity manager that communicates with the mobile devices. IC-Cloud provides a library to application developers and allows them to annotate all the tasks to be considered for offloading. IC-Cloud instruments these applications to collect features for all these offloadable tasks. Then IC-Cloud uses machine learning on these features to accurately predict their execution time online. It does not explain how or when the computation code itself is uploaded to the servers. |
BibTeX:
@techreport{Shi2013,
author = {Shi, Cong and Pandurangan, Pranesh and Ni, Kangqi and Yang, Juyuan and Ammar, Mostafa and Naik, Mayur and Zegura, Ellen},
title = {IC-Cloud: Computation Offloading to an Intermittently-Connected Cloud},
publisher = {Georgia Institute of Technology},
year = {2013},
url = {https://smartech.gatech.edu/handle/1853/45985}
}
|
| Silva JN, Veiga L and Ferreira P (2008), "SPADE: scheduler for parallel and distributed execution from mobile devices", In Proceedings of the 6th international workshop on Middleware for pervasive and ad-hoc computing. , pp. 25-30. |
| Abstract: Mobile computing devices, such as mobile phones or even ultra-mobile PC's, are becoming more and more powerful. Because of this fact, users are starting to use these devices to execute tasks that until a few years ago would only be executed on a desktop PC, e.g. picture manipulation, or text editing. Furthermore, these devices, are by now almost continuously connected, either by Wi-Fi or 3G UMTS links. Nevertheless power consumption is still a major factor on these mobile devices usage, restricting autonomy. While users should be able to employ mobile computing devices to perform these tasks with convenience, it would improve performance and reduce battery drain if the bulk processing of such tasks could be offoaded to remote hosts accessible by the same user. To accomplish this, we present SPADE, a middleware to deploy remote and parallel execution of some commodity applications to solve complex problems, from mobile devices, without any special programming effort, and by simply defining several data input sets. In SPADE, jobs are composed of simpler tasks that will be executed on remote computers. The user states what files should be processed by each task, what application will be launched and defines the application arguments. By using SPADE any user can, for instance, accelerate a batch image manipulation by using otherwise idle remote computers, while releasing the mobile device for other tasks. In order to make SPADE usable by a wide set of computer users we implemented two ideas: i) the execution code is a commodity piece of software already installed on the remote computers (e.g. image processing applications), and ii) the definition of the data sets to be remotely processed is done in a simple and intuitive way. The results are promising as the speedups accomplished are near optimal, while reducing power consumption, and SPADE allows the easy and efficient deployment of jobs on remote hosts. |
| Review: In SPADE, jobs are composed of simpler tasks that will be executed on remote computers. The user states what files should be processed by each task, what application will be launched and defines the application arguments. In order to make SPADE usable by a wide set of computer users it implements two ideas: i) the execution code is a commodity piece of software already installed on the remote computers (e.g. image processing applications), and ii) the definition of the data sets to be remotely processed is done in a simple and intuitive way. It assumes that the mobile user also owns the remote servers and that the servers have their applications registered with the SPADE system (path and name). The mobile devices specify the list of hosts. SPADE is responsible for uploading the necessary input files to the remote host, executing the selected application and downloading the result file. SPADE is most useful to those who have lengthy tasks to perform: lengthy single task jobs, repetitive data analysis, or long processing of large batches of files -- key is that the computation is performed on input file(s). In order to define the jobs that will be executed, the user must first select the necessary application, the location of the input files and what files should be transmitted to the remote hosts. |
BibTeX:
@inproceedings{Silva2008,
author = {Silva, Joao Nuno and Veiga, Luis and Ferreira, Paulo},
title = {SPADE: scheduler for parallel and distributed execution from mobile devices},
booktitle = {Proceedings of the 6th international workshop on Middleware for pervasive and ad-hoc computing},
year = {2008},
pages = {25--30},
url = {http://dl.acm.org/citation.cfm?id=1462794}
}
|
| Su Y-Y and Flinn J (2005), "Slingshot: deploying stateful services in wireless hotspots", In Proceedings of the 3rd international conference on Mobile systems, applications, and services. New York, NY, USA , pp. 79-92. ACM. |
| Abstract: Given a sufficiently good network connection, even a handheld computer can run extremely resource-intensive applications by executing the demanding portions on a remote server. At first glance, the increasingly ubiquitous deployment of wireless hotspots seems to offer the connectivity needed for remote execution. However, we show that the backhaul connection from the hotspot to the Internet can be a prohibitive bottleneck for interactive applications. To eliminate this bottleneck, we propose a new architecture, called Slingshot, that replicates remote application state on surrogate computers co-located with wireless access points. The first-class replica of each application executes on a remote server owned by the handheld user; this offers a safe haven for application state in the event of surrogate failure. Slingshot deploys second-class replicas on nearby surrogates to improve application response time. A proxy on the handheld broadcasts each application request to all replicas and returns the first response it receives. We have modified a speech recognizer and a remote desktop to use Slingshot. Our results show that these applications execute 2.6 times faster with Slingshot than with remote execution. |
| Review: The first-class replica of each application (home server) executes on a remote server owned by the handheld user; this offers a safe haven for application state in the event of surrogate failure. Slingshot deploys second-class replicas on nearby surrogates to improve application response time. A proxy on the handheld broadcasts each application request to all replicas and returns the first response it receives. It uses virtual machine encapsulation to eliminate the need to install application-specific code on surrogates. While a new replica is being instantiated, existing replicas continue to serve the user. Each Slingshot application is partitioned into a local component that runs on the mobile client and a remote service that is replicated on the home server and surrogates. Ideally, we partition the application so that resource-intensive functionality executes as part of the remote service; the local component typically contains only the user interface. Slingshot creates the first-class replica when the user starts the application -- this replica is required for execution of stateful services. As the application runs, Slingshot dynamically instantiates one or more second-class replicas on nearby surrogates. Each replica executes within its own virtual machine. Replica state consists of the persistent state, or disk image of the virtual machine, and the volatile state, which includes its memory image and registers. To handle persistent state, we use the Fauxide and Vulpes modules developed by Intel Research's Internet Suspend/Resume (ISR) project. These modules intercept VMware disk I/O requests. On the home server, we redirect these requests to a service database that stores the disk blocks of every remote service. On a surrogate, VMware reads are first directed to a service cache -- if the block is not found in the cache, it is fetched from the service database on the home server. The client proxy is responsible for locating surrogates, instantiating second-class replicas, and managing communication with all replicas. On startup, the local component sends the client proxy its serviceid. The proxy immediately instantiates a first-class replica on the home server. It subsequently instantiates second-class replicas on nearby surrogates when requested by the user. The client proxy records the replies received from each replica in the event log. When the first reply is received, it is returned to the local component. Later replies are compared with the first reply to ensure that the replicas are behaving deterministically. If the reply from a second-class replica differs significantly (as determined by an application-specific function) from the reply from the first-class replica, the second-class replica is terminated. |
BibTeX:
@inproceedings{Su2005,
author = {Su, Ya-Yunn and Flinn, Jason},
title = {Slingshot: deploying stateful services in wireless hotspots},
booktitle = {Proceedings of the 3rd international conference on Mobile systems, applications, and services},
publisher = {ACM},
year = {2005},
pages = {79--92},
url = {http://doi.acm.org/10.1145/1067170.1067180}
}
|
| Xiao Y, Simoens P, Pillai P, Ha K and Satyanarayanan M (2013), "Lowering the barriers to large-scale mobile crowdsensing", In Mobile Computing Systems and Applications. |
| Abstract: Mobile crowdsensing is becoming a vital technique for environment monitoring, infrastructure management, and social computing. However, deploying mobile crowdsensing applications in large-scale environments is not a trivial task. It creates a tremendous burden on application developers as well as mobile users. In this paper we try to reveal the barriers hampering the scale-up of mobile crowdsensing applications, and to offer our initial thoughts on the potential solutions to lowering the barriers. |
| Review: The paper proposes a three-tier architecture. The first layer is composed of mobile devices, whose roles are essentially reduced to that of multi-input sensors forwarding captured data to proxy VMs in the second layer. The second layer comprises of distributed cloud infrastructure deployed close to the mobile devices (cloudlets), typically in the access or aggregation network of Wi-Fi or cellular network providers. Each proxy VM is associated with a single mobile device, and is kept physically close to the mobile device through VM migration to other cloudlets or public clouds. The proxy VM handles all the requests for sensor data on behalf of the mobile device. On the mobile device, a single application is responsible for collecting sensor data and communicating it to the proxy VM. From here, data is forwarded to one or more application VMs also running on the cloudlet infrastructure. Application VMs perform data processing steps specific to each crowdsensing application. Each application VM hosts a single crowdsensing application, which is not customized to any particular mobile platform. The application VMs for each sensing service are deployed by a coordinating entity on the highest layer in the architecture, typically by the application server running on the centralized cloud infrastructure. Process: (1) The task generator (smartphone) constructs and sends a task description to the application server, typically located in the public cloud, (2) The application server parses the task description, and consults a global registry for a list of cloudlets that are located in the target area, (3) The application server contacts the cloudlet daemon on each target-area cloudlet and deploys an application VM, (4) The application VM on each target cloudlet uses a cloudlet-local registry to discover proxy VMs connected to devices that can provide the desired sensor data, (5) The application VM requests participation from the mobile users through the proxy VMs. |
BibTeX:
@inproceedings{Xiao2013,
author = {Xiao, Yu and Simoens, Pieter and Pillai, Padmanabhan and Ha, Kiryong and Satyanarayanan, Mahadev},
title = {Lowering the barriers to large-scale mobile crowdsensing},
booktitle = {Mobile Computing Systems and Applications},
year = {2013},
url = {http://dl.acm.org/citation.cfm?id=2444789}
}
|
| Yang F, Qian Z, Chen X, Beschastnikh I, Zhuang L, Zhou L and Shen J (2012), "Sonora: A Platform for Continuous Mobile-Cloud Computing" |
| Abstract: This paper presents Sonora, a platform for mobile cloud computing. Sonora is designed to support the development and execution of continuous mobile-cloud services. To this end, Sonora provides developers with stream-based programming interfaces that coherently integrate a broad range of existing techniques from mobile, database, and distributed systems. These range from support for disconnected operation to relational and event-driven models. Sonora's execution engine is a fault-tolerant distributed runtime that supports userfacing continuous sensing and processing services in the cloud. Key features of this engine are its dynamic load balancing mechanisms, and a novel failure recovery protocol that performs checkpoint-based partial rollback recovery with selective re-execution. To illustrate the relevance and power of the stream abstraction in describing complex mobile-cloud services we evaluate Sonora's design in the context of two services. We also validate Sonora's design, demonstrating that Sonora is efficient, scalable, and provides responsive fault tolerance. |
| Review: The paper presents Sonora, a distributed programming and execution platform for continuous data-oriented (data streams) mobile cloud computing. Streams are the main abstraction for transmitting data collected from mobile devices -- a continuously expanding data sequence with elements ordered according to their timestamps. Sonora organizes the continuously generated data in the form of a traditional data stream and provides SQL-like interfaces to operate over the stream (e.g, relational, windowing). In addition, computing is driven with recurring stream updates and data operations that subscribe to stream updates. Sonora uses sync streams for communication between the mobile and the cloud to relieve programmers from writing networking code. A sync stream is maintained in the cloud and on the mobile device, and is a reliable unidirectional channel between a source stream and the sink stream. A synchronization policy directs how and when items are propagated from the source to the sink. For two-way communication programmers can use two sync streams. Sync streams support disconnected operations, batching, filtering and compression. The data stream processing code is run through a tool that divides it into what is executed on the mobile device and what is executed in the cloud. A lot of what happens in the cloud is beyond the scope of cyber-foraging for data staging. The cloud runtime is a distributed stream query execution engine that is scalable, adaptive, and fault tolerant. However, the notion of sync stream is an architecture construct that supports data staging. |
BibTeX:
@techreport{Yang2012,
author = {Yang, Fan and Qian, Zhengping and Chen, Xiuwei and Beschastnikh, Ivan and Zhuang, Li and Zhou, Lidong and Shen, Jacky},
title = {Sonora: A Platform for Continuous Mobile-Cloud Computing},
year = {2012},
url = {http://research.microsoft.com/apps/pubs/?id=161446}
}
|
| Yang K, Ou S and Chen H-H (2008), "On effective offloading services for resource-constrained mobile devices running heavier mobile Internet applications", Communications Magazine, IEEE. Vol. 46(1), pp. 56-63. IEEE. |
| Abstract: Rapid advances in wireless mobile network technologies and mobile handsets (MHs) facilitate ubiquitous infrastructure that can support a range of mobile services and applications in addition to conventional mobile Internet access. One recent trend is to effectively run desktop PC-oriented heavier applications on MHs. However, due to their miniature, portable size, MHs are resource-constrained and therefore, running these applications directly on an MH is not satisfactory given a user’s expectations. To cope with this problem, this article proposes a novel offloading service that can seamlessly offload some of the tasks of a mobile application from an MH to nearby, resource-rich PCs (called surrogates). The system architecture and key components of the proposed offloading service are presented, prototyped, and evaluated. The results of experiments and simulations have demonstrated the effectiveness and efficiency of this offloading service for mobile applications. |
| Review: The offloading approach considers a combination of multiple resources including CPU, memory, and communication cost (i.e., bandwidth resource). The goal is to reduce response time for a user application with the premise that less resource consumption usually leads to more energy savings. The idea is that any Java applicaton can be partitioned on the fly as long as the mobile device knows how to use the offloading service. The focus is on how an offloading service can be provided to a mobile device to offload some of the tasks of the application to more powerful surrogates in the vicinity. Process: (1) Upon receipt of an offloading request, either from an end user through a GUI of the offloading service or directly from the application, resource information such as memory usage, CPU utilization, and network bandwidth is collected by the resource monitoring module, (2) The offloading decision engine invokes the partitioning module to partition the composing classes of the application into one local execution partition and one or more remote execution partition(s) for the surrogate(s), (3) The surrogate discovery module is invoked to find appropriate surrogates. At the same time, the instrumenting module is also triggered to instrument the classes that belong to the remote partition(s) into a format suitable for surrogate execution, (4) The instrumented classes, along with their run-time execution statuses, are serialized and migrated to the surrogates by the offloading module, (5) These migrated classes are then de-serialized and resume their execution in a remote execution environment (JVM) under the control of the remote execution manager at the surrogate. The offloaded classes can interact with the classes in the local partition. The main addition with respect to Ou2007 is that it assumes that surrogates are interconnected and that code execution can migrate from one surrogate to another. The execution of the offloaded classes are terminated and migrated from the old surrogate to the new one. The new surrogate takes over the execution entirely. The interaction between the MH and the old surrogate finishes. It builds on Ou2007 that proposes a runtime offloading system (Offloading Toolkit) for pervasive services that considers multiple types of system resources and carries out service partitioning and partition offloading in an adaptive and efficient manner. It runs on top if the JVM. The Partitioning module is used to partition a service/application into one unoffloadable partition for running in mobile device and one or more offloadable partitions for running on surrogates. The instrument module is used to modify Java Classes (in bytecode format) on the fly to make it suitable for offloading. The Resource Monitoring Module monitors the resource usage of the running environment including the mobile device and the access networks. The Offloading Decision Making module makes the offloading decision according to the resource monitoring (CPU, memory, bandwidth, and invocation and data access number using an adaptive (k+1) partitioning algorithm). The Offloading module is used to execute the offloading. The Secure Communication module is for communication between mobile device and surrogates. In order to offload a Java class to a surrogate, an offloadable class needs to be instrumented. A dedicated proxy class is generated automatically as a shadow class to the instrumented class. |
BibTeX:
@article{Yang2008,
author = {Yang, Kun and Ou, Shumao and Chen, Hsiao-Hwa},
title = {On effective offloading services for resource-constrained mobile devices running heavier mobile Internet applications},
journal = {Communications Magazine, IEEE},
publisher = {IEEE},
year = {2008},
volume = {46},
number = {1},
pages = {56--63},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=4427231&tag=1}
}
|
| Yang L, Cao J, Yuan Y, Li T, Han A and Chan A (2013), "A framework for partitioning and execution of data stream applications in mobile cloud computing", ACM SIGMETRICS Performance Evaluation Review. Vol. 40(4), pp. 23-32. ACM. |
| Abstract: The advances in technologies of cloud computing and mobile computing enable the newly emerging mobile cloud computing paradigm. Three approaches have been proposed for mobile cloud applications: 1) extending the access to cloud services to mobile devices; 2) enabling mobile devices to work collaboratively as cloud resource providers; 3) augmenting the execution of mobile applications on portable devices using cloud resources. In this paper, we focus on the third approach in supporting mobile data stream applications. More specifically, we study the computation partitioning, which aims at optimizing the partition of a data stream application between mobile and cloud such that the application has maximum speed/throughput in processing the streaming data. To the best of our knowledge, it is the first work to study the partitioning problem for mobile data stream applications, where the optimization is placed on achieving high throughput of processing the streaming data rather than minimizing the makespan of executions in other applications. We first propose a framework to provide runtime support for the dynamic partitioning and execution of the application. Different from existing works, the framework not only allows the dynamic partitioning for a single user but also supports the sharing of computation instances among multiple users in the cloud to achieve efficient utilization of the underlying cloud resources. Meanwhile, the framework has better scalability because it is designed on the elastic cloud fabrics. Based on the framework, we design a genetic algorithm to perform the optimal partition. We have conducted extensive simulations. The results show that our method can achieve more than 2X better performance over the execution without partitioning. |
| Review: The framework consists of runtime systems to support the adaptive partitioning and distributed execution of the applications. The offloading decision becomes which components of the pipe-and-filter data processing application to offload to the cloud. When the user executes the application on the mobile device, a request with its profiling parameters such as device’s capability and wireless bandwidth is then sent to the Resource Manager in the cloud. The resource manager then assigns an Application Master to handle the request.The Application Master decides which modules are executed at the mobile side and which others are executed at the cloud side. The components assigned to the client are initiated as threads on the mobile device. Other components assigned to the cloud are invoked as services. In the framework, every mobile application has an Application Master in the cloud to augment its execution. The profiler on the mobile client measures the device’s characteristics at startup and continuously monitors its CPU workload and wireless network bandwidth. The controller on mobile client side maintains some thresholds on the variance of the profiling parameters. The application master has one thread for every remote component. These threads are responsible for data transmission as well as CaaS invocation. |
BibTeX:
@article{Yang2013a,
author = {Yang, Lei and Cao, Jiannong and Yuan, Yin and Li, Tao and Han, Andy and Chan, Alvin},
title = {A framework for partitioning and execution of data stream applications in mobile cloud computing},
journal = {ACM SIGMETRICS Performance Evaluation Review},
publisher = {ACM},
year = {2013},
volume = {40},
number = {4},
pages = {23--32},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6253581}
}
|
| Zhang X, Jeon W, Gibbs S and Kunjithapatham A (2012), "Elastic HTML5: Workload Offloading Using Cloud-Based Web Workers and Storages for Mobile Devices", In Mobile Computing, Applications, and Services. , pp. 373-381. Springer. |
| Abstract: In this position paper, we propose the concept of Elastic HTML5, which enables web applications to offload workload using cloud-based web workers and cloud-based storage for mobile devices. Elastic HTML5 is a collection of software components and functions in for a web runtime agent (e.g., web browser); this includes components and methods to create and manage web workers in the cloud so as to augment the computation functionality of a browser-based application running on a device. Elastic HTML5 also includes the components and methods to create and manage elastic storage between the main thread of a web application and its web workers. With these functions, a web application can run in elastic manner such that, whenever necessary, the mobile device can obtain resources from the cloud, including computation and storage, and when necessary, it can run offline at the device side completely. |
| Review: It leverages the concept of web workers in HTML5, which are basically background processes -- JavaScript can run in parallel on a web page, without blocking the user interface. Also, each web application or web worker can have persistent local storage. Elastic HTML5 enables an elastic version of the web worker model in HTML5 and allows workers to run on remote cores. Elastic storage between a device and cloud dynamically extends the capability of a web application and synchronizes data between the web application’s main thread and its web workers. The main function to support this feature is a pair of proxy web workers on client and cloud sides to relay and route messages between other web workers: The Elastic Web Worker Manager (EWWM) in invoked from the main thread and decides whether the web worker should execute locally or remotely. If remotely, it communicates with the Cloud Web Worker Manager (CWWM) by sending it the absolute URL of the web worker so that it does not have to send code. |
BibTeX:
@inproceedings{Zhang2012a,
author = {Zhang, Xinwen and Jeon, Won and Gibbs, Simon and Kunjithapatham, Anugeetha},
title = {Elastic HTML5: Workload Offloading Using Cloud-Based Web Workers and Storages for Mobile Devices},
booktitle = {Mobile Computing, Applications, and Services},
publisher = {Springer},
year = {2012},
pages = {373--381},
url = {http://link.springer.com/chapter/10.1007%2F978-3-642-29336-8_26}
}
|
| Zhang X, Kunjithapatham A, Jeong S and Gibbs S (2011), "Towards an elastic application model for augmenting the computing capabilities of mobile devices with cloud computing", Mobile Networks and Applications. Vol. 16(3), pp. 270-284. Springer. |
| Abstract: We propose a new elastic application model that enables seamless and transparent use of cloud resources to augment the capability of resource-constrained mobile devices. The salient features of this model include the partition of a single application into multiple components called weblets, and a dynamic adaptation of weblet execution configuration. While a weblet can be platform independent (e.g., Java or .Net bytecode or Python script) or platform dependent (native code), its execution location is transparent—it can be run on a mobile device or migrated to the cloud, i.e., run on one or more nodes offered by an IaaS provider. Thus, an elastic application can augment the capabilities of a mobile device including computation power, storage, and network bandwidth, with the light of dynamic execution configuration according to device’s status including CPU load, memory, battery level, network connection quality, and user preferences. This paper presents the motivation behind developing elastic applications and their architecture including typical elasticity patterns and cost models that are applied to determine the elasticity patterns. We implement a reference architecture and develop a set of elastic applications to validate the augmentation capabilities for smartphone devices. We demonstrate promising results of the proposed application model using data collected from one of our example elastic applications. |
| Review: The decision of where to launch a weblet is based on application configuration and/or the status of the device such as its CPU load and battery level. A unique requirement for elastic applications is that a weblet’s functionality should not be affected by the location or environment where it is running. One principle for partitioning applications is that each weblet should have minimum dependency on others. This is not only for robustness but decreases communication overhead between weblets during runtime. Defines three elasticity patterns: Replication (running multiple weblets with the same interface), Splitter (set of worker weblets perform variant implementations of a shared interface), and Aggregator (aggregate computations from multiple worker weblets and use weblet push to relay this information to the device). The optimization algorithm determines allocation and also the elasticity pattern to implement. A typical elastic application consists of a UI component, one or more weblets, and a manifest. Weblets are autonomous software entities that run either on the device or cloud and expose RESTful web service interfaces via HTTP. On the device side, the key component is the device elasticity manager (DEM) which is responsible for configuring applications at launch time and making configuration changes during runtime. The configuration of an application includes: where the application’s components (weblets) are located, whether or not components are replicated or shadowed (e.g., for reliability purposes), and the selection of paths used for communication with weblets (e.g., WiFi or 3G if such a choice exists). The router passes requests from UI components to weblets. It insulates the UI logic from weblet location. When a weblet is migrated, the router will be aware of the new location and will continue passing requests from the UI to the weblet (and passing replies back to the UI). A typical elastic application includes a AppRoot component and one or more weblets. The AppRoot is the part of the application that provides the user interface and issues requests to weblets. All of these are packaged into one bundle, which includes the binaries of weblets and a manifest describing the application, and most importantly, the developer-signed hash values of the individual weblets. |
BibTeX:
@article{Zhang2011,
author = {Zhang, Xinwen and Kunjithapatham, Anugeetha and Jeong, Sangoh and Gibbs, Simon},
title = {Towards an elastic application model for augmenting the computing capabilities of mobile devices with cloud computing},
journal = {Mobile Networks and Applications},
publisher = {Springer},
year = {2011},
volume = {16},
number = {3},
pages = {270--284},
url = {http://dl.acm.org/citation.cfm?id=1997794}
}
|
| Zhang Y, Guan X-t, Huang T and Cheng X (2009), "A heterogeneous auto-offloading framework based on web browser for resource-constrained devices", In Internet and Web Applications and Services, 2009. ICIW'09. Fourth International Conference on. , pp. 193-199. |
| Abstract: Web applications are becoming increasingly popular. More and more types of multimedia data have been embedded into web pages for providing abundant information and user interface. However, these complex web pages could not be smoothly presented on devices without adequate functionalities or resource. An alternative approach is shifting tasks from resource-constrained device to surrogate with rich resource. In this paper, we present a heterogeneous autooffloading framework based on web browser, and implement plug-in proxy to offload multimedia processing tasks to heterogeneous surrogate automatically. The plug-in proxy works transparently with existing browser, and does not require modifying, recompiling or relinking. We perform several plug-in proxies of Firefox by offloading multimedia data and execution logic to surrogate, and merging remote display seamlessly with web browser interface. The experimental results show that the proposed framework and plug-in proxies could enrich browser functionalities, reduce resource consumed by client, or improve performance of multimedia tasks. |
| Review: The paper proposes a heterogeneous auto-offloading framework based on a web browser, and implements a plug-in proxy to offload multimedia processing tasks to heterogeneous surrogates automatically. The plug-in proxy works transparently with the existing browser, and does not require modifying, recompiling or relinking. Both client and surrogate sides are composed of two layers: application layer and control layer. In every layer there are some interactions between counterparts. The Application Layer is responsible for handling the concrete functionalities that should be offloaded. The Web browser in the client implements plug-in proxies to simulate offloaded plugins. The Control Layer implements service discovery, merges local and remote display updates seamlessly, and forwards user events to the surrogate to handle. When a client sends an HTTP request to the web server, the server sends back the content of the requested web page. If the client finds that multimedia contents are embedded into the web page, the plug-in proxy will be invoked. If these contents could not be recognized by the client, or handling these contents will consume much of client resource, multimedia offloading happens. Otherwise the plug-in proxy will switch control to the actual plug-in. The URL of unrecognized contents will be intercepted and forwarded to the surrogate by the plug-in proxy on the client. |
BibTeX:
@inproceedings{Zhang2009,
author = {Zhang, Yang and Guan, Xue-tao and Huang, Tao and Cheng, Xu},
title = {A heterogeneous auto-offloading framework based on web browser for resource-constrained devices},
booktitle = {Internet and Web Applications and Services, 2009. ICIW'09. Fourth International Conference on},
year = {2009},
pages = {193--199},
url = {http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=5072518&tag=1}
}
|
| Zhang Y, Huang G, Zhang W, Liu X and Mei H (2012), "Towards module-based automatic partitioning of Java applications", Frontiers of Computer Science. Vol. 6(6), pp. 725-740. Springer. |
| Abstract: When reengineering a monolithic application to be a distributed one, programmers always have to decide how many distributed parts the application should be partitioned, and write many codes related to where a partwill be placed on network nodes and how these parts communicate with each other through the network. These codes usually have nothing to do with the business functions of the application, and they are laborious to write. In addition, as the distribution architecture of the application is finalized beforehand, it may not adapt well to the ever-changing execution environment. In this paper, we propose DPartner, an automatic partitioning system, to help programmers create a distributed Java application without explicitly writing the distribution-related codes. Unlike the other partitioning systems, DPartner does not partition an application directly into the coarse-grained client and server. Instead, it first partitions the application into several modules where each module performs a relatively independent business function of the application. Then it makes these modules be distributable through automatic bytecode rewriting. These modules can distribute in different nodes and cooperate to work just as the original monolithic application. Such a module-based partitioning approach enables a relatively easy reshaping of the distribution architecture of an application, which facilitates the application adapt to the environmental changes without manual recoding or repartitioning with regard to distribution. This paper gives the detailed design of DPartner, and evaluates it using real-world applications. The evaluation results demonstrate the effectiveness and efficiency of DPartner. |
| Review: It first partitions the application into several modules using code analysis and clustering algorithms, where each module performs a relatively independent business function of the application. Then it makes these modules distributable through automatic bytecode rewriting. Basically, Java modules are packaged as OGSi bundles that can be distributed across a network. To make the partitioned modules be distributable, DPartner creates a proxy for each module, while each proxy is also wrapped as an OSGi bundle. The direct communication between modules is converted to indirect communication through proxies. An OSGi platform on each side (mobile device and server) manages the running of the bundles. It is not clear how the actual modules are distributed across nodes, but it seems that they are initially manually distributed according to the results of the partitioning algorithm. However, the architecture would enable the re-distribution of modules depending on environmental conditions. What is not clear to me is whether all proxies and bundles exist on both machines from the start or if they would move around. |
BibTeX:
@article{Zhang2012,
author = {Zhang, Ying and Huang, Gang and Zhang, Wei and Liu, Xuanzhe and Mei, Hong},
title = {Towards module-based automatic partitioning of Java applications},
journal = {Frontiers of Computer Science},
publisher = {Springer},
year = {2012},
volume = {6},
number = {6},
pages = {725--740},
url = {http://link.springer.com/article/10.1007%2Fs11704-012-2220-x}
}
|