Customer Reviews

The Software Optimization Cookbook: High Performance Recipes for IA-32 Platforms, 2nd Edition

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

 

 

This is a well-written, easy to read and inspiring book that gives insight into a fascinating new technology - this is the most useful software optimization book ever written. As modern processors include many advanced features such as branch prediction, cashes with hardware prefetch, out of order execution cores, instruction level paralellism and intraregister vectorization, writing high performance software for such arcitectures is not so easy. In addition, most programming languages available today have not been delibetarly designed to take advantage of these newly introduced architecture features.

It is therfore fortunate that the second edition of the software optimization cookbook gives such a useful and easy to read introduction to software optimization on modern architecures. This is most important for the engineers that develop performance critical software applications but want to ensure high readability and easily maintainable source code.

For example, advanced compiler techniques such as profile guided optimization and inter procedural optimization, pedagogically described in this book, may boost the performance of your application. This is not surprising; cache misses may seriously obstruct memory intensive applications as memory is ridiculously slow compared to cache on most modern processors.

The Intel processors, together with the Intel compilers and the books from Intel press, significantly simplify the job for the software developers that struggle to increase the efficiency of their applications. My experience is that the Intel compilers, tailormade to the Intel processors, take better and better advantage of the advanced features in modern processors. Thus, the development of efficient software becomes easier and easier even though the processor architecture becomes more and more complicated.

Switching to the Intel compiler may significantly improve the performance of your application, thus there is no such thing as "change the compiler only"; the compiler alone may actually be responsible for most of the increased speedup seen in many applications. However, you may need to rewrite some parts of your code, as recommended in this book, to obtain a clear and readable compiler-friendly programming style - a too complicated source code tends to hamper the usefulness of the advanced optimizations available in the Intel compiler and reduces the source code readability for your co-workers.

The Software Optimization Cookbook, Second Edition, provides updated recipes for high-performance applications on Intel platforms. Through simple explanations and examples, four Intel experts show you how to address performance issues with algorithms, memory access, branch prediction, automatic vectorization, SIMD instructions, multiple threads, and floating-point calculations.

Software developers learn how to take advantage of Intel® Extended Memory 64 Technology (Intel® EM64T), multi-core processing, Hyper-Threading Technology, OpenMP*, and multimedia extensions. This book guides you through the growing collection of software tools, compiler switches, and coding optimizations, showing you efficient ways to improve the performance of software applications for Intel platforms.

Highlights include:

- Choosing the right algorithm
- Automatic vectorization and hints on how to guide the compiler
- Compiler support for multi-threading
- The performance impacts of shared L2 and L3 caches
- Loop optimizations and when to use the compiler for performance gain
- Use of intrinsics to exploit SIMD technology

Software developers who want to understand the latest techniques for delivering more performance and to fine-tune their coding skills will benefit from this book.


Customer Comments
"A must-read text for anyone who intends to write performance-critical applications for the Intel processor family."

--Robert van Engelen, Professor, Florida State University

"This book simplifies the task for engineers who strive to develop high-performance software without sacrificing source code readability or having to understand all the nitty-gritty details of IA-32 processors."

--Lars Petter Endresen, Doctor of Engineering, Physics Scandpower Petroleum Technology

ABOUT THE AUTHORS
Richard Gerber has worked on numerous multimedia projects, 3D libraries, and computer games for Intel. As a software engineer, he worked on the Intel® VTune(tm) Performance Analyzer and led training sessions on optimization techniques. Richard is the original author of The Software Optimization Cookbook and co-author of Programming with Hyper-Threading Technology.

Aart J.C. Bik holds a PhD in computer science and is a Principal Engineer at Intel Corporation, working on the development of high performance Intel® C++ and Fortran compilers. Aart received an Intel Achievement Award, the company's highest award, for making the Intel Streaming SIMD Extensions easier to use through automatic vectorization. Aart is the author of The Software Vectorization Handbook.

Kevin B. Smith is a software architect for Intel's C and FORTRAN compilers. Since 1981 he has worked on optimizing compilers for Intel 8086, 80186, i960®, Pentium®, Pentium Pro, Pentium III, Pentium 4, and Pentium M processors.

Xinmin Tian holds a PhD in computer science and leads an Intel development group working on exploiting thread-level parallelism in high-performance Intel® C++ and Fortran compilers for Intel Itanium®, IA-32, Intel® EM64T, and multi-core architectures.

Without a doubt, this book is a must for software engineers aiming at producing high performance software on Intel IA-32 platforms. It contains many valuable programming experiences and tricks which you wouldn't find in technical papers or books. It also enumerates many well-known topics in the fields of computer organization, computer architectures, compilers, and parallel computing. More importantly, it clarifies many hypothetical ideas even further and provides the corresponding guidelines and suggestions.

A software programmer can learn from the very basic optimization concepts to advanced techniques in this 400-page book. It teaches you all the way from choosing right benchmarks and tools, how to locate the hot spots, till the last ten percent of the optimization process. Several famous topics on the present parallel computing are discussed as well, including instruction-level parallelism (ILP), thread-level parallelism (TLP), OpenMP, task queuing, etc.

This book contains a lot of insightful information.
It focuses mainly on the pentium 4 and pentium M architectures which make it a little out dated even though most techniques describe in the book are still relevant.
Developer using the intel compilers (c++ or Fortran) will benefit even more from this book which describes in detail some of the compiler specific flags as well as some compiler specific support (intrinsic, data types, etc).