Safety-critical services to support smart self-driving vehicles.
As a smart car drives itself on a highway or in a city, it combines on-board intelligence (based on GPS, video and lidar data, maps it holds, etc) with downloaded information from the cloud to make decisions: is it safe to drive at 55mph for another 15 seconds?
Are there any objects in motion around me that could cross my trajectory, and if so when? Am I approaching any sort of obstacles? Should I plan for a turn, or a lane change, or prepare to exit the thruway?
The quality of this decision making process depends in obvious ways on the quality of the cloud computed data the car downloads. In fact, with large numbers of smart cars, the cloud becomes a natural repository for their shared knowledge base: the tree down
on the road that one car swerved to avoid can be plotted on a map and the map update shared with other cars, so that they will shift left well in advance. They can share knowledge of congestion, lane closures, and a whole range of useful information that my
vehicle can then use to plan its own driving decisions.
For this project, we would like you to think through the design of a service capable of hosting the kinds of data smart cars might need to share, and then to implement a scalable, strongly secure, consistent and fault-tolerant solution. The project is a hard
one in part because it is very open ended. You'll need to make your own decisions, but these questions may help you plan your approach:
- What properties will your service need to offer? Is it dangerous to offer inconsistent data, or is it so important to offer a quick response that doing so might be beneficial even if correctness is impacted?
- You'll probably conclude that the answer for the first question depends on what the data is and how it will be used. What sorts of data will you focus upon?
- If the fleet of cars using the device gets large, what aspects need to scale?
- Focusing now on a specific query, like "what objects are nearby?", how would you represent data so that such a query can be answered in a scalable, parallel, fault-tolerant way? Assume for this example that the associated data is rapidly evolving
(e.g. there might be streams of GPS updates for the various objects tracked by the system, and it would be answering such a query based on data that could have changed just fractions of a second ago).
- What strategy will you use to scale the data out? How will the computational aspects of the server scale?
- How does this "map" to the group communication model and primitives that Vsync offers?
As you move to implement your system, split the aspects up cleanly:
- What functionality belongs in the client, or perhaps in a client-hosted library?
- What can be cached on the client?
- What aspects belong in the service?
- How will you represent the data the service tracks?
- How will you perform updates? Reads?
- How will you repair the state of a recovering server?
- What will fault-tolerance mean in your solution, and how will you provide the desired property?
- Are there ways in which the client platform should sense and react to faults, so that the server doesn't have to provide every aspect of failure handling?
The answers will guide you both to an implementation and to a testing strategy. Be careful to measure the performance of your solution and to try and understand what aspects of the design limit performance and scalability.