Parallel Computing Books

I have most of the parallel computing books out there so I am sort of a collector of sorts. Most focus on either the basics of parallel programming, MPI, OpenMP, both, or some other less popular (yet) paradigm e.g. PFortran, TBB, etc. With every parallel-computing wanna be buying a multicore machine dual, quad, dual-quad, etc., the parallel computing software "industry" is in flux. No longer will MPI on a cluster be enough. It still remains to be seen whether the slower memory bus on quad core machines will allow for speedups without major code overhaul or a new paradigm. Anyway, this book is a welcome addition to my collection. For one, it is current e.g. 2008 and also it is focussed on OpenMP (but does treat dual MPI/OpenMP programming). It is well written (I am about 100 pages in since I just got my copy last week) and has one tantalizing chapter entitled "How to get good performance by using OpenMP" - which is really timely since my new 72 core machine (9 dual Intel quad cores) seems to give slower performance for a major commercial CFD code than the equivalent number of dual-core nodes). I hope it helps me. Based on the rapid growth of multicore machines and the lack of a simple programming solution, I recommend this book to all those wanting to try and get their codes running fast on multicore machines. The only downsides in this book so far is the lack of downloadable code (you have to type it in yourself) and it is hard to test the code fragments because they are just that - fragments. A nice feature of the book is the 50/50 emphasis on Fortran/C codes - which are the still the mainstay in large-scale scientific computing.

This book provides answers to questions on threading that have confused me for a long time:
1. Why use a thread pool and why not?
2. How expensive are synchronization, thread creation and concurrent collections?

It clears up a lot of myths and rumors I have heard.

Before I bought this book, I had to prototype threading examples in my own workspace, setting up race conditions and such, but it was a lot of work and left a lot unexplained.

Scott Oaks, the author, did a good job of describing the synchronization process and the various Object methods relating to threading protocol. There were plenty of good examples, and clarification on several minor technical points including: how the wait/notify methods release monitors, the determinability of prioritization, and the practical uses of threadgroups. If you have nagging questions, you may find them answered here.

O'Reilly books are small-sized, which makes for easy carrying and storage. Little if any of their content is redundant or inaccurate. Given how dry the material is, O'Reilly astounds me by consistently finding authors who can write well, have something to say, and whose works can be read in a sitting.

Of course, it's important to mention that some things have changed since the first edition of this book. Methods like resume(), suspend(), and stop() have been deprecated due to their unpredictablity; the JVM will now enable programmers to address multiple processes; and there are a variety of classes which facilitate thread administration. A newer edition will bring you up to speed on those details, but this first edition is still a valid reference in all other respects.

Obviously your first read on Java should be "Concurrent Programming in Java(TM): Design Principles and Pattern" by Doug Lea. If this does not completely satisfy you this might be a possible second read on the subject. This book has a somewhat different perspective that it is closer to the classes and more distant to the principles. Here it delivers a good groundwork.

Review Date: Dec 2004.

Please Rate the overall value of the book from 1-5 where
5=Well done! This book will be a valuable teaching and reference tool.

Please rate the instructional value of the book from 1-5 where
5=Excellent! An essential book on this topic.


Please rate the reference value of this book from 1-5 where
4=This book has earned a valued place on my reference shelf.


This is a book for Java programmers of all proficiency levels; the book also provides information for

advanced users of Java. the book uses J2se 5.0 version of the compiler - and explains the

improvements in the threads implementation in this version of java.

the book is a well written book with a gradual introduction to the various aspects of thread

implementation and a detail study of the subject. the authors delves into various of aspects of

thread implementation such as creation, management, data synchronization, notification, scheduling,

pooling, performance, parallelizing loops, and other IO functions.

there are sample codes through out the book and the codes make no assumption about the skill level of

the reader. this is a good thing. there are enough diagrams to explain the threading concepts.

overall, this is an excellent book for readers interested in concurrent programming. i will use it as

a reference when i need and i have no hesistation in recommending this book to other java programmers.

<< Review of the 3rd Edition >>

