Elsevier

Computer Communications

Volume 120, May 2018, Pages 125-137
Computer Communications

Vehicular Cloud Computing through Dynamic Computation Offloading

https://doi.org/10.1016/j.comcom.2017.12.011Get rights and content

Abstract

The growing demand in the number of sensor–dependent applications and infotainment services in vehicles is pushing the limits of their on–board computing resources. Today, vehicles are increasingly being connected to the Internet and becoming a part of the Smart Internet–of–Things (IoT) paradigm. Leveraging such connectivity, the idea of vehicular cloud–computing, where computation for vehicular applications and services are offloaded to the cloud, becomes an attractive proposition. However, the large sensory data inputs, strict latency requirements, and dynamic wireless networking conditions make offloading of vehicular applications to the cloud very challenging. To address this challenge, we design a dynamic approach for offloading specific vehicular application components or modules. We develop heuristic mechanisms for placement and scheduling of these modules in the on–board unit versus the cloud. The highlight of the proposed design is the ability to offload computation to the cloud in an elastic manner through dynamic decisions during variable network conditions. Through an experimental evaluation using our prototype system we show the effectiveness of the design in reducing the response time for compute intensive applications across variable network conditions in two urban environments.

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.

Proposed Vehicular Dynamic Computation Offloading.To address the offloading challenges in a vehicular system, we design an adaptive cloud–offloading system that incorporates a heuristic mechanism for dynamic resource allocation. The mechanism partitions application into tasks and plans placements of those tasks in OBU or cloud based on variations in network bandwidth, OBU processor cycles availability and policies. In this way, the mechanism tries to identify if a schedule is possible even before applications are to be scheduled at run–time and adapt accordingly based on the planning done through resource allocation. The goal of our offloading system design is to ensure that the response time of embedded vehicular applications are within their stipulated deadlines, where,

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)

  • M. Whaiduzzaman et al.

    A survey on vehicular cloud computing

    J. Netw. Comput. Appl.

    (2014)
  • K. Ha et al.

    Just-in-time provisioning for cyber foraging

    Proceeding of the 11th Annual International Conference on Mobile Systems, Applications, and Services

    (2013)
  • E. Cuervo et al.

    Maui: making smartphones last longer with code offload

    Proceedings of the 8th International Conference on Mobile Systems, Applications, and Services

    (2010)
  • M.S. Gordon 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)
  • A. Ashok 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)
  • A. Ashok et al.

    Adaptive cloud offloading for vehicular applications

    2016 IEEE Vehicular Networking Conference (VNC)

    (2016)
  • M. Azure

    Microsoft Azure Computer Vision API

    (2015)
  • D.G. Lowe

    Distinctive image features from scale-invariant keypoints

    Int. J. Comput. Vis.

    (2004)
  • R.I. Davis et al.

    A survey of hard real-time scheduling for multiprocessor systems

    ACM Comput. Surv.

    (2011)
  • M.-R. Ra et al.

    Odessa: enabling interactive perception applications on mobile devices

    Proceedings of the 9th International Conference on Mobile Systems, Applications, and Services

    (2011)
  • S. Kosta et al.

    Thinkair: dynamic resource allocation and parallel execution in the cloud for mobile code offloading

    INFOCOM, 2012 Proceedings IEEE

    (2012)
  • Cited by (0)

    View full text