The Internet-of-Things (IoT) promises to provide an ever-growing supply of Internet-connected devices that can collect, analyze, and respond to data about their environments. Applications enabled by the IoT include autonomous driving, in which vehicles must detect and avoid collisions with nearby vehicles, and environmental monitoring, in which sensors can collect and display information, such as current noise or ambient temperature levels, about the surrounding environment. Programming such applications, however, often requires specialized knowledge. In particular, many IoT applications naturally involve multiple physical devices, such as multiple sensors or a sensor and a separate server. Coordinating across these devices, then, may require knowledge of distributed systems and networking, particularly if applications must execute in a time-sensitive manner. Ensuring that data from multiple sensors is collected at approximately the same time, for example, may require synchronizing device clocks, which is nontrivial and energy-consuming at fine time granularities. Indeed, many IoT devices are also energy-constrained, which more generally requires application programmers to be aware of the energy consumption of their applications?often not the case, especially if the programmer does not know the specific hardware on which an application will be run. Such specialized knowledge threatens to bottleneck the widespread deployment of IoT programs, by making their development difficult.

TickTalk includes new language, system, network, and device mechanisms for programmers to easily specify and enforce timing constraints. The first part of the project addressed the specific device- and network-level challenge of designing low-power mechanisms for synchronizing clocks on different physical devices. The main insight is to carefully model delays associated with data transmitted between a given pair of devices, which allows this data to be used for synchronizing clocks on these devices. These synchronization methods, which we call LongShoT, allow TickTalk to execute fine-grained synchronization if required by an application.

In addition to clock synchronization, many applications may have deadlines by which they need to be completed. Thus, at the system level, we designed a framework for representing application programs that cleanly slices them into atomic computation units and codifies their timing constraints (e.g., deadlines by which computations should be completed). This representation allows the program to be easily distributed across multiple hardware devices, e.g., across multiple sensors. We further define a protocol for exchanging information between computation units, which carries information about timing constraints and the order in which computations should be executed. Programs written in this framework can then be optimized to meet timing constraints, e.g., by splitting individual computation units across sufficiently fast physical devices. If timing constraints cannot be met, we design fallback mechanisms that detect that the constraint will be missed and instead execute backup code to avoid catastrophic application failure.

Finally, at the language level, we developed an initial prototype of the language mechanisms that has been packaged together and released as TTPython, which runs on Python3. Our language extends the usual Python programming language, allowing programmers to easily specify application timing constraints by adapting their existing Python programs into the TickTalk framework. Once written in TTPython, programs can take advantage of the system, network, and device mechanisms developed to enforce timing constraints in a low-power fashion.

The project additionally facilitated several educational activities. Two courses at CMU made extensive use of low-power synchronization mechanisms developed during the project: one on Wireless Device Architectures and one on Connected Embedded Systems. Five graduate students and one undergraduate student worked on the project over the past three years. The students participated in weekly all-hands meetings as well as individual research meetings with their faculty advisors. Thus, they gained experience in working on a team with diverse backgrounds and managing a large technical project. The public-facing nature of the TTPython open-source release and CPS IoT Week Student Design Competition further trained the students in presenting their research and demonstrating its practical value to a range of audiences.

Last Modified: 02/07/2022
Modified by: Carlee Joe-Wong