Decomposição Dinâmica de Computações para Execução na Edge

Abstract

Com o aumento do número de dispositivos terminais no domínio da Internet of Things (IoT) e que realizam pedidos a serviços em execução na cloud, tal como smartphones, tablets, etc., o processamento de um tão elevado volume de dados na cloud torna-se in- comportável. É também crescente o número de aplicações sensíveis à latência (e.g. online gaming) e de dispositivos IoT que necessitam de tomar decisões em tempo real/quase- real (e.g. smart cars) que requerem uma resposta rápida por parte de serviços essenciais. Torna-se então necessário aproximar os serviços, que executam os pedidos/processam os dados, aos dispositivos, reduzindo assim a latência e permitindo uma resposta atem- pada. Esta abordagem de trazer as computações para nós computacionais mais perto dos dispositivos/fontes de dados chama-se Computação na Edge. Características distintivas desses nós são a sua heterogeneidade, capacidade computacional e de armazenamento reduzidas, e variabilidade na carga de trabalho (workload). De modo a responder às restrições computacionais e energéticas dos nós da edge, os módulos de código que aí é possível executar têm também de ser de dimensão reduzida (e.g. micro-serviços). Adicionalmente, as decisões tomadas em termos da localização des- ses módulos (e.g. em função da carga e localização dos nós e, volume de acessos) podem ser melhoradas se houver informação sobre as características do seu código. Por exem- plo, se o módulo contém código que faz recolha de dados, filtra esses dados e agrega os resultados (e.g. à semelhança de plataformas distribuídas map-reduce). Existindo essa informação (e.g. através de anotações no código), é possível decompor (dinamicamente) a funcionalidade de um módulo em sub-módulos, e fazer o seu deployment tendo em vista melhorar a robustez e desempenho do módulo como um todo. A solução consiste numa API, que através do uso de anotações Java, permite aos uti- lizadores marcar o offload de um conjunto de tarefas para a sua execução na edge. Estas tarefas são mapeadas para um conjunto de padrões computacionais a executar na edge implementados com recurso ao modelo de actores. A avaliação realizada permitiu comprovar que a API permite aos utilizadores benefi- ciarem do offload de tarefas para o ambiente edge, ao mesmo tempo que lhes é oferecida uma forma transparente de fazer este offload, em que apenas necessitam de se focar na lógica da aplicação.

With the increasing number of end-to-end devices in the Internet of Things (IoT) domain that make requests to services running in the cloud, such as smartphones, tablets, etc., processing such a high volume of data in the cloud has become infeasible. The number of latency sensible applications (e.g. online gaming) and IoT devices that need to make real-time decisions (e.g smart cars) and need a quick server response is also growing. It becomes necessary to approximate the services, which execute the requests/process the data, to the devices, thus reducing the latency and allowing a timely response. This ap- proach of bringing computations to computational nodes closer to devices/data sources is called Edge Computing. These nodes have distinguishing features, such as heterogeneity, reduced computational storage capacity, and a varying workload. In order to respond to the computational and energetic constraints of the edge nodes, the code modules that can be implemented there must also have a reduced size (e.g. mi- croservices). Moreover, the decisions over the location of these modules (e.g. depending on the load and location of the nodes and the access volume) can be improved if there is information on code characteristics. For example, if the module contains code that collects data, filters it and aggregates the results (e.g. distributed map-reduce platforms). Obtaining this information (e.g. using code annotations), it is possible to dynamically decompose the module functionality into sub-modules, and to deploy it, improving the module robustness and performance as a whole. The solution consists of an API, which by the use of Java annotations, allows users to mark the offload of a set of tasks for its execution at the edge. These tasks are mapped to a set of computational patterns to be executed at the edge, implemented by the actor model. The evaluation proved that the API allows users to collect the benefits of task offload- ing to the edge environment, while providing a transparent way to do it, allowing users to solely focus on the logic of the application.