Vous voulez voir cette page en français ? Cliquez ici.

Have one to sell? Sell yours here
Tell the Publisher!
I'd like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Efficient C++: Performance Programming Techniques [Paperback]

Dov Bulka , David Mayhew
4.1 out of 5 stars  See all reviews (14 customer reviews)

Available from these sellers.


Save Up to 90% on Textbooks
Hit the books in Amazon.ca's Textbook Store and save up to 90% on used textbooks and 35% on new textbooks. Learn more.
Join Amazon Student in Canada


Book Description

Nov. 3 1999 0201379503 978-0201379501 1
Demonstrates the potential of C++ to produce highly efficient programs. Reveals practical, everyday object-oriented design principles and C++ coding techniques that can yield large performance improvements. Focuses on combining C++'s power and flexibility with high performance and scalability. Softcover. DLC: C++ (Computer program language).

Customers Who Bought This Item Also Bought


Product Details


Product Description

From the Inside Flap

If you conducted an informal survey of software developers on the issue of C++ performance, you would undoubtedly find that the vast majority of them view performance issues as the Achilles' heel of an otherwise fine language. We have heard it repeatedly ever since C++ burst on the corporate scene: C++ is a poor choice for implementing performance-critical applications. In the mind of developers, this particular application domain was ruled by plain C and, occasionally, even assembly language.

As part of that software community we had the opportunity to watch that myth develop and gather steam. Years ago, we participated in the wave that embraced C++ with enthusiasm. All around us, many development projects plunged in headfirst. Some time later, software solutions implemented in C++ began rolling out. Their performance was typically less than optimal, to put it gently. Enthusiasm over C++ in performance-critical domains has cooled. We were in the business of supplying networking software whose execution speed was not up for negotiation--speed was top priority. Since networking software is pretty low on the software food-chain, its performance is crucial. Large numbers of applications were going to sit on top of it and depend on it. Poor performance in the low levels ripples all the way up to higher level applications.

Our experience was not unique. All around, early adopters of C++ had difficulties with the resulting performance of their C++ code. Instead of attributing the difficulties to the steep learning curve of the new object-oriented software development paradigm, we blamed it on C++, the dominant language for the expression of the paradigm. Even though C++ compilers were still essentially in their infancy, the language was branded as inherently slow. This belief spread quickly and is now widely accepted as fact. Software organizations that passed on C++ frequently pointed to performance as their key concern. That concern was rooted in the perception that C++ cannot match the performance delivered by its C counterpart. Consequently, C++ has had little success penetrating software domains that view performance as top priority: operating system kernels, device drivers, networking systems (routers, gateways, protocol stacks), and more.

We have spent years dissecting large systems of C and C++ code trying to squeeze every ounce of performance out of them. It is through our experience of slugging it out in the trenches that we have come to appreciate the potential of C++ to produce highly efficient programs. We've seen it done in practice. This book is our attempt to share that experience and document the many lessons we have learned in our own pursuit of C++ efficiency. Writing efficient C++ is not trivial, nor is it rocket science. It takes the understanding of some performance principles, as well as information on C++ performance traps and pitfalls.

The 80-20 rule is an important principle in the world of software construction. We adopt it in the writing of this book as well: 20% of all performance bugs will show up 80% of the time. We therefore chose to concentrate our efforts where it counts the most. We are interested in those performance issues that arise frequently in industrial code and have significant impact. This book is not an exhaustive discussion of the set of all possible performance bugs and their solutions; hence, we will not cover what we consider esoteric and rare performance pitfalls.

Our point of view is undoubtedly biased by our practical experience as programmers of server-side, performance-critical communications software. This bias impacts the book in several ways:

The profile of performance issues that we encounter in practice may be slightly different in nature than those found in scientific computing, database applications, and other domains. That's not a problem. Generic performance principles transcend distinct domains, and apply equally well in domains other than networking software. At times, we invented contrived examples to drive a point home, although we tried to minimize this. We have made enough coding mistakes in the past to have a sizable collection of samples taken from real production-level code that we have worked on. Our expertise was earned the hard way--by learning from our own mistakes as well as those of our colleagues. As much as possible, we illustrated our points with real code samples. We do not delve into the asymptotic complexity of algorithms, data structures, and the latest and greatest techniques for accessing, sorting, searching, and compressing data. These are important topics, but they have been extensively covered elsewhere Knu73, BR95, KP74. Instead, we focus on simple, practical, everyday coding and design principles that yield large performance improvements. We point out common design and coding practices that lead to poor performance, whether it be through the unwitting use of language features that carry high hidden costs or through violating any number of subtle (and not so subtle) performance principles.

