COMPUTAÇÃO ESCALÁVEL

Sumário
SEMANA 1, AULA 1. ........................................................................................................................................................................ 9
SISTEMA ESCALÁVEL. ...................................................................................................................................................................... 9
COMPUTAÇÃO PARALELA. .............................................................................................................................................................. 9
RECURSOS DA COMPUTAÇÃO PARALELA. ...................................................................................................................................... 9
COMPUTAÇÃO DISTRIBUÍDA .......................................................................................................................................................... 9
CONCEITO CHAVE DA COMPUTAÇÃO DISTRIBUÍDA: TRANSPARÊNCIA. ......................................................................................... 9
COMPUTAÇÃO DISTRIBUÍDA • VANTAGENS. ................................................................................................................................. 9
COMPUTAÇÃO DISTRIBUÍDA, DESVANTAGENS. ........................................................................................................................... 10
COMPUTAÇÃO PARALELA – COMPLEXIDADE. .............................................................................................................................. 10
APLICAÇÕES DE COMPUTAÇÃO PARALELA E DISTRIBUÍDA. ......................................................................................................... 10
SEMANA 1, AULA 2. ...................................................................................................................................................................... 10
a) Tarefa (Task). ........................................................................................................................................................................ 10
b) Tarefa Paralela (Parallel Task). .............................................................................................................................................. 10
c) Execução Serial (Serial Execution). ....................................................................................................................................... 10
d) Execução Paralela (Parallel Execution .................................................................................................................................. 10
e) Escalonamento...................................................................................................................................................................... 10
f) Granularidade. ...................................................................................................................................................................... 10
g) Sincronização (Synchronization). .......................................................................................................................................... 11
h) Speedup. ............................................................................................................................................................................... 11
i) Pipelinning. ........................................................................................................................................................................... 11
O QUE É SISTEMA ESCALÁVEL? ..................................................................................................................................................... 11
O QUE É COMPUTAÇÃO PARALELA?............................................................................................................................................. 11
RECURSOS DA COMPUTAÇÃO PARALELA. .................................................................................................................................... 11
COMPUTAÇÃO DISTRIBUÍDA. ....................................................................................................................................................... 11
CONCEITO CHAVE DA COMPUTAÇÃO DISTRIBUÍDA. TRANSPARÊNCIA. ....................................................................................... 11
COMPUTAÇÃO DISTRIBUÍDA . VANTAGENS. ................................................................................................................................ 12
COMPUTAÇÃO DISTRIBUÍDA. DESVANTAGENS. .......................................................................................................................... 12
COMPUTAÇÃO PARALELA. COMPLEXIDADE. ................................................................................................................................ 12
APLICAÇÕES DE COMPUTAÇÃO PARALELA E DISTRIBUÍDA. ......................................................................................................... 12
Tarefa (Task). ................................................................................................................................................................................ 12
Tarefa Paralela (Parallel Task). ...................................................................................................................................................... 12
Execução Serial (Serial Execution). ............................................................................................................................................... 13
Execução Paralela (Parallel Execution). ........................................................................................................................................ 13
Escalonamento.............................................................................................................................................................................. 13
Granularidade ............................................................................................................................................................................... 13
Sincronização (Synchronization). .................................................................................................................................................. 13
Speedup. ....................................................................................................................................................................................... 13
Pipelinning. ................................................................................................................................................................................... 13

1
PERGUNTA.O que indica a relação entre computação e comunicação de trechos de código gerados a partir da divisão dos
problemas a ser resolvido é conhecido como: .............................................................................................................................. 13
PERGUNTA. Um conceito chave de um sistema distribuído é? .................................................................................................... 14
PERGUNTA. É um desafio da programação paralela em que os programas deveriam tirar vantagem do aumento do número
de processadores .......................................................................................................................................................................... 14
Resposta certa. A escalabilidade de uma solução computacional depende de inúmeros fatores (quantidade de elementos
computacionais, rede etc.) e isso afeta inclusive o resultado da solução, em especial o tempo de resposta. ........................... 14
PERGUNTA. No contexto de linguagens de programação é comum aparecer os termos concorrência e paralelismo. Assinale a
alternativa correta: ....................................................................................................................................................................... 14
PERGUNTA. São inúmeras as aplicações de computação paralela e distribuída no contexto atual. Em relação à computação
paralela e à computação distribuída, analise as afirmações. ....................................................................................................... 14
PERGUNTA. ................................................................................................................................................................................... 15
PERGUNTA. O paralelismo pode ser inviável quando há dependências sequenciais. Uma alternativa para isso consiste em: .. 15
PERGUNTA. Aplicações com paralelismo implícito. ..................................................................................................................... 15
SEMANA 2. .................................................................................................................................................................................... 15
Razões - Computação Paralela...................................................................................................................................................... 15
Speedup. ....................................................................................................................................................................................... 15
o que significa multicore? ............................................................................................................................................................. 16
Otimização da execução de um único fluxo de instruções através de Pipelining: ....................................................................... 16
Otimização da execução de um único fluxo de instruções através de Execução fora de ordem: ................................................ 16
Otimização da execução de um único fluxo de instruções através de Previsão de desvios e execução especulativa ................ 16
Processadores de múltiplas emissões: ......................................................................................................................................... 16
Arquiteturas VLIW - EPIC: ............................................................................................................................................................. 16
Unidades SIMD: ............................................................................................................................................................................ 16
Limitações para otimizar a execução de um único fluxo de instruções : Problema: .................................................................... 16
Paralelismo no nível de threads.................................................................................................................................................... 17
Potência e paralelismo no nível de instrução ............................................................................................................................... 17
1. Exemplos de máquinas MIMD: Multiprocessador de memória compartilhada simétrica (SMP). ....................................... 17
Exemplos de máquinas MIMD: Multiprocessador de memória compartilhada Distribuída- Não Uniforme ............................... 17
Exemplos de máquinas MIMD: Cluster ......................................................................................................................................... 17
Symmetric Multiprocessors (SMP). .............................................................................................................................................. 17
Multiprocessadores com memória compartilhada centralizada .................................................................................................. 17
Multiprocessadores com memória compartilhada distribuída (DSM). ........................................................................................ 18
Multiprocessadores com memória compartilhada. ..................................................................................................................... 18
Métrica de desempenho:.............................................................................................................................................................. 18
SEMANA 2, AULA1. ....................................................................................................................................................................... 18
ARQUITETURA DE MEMÓRIA, MEMÓRIA COMPARTILHADA. ...................................................................................................... 18
UNIFORM MEMORY ACCESS (UMA). ............................................................................................................................................ 18
NON-UNIFORM MEMORY ACCESS. ............................................................................................................................................... 19
VANTAGENS DA MEMÓRIA COMPARTILHADA. ............................................................................................................................ 19
DESVANTAGENS DA MEMÓRIA COMPARTILHADA....................................................................................................................... 19
ARQUITETURA DE MEMÓRIA, MEMÓRIA DISTRIBUÍDA. .............................................................................................................. 19

2
VANTAGENS DA MEMÓRIA DISTRIBUÍDA. .................................................................................................................................... 19
DESVANTAGENS DA MEMÓRIA DISTRIBUÍDA............................................................................................................................... 19
MODELOS DE PROGRAMAÇÃO. .................................................................................................................................................... 19
MODELO DE MEMÓRIA COMPARTILHADA. .................................................................................................................................. 20
MODELO DE MEMÓRIA DISTRIBUÍDA. .......................................................................................................................................... 20
MODELO DE MEMÓRIA DISTRIBUÍDA. IMAGEM. ......................................................................................................................... 20
ARQUITETURA DE VON NEUMANN. ............................................................................................................................................. 20
CLASSIFICAÇÃO DAS ARQUITETURAS. .......................................................................................................................................... 20
CLASSIFICAÇÃO DAS ARQUITETURAS, 4 classes. .......................................................................................................................... 21
SISD Single Instruction, Single Data. ............................................................................................................................................ 21
SIMD Single Instruction, Multiple Data. ....................................................................................................................................... 21
MISD Multiple Instruction, Single Data......................................................................................................................................... 21
MIMD Multiple Instruction, Multiple Data. .................................................................................................................................. 21
Sistemas Multicore. ...................................................................................................................................................................... 21
PERGUNTA. São características de processadores com memória compartilhada distribuída: .................................................... 22
PERGUNTA . Considere a classificação de Flynn para arquiteturas de computadores e verifique a que se encaixa no contexto
de múltiplas instruções e múltiplos dados (MIMD). ..................................................................................................................... 22
PERGUNTA. Um processador equipado com paralelismo no nível de threads pode executar processos separados do código,
sendo possível rodar dois processos de um mesmo aplicativo ao mesmo tempo. ..................................................................... 22
PERGUNTA. Analise as afirmações................................................................................................................................................ 22
PERGUNTA 5. A métrica de desempenho que é muito utilizada para comparar processamento com apenas um núcleo e vários
núcleos é chamada de: ................................................................................................................................................................. 22
PERGUNTA 6. ................................................................................................................................................................................ 23
SEMANA 3, AULA 1. ...................................................................................................................................................................... 23
POR QUE SE PREOCUPAR COM A INFRAESTRUTURA? ................................................................................................................. 23
OUTRAS QUESTÕES SOBRE INFRAESTRUTURA NÃO MENOS IMPORTANTES QUE TAMBÉM SE DESTACAM: ............................. 23
COMPONETES- GRANULARIDADE FINA. ....................................................................................................................................... 23
COMPONENTES - GRANULARIDADE GROSSA. .............................................................................................................................. 23
OPEN COMPUTER PROJECT. ......................................................................................................................................................... 23
O PROJETO OPEN COMPUTER PROJECT EM LINHAS GERAIS PROMOVE: .................................................................................... 24
NO PROJETO DE HARDWARE PARA NUVEM EM GRANDE ESCALA: ............................................................................................. 24
SEMANA 3, AULA 2 - CLUSTER. ..................................................................................................................................................... 24
COMPONENTES DE CLUSTER. ....................................................................................................................................................... 24
CATEGORIAS DE CLUSTER- ALTA DISPOBILIDADE. ........................................................................................................................ 24
CATEGORIAS DE CLUSTER- BALANCEAMENTO DE CARGA. .......................................................................................................... 24
CATEGORIAS DE CLUSTER- ALTO DESEMPENHO. ......................................................................................................................... 25
CATEGORIAS DE CLUSTER - ALTO DESEMPENHO - COMO FUNCIONA? ....................................................................................... 25
COMPONENTES - BENEFÍCIOS....................................................................................................................................................... 25
COMPONENTES - TIPOS DE APLICAÇÕES. ..................................................................................................................................... 25
COMPONENTES - LIMITAÇÕES. .................................................................................................................................................... 25
SEMANA 3, AULA 3. ...................................................................................................................................................................... 25
O QUE É UM GRID? ....................................................................................................................................................................... 25
3
GRID - CARACTERÍSTICAS. ............................................................................................................................................................. 25
GRID - PERVASIVIDADE. ................................................................................................................................................................ 26
GRID - VISÃO UNIFORME DOS RECURSOS COMPUTACIONAIS. .................................................................................................... 26
GRID - ARMAZENAMENTO REMOTO DE DADOS. ......................................................................................................................... 26
INFRAESTRUTURA MIDDLEWARE PARA GERENCIAMENTO DO GRID........................................................................................... 26
FUNDAMENTADO EM TECNOLOGIAS JÁ EXISTENTES E DISPONÍVEIS. ......................................................................................... 26
Globus Toolkit. .............................................................................................................................................................................. 26
INTERNET X WWW X GRID X CLOUD ............................................................................................................................................ 26
SEMANA 3, AULA 4. ...................................................................................................................................................................... 27
O QUE É UMA CLOUD? ................................................................................................................................................................. 27
CLOUD - CARACTERÍSTICAS ........................................................................................................................................................... 27
GRID - CARACTERÍSTICAS. ............................................................................................................................................................. 27
MODELOS DE SERVIÇOS DE CLOUD, SAAS. ................................................................................................................................... 27
MODELO DE SERVIÇOS DE CLOUD, PAAS...................................................................................................................................... 27
MODELO DE SERVIÇOS DE CLOUD, IAAS....................................................................................................................................... 27
SERVIÇOS DE CLOUD – imagem. ................................................................................................................................................... 27
CLOUD, MODELO DE IMPLANTAÇÃO PÚBLICA. ............................................................................................................................ 28
CLOUD, MODELO DE IMPLATANÇÃO PRIVADA. ........................................................................................................................... 28
CLOUD, MODELO DE IMPLANTAÇÃO HÍBRIDA. ............................................................................................................................ 28
CLOUD, INFRAESTRUTURA. ........................................................................................................................................................... 28
PERGUNTA. Em relação à importância da infraestrutura para desenvolver soluções computacionais escaláveis, é correto
afirmar que: .................................................................................................................................................................................. 28
PERGUNTA. Uma definição conhecida de cluster de computadores é: ....................................................................................... 28
PERGUNTA. Trata-se de uma característica de Grid Computing em que o usuário executa uma aplicação no Grid sem saber
quais são os nós envolvidos na computação. ............................................................................................................................... 28
PERGUNTA. O modelo SaaS no contexto de Cloud Computing significa: ..................................................................................... 29
ATIVIDADE AVALIATIVA ................................................................................................................................................................ 29
PERGUNTA. Acerca dos tipos de cluster no contexto de computação escalável é correto afirmar que: ................................... 29
PERGUNTA. A metodologia para a construção de um cluster Beowulf envolve: ......................................................................... 29
PERGUNTA.A Grade (Grid) é uma plataforma para execução de aplicações paralelas amplamente distribuída, heterogênea e
compartilhada. Outras importantes características da grade incluem: ....................................................................................... 29
PERGUNTA. São características fundamentais da Computação em Nuvem segundo o Instituto Nacional de Padrões e
Tecnologia do Departamento de Comércio Norte-Americano (NIST): ......................................................................................... 29
PERGUNTA. ................................................................................................................................................................................... 30
PERGUNTA. Um cluster Beowulf é caracterizado como: .............................................................................................................. 30
PERGUNTA. A computação em grade (Grid Computing) caracteriza-se pela coleção de recursos computacionais de
comunicação utilizado para a execução de aplicações. São características de uma Grade (Grid):.............................................. 30
O QUE É OPEN M.P.? .................................................................................................................................................................... 30
Objetivos do Open M.P.. ............................................................................................................................................................... 30
Componentes do Open M.P.. ....................................................................................................................................................... 30
Limitações do Open M.P.. ............................................................................................................................................................. 31
MODELO DE PROGRAMAÇÃO UTILIZADO PELO OPEN M.P.. ........................................................................................................ 31

4
Paralelismo Explícito ..................................................................................................................................................................... 31
Multithread Implícito .................................................................................................................................................................... 31
MODELO DE EXECUÇÃO DO OPEN M.P.. ...................................................................................................................................... 31
VARIÁVEIS NO OPEM M.P. - PRIVADA. ......................................................................................................................................... 32
VARIÁVEIS NO OPEM M.P. - COMPARTILHADA. ........................................................................................................................... 32
VARIÁVEIS NO OPEM M.P. – FIRST PRIVATE . ............................................................................................................................... 32
MAPEAMENTO PARA THREADS – imagem. .................................................................................................................................. 33
EXEMPLO - Hello World! – imagem. ............................................................................................................................................ 33
PERGUNTA. O Open M.P. tem como característica essencial para desenvolver programas paralelos o que chamamos de: ..... 33
O M.P.I.. ........................................................................................................................................................................................ 34
Estrutura de um código M.P.I.. ..................................................................................................................................................... 35
M.P.I._Finalize ............................................................................................................................................................................... 35
Envio e recebimento de dados síncrono: M.P.I._Send e M.P.I._Recv .......................................................................................... 35
Envio e recebimento de dados assíncrono: M.P.I._Isend e M.P.I._Irecv ...................................................................................... 35
M.P.I._Wait ................................................................................................................................................................................... 36
Comunicações Coletivas ............................................................................................................................................................... 36
M.P.I._Barrier ................................................................................................................................................................................ 36
M.P.I._Bcast .................................................................................................................................................................................. 36
0 M.P.I._Reduce ............................................................................................................................................................................ 36
M.P.I._Allgather ............................................................................................................................................................................ 36
Tipos derivados de dados. ............................................................................................................................................................ 36
O QUE É OPEN M.P.I. - M.P.I (Message Passing Interface)? ......................................................................................................... 37
CARACTERÍSTICAS- VANTAGENS E DESVANTAGENS DO M.P.I. .................................................................................................... 37
Vantagens do M.P.I. ...................................................................................................................................................................... 37
Desvantagens do M.P.I. ................................................................................................................................................................ 37
OUTRAS CARACTERÍSTICAS DO M.P.I............................................................................................................................................ 37
Thread Safety ................................................................................................................................................................................ 37
Comunicação Coletiva................................................................................................................................................................... 37
Perfis ............................................................................................................................................................................................. 37
CONCEITOS BÁSICOS DO M.P.I.. ................................................................................................................................................... 38
Processo ........................................................................................................................................................................................ 38
Rank .............................................................................................................................................................................................. 38
Grupos........................................................................................................................................................................................... 38
Comunicador................................................................................................................................................................................. 38
Application Buffer ......................................................................................................................................................................... 38
System Buffer ................................................................................................................................................................................ 38
Count............................................................................................................................................................................................. 38
Type............................................................................................................................................................................................... 38
Tag................................................................................................................................................................................................. 38
Status ............................................................................................................................................................................................ 38
PRINCIPAIS FUNÇÕES DO M.P.I.. .................................................................................................................................................. 39
5
MPI_Comm_size ........................................................................................................................................................................... 39
MPI_Comm_rank .......................................................................................................................................................................... 39
MPI_Get_processor_name ........................................................................................................................................................... 40
Exemplo com MPI_Get_processor_name – IMAGEM. ................................................................................................................. 40
PERGUNTA. Uma característica que difere o MPI do OpenMP é que: ......................................................................................... 40
SEMANA 4, AULA 3 - Frameworks para Computação Paralela – CUDA........................................................................................ 41
INTRODUÇÃO AO CUDA ................................................................................................................................................................ 41
ESTRUTURA DO CUDA – IMAGEM. ............................................................................................................................................... 41
ORGANIZAÇÃO DAS THREADS DO CUDA ...................................................................................................................................... 41
ORGANIZAÇÃO DAS THREADS DO CUDA – IMAGEM.................................................................................................................... 42
MODELO DE MEMÓRIA CUDA ...................................................................................................................................................... 42
CUDA EM DOCKER E CLOUD – IMAGEM. ...................................................................................................................................... 43
UTILIZAÇÃO DO CUDA................................................................................................................................................................... 43
APLICAÇÕES DO CUDA .................................................................................................................................................................. 43
PERGUNTA. Um componente da estrutura do CUDA que está diretamente ligada ao device é o: ............................................. 43
PERGUNTA.É um padrão que estabelece um conjunto de diretivas para programação utilizando memória compartilhada. ... 44
PERGUNTA.Trata-se de uma arquitetura de memória utilizada pelo MPI em que cada unidade de processamento possui suas
próprias memórias e processadores:............................................................................................................................................ 44
PERGUNTA.O nome da plataforma de computação paralela que utiliza unidades gráficas para explorar o máximo de
paralelismo, permitindo aumentos significativos de desempenho ao aproveitar a potência da GPU, denomina-se: ................ 44
PERGUNTA. Em relação à aceleração de um código sequencial na GPU, os passos devem envolver: ........................................ 44
PERGUNTA. Se comparamos o OpenMP com o OpenMPI podemos afirmar que: ...................................................................... 45
PERGUNTA. No ambiente de programação CUDA, a função utilizada para acessar dados da memória do dispositivo, bem
como a função para alocar memória são respectivamente: ........................................................................................................ 45
PERGUNTA. ................................................................................................................................................................................... 45
PERGUNTA. ................................................................................................................................................................................... 45
PERGUNTA. ................................................................................................................................................................................... 46
PERGUNTA. ................................................................................................................................................................................... 46
PERGUNTA. O OpenMP é um padrão de programação para arquiteturas de memória compartilhada que apresenta como
característica: ................................................................................................................................................................................ 46
SEMANA 5, TEXTO BASE. .............................................................................................................................................................. 47
Hadoop - Histórico ........................................................................................................................................................................ 47
Quem utiliza? ................................................................................................................................................................................ 48
Vantagens ..................................................................................................................................................................................... 48
Desvantagens ................................................................................................................................................................................ 49
Arcabouço Apache Hadoop .......................................................................................................................................................... 49
Principais subprojetos................................................................................................................................................................... 51
Outros subprojetos ....................................................................................................................................................................... 51
Apache Spark ................................................................................................................................................................................ 52
O que é Apache Kafka? ................................................................................................................................................................. 58
Visão geral..................................................................................................................................................................................... 58
Integração assíncrona com o Apache Kafka ................................................................................................................................. 58
6
Quando usar o Apache Kafka ........................................................................................................................................................ 58
Operações de TI ............................................................................................................................................................................ 59
IoT - Internet das Coisas................................................................................................................................................................ 59
E-commerce .................................................................................................................................................................................. 59
Como o Kubernetes escala as aplicações do Apache Kafka.......................................................................................................... 59
O QUE É O APACHE SPARK? .......................................................................................................................................................... 59
ECOSSISTEMA DO SPARK – IMAGEM. ........................................................................................................................................... 60
ECOSSISTEMA DO SPARK .............................................................................................................................................................. 60
BENEFÍCIOS DO SPARK .................................................................................................................................................................. 60
O QUE É APACHE HADOOP? ......................................................................................................................................................... 61
Objetivos/Requisitos do Hadoop .................................................................................................................................................. 61
ARQUITETURA APACHE HADOOP – IMAGEM. .............................................................................................................................. 61
ARQUITETURA APACHE HADOOP ................................................................................................................................................. 62
Sistema de Arquivos Distribuídos Hadoop (HDFS)........................................................................................................................ 62
NameNode .................................................................................................................................................................................... 62
DataNode ...................................................................................................................................................................................... 62
MapReduce Engine ....................................................................................................................................................................... 62
ECOSISTEMA HADOOP .................................................................................................................................................................. 63
APLICAÇÕES DO HADOOP ............................................................................................................................................................. 63
Comunicação assíncrona: utilizando eventos e mensageria ........................................................................................................ 63
Sistema de mensagens ponto a ponto ......................................................................................................................................... 64
Sistema de mensagens Publicar-Assinar....................................................................................................................................... 64
O QUE É APACHE KAFKA? ............................................................................................................................................................. 64
ARQUITETURA DO KAFKA ............................................................................................................................................................. 65
PONTOS DE ENTRADA DO KAFKA ................................................................................................................................................. 65
USOS DO KAFKA ............................................................................................................................................................................ 66
Alguns conceitos básicos muito importantes sobre o Apache Kafka: .......................................................................................... 66
Benefícios de utilizar o Apache Kafka ou uma solução semelhante ............................................................................................. 67
SEMANA 5 - ATIVIDADE AVALIATIVA. ........................................................................................................................................... 67
PERGUNTA. Analise as afirmações a seguir sobre o Apache Kafka e o Kubernetes. .................................................................... 67
PERGUNTA. O nome dado a um módulo da arquitetura do Hadoop que recebe jobs do cliente e as envia para os nós de
processamento (slaves) é conhecido como: ................................................................................................................................. 67
SEMANA 6, AULA 1. ...................................................................................................................................................................... 69
O que é desempenho? .................................................................................................................................................................. 69
PORQUE E PRA QUE DESEMPENHO? ............................................................................................................................................ 69
IMPORTÂNCIA DA AVALIAÇÃO ..................................................................................................................................................... 70
COMO MEDIR O DESEMPENHO? .................................................................................................................................................. 70
AVALIAÇÃO X ANÁLISE .................................................................................................................................................................. 71
PERGUNTA. A avaliação de desempenho consiste em: ................................................................................................................ 71
SEMANA 6, AULA 2. ...................................................................................................................................................................... 71
O QUE É CARGA DE TRABALHO? ................................................................................................................................................... 71

7
PROCEDIMENTO PARA A CARGA DE TRABALHO .......................................................................................................................... 72
CARACTERIZAÇÃO DE CARGA DE TRABALHO................................................................................................................................ 72
Carga de trabalho Real - Observada no sistema real em operação normal ................................................................................. 72
Carga de trabalho Sintética - Carga com características similares às reais. ................................................................................. 72
TESTE DE CARGA EM APLICAÇÕES ................................................................................................................................................ 73
TESTE DE CARGA EM APLICAÇÕES – BENEFÍCIOS. ........................................................................................................................ 73
PERGUNTA - A carga de trabalho é uma demanda que é gerada para um sistema alvo de modo que este processe esta
demanda e em seguida retorne com um resultado ou resposta. Acerca do termo “carga de trabalho” é correto afirmar que:73
Ferramentas para Teste de Carga ................................................................................................................................................. 73
TESTE DE ESTRESSE X TESTE DE CARGA ........................................................................................................................................ 73
PERGUNTA. Em relação ao teste de desempenho e teste de estresse, é verdadeiro afirmar que: ............................................. 74
JMETER – ESTUDO DE CASO ......................................................................................................................................................... 74
ATIVIDADE AVALIATIVA, SEMANA 6. ............................................................................................................................................ 75
PERGUNTA. Uma ferramenta de teste de carga que permite a emulação de tráfego pesado a um sistema alvo, é de código
fonte aberto e projetada para testes contínuos, denomina-se:................................................................................................... 75
PERGUNTA. ................................................................................................................................................................................... 76
PERGUNTA. Na caracterização da carga de trabalho imposta a um sistema computacional há diversas possibilidades a serem
consideradas. Àquela que utiliza sequência de requisições com time stamp é chamada de: ..................................................... 76
PERGUNTA. Entre as perguntas que precisamos responder ao considerar a avaliação de desempenho de um sistema
computacional, devemos considerar:........................................................................................................................................... 77
PERGUNTA. São pontos que precisam ser considerados na avaliação de desempenho de um sistema computacional, exceto:
...................................................................................................................................................................................................... 77
SEMANA 7, AULA 1. ...................................................................................................................................................................... 78
CONTAINER ................................................................................................................................................................................... 78
DOCKER ......................................................................................................................................................................................... 78
OpenShift – Introdução e Arquitetura .......................................................................................................................................... 78
Deploy de Aplicações com OpenShift ........................................................................................................................................... 81
Pergunta. Depois de criado um projeto de aplicação no OpenShift é preciso acessar o console Web no endereço: ................. 82
Pergunta. Uma funcionalidade oferecida pelo OpenShift é: ........................................................................................................ 83
SEMANA 7, ATIVIDADE AVALIATIVA ............................................................................................................................................. 83
Revisão - Computação Escalável. .................................................................................................................................................. 85

8
SEMANA 1, AULA 1.
SISTEMA ESCALÁVEL.
Um sistema escalável é aquele que apresenta capacidade de funcionar quando há alteração do seu contexto em relação ao
seu tamanho para atender necessidades do usuário.

