Intel Threading Building Blocks：引领并行编程新时代

需积分: 10 69 浏览量更新于2024-07-24 收藏 2.88MB PDF 举报

Intel.Threading.Building.Blocks是一本专注于Intel Threading Building Blocks (TBB) 的专业书籍，它在多核处理器时代背景下探讨了并行计算技术的发展与应用。TBB 是一个建立在工业级C++库上的并发编程工具，源自于麻省理工学院(CILK)在十五年前开发的“工作窃取”（work-stealing）技术。这本书不仅对初学者提供了一个深入浅出的TBB入门指南，还帮助资深开发者理解和应对并发编程中的复杂性。书中强调，随着单线程计算时代的结束，多核心处理器的普及使得并行计算成为主流，TBB则为程序员提供了强大的工具，使他们能够从设计阶段就兼顾正确性和性能。通过TBB，开发者如马丁·沃特（Martin Watt）能够在Autodesk的Maya等项目中实现高效并行设计，无需先满足速度再修正错误。对于C++程序员来说，TBB承诺带来编程范式的转变，使得编写并行代码更为便捷。作者詹姆斯在书中不仅展示了如何充分利用TBB提高代码性能，还将理论与实践相结合，为读者提供了实用的技术指导和最佳实践案例。无论是新手还是经验丰富的开发者，都能从中受益匪浅，了解到如何利用TBB进行任务并行化，优化程序执行效率，以及如何处理并行编程中的同步、通信和数据一致性等问题。总而言之，Intel.Threading.Building.Blocks是一本不可或缺的参考资料，它不仅介绍了TBB的核心概念和技术，还提供了实操技巧和策略，是那些希望在现代多线程环境中提升软件性能的开发者的宝贵资源。通过阅读这本书，读者将能够更好地理解和掌握在C++中利用TBB构建高效、并发且可靠的软件系统。

Note from the Lead Developer of

Intel Threading Building Blocks

Parallel computing has become personal, in both liberating and demanding ways.

I remember using an IBM 1130 mainframe in high school in the 1970s, and how frus-

trating it was because only one person could use the machine at a time, feeding it via

a card reader. Then, in the 1980s, computers became personal, and I had all the time

I wanted to run and debug sequential programs.

Parallel computing has undergone a similar shift. In the 1980s and 1990s, parallel

computers were institutional. They were fascinating to program, but access was lim-

ited. I was fortunate at one point to share a 256-processor nCUBE with only a few

other people. Now, with multi-core chips, every programmer can have cheap access

to a parallel computer—perhaps not with 256 processors yet, but with a growing

number every year.

The downside, of course, is that parallel programming is no longer optional because

parallel computers have become personal for consumers, too. Now parallel program-

ming is mandatory for performance-sensitive applications.

There is no one true way to do parallel programming. Many paradigms have been

proposed and have been cast in the form of new languages, language extensions, and

libraries. One such paradigm defines tasks that run in shared memory. This para-

digm is well suited to achieving parallel speedup on multi-core chips. The key notion

is to separate logical task patterns from physical threads, and to delegate task sched-

uling to the system.

The paradigm has been around for a long time. Intel Threading Building Blocks was

written to evangelize the paradigm, and to provide it off the shelf so that program-

mers would not have to reinvent it (and debug and tune it!).

Threading Building Blocks is strictly a library, not a new language or language exten-

sion. Though new languages and extensions are attractive, they raise a high barrier to

adoption in the near term, particularly in commercial settings, where continuity from

the existing code base is paramount. (Indeed, it is so important that businesses are

still selling systems that are upward-compatible with some of those mainframes from

the 1970s.)

xvi

Note from the Lead Developer of Intel Threading Building Blocks

Starting in 2004, I chaired a study group inside Intel that drafted the initial Thread-

ing Building Blocks proposal. Despite an early commitment to a library-only

solution, we drew much of our inspiration from new languages and extensions for

parallel programming. Our goal was to borrow as many good ideas as we could put

into library form. Sticking to a library was a requirement so that Threading Building

Blocks could slip easily into existing C++ programming environments.

C++ makes the library approach practical because it is designed for writing libraries.

Stroustrup cites a 10X reduction in line count for the Booch components written in

C++ versus Ada. Perhaps C++ will be even more powerful in the future. For exam-

ple, the addition of lambda functions (see Chapter 12) would simplify the mechanics

of using the Threading Building Blocks

parallel_for.

A library-only solution is not perfect. We had to leave out some features that really

require compiler support. For example, data-parallel array operations such as

Fortran 90, ZPL, and NESL were deemed impractical because they rely heavily on

optimizing compilers. There have been some C++ libraries such as POOMA that do

some of the optimizations via template metaprogramming, but the complexity of

such libraries is high. Parallel functional programming is another powerful para-

digm, but alas, it requires significant compiler support.

Several systems were particularly influential in the development of Threading Build-

ing Blocks; these (and others) are listed in the bibliography of this book.

The Chare Kernel (now Charm++) showed the advantages of breaking a program

into many small tasks. In particular, distributing load is simplified. By analogy, it’s a

lot easier to evenly distribute many small objects among the cases instead of a few

large objects.

Cilk showed the power of combining a scheduling technique called task stealing with

recursive tasks. Recursion is often slower than iteration for serial programming, but

it turns out that recursive parallelism has some big advantages over iterative parallel-

ism with respect to load balancing and cache reuse. Cache reuse is critical because

restructuring for cache sometimes improves program speed by 2X or more, possibly

delivering better improvement than multithreading alone. Fortunately, the Cilk

approach tends to steer programmers to solutions that both are parallel and have

good cache behavior.

The C++ Standard Template Library (STL) showed how a library could be both

generic and efficient. As we gain experience, we’re learning how to be more generic.

STAPL showed how to bring generic binding of algorithms to containers into the

parallel world, by substituting the fundamentally sequential STL iterator with paral-

lel recursive ranges (pRanges in STAPL). This enabled parallel algorithms to operate

on parallel containers and opened up the ability to apply parallel recursive ranges to

multidimensional spaces (e.g.,

blocked_range2d), and even reuse (some would say

abuse) them to write a parallel quicksort.

剩余333页未读，继续阅读

dengcy028

粉丝: 4
资源: 44

Intel Threading Building Blocks：引领并行编程新时代

Intel Threading Building Blocks：引领并行编程新时代

英特尔并行编程基石：Threading Building Blocks实战指南

Intel的Threading Building Blocks：C++的并行编程库开源

Using OpenMP vs. Threading Building Blocks for Medical Imaging on Multi-cores

Intel® Threading Building Blocks Tutorial

Intel Threading Building Blocks 线程构建模块

tbb-Intel Threading Building Blocks 线程构建模块

Intel Threading Building Blocks并行编程指南

英特尔并行编程利器：Threading Building Blocks详解

Intel® Threading Building Blocks (TBB) 使用与实践指南

最新资源