M. Ben-Ari
PRINCIPLES OF CONCURRENT AND DISTRIBUTED PROGRAMMING, 2/e
Soft cover pp. 361, plus XV
Addison Wesley, Harlow England, 2006
ISBN 0-321-31283-X

In general about the book

Impressive advances in computer architectures during the last forty years, coupled with growing availability of parallel and networked computers, have led to a new style of computing, called concurrent programming. This style allows multiple computations to occur simultaneously in cooperation with each other. The term concurrent computing refers to simultaneous execution of multiple interacting tasks, while concurrent program is one defining actions that may be performed simultaneously. These tasks may be implemented as separate programs, or a set of processes or threads created by a single program. The tasks may also be executed on a single processor, several processors in close proximity, or distributed across a network. In general, there are two classes of concurrent programming: Distributed programming refers to computations that do not share a common memory, and parallel programming refers to computations that share a common memory. Concurrent programming languages are programming languages that use language constructs for writing concurrent programs for both shared- and distributed-memory machines. These constructs may involve support for distributed computing including message passing, remote procedure call and rendezvous, and support for shared variable programming including processes and synchronization, semaphores, and monitors.

This book identifies the major concepts of concurrent programming and describes the crucial language notations for writing concurrent programs. It contains thirteen chapters, five appendices, a Bibliography and an Index. The book is organized as follows.

Chapter content

Chapter 1 (What is Concurrent Programming?, pp. 1- 6) introduces the concept of concurrent programming, explains the terms multitasking, multithreading, multiple computers, and points to the challenges of concurrent programming.

Chapter 2 (The Concurrent Programming Abstraction, pp. 7- 43) concentrates on concurrent program abstraction as the interleaved execution of atomic statements. Details concerning how concurrent programs can be written using a concurrency simulator, a programming language, or simulated with a model checker are given.

Chapter 3 (The Critical Section Problem, pp. 45- 66) covers the critical section as part of a process which must not be executed concurrently with a critical section of another process. In a step-by-step manner the concepts of solving the critical section problem for two processes, including the first-, second-, third-, and forth-attempt, as well as the DekkerXs algorithm are presented.

Chapter 4 (Verification of Concurrent Programs, pp. 67- 92) covers the verification of concurrent programming. The discussion begins with the specification of correctness properties such as inductive proofs of invariants. At the end, the Spin model checker and its language Promela, used for program verification, are described.

Chapter 5 (Advanced Algorithms for the Critical Section Problem, pp. 93- 106) studies two advanced algorithms for the critical section problem, the bakery and fast algorithms, both developed by Leslie Lamport.

Chapter 6 (Semaphores, pp. 107- 144) discusses the concept of semaphores as a versatile but low-level process synchronization tool, typically used with shared memory. Chapter 7 (Monitors, pp. 145- 178) covers monitors as program modules used as mechanisms for encapsulating shared variables and specifying functions which must be used to access the shared variables.

Chapter 8 (Channels, pp. 179- 178) describes how processes communicate by sending messages to each other through channels, and explains how channels enable us to construct decentralized concurrent programs that do not necessarily share the same address space.

Chapter 9 (Spaces, pp. 197- 210) discusses the presentation of different models of concurrency and focus on algorithms appropriate for distributed systems that communicate by sending and receiving messages.

Chapter 10 (Distributed Algorithms, pp. 211- 235) presents several algorithms of crucial importance for solving the critical section problem. The main themes discussed here relate to distributed mutual exclusion, Ricart-Agrawala algorithm, token-passing algorithms, and tokens in virtual trees.

Chapter 11 (Global Properties, pp. 237- 256) presents algorithms for two problems that can be characterized as detecting and recording global properties of distributed systems.

Chapter 12 (Consensus, pp. 257- 283) describes three different algorithms for achieving consensus, The Byzantine Generals algorithm, the King algorithm, and the flooding algorithm.

Chapter 13 (Real-Time Systems, pp. 285- 315) covers the principles of concurrency in real-time systems. The main topics discussed here are with operation of synchronous systems, asynchronous systems, interrupt-driven systems, priority inversion and priority inheritance, and scheduling algorithms for real-time systems.

Five appendices accompany the text of the book. Appendix A presents the pseudo-code notation, Appendix B deals with mathematical logic that is used to state correctness properties and to prove that a program or algorithm has these properties. Appendix C contains a list of problems to be solved by writing concurrent programs. Appendix D gives an overview of software tools used to studying concurrent and distributed programming. Appendix E suggests additional material (textbooks, papers and Websites) useful for further reading.

Useful for students

Concurrent and distributed programming is becoming increasingly important because multi-computer architectures, particularly networks of microcomputers are rapidly becoming attractive alternatives to traditional supercomputers. The main intent of this book is to introduce important basic techniques that are of practical values to those who intend to write programs for modern real-time computer systems. The style of presentation is clear. The book is timely and well written. Its organization is good and the depth of each subject covered if adequate. The book can be used as a textbook for undergraduate and graduate students in electrical Engineering, Computer Engineering and Computer Science. Also it should be a useful and valuable reference for practicing engineers, system engineers, researchers, anyone interested and active in the field of designing and programming concurrent and distributed real-time computer systems. All in all, I highly recommend this book.