a) Podemos construir aplicações e executá-las considerando que podemos explorar muitos recursos computacionais.
b) Para o usuário, a percepção da escalabilidade dos sistemas fica oculta.
c) Tradicionalmente, a grande maioria dos programas escritos são programas sequenciais.
d) Para serem executados em um único computador com uma CPU:
e) o problema é quebrado em séries discretas de instruções;
f) as instruções são executadas uma após a outra;
g) apenas uma instrução pode executar em um determinado instante do tempo.

COMPUTAÇÃO PARALELA.
Computação Paralela é definida como o uso simultâneo de múltiplos recursos computacionais para resolver um problema
computacional.

Para ser executado em diversas CPUs, um problema é quebrado em partes discretas que podem ser resolvidas
concorrentemente.

Cada parte é então quebrada em uma série de instruções.

Instruções de cada parte do programa são executadas simultaneamente em diferentes CPUs.

RECURSOS DA COMPUTAÇÃO PARALELA.

Os recursos computacionais podem incluir:

um único computador com múltiplos processadores.

um número arbitrário de computadores conectados pela rede.

uma combinação de ambos.

COMPUTAÇÃO DISTRIBUÍDA .
SISTEMA DISTRIBUÍDO é uma coleção de computadores independentes aparentando ser um único computador.

Dois aspectos da definição:

Hardware: as máquinas são autônomas.

Software: os usuários veem o sistema como uma única máquina.

CONCEITO CHAVE DA COMPUTAÇÃO DISTRIBUÍDA: TRANSPARÊNCIA.

A transparência pode ser entendida de duas formas:

Transparência de recursos físicos (esconder dos usuários a localização dos diversos recursos).

Transparência para os sistemas.

COMPUTAÇÃO DISTRIBUÍDA • VANTAGENS.

a) Extensibilidade.
b) O sistema pode crescer gradativamente.
c) Novos softwares podem ser instalados gradativamente.
d) Compartilhamento de recursos.
e) Recursos de alto custo podem ser melhor utilizados.
f) Servidores de arquivo.
g) Servidores de e-mail.
9
COMPUTAÇÃO DISTRIBUÍDA, DESVANTAGENS.
a) Execução de backup é mais complexa.
b) Alocação de tempo de processamento.
c) Manutenção - Evolução do software.
d) Desempenho - Confiabilidade.
e) Dependência da rede utilizada.

COMPUTAÇÃO PARALELA – COMPLEXIDADE.

a) Programação Paralela → Mais complexa que a Programação Sequencial.
b) Presença de erros dos programas sequenciais + erros associados às interações entre os processos .
c) Erros dependentes do momento exato em que o escalonador do SO realiza um chaveamento de contexto.
d) Dificuldades de reproduzir e identificar os erros.
e) Apesar da maior complexidade, há muitas áreas nas quais a programação paralela é vantajosa.
f) Sistemas com vários processadores (máquinas paralelas ou sistemas distribuídos).
g) Aproveitamento do paralelismo para acelerar a execução de um programa.

APLICAÇÕES DE COMPUTAÇÃO PARALELA E DISTRIBUÍDA.

Atualmente as aplicações comerciais fornecem uma força igual ou maior no desenvolvimento de computadores
mais rápidos.
Processamento de grandes quantidades de dados de forma sofisticada.

Bancos de Dados, mineração de dados.

Exploração de Petróleo.
Motores de Busca da Web, Serviços Web baseados em Negócios.
Imagens Médicas e Diagnóstico.
Gestão de Empresas Nacionais e Internacionais.
Modelagem Financeira e Econômica.
Realidade Virtual, principalmente na indústria do entretenimento.
Tecnologias Multimídia.
Ambientes Colaborativos de Trabalho.

SEMANA 1, AULA 2.
Os termos (JARGÕES) mais comumente utilizados, associados à computação paralela.

a) Tarefa (Task). Uma seção, logicamente discreta de trabalho computacional, é tipicamente um programa ou um
conjunto de instruções de um programa executado por um processador.
b) Tarefa Paralela (Parallel Task). Uma tarefa que pode ser executada por múltiplos processadores.
c) Execução Serial (Serial Execution). Execução de um programa sequencialmente, uma instrução por vez. No
sentido mais simples, isso é o que ocorre em uma máquina de um processador. No entanto, praticamente todas as
tarefas têm seções que devem ser executadas em série.
d) Execução Paralela (Parallel Execution). Execução de um programa com mais de uma tarefa. Instruções de mais de
uma tarefa podem ser executadas ao mesmo momento.
e) Escalonamento . Normalmente feito pelo sistema operacional. Ele determina quais threads executam em
determinado momento.
f) Granularidade. É o tamanho do trabalho atribuído a cada thread antes que elas se sincronizem.
Indica a relação entre computação e comunicação dos trechos de código gerados a partir da divisão do problema a
ser resolvido. Um programa que é dividido em partes pequenas entre as threads tem granularidade fina. Pequenos
trechos de código com comunicação alta, = maior potencial de exploração de paralelismo.

Um programa que faz com que suas threads tenham muito trabalho antes de se sincronizarem tem granularidade
grossa. Grandes trechos de código com comunicação baixa = menor potencial de exploração de paralelismo.

10
 g) Sincronização (Synchronization). A coordenação das tarefas paralelas, em tempo de execução, é importante para
garantir resultados determinísticos. Sincronização neste contexto, se refere às técnicas utilizadas para garantir essa
coordenação.
h) Speedup. Tempo da execução serial - Tempo da execução paralela.
Um dos indicadores mais simples e o mais utilizado para quantificar o desempenho de um programa paralelo.

i) Pipelinning. Quebra de uma tarefa em etapas realizadas por unidades diferentes de processamento.

O QUE É SISTEMA ESCALÁVEL?

• Um sistema escalável é aquele que apresenta capacidade de funcionar quando há alteração do

seu contexto em relação ao seu tamanho para atender necessidades do usuário.
• Podemos construir aplicações e executá-las considerando que podemos explorar muitos recursos
computacionais.
• Para o usuário, a percepção da escalabilidade dos sistemas fica oculta.

O QUE É COMPUTAÇÃO PARALELA?

• Computação Paralela é definida como o uso simultâneo de múltiplos recursos computacionais

para resolver um problema computacional.
• Para ser executado em diversas CPUs;
• um problema é quebrado em partes discretas que podem ser resolvidas concorrentemente.
• cada parte é então quebrada em uma série de instruções.
• instruções de cada parte do programa são executadas simultaneamente em diferentes CPUs.

RECURSOS DA COMPUTAÇÃO PARALELA.

• Os recursos computacionais podem incluir;

• Um único computador com múltiplos processadores.
• Um número arbitrário de computadores conectados pela rede.
• Uma combinação de ambos.

COMPUTAÇÃO DISTRIBUÍDA.

• SISTEMA DISTRIBUÍDO é uma coleção de computadores independentes aparentando ser um

único computador.
• Dois aspectos da definição;
• Hardware: as máquinas são autônomas.
• Software: os usuários veem o sistema como uma única máquina.

CONCEITO CHAVE DA COMPUTAÇÃO DISTRIBUÍDA. TRANSPARÊNCIA.

• A transparência pode ser entendida de duas formas;

• Transparência de recursos físicos (esconder dos usuários a localização dos diversos recursos).
• Transparência para os sistemas.

11
COMPUTAÇÃO DISTRIBUÍDA . VANTAGENS.

• Extensibilidade.
• O sistema pode crescer gradativamente.
• Novos softwares podem ser instalados gradativamente.
• Compartilhamento de recursos.
• Recursos de alto custo podem ser melhor utilizados.
• Servidores de arquivo.
• Servidores de e-mail.

COMPUTAÇÃO DISTRIBUÍDA. DESVANTAGENS.

• Execução de backup é mais complexa.

• Alocação de tempo de processamento.
• Manutenção - Evolução do software.
• Desempenho - Confiabilidade.
• Dependência da rede utilizada.

COMPUTAÇÃO PARALELA. COMPLEXIDADE.

• Programação Paralela → Mais complexa que a Programação Sequencial.

• Presença de erros dos programas sequenciais + erros associados às interações entre os processos.
• Erros dependentes do momento exato em que o escalonador do SO realiza um chaveamento de
contexto.
• Dificuldades de reproduzir e identificar os erros.
• Apesar da maior complexidade, há muitas áreas nas quais a programação paralela é vantajosa.
• Sistemas com vários processadores (máquinas paralelas ou sistemas distribuídos).
• Aproveitamento do paralelismo para acelerar a execução de um programa.

APLICAÇÕES DE COMPUTAÇÃO PARALELA E DISTRIBUÍDA.

• Atualmente as aplicações comerciais fornecem uma força igual ou maior no desenvolvimento de

computadores mais rápidos.
• Processamento de grandes quantidades de dados de forma sofisticada.
• Bancos de Dados, mineração de dados.
• Exploração de Petróleo.
• Motores de Busca da Web, Serviços Web baseados em Negócios.
• Imagens Médicas e Diagnóstico.
• Gestão de Empresas Nacionais e Internacionais.
• Modelagem Financeira e Econômica.
• Realidade Virtual, principalmente na indústria do entretenimento.
• Tecnologias Multimídia.
• Ambientes Colaborativos de Trabalho.

Tarefa (Task).

• Uma seção, logicamente discreta de trabalho computacional, é tipicamente um programa

ou um conjunto de instruções de um programa executado por um processador.

Tarefa Paralela (Parallel Task).

• Uma tarefa que pode ser executada por múltiplos processadores.

12
Execução Serial (Serial Execution).

• Execução de um programa sequencialmente, uma instrução por vez. No sentido mais simples,
isso é o que ocorre em uma máquina de um processador. No entanto, praticamente todas as
tarefas têm seções que devem ser executadas em série.

Execução Paralela (Parallel Execution).

• Execução de um programa com mais de uma tarefa. Instruções de mais de uma tarefa podem ser
executadas ao mesmo momento.

Escalonamento.

• Normalmente feito pelo sistema operacional. Ele determina quais threads executam em
determinado momento.

Granularidade

• É o tamanho do trabalho atribuído a cada thread antes que elas se sincronizem.

• l Indica a relação entre computação e comunicação dos trechos de código gerados a partir da
divisão do problema a ser resolvido.
• l Um programa que é dividido em partes pequenas entre as threads tem granularidade fina.
Pequenos trechos de código com comunicação alta = maior potencial de exploração de
paralelismo.
• l Um programa que faz com que suas threads tenham muito trabalho antes de se sincronizarem
tem granularidade grossa. Grandes trechos de código com comunicação baixa = menor potencial
de exploração de paralelismo.

Sincronização (Synchronization).

• A coordenação das tarefas paralelas, em tempo de execução, é importante para garantir

resultados determinísticos. Sincronização neste contexto, se refere às técnicas utilizadas para
garantir essa coordenação.

Speedup.

• Tempo da execução serial - Tempo da execução paralela.

Pipelinning.
Quebra de uma tarefa em etapas realizadas por unidades diferentes de processamento.

PERGUNTA.O que indica a relação entre computação e comunicação de trechos de código gerados a
partir da divisão dos problemas a ser resolvido é conhecido como:

• escalonamento.?
• granularidade.?
• sincronização.?
• tarefa.?
• speedup.?

RESPOSTA CERTA. A granularidade é o tamanho do trabalho atribuído a cada unidade de

execução-thread antes que elas se sincronizem.
13
PERGUNTA. Um conceito chave de um sistema distribuído é?

• a transparência.?
• o processamento.?
• a localização.?
• a comunicação.?

Resposta correta. Um conceito chave de um sistema distribuído é a transparência pode ser entendida de
duas formas: em relação aos recursos físicos e em relação a transparência para os sistemas-
aplicações.

PERGUNTA. É um desafio da programação paralela em que os programas deveriam tirar vantagem do aumento do
número de processadores.
• Escalabilidade?
• Granularidade?
• Balanceamento de carga?
• Locking?
• Decomposição?

Resposta certa. A escalabilidade de uma solução computacional depende de inúmeros fatores

(quantidade de elementos computacionais, rede etc.) e isso afeta inclusive o resultado da solução, em
especial o tempo de resposta.

PERGUNTA. No contexto de linguagens de programação é comum aparecer os termos concorrência e

paralelismo. Assinale a alternativa correta:

• Um programa concorrente é executado em vários processadores.?

• Utilizar o paralelismo é útil para estruturar um programa que precisa executar com vários
clientes simultaneamente.?
• Um programa paralelo é aquele que possui várias threads de controle.?
• Paralelismo e concorrência são sinônimos.?
• Um programa concorrente é aquele que possui várias threads de controle.?

RESPORTA CERTA. No contexto de linguagens de programação é comum aparecer os termos

concorrência e paralelismo Um programa concorrente é aquele que possui várias threads de
controle.

PERGUNTA. São inúmeras as aplicações de computação paralela e distribuída no contexto atual. Em relação à
computação paralela e à computação distribuída, analise as afirmações.

1. Afirmação falsa. O conceito-chave do paralelismo é a transparência.?

2. . Afirmação falsa. Computação paralela é uma coleção de computadores independentes

aparentando ser um único computador.

3. Afirmação correta. Uma vantagem da computação distribuída é a extensibilidade.

4. Afirmação correta. Ambientes colaborativos são exemplos de aplicações de computação

distribuída.
14
PERGUNTA.
A computação paralela faz uso de diversos conceitos estudados em Sistemas Operacionais e em Sistemas Distribuídos. Um
conceito fundamental que envolve a relação entre o tempo de um programa executado sequencialmente e outro executado
de forma paralela, sendo esse um dos indicadores para quantificar o desempenho de um programa paralelo é conhecido
como?

• speedup.?
• pipelinning.?
• escalonamento.?
• granularidade.?
• sincronismo.?

RESPOSTA CERTA. Um conceito fundamental que envolve a relação entre o tempo de um programa executado
sequencialmente e outro executado de forma paralela, sendo esse um dos indicadores para quantificar o desempenho de um
programa paralelo é conhecido como speedup.

PERGUNTA. O paralelismo pode ser inviável quando há dependências sequenciais. Uma alternativa para isso
consiste em:

• realizar provas formais de controle.?

• identificar as dependências quando os dados forem armazenados.?
• eliminar deadlocks.?
• eliminar as dependências desnecessárias.?
• abstrair os erros. ?

RESPOSTA CERTA. O paralelismo pode ser inviável quando há dependências sequenciais. Uma alternativa para isso consiste
em: eliminar as dependências desnecessárias.

PERGUNTA. Aplicações com paralelismo implícito.

Resposta: Aquelas para as quais pode-se distinguir facilmente funções para serem realizadas em paralelo

SEMANA 2.
Razões - Computação Paralela.
• Economizar tempo e dinheiro: Em teoria, jogar mais recurso em uma tarefa vai encurtar seu tempo para a
conclusão, com potenciais economias de custos. Clusters paralelos podem ser construídos a partr de componentes
baratos.
• Resolver grande problemas: Problemas complexos são impraticável resolvê-los num único computador,
especialmente quando a memória é limitada.
• Prover Concorrência: Um único recurso de computação pode fazer uma tarefa de cada vez. Vários podem fazer
muitas tarefas simultaneamente.
• Recursos não-locais: Usar recursos computacionais em uma rede como a Internet quando recursos locais são
escassos.
• Limite da computação serial: Razões fsicas e prátcas restringem a construção de computadores mais rápidos;
• Velocidade de transmissão.
• Limites a miniaturização.
• Limitações econômicas
• Arquiteturas de computadores atuais são cada vez mais dependentes do paralelismo em nível de hardware para
melhorar o desempenho.

Speedup.
A relação entre o tempo gasto para executar uma tarefa com um único processador e o tempo gasto com N processadores,
ou seja, Speedup é a Medida do ganho em tempo • S = T(1) - T (N) • Ou seja, Speedup é a medida do ganho em tempo

15
o que significa multicore?
Uma arquitetura na qual um único processador físico incorpora a lógica principal de mais de um processador. Um único
circuito integrado é usado para empacotar ou manter esses processadores. Esses circuitos integrados únicos são conhecidos
como matriz. A arquitetura multicore coloca vários núcleos de processador e os agrupa como um único processador físico. O
objetivo é criar um sistema que possa completar mais tarefas ao mesmo tempo, ganhando assim um melhor desempenho
geral do sistema.

A arquitetura de um processador multicore permite a comunicação entre todos os núcleos disponíveis para garantir que as
tarefas de processamento sejam divididas e atribuídas com precisão. No momento da conclusão da tarefa, os dados
processados de cada núcleo são devolvidos à placa-mãe por meio de um único gateway compartilhado. Essa técnica melhora
significativamente o desempenho em comparação com um processador de núcleo único de velocidade semelhante.

Otimização da execução de um único fluxo de instruções através de Pipelining:

• Sobrepõe a execução de várias instruções.

• Exemplo: todas as arquiteturas RISC; Intel x86.

Otimização da execução de um único fluxo de instruções através de Execução fora de ordem:

• Permite que as instruções ultrapassem umas às outras na ordem de execução de acordo com dependências de
código (RAW, WAW, WAR).
• Exemplo: todos os processadores comerciais (Intel, AMD, IBM,Oracle).

Otimização da execução de um único fluxo de instruções através de Previsão de desvios e execução especulativa:

• Reduz o número de ciclos de paralisação da CPU, devido a desvios não resolvidos.

• Exemplo: (quase) todos os processadores comerciais.

Processadores de múltiplas emissões:

• Permitem que várias instruções iniciem a execução por ciclo de relógio.

• Arquiteturas superescalares (Intel x86, AMD,…) vs. VLIW.

Arquiteturas VLIW - EPIC:

• Permitem que os coM.P.I.ladores indiquem instruções independentes em cada pacote emitido.
• Exemplo: Intel Itanium.

Unidades SIMD:

Permitem a expressão e execução eficientes de operações com vetores. Exemplo: VSIM, SSE -
SSE4, GPU.

Limitações para otimizar a execução de um único fluxo de instruções : Problema:

Dentro de um único fluxo de instruções, não encontramos instruções independentes suficientes para executar
simultaneamente devido a:

• dependências de dados,
• limitações da execução especulativa em muitos ramos,
• dificuldades para detectar dependências de acesso à memória entre as instruções (análise de alias).

Consequência: número significativo de unidades funcionais podem ficar ociosas a qualquer momento .

16
Paralelismo no nível de threads
Problemas para executar instruções de vários threads ao mesmo tempo.

• As instruções em cada thread podem usar os mesmos registradores.

• Cada thread tem seu próprio contador de programa.

O gerenciamento de memória virtual permite a execução de várias threads e compartilhamento da memória principal.

• Quando alternar entre as diferentes threads:

• Multithreading de granularidade fina: alterna entre todas as instruções
• Multithreading de granularidade grossa: alterna apenas em paradas caras (por exemplo, falta de cache do nível 2).

Potência e paralelismo no nível de instrução

• A frequencia do relógio da CPU começou a não subir tão rápido a partir de 2000.
• Limitação de paralelismo no nível de instrução.
• Consumo de potência e dissipação de calor.

1. Exemplos de máquinas MIMD: Multiprocessador de memória compartilhada simétrica (SMP).

Vários processadores em caixa comunicação através de memória compartilhada.
Chips multicores atuais possuem esta arquitetura.
Todo processador executa uma cópia do SO.

Exemplos de máquinas MIMD: Multiprocessador de memória compartilhada Distribuída- Não Uniforme

Vários processadores.
• Cada um com memória local.
• Rede escalável
Sistema Operacional extremamente leve no nó que fornece serviços simples
• Escalonamento - sincronização
• Host acessível pela rede para E - S

Exemplos de máquinas MIMD: Cluster

• Muitas máquinas independentes conectadas em rede
• Comunicação através de mensagens

Symmetric Multiprocessors (SMP).

• Pequeno número de núcleos: Normalmente oito ou menos, e não mais que 32 na maioria dos casos.
• Todos os processadores compartilham uma única memória e tem o mesmo tempo de acesso a ela. Daí o termo
simétrico.
• Todos os multicores atuais são SMPs.
• Também chamados de multiprocessadores com acesso uniforme à memória (UMA). Todos os processadores têm
latência uniforme.

Multiprocessadores com memória compartilhada centralizada

• Processadores multinúcleo (multicore):
o Normalmente conectados por um cache.
o Sistemas SMP anteriores eram tipicamente conectados através da memória principal.
Intel X7350 quad-core (Tigerton):
• Cache L1 privado: instrução de 32 KB, dados de 32 KB.
• Cache L2 compartilhado: cache unificado de 4 MB.

17
Multiprocessadores com memória compartilhada distribuída (DSM).
• Grande número de processadores: 64 a 1000.
• Memória distribuída:
o Memória remota vs local.
o Latência longa vs curta.
• Rede de interconexão: Largura de banda, topologia, etc.
• Acesso à memória não uniforme (NUMA)  Cada processador pode possuir E - S local.
• Reduz o gargalo de memória em comparação com SMPs.
• Mais difícil de programar com eficiência.
o Por exemplo, política do primeiro toque: o item de dados estará localizado na memória do processador que
usa um item de dados primeiro.
• Para reduzir os efeitos do acesso não uniforme à memória, caches são frequentemente usados.
o ccNUMA: arquiteturas com acesso à memória não uniforme coerente.
• O maior exemplo atual: SGI Origin com 512 processadores

Multiprocessadores com memória compartilhada.

• SMP e DSM são todos multiprocessadores de memória compartilhada: UMA ou NUMA.
• Multicores são SMPs com memória compartilhada.
• A maioria das máquinas com várias CPUs é DSM: NUMA.

Métrica de desempenho:
• Aceleração (Speedup): quanto mais rápido um problema é executado em p processadores em comparação com 1
processador?

• Aceleração ótima: S (p) = p (aceleração linear)  Eficiência Paralela: Aceleração normalizada pelo número de
processadores  Ótimo: E (p) = 1,0

SEMANA 2, AULA1.

ARQUITETURA DE MEMÓRIA, MEMÓRIA COMPARTILHADA.

Múltiplos processadores compartilham os mesmos recursos de memória em um espaço de endereçamento global.
Modificações efetuadas em uma região de memória por um processador são visíveis a todos os outros
processadores.
São divindades em duas classes:
o UMA – tempo de acesso uniforme.
o NUMA – tempo de acesso não uniforme.

UNIFORM MEMORY ACCESS (UMA).

Comum em processadores simétricos (SMP) .
Tempo de acesso igual para toda a memória .
Coerência de Cache;
o Se um processador atualiza um dado na memória compartilhada, isso tem que ser propagado para os outros
processadores (cache interna à CPU).
o Normalmente feita em hardware.

18
NON-UNIFORM MEMORY ACCESS.
SMPs conectados por canais de comunicação.
O espaço de endereçamento ainda é global e um SMP pode acessar diretamente a memória do outro.
O tempo de acesso a uma posição de memória varia se ela pode ser acessada localmente ou em um processador remoto
através dos canais de comunicação.
Se existe Coerência de Cache, a arquitetura é chamada de CC-NUMA (Cache Coeherent NUMA).

VANTAGENS DA MEMÓRIA COMPARTILHADA.

O espaço de endereçamento global permite um modelo de programação mais amigável (conhecido).
O compartilhamento de dados entre as tarefas é rápido.

DESVANTAGENS DA MEMÓRIA COMPARTILHADA.

Falta de escalabilidade.
Aumentando o número de CPUs, aumenta o tráfego entre memória e CPU (bottleneck de von Neumann).
É de responsabilidade do programador a sincronização dos acessos à memória global compartilhada.

ARQUITETURA DE MEMÓRIA, MEMÓRIA DISTRIBUÍDA.

Sistemas de memória distribuída possuem uma rede de comunicação para interconectar os processadores.
Cada processador tem sua própria memória local.
Não existe um espaço de endereçamento global, um processador tem acesso somente a sua memória.
É tarefa do programador determinar quando e como um dado é propagado de um processador para o outro.
A sincronização das tarefas é também função do programador.

VANTAGENS DA MEMÓRIA DISTRIBUÍDA.

A memória é escalável com o número de processadores.
Mais Processadores → Maior Quantidade de Memória.
Acesso rápido à memória do próprio processador sem interferência e sobrecarga da coerência da cache.

DESVANTAGENS DA MEMÓRIA DISTRIBUÍDA.

O programador precisa cuidar de muitos detalhes associados à comunicação de dados entre os processadores.
Dificuldade de mapear estruturas de dados projetadas para uma memória global com esta organização de memória.

MODELOS DE PROGRAMAÇÃO.
Modelos de programação paralela existem como uma abstração acima da arquitetura de hardware e de memória.
Apesar de não ser evidente, os modelos não são específicos para um determinado tipo de arquitetura.
Qualquer modelo pode (teoricamente) ser implementado em qualquer hardware.

19
MODELO DE MEMÓRIA COMPARTILHADA.
Neste modelo as tarefas compartilham um espaço de endereço comum, onde elas podem ler e escrever simultaneamente.
VANTAGEM → Para o programador:
o Não existe a necessidade de comunicação explícita de dados entre as tarefas.
Mecanismos como semáforos (podem ser utilizados para controlar o acesso à memória compartilhada).

MODELO DE MEMÓRIA DISTRIBUÍDA.

Conjunto de tarefas que utilizam a memória local durante a computação.
Várias tarefas podem residir na mesma máquina.
Tarefas trocam dados através de comunicação, enviando e recebendo mensagens.
A transferência de dados em geral requer operações de cooperação a serem executadas por cada processo Exemplo:
Operação de envio deve ter uma operação de recepção correspondente.

MODELO DE MEMÓRIA DISTRIBUÍDA. IMAGEM.

SEMANA 2, AULA 2.
ARQUITETURA DE VON NEUMANN.
Batizada em homenagem ao matemático húngaro John Von Neumann, que em 1945 introduziu os conceitos básicos dos
computadores atuais.
O conceito mais importante é o de programa armazenado na memória. Antes disso, os programas eram feitos através de
interligações físicas dos circuitos.

CLASSIFICAÇÃO DAS ARQUITETURAS.

Várias maneiras foram propostas para a classificação das arquiteturas de computadores.
Uma das mais simples, e talvez por isso, mais utilizada é a classificação de Flynn(em uso desde 1966).
Distingue arquiteturas de computadores de acordo com a multiplicidade de fluxos simultâneos de processamento de
instruções e de acessos à memória.
Cada um deles pode ser: Simples ou Múltiplos.
20
CLASSIFICAÇÃO DAS ARQUITETURAS, 4 classes.

SISD Single Instruction, Single Data.

• Um computador não paralelo, a arquitetura básica de Von Neumann.
o Fluxo Simples de Instruções: apenas um fluxo de instruções e processado de cada vez.
o Fluxo Simples de Dados: um único fluxo de dados existe entre processador e memória.
• Execução determinística.
• É o mais antigo e comum tipo de computador usado atualmente.

SIMD Single Instruction, Multiple Data.