So how do we separate myth from reality? Is C++ performance truly inferior to that of C? It is our contention that the common perception of inferior C++ performance is invalid. We concede that in general, when comparing a C program to a C++ version of what appears to be the same thing, the C program is generally faster. However, we also claim that the apparent similarity of the two programs typically is based on their data handling functionality, not their correctness, robustness, or ease of maintenance. Our contention is that when C programs are brought up to the level of C++ programs in these regards, the speed differences disappear, or the C++ versions are faster.

Thus C++ is inherently neither slower nor faster. It could be either, depending on how it is used and what is required from it. It's the way it is used that matters: If used properly, C++ can yield software systems exhibiting not just acceptable performance, but yield superior software performance.

We would like to thank the many people who contributed to this work. The toughest part was getting started and it was our editor, Marina Lang, who was instrumental in getting this project off the ground. Julia Sime made a significant contribution to the early draft and Yomtov Meged contributed many valuable suggestions as well. He also was the one who pointed out to us the subtle difference between our opinions and the absolute truth. Although those two notions may coincide at times, they are still distinct.

Many thanks to the reviewers hired by Addison-Wesley; their feedback was extremely valuable.

Thanks also to our friends and colleagues who reviewed portions of the manuscript. They are, in no particular order, Cyndy Ross, Art Francis, Scott Snyder, Tricia York, Michael Fraenkel, Carol Jones, Heather Kreger, Kathryn Britton, Ruth Willenborg, David Wisler, Bala Rajaraman, Don "Spike" Washburn, and Nils Brubaker.

Last but not least, we would like to thank our wives, Cynthia Powers Bulka and Ruth Washington Mayhew.

0201379503P04062001

From the Back Cover

Far too many programmers and software designers consider efficient C++ to be an oxymoron. They regard C++ as inherently slow and inappropriate for performance-critical applications. Consequently, C++ has had little success penetrating domains such as networking, operating system kernels, device drivers, and others.

Efficient C++ explodes that myth. Written by two authors with first-hand experience wringing the last ounce of performance from commercial C++ applications, this book demonstrates the potential of C++ to produce highly efficient programs. The book reveals practical, everyday object-oriented design principles and C++ coding techniques that can yield large performance improvements. It points out common pitfalls in both design and code that generate hidden operating costs.

This book focuses on combining C++'s power and flexibility with high performance and scalability, resulting in the best of both worlds. Specific topics include temporary objects, memory management, templates, inheritance, virtual functions, inlining, reference-counting, STL, and much more.

With this book, you will have a valuable compendium of the best performance techniques at your fingertips.



0201379503B04062001

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

Customer Reviews

