DESIGN AND IMPLEMENTATION OF AN ANDROID COMPATIBLE DISTRIBUTED MULTI-ACCESS EDGE COMPUTING PLATFORM Alexei Belikov Mogilny Master’s Thesis presented to the Telecommunications Engineering School Master’s Degree in Telecommunications Engineering Supervisor Felipe Gil Castiñeira 2020 Abstract While mobile device performance continues to increase, they are still behind servers or desktop computers in terms of computational capacity, storage or memory. Broad availability of high-bandwidth wireless communications and computational resources allows mobile devices to leverage the features of cloud computing by using remote systems to perform the most complex operations. Nevertheless, there are different use cases where the time to provide results is critical, but the multi-access edge computing paradigm proposes to move the cloud resources closer to the user (for example, by installing a small data center near the cellular base station). This master thesis covers the design and implementation of a system capable of running Android applications in a cloud environment, and more particularly at the edge of the network, in order to reduce the latency between user interaction and results, and provides a brief analysis of the performance. Key words: Google Android, Virtualization, 5G, Multi-access edge computing iii Contents Abstract iii List of figures vii 1 Introduction1 1.1 Motivation....................................1 1.2 Objectives....................................2 2 State of the art3 2.1 Android internal architecture.........................3 2.1.1 Android graphics............................3 2.1.2 Input devices..............................5 2.2 Running Android on a PC...........................6 2.2.1 Anbox..................................7 2.2.2 Anbox Cloud..............................8 2.3 Related work..................................9 3 Android Edge Platform 11 3.1 Architecture overview............................. 11 3.2 Remote rendering................................ 12 3.3 Event injection................................. 13 4 Results 15 4.1 Prototype client................................. 15 4.2 Benchmarks................................... 15 4.3 Latency..................................... 17 5 Conclusions and future work 21 5.1 Future work................................... 22 Bibliography 24 v List of Figures 2.1 Render process diagram............................4 2.2 SurfaceFlinger managing layers for a display.................5 2.3 Android Input stack components.......................7 3.1 Android Edge Platform architecture...................... 11 3.2 Remote rendering architecture......................... 12 3.3 Event forwarding................................. 14 4.1 Prototype application.............................. 16 4.2 RealPi benchmark results............................ 16 4.3 Geekbench 5 results............................... 17 4.4 Latency measurements............................. 18 vii 1 Introduction 1.1 Motivation Wireless communications have been increasing in capacity and reliability at a steady pace for years and it is expected that the arrival of 5G will be the next step forward. One of the core ideas of this next generation of communications is the multi-access edge computing (MEC) paradigm: to bring the compute, storage and networking resources closer to the users [1]. 5G networks offer flexibility for accommodating different applications with varied quality- of-service profiles. This flexibility stems from a new architecture based on the virtualization of most of the components of the network. This allows increased efficiency in distributing the resources to optimise the throughput taking into account the requirements of the data [2]. Furthermore, cloud computing has great success because it offers on-demand resources with reliability and cost savings, for example in terms of maintenance. Many applications developed nowadays leverage the cloud capacity to perform tasks that are not practical to be executed locally (because of the lack of resources in terms of computing power, memory, storage, etc.). However, there are few large cloud providers and their data centres are located in a few select locations. This is a limiting factor for certain low latency applications. Nevertheless, 5G networks plan to include distributed clouds in locations near the users. This is the edge computing paradigm, which aims to provide most of the advantages of the cloud with the pros of physical proximity of the hardware to the users. Apart from that, it has other advantages such as a reduction of the back-haul transmissions as the data has to travel across less networks [3]. New use cases for high mobility devices such as smartwatches, glasses, and phones are getting traction. Among those it is worth mentioning AR/VR applications used in industrial scenarios and in gaming [4]. Such applications have strong computing 1 Chapter 1. Introduction requirements to generate images in real time. Even though mobile devices have increased in performance in the last years they’re still behind more stationary equipment such as desktops and servers where power limits are less of a concern [5]. These new uses call for a shift in the usual client-server style of programming previously used to offload computationally heavy tasks such as speech analysis or image recognition. A new concept of offloading is being developed where even the user interface is executed in the remote server, and the local device is just used for displaying the rendered user interface and to capture interaction. This approach requires low latency, so that users don’t perceive any lag between their interaction and the results displayed on the screen. By using edge computing locations, it is possible to achieve this objective. In this thesis, we propose to offload the computing of Android applications by directly executing them in cloud or edge locations, and using the phone just for showing the rendered interface and capturing the user interaction. Most cloud servers use Intel or AMD processors with the x86-64 architecture, thus to achieve this objective we take advantage of the possibility to execute Android in different architectures, ranging from ARM smartphones to the mentioned x86-64 servers. 1.2 Objectives The main objective of this thesis is the development of an architecture for the virtualization of Android applications in a cloud/edge environment and the remote execution from a simple Android smartphone. This architecture will be validated with a “Proof of Concept” implementation. This work will lay the foundations for a platform that will be able to allow applications to be typically executed in a smartphone or a wearable, but transparently migrated to a cloud platform when the requirements increase (for example, when the application requires hardware acceleration, more memory or CPU power). Thus, in this thesis we develop a system that will enable Android smart devices, such as phones or smart glasses, to allow users to interact with a applications that are really running at the edge. To build this solution we used an open source project, Anbox, as the basis to run Android applications at the cloud. 2 2 State of the art This project uses functions and ideas from existing software and proposes modifications to explore a new use of those technologies to build an architecture for the remote execution of Android applications. For a better understanding of the solution it is important to establish a common ground and know the limitations and possibilities of this components as well as to mention alternatives that partially had influence in the design of the architecture. 2.1 Android internal architecture Android is an operating system running a kernel based on Linux, that was adapted to run on mobile devices, initially phones and later other hardware such as watches or TVs. This project uses this OS because of its widespread adoption and its open nature making it possible to implement modifications at the operating system level. To achieve the goals of this project some key components of Android have been modified. In order to capture the application output a section of the rendering process has been altered. To forward the interaction from the client to the service, some changes were needed in parts of the input stack. The sections that follow provide a brief overview of how the graphics and input stacks work on an Android device to understand where the capture and injection occurs. 2.1.1 Android graphics The way that Android handles the user interface has evolved throughout the different versions of the operating system. These changes introduced performance enhancements in forms of render flow optimisations, hardware acceleration from the GPU to draw using low level APIs or the composition of the elements coming from different sources using 3 Chapter 2. State of the art hardware acceleration [6]. This section describes how UI elements are generated on a modern Android version. The process of generating output on a display starts at the choreographer that periodically generates VSync events. At this point in the UI (user interface) thread, the input events get processed. This might trigger some changes at the UI such as starting animations, changing dimensions, etc. [7]. The components that have changed in the content hierarchy are marked as “dirty” in a process called invalidation. This goes through all the containers and other elements that are implicated (for example the entire list when one item of it is pressed). This later triggers a traversal code that