Computational Offloading in Mobile Cloud Computing 
Tags: computerscience, android, cloud, mobile
Published: 2020-02-17 22:05:27

Back in 2014, in [this](https://ieeexplore.ieee.org/document/6553297) paper, we've got to see the definition of Mobile Cloud Computing (MCC). It says that MCC is the combination of Cloud Computing and Mobile Computing 🤯. The concept of Cloud Computing sounds like the most obvious solution to the hardware limitation of Mobile devices. I know what you're looking at your newest iPhone or Xiaomi and thinking that _limitation_ might not be the right word, in fact, Smartphones nowadays are supercomputers in our pockets, but think for a moment: 

What if the battery of your phone dies RIGHT NOW? It is a "hardware limitation". 
What if you are on a bus, just passing through a tunnel, how flaky is your mobile connection going to be? 

I could keep talking about "limitations" of our Smartphones but if you think, those two scenarios that I mentioned, would not be a problem for an old fashion Desktop for example, as it is always plugged in an electricity cable, always in a cable internet or even your house wifi, pretty good and stable. 
But mobile devices are not only Smartphones, right? It can be anything, such as your Smartwatch or your Nintendo Switch - That's why I always carry a Power Bank 16000mah with me 🧞‍♂️ -. So as you can see, MCC Computational Offloading is still a very relevant topic in 2020.  

### Context-Awareness 

Context-Awareness is one of the most important topics in MCC. It has a significant impact on the computational offloading due to the uncertainty __whether this would be beneficial or not__. Context Awareness in MCC can be classified into two approaches: _Context-Aware application partitioning_ and _Context-Aware computational offloading_.

### __Context-Aware application partitioning__
If you already know what are the _resource intensive_ features of your application and you will run it in the cloud, as simple as that. [mCloud](https://www.researchgate.net/publication/287971934_mCloud_A_Context-Aware_Offloading_Framework_for_Heterogeneous_Mobile_Cloud) proposes an architecture for _dynamic_ offloading, this framework composed of several components for decision making and context-monitor, was developed in Java using reﬂection for selecting the essential piece of code to be offloaded to the cloud, it basically wraps the source code and sends to the cloud, where it will be compiled and executed. The advantage of mCloud is that you will be able to offload smaller "parts" of your application but as you can imagine, just by doing that, sounds like heavy computing itself. Also, this approach can not be the best decision in cases where the mobile application uses hardware features like sensors or GPS. 


###__Context-Aware computation offloading__ 
The Context-Aware methodology prioritises energy efficiency, application execution and performance. Here, you won't have specific functionality that will always be offloaded to the Cloud, the decision to offload or not, will be based in some aspects:

### Objective Awareness
The computational offloading has three principles that were already mentioned in this research: performance enhancement, energy efficiency and execution support. Usually, the application will need to focus on one of those principles according to the respective scenario. The mCloud architecture, for example, prioritises performance and energy efficiency.

### Performance Awareness
In the majority of the cases, the computational offloading focus on performance enhancement, but sometimes, the computational offloading takes more time to offload the task than running it locally, so in these cases, the offloading is not executed, thus not to compromise the performance of the application.

### Energy Awareness
Every time that a mobile device runs an intensive computational task locally, a significant amount of energy is consumed, it is a problem due to the energy limitation of the devices.
Many authors use energy awareness as the main factor to decide when to offload or not the computational task to the cloud, however, to offload the task itself, the mobile also consumes a considerable amount of energy during the request and result of this process. The mCloud framework takes into account the consumption of energy during the decision-making phase; an algorithm creates an estimative of the amount of energy that the particular task will spend. This information affects the final decision to offload or not to the cloud.

### Resource Awareness
Resource Awareness requires the application, to be aware of the mobile device, it means that if the device does not have sufficient resources to run a computational process, plus the awareness of the cloud environment, so when the application has an intensive computational task to run. The cloud awareness verifies the conditions to offload; these two factors will be checked during the phase of the offloading decision-making.
The aim of this research is performance enhancement as the major factor to decide
if the offloading will be beneficial or not for each scenario. Also, context awareness is another important element during the decision-making phase. So it is possible to say that the experiment done for this research is a combination of performance awareness and resource awareness.

## Conclusion
This is a summary of a topic that I believe that it is still relevant, mainly if we look at the mobile games that became such a big market and so many other examples. 

Thanks for reading! 😁 

__References:__
https://ieeexplore.ieee.org/document/6553297
https://ieeexplore.ieee.org/document/7158968
https://www.researchgate.net/publication/287971934_mCloud_A_Context-Aware_Offloading_Framework_for_Heterogeneous_Mobile_Cloud