CMP 167– Programação com Objetos Distribuídos Prof. Cláudio Geyer

Apresentação em tema: "CMP 167– Programação com Objetos Distribuídos Prof. Cláudio Geyer"— Transcrição da apresentação:

1 CMP 167– Programação com Objetos Distribuídos Prof. Cláudio Geyer
Algoritmo Paralelo para Estimação de Movimento CMP 167– Programação com Objetos Distribuídos Prof. Cláudio Geyer Eduarda Monteiro Porto Alegre, Julho de 2012

2 Sumário Introdução Conceitos Básicos Implementação Resultados
Conclusão

3 Conceitos Básicos Compressão de Vídeos Digitais Quadro Blocos x y
Número de Pixels Um vídeo é composto de uma sequencia de imagens estaticas tambem denomindas de quadros; A compressao de vídeos divide os quadros em blocos; Onde o processo é realizado bloco a bloco No h.264 os blocos podem ser de diferentes tamanhos... Neste trabalho a dimensao 4x4 será abordada Particionamento em blocos 16x16 16x8 8x8 4x8 4x4

4 Conceitos Básicos Compressão de Vídeos Digitais Vídeo Tn+1 Tn Tn+2
Aqui pode-se perceber uma sequencia de quadros Onde o processamento desses quadros a uma dada frequencia de tempo, induzem a percepção de movimento; A partir disso, pode-se perceber uma grande similaridade entre eles, E é a partir desta caracteristica, a similaridade existente entre imagens proximas ou dentro das mesmas, que a compressao de video está baseada.

5 Conceitos Básicos Diagrama de Blocos de um Codificador de Vídeo INTER
Predição INTER Quadro Atual (original) T Q Codificação de Entropia - Estimação de Movimento Quadro de Referência Compensação de Movimento - Aqui pode-se visualizar uma visão geral do diagrama de blocos de um codificador de video. Pode-se perceber os blocos referente a Transformada e Quantização; (T e Q) que são blocos aritmeticos responsaveis pelo residuos da codificação Tem também a codificação de entropia; Responsavel (codif. Entropia) pela codificação dos simbolos e do empacotamento final. Tem tambem o processo inverso para que o quadro reconstruido seja obtido e utilizado na codifcacao dos proximos quadros. Dentro desse processo inverno, as transformadas inversas e quantização, alem disso o filtro que reduz o efeito de bloco, uma suavização nas imagens; E o principal modulo, que é a predição que é composta por 3 blocos: predição intra quadro, compensação de movimento e a estimação de movimento. Dentro da predição este trabalho aborda a estimação de movimento, que é o bloco mais complexo computacionalmente dentre os blocos que foram expostos aqui. O principal modulo é a predição composta de 3 blocos, me mc e intra. Codificação de entropia reponsaveis pelo codificação dos simbolos e empacomanto Os filtos que reduzem efeito de bloco, suavizar as bordas das imagens. Dentro desses blocos o mais complexo e foco deste de trabalho é a estimação de movimento Predição INTRA Quadro Atual (reconstruído) Filtro IT IQ +

6 Conceitos Básicos Estimação de Movimento (ME)
Codificação de vídeo visa eliminar informações redundantes; Explora a redundância temporal; Alta correlação entre quadros consecutivos; Busca similaridades entre quadros vizinhos em um vídeo. Procura em um (ou mais) quadros de referência (previamente reconstruído) um bloco que se assemelha com o bloco do quadro atual – Melhor Casamento. Um vetor de movimento é gerado para cada bloco atual. A codificação de video visa eliminar informações redundantes. Existem diferentes tipos de redundancias: Entre elas, foco do trabalho existe a redundancia temporal que esta relacionada com a correlação existe entre quadros consecutivos. Explicar no primeiro item ideia de que os quadros proximos são similares: taxa de 30 quadros, se mexem pouco: - Em um video é intuitivo pensar que quadros proximos são semelhantes, em uma cena os objetos se mexem pouco ou ate mesmo não se mexem - Considerando que a taxa de reprodução padrao é de 30 quadros por segundo.

7 Conceitos Básicos Estimação de Movimento (ME) Área de Busca
Vetor de Movimento Área de Busca -Não esquecer de mencionar BLOCOS CANDIDATOS. -Ao final da explicação deste slide: Falar do criterio de similaridade - Qual o critério utilizado na litetura para comparação neste contexto? Existem diversos criterios de similaridade existentes, porem neste trabalho é utilizado o cálculo de SAD. Quadro de Referência Quadro Atual Implementação e Análise de Algoritmos para ME em Processadores Paralelos tipo GPU

8 Conceitos Básicos Estimação de Movimento (ME) Métrica de Comparação
SAD (Sum of Absolute Differences) Emprega o uso de algoritmos para encontrar as similaridades existentes: Algoritmos de Busca: Diversos algoritmos podem ser encontrados na literatura: Full Search (FS) O calculo de SAD é comumente utilizado na litetura, um dos motivos é pela sua simplicidade. Ele consiste na soma das diferenças absolutas, entre o bloco candiato e o bloco atual. A Estimação de Movimento necessita de um algoritmo que guie o modo como a busca pelas similaridades será realizado. Algoritmos existentes na literatura: FS e DS. Resolução 1920 x 1080: Area de busca 64x64 Tamanho do bloco 4x4 Diamond em geral o melhor casamento esta no centro ou perto do centro.