• Única instrução: todas as unidades de processamento executam a mesma instrução.
• Vários dados: cada unidade de processamento pode operar em um elemento de dados diferentes.
• Mais adequado para problemas específicos caracterizados por um alto grau de regularidade, tais como gráficos-
processamento de imagens.
• A maioria dos computadores modernos.
• Particularmente aqueles com as unidades de processadores gráficos (GPUs) empregam SIMD instruções e unidades
de execução.

MISD Multiple Instruction, Single Data.

• Único fluxo de dados alimentado em várias unidades de processamento.
• Cada unidade de transformação opera sobre os dados de forma independente por meio de fluxos de instruções
independentes.
• Poucos exemplos concretos desta categoria de computadores.
• Experimental Carnegie-Mellon C.mmp (1971).
• Alguns autores consideram que unidades de execução em pipeline representam essa categoria.

MIMD Multiple Instruction, Multiple Data.

• Cada processador pode executar um fluxo de instruções diferentes.
• Cada processador pode trabalhar com diferentes fluxos de dados.
• A execução pode ser síncrona ou assíncrona.
• Atualmente o tipo mais comum de computador paralelo.
• Exemplos: a maioria dos supercomputadores atuais, clusters de computadores paralelos, multi-core.

Sistemas Multicore.
• Consiste em várias cópias de um processador dentro de um único chip.
• Cada cópia é chamada de núcleo ou core.
• Essas cópias são interconectadas por um barramento ou outro mecanismo de comunicação.
• São utilizados para executar diferentes tarefas de forma simultânea ou uma mesma tarefa mais rapidamente.
• Consomem menos energia que alternativas mais complexas como processadores superescalares.

21
PERGUNTA. São características de processadores com memória compartilhada distribuída:
• processadores multinúcleo?
• não utilizar uma rede de interconexão?
• grande número de processadores?
• acesso uniforme à memória?
• mais fácil de programar com mais eficiência?

Resposta certa: São características de processadores com memória compartilhada distribuída: grande número de
processadores.

PERGUNTA . Considere a classificação de Flynn para arquiteturas de computadores e verifique a que se encaixa no
contexto de múltiplas instruções e múltiplos dados (MIMD).
• A grande parte dos computadores atuais, incluindo clusters e computadores com processadores multicore?
• Equivale a um programa puramente sequencial, sendo também conhecida como arquitetura Von Neumann?
• Este tipo de arquitetura é adequado para problemas específicos caracterizados por alto grau de regularidade, como
processamento de imagens?
• Consiste em um fluxo único de dados entre processador e memória, tendo o univac1 como exemplo?
• É um exemplo representante da classificação MIMD o C.mmp (1971)?

Resposta certa. Considere a classificação de Flynn para arquiteturas de computadores e verifique a que se encaixa no
contexto de múltiplas instruções e múltiplos dados (MIMD). A grande parte dos computadores atuais, incluindo clusters e
computadores com processadores multicore.

PERGUNTA. Um processador equipado com paralelismo no nível de threads pode executar processos separados do
código, sendo possível rodar dois processos de um mesmo aplicativo ao mesmo tempo.
• concorrentes?
• separados?
• paralelos?
• juntos?
• sequenciais?

Resposta certa. Um processador equipado com paralelismo no nível de threads pode executar processos separados do
código, sendo possível rodar dois processos de um mesmo aplicativo ao mesmo tempo Separados.

PERGUNTA. Analise as afirmações.

São vantagens dos processadores multicore:

1. Afirmação correta. Maior desempenho.

2. Afirmação falsa. Funcionar apenas em servidores de data center.

3. Afirmação falsa. Poder executar mais de um processo por ciclo de clock?

4. Afirmação correta. Poder executar mais de uma tarefa por ciclo de clock e cada tarefa executar mais de um processo por
vez.

PERGUNTA 5. A métrica de desempenho que é muito utilizada para comparar processamento com apenas um
núcleo e vários núcleos é chamada de:
• tempo de resposta?
• número de requisições?
• Speedup?
• tempo de processamento?
• vazão?

Resposta certa. A métrica de desempenho que é muito utilizada para comparar processamento com apenas um núcleo e
vários núcleos é chamada de Speedup.

22
PERGUNTA 6.
É conhecido como um modelo de programação no contexto do paralelismo em que não há a comunicação explícita de dados
entre as tarefas e o espaço de endereçamento global permite um modelo de programação mais amigável. Esse modelo
recebe o nome de:

• memória distribuída?
• certa memória compartilhada?
• memória híbrida?
• memória cache?
• memória uniforme?

Resposta certa. É conhecido como um modelo de programação no contexto do paralelismo em que não há a comunicação
explícita de dados entre as tarefas e o espaço de endereçamento global permite um modelo de programação mais amigável.
Esse modelo recebe o nome de Memória compartilhada.

SEMANA 3, AULA 1.
POR QUE SE PREOCUPAR COM A INFRAESTRUTURA?
É muito comum os usuários da rede ou de aplicações que “rodam” na nuvem se queixarem de lentidão, de queda do
link de comunicação, de falhas de segurança, etc.
O que está mais próximo do usuário é resultado da sua manipulação com ferramentas, programas, conectividade.
É muito complexo para um usuário ter que saber que a lentidão na sua conexão pode ser, por exemplo:
• devido a roM.P.I.mento de uma cabo de fibra ótica
• de discos de armazenamentos queimados
• de servidores de DNS offline, etc.

No contexto atual, em que grande parte das aplicações executam em algum tipo de nuvem computacional, muitos pontos
precisam ser considerados:
• Como garantir a conectividade até o data center?
• Como garantir a operacionalização dos servidores disponíveis para os usuários?
• E a segurança de acesso?
• E se eu quiser escalar a minha aplicação para atender uma demanda de acesso que tende a crescer
exponencialmente?

OUTRAS QUESTÕES SOBRE INFRAESTRUTURA NÃO MENOS IMPORTANTES QUE TAMBÉM SE DESTACAM:
Custo energético para manter um data center.
Autonomia pós-desastre da estrutura ou de componentes da mesma.
Disco, placa mãe, processadores com problemas.
Conectividade limitada (por conta de falha em dispositivos como switch, roteadores).

COMPONETES- GRANULARIDADE FINA.

Os componentes dos servidores em tipos e quantidades.
Placas de redes, discos (mecânicos ou SSD), placas mãe com 1 ou N processadores, placas gráficas para processamento de
alto desempenho (CUDA ou OpenCL), fontes (em geral reduntantes) → caso uma apresente problema a outra mantem o
hardware ligado.

COMPONENTES - GRANULARIDADE GROSSA.

Servidores (banco de dados, firewalls, storage, autenticação, réplicas), switches, roteadores, nobreaks e bancos de baterias,
rack, ventilação (sistema de refrigeração com ar-condicionados), sistemas de alarme do ambiente, controle de acesso ao
local onde ficam armazenados os servidores no data center, barramento de energia elétrica, geradores, etc.

OPEN COMPUTER PROJECT.

O Open Compute Project (OCP) é uma comunidade global de líderes em tecnologia que trabalha em conjunto para liberar
infraestruturas de TI proprietárias para tornar o hardware mais eficiente, flexível e escalável, facilitando a personalização.

23
O PROJETO OPEN COMPUTER PROJECT EM LINHAS GERAIS PROMOVE:
Um ecossistema dinâmico do setor para a implantação global de datacenters na nuvem.
Compartilhamento do mesmo servidor e os mesmos projetos de datacenter que capacitam a nuvem em hiperescala.
Organizações de todos os portes podem melhorar o desempenho, a eficiência, o consumo de energia e os custos de seus
datacenters.
NO PROJETO DE HARDWARE PARA NUVEM EM GRANDE ESCALA:
Todas as especificações de projeto em software livre.
Os operadores de datacenters e de TI aproveitam a inovação desenvolvida pela comunidade para escalar os projetos de
hardware.

SEMANA 3, AULA 2 - CLUSTER.

Cluster significa uma combinação de dispositivos computacionais interligados por uma rede de comunicação que envolve
software e hardware.
São utilizados para permitir alta disponibilidade, o que tende a melhorar a confiabilidade da solução.
Permitem muito mais computação do que um computador isolado.

COMPONENTES DE CLUSTER.
Os blocos básicos de qualquer cluster devem envolver:
• Hosts (Nós de processamento).
• Rede de comunicação.
• Arquitetura da rede de comunicação.

CATEGORIAS DE CLUSTER- ALTA DISPOBILIDADE.

Aquele que tende a ser resistente a falhas de hardware, software e energia.
O objetivo é manter os serviços em operação o maior tempo possível.

CATEGORIAS DE CLUSTER- BALANCEAMENTO DE CARGA.

Técnica utilizada para distribuir carga de trabalho de maneira uniforme entre dois ou mais hosts, enlaces de comunicação,
discos de armazenamento e outros recursos computacionais com o objetivo de:
• Maximizar o desempenho.
• Minimizar o tempo de resposta.
• Evitar a sobrecarga.
O balanceamento de carga aumenta a confiabilidade por meio da redundância dos recursos computacionais disponíveis.

24
CATEGORIAS DE CLUSTER- ALTO DESEMPENHO.
Utilizados para aplicações que exigem muito processamento computacional.
Sistemas utilizados em pesquisas científicas, por exemplo, podem se beneficiar deste tipo de cluster por necessitarem
analisar uma grande variedade de dados rapidamente e realizar cálculos bastante complexos.
CATEGORIAS DE CLUSTER- ALTO DESEMPENHO - imagem.

CATEGORIAS DE CLUSTER - ALTO DESEMPENHO - COMO FUNCIONA?

Usuário submete um job para o nó mestre do cluster .
Job;
• Uma aplicação que vai executar no cluster.
• Um escalonador de jobs no nó mestre associa cada tarefa definida no job para núcleos ou nós de processamento do
cluster.
• Os resultados de processamento de cada tarefa são retornados para o usuário por meio do nó mestre.

COMPONENTES - BENEFÍCIOS.
• Disponibilidade.
• Desempenho.
• Escalabilidade.
COMPONENTES - TIPOS DE APLICAÇÕES.
• Orientada a processamento intensivo (CPU).
• Orientada a entrada e saída (I-O).
• Transacionais.

COMPONENTES - LIMITAÇÕES.
Latência tende a ser alta se não for utilizada tecnologia de comunicação com alta largura de banda (localmente).
O software para rodar no cluster tende a ser mais complexo do que aquele que vai executar em um único nó (host).

SEMANA 3, AULA 3.
O QUE É UM GRID?
• Trata-se de uma coleção de recursos computacionais e de comunicação utilizados para execução de aplicações.
• Um usuário vê o grid como uma entidade única.
ORIGEM: Power Grid, termo que determina o sistema de geração e distribuição de energia.
IAN FOSTER (1998) Foi o primeiro a abordar o termo Grid Computacional.

GRID - CARACTERÍSTICAS.
Grids são formados por recursos heterogêneos, o que engloba clusters, supercomputadores, desktops e até dispositivos
móveis.
Nó mestre (eventualmente replicado).
Nós de execução.
Nós de submissão.
Interligação.
Rede de comunicação pública de larga escala: Internet!.

25
GRID - PERVASIVIDADE.
O grid está disponível em todo lugar.
Plugue e use (assim como a rede elétrica).

GRID - VISÃO UNIFORME DOS RECURSOS COMPUTACIONAIS.

O usuário executa uma aplicação no grid, sem saber quais serão os nós envolvidos.

GRID - ARMAZENAMENTO REMOTO DE DADOS.

Dados do usuário podem ser armazenados de modo transparente e confiável no grid.

INFRAESTRUTURA MIDDLEWARE PARA GERENCIAMENTO DO GRID.

Gerencia todo o funcionamento do grid, desde a descoberta, alocação e reserva de recursos, até o controle de acesso, a
detecção de falhas, a manutenção de registros de utilização, etc.

FUNDAMENTADO EM TECNOLOGIAS JÁ EXISTENTES E DISPONÍVEIS.

Comunicação: protocolos da Internet - Web.
Software: tecnologia de Web Services.

Globus Toolkit.
http:--www.globus.org.
Gratuito e de código aberto.
Baseado nos seguintes padrões e tecnologias:
• Open Grid Services Architecture (OGSA).
• Web Services (SOAP, WSDL, Web Service Resource Framework, WS-Management).
• Job Submission Description Language (JSDL).
• Distributed Resource Management.
• Application API (DRMAA).
• Grid Security Infrastructure (GSI).

INTERNET X WWW X GRID X CLOUD

Internet.
• Infraestrutura de rede que conecta milhões de computadores (baseada na pilha TCP-IP).
• Criada na década de 1970.

WWW.
• Aplicação distribuída para o compartilhamento de informações- documentos construídos sob a Internet.
• Início na década de 1990.

GRID.
• Serviço também construído sob a Internet.
• No Grid, computadores compartilham poder computacional e recursos como armazenamento de disco, aplicações e
bases de dados.

CLOUD.
• Modelo que permite o acesso de forma onipresente, conveniente e sob demanda a um conjunto de recursos
computacionais compartilhados e configuráveis (por exemplo redes, servidores, armazenamento, aplicações e
serviços)

26
SEMANA 3, AULA 4.

O QUE É UMA CLOUD?

• Tecnologia que permite acesso remoto a recursos computacionais, seja hardware ou software sob demanda, e que
utiliza massivamente tecnologias de virtualização.
• Termo utilizado para descrever uma rede global de servidores, tendo cada um deles uma função única.
• Tais servidores foram desenvolvidos para armazenar e gerir dados, executar aplicações ou fornecer conteúdos ou um
serviço, como transmissão em fluxo de vídeos, webmail, software de produtividade para escritórios ou redes sociais.

CLOUD - CARACTERÍSTICAS.
SERVIÇO SOB DEMANDA.
• Usuário solicita os recursos que deseja.
• Obtenção simplificada de recursos, sem interação humana
POOL DE RECURSOS.
• Recursos são compartilhados entre diversos usuários e alocados com base na demanda.
ACESSO VIA REDE DE COMUNICAÇÃO.
• Recursos podem ser acessados remotamente usando diversos tipos de dispositivo.

GRID - CARACTERÍSTICAS.
ELASTICIDADE.
• Recursos alocados aos usuários podem variar em função da demanda.
MEDIÇÃO.
• Provedor monitora o uso dos recursos para controlar e tarifar.

MODELOS DE SERVIÇOS DE CLOUD, SAAS.

Também conhecido como software baseado em cloud, ou aplicativos em cloud, é um software de aplicativo hospedado em
cloud, que é acessado e usado por meio de um navegador da web.

MODELO DE SERVIÇOS DE CLOUD, PAAS.

Fornece aos desenvolvedores de software uma plataforma sob demanda (hardware, solução completa de software,
infraestrutura e até ferramentas de desenvolvimento).

MODELO DE SERVIÇOS DE CLOUD, IAAS.

Acesso sob demanda a recursos fundamentais de computação (servidores físicos e virtuais, rede e armazenamento) por meio
da internet com forma de pagamento conforme a utilização.

SERVIÇOS DE CLOUD – imagem.

27
CLOUD, MODELO DE IMPLANTAÇÃO PÚBLICA.
Formada por recursos computacionais (servidores e armazenamento) fornecidos por terceiros e disponíveis para qualquer
usuário ou organização que deseje utilizá-los.

CLOUD, MODELO DE IMPLATANÇÃO PRIVADA.

Organização mantém a infraestrutura sob o seu domínio oferecendo acesso restrito aos usuários.
É utilizada por organizações que devem seguir regras específicas sobre segurança e privacidade de dados (instituições
financeiras e governamentais).

CLOUD, MODELO DE IMPLANTAÇÃO HÍBRIDA.

União de Cloud Pública e Cloud Privada.
Compartilha dados e aplicações entre ambos os tipos de nuvens.
Com alguns recursos disponibilizados de forma privada e outros disponibilizados publicamente.

CLOUD, INFRAESTRUTURA.
TODA BASEADA EM GRANDES DATACENTERS.
Espalhados geograficamente pelo mundo.
Utiliza virtualização dos recursos computacionais.

PERGUNTA. Em relação à importância da infraestrutura para desenvolver soluções computacionais escaláveis, é

correto afirmar que:

• não há redução de custos na proposta do Open Computer Project para liberar infraestrutura de T.I. proprietárias.
• a granularidade dos componentes conhecida como “grossa” indica servidores, bancos de dados e firewalls.
• o custo energético não é uma preocupação dos data centers.
• a granularidade (uma extensão em que um sistema é dividido em partes) dos componentes conhecida como “fina”,
indica servidores, bancos de dados e firewalls.
• todos os usuários têm uma visão completa da infraestrutura computacional e de conectividade de uma solução.
Resposta certa. Em relação à importância da infraestrutura para desenvolver soluções computacionais escaláveis, é correto
afirmar que a granularidade (uma extensão em que um sistema é dividido em partes) dos componentes conhecida como
“fina”, indica servidores, bancos de dados e firewalls.

PERGUNTA. Uma definição conhecida de cluster de computadores é:

• um conjunto de dados.
• um conjunto de data centers.
• um aglomerado de dispositivos computacionais interligados por uma rede de comunicação.
• um servidor.
• uma nuvem.
Resposta certa. Uma definição conhecida de cluster de computadores é:
um aglomerado de dispositivos computacionais interligados por uma rede de comunicação.

PERGUNTA. Trata-se de uma característica de Grid Computing em que o usuário executa uma aplicação no Grid sem
saber quais são os nós envolvidos na computação.
• Armazenamento?
• Visão uniforme dos recursos computacionais?
• Visão complexa dos recursos computacionais?
• Pervasividade?
• Gerenciamento?
Resposta certa. Trata-se de uma característica de Grid Computing em que o usuário executa uma aplicação no Grid sem saber
quais são os nós envolvidos na computação.
Visão uniforme dos recursos computacionais.

28
PERGUNTA. O modelo SaaS no contexto de Cloud Computing significa:
• desenvolvimento de aplicações.
• sistema legado e segurança.
• armazenamento.
• comunicação.
ferramentas de desenvolvimento e gerenciamento de banco de dados.
Resposta certa. O modelo SaaS no contexto de Cloud Computing significa:
desenvolvimento de aplicações.
O SaaS é um dos modelos de serviços de computação em nuvem que se caracterizam por disponibilizar soluções (aplicações)
por meio da WWW como um serviço.

ATIVIDADE AVALIATIVA
PERGUNTA. Acerca dos tipos de cluster no contexto de computação escalável é correto afirmar que:
1. Afirmação correta. O cluster de balanceamento de carga depende de 1 ou mais nós balanceadores de carga que será
enviada aos servidores que de fato vão processar a carga.
2. Afirmação correta. O cluster de alta disponibilidade é aquele que tende a se manter resistente a falhas e quando esta
ocorre o usuário não percebe.
3. Afirmação falsa. O cluster de alta disponibilidade tem a mesma função que um cluster de alto desempenho.
4. Afirmação falsa. Cluster de alta disponibilidade é aquele usado para distribuir a carga de trabalho.

PERGUNTA. A metodologia para a construção de um cluster Beowulf envolve:

1. Afirmação correta. Switch.
2. Afirmação correta. Nós de processamento.
3. Afirmação falsa Computador usado como servidor com apenas uma placa de rede.
4. Afirmação correta. Um sistema operacional escolhido de acordo com a sua capacidade técnica.

PERGUNTA.A Grade (Grid) é uma plataforma para execução de aplicações paralelas amplamente distribuída,
heterogênea e compartilhada. Outras importantes características da grade incluem:
• a facilidade de utilização de recursos computacionais por qualquer usuário?
• a criação de processadores virtuais com recursos existentes?
• a separação geográfica obrigatória de recursos computacionais?
• a coleção de recursos homogêneos?
• agregação e coordenação de recursos?
Resposta certa. A Grade (Grid) é uma plataforma para execução de aplicações paralelas amplamente distribuída,
heterogênea e compartilhada. Outras importantes características da grade incluem:
agregação e coordenação de recursos.

PERGUNTA. O sistema operacional tem um papel fundamental na construção de clusters de alto desempenho, pois
garante o funcionamento primordial das seguintes tarefas:
1. Afirmação correta. Controle de Recursos.
2. Afirmação correta. Consulta.
3. Afirmação falsa. Monitoração.
4. Afirmação correta. Armazenamento seguro dos dados.

PERGUNTA. São características fundamentais da Computação em Nuvem segundo o Instituto Nacional de Padrões e
Tecnologia do Departamento de Comércio Norte-Americano (NIST):
• acesso via rede e elasticidade.
• utiliza licença para o sistema operacional e para as aplicações.
• serviço que não pode ser medido como a energia elétrica. T
• em como modelo de implantação o SaaS, IaaS e o PaaS.
• tem como modelo de serviços a nuvem privada, a nuvem híbrida e a nuvem pública.

29
Resposta certa. São características fundamentais da Computação em Nuvem segundo o Instituto Nacional de Padrões e
Tecnologia do Departamento de Comércio Norte-Americano (NIST): acesso via rede e elasticidade.

PERGUNTA. A granularidade é um importante aspecto que precisa ser considerado quando um problema computacional
deve ser quebrado em partes para ser processado em paralelo. É também importante considerar esse aspecto quando
discutimos a infraestrutura computacional e seus componentes. Analise as afirmações a seguir e escolha a alternativa correta
acerca da granularidade relacionada à infraestrutura.
1. Afirmação correta. A granularidade fina envolve servidores de bancos de dados.
2. Afirmação falsa. A granularidade fina e grossa não impacta no processamento das tarefas.
3. Afirmação falsa. A granularidade é sinônimo de disponibilidade.
4. Afirmação correta. A granularidade grossa envolve componentes dos servidores como placa-mãe, processadores e
memória.

PERGUNTA. Um cluster Beowulf é caracterizado como:

1. Afirmação falsa. Um aglomerado de computadores para compartilhar arquivos entre usuários, assim como o OneDrive, o
Google Drive e o Dropbox.
2. Afirmação correta. Um conjunto de computadores agrupados com o intuito de obter a menor razão custo-benefício.
3. Afirmação falsa. Um conjunto de computadores que utilizar hardware dependentes de fornecedores específicos.
4. Afirmação correta. Um conjunto de computadores que auxilia no processamento de tarefas computacionalmente
intensivas utilizando hardware barato e heterogêneo.

PERGUNTA. A computação em grade (Grid Computing) caracteriza-se pela coleção de recursos computacionais de
comunicação utilizado para a execução de aplicações. São características de uma Grade (Grid):
1. Afirmação correta. Visão uniforme de recursos computacionais.
2. Afirmação falsa. O nó mestre não é um elemento de um grid.
3. Afirmação falsa. O usuário vê um grid como várias entidades.
4. Afirmação correta. Ser fundamentado em protocolos da Internet-Web e tecnologias de Web Services.

SEMANA 4, AULA 1 - Frameworks para Computação Paralela – OpenM.P..

O QUE É OPEN M.P.?

• É um modelo de programação de memória compartilhada que nasceu da cooperação entre um grupo de grandes
fabricantes de software e hardware.
• API para programação paralela de arquiteturas multiprocessor, foi definida inicialmente para ser usada em
programas C, C++ (1998) e Fortran (1997) tanto Linux quanto Windows.
• Não é uma implementação, e sim uma especificação X.

Objetivos do Open M.P..

• Ser o padrão de programação para arquiteturas de memória compartilhada.
• Estabelecer um conjunto simples e limitado de diretivas de programação.
• Possibilitar a paralelização incremental de programas sequenciais.
• Permitir implementações eficientes em problemas de granularidade fina, média e grossa.

Componentes do Open M.P..

• Bibliotecas de funções.
• Diretivas de coM.P.I.lação.
• Variáveis de ambiente.

30
Limitações do Open M.P..
• Quanto mais variáveis compartilhadas entre as threads, mais difícil deve ser o trabalho para garantir que a visão das
variáveis são atuais – coerência de cache.
• Outras limitações são baseadas em hardware e estão associadas à forma como muitos SMPs são fisicamente capazes
de compartilhar o mesmo espaço de memória.
• O aspecto mais difícil de criar um programa de memória compartilhada é traduzir o que se deseja para uma versão
multi-thread.
• Outro ponto é fazer a versão muilti-thread do programa operar corretamente:
o Sem problemas com variáveis compartilhadas;
o Situações de condições de corrida – disputa;
o Detecção e Depuração dessas condições;
o Questões relativas ao tempo de execução.

MODELO DE PROGRAMAÇÃO UTILIZADO PELO OPEN M.P..

Paralelismo Explícito
Cabe ao programador anotar as tarefas para execução em paralelo e definir os pontos de sincronização. A anotação é feita
por utilização de diretivas de coM.P.I.lação embarcadas no código do programa.

Multithread Implícito
• Neste caso um processo é visto em conjunto de threads que se comunicam por meio da utilização de variáveis
compartilhadas:
o Criação
o Início
o Término
• Feito de forma implícita pelo ambiente de execução sem que o programador tenha que se preocupar com tais
detalhes.

Espaço de endereçamento global compartilhado entre as threads.

Variáveis podem ser compartilhadas ou privadas para cada thread.
Controle, manuseio e sincronização das variáveis envolvidas nas tarefas paralelas são transparentes ao programador.

MODELO DE EXECUÇÃO DO OPEN M.P..

Fork-Join
• Todos os programas iniciam sua execução com um processo mestre.
• O master thread executa sequencialmente até encontrar um construtor paralelo, momento em que cria um team de
threads.
• O código delimitado pelo construtor paralelo é executado em paralelo pelo master thread e pelo team de threads.
• Quando completa a execução paralela, o team de threads sincroniza em uma barreira implícita com o master thread.
• O team de threads termina a sua execução e o master thread continua a execução sequencialmente até encontrar
um novo construtor paralelo.
• A sincronização é utilizada para evitar a competição entre as threads.

Estrutura Básica de um Programa Open M.P. – imagem.

31
 • Definições da biblioteca em ó. m. p. ponto h (omp.h)
• Implementação dentro do linux em - lib. g. o. m. p. ponto s.ó. (libgomp.so)
• CoM.P.I.lação de um programa Opem M.P..
• É preciso utilizar a opção
• -fopenmp

VARIÁVEIS NO OPEM M.P. - PRIVADA.

• Declarar acesso entre as threads:
o Private (Privada)
o Pertencem e são conhecidas apenas a cada segmento específico

Exemplo Código- antes de iniciar a execução declara a varável como privada:

int id, nthreads;

