Buy new:
-34% $26.33
FREE delivery August 16 - 22
Ships from: Kuleli Books
Sold by: Kuleli Books
$26.33 with 34 percent savings
List Price: $39.99

The List Price is the suggested retail price of a new product as provided by a manufacturer, supplier, or seller. Except for books, Amazon will display a List Price if the product was purchased by customers on Amazon or offered by other retailers at or above the List Price in at least the past 90 days. List prices may not necessarily reflect the product's prevailing market price.
Learn more
FREE delivery August 16 - 22. Details
Or fastest delivery August 13 - 16. Details
Only 1 left in stock - order soon.
$$26.33 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$26.33
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Ships from
Kuleli Books
Ships from
Kuleli Books
Sold by
Kuleli Books
Sold by
Kuleli Books
Returns
30-day refund/replacement
30-day refund/replacement
This item can be returned in its original condition for a full refund or replacement within 30 days of receipt. You may receive a partial or no refund on used, damaged or materially different returns.
Read full return policy
Returns
30-day refund/replacement
This item can be returned in its original condition for a full refund or replacement within 30 days of receipt. You may receive a partial or no refund on used, damaged or materially different returns.
Read full return policy
Payment
Secure transaction
Your transaction is secure
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
Payment
Secure transaction
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
$4.93
Connecting readers with great books since 1972! Used books may not include companion materials, and may have some shelf wear or limited writing. We ship orders daily and Customer Service is our top priority! Connecting readers with great books since 1972! Used books may not include companion materials, and may have some shelf wear or limited writing. We ship orders daily and Customer Service is our top priority! See less
$3.99 delivery August 19 - 20. Details
Only 1 left in stock - order soon.
$$26.33 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$26.33
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Access codes and supplements are not guaranteed with used items.
Ships from and sold by HPB-Emerald.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the author

James Reinders
Follow
Something went wrong. Please try your request again later.

Intel Threading Building Blocks: Outfitting C++ for Multi-core Processor Parallelism 1st Edition