9 Conceitos Básicos Estimação de Movimento Algoritmo Full Search (FS)
Exaustivo – maior custo computacional; Busca realizada de modo que os blocos se desloquem pixel a pixel dentro da área de busca; Resultados ótimos

10 Conceitos Básicos Full Search Área de Busca Quadro de Referência
Vetor de Movimento Área de Busca Quadro de Referência Quadro Atual

11 Conceitos Básicos OpenMP Paralelismo Explícito Memória Compartilhada
Anotações são realizadas pelo programador. Memória Compartilhada Baseado em Threads Variáveis podem ser: Compartilhadas: acesso por todas as threads Protegidas: duplicadas para cada thread. __________________________________________________ 1. #include <omp.h> 2. main() { 3. 4. int var1, var2, var3; 5. 6. parte_sequencial_1(); 7. #pragma omp parallel private(var1,var2) shared(var3) 8.{ 9.. parte_paralela(); // executada pelas threads 11. } 12. parte_sequencial_2(); }

12 Implementação Ideia Geral
Entrada: Sequencia de Vídeo em diferentes formatos YUV Objetivo: Estimação de Movimento para diferentes áreas de busca de diversas dimensões 1: largura  argumento {largura do quadro}; 2: altura  argumento {altura do quadro} 3: TamanhoAreaBusca argumento {dimensao da area de busca} 4: NumQuadros  2 5: TamanhoBloco  4; 6: 7: image  sequencia de video 8: AreaBusca TamanhoAreaBusca x TamanhoAreaBusca {alocação da area de busca} 9: Bloco Atual TamanhoBloco x TamanhoBloco {alocação bloco atual}; 10: PARA cada bloco atual do quadro 11: carrega Bloco Atual 12: carrega AreaBusca 13: 14: Realiza SAD; 15: 16: FIM PARA 17: retorna Vetores Movimento

