Jan L. A. van de Snepscheut

The sliding-window protocol revisited

We give a correctness proof of the sliding-window protocol. Both safety and liveness properties are addressed. We show how faulty channels can be represented as nondeterministic programs. The correctness proof is given as a sequence of correctness-preserving transformations of a sequential program that satisfies the original specification, with the exception that it does not have any faulty channels. We work as long as possible with a sequential program, although the transformation steps are guided by the aim of going to a distributed program. The final transformation steps consist in distributing the actions of the sequential program over a number of processes.

Distributed sorting

of its two neighbors per iteration, but with both (as long as necessary). The other diierence is that our algorithms are smooth in the sense that the execution time is much less for almost-sorted arrays than for hardly-sorted arrays, with a smooth transition from one to the other behavior. This is due to the conditions under which processes engage in communications.

Inversion of a recursive tree traversal

A recursive algorithm for generating the prefix and infix traversaCls of a binary tree is inverted to obtain an algorithm for constructing the tree from its traversals.

A Distributed Implementation of a Task Pool

In this paper we present a distributed algorithm to implement a task pool. The algorithm can be used to implement a processor farm, i.e., a collection of processes that consume tasks from the task pool and possibly produce tasks into it. There are no restrictions on which process consumes which task nor on the order in which tasks are processed. The algorithm takes care of the distribution of the tasks over the processes and ensures load balancing. We derive the algorithm by transforming a sequential algorithm into a distributed one. The transformation is guided by the distribution of the data over processes. First we discuss the case of two processes, and then the general case of one or more processes.

Weakest Preconditions for Progress

Predicate transformers that map the postcondition and all intermediate conditions of a command to a precondition are introduced. They can be used to specify certain progress properties of sequential programs.

Recursive Descent Parsing

We have encountered grammars a number of times. We started our discussions of what a computation is by looking at grammars. We defined languages by devising grammars for defining them. We translated right-linear grammars into transition graphs and then into VLSI circuits. In this chapter, we study programs for parsing input strings, that is, programs that determine whether a given input string can be derived from a given grammar. In the case of right-linear grammars, we had a severe restriction on the grammar: every rule has a left-hand side of exactly one nonterminal and a right-hand side of a sequence of zero or more terminals followed by at most one nonterminal. This restriction corresponds to finite machines. In this chapter, the restriction is less severe. The left-hand side is still restricted to be one nonterminal but the right-hand side is unrestricted. This class of grammars is called the class of context-free grammars. Later on, we have to impose further restrictions to admit efficient parsing algorithms; in fact, we discuss only one parsing strategy. This strategy is called top-down parsing. We give an implementation in the form of a set of recursive procedures, and then the parsing method is sometimes referred to as parsing by recursive descent. This method is limited to grammars that satisfy the LL(1) condition, which is discussed later. We begin by discussing the parsing method in the context of the domino game, and we have a look at its implementation in the form of a set of recursive procedures. We explore the theoretical limitations, and we discuss ways of improving the practical feasibility of this method.

A Collection of Nice Algorithms

We develop an algorithm for drawing a straight line on a raster. The algorithm is known as Bresenham’s algorithm.

What Is Computing All About

We begin our explorations of what computing is all about by studying a game. It’s a one-person domino game, so it is a little boring, for there is no opponent to beat. This version of the domino game is played with three differently configured pieces, each of which is available in unlimited quantity. The three pieces are as in Figure 1.1.

An Example of a Compiler

This chapter contains an example of a small compiler that compiles programs written in a subset of Pascal into instructions for a stack machine, plus a program that acts like the stack machine. The latter is called an interpreter for the stack-machine.

The Construction of a Processor

In this chapter, we study the construction of a microprocessor, using the circuitry developed in Chapter 5. A microprocessor is a large circuit, and designing a large circuit involves many of the complexities of designing a large program. We try to steer clear of most of those issues and provide only a rough sketch of the circuit.