Investigación 2: MapReduce

CC3008 - Sistemas Operativos Avanzados

Carlos López (08107) y Héctor Hurtarte (08119)
Universidad del Valle de Guatemala
Octubre del 2010

Resumen
MapReduce es un modelo de programación para procesar datos a
larga escala, diseñado para implementarse en sistemas distribuı́dos. Está in-
spirado en las funciones Map y Reduce, he de ahı́ su nombre. El modelo
consiste en:
Una función map
Una función reduce
Paralelizar las tareas y balancear la carga entre nodos, coordinado
por un programa principal (“Programa master”) para procesar los
datos y obtener el resultado esperado.
También incluye mecanismos para tolerar fallas de nodos y también
para evitar que stragglers (nodos que se atrasan en realizar sus tar-
eas) retrasen el resultado.

1 Introducción
La programación funcional nació con el lenguaje Lisp, diseñado por John
McCarthy a finales de los años 50 y basado completamente en el cálculo lamb-
da de Alonzo Church [1]. Durante años, el paradigma de la función funcional
fué puramente académico y en las últimas dos decadas, ha surgido como una
alternativa importante para resolver problemas en la ciencia de la computación.
Una de sus aplicaciones importantes es que si se cumplen ciertas normas –
explicadas más adelante – se puede conseguir aplicaciones thread-safe, es decir,
que threads puedan realizar tareas y comunicarse entre sı́ conrurrentemente
sin que existan problemas de sincronización entre ellos. Esto es un atributo
muy importante que deben mantener los sistemas distribuı́dos ya que en estos
existen diferentes nodos que realizan mini-tareas para realizar una operación
más compleja compartiendo datos y estructuras.

1
 2 Principios básicos de programación funcional y
atributos
2.1 La función Map
La función Map, como su nombre lo dice, mapea elementos de un tipo
hacia otro, tal como una función matemática. Ésta generalmente está definida
sobre listas pero puede actuar sobre otras estructuras e.g. Arreglos, Conjuntos
o Secuencias iterables.
En un lenguaje tipı́ficado, la función Map necesita de:
Una lista de A’s, denotada [A] en donde A es un tipo.
Una función f : A → B

El resultado de ejecutar Map junto con f y [A], es una lista de B’s: [B]. La
firma de esta función es

(A → B) → [A] → [B]

y se lee “Una función que toma una función que toma un A para devolver
un B que luego toma una lista de A’s para devolver una lista de B’s”
Ejemplos:
En ipython:
In [1]: f = lambda x: x + 5 #una funcion que le suma 5 a su
argumento
In [2]: l = [1,2,3,4,5]
In [3]: map(f,l)
Out[3]: [6, 7, 8, 9, 10]
In [4]: f2 = lambda x: x * 2.0 #una funcion que multiplica por 2.0
a su argumento
In [5]: map(f2,l)
Out[5]: [2.0, 4.0, 6.0, 8.0, 10.0]
In [6]: f3 = lambda x: x % 2 #una funcion mod 2
In [7]: map(f3,map(f2,l))
Out[7]: [0.0, 0.0, 0.0, 0.0, 0.0]
In [8]: map(f3,map(f,l))
Out[8]: [0, 1, 0, 1, 0]

2.2 La función Reduce

La función Reduce, también está definida sobre listas y su objetivo es re-
ducir una lista de A0 s a un valor de tipo B.
En un lenguaje tipı́ficado, la función Reduce necesita de:
Al igual que Map, una lista de A0 s para actuar sobre ella: [A].

2
 Una función binaria f : (B, A) → B
El resultado de ejecutar Reduce sobre [A] utilizando f para operar los
resultados de cada operación binaria desde el inicio o fin de la lista de A’s, es
un valor de tipo B. Esta trata de reduci por tuplas con f y siempre empieza
por un lado a transversar la lista (izquierda o derecha).
Ejemplos:
En ipython:
In [1]: f = lambda x,y: x+y #una funcion que suma sus dos
argumentos
In [2]: l = [1,2,3,4,5]
In [3]: reduce(f,l)
Out[3]: 15
In [4]: g = lambda x,y: str(x)+str(y) #una funcion que contatena
dos strings
In [5]: reduce(g,l)
Out[5]: ’12345’
In [6]: h = lambda x,y: x*y #una funcion que multiplica sus dos
argumentos
In [7]: reduce(h,l)
Out[7]: 120

