Scott M. Pike

The suitability of kinesthetic learning activities for teaching distributed algorithms

Kinesthetic learning is a process in which students learn by actively carrying out physical activities rather than by passively listening to lectures. Pedagogical research indicates that kinesthetic learning is a fundamental, powerful, and ubiquitous learning style. To date, efforts to incorporate this learning style within the computer science curriculum have focussed on introductory courses. Material in upper-level courses, however, can also benefit from a similar approach. In particular, courses on distributed computing, by the very nature of the material they cover, are uniquely suited to exploiting this learning technique. We have developed and piloted a collection of kinesthetic activities for a senior undergraduate or graduate-level course on distributed systems. We give detailed descriptions of these exercises and discuss factors that contribute to their success.

Wait-free dining under eventual weak exclusion

We present a wait-free solution to the generalized dining philosophers problem under eventual weak exclusion in environments subject to crash faults. Wait-free dining guarantees that every correct hungry process eventually eats, regardless of process crashes. Eventual weak exclusion (◊WX) actually allows scheduling mistakes, whereby mutual exclusion may be violated finitely-many times; for each run, however, there must exist a convergence point after which live neighbors never eat simultaneously. Wait-free dining under ◊WX is particularly useful for synchronization tasks where eventual safety is sufficient for correctness (e.g., duty-cycle scheduling, self-stabilizing daemons, and contention managers). Unfortunately, wait-free dining is unsolvable in asynchronous systems. As such, we characterize sufficient conditions for solvability under partial synchrony by presenting a wait-free dining algorithm for ◊WX using a local refinement of the eventually perfect failure detector ◊P1.

Eventually perfect failure detectors using ADD channels

We present a novel implementation of the eventually perfect failure detector (⋄P) from the original hierarchy of Chandra-Toueg oracles. Previous implementations of ⋄P have assumed models of partial synchrony where point-to-point message delay is bounded and/or communication is reliable. We show how to implement this important oracle under even weaker assumptions using Average Delayed/Dropped (ADD) channels. Briefly, all messages sent on an ADD channel are privileged or non-privileged. All non-privileged messages can be arbitrarily delayed or even dropped. For each run, however, there exists an unknown window size w, and two unknown upper-bounds d and r, where d bounds the average delay of the last w privileged messages, and r bounds the ratio of non-privileged messages to privileged messages per window.

Crash fault detection in celerating environments

Failure detectors are a service that provides (approximate) information about process crashes in a distributed system. The well-known “eventually perfect” failure detector, ◊P, has been implemented in partially synchronous systems with unknown upper bounds on message delay and relative process speeds. However, previous implementations have overlooked an important subtlety with respect to measuring the passage of time in “celerating” environments, in which absolute process speeds can continually increase or decrease while maintaining bounds on relative process speeds. Existing implementations either use action clocks, which fail in accelerating environments, or use real-time clocks, which fail in decelerating environments. We propose the use of bichronal clocks, which are a composition of action clocks and real-time clocks. Our solution can be readily adopted to make existing implementations of ◊P robust to process celeration, which can result from hardware upgrades, server overloads, denial-of-service attacks, and other system volatilities.

A collection of kinesthetic learning activities for a course on distributed computing: ACM SIGACT news distributed computing column 26

Kinesthetic learning is a process where students learn by actively carrying out physical activities rather than by passively listening to lectures. Pedagogical research has indicated that kinesthetic learning is a fundamental, powerful, and ubiquitous learning style. It resonates with many students across all disciplines and levels of education. The adoption of kinesthetic approaches in college classrooms, however, has been hampered by the difficulty of designing effective activities, as well as the perceived challenges of coordinating these activities. On the other hand, courses on distributed computing, by the very nature of the material they cover, are uniquely suited to exploiting this learning technique. We have developed and piloted a collection of kinesthetic activities for a senior undergraduate or graduate-level course on distributed systems. We give detailed descriptions of these exercises and discuss factors that contribute to their success (or failure). Our hope is that others will adopt these particular activities in their own distributed systems courses as well as use these examples as a pattern for developing new activities.

