Patrones de diseo con MapReduce

Profesor Sourygna Luangsay

1 Trimestre
Curso 2013-2014
Experto en Big Data
Agenda

Introduccin

Indexacin

Sort

Joins

Combiners

Stripe

Frecuencias relativas

NLines

Grafos
Patrones de diseo con !ap"educe
Introduccin
Acerca de los patrones de
diseo

Los patrones de diseo representan una especie de #plantilla$ de

solucin a nivel de diseo de soft%are&

No son un programa' cdigo fuente o e(ecutable

Son m)s abstractos *ue unos algoritmos

Son reutili+ables , flexibles

-nas #best practices$

.esde /001 con el libro #.esign Patterns& 2lements of "eusable

3b(ect43riented Soft%are$ 5escrito por el #gang of four$6

2(emplo de patrn de diseo& la programacin modular7

2(emplo en !ap"educe& el 8ordCount muestra una t9cnica para

sacar estad:sticas , ;acer agrupaciones7

Al final' en !ap"educe la dificultad no es tanto de como usar la API

de <adoop sino m)s bien saber como orientar el problema
Introduccin
Peculiaridades de !ap"educe
El paradigma de MR nos obliga a pensar de una forma distinta y
tiene varias limitaciones:

<a, *ue traba(ar con pares 5=e,'>alues6

2l problema deber ser paraleli+able 5ex& serie de Fibonacci6& no

depender de otro valor precalculados

No debe ;acer una cola de sincroni+acin global7 La ?nica forma de

sincroni+ar los datos es mediante el S;uffle @ Sort7
2sto significa *ue el algoritmo de s;ortest pat; de .i(Astra no se
puede implementar en !ap"educe

No es tiempo real 5sino modo batc;6' no es idneo par 3LBP 5m)s

orientado a 3LAP6

2ntre cada !"' nos obliga a escribir datos intermedios a discos & no
optimi+ado a mac;ine learning
Introduccin
"epaso de conceptos !"
C"ecordamos estos conceptosD Los vamos a necesitar en este
curso777

8ritable

8ritableComparable

Partitioner

Bool"unner

setup56 , cleanup56

Contadores

.istributedCac;e

!ultipleInputs
Introduccin
Patrones de diseo con !ap"educe
Endice inverso
Endice inverso 5I6

!eta& tenemos varios documentos de texto , *ueremos indexar

todas las palabras 5e(& los :ndices *ue aparecen al final de cada
libro67

Por defecto 5formato BextInputFormat6' la Ae, es el offset 5en b,te6

de la l:nea dentro del fic;ero' , el valor es la propia l:nea7
Endice inverso
Endice inverso 5II6

2s posible usar el ob(eto #Context$ para determinar el nombre del

fic;ero

2l pseudo cdigo ser:a&

Endice inverso
map5offset' line6
foreac; %ord in line&
emit5 %ord' nombreFic;ero6
reduce5%ord' IteratorFstringG files6
string fileList H #$
foreac; f in files&
fileList IH f
emit5%ord' fileList6
!ap tasA
5offset/' line/6
5offsetJ' lineJ6
5%ord/' line/6
5%ord/' line/6
"educe
tasA
5%ordK' LlinesM6
5%ordN' LlinesM6
!ap tasA
5offsetK1' lineK16
5offsetKO' lineKO6
5%ordP' line1Q6
5%ordON' line1Q6
"educe
tasA
5%ord1P' LlinesM6
5%ordPN' LlinesM6
!ap tasA
5offsetRP' lineRP6
5offsetR0' lineR06
5%ordON' lineP16
5%ord1' lineRO6
5%ord1P' LlinesM6
5%ordPN' LlinesM6
5%ordK' LlinesM6
5%ordN' LlinesM6
S;uffle
@ sort
Patrones de diseo con !ap"educe
2(ercicios& Endice inverso
Endice inverso
La meta de este e(ercicio es desarrollar un :ndice inverso7 Permite
repasar los conceptos de&

=e,>alueBextInputFormat

3b(eto #Context$

"eferirse al e(ercicio / en el P.F de e(ercicios

2(ercicios& :ndice invertido
Patrones de diseo con !ap"educe
3rdenar datos
2l caso m)s sencillo777

3rdenar es una operacin natural en !"7

.e forma autom)tica en el s;uffle @ sort& el Reducer recibe todas

las llaves de forma ordenadas

2(emplo& un fic;ero de textos' cada l:nea contiene el apellido de una

persona7 Sueremos ordenar los apellidos7

!ap es la funcin #identidad$ sobre el valor&

5A'v6 T 5v'U6

"educe es la funcin identidad&

5A'U6 T 5A'U6
3rdenar datos
V si solo ;a, un reducer 5I6

Supongamos *ue tengamos J reducers con este fic;ero de entrada&

Luangsa,
Conca
>)+*ue+
P9re+
"edondo

Como el particioner por defecto asigna las llaves a un reducer de

forma #aleatora$' las entredas de los reducers 5es decir& las salidas
del partitioner6 podr:an ser&
3rdenar datos
Reducer 1
Luangsa,
P9re+
Reducer 2
Conca
>)+*ue+
"edondo
V si solo ;a, un reducer 5II6

La salida de los J reducers ser:a&

W el resultado ser:a la concatenacin de los J reducers&

Luangsa,
P9re+
Conca
"edondo
>)+*ue+

No est) ordenadoX

Cuanto m)s reducers& peor

3rdenar datos
Reducer 1
Luangsa,
P9re+
Reducer 2
Conca
"edondo
>)+*ue+
Primera solucin posible

-samos un particioner sencillo de tal forma *ue&

si k1 < k2, entonces particin(k1) < particin(k2)

2n el e(emplo anterior' podemos elegir *ue todos los apellidos *ue

empiecen por la letra A ;asta la ! excluida va,an al reducer Q7 2l resto de
los apellidos ir)n al reducer /7

Si tengo 1 reducers' podr:a tener& "Q H LA4<L ' "/HL<4!L ' "JHL!4"L '
"KHL"4YM

Problema& C*u9 pasa si la reparticin de los datos de entrada no es

uniformeD Por e(emplo' en mi e(emplo podr:a tener&
Zlvare+
Abad
Alba
Alon+o
Antonilos
3rdenar datos
.istribuciones non uniformes

Si tenemos 1 reducers' lo idea es *ue cada reducer reciba un JO[

de los datos intermedios' para paraleli+ar lo m)ximo posible la fase
reduce7

Necesitamos un partitioner *ue sepa cuales son los puntos de corte

ptimos para cada particin7

Si la distribucin de las Ae,s es ?niforme& mu, f)cil7

Si la distribucin no es uniforme 5e(emplo& altura de los ;ombres en

2spaa dentro del rango L/'OQ m \ J'JQM 6' es m)s complicado&
3rdenar datos
Segunda solucin& el Botal Sort

Si desconocemos la distribucin de los datos' es necesario ;acer una

primera lectura de los mismos7

2l total sort consta de J fases&

An)lisis de la distribucin de los datos para elegir las particiones

2(ecucin del sort' con un partitioner *ue usa esas particiones

Para la fase de an)lisis' se podr:a leer todos los datos7 Sin embargo' esto
no es mu, eficiente777 5si tenemos *ue ordenar /QB] de datos' tendr:amos
*ue leer J veces /QB]X6

2n ve+ de leer todo' vamos a trabajar sobre una muestra 5sample6 de los
datos7

Idea sub,acente& si mi muestra es buena 5Hsuficiente representativa6' la

distribucin de mi muestra ser) parecida a la distribucin del con(unto de
mis datos7
3rdenar datos
Botal Sort& sampling

InputSampler ofrece varias implementaciones para tener una muestra

de los datos&

"andomSampler& una muestra de entradas al a+ar dentro de unos

splits elegidos al a+ar

SplitSampler& selecciona las primeras entradas de cada split

IntervalSampler& coge / de cada ^ entradas dentro de cada split

2n este e(emplo' cogemos una muestra de KQQQ entradas dentro unos

O splits elegidos al a+ar7 La probabilidad para seleccionar las entradas
es de /[7

2ste cdigo se e(ecuta en el cliente' por eso es bueno limitar el n?mero

de splits por anali+ar 5el cliente tiene *ue descargarlos todos67
3rdenar datos
InputSampler7SamplerFBext' BextG sampler H
ne% InputSampler7"andomSamplerFBext' BextG5Q7Q/' KQQQ' O6_
Botal Sort

Luego' ;a, *ue indicar *ue *ueremos el Botal3rderPartitioner7 W se

e(ecuta #inputSampler7%rite56$ para generar el fichero de particiones

2ste fic;ero de particiones se puede recuperar de la siguiente forma&

Puede ser ?til de recuperar este fic;ero& la prxima ve+ *ue

*ueramos e(ecutar un BotalSort' no ;abr) *ue volver a ;acer el
an)lisis de distribuciones 5suponiendo *ue usemos el mismo n?mero
de reducer , *ue la distribucin no ;a,a cambiado muc;o6

-na ve+ definido el partitioner' el (ob de sort se e(ecuta como antes

3rdenar datos
(ob7setPartitionerClass5Botal3rderPartitioner7class6_
InputSampler7%ritePartitionFile5(ob' sampler6_
Botal3rderPartitioner7getPartitionFile5 (ob7getConfiguration566_
Aplicacin a <]ase 5I6

<]ase es una ]].. NoSSL de tipo =e,'>alue7 2n una tabla' todos

los datos se almacenan de forma ordenada sobre las =e,s7

Adem)s' <]ase es una ]].. distribuida 5/ maestro , varios

esclavos "egionServers67 Cuando una tabla es grande' se divide en
distintos tro+os 5las regiones6 *ue se reparten sobre los distintos
esclavos del cluster 5s;arding67

Por e(emplo' la tabla #Personal$ podr:a estar dividida en 1 regiones&

3rdenar datos
Servidor maestro
4
<]ase master
YooAeeper
/
YooAeeper
J
YooAeeper
K
Servidor esclavo /
<]ase "egionServer
"egion& Noemia 4 Sour,gna
Servidor esclavo J
<]ase "egionServer
"egion& Beofilo 4 Youmana
Servidor esclavo K
<]ase "egionServer
"egion& German 4 !aria
Servidor esclavo 1
<]ase "egionServer
"egion& Alfred 4 Fred
Aplicacin a <]ase 5II6