This book is written for developers who are targeting the second wave of java programs - Intermediate to advanced level programmers will be able to get best value out of this book. Developers who are already familiar with the basics of java may also be able to get some value, but if you are completely new to java, please look elsewhere.

Without any futher ado, i will dive right into the deep end of the pool. This book is partitioned into 4 logical sections, though it is not explicit in the TOC.

1. Important Threading Concepts:
In this section, the author prepares us with the fundamentals of creating and managing a thread, basic synchronization concepts, synchronized keyword, lock mechanism, thread communication using wait-notify and condition-variables, minimal synchronization using volatile keyword and atomic variables, advanced synchronization classes like Barrier, Semaphore, CountdownLatch, etc. Chapters 1 through 6 underwrite this section and this is by-far the best part of the book.

2. Thread Pools/Schedulers:
This section first lectures around how thread scheduling materializes in java and how it is related to the underlying Operating System. Next, you are guided through a tour of Thread Pools and Task Schedulers that will enlighten us with quite a few new classes in java 5. Chapters 9 through 11 cover this section.

3. Threading and other Java APIs:
This section details how the threading API plays with other inbuilt java APIs like Collections, IO and Swing. Chapters 7,8 and 12 cover this section.

4. Misc topics:
Some miscellaneous thread topics like ThreadGroup, Security, Class Loading, Exception Handling and Performance are addressed in this section. Chapters 13, 14, and 15 cover this section.

Though this book wasn't an easy read, i found it extremely encouraging to have ONE comprehensive manual to understand both the threading concepts and the new java 5 inclusions. I recommend this book to anyone who is in the middle of a complex multi-threaded system or wishes to create one.

The title was ever so promising. But when I finally got to use this book,my disappointment was limitless.I found myself having to be on the lookout for errors of all sorts instead of learning from the book.While the book is in the 600s in the number of pages,it is rather thin on content on the topics that it covers. Take Chapter 4, "Dividing C++ Programs into Multiple Threads" for instance.The authors do a lot of hand waving explaining what is essentially threads in C (behind some little C++ syntax),and just when you are hoping to learn about threads in the presence of composition (as you might need with nested parallelism) or inheritance, you are met with section 4.11.5 "Creating Multi threaded Objects" that is only one and half pages long and tells you nothing you did not know already. The authors then proceed to add more than hundred pages in the form of appendix B on material that you can get off the internet.I've since decided to use Intel TBB (and bought Intel Threading Building Blocks by Reinders) for my project. With POSIX threads here to stay and parallel programming becoming mainstream,the authors ought to use subsequent editions as opportunity for great improvement.

I think that the book is quite good. However, do not look architecture level concepts, neither mathematics, neither an explanation of distributed and parallel concepts (well, there is something...). The title shoudl be something like "C++ tools for distributed and parallel programming"

However, this is the only book I know that introduces the biggest amount of tools in other to implement distributed applications in C++ (in case you do not want to start from sctach). Of course, there are missing thinks like web services, sockets, peer2peer middlewares, etc. However, the explained packages are the most used in the market.

This book is a collection of many topics about MPI, PVM, Pthread, UML, CORBA, etc. None of them explains thoroughly. All the parts don't have coherence and don't have a complete example about parallel and distributed application. Readers would be better off just Google these topics and will find free documents which are far better than this book. It wastes your money to buy this book.

Even the bad reviews here are too kind. What can I say about this book? Let us start with Chapter 7, which is about exceptions and error handling -- as applied to parallel programming you'd think. But there is nothing about parallel programming and nothing good about exceptions in this chapter, which reads like a blog written by a C++ programming beginner who has just stumbled upon exceptions and thought, hey this is cool, nothing of the sort in Fortran, let me write about it.

Section 9.2 talks about using template functions for parallel programming. Their examples are of the sort: (if rank is 0, let us call the multiplies() fn that is templated on int; if rank is 1, let us call the multiplies() fn that is templated on double). What were these people smoking?

