Cameron Hughes and Tracey Hughes
Parallel and Distributed Programming Using C++
Hardcover, pp. 691, plus XXV, $ 43.99
Pearson Education, Inc., Boston, 2004
ISBN 0-13-101376-9
http://www.pearsoneduc.com

In general about the book

For over two decades we are witnesses of an explosive growth in system performance and capability of computer systems. Doubtlessly, nowadays, numerous advances in computer communication technologies have revolutionalized our modern society. The use of computers in managing information and automation has become an integral part of our daily life. Systems with multiple computers/processors operating together on a single problem and connected through communication channels to facilitate information sharing and cooperative work are commonplace. In essence, multiprocessor machines allow different application programs to execute at some time on different processors. But parallel and distributed processing requires coordination of cooperative activities among processes executing on physically distributed processors and resources. Two crucial aspects concerning programming of parallel and distributed systems now appear. The first relates to how does one synchronize the activity of concurrent processes, while the second, how can one use multiple processors to make an application run faster?

This book gives a broad view of the more important aspects of parallel and distributed programming and points how to build software that can take advantage of multiprocessor computers.

Chapter content

The material in this book is divided into thirteen chapters, two appendices, a Bibliography with 51 entries, and an Index. The book covers the following subjects:

Chapter 1 (The Joys of Concurrent Programming, pp. 1-20) involves concurrency and points to benefits of using parallel and distributed programming.

Chapter 2 (The Challenges of Parallel and Distributed Programming, pp. 21-36) gives a brief overview of the most common challenges to parallel and distributed programming. In addition some details concerning selecting a good architecture and techniques for testing and debugging are processed.

Chapter 3 (Dividing C++ Programs into Multiple Tasks, pp. 37-98) focuses on the notion of a process and how C++ programs can be divided into multiple processes. The main topics discussed here relate to process states, process scheduling, context switching, creating and terminating a process, process resources, asynchronous and synchronous processes, and dividing the program into tasks.

Chapter 4 (Dividing C++ Programs into Multiple Threads, pp. 99- 189) deals with dividing a single program into concurrently executing parts called threads. Interesting details concerning thread scheduling, thread resources, thread models, managing threads, thread safety and libraries, and dividing program into multiple threads are presented. Chapter 5 (Synchronizing Concurrency between Tasks, pp. 184-214) covers synchronization mechanism that is to coordinate the order of execution of concurrent tasks. Two types of synchronization, data (access synchronization) and task synchronization (sequence synchronization) are described.

Chapter 6 (Adding Parallel Programming Capabilities to C++ Through the PVM, pp. 215- 253) involves the Parallel Virtual Machine (PVM) library for C++. In addition the basic mechanisms of the PVM, and accessing standard input (stdin) and standard output (stdout) within PVM tasks are discussed.

Chapter 7 (Error Handling, Exceptions, and Software Reliability, pp. 254-279) concentrates on software reliability. Exception handling mechanisms in C++ are discussed too.

Chapter 8 (Distributed Object-Oriented Programming in C++, pp. 279-328) focuses on distributed programming and shows how programs can be executed in different processes. CORBA as a standard for distributed object-oriented programming is involved.

Chapter 9 (SPMD and MPMD Using Templates and the MPI, pp. 329-356) deals with implementations of simple program multiple data (SPMD) and multiple programs multiple data (MPMD) models of concurrency using templates. The implementation of the message- passing interface (MPI) is discussed.

Chapter 10 (Visualizing Concurrent and Distributed System Design, pp. 357-402) presents details related to visualization and modeling concurrent and distributed system using the UML. Diagramming techniques used to visualize and model concurrent systems from the structural and behavioral properties are explained.

Chapter 11 (Designing Components that Support Concurrency, pp. 403-458) introduces interface classes that are used to modify or enhance the interface of another class or set of classes. The main topics discussed here relate to object-oriented mutual exclusion and interface classes, maintaining the stream metaphor, user-defined classes, and framework classes' components for concurrency.

Chapter 12 (Implementing Agent-Oriented Architectures, pp. 459-498) deals with agent- oriented programming. Basic agent components are identified. Implementation of agents in C++ and multi-agent systems are discussed.

Chapter 13 (Blackboard Architectures Using PVM, Threads, and C++ Components, pp. 500- 537) introduces the Blackboard model as an approach to collaborative problem solving. Implementation of blackboard using CORBA objects is described.

Two appendices are accompanied at the end of the text. Appendix A provides a quick reference to the UML diagrams used throughout the book, while Appendix B covers system interfaces.

Useful book

The main purpose of this book is to present the basic principles for parallel and distributed programming. In order to efficiently manage the complexity of parallel and distributed programs object-oriented programming with C++ is used. The book formulates and analyzes numerous aspects, methods and techniques that may significantly improve understanding the concepts of distributed systems.

This book is very timely, well written, easy to read and informative. Its organization is excellent, the presentation of material is quite clear and the depth of each chapter covered is adequate. The book should be of considerable interest for computer programmers, researchers, software architects, and advanced undergraduate/beginning graduate students of computer science. Anyone seriously interested in programming of parallel and distributed systems will benefit from reading this book. Overall, the authors have done a commendable job and the book does largely meet it stated goals. Having in mind the above mentioned, I highly recommend this book.