Most helpful customer reviews
4.0 out of 5 stars Valuable information, but far from complete July 7 2004
Format:Paperback
Bulka and Mayhew's "Efficient C++" is an enjoyable and useful book, filled with helpful information that can be immediately applied to C++ programming. Its coverage of techniques for inlining, achieving the return value optimization, and avoiding temporary object creation is quite good. I also found the second chapter, which presents a case study about writing a tracer class, to be informative and a tidy overview of efficiency methods. There are also chapters discussing virtual functions, memory pooling, STL, and efficiency at the implementation and design levels. One helpful feature of this book is its presentation of a number of bar graphs illustrating the runtimes of actual test code. This helps to hammer home just how efficient or costly various techniques actually are.
Unfortunately, there are a number of topics which are not discussed or are only briefly discussed. The chapter on the STL, while accurate, is very incomplete. I would recommend bolstering this information with Meyers' "Effective STL". Also, different compilers implement different optimizations. It would have been nice to see a discussion of the optimizations provided by the most popular compilers, as well as tips on how to use these features effectively. The C++ standard allows compiler implementers to ignore certain keywords (register and inline) and to provide optimizations such as the return value optimization. I would have liked to have seen a discussion of the optimizations actually provided by various compilers as well as how they relate to the C++ standard. In addition, there are some advanced techniques, such as the Barton-Nackman trick, for avoiding the cost of virtual functions. Unfortunately, this and other comparable methods are not discussed.
On the whole, this book provides a lot of valuable information, but it could have been much more complete.
Was this review helpful to you?
By uniq
Format:Paperback
Few C++ books talk about such important aspects of programming like design and development for performance, as well as performance tuning. Even smaller number of them support their arguments with the actual test numbers. This book is different: on many occasions the authors show quantitative difference between techniques, which is very useful for understanding the trade-offs and is much more convincing than simply referring to common sense or authors' past experience.
This book is a well-written overview of the C++ performance programming techniques. It looks into a broad spectrum of the issues, some of them are examined in a great detail, like C++ inlining. Most often there is no free lunch in software development, and the book does a good job of showing the trade-offs of performance techniques, keeps a good balance of not advocating extra efforts simply for the sake of having faster programs.
The book has many coding examples that show "side-by-side" performance of different code snippets trying to achieve the same computational goal. The examples are very simple and are independent off each other, so one does not have to read all the previous chapters to understand a point made in the middle of the book.
Elegance usually goes hand-in-hand with good performance, so if you are just a beginner in C++, this book will help you to polish the patterns of your programming style. I think that this book will be helpful to any C++ programmer, especially to one who is writing real-time or performance intensive applications. I wish the management could read and understand it too: hopefully then it wouldn't assume that "performance profiling" is just an afterthought and is not a necessary entry in the schedule for every serious product.
Was this review helpful to you?
By Charles Ashbacher TOP 1000 REVIEWER
Format:Paperback
There are two different categories of efficiency considerations: those that you do because they are necessary and those done only when necessary. The first category consists of those changes that make the code run faster and cleaner, whether it be on a silicon or carbon based CPU. The second category becomes significant when, no matter how clean your design and completion of the first category, the hard requirements are such that the executable just does not perform to the velocity specifications. This second category is where the danger lies, because changes here often are at the expense of portability, readability or maintainability. The first category are all no-brainers, while the second will often cause headaches, either now or in the future.
Both categories are fully represented in this book, and even in the age of gigaflop desktop devices, the first should be implemented with all the due regard of a religion. For many of them save more than just clock cycles. In so many cases, the result is code that is much more elegant and easier to read, which translates into long-term savings. C++ is a very flexible, powerful language, but it does have some significant inherent performance hazards. Constructor calls are automatically generated by C++ compilers in many places where you would not on first pass suspect them. I have been teaching and writing C++ code for almost a decade and there were some that I had not thought about. However, once noted, they are relatively easy to avoid, a point where the authors are very clear. This feature alone is enough for managers to buy copies for all C++ developers and use the examples in this book to construct company wide coding guidelines.
The second category is of course more problematic, but we all know that it happens.
Read more ›
Was this review helpful to you?
Want to see more reviews on this item?
Most recent customer reviews
4.0 out of 5 stars A good read if you need to optimize code
The book title suggested to me that the book would follow the Effective C++ series format where advices are given in small items. This is not the case. Read more
Published on May 3 2007 by Olivier Langlois
5.0 out of 5 stars A great (and underappreciated) book
First off: it's practical! It's based not on some tenured professor's abstract hifalutin vaporous gobbledegook but on personal, actual, concrete experiences of the author. Read more
Published on June 2 2002 by John Doe
4.0 out of 5 stars Keys to acceptable C++ performance
The authors are developers of network and web server software for IBM. They specifically target performance issues related to C++ programming. Read more
Published on Jan. 4 2001 by Daniel Mall
4.0 out of 5 stars Recommended, with reservations
I thought the book a useful compendium of performance information, as far as it went: temporaries, constructors and destructors, virtual functions, inlining, reference counting,... Read more
Published on June 16 2000 by George V. Reilly
3.0 out of 5 stars Take the money and run...
This book came well reviewed from either CUJ or DDJ (can't remember). Anyways, page 21, there's a "cout << "blah blah blah" << blah < endl" Is... Read more
Published on June 14 2000 by Corey L Cole
4.0 out of 5 stars Very Helpful Overview of Performance Issues
I found this book to be quite helpful as a guide to areas in which C++ performance may be an issue. I was surprised by the vast difference in speeds caused by choice of allocation... Read more
Published on June 2 2000 by Brent Fulgham
1.0 out of 5 stars Sloppy information mars book.
I don't know about every topic in the book but for those where I have good information the book was wrong. Read more
Published on March 31 2000 by Charles Fiterman
5.0 out of 5 stars An efficient way to come up to speed on C++ efficiency.
I was really pleased to find this book at Borders. When I saw the title I thought that this was the book we were really missing among other excellent books on C++. Read more
Published on March 29 2000 by Anton Hristozov
5.0 out of 5 stars Informative through painful personal experiences
To start, I have to say that this book is well written. By using examples from personal experience, they also keep you very involved. Read more
Published on Feb. 25 2000 by Robert A. Gibson
5.0 out of 5 stars How to Make C++ Programs Run Faster and Cleaner
There are two different categories of efficiency considerations: those that you do because they are necessary and those done only when necessary. Read more
Published on Feb. 11 2000 by Charles Ashbacher
Search Customer Reviews
Only search this product's reviews

Look for similar items by category


Feedback