A veces' en <]ase es necesario ;acer imports masivos de datos7

Se podr:a ;acer un insert 5Put6 por cada una de las entradas *ue
*ueremos aadir' pero no es nada ptimo

2l #]ulA Load$ es una ;erramienta de <]ase *ue permite ;acer inserts

m)sivos&

Prepara todos los datos a insertar , los transforma en el formato

nativo de almacenamiento de <]ase 5<File3utputFormat67

Cada "egionServer carga el fic;ero generado *ue le corresponde

2n la fase de preparacin' es necesario&

3rdenar totalmente todos los datos

Separarlos de tal forma *ue todos las entradas para un mismo

"egionServer est9n agrupadas dentro de un mismo fic;ero <File

Para ello' la ;erramienta #]ulA Load$ usa tambi9n el Botal3rderPartitioner

3rdenar datos
2l secondar, sort 5I6

2l S;uffle @ Sort !" ordena las llaves' pero no los valores7 3rdenar
los valores es un patrn de diseo llamado #secondar, sort$7

2(emplo de aplicacin& el reduce (oin7

2n las siguientes slides' usaremos el siguiente e(emplo& unas

personas , una fec;a *ue indica cuando se conectan al sistema7
Sueremos listar todos los accesos de cada persona por orden
descendente&
3rdenar datos
luangsa, JQ/K/QJO
conca JQ/K/QJO
pere+ JQ/KQ0/J
luangsa, JQ/K/QJ/
pere+ JQ/KQPKQ
luangsa, JQ/KQJKQ
conca JQ/K/QJR
luangsa, JQ/K/QJO
luangsa, JQ/K/QJ/
luangsa, JQ/KQJKQ
conca JQ/K/QJR
conca JQ/K/QJO
pere+ JQ/KQ0/J
pere+ JQ/KQPKQ
2l secondar, sort 5II6

Primero se ordenan , se agrupan las personas& el apellido es la llave #natural$

de nuestro algoritmo7

Como tambi9n se *uiere ordenar por los valores' la ?nica solucin es aadir el
valor 5la fec;a6 a la llave& hacemos una llave compuesta7
Por lo cual' la salida del m9todo map56 ser:a&

La fec;a tiene *ue seguir apareciendo en el valor a pesar de estar en la llave'

por*ue el reducer solo se *uedar) con una llave por cada valor7

Se ;a usado #`$ como car)cter de separacin por*ue los tipos son sencillos7 2n
caso de tipos m)s comple(os podr:a ser necesario escribir una clase propia para
la llave compuesta 5interfa+ ritable!omparable6
3rdenar datos
5luangsa,`JQ/K/QJO'JQ/K/QJO6
5conca`JQ/K/QJO'JQ/K/QJO6
5pere+`JQ/KQ0/J'JQ/KQ0/J6
5luangsa,`JQ/K/QJ/'JQ/K/QJ/6
5pere+`JQ/KQPKQ'JQ/KQPKQ6
5luangsa,`JQ/KQJKQ'JQ/KQJKQ6
5conca`JQ/K/QJR'JQ/K/QJR6
Salida tarea map 1 Salida tarea map 2
2l secondar, sort 5III6

Problema potencial& el particioner va a considerar toda la llave

compuesta para distribuir el espacio de llaves a los reducers7

No *ueremos *ue #luangsa,`JQ/K/QJO$ , #luangsa,`JQ/K/QJ/$

va,an a J reducers distintos

2s necesario escribir un particioner *ue considere solo la llave

natural7

"ecuerdo& en el driver se usa el m9todo "ob#set$artitioner!lass%&

3rdenar datos
5luangsa,`JQ/K/QJO'JQ/K/QJO6
5pere+`JQ/KQ0/J'JQ/KQ0/J6
5luangsa,`JQ/K/QJ/'JQ/K/QJ/6
5pere+`JQ/KQPKQ'JQ/KQPKQ6
5luangsa,`JQ/KQJKQ'JQ/KQJKQ6
Salida tarea map 1 para reducer 1 Salida tarea map 2 para reducer 1
5conca`JQ/K/QJO'JQ/K/QJO6 5conca`JQ/K/QJR'JQ/K/QJR6
Salida tarea map 1 para reducer 2
Salida tarea map 2 para reducer 2
2l secondar, sort 5I>6

La ordenacin de las claves compuestas en la fase S;uffle @ Sort

debe ;acerse con una clase #8ritableComparator$ *ue reali+a lo
siguiente&

Primero se ordena sobre la llave natura& el apellido

Si J llaves compuestas tiene mismo apellido' ordenamos sobre la

fec;a 5por orden descendente6&

2n el driver' se espec:fica este comparator con el m9todo

#"ob#set'ort!omparator!lass%&$
3rdenar datos
5luangsa,`JQ/K/QJO'JQ/K/QJO6
5luangsa,`JQ/K/QJ/'JQ/K/QJ/6
5pere+`JQ/KQ0/J'JQ/KQ0/J6
5luangsa,`JQ/KQJKQ'JQ/KQJKQ6
5pere+`JQ/KQPKQ'JQ/KQPKQ6
Salida tarea map 1 para reducer 1 Salida tarea map 2 para reducer 1
5conca`JQ/K/QJO'JQ/K/QJO6 5conca`JQ/K/QJR'JQ/K/QJR6
Salida tarea map 1 para reducer 2
Salida tarea map 2 para reducer 2
2l secondar, sort 5>6

Luego' en los reducers' los datos de cada particin se vuelven a unir

, a ordenar una ?ltima ve+
3rdenar datos
5luangsa,`JQ/K/QJO'JQ/K/QJO6
5luangsa,`JQ/K/QJ/'JQ/K/QJ/6
5luangsa,`JQ/KQJKQ'JQ/KQJKQ6
5pere+`JQ/KQ0/J'JQ/KQ0/J6
5pere+`JQ/KQPKQ'JQ/KQPKQ6
Entrada del reducer 1
5conca`JQ/K/QJR'JQ/K/QJR6
5conca`JQ/K/QJO'JQ/K/QJO6
Entrada del reducer 2
2l secondar, sort 5>I6

A;ora' las llaves compuestas #luangsa,`JQ/K/QJO$' #luangsa,`JQ/K/QJ/$

, #luangsa,`JQ/KQJKQ$ van a llegar 5en este mismo orden6 al mismo
reducer7

Problema potencial& como son K llaves distintas' por defecto el reducer

tendr:a *ue llamar K veces el m9todo reduce56' una ve+ por cada llave7

Nosotros *ueremos llamar el m9todo reduce56 solo una ve+' , *ue considere
todos los valores de estas K llaves a la ve+& es necesario #agrupar$ las
llaves7

2sto se reali+a con una clase #Grouping Comparator$ 5*ue implementa

tambi9n la interfa+ #8ritableComparator$6 *ue agrupa las llaves compuestas
*ue tienen la misma llave natural 5se usa el m9todo
set(rouping!omparator!lass67

2l resultado de la agrupacin ser:a&

5luangsa,`JQ/K/QJO' LJQ/K/QJO' JQ/K/QJ/' JQ/KQJKQM6

Solo nos *uedamos con la primera llave compuesta7 Por eso era necesario
escribir el valor tanto en la llave compuesta como en el valor7
3rdenar datos
Patrones de diseo con !ap"educe
2(ercicios& ordenar datos
.esarrollar un secondar, sort
La meta de este e(ercicio es poner en pr)ctica el patrn de diseo
secondar, sort *ue acabamos de estudiar7 Nos permite repasar tambi9n
los conceptos de &

Partitioner

8ritableComparable

Comparator

Se trata del e(ercicio J en el P.F de e(ercicios

2(ercicios& ordenar datos
Patrones de diseo con !ap"educe
Los (oins en !ap"educe
-sad <ive o Pig777

La unin de informacin entre J fuentes 5o m)s6 distintas es una

operacin mu, com?n cuando se traba(a con datos7

Con SSL' es una operacin casi #nativa$7

Sin embargo' !ap"educe no es el frame%orA m)s adaptado para

este tipo de operaciones&

Puede ser algo complicado 5sobre todo el #reduce$ (oins6

Significa bastante l:neas de cdigo 5, el n?mero correspondiente

de ;oras en escribirlas7776

V m)s cdigo implica m)s posibilidades de erroresX

Conclusin& me(or no ;acerlo cuando se puede evitar

Para ;acer Joins' Pig o <ive son las ;erramientas adecuadas

Los (oins en !ap"educe
!emor, !ap Joins 5I6
Los (oins en !ap"educe

Se trata del m9todo m)s f)cil de desarrollar7

Considerando J fuentes de datos' se carga en memoria la fuente m)s

pe*uea&

2n el setup56 de la fase !ap' se recupera el fic;ero de esta fuente

5se puede usar la .istributedCac;e para acceder a la informacin6

2l fic;ero se guarda en una estructura <as;!ap' las claves del

<as; siendo las claves *ue se usar)n para el Join7

Se reali+a un (ob cu,o fic;eros de entrada corresponden a la otra

fuente' la m)s grande7 Por cada l:nea de entrada' se reali+a un mapeo
contra el <as;!ap en memoria' usando la clave del (oin7

Si la clave del (oin existe' se emite el resultado del (oin7 Sino' no se

;ace nada7

2l (ob es de tipo !ap43nl,

!emor, !ap Joins 5II6

2sta forma de reali+ar (oins no escala mu, bien& si la fuente de datos

es mu, pe*uea' es posible *ue no *uepa en la memoria de la tarea
map7

-na posible solucin& se divide esta fuente de datos en J 5o m)s6' ,

se reali+an J (obs 5o el n?mero correspondiente67 Luego' ;a, *ue
agrupar los resultados de los distintos (obs 5;aciendo un simple
#move$ de los datos por e(emplo67

2s posible tambi9n ;acer un (oins de K o m)s fuentes7 2n este caso'

se debe siempre cargar las fuentes m)s pe*ueas en memoria7 W la
fuente m)s grande sirven como entrada del (ob7

Bambi9n ;a, *ue controlar los re*uisitos de memoria7

Los (oins en !ap"educe
"educe Joins 5I6

Con el reduce side (oin' se evitan los problemas de memoria7 Por lo

tanto' puede resultar m)s interesante si las J fuentes de informacin
son mu, grandes , si no caben en memoria7

Sin embargo' este diseo usa un (ob !ap"educe' lo cual es menos

ptimo *ue el !ap43nl, del diseo anterior7

2l algoritmo es el siguiente&

Se reali+a la fase map sobre las J fuentes 5usando un

!ultipleInput para tener un cdigo m)s limpio67

Por cada l:nea' se emite 5Ae,' value6' Ae, siendo la clave del (oin ,
value el resto de la l:nea7 Los tipos de datos intermedios deben
ser id9nticos para cada fuente de datos7

2l (oin se reali+a realmente en la fase reduce' por*ue el S;uffle @

Sort ;a agrupado todos los datos usando la clave del (oin7

2l "educe Join es el ?nico *ue soporta INN2"' L2FB , "IG<B (oins7

Los (oins en !ap"educe
"educe Joins 5II6
Los (oins en !ap"educe
/' Almacen "opa' Sevilla' Jorge
J' Almacen "opa' ]arcelona' Luis
K' Almacen Casa' !adrid' Jose
777
Fic;eros de entrada&
JQ/K4QN4//'K'incidencia A
JQ/K4QN4//'J'incidencia C
JQ/K4QN4/J'K'incidencia F
JQ/K4QN4/J'1Q'incidencia C
777
Salida deseada&
JQ/K4QN4//')'incidencia A' Almacen Casa' !adrid' Jose
JQ/K4QN4//'2'incidencia C' Almacen "opa' ]arcelona' Luis
JQ/K4QN4/J')'incidencia F' Almacen Casa' !adrid' Jose
777
"educe Joins 5III6

Los datos intermedios deben tener los mismos tipos&

Para la Ae,' se trata de la clave del (oin7 2n este e(emplo' el I.

del almac9n' un Int8ritable

Para los valores' tenemos *ue unir J tipos de informacin

distinto7 Creamos un ob(eto 8ritable *ue permite unir estos
datos&
Los (oins en !ap"educe
class -nion.atos a
enum Fuente a almacen' incidenciab
Fuente fuente
string tipoAlmacen
string ciudad
string responsable
string fec;a
string tipoIncidencia
b
"educe Joins 5I>6
Los (oins en !ap"educe
mapAlmacen5offset' line6
5id' tipoAlmacen' ciudad' responsable6 H parseLineaAlmacen5 line6
emit5 id' -nion.atos5 almacen* tipoAlmacen' ciudad' responsable66
mapIncidencia5offset' line6
5id' fec;a' tipoIncidencia6 H parseLineaIncidencia5 line6
emit5 id' -nion.atos5 fuente* fec;a' tipoIncidencia66
"educe Joins 5>6
Los (oins en !ap"educe
"educe Joins 5>I6

2l problema de este reducer' es *ue no podemos emitir los

resultados ;asta *ue tengamos la descripcin del almac9n7

2sto nos obliga&

;acer J bucles #for$

almacenar en memoria todas las incidencias

Si ;a, muc;as incidencias' vamos a tener errores #3ut 3f

!emor,$

Para evitar esto' ;abr:a *ue conseguir *ue el primer valor -nion.ata
sea siempre de tipo #almacen$7

Para esto' se reutili+a el patrn de diseo Secondar, Sort

Los (oins en !ap"educe
"educe Joins 5>II6

Se elige la Ae, intermedia siguiente&

Los (oins en !ap"educe
class !,=e, a
boolean esAlmacen
int id
public int compareBo5 !,=e, o6 a
if 5 id XH o7id6
return Integer7compare5 id' o7id6
else
return ]oolean7compare5 esAlmacen' o7esAlmacen6
b
public int ;as;Code56 a
return id
b
b
"educe Joins 5>III6
Los (oins en !ap"educe
class !,=e, a
boolean esAlmacen
int id
public int compare+o% My,ey o& -
if % id ./ o#id&
return 0nteger#compare% id* o#id&
else
return 1oolean#compare% es2lmacen* o#es2lmacen&
3
public int ;as;Code56 a
return id
b
b
Con compareBo56' primero se
ordena sobre las claves naturales
5los I.s67
Luego' nos aseguramos *ue las
descripciones de los almacenes
llega antes de las incidencias7
"educe Joins 5I^6
Los (oins en !ap"educe
class !,=e, a
boolean esAlmacen
int id
public int compareBo5 !,=e, o6 a
if 5 id XH o7id6
return Integer7compare5 id' o7id6
else
return ]oolean7compare5 esAlmacen' o7esAlmacen6
b
public int hash!ode%& -
return id
3
b
Nos aseguramos *ue todos los
valores con la misma clave
natural 5el I.6 va,an al mismo
reducer7
;as;Code56 es una alternativa
en crear un partitioner propio
5recordad como funciona el
partitioner por defectoX6
"educe Joins 5^6
Los (oins en !ap"educe
mapAlmacen5offset' line6
5id' tipoAlmacen' ciudad' responsable6 H parseLineaAlmacen5 line6
My,ey m4 / ne5 My,ey% true* id&
emit5 mA' -nion.atos5 almacen* tipoAlmacen' ciudad' responsable66
mapIncidencia5offset' line6
5id' fec;a' tipoIncidencia6 H parseLineaIncidencia5 line6
My,ey m4 / ne5 My,ey% false* id&
emit5 mA' -nion.atos5 fuente* fec;a' tipoIncidencia66
"educe Joins 5^I6
Los (oins en !ap"educe
"educe Joins 5^II6
Los (oins en !ap"educe
Inner (oin&
"educe Joins 5^III6
Los (oins en !ap"educe
Left (oin&
"educe Joins 5^I>6
Los (oins en !ap"educe
"ig;t (oin&
Partitioned !ap Joins 5I6

Funciona como un (oin #fusin$&

Si las J fuentes de entradas est)n ordenadas sobre la misma clave

de (oin

Si estas fuentes est)n particionadas exactamente de la misma forma

5por e(emplo' los fic;eros #part4QQQQQ$ de las J fuentes contienen
todos los I.s del / al /QQ' los fic;eros #part4QQQQ/$ contienen los I.s
del /Q/ al JQQ' los #part4QQQQJ$ del JQ/ al KQQ7776

2ntonces' cada tarea map puede fusionar f)cilmente la informacin

de un fic;ero part4^ con el fic;ero part4^ de la otra fuente

2ste (oin es bastante efica+& de tipo !ap4onl,

Sin embargo' solo ;a, una fuente *ue puede beneficiar de la localidad
de los datos 5cuidado' los inputSplit tampoco se corresponden mu, bien
con los blo*ues <.FS7776& la segunda fuente se tiene *ue recuperar
desde la red7
Los (oins en !ap"educe
Partitioned !ap Joins 5II6

2ste (ob es idneo si los datos de entrada ,a tienen el formato

descrito anteriormente 5ordenados , particionados67

Puede parecer un re*uisito complicado7 Sin embargo' en <adoop'

muc;as veces los datos *ue se usan vienen de otros (obs7 Por lo
cual' si se ;an aprovec;ado estos (obs para ordenar , particionar
correctamente los datos' cumpliremos con los re*uisitos necesarios
para e(ecutar este tipo de (obs7

La clase CompositeInputFormat ofrece una implementacin para

este tipo de (oins

Cuidado' solo existe en la vie(a API de !ap"educe

5org7apac;e7;adoop7mapred6

Las claves del (oins deben ser las Ae,s de cada fuente de datos7
Los (oins en !ap"educe
Partitioned !ap Joins 5III6

2stas claves son de tipo Bext' por lo cual' si realmente estas claves
representan I.s' es necesario ;acer padding 5para *ue #J$ sea inferior a
#/Q$ por e(emplo6

Los valores de cada fuente deben ser del mismo tipo7

2n el driver tenemos el cdigo&

Para un full outer (oin ;a, *ue poner #outer$ 5en ve+ de #inner$6

Si se usa un fic;ero texto' el formato =e,>alueBextInputFormat nos

permite tener la clave del (oin en la primera columna de los fic;eros7

Luego' podemos tener tantos Pat;s como fuentes de datos *ue

*ueremos cru+ar
Los (oins en !ap"educe
conf7setInputFormat5CompositeInputFormat7class6_
conf7set5cmapred7(oin7exprc' CompositeInputFormat7compose5cinnerc'
=e,>alueBextInputFormat7class' emplo,eePat;' dptPat;66_
Partitioned !ap Joins 5I>6

2l cdigo del mapper ser:a&

La Ae, del map es la clave del (oin

2l Buple #value$ tiene un elemento por cada una de las fuentes *ue se
cru+an7 2n nuestro e(emplo' ;a, J fuentes& primero emplo,eePat; , luego
dptPat;7

Como resultado' devolvemos la unin de estas J fuentes' con la clave del

(oin en prefi(o7

Ben9is el cdigo completo en vuestro %orAspace

Los (oins en !ap"educe
public void map5Bext Ae,' Buple8ritable value'
3utputCollectorFBext' BextG output' "eporter reporter6
t;ro%s I32xception a
String str=e, H Ae,7toString56_
String str2mplo,ee H 55Bext6 value7get5Q667toString56_
left"esult7set5 str=e, I c c I str2mplo,ee6_
output7collect5 left"esult' 5Bext6 value7get5/66_
b
Patrones de diseo con !ap"educe
2(ercicios& el reduce (oin
-nir empleados
La meta de este e(ercicio es practicar el reduce (oin 5opcional& el map
(oin67 Permite repasar los conceptos de&

!ultipleInputFormat

.istributedCac;e 5en el e(ercicio opcional6

"eferirse al e(ercicio K en el P.F de e(ercicios

Para los *ue acaban antes' despu9s de este e(ercicio existe otro
e(ercicio opcional dnde se desarrolla un (ob !ap"educe *ue
contiene a la ve+ unos map (oins , un reduce (oin7 Se trata del
e(ercicio 17
2(ercicios& el reduce (oin
Patrones de diseo con !ap"educe
3ptimi+ando el %ordcount
>ersin b)sica
3ptimi+ando el %ordcount
map5offset' line6
foreac; %ord % in line&
emit5%'/6
reduce5%ord' IteratorFintG values6
sum H Q
foreac; v in values&
sum IH v
emit5%ord' sum6
5/JK' del elefante , el pa,asod6
5/1R' dencuentran el otro elefanted6
5deld' /6 5delefanted' /6 5d,d' /6 5deld' /6 5dpa,asod' /6
5dencuentrand' /6 5deld' /6 5dotrod' /6 5delefanted' /6
Fic;ero de entrada&
Salida del mapper&
5deld' L/' /' /M6 5delefanted' L/' /M6
5dencuentrand' L/M6 5dotrod' L/M6
5dpa,asod' L/M6 5d,d' L/M6
2ntrada del reducer&
Con un combiner

Con un combiner' es posible reducir el tamao de los datos

intermedios *ue se pasan en el S;uffle @ Sort&

!enos I3 a los discos

!enos tr)fico de red

2l problema del combiner' es *ue no ;a, control sobre su e(ecucin&

se puede e(ecutar / ve+' J veces o m)s pero no podemos decidir
cuantas veces exactamente7
3ptimi+ando el %ordcount
mapper combiner reducer
5deld' L/' 266 5delefanted' L/' /M6
5dencuentrand' L/M6 5dotrod' L/M6
5dpa,asod' L/M6 5d,d' L/M6
2ntrada posible del reducer&
In mapper4combining 5I6

-na idea para controlar me(or las agregaciones locales en la fase

map es implement)ndolas directamente en la clase #mapper$7

Por e(emplo' una primera idea es consolidar los emit de cada

l:neaeinvocacin del m9todo map56&
3ptimi+ando el %ordcount
map5offset' line6
< H ne% <as;!ap
foreac; %ord % in line&
<5%6 II
Foreac; Ae, in <&
emit5Ae,' <5Ae,66
5delefanted' /6 5d,d' /6 %7el7* 2& 5dpa,asod' /6
5dencuentrand' /6 5deld' /6 5dotrod' /6 5delefanted' /6
Salida del mapper&
In mapper4combining 5II6

2n el in mapper4combining' se consolidan los emits al final de cada

tarea mapepor cada inputsplit&
3ptimi+ando el %ordcount
!lass Mapper
Method initiali+e56
< H ne% <as;!ap
Method map5offset' line6
< H ne% <as;!ap
foreac; %ord % in line&
<5%6 II
Method close56
Foreac; Ae, in <&
emit5Ae,' <5Ae,66
%7elefante7* 2& 5d,d' /6 %7el7* )& 5dpa,asod' /6
5dencuentrand' /65dotrod' /6
Salida del mapper&
In mapper4combining 5III6

2ste patrn de diseo ofrece m?ltiples venta(as&

Se controla totalmente su e(ecucin' al contrario del combiner

La agregacin local en cada tarea map puede ser ptima 5si cabe en
memoria7776

Como se reali+an menos emit56 , no se tiene *ue pasar el

#mini4reducer$ 5Hcombiner6' no se crean tantos ob(etos (ava ni se tiene
*ue reali+ar tantas operaciones de seriali+acinedeseriali+acin

Las palabras *ue aparecen muc;asedemasiadas veces 5e(emplo& #el$'

#un$' #una$7776 ,a no generan #dese*uilibro$ en los reducers' ,a *ue la
consolidacin se distribu,e en cada tarea map en ve+ de una ?nica
tarea reduce7

<a, *ue tener cuidado con la gestin de memoria& todos los datos
intermedios se guardan en un ?nico <as;!ap *ue se libera solo al final del
inputsplit7 Sin embargo' teniendo en cuenta *ue un blo*ue <.FS es
N1!]e/JP!]' podemos imaginar *ue los datos intermedios *uepan en un
;eap de /G]4JG] 5a no ser *ue se ;aga un producto cartesiano77767
3ptimi+ando el %ordcount
C)lculo de medias con combiner

Para usar el combiner' la operacin del reducer debe ser asociativa ,

conmutativa

2n el %ordcount' tenemos una #suma$& 3=

La divisin 5para la media6 no es asociativa& por defecto no se puede

usar ning?n reducer7

Solucin& transformar el algoritmo en una operacin asociativa7

2(emplo& mi empresa vende varios productos7 Cada ve+ *ue se

vende un producto se guarda este dato en un registro' con el margen
asociado a esta venta7 Se *uiere calcular el margen medio de cada
producto7
3ptimi+ando el %ordcount
JQ/K4QR4J1 ProductoA O17QQ
JQ/K4Q04/J ProductoC J//7JQ
JQ/K4Q04/P Producto< /K71Q
777
C)lculo de medias con combiner
3ptimi+ando el %ordcount
map5offset' line6
emit5articulo' IntPair5margen'/66
combiner5articulo' IteratorFIntPairG paares6
total!argen H Q
totalApariciones H Q
foreac; 5margen'numero.eApariciones6 in paares&
total!argen IH margen
totalApariciones IH numero.eApariciones
emit5articulo' IntPair5margen'/66
reducer5articulo' IteratorFIntPairG paares6
total!argen H Q
totalApariciones H Q
foreac; 5margen'numero.eApariciones6 in paares&
total!argen IH margen
totalApariciones IH numero.eApariciones
emit5articulo' total!argen e total!argen6
Contadores , map4onl,

'i la cantidad de palabras posibles es pe8ue9a 5unas centenas

como muc;o6' se puede optimi+ar a?n m)s

A cada palabra se asocia un contador7 Cada ve+ *ue se encuentra

una palabra' se incrementa de / el correspondiente contador7

Boda la consolidacin 5la suma6 se ;ace en el (obtracAer , se puede

recuperar desde el driver' al finali+ar el (ob7

.e esta forma' podemos e(ecutar un (ob map4onl,7

-n (ob map4onl, suele ser muc;o m)s r)pido 5, consume menos

recursos6 *ue un (ob map4reduce&

No se e(ecuta ning?n reducer

No se reali+a un S;uffle @ Sort

3ptimi+ando el %ordcount
Patrones de diseo con !ap"educe
Pairs @ Stripes
!atri+ de coocurrencia

"ecordad& una matri+ de coocurrencia representa el n?mero de

veces *ue un elemento A aparece al mismo tiempo *ue un elemento
]7

2(emplo& 55Neutrex'Ariel6' ON6 _ ON personas *ue ;an comprado

Neutrex tambi9n ;an comprado Ariel' , viceversa

2n este e(emplo' #Neutrex$ ser:a una fila de la matri+ , #Ariel$ una

columna7

2s decir' se ;a usado una representacin por pares7 Para

representar toda la matri+ de n art:culos' es necesario n x n pares 5o
la mitad67

3tra representacin posible es por fran(a& representamos toda una

l:nea de un golpe&
5Neutrex' 5Ariel' ON6' 5=leenex' /JK6' 5Colgate' J16 7776
Pairs @ Stripes
Calculo de coocurrencia
Pairs @ Stripes
map5offset' line6
foreac; art % in compra&
foreac; otro in restoCompra&
emit5 5art'otro6'/6
reduce5par' IteratorFintG values6
sum H Q
foreac; v in values&
sum IH v
emit5par' sum6
Con pares&
map5offset' line6
foreac; art % in compra&
< H ne% <as;!ap
foreac; otro in restoCompra&
<5otro6II
emit5 art' <6
reduce5art' IteratorF;as;G fran(as6
< H ne% <as;!ap
foreac; <i in fran(as&
suma5<' <i6
emit5art' <6
Con fran(as&
>enta(as de fran(as
2l patrn de diseo de fran(as ofrece varias venta(as&

Con el patrn de diseo de pares' se repite varias veces el primer

elemento del par&
55:eutre;' Ariel6' ON6' 55:eutre;'=leenex6' /JK6' 55:eutre;'Colgate6' J16 V
2sta repeticin se evita con el modelo de fran(as7

Se generan menos llaves intermedias& si la matri+ de coocurrencias

es de rango N x N' se generan N Ae,s intermedias7 2n caso del
diseo por pares' se pueden generar ;asta N x N Ae,s intermedias7

Al tener menos Ae,s intermedias' las posibilidades de agregacin

locales 5combiners6 son ma,ores

Como consecuencia' los algoritmos basados en fran(as suelen ser

m)s r)pidos

2l problema del modelo de fran(as& los <as;es tienen *ue caber en

memoria777
Pairs @ Stripes
Patrones de diseo con !ap"educe
Inversin del orden
Frecuencias relativas

2l algoritmo de coocurrencias anterior nos da valores absolutos7

2l problema de este algoritmo' es *ue no toma en cuenta *ue algunos

elementos pueden aparecer muc;as m)s veces *ue el resto de
elementos' resultando en valores de coocurrencias no mu,
representativos7

Por e(emplo' cuando calculamos la matrix de coocurrencias de las

palabras dentro de varios textos en ingl9s' la palabra #t;e$ aparecer)
muc;:simas veces7 Como consecuencia' la coocurrencia C5#t;e$'
#<adoop$6 ser:a muc;o ma,or *ue la de C5#<adoop$' #!ap"educe$67

Por eso' nos interesa m)s calcular la frecuencia relativa&

F5 i f A6 H C5i ' A6 e 5 S-!Ao C5 A' o6 6

Llamemos #marginal$ el denominador 5la suma de las coocurencias de

A6
Inversin del orden
Frecuencias relativas con stripes

2s mu, f)cil adaptar el algoritmo de coocurencias con stripes para

calcular las frecuencias relativas&
2(emplo& 5Neutrex' L5Ariel' ON6' 5=leenex' /JK6' 5Colgate' J16 777M6

2l inconveniente de este algoritmo es el de siempre& < puede ser mu,

grande , esto genera un 33!7

Para evitar estos errores' se puede volver a un modelo por pares

Inversin del orden
reduce5art' IteratorF;as;G fran(as6
< H ne% <as;!ap
marginal H Q
foreac; <i in fran(as&
suma5<' <i6
foreac; elem in <&
marginal IH <5elem6
foreac; elem in <&
<5elem6 H <5elem6 e marginal
emit5art' <6
Frecuencias rel7 con pares 5I6

2l c)lculo de la coocurrencia por pares era&

Con este algoritmo' por defecto no es posible calcular la marginal

por*ue el reducer solo recibe como llave un par de elementos 5I' .6

Idea& cambiar el particioner para *ue todos las pares con el mismo
elemento #I$ va,an al mismo reducer7

Bambi9n podr:amos usar el #Grouping Comparator$ para *ue todas las

pares con I apare+can en una misma invocacin del m9todo reduce56

Ser:a algo parecido al secundar, sort pero sin usar el m9todo

setSortComparatorClass56
Inversin del orden
map5offset' line6
foreac; art % in compra&
foreac; otro in restoCompra&
emit5 5art'otro6'/6
reduce5par' IteratorFintG values6
sum H Q
foreac; v in values&
sum IH v
emit5par' sum6
Frecuencias rel7 con pares 5II6

2l c)lculo de la coocurrencia por pares era&

Problema& el mismo *ue con el algoritmo *ue usa las stripes& el

<as;!ap puede ser mu, grande , superar el <eap de las tareas
reduce7
Inversin del orden
map5offset' line6
foreac; art % in compra&
foreac; otro in restoCompra&
emit5 5art'otro6' 5otro' /66
reduce5par' IteratorFParG values6
< H ne% <as;!ap
marginal H Q
foreac; 5elem' count6 in values&
<5elem6 IH count
marginal IH count
foreac; elem in <&
emit5 5par7i+*uierda' elem6'
<5elem6emarginal6
Frecuencias rel7 con pares 5III6

Para evitar este problema' ;abr:a *ue tener calculado la marginal al

principio del reducer

Para esto' vamos a emitir una clave #especial$ en el mapper7 2sta

clave nos servir) para calcular la marginal&

.e la misma forma *ue antes' se escribe un particioner para *ue

todas las claves con el mismo elemento i+*uierdo del par 5art' otro6
va,an al mismo reducer

Sin embargo' no se utili+a el #Grouping Comparator$777

Sino *ue usamos setSortComparatorClass56 para la clave *ue

contiene #g$ apare+ca primero
Inversin del orden
map5offset' line6
foreac; art % in compra&
foreac; otro in restoCompra&
emit% %art*<&* 1&
emit5 5art'otro6' /6
Frecuencias rel7 con pares 5I>6

2sto es un e(emplo de los datos *ue podr:a recibir un reducer&

Cuando se recibe el par #especial$ 5dNeutrexd' g6' sabemos *ue el

reducer no ;a recibido ning?n otro par 5dNeutrexd' V6 antes7
Inversin del orden
5dNeutrexd' g6 L/O' J/0' J' OK' N' V M
5dNeutrexd' dArield6 L1' JNM
5dNeutrexd' dColgated6 LK' /M
5dNeutrexd' d=leenexd6 LRP' K/' K' RJM
5dNexd' dgd6 LRP' K/' K' RJM
int marginal
reduce5par' IteratorFintG values6
sum H Q
foreac; i in values
sum IH i
if par7derec;a H dgd
marginal H sum
else
emit5 par' sum e marginal6
La marginal se calcula
f)cilmente , se guarda
como una variable global
del reducer
Frecuencias rel7 con pares 5>6

2ste patrn de diseo se llama #inversin del orden$& conseguimos

conocer el resultado de una computacin 5la marginal6 antes de
procesar los datos *ue vamos a procesar7

Con este patrn' los re*uisitos de memoria en el reducer son

m:nimos

Se debe aprovec;ar los combinersein mapper combiners para

agregar cuanto antes los resultados *ue se presentan al reducers'
sobre todo en el caso del par #especial$7
Inversin del orden
Patrones de diseo con !ap"educe
NLines , computacin
NLine

Normalmente una tarea map recibe muc;os datos 5N1!]' /JP!]7776 *ue
tratar

2l n?mero de l:neas dentro de cada inputSplit est) indeterminado7

A veces' puede ser interesante controlar el n?mero de l:neas *ue recibe

cada tarea map7

Con el #NlineInputFormat$' se puede seleccionar el n?mero de l:neas *ue

recibir) cada tarea7

Por e(emplo' con el par)metro

#mapreduce7input7lineinputformat7linespermap$ a J 5por defecto& /6' se
recibir)n las l:neas de J en J&

-na tarea map recibir) las l:neas / , J del fic;ero de entrada

3tra tarea las l:neas K , 1

777
NLines , cumputacin
Parameter s%eep

NLine no suele usarse muc;o en <adoop& es me(or de(ar *ue una misma
tarea traba(e con muc;os datos 5debido al over;ead de arrancareparar una
tarea67

Su utilidad se demuestra cuando una l:nea de entrada genera muc;o

cmputo de CP-7

Por e(emplo' para ;acer simulaciones de modelos matem)ticos&

Simular un modelo re*uiere muc;o tiempoeciclos de CP-

Con !" podemos paraleli+ar las simulaciones de este modelo

Cada simulacin tiene el mismo modelo pero unos par)metros distintos

2ntrada de los !aps& / ?nico fic;ero con varias l:neas7 Cada l:nea
contiene los par)metros para / simulacin

.e(amos #mapreduce7input7lineinputformat7linespermap$ a / para *ue

una tarea map ;aga una ?nica simulacin

Job !ap43nl,
NLines , cumputacin
Generacin de datos

Problema *ue tuvimos en Pragsis

Sueremos generar muc;os datos de prueba en un cluster <.FS

2stos datos se repartir)n sobre J1 meses& tenemos *ue generar

unos datos para cada mes7 Los datos *ue generaremos para cada
mes ser)n distintos 5por e(emplo' el campo #fec;a$ no ser) el mismo6

2s un problema *ue&

Genera muc;os datos

-sa una generacin de n?meros aleatorios' lo cual ;ace el

algoritmo m)s lento

Idea&

-sar Nline

-n fic;ero de entrada de J1 l:neas& / por cada mes

NLines , cumputacin
Patrones de diseo con !ap"educe
2(ercicios& NLine
Inversin de matrices
La meta de este e(ercicio es simular la paraleli+acin de c)lculos
comple(os v:a !ap"educe7 2n nuestro caso' el c)lculo #comple(o$ ser)
la inversin de una matri+7

"eferirse al e(ercicio O en el P.F de e(ercicios

2(ercicios& NLine
Patrones de diseo con !ap"educe
Grafos
Grafos en ]ig .ata

-n grafo es b)sicamente un con(unto de&

Nodos

L:neaseconexiones

Luego' existen muc;os subtipos de grafos& dirigidos o no' c:clicos o

ac:clicos' con pesos777

2l mundo est) lleno de grafosX

FacebooA' LinAedin' B%itter 5Social Net%orA Anal,sis6

Aeropuertos , l:neas abiertas

"edes de ordenadores

La primera aplicacin #]ig .ata$ 5D6& 888

Grafos
Por *u9 estudiar los grafosD

Google !aps& descubrir el camino m)s r)pido entre J sitios

!inimi+ar el despliegue de una infraestructura de l:neas telefnicas

Conocer a los amigos de tus clientes&

.etectar las personas m)s influ,entes

2nviarles regalos , promociones para *ue ;ablen bien de ti

2vitar el #c;urn viral$

Controlar la difusin de epidemias

Grafos
Grafos , !ap"educe

-n algoritmo de grafo generalmente implica&

"eali+ar un procesamiento en cada nodo

Atravesar el grafo de una determinada manera

2sto implica J problemas

Cmo representar los grafos en !ap"educeD

Cmo atravesar un grafo en !ap"educeD

Grafos
"epresentacin de grafos 5I6

La representaci=n matricial es la m)s f)cil de entender , de usar&

>enta(as& tenemos tanto los #outlinAs$ 5l:neas6 como los #inlinAs$

5columnas67
Por e(emplo' se ve mu, f)cilmente en la !atri+ *ue N/ no recibe ning?n
enlace entrante

Problemas& ;a, muc;os #+eros$ 5m)s a?n en la vida real777 Aun*ue una
persona tenga muc;os contactos en FacebooA' solo ser) una pe*uea
proporcin de todos los usuarios de F]6& muc;o espacio 5,
computacin7776 para nada7
Grafos
:1 :2 :) :>
:1 Q / / Q
:2 Q Q Q /
:) Q / Q Q
:> Q Q / Q
"epresentacin de grafos 5II6

2n ve+ de una matri+ de ad,acencia' se puede usar una

representacin por listas&

>enta(as&

"epresentacin compacta , divisible

C)lculo de los outlinAs f)cil

Problemas& es dif:cil calcular los inlinAs 5;abr:a *ue #invertir$ las listas6
Grafos
:1 :2 :) :>
:1 Q / / Q
:2 Q Q Q /
:) Q / Q Q
:> Q Q / Q
N/& NJ'NK
NJ& N1
NK& NJ
N1& NK
Problema del S;ortest Pat;

2l camino #m)s corto$ es un problema mu, t:pico de los grafos

CCual es el camino m)s corto entre un nodo de origen A , un

nodo de destino ]D

-n algoritmo mu, famoso *ue lo soluciona es el de .i(Astra

;ttp&eeen7%iAipedia7orge%iAie.i(Astra[JRsUalgorit;m

Problema del algoritmo&

-sa una cola global de #prioridades$ ordenadas sobre la

distancia actual

<adoop no permite mantener un estado global entre varias tareas

*ue funcionan en paralelo de manera independente

2l algoritmo de .i(Astra no se puede e(ecutar en !ap"educeX

Grafos
Parallel ]readt;4First Searc; 5I6

Se trata de un algoritmo alternativo *ue permite contestar al problema

del S;ortest Pat;&

No tan eficiente como el de .i(Astra

Pero se puede paraleli+ar con !ap"educeX

2l algoritmo se puede resumir as:&

Iniciali+acin&

.istanceHQ al nodo de origen

.istanceH infinito para el resto de los otros nodos

Al todos los vecinos del nodo de origen' se estable #distanciaH/$

Si un nodo es alcan+able 5distancia XH infinito6 , su distancia es

#d$' entonces todos su vecinos tendr)n como distancia&
min5distancia.e2ste>ecino' d I /6
Grafos
Parallel ]readt;4First Searc; 5II6

Grafos
Q
inf
inf
inf inf
inf
/& iniciali+acin
Q
/
/
inf inf
inf
J& vecinos del
origen
inf
inf
Parallel ]readt;4First Searc; 5III6

Grafos
Q
/
/
J J
J
K
inf
Q
/
/
J J
J
1& fin
K
Parallel ]readt;4First Searc; 5I>6

2ste algoritmo nos debe permitir conocer la distancia de cada nodo

respecto al origen&

Los nodos van a ser las =e,s de nuestro !"

La distancia va a ser el >alor

Cada nodo necesita tambi9n conocer a sus vecinos& est)

informacin tambi9n debe aparecer como >alor

Por lo tanto&

La =e, ser) un Long8ritable *ue representa el I. del nodo

2l >alor ser) un ob(eto propio *ue puede tener J tipos 5usamos

un ]oolean para distinguir el tipo6&

-n Int8ritable *ue representa la distancia

-na Arra,8ritable de Long8ritable *ue representa la lista de

ad,acencia
Grafos
Parallel ]readt;4First Searc; 5>6

2l !apper&

"ecibe el 0? del nodo' su distancia actual d' la lista de los

vecinos

Primero' el nodo emite su lista de vecino , su distancia&

emit5I.' 5d'Lista>ecinos66

Por*ue necesitamos *ue esta informacin se preserve en el

reducer

Si su distancia es infinita' no ;ace nada m)s

Sino' para cada nodo @ de los vecinos se emite una posible

distancia&

emit5>' d I /6
Grafos
Parallel ]readt;4First Searc; 5>I6

2l "educer&

"ecibe 5I.' Lista5 lista>ecinos' distancia/' distanciaJ' distanciaK'

V6

2lige la distancia m:nima 5si la lista de distancias est) vac:a'

entonces la distancia m:nima es #infinito$6 , emite&

2mit5 I.' Fdistancia' lista>ecinosG6

2stos #emit$ se guardan a <.FS , sirven como entrada para

la prxima iteracin
Grafos
Parallel ]readt;4First Searc; 5>II6

Grafos
/& Q
J& inf
K& inf
1& inf O& inf
N& inf
/& iniciali+acin
R& inf
Fic;ero de entrada en <.FS&
/ Q' 5J'K6
J inf' 5/'1'O6
K inf' 5/'N6
1 inf' 5J6
O inf' 5J'N6
N inf' 5O'R6
R inf' 5N6
Parallel ]readt;4First Searc; 5>III6

Grafos
/& Q
J& inf
K& inf
1& inf O& inf
N& inf
/& !apper
R& inf
Fic;ero de entrada en <.FS&
/ Q' 5J'K6
J inf' 5/'1'O6
K inf' 5/'N6
1 inf' 5J6
O inf' 5J'N6
N inf' 5O'R6
R inf' 5N6
2l nodo / emite&
5/' FQ' 5J'K6G6
5J' /6
5K'/6
2l nodo J solo emite 5su distancia
est) a #infinito$6&
5J' Finf' 5/'1'O6G
2tc777
Parallel ]readt;4First Searc; 5>III6

Grafos
/& Q
J& inf
K& inf
1& inf O& inf
N& inf
/& "educer
R& inf
Fic;ero de entrada en <.FS&
/ Q' 5J'K6
J inf' 5/'1'O6
K inf' 5/'N6
1 inf' 5J6
O inf' 5J'N6
N inf' 5O'R6
R inf' 5N6
Para el nodo / recibimos&
5/' 5FQ' 5J'K6G6
W emitimos lo mismo
Para el nodo J recibimos&
5J' 5/' Finf' 5/'1'O6G6
W por lo tanto emitimos&
5J' F/' 5/'1'O6G6
2tc777
Parallel ]readt;4First Searc; 5I^6

Grafos
/& Q
J& /
K& /
1& inf O& inf
N& inf
J& antes
R& inf
Fic;ero de entrada en <.FS&
/ Q' 5J'K6
J /' 5/'1'O6
K /' 5/'N6
1 inf' 5J6
O inf' 5J'N6
N inf' 5O'R6
R inf' 5N6
Parallel ]readt;4First Searc; 5^6

Grafos
/& Q
J& /
K& /
1& inf O& inf
N& inf
J& !apper
R& inf
Fic;ero de entrada en <.FS&
/ Q' 5J'K6
J /' 5/'1'O6
K /' 5/'N6
1 inf' 5J6
O inf' 5J'N6
N inf' 5O'R6
R inf' 5N6
2l nodo / emite lo mismo *ue en
el !" /
2l nodo J emite
5J' F/' 5/'1'O6G6
5/' J6
51' J6
5O' J6
2tc777
Parallel ]readt;4First Searc; 5^I6

2l algoritmo es un bucle #for$&

Cada iteracin en un (ob !" *ue nos acerca de la solucin

5suele ser as: para todos los algoritmos con grafos7776

2s el driver *ue controla el bucle #for$

2ntre cada (ob !"' los resultados obtenidos se tienen *ue

almacenar en <.FS 5no mu, efica+777 usad la compresinX6

Cuando parar el bucle #for$D

-sar los contadores

Cada ve+ *ue en el reducer se emite un nodo cu,a distancia no

es #infinito$' incrementamos el contador de /

Cuando el contador es igual al n?mero de nodos en el grafo'

paramos el algoritmo
Grafos
Patrones de diseo con !ap"educe
2(ercicios& Grafos
Parallel ]readt;4First Searc;
La meta de este e(ercicio es desarrollar nuestro primer algoritmo !" de
grafos7 2ste e(ercicio permite repasar los conceptos de&

contadores

"eferirse al e(ercicio N en el P.F de e(ercicios

2(ercicios& Grafos