Обзор библиотеки Intel® Threading uilding locks · Уровни...

Обзор библиотекиIntel® Threading Building Blocks

Алексей Федотов

SSG/DPD/TCAR/Threading Runtimes

Intel® Threading Building Blocks (Intel® TBB) - это простойспособ помочь вашей программе эффективно использоватьвычислительные ресурсы системы, на которой онавыполняется.

Для чего нужна данная библиотека?

Время

ЗадачаУти

зац

сте

Время

Задача

Ути

зац

сте

А что, без Intel® TBB неэффективно?

“The free lunch is over: A Fundamental Turn Toward Concurrency” – Herb Sutter, Dr. Dobb’s журнал, март 2005 г.

10 ГГц

1 ГГц

100 МГц

10 МГц

1 МГц

’79 ’87 ’95 ’03 ’11

Частота процессора

больше

не возрастает

… но мы хотим, чтобы

приложения исполнялись

быстрее…

Когда нет супергероя, на помощь приходят миллионы рядовых солдат!

Уровни параллелизма(аппаратное обеспечение)

• Параллелизм на уровне инструкций (ILP)• Конвейерное исполнение.

• Супер-скалярное исполнение (Hyper-Threading).

• Параллелизм на уровне данных (DLP)• SIMD (Single Instruction Multiple Data) векторная обработка.

• Реализован через использование SSE регистров и инструкций.

• Параллелизм на уровне потоков (TLP)• Многоядерная архитектура.

• Множество сокетов с когерентной кэш-памятью.

• Параллелизм на уровне кластеров (CLP)• Множество платформ, соединённых через сеть.

• Нет аппаратный поддержки когерентности кэш-памяти.

Уровни параллелизма(программное обеспечение)

• Передача сообщений

• Обработка событий

• Параллелизм данных

• Вектора, SIMD

• Параллелизм данных

• Параллелизм задач

• Шаблон fork-join

Неструктурированный

Структурированный

Все 3 уровня необходимы чтобы достигнутьмаксимального параллелизма

Поддержка параллелизма в С++

С++03 C++11 C++17+ Другие подходы

нет

С++11 С++17+ Другие подходы

std::async, std::future

«Вручную»на

std::thread и т.п.

std::async, std::future ?

Нет

resumableфункции,

развитие std::asyncи std::future

Нет

task_block,Parallel STL

Нет ?

Нет Parallel STL (par_vec)

MPI*, Microsoft AAL*Intel TBB flow graph,Qualcomm MARE* и

другие

task_block,Parallel STL ?

другие

OpenMP*, Intel TBB, Cilk*, Nvidia Thrust

Microsoft PPL*, Qualcomm MARE* и

другие

Нет Parallel STL (par_vec) ?

другие

OpenMP*, Intel TBB, Cilk*, Nvidia Thrust

Microsoft PPL*, Qualcomm MARE* и

другие

intrinsics, auto-vectrorization, Intel® Cilk™ Plus, OpenCL*,

Nvidia CUDA*, OpenMP* 4, Open ACC

и другие

int flag = 0;