Section 9.3 overloads stream operators (<<,>>) to do MPI send/recv. This is bad design because the rank of the other process (for one) is an input to the MPI functions, so there is a stream class per other process - which is more messy than convenient. A better design would be to make a communicator class with send(), recv() fns taking the other rank as input. This would also support collective (gather, scatter) communication. Not to mention *unbuffered* MPI send/recv calls can be terribly slow, so there should be some buffering support.

This brings to my basic gripe about this book: it is incredibly shallow. Of course it is garbage to an expert, but even to the dullest of beginners it can be of little use. Just about anything that you can find on parallel programming or C++ is better than this.

I gave it 3 stars only because there are few books on the subject; it deserves only 2.

The main problem I see with this book is that it tries to cover too much ground, even with subjects that it should not touch upon: there are whole chapters (7 and 9, for example) that are more about C++ than parallel or distributed programming, and one chapter (10) is about UML. Although it is interesting to see C++ and UML techniques applied to parallel and distributed programming, this leaves little space left for the coverage of MPI, for example. PVM and pthreads are given somewhat more attention, but still not nearly enough.

Another problem is that the examples are mostly incomplete code fragments. There are few complete, running examples. I hoped to see bigger examples in the last chapters (they seem like case studies), but again they are made of too much "talk" and no code.

The chapters are mostly independent of one another; it can be good if all you need is a quick first read on one of the subjects, but it gets annoying if you try to read it sequentially. Exercise for the reader: count how many times the PRAM model is cited AND explained.

To say something good about it, the book has some nice general musings about the nature and fundamental problems of concurrent systems. But it is not a coherent whole and is not particularly good at explaining any of the myriad subjects it touches upon.

Bottomline: It's neither an applied book about specific technologies, nor a general treatment. I would not buy this book unless it were very cheap. Take a look at it at the bookstore or borrow from a library, but don't spend your money.

To people wanting a general treatment about concurrency, it's principles, problems and solution space, I recommend "Concepts, Techniques and Models of Computer Programming" by Peter van Roy and Seif Haridi. It's thoroughly educational, and half of it is about concurrency (but no specific treatment of pthreads, PVM or MPI).

Hi friends, I am an E-commerce consultant in silicon valley , I can say only one thing about this book - This is a terrific book.

First, this book is based upon information prior to August 1995. (There is a reference in the book to something that is to happen by August 1995.) The 1996 publish date is (IMHO) somewhat misleading. Their treatment of OLE/COM is partisan, but probably valid as of the date it was written. (See Understanding ActiveX and OLE for more current information.) Apparently Micro$oft agreed with some of the authors' objections, since some of the more objectionable parts of OLE have been changed. For example, ODL is out; enhanced IDL is in. All in all, it's a very good intro to CORBA/OpenDoc for people unfamiliar with the nonproprietary industry standard for distributed objects (like me). I'm glad I bought it, but I am searching for a better description of whatever it is in CORBA/OpenDoc that corresponds to Custom Controls (now known as ActiveX controls). Maybe I'm dense, but I missed it. I read this book after having read Understanding ActiveX and OLE. I'm glad I read these books in that order; I would have been mightily confused about OLE if my introduction to it was via The Essential Distributed Objects Survival Guide.

I knew I was in trouble when even in the first pages the authors never bothered to parse the acronyms that form the subject of this "Essential" guide. For example, CORBA and OLE remained useless clusters of letters until much further in the book.

My apprehension was confirmed as I delved deeper and the mists of this cute but uselessly-cartooned book grew ever more thick.

I've no doubt that these guys know their business. There were more buzzwords flying around in the first few paragraphs than Martians have saucers. Unfortunately, like a few too self-absorbed college profs. I once knew, they don't know how to teach.

If you really want an ESSENTIAL guide, grope in the dark a little further for a better explanation. This book won't help very much.

Orfali, Harkey & Edwards are some of the most influential leaders in the distributed object field. This book is highly readable, and does something that few comprehensive books do: present the technologies in a sufficient manner for both managers and programmers. Their biases are very clear throughout the book: they're rooting for CORBA/OpenDoc.. Which reflects the age of the book. Unfortunately OpenDoc looks to be lost, while CORBA continues to still be used by industry. They treat OLE (ActiveX) like a second-class component model. (It's up to you to decide if it really is :) However, this book will get you "there" faster than any other, with good sprinkles of Oliver Sims' Business Object work, and Taligent's Commonpoint technology (the concept of which may become our future computer user-interface..) A Must read!