by James Reinders (Author)
4.3 4.3 out of 5 stars 14 ratings
See all formats and editions
{"desktop_buybox_group_1":[{"displayPrice":"$26.33","priceAmount":26.33,"currencySymbol":"$","integerValue":"26","decimalSeparator":".","fractionalValue":"33","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"92MFDbYZcfoxL0uLA7n4To4M9Pb%2BLESe%2FPJF7gzEJZzdHt3YbrkmDP1f2vJOG37uboNz1C%2F4m3A6zuYtJl5Ki1Z%2Bu19Y7%2B42sAC68LnbRs9%2F%2BlPil%2FEi3aU5wfXgk3Jcvm8f2MjvkrZUSHAnxKzfKiRXJTBRThyUGrFbjjW4lX3oLXjJS5jtOJ20mHnS6X%2Fb","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}, {"displayPrice":"$4.93","priceAmount":4.93,"currencySymbol":"$","integerValue":"4","decimalSeparator":".","fractionalValue":"93","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"92MFDbYZcfoxL0uLA7n4To4M9Pb%2BLESeefjEo9q6DfQkktfQwB3gHu0OkBpl%2BehX4nnL3B2MsF%2F%2FUNLZjPni7H9Hq29WB89jPxHMc6zhe97fAPQgN%2FllwL2kLz4nveujm0Y8oXg0IVu5E0ZtaDfGwV9X5X%2FNnCQ04%2BYQpNAlPqorcRFYGrr7xeoHyMgjKker","locale":"en-US","buyingOptionType":"USED","aapiBuyingOptionIndex":1}]}

Purchase options and add-ons

Multi-core chips from Intel and AMD offer a dramatic boost in speed and responsiveness, and plenty of opportunities for multiprocessing on ordinary desktop computers. But they also present a challenge: More than ever, multithreading is a requirement for good performance. This guide explains how to maximize the benefits of these processors through a portable C++ library that works on Windows, Linux, Macintosh, and Unix systems. With it, you'll learn how to use Intel Threading Building Blocks (TBB) effectively for parallel programming -- without having to be a threading expert.

Written by James Reinders, Chief Evangelist of Intel Software Products, and based on the experience of Intel's developers and customers, this book explains the key tasks in multithreading and how to accomplish them with TBB in a portable and robust manner. With plenty of examples and full reference material, the book lays out common patterns of uses, reveals the gotchas in TBB, and gives important guidelines for choosing among alternatives in order to get the best performance.

You'll learn how Intel Threading Building Blocks:
  • Enables you to specify tasks instead of threads for better portability, easier programming, more understandable source code, and better performance and scalability in general
  • Focuses on the goal of parallelizing computationally intensive work to deliver high-level solutions
  • Is compatible with other threading packages, and doesn't force you to pick one package for your entire program
  • Emphasizes scalable, data-parallel programming, which allows program performance to increase as you add processors
  • Relies on generic programming, which enables you to write the best possible algorithms with the fewest constraints
Any C++ programmer who wants to write an application to run on a multi-core system will benefit from this book. TBB is also very approachable for a C programmer or a C++ programmer without much experience with templates. Best of all, you don't need experience with parallel programming or multi-core processors to use this book.
Previous slide of product details
  1. ISBN-10
    0596514808
  2. ISBN-13
    978-0596514808
  3. Edition
    1st
  4. Publisher
    O'Reilly Media
  5. Publication date
    August 21, 2007
  6. Language
    English
  7. Dimensions
    7 x 0.71 x 9.19 inches
  8. Print length
    332 pages
  9. See all details
Next slide of product details
Save time and resources when buying books in bulk. Your Company Bookshelf Save time and resources when buying books in bulk. Your Company Bookshelf

Editorial Reviews

About the Author

James Reinders, Chief Evangelist of Intel Software Products, is a senior engineer who joined Intel Corporation in 1989 and has contributed to a number of projects, including the world's first TeraFLOP supercomputer (ASCI Red), compilers and architecture work for the iWarp, Pentium Pro, Pentium II, Itanium, and Pentium 4 processors. He has years of experience in processor architecture, optimizing compilers, parallel computer architecture, and making products for software developers.

Reinders is also the editorial columnist for the monthly "The Gauntlet" at www.devX.go-parallel.com, as well as the author of the Intel Press book titled "VTune Performance Analyzer Essentials" and contributor to the new book "Multi-Core Programming."

Product details

  • Publisher ‏ : ‎ O'Reilly Media; 1st edition (August 21, 2007)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 332 pages
  • ISBN-10 ‏ : ‎ 0596514808
  • ISBN-13 ‏ : ‎ 978-0596514808
  • Item Weight ‏ : ‎ 1.16 pounds
  • Dimensions ‏ : ‎ 7 x 0.71 x 9.19 inches
  • Customer Reviews:
    4.3 4.3 out of 5 stars 14 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
James Reinders

James Reinders

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

I am passionate about Parallel Programming and Parallel Computer Architecture. Fast computers! I have had the great fortune to help make key contributions to two of the world's fastest computers (#1 on the "Top500" lists many times) and many other supercomputers.

My latest project is a book on Data Parallelism for C++ (available late 2020).

I am an independent consultant on parallel computing, high performance computing (HPC, AI, ML, CPUs, FPGAs, GPUs, and accelerators of all kinds). I previously worked at Intel until 2016. During my 10,001 days at Intel, I contributed to many projects including the world's first TeraFLOP/s supercomputer (ASCI Red) and the world's first TeraFLOP/s microprocessor. Today, I continue to publish articles and do consulting in areas related to high performance computing, and applications that use high performance computing including AI/ML.

Customer reviews

4.3 out of 5 stars
14 global ratings

Top reviews from the United States

rdf
5.0 out of 5 stars Opens up your thinking about parallelism
Reviewed in the United States on January 27, 2008
Verified Purchase
I agree with Hardman's review as far as it goes -- the book cannot go into as much detail as he would like since it is designed to be cross platform (and surprisingly also applicable to other similar chips e.g., AMD).

On the other hand, this book opens you up to an important area: how can you use a small number of cores to speed up your program, including those programs that appear serial at first (and maybe second) glance e.g., the cumulative sum of a vector.

The book has a lot of depth on the algorithms used and works through applications of differing complexity and varied domains.

As an extra bonus it provides annotated pointers to its intellectual predecessors, albeit not as extensive as Hillis' book. The Connection Machine (Artificial Intelligence)
15 people found this helpful
Helpful
 Report
Chunhyok Chong
4.0 out of 5 stars Complementary Manual of Intel's TBB documents
Reviewed in the United States on April 4, 2012
Verified Purchase
I think, this book is the complementary manual of Intel's TBB documents.
Because Intel provides some documents (tutorial, getting started, reference, design pattern) and example codes in the TBB package, but it could be somewhat difficult to find the sample code for all of TBB features like concurrent_*(queue, hash_map, vector) or TBB's task modules.

Although it proposes a good philosophy of concurrency but lacks concepts or diagrams to explain its codes parts.

A good example book.
3 people found this helpful
Helpful
 Report
strawhatguy
4.0 out of 5 stars Four Stars
Reviewed in the United States on October 1, 2017
Verified Purchase
Good, but a bit outdated at this point. Some of the newer constructs are not covered
Helpful
 Report
Jeff
4.0 out of 5 stars more than just a book on TBB
Reviewed in the United States on October 24, 2011
Verified Purchase
While this book is about Intel TBB, I think it has some of the best introductory material on parallel programming in general. Chapter 2 is truly excellent in this respect.
One person found this helpful
Helpful
 Report
J. S. Hardman
3.0 out of 5 stars Potentially useful technology, book could be better
Reviewed in the United States on August 25, 2007
There are many views of how best to implement multi-threading and with multi-core processors now common the topic is becoming ever more relevant. Of course the best implementation method really depends on what you are trying to do. Are you implementing something that waits for a price update message from a derivatives exchange, parses the message, updates cached data, writes a log and forwards the message on to an algorithmic trading engine? If so, you'll probably be attracted to techniques different from someone calculating risk, bond prices etc. There is no one technique that suits every job.

Anyone working with multi-threading (and parallelism in general) keeps an eye on what techniques other people are using to see whether they may be useful. That's why I bought this book (Intel Threading Building Blocks) and TBB certainly looks like it will be of use for some multi-threaded applications that I develop, although not for all.

Starting with the most important question - have I learnt anything from reading this book. Yes, and I've learnt a couple of bits from reading the TBB source code too (downloadable from the web). Now for the detail...

Having read the book, am I now about to start using the Intel Threading Building Blocks library (downloadable from Intel)? The answer is yes, for some applications on some hardware architectures, but not for all of my multi-threaded applications. Importantly in terms of this book though, the first reason I looked at the TBB source code was to answer questions raised when reading the book, and that is my main issue with this book. For a developer who already has extensive multi-threading experience, this book raises quite a few questions that it doesn't answer.

Even some of the things that this book does answer are tucked away in the text a long way into the book. Here are three examples:
(1) The book tells you to create tasks, not explicitly work with threads. Where is the best description of a task? Page 267. It's not even in a glossary, but tucked away in the examples chapter. Somewhere in the first chapter would have been more useful.
(2) Personally, if I am told within the first few pages that TBB is based on the idea of developers implementing their systems as small tasks that are scheduled by the TBB scheduler I am immediately going to ask how that task is handled at a technical level. Ok, we're told quickly that it's written as a functor, and that functors may be executed on different cores, but does that mean that a thread is chosen from a thread pool to execute each functor, that (on Windows) fibers are used, that there is one manager thread running per core (with processor affinity set?) with each manager pulling tasks from its own queue, what are the performance implications of context switching and locking, etc? The author may think that the reader doesn't need this level of detail, but if somebody is going to the trouble of writing multithreaded code to improve performance I would think it very likely that they will want to know what is happening beneath the surface to ensure that they are using the best techniques. Some details of the scheduler are provided much further into the book (for instance we discover that last-in, first-out deques are used), but not enough and far too late.
(3) On page 133 there are two paragraphs discussing when task-based programming is inappropriate, a bit late in my opinion for those people for whom it does turn out to be inappropriate.

I also have issues with some of the things presented as absolute fact in the book. For example "Race conditions are less catastrophic than deadlocks". I disagree. With a deadlock your program stops, you know about it very quickly, you investigate and you sort it out. If it happens, it'll probably only happen once. With a race condition you may not even realise it exists, the application produces subtly incorrect results and hence your functionality goes awry. If that means your algorithmic trading engine decides to buy a million shares instead of doing nothing (or selling) then you are going to lose a lot of money very quickly. Possibly not just once, but day after day until you realise the race condition is there.

Then there are the bits that are just plain confusing. Here are two examples:
(a) We are told on page 271 that Task stealing is "Terrible" and "will disrupt cached data", but are told on page 283 that TBB is "unique because it rests on a few key decisions" including "Use task stealing". Hmmm...
(b) The code comment on page 231, "2 = 1 for SideShow and C". I know what it means, but adding a verb phrase would prevent the moment when the reader wonders just which proof is about to be presented that "2 = 1".

On the plus side, the book does discuss the split/join pattern, pipelines, atomic operations, benefits of working in user space, issues with the standard new operator (and hence libraries that make use of it), caching issues etc. There is also a chapter on general "Keys to Success" which is useful. There are also some reasonable examples towards the end of the book (although some half way through would be better replaced - demonstrating a point is one thing, but demonstrating it with realistic code is better).

Possibly outside the intended scope of the book, it might have been useful to briefly describe grid computing and whether Intel have plans to add a layer above TBB for use across grids instead of just on one machine, or whether Intel's plans for grid computing simply rely on a completely different model.

So to summarise, the TBB library from Intel looks like it could be very useful, this book will certainly get you started using it, but have no doubt that this book could have been better. Buy it if you will be using TBB, but until somebody writes a better book be prepared to read the TBB source code to find the answers to your deeper questions, or simply ask questions on Intel's web-site.
110 people found this helpful
Helpful
 Report
Abc123
4.0 out of 5 stars Four Stars
Reviewed in the United States on November 27, 2015
Verified Purchase
Update it with the lambda expression variant!
Helpful
 Report