pragma omp parallel private(id)
{id = omp_get_thread_num();

VARIÁVEIS NO OPEM M.P. - COMPARTILHADA.

• Declarar acesso entre as threads:

o Shared (Compartilhada)
o Variáveis compartilhadas são conhecidas por todas as threads
o Cuidados devem ser tomados quando utilizadas essas variáveis, já que a manipulação incorreta poderá
dificultar a detecção de erros como condições de disputa e deadlocks
Exemplo de Código:
int id, nthreads, A, B; A = getA();
B = getB();
#pragma omp parallel private(id,nthreads) shared(A,B)
{ id = omp_get_thread_num();

VARIÁVEIS NO OPEM M.P. – FIRST PRIVATE .

• Inicialização de Variáveis
• Firstprivate
• Permite inicializar uma variável privada na thread master antes de entrar em uma região paralela do código. Caso
contrátrio, todas as variáveis privadas serão consideradas não inicializadas no início da thread.

Exemplo de código

int id, myPi; myPi = 3.1459

#pragma omp parallel private(id) firstprivate(myPi)
{ id = omp_get_thread_num();

32
MAPEAMENTO PARA THREADS – imagem.

EXEMPLO - Hello World! – imagem.

PERGUNTA. O Open M.P. tem como característica essencial para desenvolver programas paralelos o que chamamos
de:
• paralelismo implícito.
• distribuição explícita.
• comunicação explícita.
• distribuição de dados.
33
Resposta Correta. O Open M.P tem como característica essencial para desenvolver programas paralelos o que chamamos de:
paralelismo explícito. Cabe ao programador anotar as tarefas para serem executadas em paralelo e definir os pontos de
sincronização.

SEMANA 4, AULA 2.
TEXTO BASE.
O M.P.I..
Durante a década de 90, foram produzidas duas especificações que unificaram os trabalhos dos participantes do
M.P.I. Forum (http://www.M.P.I.-forum.org) na área de processamento paralelo e distribuído. Este trabalho foi encabeçado
por um grupo formado por cerca de 60 pessoas provenientes de mais de 40 organizações dos Estados Unidos e Europa,
sendo fortemente influenciado pelos resultados até então alcançados nos grupos do IBM T.J. Watson Research Center, Intel's
NX/2 , Express, nCUBE's Vertex, p4 e o PARMACS. Outras importantes contribuições vieram também do Zipcode, Chimp,
PVM, Chameleon e PICL.
A primeira versão – M.P.I.-1 - foi publicada no ano de 1994 contando com os requisitos base necessários para o
padrão de troca de mensagens. Os pontos mais complexos foram deixados para a versão M.P.I.-2, lançada posteriormente
em 1997 [Mattson et al. 2010] .
Os trabalhos mais recentes do M.P.I. Forum remontam aos anos de 2008 e 2009, tendo como diretrizes a correção de
bugs, a coM.P.I.lação das duas especificações – M.P.I.-1 e M.P.I.-2 - em um único documento e a publicação de revisões
minor: M.P.I.-2.1 e M.P.I.2.2. A última atualização aconteceu em setembro de 2012, quando o grupo publicou o maior grupo
de atualizações no padrão, incluindo novas extensões, a remoção de bindings obsoletos para o C++ e o suporte ao FORTRAN
2008. Este último release foi nomeado como M.P.I.-3.0.
Apesar de não ser uma norma homologada por institutos como IEEE, IETF, o M.P.I. é “De facto” um padrão para
arquiteturas de memória distribuída, escrito e ratificado pelo M.P.I. Forum. A idéia central do M.P.I. consiste em prover
rotinas de sincronização e controle processos, além da distribuição e consolidação dos dados entre os computadores
interconectados, utilizando para isto o paradigma de troca de mensagens.
O modelo da API do M.P.I., entrega ao programador uma camada de abstração, altamente portável, entre o sistema
operacional/tecnologias de comunicação e a aplicação, permitindo escalar a execução do programa entre os computadores
da rede, com o uso de suas memórias e poder de processamento, baseado no padrão de divisão e conquista. Por ser uma
camada de alto nível, é possível utilizar o mesmo programa em uma grande variedade de computadores que estejam
interconectados. A API é muito adequada a programas de propósito geral desenhados para sistemas SIMD e MIMD.
O padrão tem como foco auxiliar a todos que precisem ou desejem criar aplicativos portáveis e paralelos em Fortran
e C, fornecendo uma interface simples que atenda desde soluções menos sofisticadas até as mais avançadas, voltadas para o
alto desempenho, como as disponíveis em computadores massivamente paralelos.
Cabe enfatizar que o M.P.I. é uma especificação. No entanto, há disponíveis no mercado implementações livres e
pagas. Podemos relacionar no modelo pago o Intel M.P.I., HP M.P.I. e o MATLab M.P.I.. Já as implementações open source
mais utilizadas são 33 o Open M.P.I. e o M.P.I.CH. Fabricantes de supercomputadores costumam incluir features e
ferramentas específicas que visam maximizar o desempenho em suas máquinas.
Apesar de todas as facilidades do padrão, a identificação das zonas paralelas (áreas do código que podem ser
executadas simultaneamente a outras tarefas) e o dimensionamento de carga entre os computadores participantes, ficam a
cargo do desenvolvedor e devem ser explicitadas no programa. Uma análise prévia do problema a ser tratado, irá auxiliá-lo
nesta tarefa.
Como o objetivo é o aumento de desempenho, deve-se ter em mente o projeto de um programa que realiza a menor
troca de mensagens possível, visando anular e/ou reduzir o impacto do tempo despendido na distribuição e consolidação dos
dados, no tempo total de execução. Podemos relacionar como exemplos os Hipercubos e Meshes, que são formas de
interconexão que visam reduzir e otimizar o processamento. Não iremos abordar este tema aqui por ser tratar de um tópico
complexo para quem está começando a explorar computação paralela. Para finalizar a apresentação do padrão, vamos
conhecer alguns conceitos importantes inerentes a API, os quais nos ajudarão a compreender as funções disponíveis e como
funciona o M.P.I.. Estes são:
• Processo: é o módulo executável, ou seja, seu programa, que pode ser dividido em N partes, e executado em
uma ou mais máquinas;
• Grupo: é o conjunto de processos. No M.P.I. a constante M.P.I._COMM_WORLD armazena o comunicador de
todos os processos definidos na aplicação M.P.I.;

34
 • Rank: o controle de execução do programa em M.P.I. depende diretamente da correta identificação do
processador no grupo de trabalho. Esta identificação é um número inteiro que varia de 0 a N-1 processos. A
função M.P.I._Comm_rank determina qual é o identificador de cada processo dentro do comunicador;
• Comunicador: é o componente que representa o domínio de uma comunicação em uma aplicação M.P.I.;
• Buffer de Aplicação: é o espaço reservado em memória para armazenar os dados das mensagens que um
processo necessita enviar ou receber, gerenciado pela aplicação;
• Buffer de Sistema: é o espaço reservado em memória pelo sistema para o gerenciamento de mensagens.
2.8.1

Estrutura de um código M.P.I..

Antes de avançarmos nas funções que compõe a API, precisamos compreender alguns aspectos estruturais no
código. Na declaração de dependências, é obrigatório a inclusão do cabeçalho M.P.I..h em todos os arquivos que utilizarem
algum recurso do M.P.I.. Este cabeçalho contém as definições de funções e constantes necessários durante o
desenvolvimento e coM.P.I.lação do seu programa. Todas as chamadas M.P.I. devem estar entre o M.P.I._Init e o
M.P.I._Finalize,

O M.P.I. emprega uma consistente padronização, que ajuda o desenvolvedor a identificar facilmente métodos e tipos
da API. Todos os identificadores possuem o prefixo “M.P.I._”. Tipos e constantes estão em letras maiúsculas (Ex.
M.P.I._SHORT) e as funções estão definidas com a primeira letra em maiúscula e as demais letras em minúsculas. (Ex.
M.P.I._Send).
Para o tratamento de exceções, a biblioteca conta com um manipulador de erros próprio. Caso ocorra algum
problema durante a execução, o mesmo é responsável por sinalizar a ocorrência para seu aplicativo e abortar as chamadas
M.P.I. .

M.P.I._Finalize
Finaliza o ambiente de execução do M.P.I., liberando os recursos utilizados durante o processamento. Deve ser
invocado sob a mesma Thread que executou o M.P.I._Init. Este método não possui argumentos.

Envio e recebimento de dados síncrono: M.P.I._Send e M.P.I._Recv

O M.P.I. disponibiliza várias rotinas para realizar as operações de envio e recebimento de mensagens entre os processadores,
enquanto a de envio é feita pela função M.P.I._Send, a de recebimento é pelo M.P.I._Recv. Estes dois métodos realizam a
operação de envio e recebimento de mensagens de forma síncrona, ou seja, aguarda a confirmação de recebimento da
mensagem para passar para a próxima instrução.

Envio e recebimento de dados assíncrono: M.P.I._Isend e M.P.I._Irecv

O M.P.I._Isend e o M.P.I._Irecv fornecem a funcionalidade de envio e recebimento assíncrono, respectivamente. Como só o
comportamento é modificado, é possível combinar os métodos M.P.I._Send/M.P.I._Recv com os métodos
M.P.I._Isend/M.P.I._Irecv.

35
M.P.I._Wait
Ao realizar operações assíncronas, podemos nos deparar com situações de dependência ( dados, instruções, entre outros)
onde é necessário assegurar a conclusão dos mesmos antes de executar a próxima instrução. Para solucionar tais questões o
M.P.I. fornece funções como o M.P.I._Wait.

Comunicações Coletivas
Até o momento, foram apresentadas rotinas que fazem a comunicação entre dois processos específicos,
denominados ponto-a-ponto. Adicionalmente a estas funções, o M.P.I. provê suporte a operações que devem ser realizadas
simultaneamente em mais de 38 dois processos de um grupo de trabalho, especificados através do contexto - para
arquiteturas SIMD (M.P.I._COMM_WORLD), já em MIMD (o comunicador criado pela função M.P.I._Comm_create). As
operações mais comuns nas comunicações coletivas são as que realizam sincronização, distribuição de dados (Broadcast) e
finalmente, as reduções (Reduction) para operações de consolidação de dados, como operações de soma por exemplo.
As operações mais comuns nas comunicações coletivas são as que realizam sincronização, distribuição de dados
(Broadcast) e finalmente, as reduções (Reduction) para operações de consolidação de dados, como operações de soma por
exemplo.

M.P.I._Barrier
O M.P.I._Barrier define um ponto de sincronização entre todos os processos participantes da comunicação coletiva, isto é, o
código não pode prosseguir enquanto todos não estiverem no sincronizados no mesmo ponto.

M.P.I._Bcast
A distribuição de uma mensagem para todos os processos do grupo é realizado pela função M.P.I._Bcast

0 M.P.I._Reduce
Para a consolidação dos resultados do processamento em comunicações coletivas, a função M.P.I._Reduce fornece vários
tipos de operações

M.P.I._Allgather
Quando todos os processos precisam receber os dados coletados dos demais processos do grupo, o M.P.I._Allgather deve ser
utilizado. Novamente aqui os dados precisam ser do mesmo tamanho.

Tipos derivados de dados.

Os mecanismos básicos de comunicação do M.P.I. podem ser usados para enviar ou receber sequências de
elementos de mesmo tipo, que podem ser ou não contíguos em memória. O objetivo é amortizar o custo desta operação e
prover ganhos no tempo total de execução do seu algoritmo.
Diferentemente da abordagem de declaração em tempo de desenvolvimento, no M.P.I. os tipos de dados são criados
em tempo de execução, entre as funções M.P.I._Init e M.P.I._Finalize. O ciclo de vida destes tipos possuem as seguintes
etapas: declaração, alocação, o uso efetivo do tipo durante a execução do programa e, finalmente, a liberação dos recursos.
Os métodos de construção destes tipos são:
• M.P.I._Type_contiguous: é o construtor mais simples dentre os disponibilizados no M.P.I.. Gera um novo tipo
contínuo a partir de cópias de um tipo de dados existente.
• M.P.I._Type_vector: semelhante ao M.P.I._Type_contiguous, porém permite a configuração de lacunas
(strides) nos deslocamentos. Há ainda a função M.P.I._Type_hvector que é um M.P.I._Type_vector, porém
definido em bytes
• M.P.I._Type_vector: semelhante ao M.P.I._Type_contiguous, porém permite a configuração de lacunas
(strides) nos deslocamentos. Há ainda a função M.P.I._Type_hvector que é um M.P.I._Type_vector, porém
definido em bytes
• M.P.I._Type_struct: dos tipos derivados, este é o mais genérico. O novo tipo é formado de acordo com cada
componente da estrutura de dados
Antes de ser utilizado, é necessário informar aos processadores da comunicação coletiva que o tipo está disponível.
Esta operação é feita através da função M.P.I._Type_commit. Para a liberação dos recursos alocados, a função é a
M.P.I._Type_free. Como o free no C, o M.P.I._Type_free evita o consumo de memória desnecessário, para os tipo de dados
que não são mais utilizados.
36
A utilização de tipos derivados é recomendada por prover uma solução portável e elegante para o envio de dados não
contíguos, maximizando a eficiência dos métodos de envio e recebimento de dados, promovendo ganhos no tempo total de
execução do seu programa.

O QUE É OPEN M.P.I. - M.P.I (Message Passing Interface)?

• O modelo de passagem de mensagens é um conjunto de processos que possuem acesso à memória local. As
informações são enviadas da memória local do processo para a memória local do processo remoto.
• M.P.I. é uma biblioteca de Message Passing desenvolvida para ambientes de memória distribuída, máquinas
massivamente paralelas, NOWs (network of workstations) e redes heterogêneas Padrão criado por um consórcio
entre empresas e universidades
• É uma biblioteca de rotina que fornece funcionalidade básica para que os processos se comuniquem.
• O paralelismo é explícito (programador é responsável pela distribuição)

MOTIVAÇÃO PARA USO DO OPEN M.P.I.

• Necessidade de poder computacional
• Dificuldades na melhoria dos processadores sequenciais
• Custo x Benefício
• Dificuldades
o Comunicação, coordenação, sincronização
o Distribuição de trabalho

CARACTERÍSTICAS- VANTAGENS E DESVANTAGENS DO M.P.I.

Vantagens do M.P.I.
• Maduro
• Portabilidade é facilidade
• Combina eficientemente com diversos hardwares
• Implementações proprietárias e públicas
• Interface com usuário
• Buffer de manipulação
• Permite abstrações de alto nível
• Desempenho
Desvantagens do M.P.I.
• O ambiente de controle de execução depende da implementação
• Comunicação entre os hosts pode ser o gargalo da solução

OUTRAS CARACTERÍSTICAS DO M.P.I.

Thread Safety
• Comunicação ponto-a-ponto
• Modos de comunicação: standard, synchronous, ready, buffered
• Buffers estruturados
• Tipos de dados derivados

Comunicação Coletiva
• Nativo já incorporado, operações coletivas definidas pelo usuário
• Rotinas de movimentação de dados

Perfis
• Usuários podem interceptar chamadas M.P.I. e chamar suas próprias ferramentas

37
CONCEITOS BÁSICOS DO M.P.I..

Processo
• Cada parte do programa quebrado é chamado de processo. Os processos podem ser executados em uma única
máquina ou em várias.
Rank
• Todo o processo tem uma identificação única atribuída pelo sistema quando o processo é inicializado. Essa
identificação é contínua e representada por um número inteiro, começando de zero até N-1, cujo N é o número de
processos. Cada processo tem um rank, e ele é utilizado para enviar e receber mensagens.
• Usado pelo desenvolvedor para especificar a fonte e o destino de mensagens  Pode ser usado condicionalmente
pela aplicação para controlar a execução do programa.
• Exemplo de código:
if rank == 0
do ...
else if rank == 1
do …

Grupos
• Grupo é um conjunto ordenado de N processos. Todo e qualquer grupo é associado a um comunicador muitas vezes
já predefinido como "M.P.I._COMM_WORLD"

Comunicador
• O comunicador é um objeto local que representa o domínio (contexto) de uma comunicação (conjunto de processos
que podem ser contatados). O M.P.I._COMM_WORLD é o comunicador predefinido que inclui todos os processos
definidos pelo usuário numa aplicação M.P.I.
• As chamadas de M.P.I._Send e M.P.I._Recv correspondentes devem possuir o mesmo comunicador

Application Buffer
• É o endereço de memória, gerenciado pela aplicação, que armazena um dado que o processo necessita enviar ou
receber

System Buffer
• É um endereço de memória reservado pelo sistema para armazenar mensagens.

Count
• Indica o número de elementos de dados de um tipo, para ser enviado

Type
• O M.P.I. pré define tipos de dados elementares

Tag
• Inteiro (não negativo). Utilizado para identificar unicamente uma mensagem. As chamadas de M.P.I._Send e
M.P.I._Recv correspondentes devem possuir a mesmo tag

Status
• Para uma operação de receive, indica a fonte da mensagem e a tag da mensagem. Em C, um ponteiro para uma
estrutura pré-definida (M.P.I._STATUS). Adicionalmente, o número de bytes é obtido do status, via rotina
M.P.I._Get_Count

38
PRINCIPAIS FUNÇÕES DO M.P.I..
Em geral são utilizadas:
• MPI_Init
• MPI_Finalize
• MPI_Comm_size
• MPI_Comm_rank
• MPI_Get_processor_name

MPI_Init
Inicializa um processo M.P.I.
Deve ser a primeira rotina a ser chamada por cada processo, pois estabelece o ambiente necessário para executar o MPI
Sincroniza todos os processos na inicialização de uma aplicação MPI
Utilizada para passar argumentos de linha de comando para todos os processos

MPI_Finalize
M.P.I_Finalize é chamada para encerrar o M.P.I. Ela deve ser a última função a ser chamada. É usada para liberar memória.
Não existem argumentos

Exemplo com MPI_Init e MPI_Finalize – IMAGEM.

MPI_Comm_size
• Determina o número de processos no grupo, associado com o comunicador
• Usado com o comunicador MPI_COMM_WORLD para determinar o número de processos utilizados pela aplicação
• Obtém o comunicador como seu primeiro argumento, e o endereço de uma variável inteira é usada para retornar o
número de processos
MPI_Comm_rank
• Identifica um processo M.P.I. dentro de um determinado grupo comunicador. Retorna sempre um valor inteiro entre
0 e n-1, cujo n é o número de processos

Exemplo com MPI_Comm_size e MPI_Comm_rank – IMAGEM.

39
MPI_Get_processor_name
• Retorna o nome do nó, cujo processo individual está executando
• Usa um argumento para guardar o nome da máquina e outro para o tamanho do nome

Exemplo com MPI_Get_processor_name – IMAGEM.

PERGUNTA. Uma característica que difere o MPI do OpenMP é que:

• no OpenMPI não há comunicação entre os hosts de processamento.
• no OpenMP há comunicação entre os hosts de processamento.
• no OpenMPI o paralelismo é implícito.
• no OpenMPI há comunicação entre os hosts de processamento.
• no OpenMP o paralelismo é implícito.

Resposta certa. Uma característica que difere o MPI do OpenMP é que: no OpenMPI há comunicação entre os hosts de
processamento. A comunicação entre os hosts que processam uma grande tarefa se mal utilizada impacta no tempo de
resposta.
40
SEMANA 4, AULA 3 - Frameworks para Computação Paralela – CUDA.

INTRODUÇÃO AO CUDA
• CUDA é uma plataforma de software e hardware para computação paralela de alto desempenho que utiliza o poder
de processamento dos núcleos das GPUs da NVIDIA
• Possui demanda nos campos matemático, científico e biomédico, além das demandas na computação e na
engenharia devido às características das aplicações nesses campos, que são altamente paralelizáveis
• O motivo para as GPUS serem tão eficientes é que elas são exclusivamente dedicadas a processar dados não tendo
que guardar informações de cache ou controlar fluxos de dados.

ESTRUTURA DO CUDA – IMAGEM.

ORGANIZAÇÃO DAS THREADS DO CUDA

• O escalonamento das threads da plataforma CUDA utiliza dois conceitos: bloco e grid. Através deles se organiza a
repartição dos dados entre as threads, a organização e a distribuição dos dados ao hardware
• Em geral, cada bloco dispõe de duas ou três coordenadas dimensionais dadas por palavras chave: blockIdx.x,
blockIdx.y e blockIdx.z

41
ORGANIZAÇÃO DAS THREADS DO CUDA – IMAGEM.

MODELO DE MEMÓRIA CUDA

• Memória global e memória constante podem ser escritas e lidas pelo host chamando funções da API
o Memória global: maior e também a mais lenta
o Memória constante: é pequena e mais rápida Suporta, basicamente, apenas só leitura

42
CUDA EM DOCKER E CLOUD – IMAGEM.

UTILIZAÇÃO DO CUDA
Para utilizar o CUDA é preciso:

• Ter uma placa gráfica da Nvidia

• Ter o driver da Nvidia devidamente configurado no host
• Ter um toolkit contendo compilador e ferramentas adicionais
• Para saber os requisitos, o site da Nvidia detalha tais necessidades https://developer.nvidia.com/cuda-downloads

APLICAÇÕES DO CUDA
• Ataques cardíacos são a maior causa de mortes no mundo todo
• Utilização de GPUs com o objetivo de simular o fluxo sanguíneo e identificar placas arteriais ocultas sem fazer uso de
técnicas de imageamento invasivas ou cirurgias exploratórias
• Simulação de moléculas com melhor desempenho com a utilização de GPUs
• A aceleração do desempenho é resultado da arquitetura paralela das GPUs

PERGUNTA. Um componente da estrutura do CUDA que está diretamente ligada ao device é o:

• aplicação?
• cuda runtime?
• cuda driver?
• docker?
• cuda libraries?

Resposta certa. Um componente da estrutura do CUDA que está diretamente ligada ao device é o cuda driver. A função do
CUDA driver é aceitar requisitos abstratos do software independente do dispositivo acima dele e cuidar para que a
solicitação seja executada, permitindo que o software em CUDA interaja com o dispositivo.

43
PERGUNTA.É um padrão que estabelece um conjunto de diretivas para programação utilizando memória
compartilhada.
• C / C++
• Java
• OpenMPI
• OpenMP
• CUDA

Resposta certa. É um padrão que estabelece um conjunto de diretivas para programação utilizando memória compartilhada.
O OpenMP tem como característica permitir que programas possam explorar o paralelismo por meio de memória
compartilhada, fazendo uso de threads.

PERGUNTA.Trata-se de uma arquitetura de memória utilizada pelo MPI em que cada unidade de processamento
possui suas próprias memórias e processadores:
• publica.
• distribuída.
• híbrida.
• compartilhada.
• privada.

Resposta certa. Trata-se de uma arquitetura de memória utilizada pelo MPI em que cada unidade de processamento possui
suas próprias memórias e processadores: arquitetura de memória distribuída. O MPI é um padrão que permite que
processos que executem em hosts diferentes possam trocar dados por meio de uma rede de comunicação. Ou seja, o
processamento paralelo é feito com base em memórias locais de cada host, e na sequência combinam resultados parciais de
processamento.

PERGUNTA.O nome da plataforma de computação paralela que utiliza unidades gráficas para explorar o máximo de
paralelismo, permitindo aumentos significativos de desempenho ao aproveitar a potência da GPU, denomina-se:
• CUDA.
• Spark.
• OpenMP.
• Hadoop.
• MPI.

Resposta certa. O nome da plataforma de computação paralela que utiliza unidades gráficas para explorar o máximo de
paralelismo, permitindo aumentos significativos de desempenho ao aproveitar a potência da GPU, denomína-se: CUDA.
CUDA é uma plataforma e modelo de programação para computação paralela criados pela NVIDIA. Ela aproveita a potência
da unidade de processamento gráfico para processar dados.

PERGUNTA. Em relação à aceleração de um código sequencial na GPU, os passos devem envolver:

• a divisão de metade das funções computacionalmente intensivas em instruções que serão processadas na GPU?
• a divisão de todas as funções do código em instruções que serão processadas na GPU?
• a divisão de funções computacionalmente intensivas em instruções que serão processadas na GPU?
• a divisão de todas as funções mais simples em instruções que serão processadas na GPU?
• a divisão de funções mais simples em instruções que serão processadas na GPU?

Resposta certa. Em relação à aceleração de um código sequencial na GPU, os passos devem envolver: a divisão de funções
computacionalmente intensivas em instruções que serão processadas na GPU.

44
PERGUNTA. Se comparamos o OpenMP com o OpenMPI podemos afirmar que:
Afirmação falsa. O OpenMPI é um padrão para troca de mensagens que utiliza memória compartilhada.

Afirmação falsa. O OpenMP é um padrão para troca de mensagens que utiliza memória distribuída.

Afirmação correta. O OpemMPI utiliza comunicação coletiva entre processos.

Afirmação correta. O conceito de rank é nativo do OpenMPI.

PERGUNTA. No ambiente de programação CUDA, a função utilizada para acessar dados da memória do dispositivo,
bem como a função para alocar memória são respectivamente:
• FreeCuda, CudaMalloc?
• Free, CudaMalloc?
• cudaFree, cudaMalloc?
• cudaFree, CudaMemcpy?
• FreeCuda, MallocCuda?

Resposta certa. No ambiente de programação CUDA, a função utilizada para acessar dados da memória do dispositivo, bem
como a função para alocar memória são respectivamente: cudaFree, CudaMemcpy

PERGUNTA. O, (lacuna para preencher), é um padrão para desenvolver códigos em arquiteturas de memória compartilhada
e para isso utiliza o modelo , (lacuna para preencher), em que os programas iniciam como um único processo denominado ,
(lacuna para preencher), o qual executa sequencialmente até encontrar a primeira região paralela.

• openmp, fork-join, master thread?

• openmpi, fork-join, slave thread?
• openmp, fork-join, rank?
• openmpi, fork-join, slave thread?
• openmpi, fork-join, rank?

Resposta certa. O, (openmp), é um padrão para desenvolver códigos em arquiteturas de memória compartilhada e para isso
utiliza o modelo , (fork-join), em que os programas iniciam como um único processo denominado , (master thread), o qual
executa sequencialmente até encontrar a primeira região paralela.

PERGUNTA. Os modelos que lidam com ambientes computacionais de , (lacuna para preencher), são os que utilizam o
paradigma de , (lacuna para preencher), os quais são compostos por rotinas de comunicação e sincronização de tarefas. Um
exemplo que utiliza tal modelo é o , (lacuna para preencher).

• memória híbrida, passagem de mensagens, OpenMP?

• memória híbrida, passagem de mensagens, OpenMPI?
• memória compartilhada, passagem de mensagens, OpenMP?
• memória distribuída, passagem de mensagens, OpenMP?
• memória distribuída, passagem de mensagens, OpenMPI?

Resposta certa. Os modelos que lidam com ambientes computacionais de , (memória distribuída), são os que utilizam o
paradigma de , (passagem de mensagens), os quais são compostos por rotinas de comunicação e sincronização de tarefas.
Um exemplo que utiliza tal modelo é o , (OpenMPI).

45
PERGUNTA. A plataforma CUDA da Nvidia utiliza o poder de processamento gráficos da GPUs (Graphical Processing Unit)
para auxiliar na resolução de tarefas computacionais complexas nos campos da medicina e engenharia por exemplo. Sobre o
CUDA podemos afirmar que:

• CUDA não pode ser utilizada em containers Docker?

• O escalonamento de tarefas em CUDA usa o conceito de grid e processo?
• O escalonamento de tarefas em CUDA usa o conceito de bloco e processo?
• O CUDA utiliza apenas o conceito de memória local da GPU?
• O ambiente do CUDA envolve bibliotecas que estão linkadas o CUDA runtime?

Resposta certa. A plataforma CUDA da Nvidia utiliza o poder de processamento gráficos da GPUs (Graphical Processing Unit)
para auxiliar na resolução de tarefas computacionais complexas nos campos da medicina e engenharia por exemplo. Sobre o
CUDA podemos afirmar que: O ambiente do CUDA envolve bibliotecas que estão linkadas o CUDA runtime.

PERGUNTA. O CUDA (Computer Unified Device Architecture), além de ser uma plataforma de computação paralela é
também um modelo de programação. Este modelo envolve , (lacuna para preencher), que possui duas ou três coordenadas
dimensionais. Tais , (lacuna para preencher), são partes de um , (lacuna para preencher).

• grids, blocos, grids?

• grids, blocos, bloco?
• grids, grids, blocos?
• blocos, grids, blocos.?
• blocos, blocos, grid?

Resposta certa. O CUDA (Computer Unified Device Architecture), além de ser uma plataforma de computação paralela é
também um modelo de programação. Este modelo envolve , (blocos), que possui duas ou três coordenadas dimensionais.
Tais , (blocos), são partes de um , (grid).

PERGUNTA. O OpenMP é um padrão de programação para arquiteturas de memória compartilhada que apresenta
como característica:
• funcionar somente no Linux.
• lidar apenas diretivas de compilação, mas não com variáveis de ambiente.
• deixar ao programador lidar com o paralelismo implícito.
• utilizar o modelo de execução fork-thread.
• permitir implementações de códigos com diferentes tipos de granularidade

Resposta certa. O OpenMP é um padrão de programação para arquiteturas de memória compartilhada que apresenta como
característica: permitir implementações de códigos com diferentes tipos de granularidade

46
SEMANA 5, TEXTO BASE.
Hadoop - Histórico
Desde sua origem até hoje, o Hadoop apresentou uma rápida evolução. A seguir apresentamos alguns dos fatos
marcantes que nortearam a evolução e a história doHadoop, como é hoje conhecido.

• Fevereiro de 2003: a Google buscava aperfeiçoar seu serviço de busca de páginas Web - ferramenta pela qual ficou
mundialmente conhecida – almejando criar uma melhor técnica para processar e analisar, regularmente, seu imenso
conjunto de dados da Web. Com esse objetivo, Jeffrey Dean e Sanjay Ghemawat, dois funcionários da própria
Google, desenvolveram a tecnologia MapReduce, que possibilitou otimizar a indexação e catalogação dos dados
sobre as páginas Web e suas ligações. O MapReduce permite dividir um grande problema em vários pedaços e
distribuí-los em diversos computadores. Essa técnica deixou o sistema de busca da Google mais rápido mesmo sendo
executado em computadores convencionais e menos confiáveis, diminuindo assim os custos ligados a infraestrutura.
• Outubro de 2003: depois do desenvolvimento da tecnologia MapReduce pela Google, três de seus funcionários:
Sanjay Ghemawat, Howard Gobioff, e Shun- Tak Leung, publicaram um artigo intitulado The Google File System
(Ghemawat, Gobioff, & Leung, 2003). Esse trabalho descreve um sistema de arquivos implementado por eles,
chamado Google File System (GFS ou ainda GoogleFS). O GFS é um sistema de arquivos distribuído que foi criado
para dar suporte ao armazenamento e o processamento do grande volume de dados da Google por meio da
tecnologia MapReduce.
• Dezembro de 2004: pouco mais de um ano após a divulgação do GFS, Sanjay Ghemawat, coautor do artigo sobre o
GFS, junto com Jeffrey Dean, que também é funcionário da Google, publicaram o artigo Simplified Data Processing on
Large Clusters (Dean & Ghemawat, 2004), agora sobre o modelo de programação MapReduce, que foi criado pela
Google em 2003. Nesse artigo, os autores apresentaram os principais conceitos e características da tecnologia,
porém, sem mencionar muitos detalhes sobre como implementá-la.
• Dezembro de 2005: o consultor de software Douglas Cutting divulgou a implementação de uma versão do
MapReduce e do sistema de arquivos distribuídos com base nos artigos do GFS e do MapReduce publicados pelos
funcionários da Google. Esta implementação estava integrada ao subprojeto Nutch (White, 2010), liderado por
Cutting, que é o esforço da comunidade de software livre para criar um motor de busca na Web, mais
especificamente um rastreador de páginas Web (web crawler) e um analisador de formato de documentos (parser).
Por sua vez, o Nutch fazia parte de um projeto muito maior chamado Lucene, um programa de busca e uma API de
indexação de documentos.
• Fevereiro de 2006: percebendo que enfrentava problemas similares ao de indexação de páginas da Google, a
empresa Yahoo! decide contratar Cutting e investir para que ele desse andamento a seu projeto de código aberto.
Nesse mesmo ano, o projeto recebe o nome de Hadoop - nome do elefante amarelo de pelúcia do filho de Cutting -
deixa de ser parte integrante do Nutch e passa a ser um projeto independente da Apache Software Foundation.
• Abril de 2007: passado mais de um ano desde a contratação de Cutting, o Yahoo! anuncia ter executado com sucesso
uma aplicação Hadoop em um aglomerado de 1.000 máquinas. Também nessa data, o Yahoo! passa a ser o
maior contribuinte no desenvolvimento do arcabouço. Alguns anos depois, a empresa já contava com mais de 40.000
máquinas executando o Hadoop (White, 2010).
• Janeiro de 2008: o Apache Hadoop, que já se encontrava na versão 0.15.2, tem lançamento constante de versões
com correção de erros e novas funcionalidades e, nesse mês, se transforma em um dos principais projetos da
Apache.
• Julho de 2008: uma aplicação Hadoop em um dos aglomerados do Yahoo! quebra o recorde mundial de velocidade
de processamento na ordenação de 1 terabyte de dados. O aglomerado era composto de 910 máquinas e executou a
ordenação em 209 segundos, superando o recorde anterior que era de 297 segundos.
• Setembro de 2009: a Cloudera contrata Cutting como líder do projeto. Cloudera é uma empresa que redistribui uma
versão comercial derivada do Apach Hadoop, que integra, em um único pacote, os subprojetos mais populares do
Hadoop.
• Dezembro de 2011: passado seis anos desde seu lançamento, o Apache Hadoop disponibiliza sua versão 1.0.0. Os
desenvolvedores da ferramenta afirmam que essa versão possui maior confiabilidade e estabilidade em
escalonamentos. Dentre os destaques dessa nova versão, cabe mencionar o uso do protocolo de autenticação de
rede Kerberos, para maior segurança de rede; a incorporação do subprojeto HBase, oferecendo suporte a BigTable; e
o suporte à interface webhdfs, que permite o acesso HTTP para leitura e escrita de dados.

47
 • Maio de 2012: no momento em que este capítulo é escrito, a Apache faz o lançamento da primeira versão da série
2.0 do Hadoop. Na Figura 3.1 é apresentado um cronograma no formato linha do tempo do lançamento de todas as
versões disponibilizadas do Hadoop. Do lado esquerdo, estão as versões estáveis e do lado direito as versões beta. É
possível perceber o grande apoio da comunidade observando a quantidade de releases liberadas e o curto intervalo
entre elas.

Quem utiliza?
A eficácia obtida pelo Hadoop pode ser constatada ao verificar a quantidade de importantes empresas, de diferentes ramos,
que estão usando Hadoop para fins educacionais ou de produção. Como já foi mencionado, um dos maiores desenvolvedores
e contribuintes do projeto tem sido a empresa Yahoo!, entretanto, atualmente, tem sido utilizado também por outras
grandes corporações. A seguir apresentaremos uma lista com algumas das principais instituições que utilizam Hadoop,
todavia, uma lista mais abrangente pode ser consultada no sítio do próprio projeto2. Adobe, e-Bay, Facebook, Last.FM,
LinkedIn, The New York Times, Twitter, Yahoo.

Apesar dos valores correspondentes aos parques computacionais não serem exatos, é possível vislumbrar a
infraestrutura das empresas e também observar a diversidade de áreas na qual o Hadoop está sendo utilizado.
Por se tratar de um software sob a tutela da Apache Software Foundation, o Apache Hadoop segue o modelo de
licenciamento da Apache3, que é bem flexível, e permite modificações e redistribuição do código-fonte. Assim, surgiram no
mercado, diversas implementações derivadas do Apache Hadoop. Cada uma dessas implementações normalmente
acrescentam novas funcionalidades, aplicam especificidades de um nicho de mercado, ou ainda limitam-se a prestação de
serviços como implantação, suporte e treinamento. Dentre algumas empresas com estes objetivos
temos a Amazon Web Service, Cloudera, Hortonworks, KarmaSphere, Pentaho e Tresada. Atualmente, a Cloudera é chefiada
por Douglas Cutting, um dos criadores do Apache Hadoop original.

Vantagens
O Apache Hadoop é considerado atualmente uma das melhores ferramentas para processamento de alta demanda
de dados. Entre os benefícios de utilizá-lo pode-se destacar:

Código aberto: todo projeto de software livre de sucesso tem por trás uma comunidade ativa. No projeto Apache
Hadoop, essa comunidade é composta por diversas empresas e programadores independentes partilhando seus
conhecimentos no desenvolvimento de melhorias, funcionalidades e documentação. Entende-se que essa colaboração
remeta a uma possível melhoria na qualidade do software devido ao maior número de desenvolvedores e usuários
envolvidos no processo. Um maior número de desenvolvedores é potencialmente capaz de identificar e corrigir mais falhas
em menos tempo. Um número maior de usuários gera situações de uso e necessidades variadas. Também, em um
trabalho cooperativo, os desenvolvedores tendem a ser mais cuidadosos em suas atividades, pois sabem que sua produção
será avaliada por muitos outros profissionais. Além disso, sendo um software de código aberto, tem por princípio a garantia
das quatro liberdades aos seus usuários: liberdade para executar o programa para qualquer propósito; liberdade de estudar
como o programa funciona e adaptá-lo para as suas necessidades; liberdade de redistribuir cópias do programa; e liberdade
para modificar o programa e distribuir essas modificações, de modo que toda a comunidade se beneficie;

Economia: podemos apontar neste quesito 3 formas de economia. Primeiro, como já discutido no item anterior, por
ser um software livre, com um esforço relativamente pequeno é possível implantar, desenvolver aplicações e executar
Hadoop sem gastar com aquisição de licenças e contratação de pessoal especializado. Segundo, um dos grandes benefícios
para quem faz uso do Hadoop é a possibilidade realizar o processamento da sua massa de dados utilizando máquinas e rede
convencionais. Por último, existe uma outra alternativa econômica dado pela existência de serviços em nuvem, como a
Amazon Elastic MapReduce (EMR), que permite a execução de aplicações sem a necessidade de implantar seu próprio
aglomerado de máquinas, alugando um parque virtual ou simplesmente pagando pelo tempo de processamento utilizado;

Robustez: um outro diferencial do Hadoop é que como ele foi projetado para ser executado em hardware comum,
ele já considera a possibilidade de falhas frequentes nesses equipamentos e oferece estratégias de recuperação automática
para essas situações. Assim, sua implementação disponibiliza mecanismos como replicação de dados, armazenamento de
metadados e informações de processamento, que dão uma maior garantia para que a aplicação continue em execução
mesmo na ocorrência de falhas em algum recurso;

Escalabilidade: enquanto as demais aplicações similares apresentam dificuldade em aumentar a quantidade de

máquinas utilizadas no processamento e/ou aumentar o conjunto de dados, precisando em alguns casos até reescrever todo
o código-fonte da aplicação, Hadoop permite obter escalabilidade de forma relativamente simples. Mudanças no ambiente
48
implicam em pequenas modificações em um arquivo de configuração. Dessa forma, o trabalho para preparar um ambiente
contendo mil máquinas não será muito maior do que se este fosse de dez máquinas. O aumento no volume de dados só fica
limitado aos recursos, espaço em disco e capacidade de processamento, disponíveis nos equipamentos do aglomerado, sem
a necessidade de alteração da codificação;

Simplicidade: Hadoop retira do desenvolvedor a responsabilidade de gerenciar questões relativas à computação

paralela, tais como tolerância a falhas, escalonamento e balanceamento de carga, ficando estas a cargo do próprio
arcabouço. O Hadoop descreve suas operações apenas por meio das funções de mapeamento (Map) e de junção (Reduce).
Dessa forma, o foco pode ser mantido somente na abstração do problema, para que este possa ser processado no
modelo de programação MapReduce.

Desvantagens
Como o Apache Hadoop é um arcabouço recente e em constante evolução, algumas de suas funcionalidades ainda
não estão maduras o suficiente para dar suporte a todas as situações pelas quais está sendo empregado. Além disso, como
desvantagem, somam-se outras dificuldades inerentes ao modelo de programação paralelo. Ressalta-se que algumas dessas
desvantagens listadas a seguir estão, na medida do possível, constantemente sendo amenizadas a cada nova versão
disponibilizada do arcabouço.

Único nó mestre: a arquitetura do Hadoop tradicionalmente utiliza várias máquinas para o processamento e
armazenamento dos dados, porém, contém apenas um nó mestre. Esse modelo pode se tornar restritivo a medida que essa
centralidade causar empecilhos na escalabilidade e ainda criar um ponto crítico, suscetível a falha, uma vez que o nó mestre
é vital para o funcionamento da aplicação.

Dificuldade no gerenciamento do aglomerado: um dos maiores problemas sofridos pelos desenvolvedores de

computação paralela ocorre no momento de depurar a execução da aplicação e de analisar os logs que estão distribuídos.
Infelizmente, com o Hadoop, também ocorrem essas mesmas dificuldades, entretanto, existem subprojetos do ecossistema
Hadoop que procuram minimizar esse problema, como por exemplo, o arcabouço ZooKeeper. Mesmo sendo uma excelente
ferramenta para o processamento de dados em larga escala, existem situações para as quais o Hadoop não é a solução mais
adequada, devido a alguma particularidade, como as citadas a seguir:

Problemas não paralelizáveis ou com grande dependência entre os dados: esta é uma das maiores dificuldades para
toda e qualquer aplicação que requer alto desempenho. Como o princípio básico dos programas paralelos e/ou distribuídos
é dividir as tarefas em subtarefas menores, para serem processadas simultaneamente por vários recursos computacionais, a
impossibilidade ou adificuldade na extração da porção paralelizável da aplicação torna-se um grande fator de insucesso.
Assim, problemas que não podem ser divididos em problemas menores e problemas com alta dependência entre os seus
dados não são bons candidatos para o Hadoop. Como exemplo, podemos imaginar uma tarefa T sendo dividida em cinco
subtarefas t1, t2, t3, t4 e t5. Suponha cada tarefa ti+1 dependente do resultado da tarefa ti. Dessa forma, a dependência
entre as subtarefas limita ou elimina a possibilidade de sua execução em paralelo. O tempo total de execução de uma
aplicação nesse contexto será equivalente (ou maior) do que se fosse executada sequencialmente;

Processamento de arquivos pequenos: trabalho pequeno definitivamente não é tarefa para ser executada com base
em um arcabouço com foco em larga escala. Os custos adicionais (overhead) impostos pela divisão e junção das tarefas,
rotinas e estruturas gerenciais do ambiente e comunicação entre os nós de processamento, certamente irão inviabilizar sua
execução;

Problemas com muito processamento em poucos dados: problemas com regras de negócio complexas demais ou
com um fluxo de execução extenso em um conjunto de dados não muito grande, também não serão bons candidatos a se
tornar aplicações Hadoop. Como o foco do modelo de programação é oferecer simplicidade com as operações Map e
Reduce, pode ser uma tarefa árdua tentar abstrair toda a complexidade do problema apenas nessas duas funções.

Arcabouço Apache Hadoop

Hadoop é um arcabouço de código aberto, implementado em Java e utilizado para o processamento e armazenamento em
larga escala, para alta demanda de dados, utilizando máquinas comuns. Os elementos chave do Hadoop são o modelo de
programação MapReduce e o sistema de arquivos distribuído HDFS. Entretanto, em meio a sua evolução, novos subprojetos,
cada um para uma proposta específica da aplicação, foram incorporados ao seu ecossistema, tornando a infraestrutura do
arcabouço cada vez mais completa.

49
 Subprojetos do Hadoop
A grande quantidade de dados gerada por diversos segmentos trouxe a necessidade de se criar alternativas capazes de
promover um processamento mais rápido e eficaz que os fornecidos pelos bancos de dados relacionais. Essa necessidade,
aliada à carência de ferramentas específicas, fez com que grandes empresas experimentassem o arcabouço.
Por se tratar de um projeto de código aberto, a Apache recebeu fortes estímulos dessas empresas, que inclusive tornaram-se
contribuintes no seu desenvolvimento. Ao passo que novas necessidades vinham à tona, novas ferramentas foram criadas
para serem executadas sobre o Hadoop. Conforme essas ferramentas se consolidavam, passavam a integrar ou virar projetos
da Apache. Foram essas muitas contribuições que fizeram com que o Hadoop tivesse uma rápida evolução, tornando-se a
cada nova ferramenta incorporada, um arcabouço cada vez mais completo.

Conforme apresentado na Figura 3.2, pode-se perceber a ampla gama de subprojetos vinculados atualmente ao Hadoop e
cada um com uma finalidade específica. Na camada de armazenamento de dados, temos os sistemas de arquivos
distribuídos:
Hadoop Distributed File System (HDFS), um dos subprojetos principais do arcabouço; e o HBase, outro sistema de arquivos,
que foi desenvolvido posteriormente ao HDFS. Já na camada de processamento de dados temos disponível o modelo de
programação MapReduce, que também figura como um dos principais subprojetos do Hadoop. Na camada de acesso aos
dados são disponibilizadas três diferentes ferramentas: Pig, Hive e Avro. Estas ferramentas tendem a facilitar o acesso à
análise e consulta dos dados, inclusive com linguagem de consulta semelhante às utilizadas em banco de dados relacionais.
Por se tratar de uma aplicação paralela, dificuldades são encontradas no manuseio das aplicações, porém, nesta camada de
gerenciamento, existe duas ferramentas diferentes: ZooKeeper e Chukwa.
Uma aplicação Hadoop exige no mínimo a utilização das ferramentas da camada de armazenamento e processamento, as
demais podem ser adicionadas conforme haja necessidade. Além disso, para acessar esses recursos, a camada de conexão
tambémprecisa ser implementada. É por meio dessa camada que aplicações que necessitam de processamento de alto
desempenho, como Data Warehouse, Business Intelligence e outras aplicações analíticas, poderão desfrutar dos benefícios
do Hadoop.

50
Principais subprojetos
• Hadoop Common: contém um conjunto de utilitários e a estrutura base que dá suporte aos demais subprojetos do
Hadoop. Utilizado em toda a aplicação, possui diversas bibliotecas como, por exemplo, as utilizadas para seriação de
dados e manipulação de arquivos. É neste subprojeto também que são disponibilizadas as interfaces para outros
sistemas de arquivos, tais como Amazon S3 e Cloudsource.
• Hadoop MapReduce: um modelo de programação e um arcabouço especializado no processamento de conjuntos de
dados distribuídos em um aglomerado computacional. Abstrai toda a computação paralela em apenas duas funções:
Map e Reduce.
• Hadoop Distributed File System (HDFS): um sistema de arquivos distribuído nativo do Hadoop. Permite o
armazenamento e transmissão de grandes conjuntos de dados em máquinas de baixo custo. Possui mecanismos que
o caracteriza como um sistema altamente tolerante a falhas.

Outros subprojetos
• Avro4: sistema de seriação de dados baseado em schemas. Sua composição é dada por um repositório de dados
persistentes, um formato compacto de dados binários e suporte a chamadas remotas de procedimentos (RPC).
• Chukwa5: sistema especialista em coleta e análise de logs em sistemas de larga escala. Utiliza HDFS para armazenar
os arquivos e o MapReduce para geração de relatórios. Possui como vantagem um kit auxiliar de ferramentas, muito
poderoso e flexível, que promete melhorar a visualização, monitoramento e análise dos dados coletados.
• Hbase6: banco de dados criado pela empresa Power Set em 2007, tendo posteriormente se tornando um projeto da
Apache Software Foundation. Considerado uma versão de código aberto do banco de dados BigTable, criada pela
Google, é um banco de dados distribuído e escalável que dá suporte ao armazenamento estruturado e otimizado
para grandes tabelas.
• Hive7: arcabouço desenvolvido pela equipe de funcionários do Facebook, tendo se tornado um projeto de código
aberto em agosto de 2008. Sua principalfuncionalidade é fornecer uma infraestrutura que permita utilizar Hive QL,
uma
linguagem de consulta similar a SQL bem como demais conceitos de dados relacionais tais como tabelas, colunas e
linhas, para facilitar as análises complexas feitas nos dados não relacionais de uma aplicação Hadoop.
• Pig8: uma linguagem de alto nível orientada a fluxo de dados e um arcabouço de execução para computação
paralela. Sua utilização não altera a configuração do aglomerado Hadoop, pois é utilizado no modo client-side,
fornecendo uma
linguagem chamada Pig Latin e um compilador capaz de transformar os programas do tipo Pig em sequências do
modelo de programação MapReduce.
• ZooKeeper9: arcabouço criado pelo Yahoo! em 2007 com o objetivo de fornecer um serviço de coordenação para
aplicações distribuídas de alto desempenho, que provê meios para facilitar as seguintes tarefas: configuração de
nós, sincronização de processos distribuídos e grupos de serviços.

Componentes do Hadoop
Uma execução típica de uma aplicação Hadoop em um aglomerado utiliza cinco processos diferentes: NameNode, DataNode,
SecondaryNameNode, JobTracker e TaskTracker. Os três primeiros são integrantes do modelo de programação MapReduce,
e os dois últimos do sistema de arquivo HDFS. Os componentes NameNode, JobTracker e SecondaryNameNode são únicos
para toda a aplicação, enquanto que o DataNode e JobTracker são instanciados para cada máquina.
● NameNode: tem como responsabilidade gerenciar os arquivos armazenados no HDFS. Suas funções incluem mapear a
localização, realizar a divisão dos arquivos em blocos, encaminhar os blocos aos nós escravos, obter os metadados dos
arquivos e controlar a localização de suas réplicas. Como o NameNode é constantemente acessado, por questões de
esempenho, ele mantém todas as suas informações em memória. Ele integra o sistema HDFS e fica localizado no nó mestre
da aplicação, juntamente com o JobTracker.
● DataNode: enquanto o NameNode gerencia os blocos de arquivos, são os DataNodes que efetivamente realizam o
armazenamento dos dados. Como o HDFS é um sistema de arquivos distribuído, é comum a existência de diversas
instâncias do DataNode em uma aplicação Hadoop, para que eles possam distribuir os blocos de arquivos em diversas
máquinas. Um DataNode poderá armazenar múltiplos blocos, inclusive de diferentes arquivos. Além dearmazenar, eles
precisam se reportar constantemente ao NameNode, informando quais blocos estão guardando bem como todas as
alterações realizadas localmente nesses blocos.
● JobTracker: assim como o NameNode, o JobTracker também possui uma função de gerenciamento, porém, nesse caso, o

51
controle é realizado sobre o plano de execução das tarefas a serem processadas pelo MapReduce. Sua função então é
designar diferentes nós para processar as tarefas de uma aplicação e monitorá-las enquanto estiverem em execução. Um dos
objetivos do monitoramento é, em caso de falha, identificar e reiniciar uma tarefa no mesmo nó ou, em caso de
necessidade, em um nó diferente.
● TaskTracker: processo responsável pela execução de tarefas MapReduce. Assim como os DataNodes, uma aplicação
Hadoop é composta por diversas instâncias de TaskTrackers, cada uma em um nó escravo. Um TaskTracker executa uma
tarefa Map ou uma tarefa Reduce designada a ele. Como os TaskTrackers rodam sobre máquinas virtuais, é possível criar
várias máquinas virtuais em uma mesma máquina física, de forma a explorar melhor os recursos computacionais.
● SecondaryNameNode: utilizado para auxiliar o NameNode a manter seu serviço, e ser uma alternativa de recuperação no
caso de uma falha do NameNode. Sua única função é realizar pontos de checagem (checkpointing) do NameNode em
intervalos pré-definidos, de modo a garantir a sua recuperação e atenuar o seu tempo de reinicialização.

Na Figura 3.3 pode-se observar de forma mais clara como os processos da arquitetura do Hadoop estão interligados.
Inicialmente nota-se uma separação dos processos entre os nós mestre e escravos. O primeiro contém o NameNode, o
JobTracker e possivelmente o SecondaryNameNode. Já o segundo, comporta em cada uma de suas instâncias um
TaskTracker e um DataNode, vinculados respectivamente ao JobTracker e ao NameNode do nó mestre.
Um cliente de uma aplicação se conecta ao nó mestre e solicita a sua execução.
Nesse momento, o JobTracker cria um plano de execução e determina quais, quando e quantas vezes os nós escravos
processarão os dados da aplicação. Enquanto isso, o NameNode, baseado em parâmetros já definidos, fica encarregado de
armazenar e gerenciar as informações dos arquivos que estão sendo processados. Do lado escravo, o TaskTracker executa as
tarefas a ele atribuídas, que ora podem ser Map ora Reduce, e o DataNode armazena um ou mais blocos de arquivos.
Durante a execução, o nó escravo também precisa se comunicar com o nó mestre, enviando informações de sua situação
local. Paralelamente a toda essa execução, o SecondaryNameNode registra pontos de checagem dos arquivos de log do
NameNode, para a necessidade de uma possível substituição no caso do NameNode falhar.

Apache Spark
De forma geral, o Spark é uma engine rápida, escrita em Scala, para processamento de grandes volumes de dados em um
cluster de computadores. Scala é uma liguaguem funcional que roda na JVM. Surgiu como um projeto da AMPLab de
Berkeley em 2009, tendo como principal criador Matei Zaharia em sua tese de doutorado. Em 2010, foi lançada a primeira
versão, a alpha-0.1. Em junho de 2015 está sendo lançada a versão 1.4, com muito mais propriedades interessantes. Apesar
de ter surgido em Berkeley, mais tarde, os criadores de Spark fundaram uma empresa, DataBricks para suportar e fornecer
consultoria ao Spark.

No início de 2014, o Spark se tornou um projeto top level Apache. Atualmente é um dos projetos mais ativos da comunidade
open source com mais de 400 desenvolvedores de 50 empresas diferentes, apresentando committers de mais de 16
organizações, incluindo grandes empresas como Yahoo, Intel, DataBricks, Cloudera, HortonWorks, etc.

52
Atualmente já é possível perceber diversas empresas, grandes ou pequenas, utilizando Spark nos seus ambientes internos ou
na própria nuvem, visto que é simples subir o Spark na cloud da Amazon, o que faz com que o Spark seja uma grande
tendência para os próximos anos, assim como a necessidade de profissionais qualificados em Spark.

Definindo um pouco a notação utilizada neste trabalho, um nó é um computador do cluster e se divide em master,
responsável por gerenciar todo o cluster, e workers, responsáveis por executar os processos. O Spark driver é o programa
principal que cria um spark context e comunica-se com o cluster manager para distribuir tarefas aos executores.
O Spark, assim como o Hadoop, também foi pensado para ser escalável. Ou seja, assim quando seu problema for muito
grande, basta aumentar o número de computadores disponíveis para conseguir processar e reduzir o tempo. É esperada uma
redução quase linear do tempo com mais computadores. No entanto, conforme discutiremos adiante, o Spark ainda não
escala tão bem com muitos computadores, mais de quinhentos mil computadores.

Umas das grandes vantagens do Spark em relação ao Hadoop são as High Level API’s de programação. Enquanto que o
Hadoop é nativamente apenas Java, no Spark temos a disposição API’s em Scala, Java e Python, sendo este último o mais
utilizado atualmente. Uma novaAPI com suporte para R e Dataframes será disponibilizada no Spark 1.4, lançado nas róximas
semanas. Por ser uma API de alto nível, os programadores podem focar na lógica do problema, fazendo com que o
desenvolvimento seja mais fácil e rápido. Vale ressaltar que estas API’s não estão disponíveis para todos os módulos do
Spark. Por exemplo, a programação no Spark Streaming só está disponível em Scala atualmente.

Outra vantagem do Spark em relação ao Hadoop é a baixa latência, considerada near real time. Isto se deve ao Hadoop
persistir dados intermediários em disco, ao contrário do Spark, como veremos adiante, que tem diversos tipos de
persistência. Outra propriedade interessante no Spark é a possibilidade de construção de uma arquitetura Lambda
usando apenas Spark. O Spark pode acessar dados de diferentes fontes, como por exemplo, do HDFS, o armazenamento
distribuído presente no Hadoop. Além disso, ele pode acessar dados de banco de dados NOSQL como Cassandra ou
Hbase, ou até dados utilizados no Hive. Há muitas outras opções e sempre são feitas novas conexões do Spark com outros
bancos de dados. Além de poder fazer com que o Spark utilize dados armazenados em diferentes lugares, podemos rodar o
Spark de diferentes maneiras. A primeira possibilidade, que é muito utilizada para testes, é executar o
Spark local sem processamento distribuído. Há também a possibilidade de rodar o Spark local com múltiplos processadores
(threads). O modo mais comum, entretanto, é utilizar o Spark em um cluster de computadores, podendo ser controlado por
diferentes gerenciadores. Se não houver nenhum gerenciador no seu cluster, é possível utilizar o gerenciador do próprio
Spark, Spark Standalone. Também, jobs de Spark podem ser gerenciados pelo Hadoop Yarn, Apache Mesos ou pelo
gerenciador da Amazon (EC2). Mesos também é um projeto Top Level Apache de Berkeley e que tem como um dos seus
criadores, Matei Zaharia, o mesmo criador do Spark, fazendo com que fosse muito utilizado no começo do desenvolvimento
de Spark.

O Spark pode ser utilizado interativamente por meio da Spark Shell, disponível em Python ou Scala. A programação em Spark
é muito baseada em programação funcional, sempre passando funções como parâmetros.
Um dos problemas do Hadoop que apontamos anteriormente é que o modelo de programação Map Reduce não era a
solução para tudo, o que fez com diversos sistemas especializados surgissem. O Spark tenta solucionar isso sendo uma
ferramenta mais genérica que substitui muito destes sitemas criados em cima do Hadoop. Por exemplo, o Hive foi criado
para a execução de queries em dados estruturados sem a necessidade de escrevermos função Map Reduce em Java. Para
isso, um dos módulos em Spark é o SparkSQL. Para algoritmos de machine learning, surgiu no Hadoop uma biblioteca de
código em Java, denominada Mahout, já no Spark há o módulo do MLLib com o mesmo objetivo. Da mesma forma
o Spark streaming tem como objetivo processamento de dados em tempo real, assim como o A pache Storm. Já o módulo
GraphX do Spark surgiu como alternativa ao Apache Giraph.
A Figura 1 abaixo nos mostra os módulos construídos no Spark. Falaremos nas subseções adiante um pouco de cada um
destes módulo.

53
 A programação em Spark se baseia no conceito de RDD’s. RDD’s são a unidade fundamental de dados no Spark e tem
como principal característica a propriedade de ser imutável. Após ser criada, não podemos alterá-la, apenas criar um nova
RDD baseada nesta RDD. RDD significa resilient distribute dataset. A propriedade de resiliência vem da tolerância a falhas, se
os dados na memória forem perdidos, podem ser recriados. Explicaremos mais para frente como o Spark trata a questão da
resiliência. O distributed, como o próprio nome já diz, significa que os dados são armazenados na memória de todo o cluster.
Por fim o dataset indica que os dados iniciais podem vir de um arquivo ou ser criado programaticamente. Logo, RDD’s são
criadas por meio de arquivos, de dados na memória ou de outras RDD’s. A maioria das aplicações em Spark consistem em
manipular RDD’s.

RDD’s podem armazenar qualquer tipo de elemento, como tipos primitivos (inteiros, caracteres, booleanos, etc),
sequências (strings, listas, arrays, tuples, etc), assim como tipos mistos e objetos Scala ou Java. Alguns tipos de RDD ainda
possuem outras características, como o Pair RDD’s, que armazenam na forma de chave valor e os Double RDD’s, que
armazenam dados numéricos. As RDD’s são particionadas e divididas em todo o cluster. O Spark constrói estas partições de
forma automática, no entanto, o usuário também pode escolher o número de partições desejado.

As operações em RDD são divididas em dois tipos, de transformação e de ação. Há diversas funções de
transformação e de ação. As operações de transformação retornam um novo RDD, enquanto que operações de ação
retornam um resultado para o driver ou escreve na camada de armazenamento. Abaixo apresentamos alguns exemplos
destas funções.

A lista mais extensa pode ser consultada na documentação do Spark.

Abaixo, segue alguns exemplos de operações de transformação:

• map (func) - retorna um novo RDD aplicando a função func emcada elemento.
• filter (func) - retorn um novo RDD aplicando o filtro func.
• flatMap (func) - similar ao map, mas retornando mais itens ao invés de apenas um.
• sample(withReplacement, fração, semente) - amostra aleatoriamente uma fração dos dados com ou sem
reposição usando a semente paragerar os números aleatórios.
• union(rdd) - retorna um novo RDD que contém a união dos elementos do RDD original e do RDD passado
como argumento.
• distinct() - retorna um novo dataset contendo os valores distintos do RDD original.
• groupByKey() - aplicado em pair RDD’s da forma (K, V), retornando um novo pair RDD da forma (K,
iterable<V>).
• reduceByKey(func) - aplicado também em um pair RDD (K, V), agregando os valores de V pela função func
para cada chave K.
• pipe(command) - aplica para cada partição do RDD um comando shell. Qualquer linguagem com stdin, stdout
pode ser utilizada.
Algumas operações de ação são:
• collect() - retorna todos os elementos do RDD como um array para o driver. Usado principalmente após uma
operação de filtro para retornar poucos dados.
• count() - retorno o número de elementos no RDD.
• first() - retorna o primeiro elemento do dataset.
• take(n) - retorna os primeiros n elementos do dataset.
• saveAsTextFile(file) - salva o RDD em um arquivo de texto.

Uma propriedade interessante das RDD’s é a lazy evaluation, que significa que nada é processado até uma operação de ação.
Por exemplo, imagine que executamos o código abaixo:

54
Exemplo de programa em Spark usando API em Python – IMAGEM.

A primeira linha lê um arquivo texto e cria o RDD data. No entanto, este RDD não é criado até utilizarmos uma operação de
ação. A segunda linha aplica uma função em cada elemento do RDD data, criando o RDD data up transformando todas as
letras em maiúsculas. Mais uma vez, na verdade, o Spark não cria nada, apenas salva como criar. A terceira linha pedimos
para criar o RDD data filtr filtrando data up para linhas que comecem com E. Novamente nada é criado. Na quarta linha
aplicamos uma ação, pedindo para ele retornar o número de linhas do RDD data filtr. Apenas nesta etapa, o Spark que
guardou toda a linhagem dos dados, irá criar todos os RDD’s e executar a contagem final.

A linhagem dos dados (data lineage) também é algo importante dentro do Spark, visto que é exatamente o que ele utiliza
para ser tolerante à falha. Assim, se um processo falha, o Spark utiliza esta linhagem para reconstruir tudo que falhou e
processar novamente.

Uma das propriedades mais interessantes do Spark é a persistência de dados, podendo deixar algumas RDD’s na memória
RAM, para reuso, diminuindo consideravelmente o tempo de execução de processos iterativos, visto que não precisarão, a
cada etapa, escrever os resultados no disco para depois ler novamente. O Spark apresenta diversos níveis de persis-
tência. A Figura abaixo, retirada de Zaharia et al. (2015), apresenta todas as possibilidades de persistência.

Níveis de persistência no Spark – IMAGEM.

A opção default é a opção memory only, que armazena o RDD como um objeto Java deserializado na JVM. Se o RRD não cabe
na memória, algumas partições não serão armazenadas e serão recalculadas quando necessário. A opção memory and disk é
similar, mas quando o RDD não cabe na memória, algumas partições são armazenadas em disco. Outra opção é memory only
ser que armazena o RDD como um objeto serializado (um byte por partição). Já a opção memory only disk ser é similar, mas
faz o spill para disco se não couber tudo na memória invés de reconstruir no momento da execução como no passo anterior.
Por fim, a opção disk only armazena as partições do RDD apenas usando disco. O número 2 ao lado das opções apenas indica

55
que cada partição é replicada em dois nós do cluster.
Para entender como funciona o processo de cache, fizemos uma pequena alteração no código utilizado anteriormente,
descrito na Figura
abaixo.

Exemplo de persistência de programa em Spark usando API em Python – IMAGEM.

Este código tem como objetivo realizar o mesmo procedimento. No entanto, agora, deixamos na memória o RDD data up,
por meio do comando data up.cache. Ao executarmos a primeira operação de ação, o count, o processo de lazy evaluation
constrói todos os RDD’s, deixando em memória o data up. Quando executamos o segundo count, ele não precisará recalcular
todos os RDD’s, visto que o data up já estará pronto, logo iniciará a construção a partir deste RDD. Se por acaso, algum pro-
cesso de alguma partição falhar, o Spark, que armazenou toda a lineage, irá reconstruir as partes faltantes e executará
novamente.
O Spark pode apresentar problemas quando a linhagem dos dados começar a ficar muito grande, visto que se for preciso
reconstruir os RDD caso ocorra alguma falha, demorará bastante tempo. Uma maneira de tentar evitar este problema é a
opção de checkpoint, que salva os dados direto no HDFS, eliminando toda a linhagem armazenada e tendo ainda
tolerância a falhas.
Na notação de Spark, um job é dividido em várias tarefas (tasks). Uma tarefa corresponde a uma sequência de operações em
uma mesma partição nos dados. Um conjunto de tarefas compreende um stage. Um job também corresponde a vários
stages. Adiante, exemplificaremos estes detalhes de notação.
Assim como no Hadoop, os dados são armazenados em diferentes nós.
Quando possível, as tarefas (tasks) são executadas nos nós onde os dados estão na memória.
Com o código abaixo, iremos exemplificar estes conceitos definidos aqui. O objetivo deste código é calcular o tamanho médio
das linhas que cada palavra aparece em um arquivo texto. A primeira coisa que ele fez foi ler os dados do HDFS. Depois,
aplicamos uma função flatMap para quebrar a linha em palavras, após este passo aplicamos a função Map que
retorna cada palavra e o tamanho da linha em que ela aparece. Depois agrupamos todos os elementos de chave e valor pela
mesma chave por meio da função groupByKey. Por fim, devolvemos para cada palavra o tamanho médio de todas as linhas
em que a palavra aparece, utilizando a função Map novamente.

Para exemplificar o que discutimos aqui e o que discutiremos adiante, suponha que executamos este código e que a tabela
mydata esteja particionada em três nodes diferentes. Assim, o Spark executará este código do seguinte modo:

56
Construção dos Stages e Tasks para execução do código acima – IMAGEM.
O primeiro retângulo da esquerda representa o momento em que lemos os dados do HDFS e armazenamos os três pedaços
em três nós diferentes.

O segundo representa a execução da função flatMap enquanto que o terceiro representa a execução da função Map. Repare
que estas três etapas são feitas de modo independente entre cada pedaço. Depois há uma etapa de shuffle que ordena por
chave e distribui as mesmas chaves para as etapas finais. Já na quarta etapa, o groupByKey consolida os resultados de cada
chave, no caso cada palavra. Por fim, é calculada a média por meio da função Map

Para cada partição, as execuções das três etapas representa uma task. Logo, temos três tasks nestas três primeiras etapas,
definindo o primeiro stage. Repare que se um processo dentro da task falhar, toda a task será recalculada. Depois, entre a
etapa 4 e 5, temos que os dois nós podem atuar de forma independente, criando mais duas tasks e o segundo stage.
Para cada uma destas etapas, o Spark constrói um grafo acíclico direcionado (DAG) das dependências entre a RDD, para
assim ter todo o mapa de execução caso ocorra alguma falha, bem como para paralelizar as execuções entre as diferentes
partições. Há dois tipos de relações entre as RDD’s, operações Narrow e operações Wide. Nas operações Narrow, apenas um
filho depende da RDD, não é necessário o processo de Shuffle e pode ser colapsada em um estágio único. Já nas operações
Wide, múltiplos filhos dependem da mesma RDD e há sempre a definição de um novo stage.
Com a construção do DAG, o Spark paraleliza as execuções, inicialmente com todas as tasks do primeiro stage. Quando elas
terminam, fazem o shuffle e executam todas as tasks do segundo stage. Em caso de falhas, ele executa novamente as tasks
necessárias.

A Spark shell possibilita a exploração interativa dos dados. Além disso, o Spark também disponibiliza as aplicações em Spark,
que rodam como se fossem programas independentes. Estas aplicações em Java ou Scala devem ser compiladas em arquivo
JAR e passadas para todos os computadores onde irão ser executadas. Com esta opção, é possível a programação de diversas
funções que serão executadas várias vezes por usuários diferentes com diferentes dados. Com todas estas propriedades,
diversos benchmarks surgiram comparando os tempos de execução do Spark com os tempos de execução do Hadoop.
Quando os dados cabem na memória, os números apontam que o Spark consegue resultados cerca de cem vezes mais
rápidos. Já quando o Spark precisa fazer uso do disco também, os números indicam um melhor em torno de dez vezes. A
figura abaixo, retirada do próprio site do projeto, compara o tempo de execução de uma regressão logística
no Spark e no Hadoop.

Regressão Logística em Spark e Hadoop - IMAGEM.

Outro benchmark conhecido é o problema de ordenar um conjunto de 100 terabytes. O Hadoop em 2013 ordenou 103

57
terabytes com 2100 nós em 72 minutos, já o Spark em 2014 ordenou 100 terabytes com 206 nós em 23 minutos.
Apesar do Spark apresentar propriedades bastante interessantes e ser o assunto do momento no mundo da computação
distribuída, nem tudo são flores, apresentando alguns problemas. O que talvez mais esteja impactando as empresas
atualmente é a sua imaturidade em razão de ser um projeto bastante novo, com vários bugs sendo descobertos recente-
mente. Outro fator conhecido é que ainda não é tão escalável quanto o Hadoop. Outro ponto é que por poder apresentar um
job com tasks formada por vários processos, sob uma falha, pode demorar um tempo maior para esta falha ser refeita. Como
era de esperar, outro ponto é que vários jobs de Spark consomem muita memória RAM, o que requer um gerenciador
melhor do cluster. Por fim, outro ponto de desvantagem ao ser comparado com o Hadoop, é que sua configuração é mais
difícil, bem como a otimização de todos os parâmetros de configuração para melhorar o desempenho do seu cluster para
algum caso específico

O que é Apache Kafka?

Visão geral
O Apache Kafka é uma plataforma distribuída de transmissão de dados que é capaz de publicar, subscrever, armazenar e
processar fluxos de registro em tempo real. Essa plataforma foi desenvolvida para processar fluxos de dados provenientes de
diversas fontes e entregá-los a vários clientes. Em resumo, o Apache Kafka movimenta volumes imensos de dados não
apenas do ponto A ao ponto B, mas também de A a Z e para qualquer outro local que você precisar simultaneamente.

O Apache Kafka é uma alternativa aos sistemas de mensageria empresariais tradicionais. Inicialmente, ele era um sistema
interno desenvolvido pela LinkedIn para processar 1,4 trilhão de mensagens por dia. Mas agora é uma solução de
transmissão de dados open source aplicável a variadas necessidades 6empresariais.

Integração assíncrona com o Apache Kafka

Os microsserviços mudaram o panorama do desenvolvimento. Eles tornaram os desenvolvedores mais ágeis ao reduzir as
dependências, como as camadas de banco de dados compartilhado. No entanto, as aplicações distribuídas que estão sendo
criadas pelos desenvolvedores ainda precisam de algum tipo de integração para compartilhar dados. Uma opção de
integração muito usada, conhecida como método síncrono, utiliza interfaces de programação de aplicações (APIs) para
compartilhar dados entre usuários diferentes.

Uma segunda opção de integração, o método assíncrono, envolve a replicação de dados em um armazenamento
intermediário. É aí que o Apache Kafka entra em cena, na transmissão de dados de outras equipes de desenvolvimento para
preencher o armazenamento de dados. Assim, é possível compartilhar os dados entre várias equipes e respectivas
aplicações.

As equipes de microsserviços têm requisitos de integração diferentes de outras equipes de desenvolvimento em cascata
tradicionais. Elas requerem três recursos fundamentais:

2. Integrações distribuídas: integrações leves e baseadas em padrões que podem ser implantadas continuamente quando
necessário e não estão limitadas por implantações do tipo ESB centralizado.
3. APIs: serviços baseados em API para incentivar um ecossistema de parceiros, clientes e desenvolvedores que podem
oferecer serviços confiáveis e lucrativos.
4. Containers: plataforma para desenvolver, gerenciar e escalar aplicações nativas em nuvem e conectadas. Os containers
possibilitam o desenvolvimento de artefatos lean que podem ser implantados individualmente, fazem parte de processos
de DevOps e são compatíveis com soluções prontas de clusterização, assegurando uma alta disponibilidade.

A Red Hat chama essa abordagem de "integração ágil", o que permite que as integrações façam parte de processos de
desenvolvimento de aplicações, fornecendo soluções mais ágeis e adaptáveis. Um elemento da integração ágil é a liberdade
de usar a integração síncrona ou assíncrona, dependendo das necessidades específicas da aplicação. O Apache Kafka é uma
excelente opção na integração assíncrona orientada por eventos para aumentar o uso de integração síncrona e APIs, o que
oferece ainda mais compatibilidade com microsserviços e possibilita a integração ágil. Dessa forma, o Apache Kafka pode ser
uma parte importante da sua iniciativa para simplificar os processos de desenvolvimento, incentivar a inovação, poupar
tempo e, em última análise, acelerar o time to market de novas funcionalidades, aplicações e serviços.

Quando usar o Apache Kafka

O Apache Kafka é incorporado a pipelines de transmissão que compartilham dados entre sistemas e/ou aplicações, bem
como a sistemas e aplicações que consomem esses dados. O Apache Kafka é compatível com vários casos de uso, em que alta
produtividade e escalabilidade são fatores vitais. Como o Apache Kafka minimiza a necessidade de usar integrações point-to-
point (P2P) para o compartilhamento de dados em determinadas aplicações, ele é capaz de reduzir a latência a milésimos de
58
segundos. Isso significa que os dados são disponibilizados mais rapidamente aos usuários, o que é uma vantagem para os
casos de uso que exigem disponibilidade de dados em tempo real, como operações de TI e comércio eletrônico.

O Apache Kafka é capaz de lidar com milhões de pontos de dados por segundo, o que faz dessa solução a ideal para desafios
que envolvem big data. No entanto, o Kafka também é útil para empresas que no momento não operam em cenários com
uso tão extremo de dados. Em muitos casos de uso de processamento de dados, como Internet das Coisas (IoT) e mídias
sociais, os dados aumentam exponencialmente e, em pouco tempo, podem sobrecarregar uma aplicação que a empresa
esteja criando com base no volume de dados atual. Em termos de processamento de dados, é necessário levar em
consideração a escalabilidade. Isso significa planejar para a proliferação intensificada dos dados da empresa.

Operações de TI
As equipes operações de TI dependem sobretudo de dados. E elas precisam ter acesso rápido a eles. Essa é a única maneira
de manter sites, aplicações e sistemas ativos e em funcionamento permanentemente. O Apache Kafka é uma excelente
solução para as funções de operações de TI porque elas dependem da coleta de dados de variadas fontes, como os sistemas
de monitoramento, alerta e geração de relatórios, as plataformas de gerenciamento de registros e as atividades de
monitoramento de sites.

IoT - Internet das Coisas

De acordo com as previsões do Gartner, a IoT incluirá mais de 20 bilhões de dispositivos até 2020. O valor da IoT está nos
dados acionáveis gerados pela grande variedade de sensores. O Apache Kafka foi desenvolvido para oferecer escalabilidade
capaz de processar os imensos volumes de dados provenientes da IoT.

E-commerce
O comércio eletrônico é uma oportunidade em crescimento para uso do Apache Kafka, pois ele pode processar dados do tipo
cliques de página, curtidas, pesquisas, pedidos, carrinhos de compra e inventários.

Como o Kubernetes escala as aplicações do Apache Kafka

O Kubernetes é a plataforma ideal para o Apache Kafka. Os desenvolvedores precisam de uma plataforma escalável para
hospedar as aplicações do Kafka, e o Kubernetes é a resposta.

Assim como o Apache Kafka, o Kubernetes torna o processo de desenvolvimento mais ágil. O Kubernetes, a tecnologia por
trás dos serviços de nuvem do Google, é um sistema open source para gerenciamento de aplicações em containers. Ele
elimina muitos dos processos manuais associados aos containers. Usar o Apache Kafka no Kubernetes otimiza a implantação,
a configuração, o gerenciamento e o uso do Apache Kafka.

Ao combinar o Kafka com o Kubernetes, você terá todos os benefícios e vantagens das duas soluções: escalabilidade, alta
disponibilidade, portabilidade e implantação fácil.

A escalabilidade do Kubernetes é um complemento natural ao Kafka. No Kubernetes, é possível ajustar a escala de recursos
com um comando simples ou automaticamente com base no uso e conforme o necessário para utilizar da melhor forma a
infraestrutura de computação, sistema de rede e armazenamento. Essa capacidade permite ao Apache Kafka compartilhar
um pool de recursos com outras aplicações. O Kubernetes também confere ao Apache Kafka portabilidade entre provedores
de infraestrutura e sistemas operacionais. Com o Kubernetes, os clusters do Apache Kafka podem ser distribuídos em
ambientes locais e em nuvens públicas, privadas ou públicas, além de utilizar sistemas operacionais diferentes.

SEMANA 5, AULA 1.

O QUE É O APACHE SPARK?

• É uma alternativa ao Map Reduce para algumas aplicações
• Um sistema de computação em cluster com baixa latência
• Usado para grandes conjuntos de dados
• Usado em conjunto com o Hadoop FS
• O MapReduce permite a análise de big data usando clusters grandes e não confiáveis

O MapReduce carece de primitivas eficientes para compartilhamento de dados, é neste contexto que o Spark entra em cena:

• Ao invés de carregar os dados do disco para cada consulta, faz o compartilhamento de dados na memória, já que o
acesso à memória é mais rápido se comparado ao acesso ao disco.
• Há APIs para linguagens como: Java, Scala e Python

59
 • Cache de dados na memória (para algoritmos iterativos, gráficos e de aprendizado de máquina, etc.)
• O Apache Spark suporta análise de dados, aprendizado de máquina, gráficos, dados de streaming, etc. Ele pode
ler/gravar de uma variedade de tipos de dados e permite o desenvolvimento em várias linguagens.

COMO O SPARK FUNCIONA?

O Spark aborda o problema do acesso compartilhado aos dados com:

• Conjuntos de dados distribuídos resilientes (RDDs)

• O RDD permite que as aplicações mantenham conjuntos de trabalho na memória para reutilização
• RDD se destaca como um modelo de programação
o Tolerante a falhas
o Computação distribuída
o Compartilhamento em memória
• Spark é uma implementação do RDD
• Com o RDD
o Somente leitura, coleções particionadas de objetos
o Um array imutável distribuído
o Criado por meio de transformações paralelas em dados e armazenamento estável
o Pode ser armazenado em cache para reutilização eficiente

ECOSSISTEMA DO SPARK – IMAGEM.

ECOSSISTEMA DO SPARK
• Spark Core: é o motor de execução da plataforma Spark. Ele fornece recursos de computação distribuídos na
memória.
• Spark SQL: é um mecanismo para o Hadoop Hive que permite que consultas não modificadas do Hadoop
Hive sejam executadas até 100 vezes mais rápido em implantações e dados existentes.
• Spark Streaming: é um mecanismo que permite aplicativos interativos e analíticos poderosos no streaming
• de dados.
• MLLib: é uma biblioteca de aprendizado de máquina escalável
• GraphX: é um mecanismo de computação gráfica construído em cima do Spark

BENEFÍCIOS DO SPARK
• Generaliza o MapReduce
• Modelo de programação mais rico
• Menos sistemas para dominar
• Melhor gerenciamento de memória
• Menor movimentação de dados que leva a um melhor desempenho para análises complexas

60
Pergunta. Um desenvolvedor interessado em processar grandes volumes de dados deve fazer uso de um conjunto de
bibliotecas para processamento paralelo de dados em clusters. Uma ferramenta que representa esse conjunto de bibliotecas
para processar dados em memória e que também permite conectar várias fontes de dados, incluindo os storages das
principais nuvens computacionais é conhecido como:

• spark core.
• spark sql.
• spark machine learning.
• spark streaming.
• spark graph.

Resposta certa. Uma ferramenta que representa esse conjunto de bibliotecas para processar dados em memória e que
também permite conectar várias fontes de dados, incluindo os storages das principais nuvens computacionais é conhecido
como spark core. O Spark Core é o motor de execução da plataforma Spark. Ele fornece recursos de computação distribuídos
na memória.

SEMANA 5, AULA 2.

O QUE É APACHE HADOOP?

• É uma implementação de código aberto de estruturas para armazenamento de dados e computação confiável,
escalável e distribuído.
• É uma arquitetura flexível e altamente disponível para computação em larga escala e processamento de dados em
uma rede de hardware comum

Projetado para responder à pergunta: “Como processar big data com custo e tempo razoáveis?”
Objetivos/Requisitos do Hadoop
• Abstrair e facilitar o armazenamento e o processamento de conjuntos de dados grandes e/ou em rápido crescimento
• Dados estruturados e não estruturados
• Modelos de programação simples
• Alta escalabilidade e disponibilidade
• Usa hardware comum (barato!) com pouca redundância
• Tolerância ao erro
• Mover computação em vez de dados

ARQUITETURA APACHE HADOOP – IMAGEM.

61
ARQUITETURA APACHE HADOOP
Distribuída com alguma centralização

• A maior parte do poder computacional e de armazenamento do sistema está nos nós principais do cluster
• s nós principais executam o TaskTracker para aceitar e responder às tarefas do MapReduce e também o DataNode
para armazenar os blocos necessários o mais próximo possível
• O nó de controle central executa o NameNode para acompanhar os diretórios e arquivos do HDFS e o JobTracker
para despachar tarefas de computação para o TaskTracker
• Escrito em Java, também suporta Python e Ruby

Sistema de Arquivos Distribuídos Hadoop (HDFS)

• Adaptado às necessidades do MapReduce
• Direcionado para muitas leituras de fluxos de arquivos
• Gravações são mais caras
• Alto grau de replicação de dados (3x por padrão)
• Não há necessidade de RAID em nós normais
• Tamanho de bloco grande (64 MB)
• Reconhecimento de localização de DataNodes na rede

NameNode
• Armazena metadados para os arquivos, como a estrutura de diretórios de um FS típico
• O servidor que contém a instância NameNode é bastante crucial, pois existe apenas um Log de transações para
exclusões/inclusões de arquivos, etc. Não usa transações para blocos inteiros ou fluxos de arquivos, apenas
metadados.
• Lida com a criação de mais blocos de réplica quando necessário após uma falha do DataNode

DataNode
• Armazena os dados reais em HDFS
• Pode ser executado em qualquer sistema de arquivos subjacente (ext3/4, NTFS, etc.)
• Notifica NameNode de quais blocos ele possui
• NameNode replica blocos 2x no rack local, 1x em outro lugar

MapReduce Engine
• O JobTracker divide os dados em tarefas menores (“Mapa”) e os envia para o processo TaskTracker em cada nó
• O TaskTracker reporta de volta ao nó JobTracker e relata o progresso do trabalho, envia dados (“Reduzir”) ou solicita
novos trabalhos

62
ECOSISTEMA HADOOP

APLICAÇÕES DO HADOOP
• Publicidade (comportamento do usuário de mineração para gerar recomendações)
• Pesquisas (documentos relacionados ao grupo)
• Segurança (busca por padrões incomuns)

Soluções Comerciais

• Dell
• Amazon
• Microsoft
• Cloudera

PERGUNTA. Uma característica pertinente ao Hadoop, uma solução para computação escalável é que:

• que ele lida com tolerância a falhas e possui a confiabilidade alcançada por meio de diversas cópias de dados?
• ele faz processamento em tempo real?
• ele é uma linguagem de programação?
• ele não usa memória secundária (disco)?
• é uma biblioteca de aprendizado de máquina?

Resposta certa. Uma característica pertinente ao Hadoop, uma solução para computação escalável é que ele lida com
tolerância a falhas e possui a confiabilidade alcançada por meio de diversas cópias de dados. Um benefício do Hadoop é o
de lidar com a falha para que o processamento não seja interrompido em caso de erros. Esta tolerância a falhas independe
do programador.

Comunicação assíncrona: utilizando eventos e mensageria. Utiliza uma estrutura independente das aplicações: os
brokers de mensageria. Esse tipo de middleware oferece estruturas de comunicação e dados que permitem que diferentes
serviços conversem entre si de forma assíncrona, segura, replicada e altamente tolerante a falhas.

63
Há dois tipos de sistema de mensagens:

• Sistema ponto a ponto

• Sistema Publicar-Assinar

Sistema de mensagens ponto a ponto

As mensagens são persistidas em uma fila, mas uma mensagem específica pode ser consumida por no máximo apenas um

consumidor. Depois que um consumidor lê uma mensagem na fila, ela desaparece dessa fila.

Sistema de mensagens Publicar-Assinar

• As mensagens são persistidas em um tópico. Ao contrário do sistema ponto a ponto, os consumidores podem se
inscrever em um ou mais tópicos e consumir todas as mensagens desse tópico
• Neste sistema, os produtores de mensagens são chamados de publicadores e os consumidores de mensagens são
chamados de assinantes.

O QUE É APACHE KAFKA?

• Kafka é uma plataforma de streaming distribuído.
• Dentre as principais características estão:
• Alta escalabilidade (partição)
• Tolerante a falhas (replicação)
• Permite alto nível de paralelismo e desacoplamento entre produtores de dados e consumidores de dados
• Padrão de fato para armazenamento, acesso e processamento de fluxo de dados quase em tempo real
• Componente crítico da maior parte da plataforma de Big Data e, portanto, do ecossistema Hadoop

ARQUITETURA – IMAGENS.

64
ARQUITETURA DO KAFKA
• Um produtor é uma entidade/aplicação que publica dados em um cluster Kafka, composto por brokers
• Um broker é responsável por receber e armazenar os dados quando um produtor publica
• Um consumidor consome dados de um broker em um deslocamento especificado, ou seja, posição
• O Kafka usa o zookeeper para facilitar a verificação de integridade, o gerenciamento e a coordenação
• O zookeeper oferece aos brokers, metadados sobre os processos em execução no sistema
• Um tópico é um nome de categoria/feed, no qual os registros são armazenados e publicados. Os tópicos têm
partições e ordem garantida por partições
• Todos os registros do Kafka são organizados em tópicos. Aplicativos produtores gravam dados em tópicos e
aplicativos consumidores leem tópicos

PONTOS DE ENTRADA DO KAFKA

PONTOS DE ENTRADA

Implementação personalizada de produtor e consumidor usando a API do cliente Kafka

• Java, Scala, C++, Python

Conectores Kafka

• LogFile, HDFS, JDBC, ElasticSearch...

Logstash

• Fonte e destino

65
Outras ferramentas de ingestão ou processamento que suportam Kafka

• Apache Spark, LinkedIn Gobblin, Apache Storm.

REGISTRO DE FLUXO DO KAFKA

• Considere um broker com três tópicos, no qual cada tópico possui 8 partições
• O produtor envia um registro para a partição 1 no tópico 1 e, como a partição está vazia, o registro termina no
deslocamento 0

• O próximo registro é adicionado à partição 1 e acima no deslocamento 1, e o próximo registro no deslocamento 2 e

assim por diante
• Esse é um log de confirmação e cada registro é anexado ao log e não há como alterar os registros existentes no log
(imutável). Esse também é o mesmo deslocamento que o consumidor usa para especificar onde iniciar a leitura

USOS DO KAFKA
• Mensageria
• Métricas
• Agregação de logs
• Registros de atividades em sites e aplicações Web
• Operações de TI
• Internet das Coisas

Alguns conceitos básicos muito importantes sobre o Apache Kafka:

Brokers - componentes do cluster de mensageria, que permitem a comunicação com os serviços, armazenam, replicam e
fornecem toda garantia de integridade dos dados.

Tópicos - estruturas de dados que armazenam as mensagens produzidas e consumidas por serviços. Eles são criados de
forma a fazerem sentido para a vida real como, por exemplo, tópico para eventos de compras em um e-commerce e novos
pedidos em um aplicativo de delivery. Muitos chamam os tópicos de filas.

66
 Produtores - serviços que produzem mensagens no broker, indicando que um novo evento aconteceu. Seguindo o exemplo
usado nos tópicos, o serviço de checkout de um e-commerce pode produzir eventos com mensagens a cada nova compra
realizada numa loja on-line.

Consumidores - serviços que consomem mensagens no broker, iniciando um novo fluxo de processos de acordo com a sua
missão. Um exemplo pode ser um serviço de ordem de produção, que consome eventos produzidos pelo checkout de um e-
commerce, dando início ao processo e, ainda pode produzir um novo evento para outros serviços realizarem atividades
específicas como produção, logística, fiscal. E, já respondendo a dúvida que acabou de pipocar na sua cabeça, serviços
podem sim ser produtores e consumidores de diferentes tópicos!

Benefícios de utilizar o Apache Kafka ou uma solução semelhante

• Por natureza, o cluster de mensageria é assíncrono, distribuído e escalável, tornando-o tolerante a falhas.
• Permite uma enorme visibilidade do fluxo, devido à forma como se organizam os tópicos e às métricas que são
coletadas.
• Diferentes times podem consumir os mesmos eventos para gerar diferentes informações. Por exemplo, times de
operações podem consumir eventos de pedidos para medir throughput na plataforma e graficar possíveis gargalos,
times de big data podem consumir os mesmos eventos para gerar insights de negócios e, claro, os times de dev
consomem os eventos que foram originalmente direcionados a suas aplicações para dar andamento nos fluxos dos
processos.
• Pode-se integrar eventos gerados em outras fontes de dados, como bancos relacionais, sensores de IoT etc.

SEMANA 5 - ATIVIDADE AVALIATIVA.

PERGUNTA. Analise as afirmações a seguir sobre o Apache Kafka e o Kubernetes.
1. (Afirmação verdadeira) O Kubernetes confere ao Apache Kafka a portabilidade entre provedores de infraestrutura e
sistemas operacionais.
2. (Afirmação falsa Com o Apache Kafka, os clusters do Kubernetes podem ser distribuídos em ambientes locais e em nuvens
públicas, privadas ou públicas.
3. (Afirmação verdadeira) O Kubernetes é uma plataforma escalável para hospedar as aplicações do Kafka.
4. (Afirmação falsa) O Apache Kafka é um sistema open source para gerenciamento de aplicações em containers.

PERGUNTA. (lacuna para preencher) no contexto do Spark significa que a execução não será iniciada até que uma ação seja
acionada. Isso acontece quando ocorrem transformações do Spark. As transformações são (lacuna para preencher) por
natureza, ou seja, quando chamamos alguma operação no RDD, ela não é executada imediatamente.

Assinale a alternativa que completa corretamente as lacunas acima:

• first()
• Lazy evaluation, preguiçosas
• Collect(), lenta
• Speed evaluation, rápida
• Count(), preguiçosas

Resposta Certa. (Lazy evaluation), no contexto do Spark significa que a execução não será iniciada até que uma ação seja
acionada. Isso acontece quando ocorrem transformações do Spark. As transformações são (preguiçosas) por natureza, ou
seja, quando chamamos alguma operação no RDD, ela não é executada imediatamente.

PERGUNTA. O nome dado a um módulo da arquitetura do Hadoop que recebe jobs do cliente e as envia para os nós
de processamento (slaves) é conhecido como:
a. secondary node.
b. hdfs.
c. job tracker
d. slave node.
e. task trackers.

67
Resposta certa. nome dado a um módulo da arquitetura do Hadoop que recebe jobs do cliente e as envia para os nós de
processamento (slaves) é conhecido como: Alternativa: c. job tracker

PERGUNTA. O (lacuna para preencher) é um dos subprojetos do Hadoop, sendo um modelo de programação e um arcabouço
especializado no processamento de conjuntos de dados distribuídos em um aglomerado computacional.

Assinale a alternativa que completa corretamente a lacuna acima:

• HDFS
• Apache Spark
• Apache Server
• Common
• Map Reduce

Resposta certa. O (Map Reduce) é um dos subprojetos do Hadoop, sendo um modelo de programação e um arcabouço
especializado no processamento de conjuntos de dados distribuídos em um aglomerado computacional.

PERGUNTA. O Spark lida com o problema de acesso compartilhado por meio de conjuntos de dados distribuídos conhecidos
como (lacuna para preencher), os quais se destaca como um modelo de programação (lacuna para preencher).

Assinale a alternativa que completa corretamente as lacunas acima:

• hdfs, tolerante a falhas.

• JSON, RDD.
• Graphx, tolerante a falhas.
• RDD, SQL.
• RDD, tolerante a falhas.

Resposta certa. O Spark lida com o problema de acesso compartilhado por meio de conjuntos de dados distribuídos
conhecidos como (RDD), os quais se destaca como um modelo de programação (tolerante a falhas.).

PERGUNTA. O (lacuna para preencher) é um dos componentes do Apache Kafka que atua para facilitar a verificação de
(lacuna para preencher), o gerenciamento e a coordenação. Também pode ser chamado de um serviço centralizado para
manter informações de configurações e nomenclaturas entre serviços distribuídos. O Kafka utiliza este componente para
sincronizar as configurações entre diferentes clusters.

Assinale a alternativa que completa corretamente as lacunas acima:

• consumidor, segurança
• spark, integridade
• produtor, integridade
• broker, disponibilidade
• zookeeper, integridade

Resposta certa. O (zookeeper) é um dos componentes do Apache Kafka que atua para facilitar a verificação de (integridade),
o gerenciamento e a coordenação. Também pode ser chamado de um serviço centralizado para manter informações de
configurações e nomenclaturas entre serviços distribuídos. O Kafka utiliza este componente para sincronizar as configurações
entre diferentes clusters.

68
PERGUNTA. O Hadoop é uma plataforma de software desenvolvida em Java utilizada para clusters e processamento de
grandes volumes de dados. São camadas importantes de uma aplicação no contexto do Hadoop:

1. Afirmação verdadeira. Armazenamento.

2. Afirmação verdadeira. Processamento.

3. Afirmação falsa. Interface.

4. Afirmação verdadeira. Conexão.

PERGUNTA. Embora os microsserviços tornaram mais ágeis, o desenvolvimento de soluções e a integração entre elas pode
ser feita de modo síncrono e assíncrono. Analise as afirmações a seguir:

1. Afirmação falsa. O método síncrono utiliza apenas o Apache Kafka.

2. Afirmação falsa. O método assíncrono utiliza APIs para compartilhar dados dos usuários.

3. Afirmação verdadeira. O Apache Kafka pode ser utilizado na transmissão de dados de equipes de desenvolvimento de
soluções.

4. Afirmação verdadeira. Uma abordagem de integração ágil permite utilizar integração síncrona ou assíncrona
dependendo das necessidades da aplicação.

SEMANA 6, AULA 1.

O que é desempenho?
Medida da capacidade de resposta de um sistema.

OMO ANALISAR DESEMPENHO?

• Medições
• Análises quantitativas
• Métricas de desempenho

PORQUE E PRA QUE DESEMPENHO?

POR QUE?

• Aspecto chave no projeto, compra, gerenciamento e otimização de sistemas computacionais

• Exemplo: Sistemas Web são críticos para a vida cotidiana. Praticamente quase tudo está na web

PARA QUE?

• Identificar pontos de contenção e/ou de desperdício de um sistema

• Avaliar múltiplas alternativas de projeto e/ou implementação de uma aplicação
• Encontrar a configuração ótima dos parâmetros de um sistema
• Planejamento de capacidade
• Identificar erros de implementação

69
IMPORTÂNCIA DA AVALIAÇÃO
• Por que se preocupar em avaliar um sistema
• Obtenção do melhor desempenho com custo reduzido
• O que é o melhor desempenho e o que deve ser analisado?
• Depende do ponto de vista!!!

Perguntas

• O que o sistema precisa?

• Qual é o tipo de usuário?
• Qual é o objetivo do sistema?
• Como se dá o gerenciamento de recursos?

PONTOS DE AVALIAÇÃO – EXEMPLO

Tornar um sistema mais rápido. O que será preciso?

• Descobrir os pontos de atraso

• Propor soluções
• Avaliar as soluções

O QUE VEM A SER A AVALIAÇÃO?

• Período/situação: quando se preocupar com o desempenho?

• Atores: quem deve ser preocupar?
• Métricas: como medir o desempenho? E o que medir?
• Confiança: como confiar nas métricas obtidas?

AVALIAR UM SISTEMA (COMPUTACIONAL OU NÃO) É:

• Buscar uma métrica que indique quantidade ou qualidade, por exemplo, de um serviço prestado.
• Determinar a eficiência com a qual um sistema atinge as necessidades e expectativas de seus usuários e
desenvolvedores para uma dada aplicação.

PARA AVALIAR UM SISTEMA (COMPUTACIONAL OU NÃO) É PRECISO UMA ANÁLSE DETALHADA:

• Dos recursos do sistema

• Dos gerenciadores
• Dos usuários
• Dos objetivos do sistema e da avaliação

COMO MEDIR O DESEMPENHO?

EM SISTEMAS COMPUTACIONAIS AS MEDIDAS:

• Não podem ser um fator degenerador

• Devem considerar o domínio da aplicação
• Devem deixar a análise isenta

TÉCNICAS PARA A MEDIÇÃO

• Aferição
• Protótipos
• Coleta de dados
• Benchmarks

Realizam experimentações no sistema.

70
TÉCNICAS PARA A MEDIÇÃO

• Modelagem
• Desenvolvimento do modelo
• Soluções para o modelo

Criam abstrações do sistema

O QUE MEDIR?

• Chama-se variável de resposta

• Depende de diversos enfoques
• Responsividade
• Produtividade
• Utilização

AVALIAÇÃO X ANÁLISE
AVALIAÇÃO

• Obter, produzir e levantar dados sobre uma determinada entidade

o Exemplo: calcular o consumo de um automóvel
o Utilizar uma técnica para medir a distância percorrida e o volume de combustível consumido

ANÁLISE

Verificar a precisão, a validade e o significado da grandeza produzida durante a avaliação

Exemplo: se a avaliação do automóvel levou a 12 km/litro de álcool, então a análise se preocupa em se certificar que:

• a metodologia utilizada foi correta

• os números levantados são suficientemente precisos
• e, então, conclui se o desempenho avaliado é bom, ruim etc

PERGUNTA. A avaliação de desempenho consiste em:

• verificar a precisão de um sistema.
• usar um benchmark.
• modelar um sistema.
• prototipar um sistema.
• buscar uma métrica que indica qualidade ou quantidade de um serviço prestado.

Resposta certa. A avaliação de desempenho consiste em: buscar uma métrica que indica qualidade ou quantidade de um
serviço prestado. A modelagem é uma ferramenta que auxilia na avaliação de desempenho assim como os benchmarks e a
construção de protótipos. Mas elas por si só não avaliam um sistema e precisam fazer uso de métricas devidamente
definidas. Tais métricas pode indicar pontos positivos ou negativos do sistema (qualidade do serviço prestado por exemplo,
ou o tempo de resposta a uma requisição de compra em uma loja virtual)

SEMANA 6, AULA 2.
O QUE É CARGA DE TRABALHO?
• Conjunto de todas as informações de entrada que um sistema recebe durante qualquer período de tempo
determinado
• Muito importante no planejamento de capacidade e na avaliação de sistemas.

71
PROCEDIMENTO PARA A CARGA DE TRABALHO
DETERMINAR QUE TIPO DE CARACTERISTICA É IMPORTANTE SER REPRESENTADA.

Depende do objetivo da avaliação.

• Exemplo: qual a carga que devemos considerar para avaliar um sistema computacional?

CARACTERIZAÇÃO DE CARGA DE TRABALHO

NÍVEL DE DETALHE A SER CONSIDERADO

VÁRIAS POSSIBILIDADES:

• Utilizar as requisições mais frequentes

• Considerar os vários tipos de requisições e suas frequências
• Trace: sequência de requisições com timestamp
• Utilizar valores médios
• Utilizar distribuições de probabilidade

CARACTERIZAÇÃO DE CARGA DE TRABALHO

VERIFICAR A REPRESENTATIVIDADE DA CARGA DE TRABALHO

TRÊS ASPECTOS IMPORTANTES:

• Taxa de chegada
• Demanda por recurso
• Sequência e demanda por diferentes recursos
• Atualização da carga de trabalho

TIPOS DE CARGA DE TRABALHO

Basicamente, duas formas:

• Carga de trabalho Real

• Carga de trabalho Sintética

Carga de trabalho Real - Observada no sistema real em operação normal

Vantagem

• Precisão

Desvantagens

• Não pode ser repetida com facilidade

• Arquivos de Trace → arquivos muito grandes

Carga de trabalho Sintética - Carga com características similares às reais.

Vantagens:

• Pode ser repetida de forma controlada

• Não necessita de arquivos com dados reais
• Carga pode ser facilmente modificada
• Pode ser transportada para diferentes sistemas

Problema:

• Determinar a distribuição mais apropriada para o sistema em avaliação

72
TESTE DE CARGA EM APLICAÇÕES
Teste de carga é um tipo de teste de desempenho que simula uma carga do mundo real em qualquer software, aplicativo ou
site em teste.

Objetivo: examinar como o sistema se comportará em condições normais e extremas de carga geradas por usuários.

POR QUE É IMPORTANTE?

• O teste de carga ajuda a descobrir erros ou possíveis falhas em diferentes cenários, para que você possa cuidar deles
e corrigi-los muito antes de finalizar o desenvolvimento de um sistema.
• Outros motivos importantes pelos quais a realização de um teste de carga é fundamental:
• acessibilidade, base de clientes e muitos outros.

TESTE DE CARGA EM APLICAÇÕES – BENEFÍCIOS.

• Escalabilidade
• Descobrir gargalos antes da implantação
• Reduzir o tempo de inatividade do sistema
• Garantir satisfação do usuário
• Reduzir o custo de falha

PERGUNTA - A carga de trabalho é uma demanda que é gerada para um sistema alvo de modo que este processe
esta demanda e em seguida retorne com um resultado ou resposta. Acerca do termo “carga de trabalho” é correto
afirmar que:
• a carga de trabalho real é fácil de reproduzir.
• a carga de trabalho sintética não pode ser repetida com facilidade.
• a carga de trabalho real pode ser repetida de forma controlada.
• a carga de trabalho real é observada no sistema normal em operação.
• a carga de trabalho real tem características da carga de trabalho sintética.

Resposta certa. A carga de trabalho é uma demanda que é gerada para um sistema alvo de modo que este processe esta
demanda e em seguida retorne com um resultado ou resposta. Acerca do termo “carga de trabalho” é correto afirmar que: a
carga de trabalho real é observada no sistema normal em operação. Uma carga de trabalho real é aquela que chegou a um
sistema, e depois de processada, uma resposta foi dada para o usuário, ou para outro sistema em um dado instante no
tempo. Essa carga inicialmente gerada, não pode ser repetida de forma idêntica, pois não conseguimos ter o controle de
todos os fatores que levaram a criação e execução desta carga em um sistema alvo. Podemos sim mapear características
desta carga de trabalho real e criar uma carga sintética.

SEMANA 6, AULA 3.

Ferramentas para Teste de Carga

A escolha de uma ferramenta de teste de carga depende inteiramente das necessidades do seu projeto, como tempo,
orçamento, etc.

TESTE DE ESTRESSE X TESTE DE CARGA

Teste de Carga

• Usado para simular condições normais

• Quantidade de dados utilizada é a mesma estimada para o dia a dia de trabalho
• Objetivo não é quebrar o sistema

Teste de Estresse

• Testa o comportamento do sistema simulando condições extremas

• O teste só encerra após ter gerado uma falha no sistema
• Objetivo é quebrar o sistema, gerar falhas

73
FERRAMENTAS

• Stress Tester
o Oferece uma análise extensa do desempenho de aplicações Web, além de resultados em formatos de gráfico
o Fácil de utilizar
o Não precisa de scripts de altíssimo nível
• Jmeter
o Ferramenta de teste open source
o É uma aplicação em Java para testar estresse e performance
o Objetivo: Realizar uma gama de testes, como carregamento, funcionalidade, estresse, etc.

• BlazeMeter
o A BlazeMeter comercializa uma plataforma comercial de teste de carga de autoatendimento como serviço
(PaaS),
o que é compatível com o Apache JMeter
o A BlazeMeter foi fundada em 2011 e foi adquirida pela CA Technologies em 2016. Em 2021, foi adquirida pela
Perforce
• Gatling
o Gatling é uma solução de teste de carga de código aberto
o Foi projetada para testes de carga contínuos e se integra ao seu pipeline de desenvolvimento
o Gatling inclui um gravador web e relatórios
o O teste de carga com Gatling permite que você emule tráfego pesado, obtenha relatórios e encontre possíveis
o bugs. Testes de capacidade, testes de imersão ou teste de estresse podem ser feitos sem muito esforço ao
o longo do processo de CI/CD:
o Injetores de carga sob demanda
o Relatórios avançados
o APIs públicas e fonte de dados Grafana
o Integração contínua
o Modo de clustering/Distribuído

PERGUNTA. Em relação ao teste de desempenho e teste de estresse, é verdadeiro afirmar que:

• ambos são utilizados para simular condições extremas do sistema.
• ambos são utilizados para simular condições normais do sistema.
• o teste de estresse e o teste de carga são a mesma coisa.
• no teste de carga o objetivo é testar os dados de entrada do sistema.
• o teste de estresse testa o sistema até este falhar.

Resposta certa. Em relação ao teste de desempenho e teste de estresse, é verdadeiro afirmar que: o teste de estresse testa
o sistema até este falhar.

O teste de desempenho não simula condições extremas do sistema, mas verifica seu comportamento em situações normais.
O teste de dados de entrada para um sistema está relacionado com dados incluídos pelos usuários em aplicações
computacionais, como por exemplo aplicações Web.

JMETER – ESTUDO DE CASO

• Multiplataforma e gratuito
• Gera gráficos em CSV, tabelas e gráficos
• Execução distribuída
• Suporta supervisores como: HTTP, HTTPS, LDAP, JMS
• O JMeter simula um grupo de usuários enviando solicitações para um servidor de destino e retorna estatísticas, que
mostram
• o desempenho/funcionalidade do servidor/aplicativo de destino por meio de tabelas, gráficos, etc.

74
PLANO DE TESTE

Um Plano de Teste pode ser visto como um container para execução de testes

• Define o que testar e como fazê-lo

• Um plano de teste completo consiste em um ou mais elementos, como grupos de threads, controladores lógicos,
controladores geradores de amostra, ouvintes, temporizadores

Plano de Teste Web

Passos

• Iniciar o Jmeter
• Renomear o Plano de Teste
• Adicionar grupo de tópicos
• Adicionar amostrador
• Adicionar ouvinte
• Executar o plano de teste
• Saída gerada

O projeto precisa ser criado, pois ele detalha todas as características dos testes, como por exemplo, o sistema alvo, o
nome do teste, quantidade de requisições/carga ao sistema etc. Os usuários representam um conjunto de carga de
trabalho enviada para o sistema alvo e pode correr em intervalos de tempos definidos pelo testador. Todos esses ajustes
podem ser gravados e associados a tal cenário de teste para que possa ser executado novamente em outra ocasião.

ATIVIDADE AVALIATIVA, SEMANA 6.

PERGUNTA. Uma ferramenta de teste de carga que permite a emulação de tráfego pesado a um sistema alvo, é de
código fonte aberto e projetada para testes contínuos, denomina-se:
• Blaze Meter.
• Stress Tester.
• Gatling.
• JMeter.
• Jenkins.

Resposta certa. Uma ferramenta de teste de carga que permite a emulação de tráfego pesado a um sistema alvo, é de código
fonte aberto e projetada para testes contínuos, denomina-se: Gatling.

75
PERGUNTA. Algum tipo de teste em aplicações computacionais precisa ser realizado. Há diversos tipos de testes associados
a contexto diferentes. Por exemplo, quando se desenvolve uma interface de uma aplicação Web há a necessidade de realizar
um teste para saber se a interface está adequada para a entrada de dados pelo usuário. Porém há testes de carga para
sistemas que rodam no back-end (servidores) que ajudam a provisionar melhor a infraestrutura computacional. O nome do
teste que considera vários sistemas executando no mesmo servidor, sendo utilizado para encontrar situações em que uma
aplicação boqueia os dados da outra, chama-se:

• Teste de estresse sistêmico.

• Teste de estresse distribuído.
• Teste de estresse exploratório.
• Teste de API.
• Teste de estresse transacional.

Resposta certa. Algum tipo de teste em aplicações computacionais precisa ser realizado. Há diversos tipos de testes
associados a contexto diferentes. Por exemplo, quando se desenvolve uma interface de uma aplicação Web há a necessidade
de realizar um teste para saber se a interface está adequada para a entrada de dados pelo usuário. Porém há testes de carga
para sistemas que rodam no back-end (servidores) que ajudam a provisionar melhor a infraestrutura computacional. O nome
do teste que considera vários sistemas executando no mesmo servidor, sendo utilizado para encontrar situações em que
uma aplicação boqueia os dados da outra, chama-se: Teste de estresse sistêmico.

PERGUNTA. Na caracterização da carga de trabalho imposta a um sistema computacional há diversas possibilidades

a serem consideradas. Àquela que utiliza sequência de requisições com time stamp é chamada de:
• taxa de chegada.
• localização do usuário.
• valor médio.
• trace.
• frequência de requisições.

Resposta certa. Na caracterização da carga de trabalho imposta a um sistema computacional há diversas possibilidades a
serem consideradas. Àquela que utiliza sequência de requisições com time stamp é chamada de: trace.

PERGUNTA. Uma das técnicas de avaliação de desempenho que cria abstrações de um sistema por meio do desenvolvimento
e solução de um modelo é conhecida como:

• aferição.
• modelagem.
• avaliação.
• prototipação
• análise.

Resposta certa. Uma das técnicas de avaliação de desempenho que cria abstrações de um sistema por meio do
desenvolvimento e solução de um modelo é conhecida como: modelagem.

76
PERGUNTA. Analise as afirmações a seguir acerca de um plano de teste com a ferramenta JMeter e escolha a alternativa
correta.

1. Afirmação verdadeira) Um plano de teste pode ser composto de geradores de amostra, temporizadores e grupos de
threads.

2. Afirmação falsa. Grupos de threads não podem ser utilizados no plano de teste.

3. Afirmação falsa. Com o JMeter o primeiro passo de um plano de teste é adicionar um ouvinte.

4. Afirmação falsa. O JMeter apenas gera dados de testes no formato de tabelas.

PERGUNTA. Entre as perguntas que precisamos responder ao considerar a avaliação de desempenho de um sistema
computacional, devemos considerar:

1. Afirmação correta. O que o sistema precisa.

2. Afirmação correta. O tipo de usuário.

3. Afirmação correta. O objetivo do sistema.

4. Afirmação falsa. A validade do sistema.

PERGUNTA. São pontos que precisam ser considerados na avaliação de desempenho de um sistema computacional,
exceto:
• recursos do sistema.
• objetivos do sistema e da avaliação.
• a aferição.
• gerenciadores.
• usuários.

Resposta certa. São pontos que precisam ser considerados na avaliação de desempenho de um sistema computacional,
exceto: a aferição.

PERGUNTA. Uma das características da ferramenta (lacuna para preencher) são os controles de gravação que são
importantes no momento da gravação dos scripts, ajudando a economizar tempo no projeto, bem como o extrator de
expressão regular que auxilia a coleta de dados dos resultados retornados, podendo assim realizar validações durante o
teste.

• OpenMP
• OpenMPI
• BlazeMeter.
• JMeter
• Apache Server

Resposta certa. Uma das características da ferramenta (JMeter) são os controles de gravação que são importantes no
momento da gravação dos scripts, ajudando a economizar tempo no projeto, bem como o extrator de expressão regular que
auxilia a coleta de dados dos resultados retornados, podendo assim realizar validações durante o teste.

77
SEMANA 7, AULA 1.
CONTAINER
• Agrupamento de uma aplicação junto com suas dependências que compartilham o kernel do S.O do host, ou seja, da
máquina virtual ou física onde está rodando a aplicação.
• Seu objetivo é dar independência de execução à diversos processos e aplicações, a fim de otimizar a utilização da
infraestrutura de recursos promovendo a mesma segurança de sistemas separados.

DOCKER
• Projeto open source de plataforma as a service (PaaS), com a proposta de desenvolver, entregar e executar projetos
em pacotes de software.
• Esses pacotes são containers isolados que agrupam seus próprios softwares, bibliotecas e arquivos.
• Solução flexível, portátil e escalável para desenvolvimento de aplicações.

OpenShift – Introdução e Arquitetura

• O OpenShift é uma ferramenta utilizada para gerenciar containers de software, oferecendo segurança,
monitoramento e controle
• Com a ferramenta podemos:
o criar um ambiente integrado baseado em containers
o implantar aplicações feitas em diversas linguagens
o escalar essas aplicações

OpenShift - Componentes

• Nodes
• Masters
• Containers
• Pod
• Services
• API Authentication
• Datastore
• Scheduler
• Management/Replication
• Registry

OpenShift - Camada de infraestrutura

Ambiente em que podemos hospedar as aplicações em servidores físicos, servidores virtuais ou na nuvem (pública/privada)

OpenShift – Camada de serviços

• Responsável por definir os pods e a política de acesso

• Fornece endereço IP e um nome de host para os pods
• Conecta aplicações
• Permite balanceamento de carga

OpenShift - Nó principal

• Aquele que gerencia o cluster e cuida dos nós trabalhadores, sendo responsável por:
• API e Autenticação
• Data Stora
• Escalonamento
• Escalabilidade
78
OpenShift - Nós trabalhadores

Compostos de pods. Pod é a menor unidade que pode ser definida, implantada e gerenciada e pode conter um ou mais
containers. Containers são formados por aplicações + suas dependências

OpenShift - Registro

Salva suas imagens localmente no cluster

Quando uma nova imagem é enviada para o registro, este notifica o OpenShift e passa as informações da imagem

OpenShift - Armazenamento persistente

• Local em que os dados são salvos e conectados aos contêineres.

• Por que precisa?
o Porque os contêineres são efêmeros, o que significa que quando são reiniciados ou excluídos,
o todos os dados salvos são perdidos. Isso vai evitar qualquer perda de dados

Camada de roteamento

• Fornece acesso externo as aplicações no cluster de qualquer dispositivo

• Fornece também balanceamento de carga e roteamento automático em torno de pods

Pergunta. No contexto do OpenShift, a camada que é responsável por definir os pods e permitir o balanceamento de carga é
a de:

• registro.
• persistência.
• roteamento.
• nó mestre.
• serviços

Resposta certa. No contexto do OpenShift, a camada que é responsável por definir os pods e permitir o balanceamento de
carga é a de: serviços.

A função de balanceamento e definição de pods é da camada de serviços. A camada de infraestrutura é aquela em que são
hospedadas as aplicações em servidores físicos, servidores virtuais ou na nuvem (pública/privada). A camada de roteamento
fornece acesso externo as aplicações no cluster de qualquer dispositivo. A camada de serviços é a responsável por definir os
pods e a política de acesso, bem como fornecer endereço IP e um nome de host para os pods.

SEMANA 7, AULA 2.

Criação de um Cluster OpenShift

PRÉ-REQUISITOS

• O OpenShift é uma plataforma como serviço (PaaS) gratuita, de código aberto, e de desenvolvimento em nuvem
desenvolvida pela Red Hat
• O pré-requisito para instalar o OpenShift como PaaS é:
o uma distribuição Linux instalada no host
o ter o docker instalando no host/desktop/notebook

79
INICIAR O OPENSHIFT CLUSTER

• Para iniciar o cluster OpenShift é preciso especificar o IP do host

• oc cluster up –public-hostname=192.168.2.5

Após a inicialização do servidor, veremos uma saída:

The server is accessible via web console at:
https://your-server-ip:8443
You are logged in as:
User: developer
Password: <any value>
To login as administrator:
oc login -u system:admin
INICIAR O OPENSHIFT CLUSTER
Logar no cluster como administrador
oc login -u system:admin
A saída será como mostrado a seguir

Logged into "https://127.0.0.1:8443" as "system:admin" using existing credentials.

You have access to the following projects and can switch between them with 'oc project ':
default
kube-dns
kube-proxy
kube-public
kube-system
* myproject
openshift
openshift-apiserver
openshift-controller-manager
openshift-core-operators
openshift-infra
openshift-node
openshift-service-cert-signer
openshift-web-console
Using project "myproject".

INICIAR O OPENSHIFT CLUSTER

Vamos agora mudar para um projeto padrão como descrito no slide anterior oc project default
Now using project "default" on server "
https://localhost:8443".

Verificar o status atual do projeto

INICIAR O OPENSHIFT CLUSTER
In project default on server https://your-server-ip:8443
svc/docker-registry - 172.30.1.1:5000
dc/docker-registry deploys docker.io/openshift/origin-docker-
registry:v3.11
deployment #1 deployed 2 minutes ago - 1 pod
svc/kubernetes - 172.30.0.1:443 -> 8443
svc/router - 172.30.94.157 ports 80, 443, 1936
dc/router deploys docker.io/openshift/origin-haproxy-router:v3.11
deployment #1 deployed 2 minutes ago - 1 pod
View details with 'oc describe /' or list everything with 'oc get all'.

SEMANA 7, AULA 3.

80
Deploy de Aplicações com OpenShift

Para criar o projeto temos que logar no cluster com o usuário developer
Coloque para login e senha: developer
oc login
Authentication required for
https://127.0.0.1:8443 (openshift)
Username: developer
Password: developer
Login successful.
You have one project on this server:
"myproject"
Using project "myproject".

CRIAR PROJETO
Comando para a criação de um projeto:
oc new-project dev --display-name="Project -
Dev" --description="My Project"

ACESSO AO CONSOLE WEB

Para acessar o console Web do OpenShift basta digitar no browser
https://localhost:8443
Utilize como login e senha: developer
No lado direto da tela, clique no botão Create Project
Name: my-project
Display Name: Meu Projeto
Description: Meu primeiro projeto

DEPLOY DE APLICAÇÃO
PASSO A PASSO
Logar com usuário e senha: developer
oc login
Authentication required for https://127.0.0.1:8443 (openshift)
Username: developer
Password:
Login successful.
You have access to the following projects and can switch between them
with 'oc project ':
* dev
my-project
myproject
Using project "dev".
Ainda no terminal digite: oc project my-project
ow using project "my-project" on server "https://127.0.0.1:8443".
Para ver o status do projeto: oc status

In project My Project (my-project) on server https://127.0.0.1:8443

You have no services, deployment configs, or build configs.
Run 'oc new-app' to create an application.

81
Deploy da aplicação
oc my-project deployment-example
--> Found image da61bb2 (4 years old) in image stream "my-project/deployment-example" under tag
"latest" for "deployment-example"
* This image will be deployed in deployment config "deployment-example"
* Port 8080/tcp will be load balanced by service "deployment-example"
* Other containers can access this service through the hostname "deployment-example"
* WARNING: Image "my-project/deployment-example:latest" runs as the 'root' user which may not be
permitted by your cluster administrator
--> Creating resources ...
deploymentconfig.apps.openshift.io "deployment-example" created
service "deployment-example" created
--> Success
Application is not exposed. You can expose services to the outside world by executing one or more
of the commands below:
'oc expose svc/deployment-example'
Run 'oc status' to view your app.

Status do Deploy : oc status

In project My Project (my-project) on server https://your-server-
ip:8443
svc/deployment-example - 172.30.87.146:8080
dc/deployment-example deploys istag/deployment-example:latest
deployment #1 deployed 36 seconds ago - 1 pod
2 infos identified, use 'oc status --suggest' to see details.

Status do serviço: oc get svc

Verificar os pods: oc get pods

Exportar a aplicação para acesso externo: oc expose service/deployment-example
Informações de rota: oc get routes

ACESSAR APLICAÇÃO
ABRA O BROWSER COM UM IP COMO ESTE
http://172.30.106.225:8080/

Pergunta. Depois de criado um projeto de aplicação no OpenShift é preciso acessar o console Web no endereço:
• htps://localhost:22
• htps://localhost:80
• htps://localhost:8443
• htps://localhost:25
• htps://localhost:9090

Resposta certa. Depois de criado um projeto de aplicação no OpenShift é preciso acessar o console Web no endereço:
htps://localhost:8443
A portão padrão do console Web do OpenShift é a 8443, A porta 80 é padrão para servidores Web. A porta 25 é utilizada
para serviços de e-mail (SMTP). E a porta 9090 também é utilizada em geral para serviços web que executam localmente ou
externamente a uma rede por meio de portas redirecionadas em um firewall. A porta 8443 embora não seja uma “porta bem
conhecida” (entre as 1024 portas desta categoria) é a que foi definida pelo OpenShift com porta padrão.

82
Pergunta. Uma funcionalidade oferecida pelo OpenShift é:

• suporte somente para cargas de trabalho reais.

• registro de banco de dados.
• compatibilidade com redes P2P.
• limitação com broker de serviços.
• integração com Kubernetes.

Resposta certa. Uma funcionalidade oferecida pelo OpenShift é a integração com Kubernetes.

Além de integração com o Kubernetes, outras funcionalidades incluem: acesso fácil aos serviços, fluxos de trabalho do
desenvolvedor, compatibilidade com o open container initiative, registro de contêiner de dados etc.

Pergunta. Sobre a funcionalidade do OpenShift é correto afirmar que:

• ele é um cluster.
• ele é uma infraestrutura como serviço.
• ele não utiliza Kubernetes.
• ele é uma ferramenta utilizada para implantar e gerenciar aplicações baseadas em containers
• ele não utiliza Docker.

Resposta certa. Sobre a funcionalidade do OpenShift é correto afirmar que ele é uma ferramenta utilizada para implantar e
gerenciar aplicações baseadas em containers .
O OpenShift faz uso intensivo da tecnologia de containers e do sistema de orquestração de containers que é o Kubernetes.
Ele não é um cluster. É na verdade considerado uma plataforma como serviço.

SEMANA 7, ATIVIDADE AVALIATIVA

Pergunta. Da lista apresentada a seguir, analise quais itens são componentes da arquitetura do OpenShift e escolha a
alternativa correta.

• Afirmação correta. 1. Data Store

• Afirmação correta. 2. Scheduler
• Afirmação falsa. 3. Zookeeper
• Afirmação falsa. 4.Broker

Pergunta. O OpenShift é uma plataforma desenvolvida pela Red Hat que auxilia no processo de orquestração de contêineres
de maneira independente da plataforma na qual os contêineres serão executados. Quando devidamente configurado, o
acesso ao OpenShift pelo browser é, por padrão, feito pela URL:

• http://localhost:443
• http://localhost:8443
• http://localhost:8080
• http://localhost:22
• http://localhost:200

Resposta certa. O OpenShift é uma plataforma desenvolvida pela Red Hat que auxilia no processo de orquestração de
contêineres de maneira independente da plataforma na qual os contêineres serão executados. Quando devidamente
configurado, o acesso ao OpenShift pelo browser é, por padrão, feito pela URL: http://localhost:8443

83
Pergunta. O OpenShift fornece uma base consistente para gerenciar implantações de aplicações na edge, multicloud e na
nuvem híbrida. O (lacuna para preencher) é mecanismo responsável por coletar informações sobre o estado dos
componentes e elementos do cluster OpenShift, enquanto a (lacuna para preencher) faz o controle de acesso às APIs.

• Data Store, Management Replication

• API Authentication, Data Store
• API, Data Store
• Scheduler, API
• Management Replication, API Authentication

Resposta certa . O OpenShift fornece uma base consistente para gerenciar implantações de aplicações na edge, multicloud e
na nuvem híbrida. O (Management Replication) é mecanismo responsável por coletar informações sobre o estado dos
componentes e elementos do cluster OpenShift, enquanto a (API Authentication) faz o controle de acesso às APIs.

O OpenShift tem seu funcionamento baseado em camadas, sendo cada uma responsável por determinada funcionalidade.
Assinale a alternativa correta.

• Um componente que é responsável por distribuir cargas de trabalho entre os nós do cluster OpenShift é o
Management/Replication.
• Os componentes do OpenShift são organizados de forma monolítica.
• Os componentes do OpenShift são armazenados em um nó chamado de slave.
• O OpenShift é agnóstico a ferramentas de automação de operações.
• O OpenShift não é compatível com o Kubernets.

Resposta certa. O OpenShift tem seu funcionamento baseado em camadas, sendo cada uma responsável por determinada
funcionalidade. sendo assim é correto dizer que: O OpenShift é agnóstico a ferramentas de automação de operações.

Pergunta. Com base em uma visão geral das ferramentas que são integradas e orquestradas pelo OpenShift, avalie as
afirmações a seguir e escolha a alternativa correta.

• Afirmação falsa. 1. A segurança é um dos blocos do gerenciamento de ciclo de vida da aplicação.

• Afirmação falsa. 2. O balanceamento de carga faz parte do enterprise container host.
• Afirmação correta. 3. O gerenciamento de configurações e logs faz parte da orquestração de contêineres e
gerenciamento.
• Afirmação correta. 4. O deploy é parte do gerenciamento de ciclo de vida da aplicação.

Pergunta. No passo a passo apresentado na Videoaula 21, destacamos alguns comandos utilizados para realizar o deploy de
uma aplicação no OpenShift. Em particular, os comandos utilizados para ver o status do serviço e o status do deploy é:

oc get pods, oc get svc

oc get svc, oc expose

oc get svc, oc get pods

oc get svc, oc status

oc get pods, oc status

Resposta certa: No passo a passo apresentado na Videoaula 21, destacamos alguns comandos utilizados para realizar o
deploy de uma aplicação no OpenShift. Em particular, os comandos utilizados para ver o status do serviço e o status do
deploy é:oc get svc, oc status

84
Revisão - Computação Escalável.
Nesta revisão abordaremos os principais tópicos relativos ao conteúdo da disciplina de Computação Escalável para cada
semana de aula que foi ministrada. Esta revisão deve ser um guia para ajudá-lo(a) a rever os principais assuntos abordados
na disciplina e auxiliá-lo(a) para a realização da prova final. Espera-se que você tenha realizado as leituras sugeridas como
texto-base, feito as atividades propostas no decorrer de cada aula, bem como, sempre que possível, ter assistido aos vídeos
de apoio. Foram discutidos ferramentas e códigos de exemplo nas aulas para reforçar o seu aprendizado. Por ter se

esforçado e seguido o roteiro indicado a cada semana, tenho certeza de que terá sucesso na avaliação.

Na primeira semana, discutimos os conceitos que envolvem a computação paralela e distribuída, de modo que você
aprendeu que a computação que utilizamos cotidianamente depende muito de como centros computacionais provisionam
seus recursos (servidores com CPU, disco e memória) para atender a uma enorme demanda de processamento.

Compreendemos, em linhas gerais, o que é a computação paralela e distribuída, as aplicações práticas da computação
paralela e distribuída no nosso cotidiano e como isso auxilia na tomada de decisões rápidas quando é necessário computar
muitos dados provenientes de muitas fontes e consumidos por milhões de usuários.

Na segunda semana, destacamos o relacionamento em termos da computação escalável e identificamos a importância que o
paralelismo traz para a escalabilidade de soluções computacionais. Nesse contexto, é preciso lidar com concorrência de
dados, acessos, usuários, sistemas de arquivos etc., para termos soluções como aplicações que rodam na nuvem e que são
transparentes para os usuários, envolvendo sobremaneira muitos ajustes na infraestrutura computacional. Compreendemos,
então, a relação do tipo de arquitetura de um processador com a possibilidade de explorar o paralelismo em diversos níveis,
bem como discutimos o é a arquitetura multicore, os tipos de máquinas MIMD e compreendemos por que é importante
utilizar métricas de desempenho para mediar o paralelismo de aplicações. Considerando os frameworks discutidos nesta
semana, o mais recomendado para processamento de grandes volumes dados é o CUDA, embora esse framework tenha

uma curva de aprendizado mais lenta, dada a complexidade apresentada. O OpenMP e o OpenMPI são muito utilizados em
ambientes acadêmicos com bons resultados no processamento de informações. Para definir o que é escalabilidade,
precisamos conhecer os requisitos específicos de demanda da computação que deverão ser dimensionados, visto que é um
assunto relevante e importante para bancos de dados, roteadores, redes de computadores e implica em melhor ou pior
desempenho. Por exemplo, se um sistema melhora o desempenho quando aumentamos o hardware (memória CPU, disco),

proporcionalmente à capacidade acrescida, podemos dizer que o sistema tende a ser escalável. No contexto de Computação
em Nuvem, por exemplo, com a grande oferta de recursos virtualizados podemos aumentar tais recursos rapidamente de
forma horizontal (replicando uma máquina virtual) ou verticalmente (aumentando memória, disco, processamento).

Na terceira semana, aprendemos sobre a infraestrutura para computação paralela e distribuída. Discutimos que a
computação paralela e distribuída nem sempre é evidente para a grande maioria dos usuários, mas ambas estão em grande
parte das aplicações que utilizamos no cotidiano. Quando você acessa um site de conteúdo ou de comércio eletrônico, os
milhões de acessos precisam ser distribuídos para centenas ou até milhares de servidores em um data center. Isso ajuda a
equacionar o que chamamos de “carga de trabalho” dentro do data center e permite atender à demanda do usuário mais
rapidamente.

Além disso, há situações, por exemplo, em que é exigido alto poder de processamento computacional para a resolução de
tarefas complexas. Uma situação que também faz parte do nosso cotidiano é diariamente consultar informações sobre o
clima de nossa cidade, região ou país. Saiba você que, para termos uma boa previsão climática, é necessário processamento
de modelos matemáticos complexos junto a informações coletadas de diversas estações meteorológicas em terra e de
imagens via satélite. Além das aplicações computacionais relacionadas ao clima há muitas outras que necessitam de muita

computação, comunicação, distribuição e armazenamento de dados. Finalizamos a semana compreendendo a importância

da infraestrutura computacional e a necessidade de ter essa infraestrutura ajustada a categorias de problemas que poderão
ser computados nesses ambientes. Além disso, discutimos um pouco sobre Cluster, Grid e Cloud Computing.

Na quarta semana, aprendemos sobre alguns frameworks/middlewares amplamente utilizados para auxiliar programadores
na construção de aplicações paralelas envolvendo tanto memória compartilhada quanto memória distribuída, com destaque
para OpenMP, OpenMPI e CUDA, esta última amplamente utilizada atualmente para auxiliar no processamento de tarefas
computacionalmente intensivas em placas de vídeo. Dessa forma, conseguimos entender que a computação paralela torna
possível, com o auxílio e middlewares que abstraem as complexidades de hardware e de comunicação, desenvolver

85
programas computacionais mais robustos e que podem explorar toda a capacidade computacional disponível de uma
empresa ou universidade por exemplo.

Na quinta semana, abordamos a necessidade de utilizar ferramentas adequadas para processar grandes volumes de dados,
ferramentas essas que consideram a escalabilidade dos recursos computacionais disponíveis, os quais precisam estar
devidamente ajustados para que respostas rápidas sejam dadas para os usuários ou outras aplicações de um ecossistema de
serviços. Como exemplo destacamos ferramentas como o Spark, Haddop e Kafka, ambas de código fonte aberto utilizadas
pelas organizações para processar gigantescos volumes de dados.

Na sexta semana, o assunto foi avaliação de desempenho e como estratégias de avaliação de desempenho em sistemas
computacionais pode auxiliar na tomada de decisão fornecendo informações do sistema avaliado e de quem utiliza tal
sistema (usuário). Vimos que esse assunto impacta os profissionais que atuam no desenvolvimento de soluções que

são executadas localmente ou em nuvens computacionais. Apresentaremos o que é e como indicamos ferramentas que
podem ser utilizadas para avaliar o desempenho de aplicações, bem como discutimos o que vem a ser testes de carga e de
estresse. Dentre as ferramentas apresentadas demos destaque ao JMeter.

Chegamos à sétima e última semana, nela apresentamos uma ferramenta utilizada para criar soluções computacionais em
ambientes que consideram a escalabilidade como um quesito fundamental. O OpenShift é uma plataforma open source para
orquestração de contêineres, que conta com funcionalidades de produtividade e segurança fundamentais para empresas de
grande porte. Serve para o gerenciamento de contêineres e para o controle de todo o ciclo de vida de uma aplicação, bem
como auxilia no processo de orquestração de contêineres baseada em Kubernetes e contêineres Linux, independentemente
da plataforma na qual os contêineres serão executados. Um contêiner é uma unidade padrão de software que empacota o
código e todas as suas dependências para que a aplicação seja executada de forma rápida e confiável de um ambiente de

computação para outro. Os contêineres Linux® e as máquinas virtuais são ambientes de computação empacotados que
combinam vários componentes de TI e os isolam do restante do sistema. As principais diferenças entre eles têm a ver com
escala e portabilidade.

Máquinas Virtuais (VMs) são medidas em gigabyte, enquanto os contêineres são medidos em megabyte. Docker é um
conjunto de produtos de plataforma como serviço que usam virtualização de nível de sistema operacional para entregar
software em pacotes chamados de contêineres. Discutimos brevemente como instalar e configurar o OpenShift, bem como

instanciar um projeto simples e fazer deploy dele na plataforma OpenShift.

Para finalizar, sugiro que revise as Atividades Avaliativas, bem como os textos-base, vídeos e ferramentas que foram
solicitados que você interagisse ou utilizasse durante as semanas.

O material de revisão ajuda a ampliar o escopo do assunto abordado semanalmente e, certamente, traz novas discussões
para que você aprenda mais. Outro ponto importante que também o(a) ajuda a aprender é revisar as discussões que
ocorreram nos fóruns semanais e desafios da semana. A sua dúvida pode ser a de muitos outros colegas e essa

troca de experiências enriquece o aprendizado.Como o docente responsável pela disciplina, espero que os assuntos tratados
possam complementar a sua formação profissional. Os assuntos abordados são muito atuais e tenho certeza de que, na sua
carreira profissional, você deva lidar com um ou mais desses assuntos. Espero que o que abordamos nesta disciplina ajude
você a buscar por novos conhecimentos. Tenha em mente que todo o esforço será recompensado.

86