13 Implementação Versão OpenMP
SAD  TamanhoBloco * TamanhoBloco * INT_MAX; {vetor que armazena menores valores de SAD} SAD_vector  AreaBuscaL* AreaBuscaB; {vetor que armazena blocos candidatos} Num_Threads  4; Chunk_Full_Search  floor(log(Search Area Size)); Chunk_Full_Decision floor(log(Search Area Size * Search Area Size); 6: #pragma omp parallel 7: seta numero de threads; 8: #pragma omp for schedule (Static, Chunk_Full_Search) 9: PARA cada pixel que compoe a area de busca - Largura 10: #pragma omp parallel for schedule (Static, Chunk_Full_Search) private (indices) shared (SAD_vector) 11: PARA cada pixel que compoe a area de busca - Largura 12: acc = acumulador de valores de SAD; 13: PARA cada pixel que compoe o bloco - Altura 14: PARA cada pixel que compoe o bloco - Altura 15: acc  acc + abs (blocoCandidato[indices] – BlocoAtual[indices]; 16: fim PARA 17: fim PARA 18: SAD_vector [ indices]  acc; 19: fim PARA 20: fim PARA 21: #pragma omp parallel for schedule (Static, Chunk_Decision) 22: PARA cada elemento do vetor de SAD 23: if SAD_vector[k] < SAD_vector[k+1] then 24: SAD = SAD_vector[k]; 25: else 26: SAD = SAD_vector[k+1]; 27: fim PARA

14 Implementação Versão OpenMP Região Paralela
SAD  TamanhoBloco * TamanhoBloco * INT_MAX; {vetor que armazena menores valores de SAD} SAD_vector  AreaBuscaL* AreaBuscaB; {vetor que armazena blocos candidatos} Num_Threads  4; Chunk_Full_Search  floor(log(Search Area Size)); Chunk_Full_Decision floor(log(Search Area Size * Search Area Size); 6: #pragma omp parallel 7: seta numero de threads; 8: #pragma omp for schedule (Static, Chunk_Full_Search) 9: PARA cada pixel que compoe a area de busca - Largura 10: #pragma omp parallel for schedule (Static, Chunk_Full_Search) private (indices) shared (SAD_vector) 11: PARA cada pixel que compoe a area de busca - Largura 12: acc = acumulador de valores de SAD; 13: PARA cada pixel que compoe o bloco - Altura 14: PARA cada pixel que compoe o bloco - Altura 15: acc  acc + abs (blocoCandidato[indices] – BlocoAtual[indices]; 16: fim PARA 17: fim PARA 18: SAD_vector [ indices]  acc; 19: fim PARA 20: fim PARA 21: #pragma omp parallel for schedule (Static, Chunk_Decision) 22: PARA cada elemento do vetor de SAD 23: if SAD_vector[k] < SAD_vector[k+1] then 24: SAD = SAD_vector[k]; 25: else 26: SAD = SAD_vector[k+1]; 27: fim PARA Região Paralela

15 Implementação Versão OpenMP Divisão da área de busca entre as threads
SAD  TamanhoBloco * TamanhoBloco * INT_MAX; {vetor que armazena menores valores de SAD} SAD_vector  AreaBuscaL* AreaBuscaB; {vetor que armazena blocos candidatos} Num_Threads  4; Chunk_Full_Search  floor(log(Search Area Size)); Chunk_Full_Decision floor(log(Search Area Size * Search Area Size); 6: #pragma omp parallel 7: seta numero de threads; 8: #pragma omp for schedule (Static, Chunk_Full_Search) 9: PARA cada pixel que compoe a area de busca - Largura 10: #pragma omp parallel for schedule (Static, Chunk_Full_Search) private (indices) shared (SAD_vector) 11: PARA cada pixel que compoe a area de busca - Largura 12: acc = acumulador de valores de SAD; 13: PARA cada pixel que compoe o bloco - Altura 14: PARA cada pixel que compoe o bloco - Altura 15: acc  acc + abs (blocoCandidato[indices] – BlocoAtual[indices]; 16: fim PARA 17: fim PARA 18: SAD_vector [ indices]  acc; 19: fim PARA 20: fim PARA 21: #pragma omp parallel for schedule (Static, Chunk_Decision) 22: PARA cada elemento do vetor de SAD 23: if SAD_vector[k] < SAD_vector[k+1] then 24: SAD = SAD_vector[k]; 25: else 26: SAD = SAD_vector[k+1]; 27: fim PARA Divisão da área de busca entre as threads

16 Implementação Versão OpenMP Divisão de tarefa entre as threads
SAD  TamanhoBloco * TamanhoBloco * INT_MAX; {vetor que armazena menores valores de SAD} SAD_vector  AreaBuscaL* AreaBuscaB; {vetor que armazena blocos candidatos} Num_Threads  4; Chunk_Full_Search  floor(log(Search Area Size)); Chunk_Full_Decision floor(log(Search Area Size * Search Area Size); 6: #pragma omp parallel 7: seta numero de threads; 8: #pragma omp for schedule (Static, Chunk_Full_Search) 9: PARA cada pixel que compoe a area de busca - Largura 10: #pragma omp parallel for schedule (Static, Chunk_Full_Search) private (indices) shared (SAD_vector) 11: PARA cada pixel que compoe a area de busca - Largura 12: acc = acumulador de valores de SAD; 13: PARA cada pixel que compoe o bloco - Altura 14: PARA cada pixel que compoe o bloco - Altura 15: acc  acc + abs (blocoCandidato[indices] – BlocoAtual[indices]; 16: fim PARA 17: fim PARA 18: SAD_vector [ indices]  acc; 19: fim PARA 20: fim PARA 21: #pragma omp parallel for schedule (Static, Chunk_Decision) 22: PARA cada elemento do vetor de SAD 23: if SAD_vector[k] < SAD_vector[k+1] then 24: SAD = SAD_vector[k]; 25: else 26: SAD = SAD_vector[k+1]; 27: fim PARA Divisão de tarefa entre as threads

17 Implementação Experimentos: CPU: Área Paralelizada: Bloco: Thread:
Intel Quad-core 2.4GHz Área Paralelizada: Resolução do Quadro utilizada: 352x288 (CIF) Bloco: Área de Busca (16x16, 32x32, 64x64, 128x128, 240x240). Thread: Um bloco do quadro atual (4x4 pixels). Total de 4 threads – OpenMP Média de 30 execuções para cada dimensão área de busca

18 Resultados OpenMP x Sequencial – Tempo de Processamento (s)

19 Resultados OpenMP x Sequencial – Tempo de Processamento (s)

20 Resultados OpenMP x Sequencial – Tempo de Processamento (s)

21 Resultados OpenMP – Speed-up

22 Resultados OpenMP – Speed-up Crescimento Maior Volume de dados

23 Resultados OpenMP x MPI – Tempo de Processamento

24 Resultados OpenMP x MPI – Tempo de Processamento MPI  Comunicação

25 Resultados OpenMP x MPI – Speed-up

26 Comportamento Coerente
Resultados OpenMP x MPI – Speed-up Comportamento Coerente

27 Conclusões Compressão de Vídeo: Algoritmo FullSearch para Estimação de Movimento; Aplicação: Exaustiva; Massivamente paralela: independência de dados; Comparação Sequencial x OpenMP: Pouco ganho – OpenMP Custo / threads x Volume de Execução Comparação OpenMP x MPI OpenMP – melhor desempenho MPI: comunicação.

28 CMP 167– Programação com Objetos Distribuídos Prof. Cláudio Geyer
Algoritmo Paralelo para Estimação de Movimento CMP 167– Programação com Objetos Distribuídos Prof. Cláudio Geyer Eduarda Monteiro Porto Alegre, Julho de 2012