2.3 Programación funcional en un sistema distribuı́do

Habı́amos hablado en la introducción sobre el rol de un lenguaje funcional
en un sistema distribuı́do. En uno de estos lenguajes, las operaciones y sus
resultados están basadas en funciones, contrario a los lenguajes comunes como
Java o C++ en donde uno declara instrucciones en una forma imperativa y estas
son inmediatamente computadas.
Consideremos las siguientes estructuras escritas en Java:
class EjecutorDeTransacciones extends Thread{
void depositar(Cuenta cuenta, int deposito){
cuenta.balanceGeneral += deposito;
}
void descontar(Cuenta cuenta, int descuento){
cuenta.balanceGeneral -= descuento;
}
}

class Cuenta{
public int balanceGeneral;
public Cuenta(int balanceInicial){
this.balanceGeneral = balanceInicial;
}
void depositar(int deposito){
this.balanceGeneral += deposito;

3
 }
void descontar(int descuento){
this.balanceGeneral -= descuento;
}
}

Podemos observar rápidamente que el programa que utilice más de un Eje-

cutorDeTransacciones concurrentemente, tendrá problemas de sincronización
y decimos que el programa tiene efectos secundarios (o side-effects). En una fun-
ción nunca puede haber este tipo de problemas ya que es libre de side-effects:
una función que su valor de retorno dependa únicamente de sus argumentos, no
puede tener problemas de sincronización con otras estructuras o funciones, ya
que sus variables están limitadas a ser utilizadas sólamente por la función que
las necesita, a estas variables les llamamos bounded variables.
En conclusión, las funciones mantienen siempre un estado y donde todas las
variables son inmutables, es decir, que no cambian de valor. Por lo tanto, pen-
sando en thread-safety, podemos decir que la programación funcional promueve
la exclusión mutua en sistemas distribuı́dos.

3 Implementación
Los detalles sobre la implementación del modelo de MapReduce dependen
del entorno. Para el presente trabajo considerese un entorno como el siguiente
[3]:

Muchas computadoras con procesador dual x86, Linux y 2-4 GB de memo-

ria o similar.
Red con conexión de 100 Mbps a 1 Gbps.
Clusters con cientos o miles de computadoras (propenso a fallas).

Filesystem distribuı́do con replicación (GFS).

Usuarios que presentan jobs a calendarizador.

3.1 Ejecución
Las invocaciones de Map se distribuyen entre múltiples equipos particionan-
do automáticamente el input en un conjunto de M splits. Estos splits pueden
ser procesados en paralelo por diferentes equipos. Las invocaciones de Reduce
se distribuyen particionando las llaves intermedias en R trozos usando una fun-
ción de partición. Este es el flujo de una operación de MapReduce en la presente
implementación [3]:

4
1. La librerı́a de MapReduce en el user program primero divide el input en
M trozos de 16 a 64 MB. Luego arranca varias copias del programa en un
cluster de máquinas.
2. Una de las copias del programa se asigna como master y el resto son
trabajadores. Se asignan M tareas map y R tareas reduce. El master escoge
trabajadores inactivos y asigna tareas.
3. Un trabajador a quien se le asigna una tarea map obtiene el contenido
del input split correspondiente. Luego parsea pares llave/valor y los pro-
porciona a la función map definida por el usuario. Los pares intermedios
llave/valor producidos por la función se almacenan en memoria buffer.
4. Periodicamente, los pares en buffer se escriben a discos locales, particiona-
dos en R regiones por una función de partición. La posición de estos pares
luego de moverse a discos locales se envı́an a master.
5. Cuando a un trabajador de reduce se le notifica sobre estas posiciones,
utiliza llamadas a procedimientos remotos para leer esta data. Luego de
leer toda la data intermedia la ordena y agrupa según la llave intermedia.
6. Este trabajador itera sobre la data intermedia ordenada y para cada llave
intermedia única pasa la llave y su correspondiente conjunto de valores
intermedios a la función reduce del usuario. El output se añade al archivo
final de output para esta partición de reduce.

