Browse Books

Reviewer: Michele Mazzucco

As the clock speed of central processing units (CPUs) does not increase because of heating issues, chip manufacturers are fitting more and more transistors in the same space. Hence, while exploiting parallelism is already important in the context of grid and cluster computing, it is also gaining momentum in low-end workstations, because of the widespread adoption of multicore architectures. The book is organized into two parts: "Principles" (of concurrent programming, chapters 2 to 6) and "Practice" (chapters 7 to 18). It is rich in examples and code snippets written in Java. Following an introduction to the subject (chapter 1), chapters 2 to 4 discuss very basic topics, such as the producer-consumer problem, critical sections, the sequential consistency memory model, the Java memory model, and the single-writer/single-reader algorithm and its variants. The reader who is familiar with concurrent programming can skip these. Chapters 5 and 6 introduce the consensus problem in a concurrent environment, and show some nice wait-free algorithms to solve it. The second part introduces more advanced topics and is far more interesting. The introduction in chapter 7, "Spin Locks and Contention," states that while it is safe to ignore the "underlying system's architecture details" when writing sequential programs, the same does not apply to concurrent algorithms. Given that all of the examples provided are implemented using Java, I disagree with that, as the Java Virtual Machine hides all the differences. Hence, obeying the Java memory model guarantees that the program will work as expected. The authors also discuss two approaches to the mutual exclusion problem-spin locking and busy-waiting-and present the second alternative as "expensive" (the thread needs to be suspended and later resumed) and viable only if the lock delay is expected to be "long." While busy-waiting is certainly more expensive than spin locking, its performance has improved over time. Also, "expensive" and "long" are very abstract terms-it would have been very helpful if some benchmarks had been provided. Various lock implementations are introduced and discussed throughout the chapter, including those that use some building blocks introduced in the first part (such as Peterson's algorithm) and various versions of the "Test And Set" model. Having introduced the basic algorithms for spin locking, the second part of the chapter discusses more advanced algorithms based on queue locks, and concludes with some sophisticated algorithms for composite and hierarchical locking. Chapter 8 introduces the monitor abstraction, a structured way of combining data and the synchronization of that data, with the semaphore probably being the most popular implementation. The synchronization tools discussed in chapters 7 and 8 are commonly known as coarse-grained synchronization. Chapters 9 to 11 move to a higher level of abstraction, by offering thorough discussions of more advanced techniques, such as lazy and nonblocking synchronization. The authors always follow the same pattern-they start with the easiest (and worst-performing) algorithm, discuss it, and point out its shortcomings; then, with successive refinements, they end up presenting the best solution. In chapter 9, they implement a nonblocking concurrent set (that is, a collection that contains no duplicates) using a linked list; in chapter 10, they implement various types of concurrent queues using a linked list; and, in chapter 11, they implement a concurrent stack that is not inherently sequential, even though both push() and pop() work at the top of the data structure. Having shown how to build concurrent basic data structures (lists and sets), the authors present some sophisticated algorithms for different classes of problems, such as (concurrent) counting, sorting, hashing of collections, search, and queues with priority (chapters 12 to 15). Next, the authors discuss, in chapter 16, practical issues such as thread pools and data structures for load distribution and balancing purposes. Chapter 17 covers the last of the synchronization primitives, the barrier, presenting various implementations for dealing with different problems. While most of the arguments above are already well known, chapter 18 discusses a topic that is gaining momentum: transactional memory and how to effectively program it. Herlihy and Shavit introduce the topic by summarizing the problems affecting conventional synchronization primitives, the first one being that it is very difficult to manage them effectively, especially in large-scale systems. Hence, transactional memory comes to the rescue. The idea behind this approach is very similar to the one regarding ordinary transactions (that is, they can be aborted if a conflict arises); the difference is that the changes are made to the local memory. Various algorithms for programming software transactional memory are discussed, and the chapter concludes with some remarks about hardware transactional memory. Overall, the book reads well. The first part covers very basic topics, which are found in many other books, and can be skipped by the reader who has some concurrent programming experience. The second part deals with advanced topics and is very interesting. The book can also be used as a reference, as it has plenty of code for concurrent algorithms. Online Computing Reviews Service

Reviewer: Burkhard Englert

Developing efficient software for multicore processors is a challenging endeavor. In order to be able to increase performance, such software must exploit the parallelism offered by these architectures. This requires the software developer to have a deep understanding of all issues related to asynchronous concurrent computation and the underlying hardware. This outstanding book addresses these challenges head on. I sincerely hope that it will find its way into the curriculum of many undergraduate and graduate institutions, and become required reading in many companies. Over the last few years, multicore processor architectures have become the new front line in the quest to further increase the speed of processors. In a multicore architecture, multiple processors communicate through shared hardware caches. The resulting multiprocessor chips make computing more effective, by exploiting parallelism where multiple processors work on a common task. Why is multicore programming an art__?__ Multicore architectures require a totally new set of skills from software developers. On a single core processor, software speed increases on its own, every time processor speed increases. This is not the case with multicore architectures, since developers must understand the limitations and strengths of the underlying multicore architecture, in order to be able to truly exploit parallelism. The book familiarizes the reader with these strengths and limitations, and provides a collection of shared objects and programming tools. The book is divided into two parts. The first part, "Principles" (chapters 1 to 6), is theoretical. It familiarizes the reader with what can actually be computed in an asynchronous concurrent environment-the multicore world. This question needs to be answered before actual programming begins, to avoid attempting to solve unsolvable problems. After an introduction in chapter 1 that nicely illustrates the problem, chapter 2 discusses solutions of the mutual exclusion problem and their limitations. Chapter 3 does the same for concurrent objects. Chapter 4 discusses shared memory register and snapshot constructions. Chapter 5 considers what is needed to solve a given synchronization problem-namely, consensus-and chapter 6 explains the universality of consensus-that is, it justifies the focus on consensus in the preceding chapter. Part 2, "Practice" (chapters 7 to 18), focuses on performance. Unlike the sequential case in which developers can take advantage of well-understood abstractions, in a multiprocessor setting, a developer must often be aware of the underlying memory system to be able to maximize performance. Chapter 7 discusses spin locks and contention. Chapter 8 covers monitors and blocking synchronization. Locking is explained in chapter 9, with an example of linked lists, while concurrent queues and the ABA problem are the topics of chapter 10. This is followed by discussions of concurrent stacks and elimination (chapter 11); counting, sorting, and distributed coordination (chapter 12); concurrent hashing (chapter 13); skip lists and balanced search (chapter 14); priority queues (chapter 15); scheduling and work distribution (chapter 16); barriers (chapter 17); and transactional memory (chapter 18). Throughout the book, concepts are illustrated with Java examples and Java-based programming exercises. The book concludes with a useful appendix that familiarizes the reader with the Java language constructs needed to understand the Java code examples and write concurrent programs in Java. A second appendix introduces the reader to the multiprocessor hardware architecture. Overall, this excellent book does a real and urgently needed service to the community. It is very well organized, and it allows interested readers, students, and professional to explore first hand the underlying principles of multicore programming. At the same time, it enables its readers-now armed with a solid theoretical foundation-to become multicore programmers, and helps them maximize the performance of these architectures. To be successful as a multicore programmer, one must be constantly aware of the strengths and, even more importantly, the limitations of these architectures. The authors never hide from the readers or trivialize the resulting difficulties. They also do not shy away from rigorous proofs-the reader is expected to have a certain mathematical maturity, especially in the first part of the book. At the same time, difficult concepts are illustrated with clear and concise examples. The book is written in a way that makes multiprocessor programming accessible. It deserves to become a classic. Online Computing Reviews Service