MapReduce Mapeando e reduzindo Prof. Fabrício Olivetti de França Universidade Federal do ABC
Motivação Vimos até então que nosso maior problema é a quantidade de dados. O processamento não pode ser distribuído se não pudermos distribuir os dados.
Motivação Como extrair informações dos dados tendo apenas uma visão local (parte dos dados) mas tendo a possibilidade de mesclar essa informação em uma visão global?
Ordenando dados Um fato comum a muitos algoritmos de ordenação de dados é que eles estão limitados a uma complexidade computacional O(nlogn). Isso porque eles se baseiam em comparação par a par.
Ordenando dados Mas existem algumas técnicas que conseguem superar essa limitação! Uma delas é a Bucket Sort que utiliza o princípio da casa dos pombos.
Princípio da Casa dos Pombos Imaginem que temos 1 pombo e uma casa.
Princípio da Casa dos Pombos É fácil alocar esse pombo nessa casa.
Princípio da Casa dos Pombos Da mesma forma se temos dois pombos e duas casas.
Princípio da Casa dos Pombos Ou n pombos e n casas.
Princípio da Casa dos Pombos Mas se tivermos n pombos e m casas, com n>m?????
Princípio da Casa dos Pombos Nesse caso podemos dizer que pelo menos 1 pombo terá que dividir casa com outro!
Princípio da Casa dos Pombos Mas o que isso tem a ver com ordenação...e com nosso problema de distribuição de dados?
Princípio da Casa dos Pombos Imagine que temos um monte de pombos.
Princípio da Casa dos Pombos E queremos dividi-los em machos e fêmeas.
Princípio da Casa dos Pombos Mas para saber se são machos ou fêmeas, devemos comparar com pombos da mesma espécie.
Princípio da Casa dos Pombos Digamos que temos 3 espécies diferentes...
Princípio da Casa dos Pombos...devemos comparar cada pombo com todos os outros?
Princípio da Casa dos Pombos Mas, nós sabemos que cada espécie come uma fruta diferente.
Princípio da Casa dos Pombos Se colocarmos cada fruta em uma casa diferente, atrairemos pombos da mesma espécie para as mesmas casas.
Princípio da Casa dos Pombos Se colocarmos cada fruta em uma casa diferente, atrairemos pombos da mesma espécie para as mesmas casas.
Princípio da Casa dos Pombos Matematicamente aplicamos uma função f(x), onde x é um pombo, que retorna a casa que o pombo pertence. f(x) f(x) f(x)
Princípio da Casa dos Pombos Ou seja, temos uma função que mapeia nossos objetos para o lugar deles. f(x) f(x) f(x)
Princípio da Casa dos Pombos Em cada casa, fazemos a comparação entre os pombos para determinar quem é macho e quem é fêmea. f(x) f(x) f(x)
Princípio da Casa dos Pombos Retiramos os pombos da casa já separados.
Princípio da Casa dos Pombos Fazemos as operações dentro das casas mas reduzimos os dados para fora delas.
Princípio da Casa dos Pombos Bom, acabamos de ordenar os pombos.
Princípio da Casa dos Pombos Com 9 pombos, fizemos 9 operações de mapeamento. Em cada casa fizemos 3 operações.
Princípio da Casa dos Pombos Ao todo fizemos 18 operações, menos do que as 36 na ordenação ingênua.
Bucket Sort Digamos que temos 20 bolinhas numeradas de 1 a 20 e queremos ordená-las. 7 6 1 12 9 20 4 14 17 16 3 11 8 2 5 10 19 13 15 18
Bucket Sort Vamos fazer isso utilizando 5 baldes (ao invés de casas). 7 6 1 12 9 20 4 14 17 16 3 11 8 2 5 10 19 13 15 18
Bucket Sort Primeiro vamos definir quais números devem ir em cada balde! 7 6 1 12 9 20 4 14 17 16 3 11 8 2 5 10 19 13 15 18
Bucket Sort Primeiro vamos definir quais números devem ir em cada balde! 7 6 1 12 9 20 4 14 17 16 3 11 8 2 5 10 19 13 15 18 1 a 4 5 a 8 9 a 12 13 a 16 17 a 20
Bucket Sort Nossa função pode ser f(x) = floor((x-1) / 4) 7 6 1 12 9 20 4 14 17 16 3 11 8 2 5 10 19 13 15 18 1 a 4 5 a 8 9 a 12 13 a 16 17 a 20
Bucket Sort No primeiro passo, aplicamos f(x) em cada elemento e jogamos no balde correto. 1 4 6 7 10 12 13 15 17 18 2 3 5 8 9 11 14 16 20 19
Bucket Sort Em cada balde ordenamos utilizando qualquer método de ordenação. 1 2 5 6 9 10 13 14 17 18 3 4 7 8 11 12 15 16 19 20
Bucket Sort Retiramos os números dos baldes na ordem correta e concatenamos o resultado de cada balde. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Bucket Sort Fizemos um total de 20 operações para mapear os números e 5*6=30 operações para ordenar no balde. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Bucket Sort 50 operações contra cerca de 60 com n.logn ou 2500 em n 2. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Bucket Sort Mas reparem que nossa função de mapeamento dividiu nossos dados. Essa divisão permitiu que trabalhássemos com apenas parte dos dados de forma independente sem afetar o resultado final.
MapReduce O mapeamento dos dados, chamado de map e a redução dos conjuntos, chamado reduce, nos permite trabalhar com grandes quantias de dados de forma paralela sem alterar a saída do algoritmo.
MapReduce Essas funções já são velhas conhecidas de quem programa em linguagem funcional. O x da questão está em criar essas funções map e reduce para executar nossa tarefa.
Sistemas de Arquivos Distribuídos Antes de aprendermos os conceitos de MapReduce vamos entender como funciona a rede de servidores para lidar com grande quantidade de dados.
Sistemas de Arquivos Distribuídos Um sistema de arquivos distribuídos geralmente é composto por vários racks de servidores em gavetas.
Sistemas de Arquivos Distribuídos Os computadores de cada rack são interligados por uma rede Gigabit.
Sistemas de Arquivos Distribuídos E os racks são interligados por um switch ou roteador.
Sistemas de Arquivos Distribuídos Em casos que temos uma grande massa de dados sendo adquiridos a cada instante, faz-se necessário tal estrutura. Porém, muitas máquinas significa uma maior chance de falhas.
Sistemas de Arquivos Distribuídos Note que esse tipo de sistema só faz sentido quando temos algo além dos Terabytes de dados e os dados não são atualizáveis.
Sistemas de Arquivos Distribuídos Nesse tipo de sistema temos duas falhas principais: Falha em uma gaveta (perda de dados). Falha na comunicação intra-racks (perda de comunicação).
Sistemas de Arquivos Distribuídos A computação efetuada nesse sistema deve ser tolerante a falhas! Imaginem um processamento que leva horas tendo que ser reiniciado por completo por conta de uma falha na rede. Ou parte dos seus dados perdidos pois um único HD deu problema.
Sistemas de Arquivos Distribuídos Para resolver isso nosso sistema deve: Armazenar os dados de forma redundante Dividir o processamento em tarefas
Dados Redundantes Nesse tipo de sistema de arquivos os dados são divididos em pedaços, geralmente de 64 MB. Cada pedaço é armazenado em pelo menos 3 servidores localizados em diferentes racks.
Dados Redundantes A localização de cada pedaço de um arquivo é armazenado no chamado Nó Mestre, que também é replicado para caso de falhas.
Dados Redundantes Exemplos desse tipo de sistema de arquivos: GFS: Google File System HDFS: Hadoop Distributed File System CloudStore
Processamento em Tarefas O processamento de dados nesse tipo de sistema segue a lógica do MapReduce. Esse procedimento inicia em cada nó do sistema que contém um pedaço de arquivo de interesse.
Processamento em Tarefas Em cada nó, os pedaços de arquivo passam por uma função Map, que transforma os dados do arquivo em uma tupla (chave, valor) Chave-Valor (k,v) DADOS MAP
Processamento em Tarefas Essas tuplas são direcionadas a um nó mestre, onde são ordenadas e agrupadas pela chave. Chave-Valor (k,v) (k,[v1,v2,..,vn]) DADOS MAP ORDENA AGRUPA
Processamento em Tarefas As tuplas agrupadas são repassadas para outros nós que fazem a redução dos dados. Chave-Valor (k,v) (k,[v1,v2,..,vn]) DADOS MAP ORDENA AGRUPA REDUCE
Processamento em Tarefas Finalmente, os dados são combinados e a saída é emitida. Chave-Valor (k,v) (k,[v1,v2,..,vn]) DADOS COMBINAR MAP ORDENA AGRUPA REDUCE
Processamento em Tarefas Note que esse sistema é naturalmente tolerante a falhas. Chave-Valor (k,v) (k,[v1,v2,..,vn]) DADOS COMBINAR MAP ORDENA AGRUPA REDUCE
Processamento em Tarefas Se um nó MAPPER falhar, basta o nó mestre aguardar que outro mapper termine a tarefa e repassa os pedaços para ele. DADOS COMBINAR MAP ORDENA AGRUPA REDUCE
Processamento em Tarefas Se um nó REDUCER falhar, o nó mestre repassa os dados para outro reducer. DADOS COMBINAR MAP ORDENA AGRUPA REDUCE
Processamento em Tarefas Se o nó mestre falhar, basta um novo nó mestre recuperar os dados dos mappers. DADOS COMBINAR MAP ORDENA AGRUPA REDUCE
Exemplo Canônico Vamos exemplificar o procedimento com uma tarefa bem simples: contar a frequência de cada termo em uma série de documentos. Imaginem que temos armazenados 10TB de documentos em nosso sistema, queremos contar a frequência de cada termo existente em TODOS os documentos.
Exemplo Canônico Cada mapper vai receber 64MB de texto (não necessariamente do mesmo documento).
Map A nossa função MAP vai receber um pedaço de texto: Para cada termo t do texto: emite ( t, 1 ) Ou seja, o mapper emite cada termo encontrado (chave) com o valor 1.
Reduce Cada reducer recebe a tupla (termo, [valores]) após o nó central ordenar a saída dos mappers. Para cada (k,[vi]) faça: total = soma([vi]) emite (k,total) Nesse momento os reducers fazem a soma dos termos e emitem a contagem.
Combine Quando temos um cálculo associativo e comutativo (ex.: soma das contagens), podemos usar um passo intermediário chamado Combine. Esse passo é feito em cada nó mapper e consiste em pré-calcular parte do reduce.
Combine No nosso caso, o combine faria o cálculo da frequência de cada termo em cada nó mapper e emitiria (t, v) com v sendo a soma de ocorrência do termo t.
MapReduce no Haskell
GHC Mapper e Combiner mapper :: (Hashable k0, Eq k0) => Op a0 -> Mapper k0 a0 -> [k0] -> M.HashMap k0 a0 mapper combfun f job = combiner combfun $ map f job
GHC Mapper e Combiner combiner :: (Hashable k0, Eq k0) => Op a0 -> [(k0,a0)] -> M.HashMap k0 a0 combiner f m = M.fromListWith f m
GHC Reducer reducer :: (Hashable k0, Eq k0) => Op a0 -> [M.HashMap k0 a0] -> M.HashMap k0 a0 reducer f m = foldl' (M.unionWith f) M.empty m
GHC Tipos type Op a = (a -> a -> a) -- Function of two inputs type Mapper k a = k -> (k,a) -- Function that maps a key to a key value tuple
GHC Contador de Palavras wordcount :: Int -> [String] -> M.HashMap String Integer wordcount n wl = reducer (+) mapped where mapped = map mapfun workers `using` parlist rdeepseq mapfun = mapper (+) counter counter w = (w,1) workers = chunksof n wl
Tarefa para a casa Implemente os algoritmos em BoW utilizando o conceito de MapReduce.