void AddHead (struct List *list,

struct Node *node) {

while (flag != 0) /* wait */ ;

flag = 1;

node->next = list->head;

list->head = node;

flag = 0;

Сработает на двух потоках?

int flag = 0;

flag = 1;

list->head = node;

flag = 0;

int flag = 0;

flag = 1;

list->head = node;

flag = 0;

flagT2

int flag = 0;

flag = 1;

list->head = node;

flag = 0;

flagT2

int flag = 0;

flag = 1;

list->head = node;

flag = 0;

flagT2

int flag = 0;

flag = 1;

list->head = node;

flag = 0;

flagT2

int flag = 0;

flag = 1;

list->head = node;

flag = 0;

flagT2

Гонки данных

Пример: i++;

Поток №1 Поток №2Общийсчётчик

Чтение 0

Сложение 0

Запись 1

Чтение 1

Сложение 1

Запись 2

Поток №1 Поток №2Общийсчётчик

Чтение 0

Сложение 0

Запись 1

Чем гонки данных так неприятны?

Программы, в которых есть гонки данных, проявляютнедетерминированность в своём исполнении:

• Иногда дают верный результат

• Иногда дают ошибочный результат

Такие программы обычно работают корректно намаленьком количестве потоков с небольшим наборомданных.

Проблемы проявляются чаще, когда количествопотоков и время выполнения программы возрастает.

Отладка таких программ затруднительна!

Критические секции

• Это участки кода, которые выполняются потоками эксклюзивно.

• Реализованы при помощи примитивов синхронизации:

• pthread_mutex (Linux*)

• CRITICAL_SECTION (Windows*)

Критические секции устраняют гонки данных!

Критические секции исполняются последовательно!

Нужно понять, что должно исполняться эксклюзивно!

Взаимная блокировка

Потоки ждут некоторого события или условия, которое никогда не произойдёт.

Пример: дорожные пробки.Машины не могут повернуть или развернуться.

Взаимная блокировка (пример)

CRITICAL_SECTION cs1;

CRITICAL_SECTION cs2;

int x = 0;

int y = 0;

InitializeCriticalSection(&cs1); // Allocation Site (cs1)

InitializeCriticalSection(&cs2); // Allocation Site (cs2)

EnterCriticalSection(&cs1);

LeaveCriticalSection(&cs2);

Поток №1 Поток №2

Нарушение порядка захвата

1. EnterCriticalSection(&cs1); в потоке №1

Взаимная блокировка

Активная взаимная блокировка

http://stackoverflow.com/a/27997039/2882509

Ложное разделение ресурсовнеумышленное разделение данных в кэш-линии

Условия:

Два или более потока «работают» с одной и той же кэш-линией, но с разными адресами в памяти.

Хотя бы один поток пишет в свой адрес памяти, фактически помечая кэш-линию на других ядрах как устаревшую.

Последствия:

При следующем обращении по своему адресу ядру будет необходимо обратиться к памяти снова, чтобы загрузить «свежие» данные из неё.

float a[N], b[N];

float localSum[NUM_PROCS];

void* work(int tid) {

for (int j = 0; j < ITERATIONS; j++) {

for (int i = tid; i < N; i+= NUM_PROCS) {

a[i] = i + a[i] * b[i];

localSum[tid] += a[i];

0 1 2 3 4 … N-1a[i]

0 1 2 3 4 … N-1b[i]

thread 1 thread 2

0 1 2 3 4 … 15cacheline

Ложное разделение ресурсов (пример)

Пусть NUM_PROCS = 2:

void* work(int tid) {

for (int j = 0; j < ITERATIONS; j++) {

for (int i = ;

i < ; i++)

a[i] = i + a[i] * b[i];

Ложное разделение ресурсов (исправленный вариант)

int chunks = N / NUM_PROCS;

tid * chunks

(tid + 1) * chunks

float sum = 0.0f;

localSum[tid] = sum;

sum += a[i];

Библиотека для параллельного программирования на C++:

Упрощает написание параллельных алгоритмов и скрывает явное управление потоками;

Автоматически адаптируется к системе и позволяет достигнуть максимальной масштабируемости приложения;

Кроссплатформенная: Windows *, Linux *, Mac OS* и другие

http://threadingbuildingblocks.org/

Intel® Threading Building Blocks(Intel® TBB)

Настольные компьютеры

Планшеты

Смарфоны

Ноутбуки

Нетбуки

Встроенное ПО

Кластеры

Рабочие станции

Серверы

Облако/Датацентры Сопроцессоры

Ниша Intel® TBB

OpenMP

Intel® TBB

Структура Intel® TBB

Параллельные алгоритмы и структуры данных

Потоки и синхронизация Управление памятью и задачами

Параллельные алгоритмы

Эффективная реализация

типовых шаблонов параллелизма

Конкурентные контейнеры

Контейнеры в стиле STL с возможностью конкурентного доступа без внешних

блокировок

Планировщик задач

Обеспечивает параллелизм на уровне задач, балансировка методом перехвата

работы

Потоки

Обёртки для

системных вызовов

Другое

Потокобезопасныетаймеры и

поддержка С++ исключений

Масштабируемый менеджер памяти

Спроектирован для параллельных программ

Примитивы синхронизации

Атомарные операции и различного рода мьютексы

Вычислительныйграф (Flow Graph)

Набор классов для описания

вычислительных графов, которые

могут исполняться параллельно

Локальнаяпамять потока

Неограниченное число локальных

переменных потока (TLS)

Шаблоны параллельных алгоритмов

• Fork-join запускает исполнение нескольких задач одновременно и затем дожидается завершения каждой из них• Удобен в применении для

функциональной и рекурсивной декомпозиции• Используется как базовый

блок для построения других шаблонов

Примеры: Сортировка слиянием, быстрая сортировка (Хоара), другие алгоритмы «разделяй-и-властвуй»

Шаблон: Fork-Join

Функциональная декомпозиция

int e;

main () {

int x[10], j, k, m; j = f(x, k); m = g(x, k);

int f(int *x, int k)

int a; a = e * x[k] * x[k]; return a;

int g(int *x, int k)

int a; k = k-1; a = e / x[k]; return a;

Поток №0

Поток №1

Статическая переменная: общаяГлобальная для потоков: общая

Локальные переменные функций

Fork-Join в Intel® TBB

task_group g;

g.run( functor1 );

g.run( functor2 );

g.wait();

Для небольшого предопределённого количества задач

parallel_invoke( functor1, functor2, ...);

Когда количество задач велико или заранее неизвестно

Пример: быстрая сортировка

template<typename I>

void fork_join_qsort(I begin, I end) {

typedef typename

std::iterator_traits<I>::value_type T;

if (begin != end) {

const I pivot = end - 1;

const I middle = std::partition(begin, pivot,

std::bind(std::less<T>(), _1, *pivot));

std::swap(*pivot, *middle);

tbb::parallel_invoke(

fork_join_qsort(begin, middle),

fork_join_qsort(middle + 1, end)

Рекурсивный (вложенный) параллелизм

Эффективная рекурсия с fork-join

• Легко «вкладывается»

• Накладные расходы делятся между потоками

• Именно так устроены tbb::parallel_for, tbb::parallel_reduce

Рекурсивный fork-join обеспечивает высокую степень параллелизма

• Map применяет указанную функцию к каждому элементу из заданного набора• Это может быть некий

набор данных или абстрактный индекс

• В серийной программе это частный случай итерирования –независимые операции.

A = map(f)(B);

Примеры: цветовая коррекция изображений; преобразование координат; трассировка лучей; методы Монте-Карло

Шаблон: Map

Параллелизм по данным

Последовательный код

for (int i = N/2; i < N; i++) a[i] = foo(i);

for (int i = 0; i < N/2; i++) a[i] = foo(i);

const int N = 1000;int a[N];for (int i = 0; i < N; i++) a[i] = foo(i);

Локальная памятьРазделяемая память

Поток №0

Поток №1

Параллелизм по данным

Разделяемая

память

Поток №0 Поток №2

Поток №1

tbb::parallel_for

parallel_for( lower, upper, functor );

Применить functor(i) ко всем i [lower, upper)

Предоставляется в нескольких вариантах

parallel_for( lower, upper, stride, functor );

Применить functor(i), изменяя i с заданным шагом

parallel_for( range, functor );

Применить functor(subrange) для набора subrange из range

Пример с parallel_for

void saxpy( float a, float x[], float (&y)[], size_t n ) {

tbb::parallel_for( size_t(0), n, [&]( size_t i ) {

y[i] += a * x[i];

void saxpy( float a, float x[], float (&y)[], size_t n ) {

size_t gs = std::max( n / 1000, 1000 );

tbb::parallel_for( tbb::blocked_range<size_t>(0,n,gs),

[&]( tbb::blocked_range<size_t> r ) {

for( size_t i = r.begin(); i != r.end(); ++i )

y[i] += a * x[i];

}, tbb::simple_partitioner() );

Управление распределением работы

parallel_for( range, functor, simple_partitioner() );

affinity_partitioner affp;

parallel_for( range, functor, affp );

parallel_for( range, functor, auto_partitioner() );

Рекурсивное деление на максимально возможную глубину

Глубина деления подбирается динамически

Деление запоминается и по возможности воспроизводится

Ещё пример: параллелизм в 2D

tbb::parallel_for(

tbb::blocked_range2d<int>(0,m,0,n),

[&](tbb::blocked_range2d<int> r ) {

int i, j;

for(i=r.rows().begin(); i!=r.rows().end(); ++i)

for(j=r.cols().begin(); j!=r.cols().end(); ++j )

a[i][j] = f(b[i][j]);

// serial

for( int i=0; i<m; ++i )

for( int j=0; j<n; ++j )

a[i][j] = f(b[i][j]);

Декомпозиция «плиткой» /*tiling*/ в 2D может приводить к лучшей локальности данных, чем вложенные параллельные циклы в 1D.

Если parallel_for не подходит

parallel_for_each( first, last, functor );

Применить functor(*iter) ко всем элементам контейнера

•Параллельная версия std::for_each

•Работает со стандартными контейнерами

parallel_do( first, last, functor );

То же с возможностью добавить работу «на лету»

[]( work_item, parallel_do_feeder& feeder ) {

<обработка полученного work_item>

if( <в процессе создан new_work_item> )

feeder.add( new_work_item );

Добавление данных для обработки:

• Reduce объединяет, при помощи ассоциативной операции, все элементы набора в один элемент

• Например, reduce можно использовать, чтобы найти сумму элементов или максимальный элемент

b = reduce(f)(B);

Примеры: вычисление агрегатных функций; операции с матрицами; численное интегрирование

Шаблон: Reduce /* свёртка */

Reduce в Intel® TBB

enumerable_thread_specific<T> sum;

parallel_for( 0, n, [&]( int i ) {

sum.local() += a[i];

T total = sum.combine(std::plus<T>());

T sum = parallel_reduce(

blocked_range<int>(0,n),

[&](blocked_range<int> r, T s) -> T {

for( int i=r.begin(); i!=r.end(); ++i )

s += a[i];

return s;

std::plus<T>()

При помощи класса enumerable_thread_specific

При помощи функции parallel_reduce

Способ с enumerable_thread_specific

Подходит, если:

Операция коммутативна

Дорого вычислять свёртку (напр. большой размер операндов)

enumerable_thread_specific<T> sum;

parallel_for( 0, n, [&]( int i ) {

sum.local() += a[i];

T total = sum.combine(std::plus<T>());

Обращение к локальной копии

Применяет указанную операцию для свёртки

локальных копий

Контейнер для thread-local

представлений

Способ с parallel_reduce

Подходит, если

Операция некоммутативна, но ассоциативна

Использование диапазона улучшает производительность

string concat = parallel_reduce(

blocked_range<int>(0, n),

string(),

[&](blocked_range<int> r, string s)->string

for( int i=r.begin(); i!=r.end(); ++i )

s += a[i];

return s;

std::plus<string>()

Свёртка частичных результатов

Нейтральный элемент

Свёртка поддиапазона

Начальное значение для свёртки

Пример: поиск наименьшего элемента// Find index of smallest element in a[0...n-1]

int ParallelMinIndex ( const float a[], int n ) {

struct MyMin {float value; int idx;};

const MyMin identity = {FLT_MAX,-1};

MyMin result = tbb::parallel_reduce(

tbb::blocked_range<int>(0,n),

identity,

[&] (tbb::blocked_range<int> r, MyMin current) -> MyMin {

for( int i=r.begin(); i<r.end(); ++i )

if( a[i] < current.value ) {

current.value = a[i];

current.idx = i;

return current;

[] (const MyMin a, const MyMin b) {

return a.value<b.value? a : b;

return result.idx;

Комментарии к parallel_reduce

Можно указывать необязательный аргумент partitioner

Аналогично parallel_for

Для неассоциативных операций рекомендуется parallel_deterministic_reduce

Воспроизводимый результат для арифметики с плавающей точкой

Но не соответствует результату в серийном коде

Рекомендуется явно указывать гранулярность

Не позволяет задать partitioner

• Scan полезен в сценариях, когда данные по сути зависимы.

• Для достижения параллелизма необходимо слегка «извернуться».

• Необходимо, чтобы операция удовлетворяла правилу ассоциативности.

Примеры: вычисление частичных сумм, сортировка подсчётом, ранжирование списка, интегральные изображения

Шаблон: Scan /* частичные суммы */

int n = 16; int temp = 0;

for(int i = 0; i < n; ++i) {

y[i] = temp;

temp = temp + z[i];

y[n] = temp;

Задача: найти частичные суммы

1 2 3 4 5 166 7 8 9 10 11 12 13 14 15z[]

y[] 0 1 3 6 10 15 21 28 36 45 55 66 78 91 105120136

Параллелизм в шаблоне scantemplate <class T> class Body {

T sum;

T* const y;

const T* const z;

public:

Body(T* y_,const T* z_):sum(0),z(z_),y(y_){}

T get_sum() const {return sum;}

template<typename Tag>

void operator()(

const blocked_range<int>& r,Tag) {

T temp = sum;

for(int i=r.begin();i<r.end();++i) {

temp = temp+z[i];

if(Tag::is_final_scan())

y[i] = temp;

sum = temp;

Body(Body& b,split):z(b.z),y(b.y),sum(0){}

void reverse_join(Body& a){sum = a.sum+sum;}

void assign(Body& b) {sum = b.sum;}

float DoParallelScan(T y[],const T z[],int n){

Body body(y,z);

parallel_scan(blocked_range<int>(0,n),body);

return body.get_sum();

Шаблон: Sort /* сортировка */

template<typename RandomAccessIterator>

void parallel_sort( RandomAccessIterator begin,

RandomAccessIterator end );

template<typename RandomAccessIterator, typename Compare>

void parallel_sort( RandomAccessIterator begin,

RandomAccessIterator end,

const Compare& comp );

template<typename Container>

void parallel_sort( Container c );

template<typename Container>

void parallel_sort( Container c, const Compare& comp );

Вычислительные графы вIntel® Threading Building Blocks

• Состоит из объекта графа

• Задан набором узлов и рёбер

• Позволяет дождаться завершения всей работы внутри графа

Интерфейс Intel TBB flow graph

Объект графа

Узел графа

Ребро

Пользователь задаёт узлы и рёбра, взаимодействует с графом, и дожидается его завершения

Пример «Hello World»

tbb::flow::graph g;

tbb::flow::continue_node< tbb::flow::continue_msg >

h( g, []( const continue_msg & ) { std::cout << “Hello “; } );

tbb::flow::make_edge( h, w );

tbb::flow::continue_node< tbb::flow::continue_msg >

w( g, []( const continue_msg & ) { std::cout << “World\n“; } );

h.try_put(continue_msg());

g.wait_for_all();

f() f()

Типы узлов

Функциональныеузлы

f() f() f(x) f(x)

source_node continue_node function_node multifunction_node

Буферизирующиеузлы

buffer_node queue_node priority_queue_node sequencer_node

Разделяющие и объединяющие

узлы

queueing join reserving join tag matching join split_node indexer_node

Другие

broadcast_node write_once_node overwrite_node limiter_node

Intel TBB Flow Graph позволяет описывать как графы зависимостей, так и граф потока данных

Граф зависимостей

Описывает зависимости между вычислительными узлами, но не специфицирует, каким образом передаются данные

Виды вычислительных графов

continue_node

function_node

Граф потока данных

Описывает не только зависимости между вычислительными узлами, но соединяющие рёбра служат каналами передачи данных

Пример с нелинейными зависимостямиstruct body {

std::string my_name;

body( const char *name ) : my_name(name) {}

void operator()( continue_msg ) const {

printf("%s\n", my_name.c_str());

int main() {

graph g;

broadcast_node< continue_msg > start(g);

continue_node< continue_msg > a( g, body("A") );

continue_node< continue_msg > b( g, body("B") );

continue_node< continue_msg > c( g, body("C") );

continue_node< continue_msg > d( g, body("D") );

continue_node< continue_msg > e( g, body("E") );

make_edge( start, a ); make_edge( start, b );

make_edge( a, c ); make_edge( b, c );

make_edge( c, d ); make_edge( a, e );

for (int i = 0; i < 3; ++i ) {

start.try_put( continue_msg() );

g.wait_for_all();

return 0;

Пример графа, обрабатывающего поток данных

f(x)squarer

summer

struct cube {

int operator()(int v) {

return v * v * v;

class sum {

int &my_sum;

public:

sum( int &s ) : my_sum(s) {}

int operator()( tuple<int, int> v ) {

my_sum += get<0>(v) + get<1>(v);

return my_sum;

struct square {

int operator()(int v)

return v * v;

Пример графа, обрабатывающего поток данныхint main() {

int result = 0;

graph g;

broadcast_node<int> input(g);

function_node<int, int> squarer( g, unlimited, square() );

function_node<int, int> cuber( g, unlimited, cube() );

join_node< tuple<int, int>, queueing > j( g );

function_node< tuple<int, int>, int >

summer( g, serial, sum(result) );

make_edge( input, squarer );

make_edge( input, cuber );

make_edge( squarer, input_port<0>(j) );

make_edge( cuber, input_port<1>(j) );

make_edge( j, summer );

for (int i = 1; i <= 3; ++i)

input.try_put(i);

g.wait_for_all();

printf("Final result is %d\n", result);

return 0;

f(x)squarer

summer1

input.try_put(1);

Максимальный параллелизм = 1

f(x)squarer

summer

input.try_put(2);

f(x)squarer

summer

f(x)squarer

summer

input.try_put(3);

f(x)squarer

summer

f(x)squarer

summer

f(x)squarer

summer

f(x)squarer

summer

Результат = 0Максимальный параллелизм = 6

int result = 0;

f(x)squarer

summer

f(x)squarer

summer

f(x)squarer

summer

f(x)squarer

summer

g.wait_for_all();

printf("Final result is %d\n", result);

f(x)squarer

summer

Разложение Холецкого (𝐴 = 𝐿𝐿𝑇)

(a) flow based implementation

(b) dependence based implementation

Aparna Chandramowlishwaran, Kathleen Knobe, and Richard Vuduc, “Performance Evaluation of Concurrent Collections on High-Performance Multicore Computing Systems”, 2010 Symposium on Parallel & Distributed Processing (IPDPS), April 2010.

Инструмент с графическим интерфейсом, позволяющий:

Создавать вычислительные узлы и задавать зависимости между ними

Генерировать исходный код на C++

Flow Graph Designer

Позволяет запускать приложения, основанные на Intel TBB flow graph, чтобы:

Собрать информацию времени выполнения

Отобразить топологию графа

Получить информацию о проблемах производительности

Экспериментальная версия доступна на whatif.intel.com

Вместо явного указания асинхронности в коде, программист описывает структуру алгоритма; Intel TBB автоматически использует возможности для параллельного исполнения узлов в графе

Планировщик Intel TBB даёт:

автоматическое распределение и динамическую балансировку работы

сочетаемость с другими параллельными конструкциями Intel TBB, например, вложенный параллельный цикл внутри вычислительного узла

Граф сохраняет состояние между запусками и позволяет многократное исполнение

Ограничение Intel TBB flow graph

Не рекомендуется использовать блокирующий API (например, для работы с сетью или диском) внутри узлов графа. В графе может быть использован специальный узел async_node для взаимодействия с внешними активностями

Преимущества Intel TBB flow graph

Планировщик задач вIntel® Threading Building Blocks

Планировщик задач методом перехвата работы: принципКаждый поток имеет двухстороннюю очередь задач:

• Вновь созданные задача кладётся в начало очереди.

• Поток обрабатывает задачи, забирая их из начала очереди.

• Если у потока нет работы:

• Выбирается случайный поток-жертва

• Делается попытка забрать задачу из конца очереди потока-жертвы

Перехват работы в планировщике задач

Каждый процессор имеет свою рабочую очередь.

P P P P

порождение

Порождениезадачи!

P P P P

порождениеПорождение

задачи!Порождение

задачи!

Порождение добавляет задачу в очередь.Это горячий путь! Должен быть быстрым!

Когда задача завершена, из очереди вынимается следующая.

перехват

Перехват!

Когда у процессора нет работы, он перехватывает её у другого процессора.Это “холодный путь”, может стоить дороже.

P P P P

При достаточном параллелизме, перехваты работы редки, и мы получаем линейное ускорение (без учёта эффектов памяти)

Преимущества двухсторонней очереди

Общие операции дёшевы.Накладные расходы на редких операциях.

Доступ к началу очереди есть только у её потока-владельца.

Нет необходимости в дорогих атомарных операциях.

Локальная работа потока находится в начале очереди.

Она была только что порождена скорей всего ещё в кэше.

Нелокальная работа находится в конце очереди.

Порождена раньше всех, скорей всего, из кэша уже вытеснена.

Если код рекурсивно делит по принципу «разделяй и властвуй», ранние задачи будут больше по размеру.

Рекурсивный параллелизм

[Data, Data+N)

[Data, Data+N/2)[Data+N/2, Data+N)

[Data, Data+N/k)

[Data, Data+GrainSize)

Доступные для перехвата задачи

[Data, Data+N)

[Data, Data+N/k)

[Data, Data+GrainSize) Поток сначала исполняет

задачи «в глубину», такимобразом, пользуясь локальностью данных.

[Data, Data+N)

[Data, Data+N/k)

Другие рабочие потоки первоначально перехватывают работу «в ширину», забирая старые, бОльшие куски задачи.

Поток сначала исполняет задачи «в глубину», таким образом, пользуясь локальностью данных.

[Data, Data+N)

[Data, Data+N/k)

Библиотека для параллельного программирования на C++:

Упрощает написание параллельных алгоритмов и скрывает явное управление потоками;

Автоматически адаптируется к системе и позволяет достигнуть максимальной масштабируемости приложения;

Кроссплатформенная: Windows *, Linux *, Mac OS* и другие

http://threadingbuildingblocks.org/

Intel® Threading Building Blocks(Intel® TBB)

Backup

• Конвейер – цепочка из стадий обработки потока данных

• Некоторые стадии могут иметь состояние

• Можно обрабатывать данные по мере поступления: “online”

Примеры: сжатие/распаковка данных, обработка сигналов, фильтрация изображений

Шаблон: Pipeline /* конвейер */

Конвейер

Разные данные на разных стадиях

Разные данные в одной стадии, если там нет состояния

Данные на выходе могут быть переупорядочены

Может понадобиться буферизация между стадиями

parallel_pipeline (

ntoken,

make_filter<void,T>(

filter::serial_in_order,

[&]( flow_control & fc ) -> T{

T item = f();

if( !item ) fc.stop();

return item;

make_filter<T,U>(

filter::parallel, g

make_filter<U,void>(

filter:: serial_in_order, h

Использование конвейера

Стадии конвейера

Серийная стадия может поддерживать состояние

make_filter<X,Y>(

[&]( X x ) -> Y {

extern int count;

++count;

Y y = bar(x);

return y;

Параллельная стадия –функциональное преобразование

make_filter<X,Y>(

filter::parallel,

[]( X x ) -> Y {

Y y = foo(x);

return y;

Преобразование X в Y

Отсутствие «гонок» –ответственность программиста

Данные поступают в порядке, заданном на предыдущей упорядоченной стадии

make_filter<X,void>(

[&]( X x ) {

cout << x;

Стадии конвейера: вход и выход

make_filter<void,Y>(

[&]( flow_control& fc ) -> Y {

cin >> y;

if( cin.fail() ) fc.stop();

return y;

Тип “из” - void

Стадии могут быть любого

типа

Первая стадия получает

специальный аргумент

Результат передаётся дальше по конвейеру, но

игнорируется после flow_control::stop()

Тип “в” - void

Построение конвейера

make_filter<X,Y>(

make_filter<Y,Z>(

• Стадии соединяются при помощи operator&

Тип данных должен совпадать

Алгебра типов

make_filter<T,U>(mode,functor) filter_t<T,U>

filter_t<T,U> & filter_t<U,V> filter_t<T,V>

Запуск конвейера

parallel_pipeline( size_t ntoken,

const filter_t<void,void>& filter );

Ограничение на кол-во данных в

обработке

Цепочка стадий voidvoid.

• Один поток проводит данные через множество этапов

• Предпочтение обработке имеющихся элементов

Эффективное использование

кэша

• Функциональная декомпозиция не масштабируется

• Параллельные стадии улучшают ситуацию

• Производительность ограничена серийными стадиями

Масштаби-руемость

Bzip2: схема конвейера

Read block

Run-length encoding

Output stream

checksum

bit position

output file ptr

Burrows-Wheeler Transform

Move To Front

Run-length Encoding

Huffman Coding

Checksum

Bit-align

Write block

Input stream

input file ptr

Обзор библиотеки Intel® Threading uilding locks · Уровни...

Documents

аппаратное обеспечение устройства ввода. устройства соединения

Аппаратное обеспечение распределенных информационно-управляющих систем встраиваемого класса

Новые уровни технической поддержки LanDocs (СЭД)

Уровни представления ФГОС общего образования

14.2. Сущность жизни Уровни организацииbcp.sociolife.ru/docs/34.Essence_life.pdf · Уровни организации живых систем.

УРОВНИ ОРГАНИЗАЦИИ ЖИВОГО. ОПТИЧЕСКИЕ …repo.knmu.edu.ua/bitstream/123456789/9592/1/Тема 1 САЙТ.pdf · УРОВНИ ОРГАНИЗАЦИИ

Уровни Вселенной и человека

аппаратное обеспечение

Аппаратное программное ...img.armo.ru/files/STC-IP2571A_3570A_FirmwareManual_Rus.pdf · Аппаратное программное обеспечение st

Аппаратное обеспечение информационно-управляющих систем встраиваемого класса

Слайды с вебинара "Уровни и типы тестирования"

Асинхронность и параллелизм в Node.js

Архитектура и аппаратное обеспечение ЭВМ (внешние устройства)

УРОВНИ АБСТРАКЦИИ И ОСНОВНЫЕ КЛАССЫ Вhpc-education.ru/files/lectures/2011/avetisyan/... · ЛЕКЦИЯ 16 УРОВНИ АБСТРАКЦИИ И ОСНОВНЫЕ

аппаратное и программное обеспечение

Технические условия. ГОСТ 9416-83. Уровни строительные.domfacade.ru/files/docs/gost-9416-83.pdf · ГОСТ 9416-83. Уровни строительные

Параллелизм с использованием актеров (Erlang, .NET)

Уровни правового регулирования

Lean UX, Уровни UX, UXD процесс

ГН 2.2.5.2308-07 Ориентировочные безопасные уровни ... · Title: ГН 2.2.5.2308-07 Ориентировочные безопасные уровни