Förderjahr 2023 / Stipendien Call #18 / ProjektID: 6851 / Projekt: Reliability of Edge Offloadings
The blog is about finding a fast and efficient edge offloading solution that conforms to (near-)real-time application requirements. The target solution should formally guarantee performance based on reliable offloading decisions.
In this blog, we will explain which mobile applications we target to offload, what edge computing factors need to be taken into consideration during offloading, and what kind of solution we want to invent.
Mobile application and offloading
Latency-sensitive mobile applications are subject to strict quality-of-service (QoS) requirements such as response time. To ensure fast performance, applications demand a high amount of resources, ranging from CPU cores, and RAMs to disks. Executing such resource-intensive mobile applications on resource-limited mobile devices like smartphones, VR headsets, and car vehicles is not convenient. Unable to provide sufficient resources makes it impossible to achieve (near-)real-time performance and violates QoS requirements. The main goal is to offload resource-intensive application tasks from mobile devices to nearby edge servers with greater computational power. Mobile application resource requirements should be matched judiciously with available edge resource capacities. Application tasks are offloaded on those edge servers that have enough resources to satisfy QoS requirements and achieve high performance.
Edge computing challenges
Offloading application tasks on edge servers has its challenges. The edge environment is usually unreliable due to (1) limited resources, (2) intermittent connections, and (3) lack of supporting systems such as cooling and backup power. Furthermore, edge servers have heterogeneous resource capacities ranging from micro data centers, and radio base stations to single-board computing devices (e.g. Raspberry Pi). Deciding which edge server has sufficient available resources to execute application tasks timely is of paramount importance for performance efficiency. Also, mobile devices are constantly exposed to new edge servers due to mobility. The edge servers can change behavior between interactions due to dynamic failures, thus making it difficult to identify a reliable one based on local historical experience. Lastly, edge environments are usually shared between many mobile devices which makes them susceptible to highly volatile workloads. It can drastically limit edge servers' resource capacity.
The final goal is to find an offloading solution that can formally guarantee the required (near-)real-time performance amid an unreliable and volatile edge environment. The focus is on guaranteeing the performance instead of optimizing it. Optimization solutions can obtain optimal solutions but without guaranteeing performance since they prioritize efficiency over exhaustive exploration of solution space. They often rely on historical data (e.g. AI) that is potentially incomplete (e.g. mobile device limited range, data loss, potential data corruption), consume lots of resources, and can be untimely (e.g. triggering re-training when accuracy drops). These conditions are unacceptable for (near-)real-time applications. Hence, we target a solution that can compute offloading decisions timely, minimally relying on historical data, and can formally guarantee required performance. The solution should avoid centralized architectures which exhibit issues like single-point-of-failure and performance bottlenecks. It should also incorporate a reliability information-sharing service that shares reliability estimations of each edge server node based on past task executions. The reliability information should be stored securely (e.g. against tampering) and shared with all mobile devices (e.g. bypassing mobile range limitations) that will offload application tasks on edge servers.