Intel Threading Building Blocks并行编程指南

5星 · 超过95%的资源需积分: 46 29 浏览量更新于2024-07-24 1 收藏 2.87MB PDF 举报

"Intel Threading Building Blocks编程指南" Intel Threading Building Blocks（TBB）是一款高性能的并发编程库，由Intel开发，旨在帮助开发者充分利用多核处理器的计算能力。TBB提供了一种基于C++的并发编程模型，能够简化并发编程的复杂性，提高程序的性能和可扩展性。 **多核编程的重要性** 随着多核处理器的普及，传统的串行计算方式已经无法满足当前计算需求。多核处理器的出现，使得并发编程变得越来越重要。Intel Threading Building Blocks正是为了满足这种需求而开发的。 **TBB的特点** TBB具有以下几个特点： 1. **基于C++的并发编程模型**：TBB提供了一种基于C++的并发编程模型，能够简化并发编程的复杂性。 2. **高性能**：TBB能够充分利用多核处理器的计算能力，提高程序的性能和可扩展性。 3. **工业级的并发库**：TBB是一个工业级的并发库，能够满足大规模并发编程的需求。 4. **work-stealing技术**：TBB使用了work-stealing技术，能够自动地分配任务，提高程序的性能和可扩展性。 **TBB的应用** TBB可以应用于各种需要并发编程的领域，例如： 1. **科学计算**：TBB可以应用于科学计算领域，例如气象模拟、fluid dynamics等。 2. **图形处理**：TBB可以应用于图形处理领域，例如游戏开发、计算机视觉等。 3. **数据分析**：TBB可以应用于数据分析领域，例如数据挖掘、机器学习等。 **TBB的优点** TBB具有以下几个优点： 1. **简化并发编程**：TBB能够简化并发编程的复杂性，提高程序的性能和可扩展性。 2. **提高性能**：TBB能够充分利用多核处理器的计算能力，提高程序的性能。 3. **提高可扩展性**：TBB能够提高程序的可扩展性，满足大规模并发编程的需求。 **结论** Intel Threading Building Blocks是当前最流行的并发编程库之一，能够满足大规模并发编程的需求。TBB提供了一种基于C++的并发编程模型，能够简化并发编程的复杂性，提高程序的性能和可扩展性。

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页未读，继续阅读

海边_man

粉丝: 8
资源: 52

Intel Threading Building Blocks并行编程指南

Intel Threading Building Blocks

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

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

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

Intel Threading Building Blocks：引领多核编程新时代

入门Intel Threading Building Blocks (TBB)：并行编程新纪元

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

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

如何使用Intel Threading Building Blocks (TBB) 提高多线程程序的性能？

Intel TBB 并行编程指南

最新资源