I found this book to be full of unintelligible jargon. If you don't already know what it means, don't expect to find out here. I'm tired of books like this. Is it so very difficult to start from the beginning and write clearly? *** It's not just the failure of the authors in a case like this -- what about the editors? It's their job to make sure that an ordinary, intelligent reader can understand an "introductory" text like this. Did *they* even understand it? *** Maybe CORBA is superior to COM (or maybe not) - but I'll tell you one thing: David Chappell's "Understanding ActiveX and OLE" is a model of how to do this kind of book *right*.

Anyone brave enough to install vers 1.0 of any Microsoft product understands the absence of substantial documentation/literature accompanying the release. Mr. Lee's book adeptly fills this gap. While his book is very much worth the purchase price, his postsale support has truly been appreciated !

If you are currently running MSCS, you may find this book useful. Otherwise, look elsewhere.

This book is invaluable to me for it's section on troubleshooting. Believe me, when you have trouble with your cluster, this is likely the only place you will find an answer, or perhaps a glimmer of a clue, without calling Microsoft and getting their so called engineers (more like web-knowledge-base users) some more job security.

The section on clustering is good for a primer/refresher, and the installation section should ONLY be used as a guide in understanding why MSCS works. I would not recommend creating your first (or any) cluster with this section. You should KNOW how to create your cluster before doing so. DO NOT depend on a book to hold your hand on creating your cluster. LEARN this stuff any way you can, then when armed with sufficient understanding and skills, go for it.

I found the book to be of some use in my particular situation. It is a step above the manual that comes with the MSCS product. It has what I think is a serious error. Under "Mastering the Cluster Administrator", the author states that you can "Add or evict nodes from the cluster" with the Cluster Administrator. You can evict nodes, but you cannot add them back. You have to re-install the cluster software on the node to add it back to the cluster. Not fun. If you have no experience with MSCS this book can be of help.

Having 'played' around with MSCS for 1 year now on NT4 I'm still looking for good sources of reference for this technology, and unfortuneatly this is not it! In a lot of cases his explanations are very basic, and a lot of his examples don't make sense, and in some cases have serious errors. There is also far too much information that is not relevent to MSCS (have 32 pages of a registry dump with little explanation is not very useful!) After waiting months for this book to appear I was disappointed at the content, particularly when it turned up without the CD

I recently purchased the above book, somewhat in desperation, as I was detecting conflicting information regarding the installation and configuration of MS Cluster Server (MSCS.) Unfortunately, I made a poor choice in purchasing the book. What the author skimped on was the actual installation of MSCS.

While there isn't room to detail every omission here, the most serious of blunders occurs during his step by step install procedure where he mistakenly tells the reader that the MS Cluster installer is asking for the IP address of the NT workstation that will administer this cluster. This is in fact the IP address of the Cluster itself. This is a serious mistake and will result in the reader giving the IP address of another NT workstation to the Cluster which will ultimately cause an IP conflict.

Personally, I would recommend reading the MS documentation several times rather than this book

[A review of the 2nd edition.]
The authors give a mathematically sophisticated analysis of various modes of distributed computing. Where the distribution might refer to separate CPUs in a multiprocessor architecture, or perhaps to separate computers inside a LAN, or to computers scattered across the Internet.

We see that issues of latency and reliability can [and will] arise. Coordinating a task across the processors gives rise to amazing complexity. What if some processors crash? A consensus problem occurs. How to solve it is explained.

There are also impossibilities in task solving that might occur, and these need to be treated carefully. The narrative has suggestions on how to diagnose if such events happen. The reader will see that fault tolerance can be awkward to handle.

The treatment may be too mathematical for some readers. You need a strong background in maths; preferably including discrete maths.

This is a good book in the field of distributed computing, but it is very mathematically oriented. It concentrates on impossibility proofs and lower bound proofs. I advise people new to this material to read a more descriptive book before reading this one

