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

966 views

Published on

Intel Software Conference – Maio, 2014
Igor Freitas
igor.freitas@intel.com

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
966
On SlideShare
0
From Embeds
0
Number of Embeds
7
Actions
Shares
0
Downloads
31
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

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

  1. 1. Principais conceitos, técnicas e modelos de programação paralela Intel Software Conference – Maio, 2014 Igor Freitas igor.freitas@intel.com
  2. 2. Agenda 2  Introdução  Memória compartilhada  Memória distribuida  Desafios  Conclusão
  3. 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. 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. 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. 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. 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. 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. 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. 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. 11 Memória compartilhada
  12. 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. 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. 14 Shared Memory Thread 0 Thread 1 e ( ) g ( )h ( ) f ( ) Memória Compartilhada Decomposição de Tarefas via Threads
  15. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 28 Memória distribuída
  29. 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. 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. 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. 32 Desafios
  33. 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. 34 Conclusões
  35. 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. 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. 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

×