1) O documento apresenta os principais conceitos, técnicas e modelos de programação paralela, incluindo memória compartilhada e distribuída. 2) São discutidos padrões como decomposição de domínio, decomposição de tarefas e pipeline para detectar oportunidades de paralelismo. 3) Ferramentas como OpenMP, Intel TBB, Cilk Plus e MPI são apresentadas para implementar programação paralela em memória compartilhada e distribuída.

1. Principais conceitos, técnicas e
modelos de programação
paralela
Intel Software Conference – Maio, 2014
Igor Freitas
igor.freitas@intel.com

2. Agenda
2
 Introdução
 Memória compartilhada
 Memória distribuida
 Desafios
 Conclusão

3. 3
Introdução
1. Decidir a divisão dos blocos de dados entre os processadores
2. Mesma operação, dados diferentes por unidade de execução
Ex: Encontrar o maior elemento em um vetor
CPU 0 CPU 1 CPU 2 CPU 3
Decomposição de domínio
“Data Decomposition”

4. Introdução
4
1. Dividir tarefas entre os processadores
2. Decidir quais elementos de dados serão acessados por qual processador (leitura/escrita)
f()
s()
r()
q()h()
g()
CPU 1
CPU 0
CPU 2
f()
g()
r()
h() q()
r()
s()
Decomposição de tarefas – “Task paralellism”

5. Introdução
5
 Tipo especial de “Task Paralellism”. Também chamado de “Assembly line” parallelism
 Padrão utilizado tanto em software quanto em hardware
 Tasks conectadas em um modelo
“produtor-consumidor”
Pipeline
Stage 4Stage 3Stage 2Stage 1
A1 B1 C1
A2 B2 C2
A3 B3 C
A4

6. for( i = 0; i < 3; i++)
a[i] = b[i]/2.0;
6
b[0] b[1] b[2]
a[0] a[1] a[2]
///
2 2 2
Decomposição de domínio possível
Introdução
Detectando paralelismo

7. for( i = 1; i < 4; i++)
a[i] = a[i-1]*b[i];
7
b[1] b[2] b[3]
a[1] a[2] a[3]
***
a[0]
Decomposição de domínio falha neste caso
Introdução
Detectando paralelismo

8. Introdução
Detectando paralelismo
a = f(x,y,z);
b = g(w,x);
t = a + b;
c = h(z);
s = t/c;
8
Decomposição de
tarefas com 3 cores
x
f
w y z
ab
g
t
c
s/
h
+
CPU 0
CPU 1 CPU 2

9. Introdução
9
Níveis de paralelismo em relação ao hardware
 ILP - Instruction Level Parallelism
 Execução em Pipeline
 Super-scalar - Mais de uma instrução por ciclo de clock
 DLP - Data Level Parallelism
 SIMD (Single Instruction Multiple Data) vector processing
 Implementado via instruções AVX-512, AVX, AVX2, SSE etc.
 TLP - Thread-Level Parallelism
 Arquitetura Multi-core (Intel ® Xeon)
 Arquitetura Many-core (Intel ® Xeon Phi ™)
 Cache-coherent em múltiplos sockets
 CLP - Cluster Level Parallelism
 Múltiplas plataformas conectadas em rede

10. Introdução
10
Como aplicar tais padrões de programação paralela ?
 Das linguagens de programação mais populares, nenhuma foi criada com o
objetivo de explorar paralelismo
 Necessidade de adaptação destas linguagens
 Objetivos
 Performance
e
 Produtividade
e
 Portabilidade
Sequencial
Paralelo
Clusters

11. 11
Memória compartilhada

12. 12
Shared
Memory
Thread 0 Thread 2
Thread 1
f ( )
f ( )
f ( )
Ex: Decomposição de Domínio via Threads
Memória Compartilhada
Decomposição de Domínio via Threads

13. Memória Compartilhada
Decomposição de Domínio via Threads
Código sequencial:
Thread 0
Thread 1
13
for (i = 500; i < 1000; i++) a[i] = foo(i);
for (i = 0; i < 500; i++) a[i] = foo(i);
int a[1000], i;
for (i = 0; i < 1000; i++) a[i] = foo(i);
Private Shared

14. 14
Shared
Memory
Thread 0 Thread 1
e ( )
g ( )h ( )
f ( )
Memória Compartilhada
Decomposição de Tarefas via Threads

15. 15
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;
}
Thread 0
Thread 1
Static variable: Shared
Global to threads: Shared
Function’s local variables: Private
Shared
Variables
Private
Variables
Private
Variables
Thread
Thread
Memória privada e Memória compartilhada
Memória Compartilhada
Decomposição de Tarefas via Threads

16. 16
Thread 0 Thread 2Thread 1
Shared Memory
Input Output
e ( ) f ( ) g ( )
Data
set 2
Data sets
5, 6, ...
Data
set 4 Data
set 3 Data
set 1
Memória Compartilhada
Pipeline via Threads