5
 7. Cuando todas las tareas han sido completadas, el master devuelve el con-
trol al user program.

3.2 Estructuras y parámetros

Para cada tarea map y reduce, el proces master almacena el estado de la
tarea (idle, in-progress o completed ) y la identidad de la máquina trabajadora.
El proceso master es el conducto por el que la posición de las regiones de
archivos intermedios se propagan de tareas map a reduce. Por lo tanto, para
cada tarea map completada, el master almacena la posición y tamaño de las R
regiones intermedias producidas por map. Las actualizaciones a estas posiciones
y tamaños se reciben a medida que se completan las tareas map y se añaden
incrementalmente a trabajadores con procesos reduce en estado in-progress.

3.3 Balanceo, granularidad y complejidad

La fase de map se subdivide en M trozos y la de reduce en R. Idealmente M
y R serán mucho más grandes que la cantidad de máquinas disponibles de forma
que muchos trabajdores lleven a cabo muchas tareas diferentes. Esto mejora el
balanceo de carga dinámico dado que cada trabajador tendrá aproximadamente
el mismo número de tareas. De la misma forma, al fallar un trabajador, sus
tareas podrán repartirse mejor entre los demás.
Las limitantes a los tamaños de M y R se establecen dado que el proceso mas-
ter debe efectuar O(M+R) decisiones de calendarización y mantener O(M·R)
estados en memoria. Además de eso, el usuario suele limitar R porque el output
de cada tarea reduce termina en un archivo diferente.
En la práctica M suele elgirse de forma que cada tarea individual sea de
16 a 64 MB de input data y R de forma que sea un múltiplo del número de
trabajadores.

3.4 Tolerancia a fallas

El modelo de MapReduce está diseñado para procesar grandes cantidades
de data en cientos o miles de equipos, por lo que la tolerancia a fallas debe ser
robusta. Se consideran los siguientes casos:
Trabajador: El master hace ping a cada trabajador periódicamente. Si no
se recibe respuesta en cierto tiempo, el master marca al trabajador como
fallido. Cualquier tarea map completada se reinicia dado que su output
está almacenado en discos locales y por tanto es inaccesible. Cualquier
tarea map o reduce en progreso también se reinicia. Cuando una tarea map
pasa de un equipo a otro (por fallo) todos los trabajadores que ejecutan
reduce son notificados e inician a leer data del nuevo map.
La fiabilidad de este sistema se probó extendamente durante una operación
de mantenimiento en un cluster de 1,800 servidores. Se desconectaron

6
 grupos de 80 equipos a la vez. Los procesos corrieron un poco lentos pero
se completaron [6].
Master : El master escribe periódicamente checkpoints a partir de los
cuales es fácil crear una nueva copia en caso que falle. Sin embargo, da-
do que solo hay un master por cada ejecución de MapReduce, es poco
probable que falle; por lo tanto la implementación actual de MapReduce
aborta cuando falla el master. Los clientes pueden revisar esta condición
y reintentar la operación a voluntad.
El proceso confı́a en commits atómicos de los outputs de map y reduce. Cada
tarea en proceso escribe su output a archivos privatos temproales. Una tarea
reduce produce un solo archivo, y una map produce R. Cuando un proceso map
termina, el trabajador envı́a un mensaje al master e incluye el nombre de los R
archivos temporales.
Cuando una tarea reduce se completa, el trabajador automáticamente renom-
bra su archivo temporal de output con el nombre del archivo final. Si la mis-
ma tarea reduce se ejecuta por varias máquinas, se invocaran múltiples renom-
bramientos para el mismo output file. Es por esto que se confı́a en la atomicidad
del proceso de renombrar de parte del sistema operativo.