I've struggled to read this text, since it contains many very recent results distilled into intelligently organized chapters. Unfortunately, even though this book is intended for a savvy audience, the text is often too detailed and technical, while important "big picture" intuition is never relayed. Frequent errors in the algorithms and proofs, ranging from simple subscript swaps to more subtle errors in logic to the (rarer) complete lack of logic make this a difficult book to recommend. In addition, the exercises are frequently too vague (sometimes meaningless) -- this book is definitely not recommended for class work.

I used this book for teaching an under-graduate primer course in distributed computing. The book is readable, coherent, well-structured and very efficient as a textbook. It strikes a good balance between the sea of details and the basic principles. I am familiar with the core of this book since it was a collection of lecture notes (alas, no longer available). It's a pity that some important topics have been omitted from the book version (e.g., Gallager, Humblett, Spira alg). There are some minor errors and imperfections in pseudocodes and exercise definitions which are a little bit annoying. That's why I'm giving this book four points and not five. Bottom line: I would recommend this book as a course textbook.

I have gone through this book and I did not like it. Look's
like Michi's book is the best so far.

This book is clearly a reference, and research material rather than a hands-on programming guide. While there are many code fragments to support the authors' explanation of concepts, and the largest single chapter is on CORBA programming there is no single project built throughout the book as is often the case in programming guides. I much prefer this approach of being a reference rather than building a project. For example, code or diagrams illustrate things such as SII, DII, DSI, IFR, Exceptions and Any, which gives a competent programmer enough to experiment with the various bits of CORBA. For implementation using BOA, some good diagrams show implementation option using the TIE approach, handy for Java, which has single inheritance. It would be useful though to have some code fragments of a POA implementation in this section.

The book has three parts. The first part covers the basic foundation concepts of distributed computing showing how different distributed technologies (eg RMI, DCOM, RPC) need to find solutions to the same issues.

Parts 2 and 3 give an in-depth look at distributed systems and CORBA with much to study. The role of object adaptors is explained and the POA architecture is compared to the better-known BOA. This is well diagrammed, again some POA code would help. This is where the book becomes more than a programming book and a serious study of CORBA features, such as Naming Service, Trading Service, Event Service and Query Service. Additionally there is a detailed discussion of performance and consistency issues with a CORBA Caching implementation. This for me was the most interesting part of the book. Object caching in a distributed environment gives you much to think about, and clearly much thought has been put into the issues, such as scalability, cache consistency, object eviction etc. Other issues such as distributed transaction services including 2PC and 3PC are well covered.

Detailed discussion of CORBA services and distributed systems is not trivial reading, but rather for serious study. I notice that Douglas Schmidt has written the foreword. His name is well known to anyone that reads CORBA research material, which gives confidence to the quality of material.

In Summary, this is not a simple programming book. There is no downloadable code or CD and apart from some early OrbixWeb examples is not specific to any ORB implementation. It is a serious look at issues of distributed object systems with a heavy emphasis on CORBA and would be recommended for anyone interested in further study of distributed object systems. There are exercises at the end of each chapter, but there are no answers found in the book, it would be helpful to have them available in a later version of the book or on a web site.

I am pleased to find a book on distributed objects systems. this book has given me the needed information that i have been looking for in the field of transaction processing systems. it does cover CORBA to a great level given the reader the chance to see some solutions and the independency of programming languages. i believe it can be used as a text book in the field of Object-Oriented Design or programming where students can aplly either JAVA or C++.

The book is divided into three parts: Basics of CORBA, Advanced CORBA, and CORBA Services. Part one gives an intro to distributed systems and CORBA, including a bit of CORBA programming (in Java). Part two talks about object adapters, interoperability, and caching. Part three covers naming, trading, event, transaction, and query services.

Unfortunately, there is a lot to criticise about this book.

On the editorial side, you get a shocking job: it is plain that no copy editor or proof reader has ever been near this work. Spelling and grammatical errors abound, as well as inconsistent use of fonts; the index is put together without any great care.

