Vehicular Cloud Computing through Dynamic Computation Offloading
Introduction
Computing requirements for vehicular applications are increasing tremendously, particularly with the growing interest in embedding new class of interactive applications and services using on–board sensory inputs. For example, autonomous driving and novel driver–safety enhancement applications are becoming increasingly dependent on–board cameras and motion sensors. The on–board computing resources in vehicles have been primarily allocated to accommodate the driving mechanism of the vehicles. The growing need for embedding interactive applications and services requires reallocation of the limited on–board computing resources. Unlike software, updating the hardware information technology (IT) resources in vehicles to keep up with increasing demands of such applications is challenging as it cannot be done automatically. Moreover, it must be possible to reconfigure, service and manage such hardware over the long lifetimes of vehicles; 10–15 years.
The need for the day is the capability of vehicular computing resources to be elastic and easily reconfigurable. Improving hardware capabilities and adding IT resources in vehicles partially helps the case, but it has constraints. The vehicle has a limited amount of space to fit in more hardware components. With the notion of automated driving in picture, the sensory interfaces in vehicles in itself are becoming overwhelmingly complex. In addition, hardware additions also mean increased complexity in engineering their control and management. A potential solution to expanding the computing capabilities in vehicles is to leverage the cloud computing resources. In this regard, we promote the idea of vehicular cloud computing, where vehicular applications can benefit from offloading or remote execution in a cloud server. In principle, a cloud can be a remote cluster server or an proximate edge–computing unit, for example, a cloudlet [1]. The key idea here is to opportunistically utilize any remote computing resource to run vehicular applications.
Cloud–computing, while is an attractive solution for expanding vehicular information technology (IT) resources, executing vehicular applications remotely is very challenging due to some unique characteristics of the vehicular use–case and its applications. Vehicular applications are increasingly being dependent on a large array of sensory inputs. In addition, interactive applications such as those using computer vision involve large sensory inputs (e.g. high definition video) – see Fig. 1. Offloading such applications will require migrating large sensory data to the cloud which can take a lot of time depending on the network conditions. Interactive applications are particularly latency sensitive and thus large network round–trip times (RTT) will essentially undermine the usefulness of the fast cloud computing resource. Offloading when the vehicle is driving presents an additional challenge as the network connectivity between the vehicle and the cloud is now a variable, which may also include outages depending upon the vehicle’s driving path.
Prior approaches to cloud–offloading concept have proposed distributing computation by migrating virtual machines [1] or offloading parts of the application code between the mobile client and cloud [2] or using low–level memory abstractions [3]. The challenge with such designs is the large communication overhead to transport machine and application state and the overhead to manage state and/or abstractions across a large distributed cluster of machines. Distributed computing techniques using remote–procedure call (RPCs) based architectures (e.g. CORBA) have existed for a long time, however, these techniques assume high network reliability which is not guaranteed in a vehicular case.
To address the challenges in vehicular application offloading, we design a system that selectively offloads only parts of applications, instead of offloading the entire application. These parts, or modules as referred to in our design, correspond to specific set of functions as a part of the application. The design idea is to divide applications into modules and segregate a collective set of tasks from set of applications based on their computation requirements, and identify which of the modules will be offloaded to the cloud and what execute in the local on–board unit CPU. Once identified, the data corresponding to the offloaded modules is transferred to the cloud and the module computation is performed in the cloud. This design model treats that the module definitions are already available in the cloud. We introduced this treatment in this work based on our prior work that defined a service–based offloading [4], [5] mechanism where cloud executed tasks are coded as services in the cloud server.
Designing a system for offloading specific application tasks in the vehicular context brings about key fundamental challenges in real–time resource allocation, execution and adaptation:
- (i)
Dynamic Allocation; The system must allocate OBU and cloud CPU cycles to schedule execution of a collective set of application tasks. The scheduling must take into account the RTT to offload application tasks over a limited network bandwidth. It must also be able to plan CPU and network bandwidth allocations for scheduling applications for different policy considerations; for example, choosing between minimizing network bandwidth expense or minimizing OBU processor cycles usage. Overall, this takes shape of a multidimensional (multiple applications and across variable constraints) scheduling problem. As we know, scheduling problems fall under NP–hard problem category. Therefore, a heuristic real–time dynamic resource allocation mechanism is required.
- (ii)
Run–time Adaptation: The system must be able to conduct the allocation and offloading in run–time as information about what applications will be initiated and the quality of the network is not known apriori. Executing such multidimensional allocation and adaption under real–time constraints brings additional challenges to the complexity of the allocation problem.
Response Time is defined as the total execution time of the application measured from initiation to completion (deliver final output), and
Deadline, is defined as the maximum duration within which an application must complete execution to be regarded useful by the user.
In summary, we make the following specific contributions in this paper:
- 1.
A framework for cloud–offloading that is flexible and can deal with vehicular applications with large sensory inputs.
- 2.
A heuristic mechanism for partitioning and scheduling, which includes partitioning applications into tasks & identifying placement of such tasks, and computing a schedule.
- 3.
A mechanism for adapting applications’ scheduling at run–time based on the dynamics of network variations and design policy selections. The mechanism incorporates a heuristic planning–based technique that plans schedule and adapts task execution to variations in network conditions and application requirements.
- 4.
A prototype end–end system implementation of a cloud offloading system, including four proof–of–concept cloud–computing integrated applications in an Android device.
- 5.
Experimental evaluation of the effectiveness of the prototype offloading system, using the response time of applications as a metric. The evaluation is carried across variable network conditions, policy considerations and performed in two urban environments (Pittsburgh, USA and Atlanta, USA).
The rest of the paper is organized as follows: Section 2 motivates the importance, feasibility and challenges of cloud offloading in vehicular use–case; Section 3 presents an overview of the proposed system design; Section 4 discusses the heuristic dynamic resource allocation framework, followed by discussion of application workload structuring and placement & scheduling in Sections 5 and 6, respectively; Section 7 describes run–time adaption mechanism; Section 8 presents the prototype implementation details; Section 9 presents the macro–level evaluation results and Section 10 presents the micro–benchmarking study for the Atlanta trace data; Section 11 summarizes related work and Section 12 concludes the paper.
Section snippets
Motivation
The computational needs for vehicular applications are increasing with the growing number of sensor–based interactive applications and services. The long lifetime of vehicles (10–15 years) means however that the computational resources on most vehicles on the road are outdated, yet, the demand for more sensor based applications and cognition in vehicular applications is fast increasing. There is a growing need for smarter applications and services in vehicles, for example, to enhance and
Application task model
Sensor–based applications in vehicles typically are a collection of tasks with different execution times, data size inputs, etc. We characterize the properties of these tasks through a model. We divide an application into individual units called modules [5]. We regard module is a collection of application tasks that can be treated as a monolithic function and which can be reused independently across different compatible systems. Modules may execute sequentially or in parallel across an
Dynamic resource allocation
Our design of the dynamic offloading system is motivated by the lessons we learned through our prior work in designing a proof–of–concept service–based cloud offloading system [4]. We designed a framework for placement of application tasks or modules in OBU or cloud that used an exhaustive search mechanism for partitioning the OBU and cloud assignments based on the network bandwidth available. While this system showed about 3x improvement in application response time the framework considered
Workload structuring
Traditionally, heuristic approaches for real–time placement and scheduling have used tree data–structures. However, generating the tree to exhaustively represent all possible placement options is time consuming, and requires large storage space. In addition, traversing a tree is a time consuming operation and can lead to long wait times for applications’ execution.
In our design, we organize applications by representing their module characteristics in the form of tabular representations. As
Placement and scheduling
We develop a heuristic mechanism for placement and scheduling that involves three stages:
- (1)
Proactive placement to meet constraints: Find placements where the OBU CPU cycles and network bandwidth constraints are met, and which can help find a schedule to meet deadlines.
- (2)
Placement planning for different policies: Plan placements for each design policy; minimal network bandwidth expense, minimize OBU cycles usage and minimize maximum lateness across applications.
- (3)
Schedule computation: Prepare schedule
Run–Time execution and adaptation
The dynamic resource allocator conducts the placement identification and scheduling process as soon as the applications arrive at the workload within an arrival time window. Only when it is ascertained that it is feasible to schedule the workload it is executed by the run–time adaptive controller. The run–time manager adapts schedule execution when the network bandwidth changes or when new applications arrive at the workload. Since preemption of a module execution is not allowed, the schedule
Cloud server infrastructure
We implemented the cloud services in one of the cluster nodes in a private cloud server that contained 40 CPU cores at 2.3GHz processor speed and ran Ubuntu Linux 12.04 LTS. The services were implemented in the form of Java executables (.jar) that initiate through a function call.
Mobile client infrastructure
We emulated the vehicle OBU using a Nexus 7 tablet device that ran Android operating system. We chose this device as it almost has the same processor speed (1.3 GHz) as OBUs fit in vehicles over last 2 years. Vehicle
Evaluation
We conduct experiments using our prototype implementation to study the end–to–end application performance in terms of the response–time of applications in the workload. We evaluate our cloud–offloading system in terms of its effectiveness in scheduling a workload of applications such that they meet their deadlines.
General experiment setup and methodology. The general set–up for our experiments included an Android device (tablet) docked onto the dashboard of a car. During the course of our
Workload evaluation
To verify system performance in different geographical locations, we repeated the Pittsburgh app response time evaluation experiments in downtown Atlanta. We duplicated the Pittsburgh setup by docking the phone onto a car and drove around downtown Atlanta over 2 mile loop from Georgia State University (GSU) campus. The cloud server was located in the 7th floor of the computer science department at GSU. The driving route is shown in Fig. 11.
We observed that the workload was not being completed
Related work
Code migration. Prior work in cloud offloading has proposed to offload application partitions by offloading their source–code at run–time to remote machines. MAUI [2] offloads specific annotated parts of the code at run-time to a middlebox. The machine uses an integer linear programming (ILP) solver for identifying the application partitions to be offloaded. Running ILP solvers across dynamic systems will be very challenging. Odessa [9] improves response time of perceptive applications by
Conclusion
We designed a system for offloading interactive vehicular applications with large sensor inputs where remote execution of application tasks can be availed as services. We developed a system that hosts heuristic mechanisms for partitioning applications into modules, plan placement and schedule for the modules across dynamic network conditions and variable design policies, and strategies to adapt schedule execution at run–time. Through experiments using our prototype cloud offloading system we
References (22)
- et al.
A survey on vehicular cloud computing
J. Netw. Comput. Appl.
(2014) - et al.
Just-in-time provisioning for cyber foraging
Proceeding of the 11th Annual International Conference on Mobile Systems, Applications, and Services
(2013) - et al.
Maui: making smartphones last longer with code offload
Proceedings of the 8th International Conference on Mobile Systems, Applications, and Services
(2010) - et al.
Comet: code offload by migrating execution transparently
Presented as part of the 10th USENIX Symposium on Operating Systems Design and Implementation (OSDI 12)
(2012) - et al.
Enabling vehicular applications using cloud services through adaptive computation offloading
Proceedings of the 6th International Workshop on Mobile Cloud Computing and Services
(2015) - et al.
Adaptive cloud offloading for vehicular applications
2016 IEEE Vehicular Networking Conference (VNC)
(2016) Microsoft Azure Computer Vision API
(2015)Distinctive image features from scale-invariant keypoints
Int. J. Comput. Vis.
(2004)- et al.
A survey of hard real-time scheduling for multiprocessor systems
ACM Comput. Surv.
(2011) - et al.
Odessa: enabling interactive perception applications on mobile devices
Proceedings of the 9th International Conference on Mobile Systems, Applications, and Services
(2011)