利用Intel Threading Building Blocks实现高效并行编程

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

“Intel Threading Building Blocks (TBB) 是一个C++库，旨在帮助开发者在多核处理器上实现高效的并行编程。它提供了一种任务导向的编程模型，以提高可移植性、简化编程，并使代码更易于理解。TBB的重点在于数据并行和可扩展性，允许程序性能随着处理器数量的增加而提升。该库兼容其他线程包，不强制开发者为整个程序选择单一的并行化方案。TBB适用于有无模板经验的C++和C程序员，且无需具备平行编程或多核处理器的知识背景。” Intel Threading Building Blocks (TBB) 是Intel推出的一个关键的并行编程工具，主要针对多核处理器环境。在多核芯片的时代，利用TBB，开发者可以编写出在Windows、Linux、Macintosh和Unix系统上运行的高性能并行应用，而无需深入研究线程管理的复杂细节。TBB的核心理念是通过任务而不是直接操作线程来实现并行化，这有助于提高程序的可移植性和可维护性，同时通常能带来更好的性能和可扩展性。本书由Intel软件产品的首席布道师James Reinders撰写，基于Intel开发者和客户的实际经验，详细阐述了多线程编程的关键任务以及如何使用TBB以一种可移植且稳定的方式实现这些任务。书中包含丰富的示例和完整的参考材料，展示了常见的使用模式，揭示了TBB中的潜在陷阱，并提供了在不同选择之间进行权衡以优化性能的重要指导。 TBB的主要特性包括： 1. **任务导向**：TBB允许开发者指定任务而不是直接管理线程，简化了编程工作，使代码更加清晰，同时也提高了性能和可扩展性。 2. **高阶解决方案**：TBB专注于将计算密集型工作并行化，以实现高级别的解决方案，使应用程序在多核系统上运行更高效。 3. **兼容性**：TBB与其他线程包兼容，这意味着开发者可以在同一程序中结合使用不同的并行化策略，无需局限于一个特定的库。 4. **数据并行编程**：TBB强调数据并行，确保程序性能随着处理器数量增加而提升，适应了硬件的发展趋势。 5. **泛型编程**：通过泛型编程，TBB使开发者能够在最少约束的情况下编写最优算法，提升了代码的灵活性。对于任何希望在多核系统上编写应用程序的C++程序员来说，TBB都是一个非常有价值的工具。即使是对于没有并行编程或多核处理器经验的开发者，这本书也提供了入门和深入学习的宝贵资源。通过阅读本书，读者将学会如何最大限度地利用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页未读，继续阅读

halfho

粉丝: 0

利用Intel Threading Building Blocks实现高效并行编程

Intel Threading Building Blocks并行编程指南

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

Intel Threading Building Blocks：多核编程新纪元

Intel Threading Building Blocks 线程构建模块

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

Intel Threading Building Blocks - Outfitting C++ for Multi-Core Processor 无水印pdf

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

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

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

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

最新资源