The writing style is mostly poor. The prose is often stilted or redundant, uses obtuse phrasing, and is full of vague descriptions. Terms such as "usually", "in general", and "typically" are used liberally and, more often than not, are followed by descriptions that are imprecise or vague, leaving the reader wondering whether the authors properly understand what they are trying to explain. More seriously, in many places, the authors are unable to take the reader step by step through a topic. Often, the discussion veers off to something that is completely irrelevant, making it difficult for the reader to develop a clear mental picture of how things hang together. The presentation of IDL is intermingled with (poor) explanations of language mapping issues, leaving a tangled and incomplete mess.

The book doesn't describe a particular version of CORBA but appears to be largely based on the authors' experience with OrbixWeb. This means that much of the book talks about a now obsolete and proprietary BOA implementation. (Given that POA implementations have been available for more than two years, it is beyond me why anyone would publish a book based on the BOA in 2001.) The POA is covered as well, but in such confused language that it is difficult to understand what the POA is or how it really works. Little or no guidance is provided as to how to use the POA effectively for a given a set of implementation requirements.

Much of the material has been provided in more correct and accessible form elsewhere, and little in this book is original. Of great concern is the authors' apparent lack of knowledge of CORBA; the book contains many errors. Some choice examples:

- CORBA has no support for late binding.

- CORBA [...] supports the types "Any" (for fixed type length) and "DynAny" (for variable type length).

- IDL identifiers must be declared in lower cases. [sic]

- An example of nested declaration is found in the module CORBA: module org { module omg { module CORBA { /* ... */ }; }; };

- enum ParamMode { IN, OUT, INOUT };

All these statements are plainly incorrect; the book contains many more such mistakes.

The coverage of CORBA services is equally disappointing, with incomplete, sloppy, and superficial explanations that are hard to follow.

The book was written as a textbook for use at universities; I pity the students who will have to answer exam questions based on this material.

This is a very high level view on the subject of HA, as previous reviewers state. It does present some basic guidlines at the system, network, and operational level which in my experience are so basic and intuitive, that I wonder why the author needs to state in "Special techniques for system realiability", that you should purchase from reputable supplies and even to recommend not to use shareware and freeware ? In general for a CEO or Manager who knows nothing on HA, this book is for you. This is a non technical brief, and its undenable shortcomings are its lack of coverage on recent hardware and software based clustering, cashing and load balansing technologies in the market now, specifcally related to e-commerce applications, middleware and CMS tools which now incorporate many HA features. Additionally, its lacks clear focus with hardly any case studies or real worl examples, and the primary examples of HA in the defintion of the author are client server related hardware technologies such as RAID, redundant NIC's and clustering examples.

A must read book for all IT Tycoon Wannabe.

You cannot judge a book by its cover in most cases. This book's cover, however, subtly provides clues about what's inside. The picture is a panoramic view of Hong Kong taken from Victoria Peak. It accurately portrays the book, which is a high-level view of a wide number of topics related to high availability. If you are expecting nuts-and-bolts technical information, then you are better off purchasing Blueprints for High Availability. If you want a "how to" book that blends a specific technical approach with processes you should look at Mission Critical Systems Management. However, if you want a book that provides a clear set of processes, takes a business case approach, and touches on most of the issues associated with high availability, then this book is what you are looking for.

Like Hong Kong, where realities are in the eye and mind of the beholder, the book can be viewed as addressing either high availability or service level management. In fact, the book uses service level management as the driving force behind achieving high availability.

Included in the panoramic view of high availability are the many issues and factors that need to be understood in order to achieve high availability. It starts out with reasons why high availability is important, and quickly segues into factors, such as total cost of ownership (the treatment is pretty close to what GartnerGroup has been peddling since the early 90s). It does cause one to get back to basics and consider that a high availability solution has a lot of hidden costs.

