principais conceitos técnicas e modelos de programação paralela

Principais conceitos, técnicas e modelos de programação paralela Intel Software Conference – Maio, 2014 Igor Freitas [email protected]

Agenda

2

Introdução

Memória compartilhada

Memória distribuida

Desafios

Conclusão

http://software.intel.com/en-us/articles/optimization-notice

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”


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”


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 4 Stage 3 Stage 2 Stage 1

A1 B1 C1

A2 B2 C2

A3 B3 C

A4


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


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




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

a b

g

t

c

s /

h

+

CPU 0 CPU 1 CPU 2


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


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

Memória compartilhada


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


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

Shared

Memory

Thread 0 Thread 1

e ( )

g ( ) h ( )

f ( )

Memória Compartilhada Decomposição de Tarefas via Threads


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

Thread 0 Thread 2 Thread 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


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


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


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

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

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


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)


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




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



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 {

...

}



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

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

Memória distribuída


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


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


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

Desafios


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

Conclusões


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


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


©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

principais conceitos técnicas e modelos de programação paralela

Documents