17. Memória Compartilhada
Modelos de Programação
Facilidade de Uso
Ajuste Fino
Threading
Intel® Math Kernel Library
Intel® Threading Building Blocks
OpenMP
Pthreads
Intel® Cilk™ Plus

18. void foo() /* Intel® Math Kernel Library - C := alpha*op(A)*op(B) + beta*C */
{
float *A, *B, *C; /* Matrices */
sgemm(&transa, &transb, &N, &N, &N, &alpha, A, &N, B, &N, &beta, C, &N);
}
Memória Compartilhada
Intel® Math Kernel Library (Intel® MKL)
Intel® Xeon® processor Intel® Xeon Phi ™ coprocessor
Implicit automatic offloading requires no code
changes, simply link with the offload MKL Library

19.  Paralelismo com 3 palavras-chaves
 cilk_spawn
 cilk_sync
 cilk_for
Cilk™ Plus:
 Projeto Open Source
 Load Balancing
 Sincronização
 Protocolos de comunicação
 Evita estouro de pilha
19
Learn more at http://cilkplus.org
// Parallel function invocation, in C
cilk_for (int i=0; i<n; ++i){
Foo(a[i]);
}
// Parallel spawn in a recursive fibonacci
// computation, in C
int fib (int n) {
if (n < 2) return 1;
else {
int x, y;
x = cilk_spawn fib(n-1);
y = fib(n-2);
cilk_sync;
return x + y;
}
}
Memória Compartilhada
Intel® Cilk™ Plus

20. 20
Master Thread
Thread 1 Thread 2 Thread n-1 Thread n
Cada thread espera as outras
terminarem o trabalho – “wait state”
Master Thread
#pragma omp parallel
#pragma omp for
Thread pool
Memória Compartilhada
Modelo “Fork-Join” via OpenMP Threads

21. 21
Paralelizando um Loop
1. double res[200]; int i;
2. #pragma omp parallel for
3. for (i=0;i< 200; i++) {
4. res[i] = foo();
5. }
Thread 1
res[0] = foo();
res[1] = foo();
res[2] = foo();
res[3] = foo();
Thread 2
res[4] = foo();
res[5] = foo();
res[6] = foo();
res[7] = foo();
Thread N
res[MAX-3] = foo();
res[MAX-2] = foo();
res[MAX-1] = foo();
res[MAX] = foo();
...
Memória Compartilhada
OpenMP

22. Abstração de padrões de programação paralela para C++
 C++ template library
 Alocação escalável de memória
 Load-balancing
 Alocação de tasks “Work-stealing”
 Thread-safe pipeline
 STL-compatible concorrentes
 Algoritmos paralelos
 Primitivas de sincronização
 C++11 Thread Support
//Parallel function invocation example,
in C++,
//using TBB:
parallel_for (0, n, [=](int i)
{
Foo(a[i]);
});
Memória Compartilhada
Intel® Threading Building Blocks (Intel® TBB)

23.  O que diferre TBB de Cilk Plus ?
 TBB
 Template library:
 sem mudanças de compilador (portabilidade)
 Não suporta vetorização
 Computação paralela para C++
 Múltiplos padrões de programação paralela
 Ex.: Pipelines, dataflow, unstructure task graphs
 Alocação de memória
Memória Compartilhada
Intel® Threading Building Blocks (Intel® TBB)

24. Memória Compartilhada
Intel® Threading Building Blocks (Intel® TBB)
Exemplo: Padrão “Pipeline” no TBB
Fonte: Intel ® TBB distribution: diretório “examples/pipeline/square”
Artigo no Intel ® Developer Zone:
https://software.intel.com/en-us/blogs/2011/09/14/how-to-make-a-pipeline-with-an-intel-threading-building-blocks-flow-
graph
Lê um bloco de texto de um
arquivo de tamanho fixo.
Envia para a função
“transform”
Aloca um buffer de saída
Converte cada string em long
Eleva o número ao quadrado
Escreve o resultado no buffer
de saída
Filtra o resultado em ordem
sequencial
Escreve em arquivo de saída

25. Memória Compartilhada
Intel® Threading Building Blocks (Intel® TBB)
Exemplo: Padrão Pipeline
tbb::pipeline pipeline;
MyInputFilter input_filter( input_file );
pipeline.add_filter( input_filter );
MyTransformFilter transform_filter;
pipeline.add_filter( transform_filter );
MyOutputFilter output_filter( output_file );
pipeline.add_filter( output_filter );
pipeline.run( nthreads*4 );
class MyInputFilter: public tbb::filter {
public:
MyInputFilter( FILE* input_file_ );
~MyInputFilter();
…
/*override*/ void* operator()(void*);
};
class MyTransformFilter: public tbb::filter {
…
};
class MyOutputFilter: public tbb::filter {
...
}