3.5 Combatiendo stragglers: Tareas de backup

Una de las causas del prolongamiento del tiempo en completar una operación
de MapReduce son los stragglers (rezagados): máquinas a las que les toma una
cantidad inusual de tiempo completar una de las últimas tareas de map o reduce
en la operación. Las causas de los stragglers abarcan, por ejemplo, máquinas
con discos duros defectuosos que presentan errores corregibles pero relentizan
el performance de 30 a 1 MB/s, o bien que el sistema de calendarización del
cluster les imponga otras tareas o incluso que por problemas de inicialización
no tengan habilitada la cache del procesador.
El mecanismo general para atacar este problema involucra que, cuando la
operación MapReduce está por completarse, el master calendariza operaciones
backup de las tareas in-progress. La tarea se marca como finalizada cuando
cualquiera de los trabajadores completa la asignación. El mecanismo se ha afi-
nado de forma que solo consuma más recursos en un bajo porcentaje. Se ha
encontrado que este proceso reduce el tiempo para completar operaciones volu-
minosas. Por ejemplo, al programa de ejemplo de la sección 5.3 de [3] le toma
44 % más tiempo terminar cuando este mecanismo está deshabilitado.

3.6 Aplicaciones
Existe una grande variedad de procesos que se pueden computar con este
modelo, Google ha logrado ponerlo en práctica en los siguientes escenarios:
1. Grep distribuı́do: Analiza un conjunto de archivos en diferentes nodos
junto con una expresión regular y lista los que contengan el patrón. [2]

7
 Función Map: f : (Of f setdelarchivo, linea) → Either[N il, (Linea, 1),
es decir, toma una pareja ordenada (Archivo, linea) y responde con
una lista vacı́a (N il) o una pareja ordenada (linea, 1) si concuerda
con el patrón.
Función Reduce: r : (linea, [1, 1, 1..,1]) → (linea, n) en donde n es la
cantidad de 1’s que aparecen en la entrada de la función
2. PageRank, programa implementado por Google para rankear cualquier
tipo de documentos, principalmente URL’s. [2]
Empieza con un par ordenado (U RL, [U RL]) en donde la llave es una
URL cualquiera y [U RL] es la lista de links contnidas en la llave.
Utiliza una función que mapea a (U RL, (P ageRanking, [U RL2 ]))
Para cada u ∈ [U RL2 ], retorna tanto u, (P R, [U RL2 ) como (u, [U RL4 ]).
La función reduce recibe (U RL, [U RL]) y varios pares de la forma
(U RL, valor) y calcula (U RL, (nuevoP ageRank, [U RL]))

3. Machine Learning
4. Statistical machine translation

Referencias
[1] History of Lisp, John McCarthy, Artificial Intelligenge Laboratory, Stan-
ford University, 12 February 1979, http: // www-formal. stanford. edu/
jmc/ history/ lisp/ lisp. html
[2] Applications of MapReduce, Distributed Computing Systems, CS 4513, De-
partment of Computer Science, Worcester Polythechnic Institute, http: //
web. cs. wpi. edu/ ~ cs4513/ d08/ OtherStuff/ MapReduce-TeamC. ppt
[3] Dean, J. y Ghemawat S. MapReduce: Simplified Data Processing on Large
Clusters. Google, Inc. 2004.
[4] Wikipedia Foundation, Inc. MapReduce. Consultado 8 de Noviembre de
2010. Sitio web: http://en.wikipedia.org/wiki/MapReduce
[5] Bisciglia, C. et al. MapReduce Theory and Implementation. Dis-
tributed computer seminar. Google, Inc. Consultado 8 de Noviem-
bre de 2010. Sitio web: http://code.google.com/edu/submissions/
mapreduce/llm3-mapreduce.ppt

[6] Shankland, S. Google spotlights data center inner working. CNet News.
Consultado 8 de Noviembre de 2010: Sitio web: http://news.cnet.com/
8301-10784_3-9955184-7.html.