.
Book Reviews
Technical Editor: Marcin Paprzycki Dept. of Computer Science and Statistics Univ. of Southern Mississippi Southern Station 1506 Hattiesburg, MS 39406-1506
[email protected]
Book Reviews Building Secure and Reliable Network Applications reviewed by Jon B. Weissman, University of Texas at San Antonio
Building Secure and Reliable Network Applications by Kenneth P. Birman 591 pages $58 Manning Publications Greenwich, CT 1996 ISBN 1-884777-29-5
84
This book attempts to fill a needed gap between the theory and practice of reliable distributed systems. Reliability is a complex problem that includes fault tolerance, security, consistency, availability, and performance. Kenneth Birman has developed two well-known distributed-systems technologies for reliability (ISIS and Horus) and numerous real-world applications, and he brings this wealth of experience into the book. A unique feature of this book is that it presents and evaluates issues and solutions in the context of real applications. Most texts on distributed computing focus on theory or systems, but often do not connect the concepts to applications. Thus, this book is targeted primarily at network-application designers to promote the use of reliability technologies in their applications. Birman uses critical applications, such as airtraffic control and medical-instrument control, to illustrate the importance and difficulty of this problem. As a teaching text, however, the book is a little uneven, with chapter length and complexity differing by orders of magnitude (Birman warns us about this, but this might be difficult for some students). The book has three main sections: basic distributed-computing technologies, Internet technologies (the Web), and reliability. The distributed-computing technologies section covers the spectrum of low-level communication protocols, including IP and IP-multicast, UDP, TCP, XTP, ATM, and recent optimizations, including LRPC, U-net, and Xkernel, up through higher-level client-server and RPC protocols. The overview is very broad, touching on the key features of these technologies. However, some readers might desire a more in-depth discussion of TCPstreams in particular, because the vast majority of Internet technologies (including the Web) depend on it. The author nicely illustrates that “reliable” streams might in fact be
unreliable when connections are broken between clients and primary and backup servers. This simple example sets the context for much of the reliability discussion in subsequent chapters. This section also contains a detailed chapter on object-oriented technologies such as Corba, although it is difficult to tell what is “standard Corba” from the discussion. Nonetheless, object-oriented solutions promise to promote reliability by reducing application complexity. The next section describes the Web, Java, agents, and other Internet technologies. Birman uses the Web to illustrate reliability problems that are central to most complex distributed systems: systems composed of interdependent components can fail (or appear to fail) in many ways. He points out that the Web also reveals the kind of trade-offs that might be necessary: proxies can promote high availability and improved performance, but at the potential cost of consistency. The final section discusses reliability solutions in depth. While replication is the principle means of achieving reliability (along the dimensions of availability, fault tolerance, consistency, and performance), the author presents a rich array of protocols that offer different degrees of reliability. The author begins by distinguishing between static-process groups and dynamic-process groups, in which processes can join and leave dynamically. We learn, perhaps surprisingly, that protocols for static groups (for example, multiphase commit protocols) tend to be more expensive but offer greater consistency. However, protocols for dynamic groups tend to be able to make progress when a majority of processes remain alive. In dynamic groups, the ability to establish consistent group-membership views for all group processes is crucial. Different degrees of consistency are obtained by employing different multicast ordering protocols. IEEE Concurrency
.
Strong consistency can be achieved by atomic multicast with total ordering guarantees, but some applications might not require this. Once Birman has established the machinery of event ordering and membership protocols, he introduces the concept of virtual synchrony. In virtual synchrony, all group members see the same event order and process group views in spite of failures. Interestingly, virtual synchrony can be achieved with asynchronous protocols under a set of assumptions. Birman’s Horus system supports protocols for virtual synchrony and offers a flexible layering scheme to adjust the reliability protocol to the application’s needs. This section also contains a chapter on
techniques for adding reliability to existing applications using wrapper and toolkit technologies. This includes examples of wrapping a TCP connection and Web servers. Finally, this section concludes with a chapter on transactions as an alternative reliability technology. The author correctly points out that transaction systems tend to favor recoverability and consistency over the high availability made possible by process group computing. This section is well-organized and logically structured; however, most readers (even those with a solid background in distributed systems) might need to read the chapters several times. One minor criticism is that, after all is said and done, network application
designers might have trouble sorting out the protocols. One or two detailed case studies from the author’s work might have helped clarify some of the protocol choices and their impact. Readers will likely conclude that reliability is not a binary property. Indeed, reliability must be evaluated on a perapplication basis. Overall, I recommend Building Secure and Reliable Network Applications to designers of real network applications. As for teaching, I cautiously recommend it for a graduate course in distributed systems. It is too large for a single semester, so instructors will have to select chapters carefully. I suggest that instructors cover a few reliability chapters in depth and omit other chapters.
On Concurrent Programming reviewed by Reinhard Möller, University of Wuppertal, Germany
On Concurrent Programming by Fred B. Schneider 473 pages $49.95 Springer-Verlag New York 1997 ISBN 0-387-94942-9
January–March 1998
Fred Schneider uses pointillism, a 19th century style of painting, as a metaphoric description of concurrent systems. This shows the author’s general background and intention. He presents a broad and necessarily abstract view of the versatile field of concurrent processes in all areas of human life and computing. On Concurrent Programming is a fundamental book on the principles and theory of concurrent systems, with an emphasis on the problems of synchronization and communication protocols. It is intended to be a self-contained introductory textbook for first-year computer-science graduate students, but its audience should be more advanced. Readers should have a graduate-level degree and be familiar with the basics of formal logic. The book is a fundamental textbook rather than a source. It can be a valuable supplement for courses on the theory of concurrent programming for advanced students of computer science. The book is fluently written and clearly structured into twelve chapters. Each chapter builds on the previous one, with few cross-references, making the text more accessible. Each chapter finishes with a historical review and bibliography, as well as some exercises. Schneider advises on how to use the book for a dense one-semester course. Chapter 1 introduces the main problems of concurrency and synchronization. Chapter 2 introduces the terms and contents of formal
logical systems, especially propositional and predicate logic. Schneider views logic as a tool, showing how it can formalize safety and liveness. Chapter 3 extends the tools view from predicate to temporal logic. It revises axioms and inference rules and compares temporal logic with other modal logic. It gives a syntax and a set of temporal operators for the treatment of anchored sequences. Chapter 4 concerns the notation and logic for the sequential parts of concurrent programs, which are the basis for the rest of the book. It starts with a Pascal-like syntax definition of the components of a sequential program. Schneider introduces a new type of formula, the proof outline, which extends the axioms of predicate logic with program-variable axioms for reasoning about program states. He uses proofoutline logic to derive preconditions and post conditions for a given program. Generally, the programmer requires a synthesis strategy, rather than program analysis, to generate a running program. For this the author describes any program as a predicate transformer, which derives a true precondition from some selected program fragments and a given postcondition. Chapter 5, on concurrency and interference, extends the knowledge about sequential programs from Chapter 4. Schneider describes the additional necessary semantic constructs for concurrent programming and synchronization and extends proof-outline logic. After formally 85
.
specifying concurrency and introducing control-predicate axioms, he discusses the aspects of interference. Chapter 5 also discusses indivisibility and condition synchronization as the elementary synchronization mechanisms and shows how to use them to avoid interference. Chapter 6 is on invariance and Chapter 7 covers safety properties with past terms. Schneider uses the well-known consumer/producer example to demonstrate that with a proven safety property, some “bad thing” (that is, a deadlock) will not happen during execution. Chapter 7 explains that whether or not a state is considered a bad thing often depends on the system’s preceding states. This chapter extends the predicate-logic techniques of Chapter 6, which can now be used for reasoning about any arbitrary safety properties. Schneider illustrates this with a concurrent reading-while-writing problem, where shared variables are used for communication. The chapter concludes by introducing auxiliary variables. Chapter 8 covers the verification of temporal logic properties. It discusses axioms and inference rules for reasoning about properties specified by arbitrary
temporal-logic formulas, reasoning from fairness assumptions, and techniques for proving eventualities. Chapters 9 to 11 address the problems of mapping the developed formalisms to real hardware, taking into account that only a small, fixed set of unconditional atomic actions can execute on a real computer, extended by some conditional atomic actions from an operating system. In Chapter 9, Schneider introduces a subset of the programming notation developed in previous chapters, which can be easily compiled into fine-grained, unconditional atomic actions. He also discusses some programming techniques based on this subset. Chapter 10 explains the different mechanisms of synchronization on an operating-system level, beginning with semaphores and locks, and concluding with more advanced concepts such as split binary semaphores and conditional critical region synchronization. Chapter 11 addresses the communication mechanisms of distributed systems, using shared objects (that is, communication channels) instead of shared-memory objects. It also discusses synchronous and asynchronous message passing.
Chapter 12, as a conclusion and following the metaphor of pointillism, combines the atomic parts of knowledge (the “dots”) of the previous chapters to obtain the working concurrent program (the “painting”). It discusses aspects of programming languages and tools. The text is often not easily accessible, owing to a lot of abstract formulations, which are hard to understand for newcomers. A glossary of symbols for formal logic notations is necessary, which the book does not contain. Schneider should have avoided the stepwise introduction of a new formal “programming language” by using a common and wellknown programming language such as C or Pascal and extending this by the necessary syntactic and semantic elements. He tests the reader’s understanding with many exercises at the end of each chapter. However, the exercises would have been more beneficial if Schneider had outlined the solutions. On Concurrent Programming does offer a lot of formal methodology for the presentation of assertional methods, making it a solid base for any lecturer in computer science.
An Introduction to Distributed Algorithms reviewed by Svetozar Margenov, Bulgarian Academy of Sciences
An Introduction to Distributed Algorithms by Valmir C. Barbosa 365 pages $40 MIT Press Cambridge, Mass. 1996 ISBN 0-262-02412-8
86
An Introduction to Distributed Algorithms is a new textbook in one of the richest fields of modern computer science. Valmir Barbosa introduces important problems, general approaches, and algorithms while building a theoretical foundation for current distributed-memory systems—such as computer networks, workstation networks, and multiprocessors. He skillfully incorporates some of the newest achievements, recently published in scientific journals and specialized volumes, into the framework of earlier fundamental results. Barbosa organizes the material into two main parts, each consisting of five chapters. The first two chapters briefly discuss message-passing systems and introduce the asynchronous and synchronous models of distributed computations. The general assumption is that a connected graph G = (N, E)—where the set of nodes N is the set of processors and the set of edges E is the set of point-to-point
communication links—represents the distributed-memory system. These chapters introduce general templates for asynchronous and synchronous algorithms and serve as a framework for the presentation of algorithms in the following chapters. Chapter 3 introduces event-based formalism, orders, and global states, systematically treating the topic of computation models for distributed algorithms. Chapter 4 considers the problems of propagating information from one group of nodes to all nodes, providing every node with information on the identifications of all nodes in G and computing the shortest distances between all pairs of nodes. On the one hand, these are basic problems in the field of distributed computing. On the other hand, the algorithms for their solution accurately demonstrate two general approaches: using a preliminary found spanning tree of G and applying the “wave” strategy. IEEE Concurrency
.
Chapter 5 expands the general knowledge of how to construct distributed algorithms. It regards the techniques of leader election, distributed snapshots, and network synchronization as building blocks for this purpose. It derives estimates of the message complexity and the time complexity for all algorithms in Part I. In particular, this chapter illustrates with three general synchronizers the mutual dependence between these two complexities. Barbosa dedicates the final five chapters to a particular class of problems and related algorithms. Chapter 6 builds a framework of algorithmic approaches and tools for stability detection and, more specifically, for detecting deadlocks and the termination of distributed computations. Chapter 7 considers problems closely related to those in Chapter 4. It includes graph algorithms to find minimum spanning trees and a maximum flow in directed graphs. Chapter 8 studies the problems of shearing resources,
considering in particular the classic dining philosophers problem and drinking philosophers problem. These correspond respectively to the cases of ensuring mutual exclusion, when each node accesses one and the same set of resources during the distributed computation, and when the set of resources might vary from one time to the next. The last two chapters of the book discuss program debugging and the simulation of distributed programs and systems. An Introduction to Distributed Algorithms is intended to support a one-term advanced undergraduate or first-year graduate course in computer science or software engineering. Depending on the students’ level of knowledge, the instructor could omit the first two chapters. If preparing a one-term course on distributed algorithms, the instructor might also regard the last four chapters as optional. In addition, the book can be used by computer scientists and software engineers. Professionals who are not
specialists in parallel computing, but who would like some introductory knowledge about distributed algorithms, can also use this self-contained book.The required background is limited to some familiarity with basic graph theory. Every chapter has a section with exercises that can be classified in two groups: direct implementation of the general techniques for a particular case or, for more knowledgable readers, advanced treatment of the topics discussed in the textbook. The book is written clearly and on the appropriate level, and satisfies the need for new and systematic information in the field of distributed algorithms. The bibliography contains 349 titles: 166 published after 1990. Each chapter ends with bibliographic notes indicating the original sources from which the main results were taken. These notes are especially useful for readers who would like to find more detailed information about some of the topics discussed in the book.
Parallel Methods for VLSI Layout Design reviewed by Roman Trobec, Jozef Stefan Institute, Ljubljana, Slovenia
Parallel Methods for VLSI Layout Design by C.P. Ravikumar 195 pages $69 Ablex Publishing Corp. Norwood, N.J. 1996 ISBN 0-89391-828-8
January–March 1998
Very Large Scale Integration makes possible the integration of millions of connected transistors acting as a coordinated complex system on a small silicon area. Today’s technology produces much larger circuits than can be designed and tested automatically. This book introduces the promising possibility that powerful parallel computers, themselves designed with VLSI chips, can implement the automatic design of future VLSI systems; complex systems enable the development of more complex systems. Parallel Methods for VLSI Layout Design presents an interesting application of parallel computing in the field of VLSI design and testing. The book focuses on the physical design of VLSI circuits. At first glance, VLSI physical design appears to be a very specialized area, but studying this book reveals that many methods and a great part of the theory might also be applied to other engineering areas and even to solving many routine problems. The book begins by introducing, with
apropriate terminology, basic concepts of VLSI physical design. Chapter 2 divides the physical design into three steps: logic partition, placement, and routing. It then analyzes the computational complexity of each step. Some readers might find it useful to check Appendix A, which gives basic concepts of computational complexity and graph theory. Chapter 3 presents an overview of parallel architecture and processing. It describes shared-memory and distributed-memory multiprocessors as well as vector processing. For more detailed information, Ravikumar mentions some concrete computer systems and refers readers to Appendix B. This chapter also introduces the Parallel Random Access Machine as a general theoretical model of parallel computing. However, any overview of parallel architectures becomes obsolete soon after publishing; many similar books have the same problem. In this chapter, therefore, Ravikumar should have tested all described algorithms on a set of theoretical parallel architectures similar to those introduced by 87
.
PRAM. The description of contemporary machines and measured results from real computers should have been placed in a separate section or Appendix, which could be updated in each new edition. Chapter 4 discusses the different ways parallel computing helps solve combinatorial optimization problems of the NPcomplete type. Chapters 5 and 6 describe the mappings between architectures and algorithms. They explain that designers might have a parallel computer with a specific architecture available for VLSI design and that the most appropriate algorithm for that architecture should be selected from among all known algorithms, or that a new one should be invented for the available architecture. On the contrary, in very critical applications, designers must develop tailored hardware and select the best algorithms to get maximal performance. Unfortunately, Ravikumar sometimes uses the words “mapping” and “matching” ambiguously in these chapters. Both “matching algorithms to architectures” and “mapping algorithms to architectures” describe the problem of designing special-purpose computers for physical-
design algorithms. It is not sufficiently clear in the above notation what is existent and what is to be developed—the architecture, algorithm, or both. The next three chapters, devoted to parallel algorithms for physical design, represent the book’s core. Chapter 7 considers the parallelization of Kernihhan-Lin and Fiduccia-Mathyeses algorithms for logic-partition problems, whereas Chapter 8 focuses on the parallel circuit-placement algorithms based on iterative improvement, mincut, simulated annealing, and divideand-conquer approaches. Chapter 9 deals with the parallel routing of physical design. It discusses in detail the algorithms based on global or channel routing and Lee routing. Unlike the other chapters, which are self-sufficient, these three chapters require some preliminary background in VLSI design. The unfamiliar reader should read the two introductory chapters to study these essential issues. Chapter 10 enriches the theoretical part of the book and presents a collection of foundations of perfect, interval, and coloring permutation graphs and
their applications to VLSI layout design. The book concludes with Chapter 11, which lists opportunities for further research and introduces new problemsolving methods. There is also an extensive bibliography of recent publications, with author and subject indices for reader convenience. Including a real example from the VLSI physical design of contemporary circuits, along with the measured values for computational complexity, would have improved the book. A few interesting photographs of real VLSI layout designs would be valuable, and I also suggest correcting (for future editions) some small errors in the text and figures and harmonizing the book title on the cover page and in the text. However, Parallel Methods for VLSI Layout Design is well-organized and written clearly. It is self-contained and does not rely on references. The contents are pertinent for graduate or postgraduate students in VLSI design or parallel computing applications. The book might also interest specialists in VLSI practical design or parallel-algorithm designers and programmers.
Java Programming with CORBA, 2nd ed., Andreas Vogel and Keith Duddy, 496 pp., $34.99, John Wiley & Sons, New York, 1998, ISBN 0-471-2465-0.
Francisco, Calif., 1997, ISBN 1-55860434-0.
New Books Client/Server Programming with Java and CORBA, 2nd ed., Robert Orfali and Dan Harkey, 832 pp., $49.99, John Wiley & Sons, New York, 1998, ISBN 0-471-16351-1. Communication Complexity and Parallel Computing, J. Hromkovic, 341 pp., $45.95, Springer-Verlag, New York, 1997, ISBN 3-540-57459-X.
Mining Very Large Databases with Parallel Processing, Alex A. Freitas and Simon H. Lavington, 224 pp., $105, Kluwer Academic Publishers, Boston, 1998, ISBN 0-7923-8048-7.
Dynamics and Control of Distributed Systems, H.S. Tzou and L.A. Bergman, eds., 325 pp., $69.95, Cambridge Univ. Press, New York, 1998, ISBN 0-52155074-2.
Parallel Computer Architecture, David E. Culler, Jaswinder Pal Singh, and Anoop Gupta, 850 pp., $69.95, Morgan Kaufmann, San Francisco, Calif., 1997, ISBN 1-55860-343-3.
Great Ideas in Computer Science: A Gentle Introduction, 2nd ed., Alan W. Biermann, 568 pp., $37.50, MIT Press, Cambridge, Mass., 1997, ISBN 0-26252223-3.
Principles of Database Query Processing for Advanced Applications: Multimedia, Object-Oriented, and Distributed/Heterogeneous Databases, Clement Yu and Weiyi Meng, 600 pp., Morgan Kaufmann, San
88
Software Agents, Jeffrey M. Bradshaw, ed., 450 pp., $40, MIT Press, Cambridge, Mass., 1997, ISBN 0-262-52234-9. Tetrobot: A Modular Approach to Reconfigurable Parallel Robotics, Gregory J. Hamlin and Arthur C. Sanderson, 200 pp., $115, Kluwer Academic Publishers, Boston, 1998, ISBN 0-7923-8025-8. Using PLAPACK, Robert A. van de Geijn, 224 pp., $27.50, MIT Press, Cambridge, Mass., 1997, ISBN 0-26272026-4. Verification of Sequential and Concurrent Programs, 2nd ed., K. Apt and E. Olderog, 368 pp., $44.95, Springer-Verlag, New York, 1998, ISBN 0-387-94896-1. IEEE Concurrency