26. Memória Compartilhada
Intel® Threading Building Blocks (Intel® TBB)
Pipeline para Task Graph
tbb::flow::graph g;
tbb::flow::limiter_node limiter( g, nthreads*4 );
tbb::flow::sequencer_node< TextSlice * > sequencer(g, sequencer_body() );
tbb::flow::source_node input( g, MyInputFilter(input_file), false );
tbb::flow::function_node transform( g, tbb::flow::unlimited, MyTransformFilter() );
tbb::flow::function_node output( g, tbb::flow::serial, MyOutputFilter( output_file ) );
tbb::flow::make_edge( input, limiter );
tbb::flow::make_edge( limiter, transform );
tbb::flow::make_edge( transform, sequencer );
tbb::flow::make_edge( sequencer, output );
tbb::flow::make_edge( output, limiter.decrement );
input.activate();
g.wait_for_all();

27. 27
OpenMP Fortran 2008 Intel® TBB Intel® Cilk Plus
Site openmp.org fortranwiki.org opentbb.org cilkplus.org
Lançamento 1997 2010 2006 2010
Linguagens Fortan, C, C++ Fortran C++ C/C++
Descrição
Diretivas do Compilador
(pragmas), runtime
library
Extensão de
linguagem para
adicionar paralelismo
Extensão da linguagem para
adicionar paralelismo via
templates
Extensão da linguagem para
multithreading/vetorização
Método Pragmas Keywords Templates
Keywords, atributos e
pragmas
Especificação By OpenMP ISO/IEC 1539-1:2010 Open Source iniciado pela Intel®
Especificação aberta iniciada
pela Intel®
Funcionalidades
Loops paralelos, tasks,
locks
Programação paralela
Loops paralelos e algoritmos,
alocação de memória
Loops paralelos, vetorização,
array notations, elemental
functions, compatível com
TBB
Funcionalidades
Únicas
Amplamente adotada
pela comunidade HPC
DO CONCURRENT,
Coarrays
Independente de compilador, uso
em vários tipos de aplicações,
alocação de memória, suporte a
outros modelos de programação
paralela
Garantia de performance em
loadbalance, vetorização,
array notations e elemental
functions
Memória Compartilhada
Modelos de Programação

28. 28
Memória distribuída

29. 29
CORE
CORE
CORE
CORE
CORE
CORE
CORE
CORE
N1
I/O
P1 P2
N2
I/O
N3
I/O
N4
I/O
Network Interconnect
P1 P2 P1 P2 P1 P2
. . .
. . .
CO-PROCESSOR
M
Memória Distribuida
Hierarquia em sistemas de memória distribuída
• Memória distribuída
• Troca de mensagens em vários níveis
• Nós
• Processadores
• Cores
P3 P4

30. Troca de mensagens MPI
30
Process 0
User Space
Kernel Space
Send Buffer
System Buffer
Call send
function
Copy data
Safe to reuse
send buffer
Process 1
User Space
Kernel Space
Receive Buffer
System Buffer
Call
receive
function
Receive
data
Copy data
Pontos principais:
1. Envio/Recebimento
de dados é uma
operação pareada
2. Comunicação e
sincronização são
acoplados

31. Message-Passing Interface (MPI)
Intel® MPI Library
Biblioteca para comunitação entre processos e troca de dados
Principais funções
 Escalável para até 120 mil processos
 Independente do tipo de conexão de rede
 Escolha da “Fabric” em tempo de execução
31

32. 32
Desafios

33. 33
Parallel Overhead:
Sincronização
 Bandwith suficiente para comunicação entre as threads ?
Load balance
 Distribuição de carga não otimizada
 Threads ociosas ?
Escalabilidade
 Mais threads, mais performance ?
Desafios
0
1
2
3
1 2 3 4
Threads

34. 34
Conclusões

35. Conclusões
Padrões de Prog. Paralela c/ as Ferramentas corretas
 Recomendações:
 Identificar padrões de paralelismo na aplicação
 Utilizar a abordagem/ferramenta correta para cada caso
 Aproveitar todos os cores do processador
 Evitar overhead do paralelismo
 Resultados esperados:
 Ganhar performance !
 Porém, com Portabilidade & Produtividade

36. Arquitetura Intel® MIC para
workloads massivamente
paralelos
+
Many-core
Mesma
arquitetura de software
Multicore
Indicado para a maioria das
aplicações / workloads
Conclusões
Padrões de Prog. Paralela c/ as Ferramentas corretas
Código

37. ©2014, Intel Corporation. All rights reserved. Intel, the Intel logo, Intel Inside, Intel Xeon, and Intel Xeon Phi are trademarks of Intel Corporation in the U.S. and/or other countries. *Other names and brands may be claimed as the property of others.
37