Eventually k-Bounded Wait-Free Distributed Daemons

Wait-free scheduling is unsolvable in asynchronous message-passing systems subject to crash faults. Given the practical importance of this problem, we examine its solvability under partial synchrony relative to the eventually perfect failure detector diamP. Specifically, we present a new oracle-based solution to the dining philosophers problem that is wait-free in the presence of arbitrarily many crash faults. Additionally, our solution satisfies eventual k-bounded waiting, which guarantees that every execution has an infinite suffix where no process can overtake any live hungry neighbor more than k consecutive times. Finally, our algorithm uses only bounded space, bounded-capacity channels, and is also quiescent with respect to crashed processes. Among other practical applications, our results support wait-free distributed daemons for fairly scheduling self-stabilizing protocols in the presence of crash faults.

The weakest failure detector for wait-free dining under eventual weak exclusion

Dining philosophers is a classic scheduling problem for local mutual exclusion on arbitrary conflict graphs. We establish necessary conditions to solve wait-free dining under eventual weak exclusion in message-passing systems with crash faults. Wait-free dining ensures that every correct hungry process eventually eats. Eventual weak exclusion permits finitely many scheduling mistakes, but eventually no live neighbors eat simultaneously; this exclusion criterion models scenarios where scheduling mistakes are recoverable or only affect performance. Previous work showed that the eventually perfect failure detector (◊P) is sufficient to solve wait-free dining under eventual weak exclusion; we prove that ◊P is also necessary, and thus ◊P is the weakest oracle to solve this problem. Our reduction also establishes that any such dining solution can be made eventually fair. Finally, the reduction itself may be of more general interest; when applied to wait-free perpetual weak exclusion, our reduction produces an alternative proof that the more powerful trusting oracle (T) is necessary (but not sufficient) to solve the problem of Fault-Tolerant Mutual Exclusion (FTME).

Traditional assignment considered harmful

Data movement in nearly all modern imperative languages is based on a single primitive: traditional assignment. (With traditional assignment, data are moved between variables by copying.) Unfortunately, traditional assignment poses many known software engineering drawbacks with respect to efficiency for value types, and with respect to modular reasoning for reference types. Moreover, its entrenched legacy has stifled serious regard of potentially superior data-movement primitives. Exploration of the complete design space for data-movement primitives supports the following conclusions: (1) traditional assignment is fundamentally flawed, and (2) any other data-movement primitive would be better.

Crash-quiescent failure detection

A distributed algorithm is crash quiescent if it eventually stops sending messages to crashed processes. An algorithm can be made crash quiescent by providing it with either a crash notification service or a reliable communication service. Both services can be implemented in practical environments with failure detectors. Therefore, crash-quiescent failure detection is fundamental to system-wide crash quiescence. We establish necessary and sufficient conditions for crash-quiescent failure detection in partially synchronous environments where a bounded, but unknown, number of consecutive messages can be arbitrarily late or lost. Without a correct majority of processes, not even the weakest oracle for fault-tolerant consensus, ⋄W, can be implemented crash quiescently. With a correct majority, however, the eventually perfect failure detector, ⋄P, is possible. Our ⋄P algorithm is correct in all runs, but improves performance via crash quiescence in any run with a correct majority. We also present a refinement of our ⋄P algorithm to mitigate the overhead of achieving crash quiescence; the resulting bit complexity per utilized link is asymptotically better than or equal to that of non-crash-quiescent counterparts.

Brief announcement: failure detectors encapsulate fairness

Fairness is a measure of the number of steps a process takes relative to other processes and/or messages in transit. We argue that failure detectors encapsulate fairness. As evidence, we specify models for fairness-based message-passing systems that are the weakest to implement the Chandra-Toueg failure detectors from [1].