Customer Reviews

Garbage Collection: Algorithms for Automatic Dynamic Memory Management

5 star:		(8)
4 star:		(1)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

Garbage collection is a very interesting and complicated topic. To understand different garbage collection algorithms, one has to go through various research papers published over last 30 years or read the simplified descriptions presented in Java site and Bill Venners artima.com. This book does an excellent job in putting together all these algorithms in a logical order that gives us a chance to understand the different challenges sceintists and programming language authors faced and how the algorithms evolved over the time. The book starts with basic overview and history of commonly known algorithms: Reference counting, Mark and Sweep, and Copying algorithms. It then elaborates each of these algorithms, enumerates their pros and cons, and presents imporvements done by different researchers. After this, the book moves on to advanced algorithms like Generational algorithm and concurrent mark and sweep algorithm. I recommend this book to anyone interested in garbage collection. I haven't seen any other book on this topic. Even for programmers who mostly don't have to worry about GC as it is "automatically" done, this is a good book to understand and appreciate what goes on behind the scenes. Also, knowledge of the concepts in this book will be invaluable in performance tuning.

This is really a great book. It's really a must have for people who want to write their own modern virtual machine (like I).

This is simply the only book about Garbage Collection you can get. It's very complete: all GC Algorithmes are covered by this book in depth! All topics are properly introduced it has a nice layout, and offer snippets of pseudocode. It is not really a dry text.

If you want to read scientific papers about Garbage Collectors (like of ACM), it's recommended to read first this book, to get a proper introduction in this topic.

This book is superb. It is thorough enough that there is little need for a practitioner to read the primary literature, even when contemplating sophisticated garbage collector designs. I remember being intimidated by garbage collection prior to reading this book, but now I am instead enthralled by garbage collection. Given the trend toward automatic memory management in programming languages, I think this book is an increasingly important part of the practicing programmer's library.

The first time I read the book, it seemed a bit repetitive, because the first two chapters provide the basic framework for the rest of the book. As a result, topics such as copying collection are discussed in at least two places. Upon reflection though, I think that there is no better way to organize the book, because there exists no straight path through all of the concepts the book covers.

Over the past eight years I have read portions of this book over and over as I've contemplated garbage collector designs for various software projects. I continue to be surprised at just how well this book meets my needs.

I'd bought this book for personal reading. Even though I'm not directly into GC algos, I found this book amazingly lucid to read and follow. It has thorough coverage of all the GC algos I've heard of till date.

It goes about explaining the algos with a very broad level view, then goes a little deep, then deeper, so its very easy to follow, and the reader can decide to what extent (s)he wants to understand the algo.

A must have for anybody directly working on GC, or like me, people who develop high performance systems on GC aware languages/platforms. It can help you extract the most out of your platform.

For the complete review, see the Sept '97 issue of Doctor Dobbs, or look online at: http://www.ercb.com/ddj/1997/ddj.9709.html

This is the most thorough and readable tract I could have imagined on the complicated subject of GC. It has an excellent introductory chapter, then a survey chapter on the different algorithms, then some in-depth chapters on each algorithm and their many variants, trade-offs, and histories, all copiously referenced to scholarly literature, and each wrapped up with issues to be considered, and then goes on to special topics, such as concurrency. It uses no particular computer language to describe the details of its algorithms, preferring pseudo-code, which I think is a major benefit. It was easier to me to see what was going on without all of the baggage of language syntax. Every term is defined clearly, and there is a good index and glossary. I can't overstate how well-written it is from a purely English point of view.

While it has had a few minor updates from its original 1996 publication, I would have liked to see a much more extensive refresh. At the time it was published, garbage collection was not mainstream. Java was very new, so the examples, references, and studies refer almost exclusively to functional languages such as Lisp and ML (which require GC to be usable), and to antiquated hardware. Everything in the book is still as relevant now as it was in 1996 (meaning the final draft was probably submitted in 1995, if not earlier), but with Java and .NET in ascendance for over 10 years now, and 64-bit multicore processors with *megabytes* of L2 and even L3 cache now in mainstream personal computers, it would have been even better for me if there were more attention to concurrency now that it is the norm. I could probably count on one hand the number of times the x86 (let alone the x86-64) was mentioned. Scholarly publications on GC did not end in 1996 either.

In conclusion, this is a must-read if one is looking for a well-written, very solid basis in the options for algorithms for GC and the trade-offs of each. The authors spoiled me. They did such a great job laying out the results of so much research for me up to 1996, it just made me wish they could take me all the way to the cutting edge of variants and studies as nicely. The bright side, though, is that after reading this book, I have I've been able to understand anything I've found online since, be it scholarly papers, reference manuals, etc. on this topic, so it succeeded in what I wanted it to do when I ordered it.

I wanted to know about the generational algorithm that Java is now using. The book was pretty clear about how things work. I haven't read the whole book but what I've seen is very encouraging. The first few chapters are a broad overview and then you can dive into the particular algorithm you are interested in.

The book is so well written and easy to understand its worth buying it even you only read the first two chapters.

I am student at Computer and Automatic Faculty of Bucharest