The book goes through the process chain needed to develop a business case for high availability (one of the book's strong points, in my opinion), through implementation of the solution itself. If you are familiar with other books in this series you will recognize the pattern. Unlike the companion books, though, this one does not contain contradictions or have glaring gaps in the processes. The authors have thought this one through and have the writing skills to make it readable and understandable.

The treatment of service level management is highlighted by a chapter on user availability. If you are in IT you should read and take to heart this section. User availability is a key component of aligning IT to business. The complex and myraid political issues in Hong Kong sometimes seem trite compared to the political issues that surround aligning these two factions. The authors, like seasoned China watchers, provide insights about how to understand the seemingly inscrutable players and sage advice on hot to achieve consensus among the two opposing factions.

Another area that impressed me was the attention paid to facilities as a key component of high availability. Although this was a high level view, it can serve as a checklist of considerations as you are developing the business case for high availability. There was one missing fact that I wish the authors would have highlighted: compliance with fire and safety regulations and local building codes. I have seen cases where well designed solutions that were supported by excellent processes and sound management were compromised by failing a regulatory inspection. Imagine explaining to a CEO why the multimillion dollar investment in people, process and technology failed because an inspector shut down a mission critical data center because of a building code violation.

There is some token attention paid to the technology at the end of the book where high availability features are examined for specific products. Among the products covered are Windows 2000, Novell Netware, Solaris 8, AIX and OS/400. Also covered are various hardware platforms, such as S/390, AS/400, RS/6000 and Compaq Proliant server, and Oracle 8i availability features.

Bottom line: This book is about processes. It complements and augments Blueprints for High Avalability by wrapping a sound approach to making a case for, and implementing, high availability. It is also a great companion to Mission Critical Systems Management, again by providing complementary processes to the approach taken in that excellent book.

I wish the authors had summarized the issues and factors in an appendix of checklists, but other than that, this book is a solid addition to any service delivery library.

This is a very high level view on the subject of HA, as previous reviewers state. It does present some basic guidlines at the system, network, and operational level which in my experience are so basic and intuitive, that I wonder why the author needs to state in "Special techniques for system realiability", that you should purchase from reputable supplies and even to recommend not to use shareware and freeware ? In general for a CEO or Manager who knows nothing on HA, this book is for you. This is a non technical brief, and its undenable shortcomings are its lack of coverage on recent hardware and software based clustering, cashing and load balansing technologies in the market now, specifcally related to e-commerce applications, middleware and CMS tools which now incorporate many HA features. Additionally, its lacks clear focus with hardly any case studies or real worl examples, and the primary examples of HA in the defintion of the author are client server related hardware technologies such as RAID, redundant NIC's and clustering examples.

One would have thought from the title of the book that it would contain "... Parallel Genetic Algorithms", however it does not. The book covers statistical analyses of algorithms. The reader is meant to find other references that contain algorithms. It is expensive for such a small book. The author talks 'around' the algorithms, without going into the necessary details to write your own parallel genetic algorithms. There are many plots of evolution, so the author must of had access to the algorithms. This book could have been so much more valuable if it contained the algorithms, rather than just talk about them.

I think the previous reviewer got it wrong: It is very clear from the editorial introduction and from the table of contents that this book is about the ANALYSIS of parallel genetic algorithms, not about their implementation. The problem here is that implementing these algorithms is relatively easy, but configuring them is very complicated because there are many parameters. The work of Cantu-Paz---excellently summarized in this little book---is the best analysis available for the different types of parallel genetic algorithms.

I recommend this book wholeheartedly.

Genetic algorithms are easy to parallelize, but they are difficult to control. In a very concise manner, this book presents some theoretical results derived by the author that show how to make parallel genetic algoritms work for many problems and different architectures.

The book has a lot of new theory that is easy to follow and gives recommendations to make parallel genetic algorithms work well in many circumstances. Although the theory makes many simplyfying assumptions, the examples in the book demonstrate that the models are very accurate and the recommendations made in the book seem very reasonable.

There is a good effort by the author to bring this book. I am sure this is helpful for research and development in the field of High performance Cluster computing.

I am very happy and proud to say that this author is my classmate and very good friend of mine.

Sreekanth

I used the two books as part of a course which I taught at IIT Delhi during July-Dec 1999. The course was called "Special Topics in Computers" and was credited by Masters students from the Departments of Electrical Engineering and Computer Science. The idea behind the course was to introduce elements of Distributed and Clustered Computing to students who have already got some background in Computer Architecture. In my opinion, a single course in Computer Architecture at the Masters level cannot do justice to the developments that have taken place in this exciting field over the past decades. I have been teaching Computer Architecture at IIT Delhi for about 8 years now and find that the number of topics that I have to include in the course has been increasing very quickly over the years! In 1992, when I first taught the course, I used to teach about Pipelined Computers, Systolic Arrays, SIMD array processors, and Multiprocessors. As time has passed, it has become necessary to include topics such as high-performance interconnection networks, wormhole routing, cache coherence protocols, instruction pipelines, superscalar processors, and instruction-level parallelism. More recently, I have realized that it is also necessary to teach elements of distributed computing and clustered computing. I believe that a course on selected topics from distributed and clustered computing is essential to all branches of Engineering today.

Ø High-performance computing is essential to all branches of Engineering, and high-performance clustered computing on clusters of workstations/PCs makes a lot of economical sense.

Ø A course such as this is interesting because it is easy for the students to practice what is taught in such a class without too many infrastructures. This makes the course very exciting to students. When I taught parallel algorithms in my class, I could not ask my students to develop these algorithms for lack of good infrastructure. But a cluster of workstations and PCs is available in almost every University today.

Ø Distributed computing is highly popular with students. Students are eager to learn Java and network programming.

Rajkumar Buyya's edited volumes have arrived at the right time to provide the right kind of teaching material for the type of course which I have mentioned above. The first volume covers architectural and system-level issues of clustered computing systems. It has 36 chapters organized into 4 sections, spanning 811 pages. Section I develops the motivation for high-performance clustered computing. Section II introduces various networking protocols and I/O mechanisms that are useful in clustered computing. Section III covers OS issues such as process scheduling and load balancing. Section IV includes a number of case studies of existing systems. The editor has made a considerable effort in gathering learning material for the volume. I think that this volume could be an excellent text for an advanced course on Computer Architecture. In the course that I taught, I used parts of Section I and IV. To me, the second volume proved more useful.

The second volume concerns with applications of clustered computing and applications programming. It is divided into 3 sections. There are 29 chapters that span 604 pages. Both volumes have carefully prepared Glossaries and Indexes. The first section of the second volume is on various programming environments and development tools. Although I limited myself to the discussion of the Parallel Virtual Machine (PVM) and Message Passing Interface (MPI), the editor has also included entire chapters on linking of these two environments, active objects, component-based approach, LiPS, and WebOS. There is a chapter of debugging parallelized code that can be highly valuable for students and developers of applications. The second section is on Java for high-performance computing. These topics raised a lot of interest among students when I taught the course. The third section is on specific algorithms and applications such as parallel genetic algorithms, parallel simulation, distributed database systems, graphics and image processing. The authors who have contributed to the two volumes are all known experts in the areas of Computer Architecture, Computer Networks, Distributed Computing, and Operating Systems. The authors and the editor must be congratulated on this extraordinary effort to compile so much useful material under one place. The books can not only serve as reference material to professional programmers in the modern IT industry, it can also serve as excellent teaching material for courses related to Computer Architecture, Distributed Computing, and Operating Systems. The web page that the editor has created for the book is also a wonderful repository of learning material available on the web. I recommend these volumes wholeheartedly to all serious researchers and students interested in the areas of high-performance computing in general and clustered computing in particular.

C.P. Ravikumar Professor, Department of Electrical Engineering, Indian Institute of Technology, Delhi

This books is utter rubbish : edited by Buyya and NOT written by Buyya. It's simply a compilation of research articles written by different authors.

Rajkumar buyya has written ONLY the first introductory chapter, so his knowledge about the subject is seriously questionable.

On the top of that in the entire book, there's no coherence or focus at all. It simply wanders from one author to another researcher.

I am teaching at a university in Master's program, and I regret having purchased the book.

If you're not sure of what I've written, simply go thru' the index and you'd find different authors.