Está en la página 1de 63

UNIVERSIDAD TECNOLGICA DE PANAM

FACULTAD DE INGENIERA DE SISTEMAS COMPUTACIONALES

PROGRAMACIN PARALELA Y CONCURRENTE CON HASKELL

ASESOR: DOCTOR MIGUEL VARGAS LOMBARDO

INTEGRANTE: ALLEYNE THOMPSON HUFFMAN

TRABAJO DE GRADUACIN PARA OPTAR AL TTULO


DE MAESTRA EN INGENIERA DE SOFTWARE APLICADA

2014

AGRADECIMIENTO

Deseo agradecer a Dios, por darme las fuerzas necesarias para culminar con xito este
significativo trabajo, el cual me colma de satisfaccin personal, producto del constante
esfuerzo por superar las dificultades que se nos presentaron durante el desarrollo de este.

Quiero expresar mi ms profundo agradecimiento al Dr. Miguel Vargas Lombardo, quien


ha compartido con nosotros sus conocimientos y experiencias durante todo el tiempo de
elaboracin de esta monografa.

Finalmente, deseo extender mi agradecimiento a todas aquellas personas que de una u


otra forma me apoyaron y alentaron a continuar trabajando para finalizar esta
investigacin.

ii

DEDICATORIA

Agradezco infinitamente a Dios, por haberme guiado durante mis estudios de maestra y
en la culminacin de este trabajo, el cual dedico de todo corazn a mi esposo Nicanor;
quien con su amor incondicional me brind su apoyo en todo momento, atendiendo
nuestro hogar y a nuestros hijos en los momentos ms difciles.

Extiendo mi dedicatoria tambin a mis hijos Harold y Harith, quienes siempre esperaron
pacientemente la culminacin de esta monografa, renunciando en ocasiones a parte del
tiempo que usualmente compartamos en familia.

A mi madre Bella, familiares y amigos en, sobre todo a Germn; y a las personas que de
alguna forma contribuyeron con mis estudios, muchas gracias.

iii

NDICE GENERAL
AGRADECIMIENTO ........................................................................................................ ii
DEDICATORIA ................................................................................................................ iii
NDICE DE ILUSTRACIONES ....................................................................................... vi
RESUMEN DESCRIPTIVO ........................................................................................... viii
INTRODUCCIN .............................................................................................................. x
CAPTULO I ...................................................................................................................... 1
1.1.

HIPTESIS ...................................................................................................... 1

1.2.

OBJETIVO GENERAL ................................................................................... 1

1.2.1. OBJETIVOS ESPECFICOS ........................................................................... 1


CAPTULO II ..................................................................................................................... 2
2.1.

ESTADO DEL ARTE ...................................................................................... 2

2.1.1. Paralelismo vs. Concurrencia........................................................................... 6


2.1.2. Programacin Paralela con Haskell ................................................................. 7
2.1.2.1. Paralelismo Bsico: La monada Eval ........................................................ 8
2.1.2.2. Estrategias de Evaluacin .......................................................................... 8
2.1.2.3. MapReduce .............................................................................................. 10
2.1.2.4. Paralelismo de Flujo de Datos (Dataflow Parallelism) ............................ 10
2.1.2.5. Programacin de Datos Paralelos con Repa ............................................ 10
iv

2.1.2.6. Paralelismo con datos anidados (Nested data) ......................................... 12


2.1.3. Programacin concurrente con Haskell .......................................................... 13
2.1.3.1. Concurrencia Bsica: MVar y Threads (hilos) ........................................ 14
CAPTULO III .................................................................................................................. 16
3.1.

CASOS

DE

ESTUDIO

DE

PROGRAMACIN

PARALELA

CONCURRENTE CON HASKELL ......................................................................... 16


3.1.1. Proyecto Haxl en Facebook ............................................................................ 16
3.1.2. IMVU, Inc. ...................................................................................................... 18
3.1.3. Barclays Capital Quantitative Analytics Group .............................................. 19
3.1.4. Parallel Scientific, Boulder, Colorado ............................................................ 24
3.1.5. Aetion Technologies LLC, Columbus, Ohio .................................................. 25
3.1.6. Eaton Cleveland, Ohio .................................................................................... 26
3.1.7. The Big Board: Teleconferencing over High-res Maps con Haskell .............. 28
3.1.8. Google ............................................................................................................. 31
3.1.9. New York Times ............................................................................................. 32
3.1.10. Humane Software.......................................................................................... 35
CAPTULO IV.................................................................................................................. 36
4.1. IMPLEMENTACIN Y PRUEBAS DE HASKELL PARALELO A TRAVS
DE UN CDIGO DE EJEMPLO ............................................................................. 36
CAPTULO V ................................................................................................................... 45
v

5.1. CONCLUSIONES ................................................................................................. 45


BIBLIOGRAFA Y REFERENCIAS............................................................................... 50

NDICE DE ILUSTRACIONES
Figura 1. Arquitectura de Haskell ....................................................................................... 4
Figura 2. Funcionamiento de Kernel en su gestin y comunicacin de los recursos del
sistema que asiste ............................................................................................................... 4
Figura 3. Ejemplo de Estructura de Mdulo en Haskell ..................................................... 5
Figura 4. Captura de pantalla del compilador GHC para Windows. .................................. 5
Figura 5. Ejemplo de rpar/rseq ........................................................................................... 8
Figura 6. Proyecto Haxl de Facebook ............................................................................... 17
Figura 7. Pgina principal del sitio web http://es.imvu.com/ ........................................... 18
Figura 8. Herramientas exticas para Operaciones exticas ........................................... 20
Figura 9. Proyecto Functional Payout Framework de Barclays ....................................... 23
Figura 10. Logo de la Compaa Parallel Scientific ........................................................ 24
Figura 11. http://www.taglianirepuestos.com.ar/imagenes/genericas/foto_eaton.png ..... 26
Figura 12. Big Board con contenido en Firefox .............................................................. 30
Figura 13. Huellas digitales en el contexto de Fashion Week (Semana de la Moda) ....... 32
Figura 14. Pasos para obtener la huella digital (recortar, dividir y obtener modelo) ....... 33
vi

Figura 15. Pasos para obtener la huella digital (elegir tira, promediar los colores) ......... 33
Figura 16. Huellas digitales futuras .................................................................................. 34
Figura 17. Ejecucin de mdulo GHC.Conc desde un compilador Haskell Online ......... 36
Figura 18. Ejecucin de mdulo GHC.Conc desde un compilador GHC Ubuntu ........... 37
Figura 19. Cdigo Paralelo Fib,hs .................................................................................... 37
Figura 20. Instalacin de librera paralela, compilacin y ejecucin de programa Fib.hs
con 2 cores ........................................................................................................................ 38
Figura 21. Cdigo Sorting.hs (Sort Secuencial) ............................................................... 39
Figura 22. Cdigo SortMain.hs ......................................................................................... 40
Figura 23. Compilacin y ejecucin del programa Sort Secuencial ................................. 40
Figura 24. Cdigo Sorting.hs (parSort)............................................................................. 41
Figura 25. Compilacin y ejecucin del programa parSort .............................................. 41
Figura 26. Cdigo Sorting.hs (seqSort) ............................................................................ 42
Figura 27. Compilacin y ejecucin de la funcin seqSort .............................................. 42
Figura 28. Cdigo Sorting.hs (parSort 2).......................................................................... 43
Figura 29, Compilacin, ejecucin y optimizacin de la funcin seqSort ....................... 44

vii

RESUMEN DESCRIPTIVO
En esta monografa se describe la programacin paralela a travs de casos de estudio
reales en un mercado comercial e industrial. Primeramente, se presenta un escrito sobre
los antecedentes del lenguaje funcional Haskell, sus puntos claves y principales
caractersticas, con la idea de introducir al lector a un entendimiento general del lenguaje.
Seguidamente se va mostrando la evolucin de Haskell, sus percusores, compiladores que
utiliza, haciendo hincapi en la programacin declarativa secuencial hasta llegar a la
programacin paralela y concurrente. Posteriormente se presenta un anlisis diferenciador
entre los trminos de paralelismo y concurrencia. Seguidamente, se introduce a la
descripcin de los conceptos propios de la programacin paralela Haskell, sus principales
mdulos y funciones, y se explica en trminos generales la programacin concurrente,
dado lo extenso del tema.

Es importante sealar que el objetivo de esta monografa consiste en describir la


programacin paralela a travs de casos de estudios reales, y as exponer al lector la
aplicacin que tiene Haskell en las grandes compaas de software al utilizarlo en sus
proyectos.

Una vez se describen algunos casos de uso, se procede a la implementacin del


compilador de GHC (Glasglow Haskell Compiler) y se ejecutan pruebas, tomando un
cdigo de ejemplo de ordenamiento de elementos de una lista, tanto en programacin
secuencial, como en paralela que provee Haskell y se registran los resultados.

Finalmente, se emiten las conclusiones del trabajo de monografa, expresando los


conocimientos y experiencias obtenidas.

La monografa est formada por los captulos que se describen a continuacin:

viii

Captulo I: Se plantea el objetivo general y los objetivos especficos que se quieren


alcanzar durante el desarrollo de la monografa.

Captulo II: En este captulo se desarrolla el estado del arte del lenguaje Haskell. Se
presentan los antecedentes y evolucin del lenguaje, se resumen sus principales
caractersticas y se describen las funcionalidades del compilador intrprete que se
utiliza. Asimismo, se plantea un anlisis de diferencias entre los conceptos de
paralelismo y concurrencia, los cuales se tienden a confundir. Adems se describen
las funcionalidades de los principales mdulos para crear programacin paralela con
Haskell y se explican en trminos generales los principales mdulos de la
programacin concurrente.

Captulo III: Se presentan 10 casos de estudio de diversas compaas de renombre y


se describe la importancia y aplicacin al utilizar Haskell, paralelo para la resolucin
de sus problemas. Del mismo modo, se muestran pantallas de la solucin en algunos
de los casos descritos.

Captulo IV: En este captulo se detallan las herramientas utilizadas para la


instalacin de Haskell y el procedimiento que se lleva a cabo en la eleccin del
cdigo para la realizacin de las pruebas. Tambin, se exponen los resultados
obtenidos en la ejecucin de un cdigo de forma secuencial y paralela con el objetivo
de determinar la diferencia de tiempo de ejecucin entre ambos mtodos y sus
beneficios en relacin al tiempo de ejecucin.

Captulo V: Se emiten las conclusiones a partir del estudio realizado, los casos de
estudio presentados y los resultados de las pruebas de la programacin con Haskell.

Palabras claves: paralelismo, concurrencia, monada, estrategias map reduce, datos


paralelos, paralelismo con datos anidados, paralelismo con flujo de datos.

ix

INTRODUCCIN
La intencin al escribir este monografa no es ensear programacin, por el contrario, el
objetivo es describir la programacin paralela y concurrente del lenguaje funcional
Haskell a travs de la informacin proporcionada, que va desde los antecedentes del
lenguaje, su evolucin, hasta su uso en diversas compaas de gran renombre.

Nuestra estrategia general para introducir las caractersticas del lenguaje y su


funcionalidad en programacin paralela y concurrente son: definir algunos trminos,
presentar casos de estudio, representar pruebas de ejecucin de un cdigo de ejemplo y
dar referencias precisas para que el lector pueda obtener mayores detalles. Por ejemplo, la
librera Prelude,

estndar de Haskell y las libreras estandarizadas como Cabal,

contienen numerosos ejemplos tiles de cdigo Haskell.

En el presente trabajo se muestra una aplicacin del programa Haskell, a travs de una
serie de pruebas que permiten comparar el desempeo desde el punto de vista del tiempo
de ejecucin, cantidad de ncleos utilizados y el espacio de memoria requerido entre las
versiones secuenciales y paralelas de un conjunto de programas ejemplo.

Finalmente, cabe destacar, que en el enlace del sitio de Haskell http://www.haskel.org


podemos encontrar mayor informacin sobre el lenguaje Haskell y sus implementaciones.

CAPTULO I

1.1.

HIPTESIS
Es Haskell Paralelo un entorno de programacin ideal para el contexto cientfico y
comercial.

1.2.

OBJETIVO GENERAL
Describir la programacin paralela con Haskell mediante casos de estudio.

1.2.1. OBJETIVOS ESPECIFICOS

Definir los antecedentes y base terica de la programacin paralela y


concurrente con Haskell.

Establecer diferencias entre la programacin paralela y concurrente.

Identificar los principales mdulos y funciones de programacin paralela


y concurrente que provee Haskell.

Identificar, analizar y presentar casos de estudio que apliquen a la


programacin paralela y concurrente Haskell.

Comparar la programacin Haskell de forma secuencial y paralela a travs


de la ejecucin de un cdigo de ejemplo.

CAPTULO II
2.1. ESTADO DEL ARTE
Haskell es un lenguaje funcional puro, de cdigo abierto, con ms de 20 aos de
investigacin, creado por un comit, liderado por Simon Peyton Jones, investigador de
Microsoft y John Hughes en los aos 80's[1].

El lenguaje toma el nombre de Haskell Brooks Curry, cuyos trabajos en lgica


matemtica sirvieron como base a los lenguajes funcionales[2].Con este producto se
pretenda unificar las caractersticas ms importantes de los lenguajes funcionales.

Entre sus principales caractersticas se pueden mencionar:

Evaluacin perezosa, la cual realiza operaciones cuando se le indique, no antes, ni


despus.

Sistema de tipo de datos esttico, que hace que los errores sean detectados en tiempo
de compilacin.

Sistema de inferencia de datos, el cual permite no declarar los tipos.

Funciones de orden superior, lo que significa que la salida de una funcin puede ser
entrada o parmetro que puede ser utilizado por otra funcin.

Patrn sintctico que incluye asignacin de expresiones, condicionales if-else,


case, uso de guards, notacin do y patrones as.

Recursin para tratar datos que se trataban con estructuras loops o bucles.

Mdulos, anlogos de las libreras de los lenguajes imperativos [1].

Haskell permite la integracin con otros lenguajes, una funcin de la concurrencia y


paralelismo, depuradores, perfiladores, bibliotecas y una comunidad activa. Est basado
en el clculo lambda[3].

La implementacin de sistemas de software con Haskell se destaca en el mbito


industrial, acadmico y cientfico. Algunos de estos sistemas son de cdigo abierto,
mientras que otros son productos comerciales. Como ejemplo podemos citar grandes
empresas como: NASA, con apoyo a programas para estudiantes, Eaton, Facebook,
Google, New York Times, bancos, entre otros.

Los lenguajes funcionales son candidatos para la programacin paralela eficaz, debido a
su alto nivel de abstraccin y, a su transparencia referencial[4].

Hoy por hoy, Haskell es un lenguaje de programacin muy verstil, ya que permite las
facilidades; tanto la programacin paralela como la programacin concurrente, lo que no
nos ofrecen la mayora de los otros lenguajes de programacin, ya que es un lenguaje
funcional "puro" (sin efectos laterales), y al mismo tiempo utiliza evaluacin perezosa, lo
que lo hace ideal para crear programas concurrentes y operaciones en paralelo.

Para los desarrolladores, Haskell proporciona el compilador GHC, que implementa las
principales extensiones de Haskell, con el fin de facilitar la programacin concurrente y
paralela[3]. El Compilador GHC (Glasgow Haskell Compiler), es un compilador con un
sistema paralelo para el lenguaje funcional Haskell [10]. Con este compilador se logra
gran flexibilidad, utilizando un modelo de hilo ligero, donde mltiples subprocesos
lgicos Haskell se asignan a un nico subproceso, que funciona simultneamente con
otros[5].

De

acuerdo

Fernando

Rubio,

en

su

escrito

publicado

en

http://antares.sip.ucm.es/~fernando/pf/temas/GHC.html, GHC es un compilador de libre


distribucin, y existen versiones gratuitas para distintos sistemas operativos. El sitio web
principal del compilador contiene las distintas versiones, as como la documentacin de
instalacin y uso. Conjuntamente, Rubio agrega que el modo de compilacin bsico de
GHC es muy sencillo y en caso de que deseemos compilar un programa formado por un
3

nico fichero, solo es necesario ejecutar el comando: ghc programa.hs y se generar un


ejecutable a.out para el mismo. Si se desea usar otro nombre, debe proporcionarse el
nombre del ejecutable: ghc -o ejecutable programa.hs. En caso de tener varios mdulos,
cada uno de ellos puede compilarse por separado mediante ghc -c modulo.hs, lo cual
genera los correspondientes ficheros objeto y de interface. Para crear el ejecutable final,
solamente es necesario utilizar ghc programa.hs modulo1.o modulo2.o.

Figura 1. Arquitectura de Haskell [6]

Figura 2. Funcionamiento de Kernel en su gestin y comunicacin de los recursos del sistema que asiste [7]

Figura 3. Ejemplo de Estructura de Mdulo en Haskell [5]

Es importante sealar que Haskell se apoya mucho en mdulos que se integran al


lenguaje, lo que permite mayor amplitud en la resolucin de los problemas. En el caso de
nuestra investigacin, emplearemos Cabal, librera para compilar y empaquetar
bibliotecas y programas Haskell. Cabal es parte de una gran infraestructura para la
distribucin, organizacin y catalogacin de bibliotecas y programas Haskell. Funciona
junto a HackageDB, que es un repositorio de paquetes Haskell. Cada paquete tiene un
formato Cabal, y como comentbamos anteriormente es un formato estndar de
empaquetamiento, lo que en Java llamaramos un jar[2].

Figura 4. Captura de pantalla del compilador GHC para Windows. Tomado de la pantalla del autor.

2.1.1. Paralelismo vs. Concurrencia


En muchas reas los trminos paralelo y concurrente son sinnimos, sin embargo, en
programacin no es as: Segn [3] y [8] un programa paralelo es uno que utiliza
mltiple hardware computacional (mltiples ncleos de procesador) para realizar un
clculo ms rpido, ya que ciertos fragmentos de cdigo sern ejecutados por diferentes
procesadores que se ejecutan al mismo tiempo (en paralelo), para que los resultados
sean entregados en el menor tiempo posible.

Por el contrario, la concurrencia es una tcnica de estructuracin de programa, en la


cual existen mltiples hilos de control. Estos hilos de control proceden a ejecutarse al
mismo tiempo. Un programa concurrente puede ejecutarse en un solo procesador
mediante una ejecucin intercalada o en mltiples procesadores fsicos[8].

A la programacin paralela slo le concierne la eficiencia, mientras que la


programacin concurrente es una estructura que necesita interactuar con mltiples
agentes externos independientes (usuario, servidor, algunos clientes externos, entre
otros)[8].

Un programa concurrente necesita realizar varias tareas relacionadas al mismo tiempo.


Por ejemplo un servidor de juegos, que normalmente est compuesto por decenas de
componentes, cada uno de los cuales ha complicado las interacciones con el mundo
exterior. Uno de los componentes puede manejar chat multiusuario; otros procesarn
las entradas de los jugadores y las actualizaciones de estado a ellos; mientras que otros
realizarn clculos fsicos. Por lo que podemos observar, la operacin correcta de un
programa concurrente no requiere de mltiples hilos, aunque estos pueden mejorar el
rendimiento y capacidad de respuestas[9]. No as, un programa paralelo, que soluciona
un solo problema. Consideremos como ejemplo un modelo financiero que intenta
predecir el prximo minuto de cambios en el precio. Si queremos aplicar este modelo a
la bolsa de valores y estimar cules debemos comprar y vender, esperamos obtener una
6

respuesta ms rpida si corremos el modelo en muchos ncleos que si lo usamos en uno


solo.

Otra distincin til entre programas concurrentes y paralelos se percibe en su


interaccin con el mundo exterior. Un programa concurrente trata continuamente con
los protocolos de redes, bases de datos y similares. Un tpico programa paralelo est
ms enfocado en transmitir datos y luego los retorna[9].

Las bibliotecas de Haskell permiten programas paralelos concisos de alto nivel con
resultados determinsticos, es decir, independientes de la cantidad de ncleos y la
programacin que se utiliza[10]. La concurrencia es apoyada con hilos ligeros y
abstracciones de alto nivel, tales como software de memoria transaccional para la
gestin de la informacin compartida a travs de las discusiones. La programacin
distribuida sigue siendo un rea de investigacin, como la nube Haskell.

2.1.2. Programacin Paralela con Haskell


Con la programacin paralela se acelera la ejecucin de un programa mediante el uso
de mltiples procesadores, con un resultado determinista, lo que garantiza siempre la
misma respuesta, independientemente de cuantos procesadores se utilicen para
ejecutarlo.

Adicional, estos programas paralelos son declarativos de alto nivel, por lo que no tratan
con conceptos como la sincronizacin o comunicacin. En este caso el programador
indica donde estar el paralelismo y los detalles de la ejecucin del programa en s, se
le deja al Sistema, y de esta manera el programador se enfoca solamente en dividir el
problema en pedazos para que pueda ser computados en paralelo. Lo ideal sera tener
muchas tareas y mantener ocupados los procesadores continuamente, sin embargo, esto
se podra ver afectado por la granularidad y la dependencia de datos[8].

En Haskell existen dos maneras de lograr el paralelismo:

Paralelismo puro, que se puede utilizar para acelerar partes no-IO (entrada/salida)
del programa.

Concurrencia, que se puede utilizar para paralelismo IO (mltiples hilos de


control que se ejecutan al mismo tiempo)[9].

2.1.2.1. Paralelismo Bsico: La monada Eval


Dado que Haskell es un lenguaje perezoso no es necesario preocuparse sobre la
evaluacin de las expresiones, ya que estas se realizan solamente cuando sea
necesario.

El paralelismo en Haskell se expresa utilizando la Monada Eval, que viene con dos
operaciones rpar y rseq. La combinacin rpar crea paralelismo al decir, "mi
argumento podra evaluarse en paralelo"; mientras que rseq se utiliza para forzar la
evaluacin secuencial al decir, "Evaluar mi argumento y esperar por el resultado".
Es importante sealar que el argumento rpar debe ser un clculo no evaluado, si el
argumento fue evaluado no pasa nada, porque no hay trabajo para realizar en
paralelo[11].

Figura 5. Ejemplo de rpar/rseq [11]

2.1.2.2. Estrategias de Evaluacin


Las Estrategias son un API de composicin de alto nivel para la programacin
paralela, un medio para la modularidad del cdigo paralelo, al separar el algoritmo
del paralelismo. As pues, una estrategia es una funcin de la Monada Eval que toma
8

un valor de tipo y retorna el mismo valor. Las estrategias cuentan con las siguientes
caractersticas:

Expresan paralelismo determinstico: el resultado del programa no es afectado por


la evaluacin en paralelo.

Permiten separar la descripcin del paralelismo de la lgica del programa.

Son compositivas: las estrategias grandes se pueden construir a partir de


estrategias ms pequeas.

Se proveen de aplicativos y Monadas para construir estrategias de forma ms


rpida[12].

La Monada Par es una API de programacin paralela alternativa a la proporcionada


por el paquete paralelo. La Monada Par permite la descripcin simple de clculos en
paralelo, y se puede utilizar para aadir paralelismo al cdigo Haskell puro [11].

Debemos conocer que para hacer uso de las Estrategias se debe aplicar a su entrada y
ejecutar Eval para obtener la salida, as que podemos escribir directamente runEval;
por ejemplo, para evaluar los pares (fib 35, fib 36) en paralelo como sigue[11]:

runEval (parPair (fib 35, fib 36))

La Estrategia parPair siempre evala los componentes de la pareja en paralelo en la


forma normal de encabezado dbil, por lo que se recomienda utilizar una estrategia
parametrizada, que toma como argumentos las estrategias que se aplicarn a los
componentes de la estructura de datos.

2.1.2.3. MapReduce
MapReduce de Google, es una tcnica general con alto grado de procesamiento
paralelo sobre grandes volmenes de datos. Esta tcnica est inspirada en la
programacin funcional, a pesar que en la actualidad va hacia un enfoque imperativo,
como lo es la implementacin del Framework Hadoop, basado en JAVA. No
obstante, dado que MapReduce, puede ser expresado en su forma natural, usando
programacin funcional a travs de las monadas generalizadas, este se generaliza
an ms y se puede definir un transformador de monada MapReduceT, con lo cual
se tendra un tipo de MapReduce y una operacin asociada a cualquier monada [11].

El modelo de programacin MapReduce nos permite escribir programas paralelos en


Haskell con buen rendimiento y mnimo esfuerzo. Se puede complementar con otras
fuentes de datos, como las colecciones de archivos[9].

2.1.2.4. Paralelismo de Flujo de Datos (Dataflow Parallelism)


En el caso de requerir paralelismo de flujo datos, el objetivo de la Monada Par, es
ser ms explcito acerca de granularidad y las dependencias de datos, para evitar la
dependencia de la evaluacin perezosa, pero sin sacrificar el determinismo de la
programacin en paralelo. En este modelo de programacin, el programador tiene
que dar ms detalles, pero a cambio, obtiene ms control. La Monada Par posee
ventajas, por ejemplo, si se implementa totalmente como una biblioteca de Haskell, la
implementacin puede ser modificada para adaptarse a las estrategias alternativas de
programacin.

2.1.2.5. Programacin de Datos Paralelos con Repa


Haskell tambin nos permite la realizacin de programacin paralela con Repa
(librera de matrices paralelas), que proporciona alto rendimiento, formas

10

multidimensionales, matrices regulares, matrices polimrficas paralelas[13]. Todos


los datos numricos se almacenan sin empaquetar. Las funciones escritas con las
combinaciones Repa se vuelven automticamente paralelas al suministrar + RTS Nwhatever en el comando de lnea al momento de correr el programa[14].

Repa proporciona un Framework para describir las operaciones de las matrices y


posee los siguientes beneficios:

Los arreglos de discos intermedios se eliminan automticamente cuando las


operaciones de la matriz son compuestas (fusin).

Las operaciones computeP y foldP paralelizan automticamente utilizando los


ncleos disponibles.

Repa depende en gran medida del optimizador de GHC y es muy sensible a las
anotaciones e identado, por lo que es buena prctica la utilizacin de ambos al
mismo tiempo.

Repa tiene soporte en la clase de algoritmos de procesamiento de imgenes, donde la


transformacin de cada pxel es calculada como una funcin de los pxeles prximos.
Para ciertos tipos de funciones en tiempo de compilacin, Repa puede generar cdigo
especializado, que permite que el cdigo se ejecute muy rpido[11].

La estructura de datos central en Repa es el arreglo paralelo. Cada elemento de un


arreglo paralelo puede calcularse independientemente y la biblioteca Repa se encarga
de calcularlos en paralelo. En particular la biblioteca Repa ayuda con el tema de
granularidad, dividiendo la matriz en tantos trozos como ncleos posea el CPU[10].

En Repa, los arreglos de discos vienen de dos formas, retrasados y manifiesto. Las
matrices retrasadas estn representadas en funcin del ndice de valor, mientras que
un conjunto manifiesto es la representacin de memoria tradicional. La
11

representacin retrasada es til para definir arreglos de varias operaciones de


matrices simples, sin generar arreglos temporales intermedios. La funcin
computeP crea una matriz manifiesta en paralelo desde una matriz
retrasada[10].

Es importante sealar el uso de Acelerate, un lenguaje integrado de los clculos de la


matriz para la computacin de alto rendimiento en Haskell. Los clculos sobre
matrices regulares multidimensionales se expresan en forma de operaciones
colectivas parametrizadas (tales como mapas, reducciones y permutaciones).

2.1.2.6. Paralelismo con datos anidados (Nested data)


Los arreglos paralelos anidados tienen un alto rendimiento y soportan a gran escala la
programacin multicore. Los datos de Haskell en paralelo DPH (Data Parallel
Haskell) son una extensin de datos anidados de paralelismo (GHC)[13].

En DPH, el programador puede usar matrices paralelas de tipo [: e:] que se parecen a
las listas de Haskell normales; sin embargo, dan acceso a datos de ejecucin paralela.
Las operaciones en estas matrices paralelas son una invocacin de la lista normal de
funciones de procesamiento de Haskell. Por ejemplo, mapP, unzipP y sumP son
versiones paralelas de estas funciones conocidas[15].

El paralelismo de datos anidados aumenta la gama de estructuras de datos en paralelo


y algoritmos que pueden ser expresados mediante matrices paralelas, permitiendo que
las matrices paralelas contengan otros arreglos de discos o estructuras. Con este
mtodo de programacin paralela se logra un buen rendimiento mediante una
transformacin del tiempo de compilacin, convirtiendo las matrices anidadas en una
sola matriz plana, que luego puede ser repartida uniformemente a travs de todos los
ncleos de procesador[10].

12

2.1.3. Programacin concurrente con Haskell


Concurrencia es el nombre que Haskell proporciona para la programacin con mltiples
hilos de control. A diferencia de la programacin paralela, donde el objetivo es hacer
que el programa se ejecute ms rpido, mediante el uso de ms de un CPU; el xito de
la programacin concurrente est en escribir un programa con mltiples interacciones.
Estas interacciones podran estar del lado del usuario a travs de una interfaz, con otros
sistemas, o de hecho entre diferentes subsistemas dentro del mismo programa. La
concurrencia permite escribir un programa en el cual cada una de estas interacciones se
describe por separado, pero todo sucede al mismo tiempo. As pues, la concurrencia es
una poderosa herramienta para estructurar programas con mltiples interacciones [9] y
[11].

De esta manera, la concurrencia, se entiende como

las tcnicas para estructurar

programas, que nos permitan modelos computacionales tales como actividades


independientes,

que se pueden comunicar y sincronizar; en contraste con el

paralelismo, que hace uso de mltiples unidades de procesamiento como ncleos CPU
o GPU (unidad de procesamiento grfico) en el menor tiempo posible[10].

En muchas reas de aplicacin hoy en da, se hace necesario cierto grado de


concurrencia. Una aplicacin tpica, orientada hacia el usuario, debe tener una interfaz,
que debe seguir activa mientras la aplicacin est descargando datos de la red o
calculando algunos resultados. A menudo estas aplicaciones pueden interactuar con
mltiples servidores en la red al mismo tiempo; por ejemplo, un navegador web tendr
muchas conexiones simultneas abiertas a los sitios que el usuario se encuentre
navegando, por lo que las aplicaciones del servidor necesitan concurrencia para
gestionar mltiples interacciones cliente, simultneamente.

13

La programacin concurrente cubre MVARs, excepciones asincrnicas, software


transaccional de memoria, interfaz para funciones de relaciones forneas y construccin
de los servidores de red de alta velocidad.

2.1.3.1. Concurrencia Bsica: MVar y Threads (hilos)


El objetivo primordial de la concurrencia es dividir un nuevo hilo de control. En
Haskell concurrente, esto se logra con la operacin forkIO. La operacin de forkIO
toma un tipo IO () como su argumento; es decir, un clculo en la monada IO, que
finalmente proporciona un valor de tipo (). El valor pasado a forkIO, se ejecuta en un
subproceso (hilo) nuevo que funciona simultneamente con los otros subprocesos
(hilos) en el sistema. Si el subproceso tiene efectos, esos efectos sern intercalados de
manera indeterminada con los efectos de otros hilos.

Las variables MVars son primitivas de bajo nivel, que proporcionan una cola que se
bloquea con una sola celda, por lo que resulta til para construir los locks, colas
ilimitadas y otras estructuras concurrentes. De igual forma, se utiliza internamente,
para la sincronizacin del sistema en tiempo de ejecucin. Las MVars se
implementan con una cola FIFO de hilos en espera, ya que generalmente representan
un cuello de botella. En algunos casos se construyen MVars usando STM (llamado
TMVars), sacrificando la ordenacin del servicio de hilos de espera. Por lo tanto,
mejorar el rendimiento de MVar podra ser beneficioso para muchos programas de
Haskell, as como el tiempo de ejecucin del sistema que se basa en MVars,
incluyendo el administrador asncrono IO.

El sistema de tiempo de ejecucin tiene un gestor de IO, que maneja las peticiones de
Entrada/Salida asincrnicas y las respuestas dirigiendo de vuelta las respuestas a un
subproceso (hilo) bloqueado de Haskell. Muchas veces surgen problemas de
programacin en el diseo, y en consecuencia, programas como servidores web se

14

beneficiarn de las mejoras a las estructuras de datos concurrentes utilizadas por el


administrador de IO[16].

Desarrollos recientes de Haskell incluyen tambin bibliotecas que ofrecen elegantes


formas de programacin de GPUs (unidades de procesamiento grfico) y bibliotecas
para crear programacin de memoria distribuida, por ejemplo los racimos o sistemas
grid/cloud[10].

En la siguiente seccin se abordar el tema de los casos de estudio para


Programacin Paralela y Concurrente con Haskell.

15

CAPTULO III
3.1.

CASOS

DE

ESTUDIO

DE

PROGRAMACIN

PARALELA

CONCURRENTE CON HASKELL


El lenguaje de programacin funcional Haskell aporta una amplia biblioteca de mdulos
y posee utilidades en: audio, msica

y sonido, bioinformtica, concurrencia and

paralelismo, compiladores e intrpretes, criptografa, estructura de datos, base de datos,


juegos, grficas, matemticas y fsicas, redes, criptografa, robtica, web, HTML, XML,
entre otros.

Haskell, en un entorno de programacin paralela, es ampliamente utilizado en la


industria, comercio, educacin e investigacin. Su aplicacin en el comercio va desde su
empleo en el mbito aeroespacial, defensa, finanzas, firmas de diseo de hardware hasta
manufactura de maquinarias. El principal usuario de Haskell industrial es CUFP (usuarios
comerciales de Workshop de programacin funcional). Por otro lado, el grupo de Haskell
industrial soporta a los usuarios comerciales[17].

En este captulo mostraremos varios casos de estudios de empresas, productos y servicios


que utilizan esta tecnologa para paralelizar sus sistemas de informacin.

3.1.1. Proyecto Haxl en Facebook


Simon Marlow, autor de "programacin paralela y concurrente en Haskell" (O'Reilly),
publicada en agosto de 2013, describe un sistema elaborado con Haskell, basado en la
concurrencia, y permite a los programadores de aplicaciones para usuario, escribir la
lgica de negocio para acceder a todos los servicios de backend de una manera concisa
y coherente [18].

16

Haxl Open Source Facebook: Acceso a datos con Haskell implcito y concurrente

Figura 6. Proyecto Haxl de Facebook

El cdigo abierto Haxl de Facebook es una biblioteca para el acceso eficiente de datos
concurrentes. La biblioteca aprovecha las fortalezas tradicionales de Haskell como el
sistema de tipo expresivo, garantas de exactitud y seguridad, as como un alto
rendimiento en tiempo de ejecucin del compilador GHC. Haxl simplifica el acceso de
datos a los datos remotos, tales como bases de datos o servicios web. Puede atender
automticamente mltiples peticiones a la misma fuente de datos, solicitar datos de
mltiples fuentes de datos y tambin almacenar en cach peticiones anteriores. Jon
Purdy, uno de los ingenieros que trabajaron en Haxl, explica que la idea bsica es que
se puede escribir datos de forma perezosa e ir a buscar el cdigo sin duplicacin. Para
utilizar Haxl en la aplicacin, se crea una capa que indica el origen de los datos y
describe cmo acceder a ella. Haxl utiliza una clase de tipo aplicativo para permitir que
los clculos sean implcitamente concurrentes. Haxl es el sucesor de FXL, que resolva
el mismo problema. Aunque FXL tambin tiene un modelo de ejecucin pura, la
aplicacin ha presentado problemas de rendimiento, especialmente con la CPU y uso de
memoria. En este sentido el uso de Haskell, con el compilador GHC resultan ser una
mejor alternativa [19].

17

3.1.2. IMVU, Inc.


Es una empresa de entretenimiento social que adhiere usuarios a travs de experiencias
basadas en avatar 3D.

Figura 7. Pgina principal del sitio web http://es.imvu.com/

IMVU utiliza Haskell desde 2013 para construir varias de las APIs REST que soportan
su sitio web. Cuando la compaa inici operaciones escogi el lenguaje PHP y estaba
enfocada slo en un servicio Client 3D descargable. Aos ms tarde, con el
crecimiento de la compaa y aumento de clientes, surge la necesidad de mayor
rendimiento, por lo que el PHP ya no era suficiente, y en 2012 se decidieron a buscar
otra alternativa. De aqu surge la iniciativa de utilizar Haskell, con un personal
dedicado. con el objetivo de lograr el crecimiento de la compaa. Se obtienen los
siguientes beneficios:

Escalabilidad Se inicia con el reemplaz de un solo servicio, de alto volumen,


pero no crtico y se implementa con Haskell. Incluso sin realizar ningn tipo de
optimizacin, este servicio muestra un excelente rendimiento, con la
18

implementacin en un pequeo servidor Haskell, que manejaba alrededor de 20x


peticiones adicionales a las que manejaba el servidor PHP anterior.

Confiabilidad El servicio con Haskell estuvo funcionando por meses sin


intervencin de soporte alguno.

Capacitacin La formacin de un ingeniero para que fuese productivo en cdigo


Haskell fue como formar a alguien para PHP y de hecho si la persona tena
conocimiento previo en programacin funcional, en pocos das se pona al da.

Pruebas Con el uso de Haskell se minimiz el tamao de las pruebas que se


deban realizar, dado los pocos defectos que se generaban. Para las pruebas
unitarias utilizaron TDD, que tiene un alto grado de fiabilidad con Haskell.

La herramienta Haskell QuickCheck fue tambin de gran ayuda para los


desarrolladores, por la forma en que Haskell separa clculos puros de efectos
secundarios.

Despliegue La compaa realiza extensiones continuamente, pero se mantiene el


historial de versiones antiguas por si es necesario hacer modificaciones.

El gestor de paquetes Haskell, con la librera Cabal aport mucho al desarrollo con la
especificacin de rangos de versin res y el control de dependencias transitivas con
mucha precisin[20].

3.1.3. Barclays Capital Quantitative Analytics Group


Barclays Capital est usando Haskell para desarrollar un lenguaje funcional embebido
de dominio especfico llamado FPF, que se utiliza para especificar las derivadas de la
equidad extica, dado que naturalmente las derivadas se describen mejor en trminos de
funciones matemticas y estn construidas compositivamente [17].

El grupo Barclays Capital Quantitative Analytics trabaja en estrecha colaboracin con


todas las reas de negocio de la empresa. El grupo propone soluciones a los problemas

19

de precios y riesgo. Este grupo es responsable de la investigacin, desarrollo y la


aplicacin de modelos cuantitativos en todas las clases de activos Global Markets (tasas
de inters, equidad, divisas, materias primas, mercados emergentes y DCRM) [21]. El
grupo tambin se asegura del vnculo entre las empresas que facilitan mltiples activos
y productos hbridos. Barclays Group est ubicado en Londres, Pars, Singapur , Hong
Kong, Tokio y Nueva York, y ofrece soluciones para el conjunto de Barclays Capital en
todo el mundo [21].

El personal de Quantitative Analytics requiere de un perfil con nivel de matemticas y


fsica, ya que es preciso que posean habilidades de pensamiento lgico, resolucin de
problemas, matemticas, programacin, habilidades necesarias para desarrollar,
mantener modelos de comunicacin con los comerciantes, y proveerles del servicio de
soporte cuantitativo para soluciones de precios y gestin de riesgos [21].

Figura 8. Herramientas exticas para Operaciones exticas [22]

Tim Williams, fsico y desarrollador de software, en el sector financiero por ms de 10


aos, describe una de los expansiones ms grandes del mundo comercial Haskell
(Barclays) y comparte algunas experiencias y conocimientos adquiridos durante su
ejercicio de uso de Haskell en la construccin de lenguajes especficos de dominio [22].

20

Detallando un poco ms sobre el proyecto, el Framework de Pago Funcional (FPF), es


una aplicacin de Haskell, que utiliza un lenguaje funcional de dominio especfico,
incorporado para representar y procesar derivadas financieras exticas. Mientras que
los lenguajes de secuencias de comandos para precios en derivadas exticas son
comunes en banca, FPF utiliza mltiples interpretaciones de los precios, no slo en
dichas operaciones, sino tambin, para analizar las secuencias de comandos y
proporcionar soporte del ciclo de vida. En este trabajo se discute la aplicacin de FPF
en relacin con el flujo de trabajo de intercambio comercial y la experiencia del Grupo
Barclays Capital en el uso del lenguaje funcional Haskell, tanto como sistema de
implementacin como de dominio especfico [23]. Con esta solucin se apunta hacia un
dominio especificado por funciones, por lo que el motor de precios FPF deba manejar
mltiples backends para la descripcin de un solo intercambio comercial dadas las
diferentes interpretaciones o anlisis de los scripts.

Barclays cre FPF mediante un proceso iterativo experimental en lugar de un diseo


formal basado en metas absolutas. Por ejemplo, para los aspectos de la actividad
comercial que requieren de un anlisis humano, debera ser posible representarlo en una
forma matemtica para que los analistas pudiesen estudiar y discutir. Antes de FPF todo
era expresado a travs de un lenguaje de dominio especfico (DSL - lenguaje
imperativo). Muchos bancos estaban movindose hacia lenguajes funcionales, as que
se identific un patrn comn de funcionalidades y se transform el sistema en
plantillas, con un formulario estandarizado, que cubra la mayora de las variaciones
que se encontraban en este tipo de comercio. El problema de estas plantillas era el
esfuerzo que se requera para crearlas. Posteriormente, surge un frontend basado en
Excel, con cdigo especfico en este tipo de comercio y se trata con campos particulares
del negocio y cuenta con un generador de grficos en la emisin del pago. Sin embargo,
a finales del ao 2006 Barclays ya manejaba ms de 35 plantillas, lo que representaba
miles de transacciones, y para ese entonces, los sistemas deban adaptarse muy rpido
al mercado cambiante, con la presin de agregar nuevas caractersticas. Como
21

resultado, el cdigo se vuelve insostenible, causando riesgo operacional. Estos


problemas sirvieron de motivacin para la creacin de PFP, con la funcionalidad de
anlisis genricos, que pudiesen aplicarse a todo tipo de comercio, reduciendo al mismo
tiempo el costo de produccin [23].

La decisin de utilizar Haskell no fue trivial, aun cuando todo apuntaba hacia entornos
C++ y VBA, se deseaba escoger un lenguaje funcional, por su naturaleza para manejar
funciones matemticas. Al inicio, se hizo un prototipo en Prolog, pero se dieron cuenta
que no usaba ninguna caracterstica del lenguaje de programacin lgica, as que
entendieron que los requerimientos principales eran los de una escritura fuerte para una
gran cantidad de usuarios. As es como surge FPF, de un arduo trabajo de 2-3 aos y
20,000 lneas de Haskell. Los scripts de intercambio comercial contribuyen
aproximadamente con 30,000 lneas, distribuidas en ms de 400 tipos y variantes de
intercambio comercial. Adems existen alrededor de veinte usuarios directos
(comerciantes y estructuradores) [23].

Dado que Haskell incrusta FPF, la sintaxis es simple y acta como un subconjunto de
Haskell definido por sus funciones primitivas. Los tipos Double y Bool no son las
mismas provistas por el Prelude de Haskell, pero son tipos que juegan roles
equivalentes en FPF [23].

Con la utilizacin de una estructura de datos Haskell como texto en lugar de XML, se
logr controlar completamente la escritura, reduciendo el riesgo de que terceras partes
trataran de procesar estas estructuras por s mismas. En contraste, se proporcionaron
herramientas de traduccin para presentar los datos en el formato que se necesitaba, por
lo que la empresa continua escribiendo herramientas totalmente genricas y la interfaz
de lneas de comandos que utiliza hace que la identificacin de las pruebas y fallos sea
un proceso mucho ms productivo [23].

22

Ahora, FPF es parte integral del negocio de especies exticas de equidad de Barclays,
tanto de forma tctica como estratgica. Actualmente, tambin estn empezando a
migrar las plantillas de intercambios comerciales a FPF [23].

El proyecto FPF influy mucho en el xito de la empresa, reduciendo el ciclo de


desarrollo, lo que les permite ms tiempo para implementar nuevas ideas. Una vez que
las instituciones financieras han automatizado todo el proceso asociado con su
representacin interna de comercio se estandarizan las descripciones del comercio
externo para eliminar el riesgo de las hojas del trmino ambiguo o un error humano
durante la traduccin [23].

Figura 9. Proyecto Functional Payout Framework de Barclays

En la actualidad el Grupo Capital Barclays QA publica anuncios, solicitando


desarrolladores de Haskell para que se integren al grupo de trabajo del Proyecto
Functional Payout Framework (FPF), tanto en Londres como en Kiev. Los
desarrolladores que requieren, deben tener un profundo dominio de la programacin
funcional y tener la disposicin de trabajar con los comerciantes. No es necesario que
posean conocimiento previo de desarrollo de Haskell comercial ni experiencia en
inversin de banca, aunque si lo posee, sera una ventaja [24].
23

3.1.4. Parallel Scientific, Boulder, Colorado


Esta compaa de laboratorios utiliza Haskell para el desarrollo de un sistema de
gestin ultra escalable de recursos de alta disponibilidad para grandes clsteres
(millones de nodos). Un elemento clave del diseo del sistema es proporcionar
mecanismos confiables y escalables para fallas de comunicacin y coordinacin de las
transiciones de recuperacin.

Figura 10. Logo de la Compaa Parallel Scientific [25]

Para lograr concurrencia se utiliza el modelo que provee el Cloud de Haskell, que
proporciona buena red semntica y gestin de procesos remotos. Los desafos de la
utilizacin de nube Haskell; incluyen lidiar con problemas de escalabilidad y
proporcionar transportes backend para mltiples tipos de hardware de red. Una
mquina de estado replicada conserva el estado derivado de fallas y transiciones y est
en el centro de su diseo. Tambin utiliza el algoritmo de Paxos para la verificacin
formal en el diseo y depuracin que brinda este algoritmo [26].
En su reporte HA - A Development Experience Report, Jeff Epstein (con experiencia
en gestin de equipos y desarrollo de software, incluyendo sitios web, telefona digital,
sistemas distribuidos) indica que HA (High Availability), administra clsteres con
decenas de miles de nodos en la red, controlndolos de forma centralizada. Fue
diseado por Mathieu Boespflug y Peter Braam. Tambin maneja eventos debido a
fallas, donde el tiempo de recuperacin puede ser aproximadamente de 5 segundos y el
estado del clster puede replicarse [26].

24

Parallel Scientific usa Haskell en:

Estructuras de datos funcionales el estado del clster es un grfico puramente


funcional, replicacin (no pura) entre los administradores de clsteres.

Refactorizacin ms fcil, gracias a su fuerte escritura.

Programacin perezosa.

Librera para concurrencia distribuida que provee una interface de paso de


mensajes donde los procesos se comunican sin datos compartidos y

la

comunicacin sigue siendo la misma aunque los procesos sean distribuidos [26].

3.1.5. Aetion Technologies LLC, Columbus, Ohio


Aetion es un contratista de Defensa, cuyas aplicaciones utilizan inteligencia artificial.
Esta empresa utiliza Haskell de forma exitosa en tres proyectos de gran relevancia para
minimizar el impacto del cdigo de los cambios. El cdigo conciso de Haskell fue ms
importante para la reescritura. DSELs permiti que la Inteligencia Artificial se pudiera
especificar de forma declarativa [17].

Dado que Aetion est enfocado en la necesidad de la inteligencia artificial y el desafo


de afrontar los constantes cambios de dominios, se haca necesario minimizar el
impacto del cdigo de los cambios, por lo que era ms til en dominios con muchas
posibilidades de superposicin o escasos datos [27].

Como resultado de estos tres proyectos se obtienen buenos resultados con Haskell, el
cual les proporcion una gestin de datos con administracin de cambios, reglas de
inferencia y trucos especficos para la aplicacin [27].

25

3.1.6. Eaton Cleveland, Ohio


EATON es una compaa internacional, lder global en la prestacin de servicios en los
sectores energtico e industrial, capaz de producir artculos complejos aplicables en
diversos mbitos (aeroespacial, mecnico automotriz, hidrulico).

Figura 11. http://www.taglianirepuestos.com.ar/imagenes/genericas/foto_eaton.png

En el CUFP 2008 sobre El control de los vehculos hbridos con Haskell, el ponente
Tom Hawkins, de Eaton Corporation, manifiesta que la compaa est desarrollando
sistemas hbridos hidrulicos para aumentar el ahorro del combustible, sobre todo de
los camiones pesados. Estos hbridos hidrulicos funcionan de forma parecida a los
hbridos elctricos, slo que en lugar del motor elctrico y la batera, utilizan bombas,
vlvulas y acumuladores para capturar y devolver la energa cintica de un vehculo.
Estos componentes estn bajo el control de un software y requieren de un alto nivel de
seguridad, lo que se logra mediante el uso de los lenguajes funcionales, que son capaces
de describir el comportamiento crtico, reduciendo la posibilidad de introducir errores
en la fase de diseo. El ponente, explica que su entorno experimental utiliza un DSL
Haskell llamado Atom, que compila un programa de normas de transicin de estados
atmicos en la unidad de control electrnico de un vehculo. Con la programacin de la
regla adecuada, Atom puede transformar un programa multitarea en un solo hilo de
ejecucin, lo que elimina la necesidad de programacin en tiempo de ejecucin, el
cambio de contexto, y la comunicacin entre procesos [28].

26

Al mismo tiempo, la empresa trata de reclutar ingenieros para el desarrollo con Haskell
tal y como podemos apreciar en el anuncio enviado por Tom Hawkins, donde
anunciaba una vacante para un ingeniero para desarrollo Haskell y le deca que Eaton
crea software de control, en tiempo real para aplicaciones de vehculos y maquinarias.
El anuncio hace hincapi en que la posicin que se requiere es para el diseo y
verificacin de sistemas de vehculos hbridos hidrulicos con un peso de ms de
30,000 libras. Al mismo tiempo,l indica que las tareas primarias incluyen el software de
diseo de vehculo, verificacin del sistema de simulacin, anlisis formal, desarrollo
de telemetra para diagnstico remoto y desarrollo de herramientas para automatizar
an ms el diseo. En el anuncio, Hawkins informa que en Eaton utilizan Haskell como
herramienta de anlisis de datos internos y que algunos vehculos ejecutan cdigo
generado por un DSL Haskell. Finalmente, el anunciante dice que esperan poder
ampliar el uso de Haskell, especialmente para suites de regresin de simulacin, tal vez
QuickCheck en combinacin con un sistema modelado y verificacin DSL [29].

A raz de su primera ponencia en 2008, Tom Hawkins de Eaton, relata su experiencia


en el uso de DSL Haskell, a solicitud de algunos participantes, mismo que subi a
Hackage. En este relato explica que Atom es un DSL en Haskell para diseo de
programas embebidos en tiempo real y que en Eaton se utiliza para el control hidrulico
hbrido de camiones de basura y autobuses. Hace nfasis en las siguientes mejoras:

Un planificador simple para balanceo de carga.

Seal de sondeo de depuracin y registro de datos.

Cobertura funcional para monitorear las reglas que se han ejecutado.

Hawkins seala las experiencias del proyecto para diseo y verificacin de los sistemas
del vehculo hbrido hidrulico Eaton:

27

5K lneas de Haskell / Atom reemplaz 120K lneas de Matlab, Simulink, y visual


basic.

2 meses para pasar el diseo Simulink a Atom.

3K lneas de Atom genera 22K lneas de C embebido.

Diseo integrado por 450 reglas de transicin de estado atmico.

Las reglas con perodos de ejecucin de 1 ms a 10 s, todo programado en tiempo


de compilacin a un bucle principal de 1 ms.

El tiempo de compilacin en 3 minutos desde la fuente de Atom hasta ECU [30].

3.1.7. The Big Board: Teleconferencing over High-res Maps con Haskell
El ponente de esta teleconferencia, Jefferson Heard, del Renaissance Computing
Institute, plantea que la emergencia pblica representa un ejemplo reciente de
multitarea y colaboracin en una zona amplia de cobertura. Indica que bomberos,
policas, primeros auxilios, control de multitudes, rescates necesitan dar una respuesta
oportuna y coordinada para salvar vidas y propiedades. Para lograr esto se requiere que
estos organismos tengan conocimiento y control de la situacin, conocer dnde se
encuentran sus recursos y dems caractersticas que se requieran para resolver el
problema, trabajos que muchas veces carece de herramientas tecnolgicas e incluso lo
llevan en papel [31].
Con este proyecto Big Board se reduce la brecha tecnolgica, ya que se proporciona
una fotografa area, lo que facilita la creacin de contenido geo referenciado dinmico
y un mecanismo para la difusin.,m,. simultnea para todos los participantes de la
gestin de una emergencia. El xito es que se da a los administradores de emergencias
una va flexible y confiable para coordinar a travs de mapa, de forma fcil como si
usara papel y lpiz, capaz de funcionar en muchos entornos [31].

28

Con Big Board, los usuarios abren un mapa, se unen a una sala de conferencia virtual y
luego pueden marcar el mapa en un ambiente de colaboracin con las rutas, polgonos,
marcas de posicin y adems agregar contenido, utilizando un wiki, que es generado
como parte de la conferencia. Cuando cada uno de los usuarios marca el mapa, sus
anotaciones son vistas simultneamente por todos los dems integrantes. Adicional, los
servicios web que sirven de contenido geo referenciado pueden ser integrados al mapa
para conocer, por ejemplo, la localizacin de vehculos y sensores de datos en tiempo
real [31].

Esta aplicacin ha sido escrita desde cero en Haskell con backend de PostGIS. Haskell
fue escogido por su caracterstica de evaluacin perezosa, la fiabilidad de las
aplicaciones escritas en este lenguaje, el desarrollo rpido, la escalabilidad multicore y
su compilacin nativa. El diseo de esta aplicacin fue incorporada a dos bibliotecas
reutilizables, a disposicin del pblico en el Hackage: Buster (FRP para la orquestacin
de la aplicacin) y del jeroglfico (para grficas funcionales de vectores 2D) [31].

Segn [32], el tablero Big Board es un entorno colaborativo en tiempo real para trabajar
sobre mapas. Es muy parecido a las conversaciones en una sala de conferencias, solo
que en lugar de compartir presentaciones y discursos los usuarios pueden dibujar y
agregar contenidos sobre mapas compartidos. Esta plataforma es muy similar a Google
Map, ArcInfo o Microsoft VirtualEarth, con la ventaja de contar con la colaboracin en
lnea en lugar de un mapa esttico. Los usuarios de Big Board tienen control total de la
superficie sobre la cual trabajan y al agregar contenido, esto se replica a todos los
participantes de la teleconferencia. El contenido que se genera y no se limita a un
polgono o lnea, ya que el mismo es dinmico con la ayuda del backend PmWiki, que
permite a los usuarios crear sus propios contenidos de hipertexto con anclajes de
polgonos, lneas, puntos, rectngulos o crculos sobre el mapa [32].

29

Figura 12. Big Board con contenido en Firefox [33]

Adems del contenido dinmico generado por el usuario, el tablero Big Board tambin
maneja superposiciones de geometra (provistas por el servidor) y servicios web para
agregar contenidos como alimentador de la misma manera que Google Earth o los
mapas son alimentados con datos. El propsito de este programa es que sea utilizado
por administradores de emergencias como parte de un Centro de Operaciones de
emergencias virtuales o distribuidas. En lugar que todos los administradores de
emergencia estn en una sala y que tengan que comunicar su ubicacin a travs de un
texto, el contenido puede adjuntar directamente sobre un punto en el mapa. La idea es
que un solo localizador de recursos, como los oficiales de campo con celulares, se
puedan reflejar en el mapa y se les permita agregar contenido, como por ejemplo,
imgenes de una escena de desastre, informacin sobre las personas que necesitan
ayuda[32].

En la actualidad este Proyecto se est abriendo a una comunidad ms grande con


cdigo abierto, con la esperanza de que sea una aplicacin ms til y con mayor uso. El
30

autor proporciona el siguiente enlace Stable source snapshot (.tar.gz) para aquellos que
se interesen en conocer un poco ms sobre el proyecto. Tambin incluye una
subversin de repositorio annima https://svn.renci.org/bigboard y una gua de usuario
[34].

3.1.8. Google
Haskell es usado en proyectos internos de Google como Soporte de la infraestructura IT
del proyecto de cdigo abierto Ganeti, el cual representa una herramienta para la
Administracin de Clsteres de Servidores Virtuales construidos sobre Xen y KVM
[17].
Iustin Pop, en su artculo sobre Experience Report: Haskell as a Reagent nos relata,
que como parte del trabajo, el grupo de IT, de la corporacin Google, desarroll el
proyecto Ganeti (http://code.google.com/p/ganeti/), una herramienta de Administracin
de clsteres de mquinas virtuales. Este proyecto fue iniciado en 2006, luego pasa a ser
de cdigo abierto (escrito en Python) en septiembre de 2007; posteriormente se le
agrega el componente Haskell, que emerge gracias a su formato de datos estables y
fciles de usar, incluso desde el Shell. La introduccin de Haskell al proyecto fue algo
accidental. La capacidad de Ganeti fue creciendo y era capaz de manejar grandes
cantidades de clsteres, pero los layouts de algoritmos eran muy dbiles. Este proyecto
(Ganeti) se convierte en un conjunto de pequeas herramientas externas aplicadas al
cdigo base Python. La arquitectura de Ganeti es algo compleja: corre sobre todas las
mquinas fsicas llamadas node daemon, una de estas mquinas es designada como
master node y se ejecuta en dos daemons ms: el master daemons (responsable de la
ejecucin y coordinacin de los node daemons) y remote API daemon. En esta
arquitectura, los nodos daemons realizan un trabajo I/O puro hablando a LVM, DRBM,
y al hypervisor en uso. El master daemon administra la configuracin del clster y
coordina las interacciones entre los nodos daemons.

31

El autor concluye en su artculo que la combinacin de Haskell con Python fue todo un
xito para resolver problemas de la vida real. En general, argumenta que Haskell es
muy buena herramienta para resolver ciertos tipos de problemas, sobre todo los
relacionados a algoritmos matemticos, por lo que est seguro que tanto a nivel de
lenguaje, como a nivel de implementacin (GHC) Haskell es una opcin muy viable
para proyectos de complejidad similar en el dominio de administracin de sistemas
[35].

3.1.9. New York Times


Erik Hinton, filsofo analtico y desarrollador de noticias interactivas del New York
Times, analiza los xitos y fracasos de hacer un cambio cultural en la sala de redaccin,
al admitir Haskell en algunos proyectos dentro de la empresa. Hilton nos comenta que
el NYT utiliza la librera de array de Haskell paralelo para procesar las imgenes de
Semana de la moda New York 2013, y que este lenguaje de programacin fue
escogido basado en la rapidez de sus paquetes de arrays numricos y en su facilidad de
paralelizacin [36].

Figura 13. Huellas digitales en el contexto de Fashion Week (Semana de la Moda) [37]

32

El proyecto de Huella Digital surge de la idea del autor, de visualizar el ritmo y el color
de las colecciones de desfiles de moda, sin tener la necesidad de mostrar directamente
los vestidos. La idea de huellas digitales es inspirada por los personajes animados,
por lo que el autor decide aplicar este concepto a modelos de pasarela, creando fichas
de cada coleccin y sus paletas de color.

Figura 14. Pasos para obtener la huella digital (1. Recortar, 2.Dividir en tres paneles y 3. Obtener el modelo)[35]

El proceso para obtener las huellas digitales les permiti tener visin a travs del
computador de la teora del color con la ayuda de programacin paralela y compilar en
Haskell. De esta forma, lo primero que deban hacer era obtener una galera de fotos de
cada perspectiva, luego cada foto deba ser recortada de forma casi idntica con la
modelo en el centro de la fotografa.

Figura 15. Pasos para obtener la huella digital (4. Elegir una tira, 5.Retirar el modelo extrao y 6. Promediar los
colores, 7. Matemticas)[35]

33

Hasta este punto los mtodos eran obtusos: adivinar y recortar. Ahora realizar el
bloqueo de colores era ms complicado, ya que era necesario tomar cada cuatro filas de
pixeles del pedazo de vestido y reducirlo a su color promedio, lo que resultaba en una
tarea bastante difcil de lograr. Se contaba con una matriz de 150 colores y era
necesario reducirla a menos de 15 colores, por lo que se us el conocido 1dimensional k-means clustering, un algoritmo relativamente simple, que agrupa los
colores en clsteres y el color de cada clster es la menor distancia de cada uno de los
colores anexados por el clster. Afortunadamente, el algoritmo es una instancia de
programacin dinmica, donde el resultado final se construye a partir de resultados
parciales sucesivos.

Cabe sealar que el algoritmo de anlisis para crear estas huellas digitales fue escrito en
Haskell, el cual escogieron al evaluar la calidad del ajuste de la barra de color, dado que
se tenan que ejecutar las 170 colecciones de sus datos de prueba cada vez que
modificaban el algoritmo. Por la complicacin del caso se opt por un lenguaje de alto
rendimiento para facilitar los prototipos complejos, ms que pensar en la experiencia
del usuario. Al realizar las pruebas con Haskell el equip pudo percatarse que el mismo
es dos veces ms rpido que un prototipo Ruby. El resultado con Haskell permiti una
vinculacin mxima a la CPU y gracias a las garantas matemticas proporcionadas por
Haskell pudieron paralelizar la operacin sobre mltiples ncleos de CPU sin cambiar
una lnea de cdigo, obteniendo una velocidad cuatro veces mayor. Todas estas
caractersticas que proporciona Haskell estn disponibles con la librera REPA.

Figura 16. Huellas digitales futuras

34

3.1.10. Humane Software


Esta compaa se dedica al desarrollo de sistemas empresariales con backends asncronos
de Haskell y Javascript UIs. El caso de estudio refiere a un cliente de la empresa, un
proveedor de Internet, a quien se le implement una solucin de mltiples mquinas
remotas de monitoreo y anlisis de gigabytes de muestras de trfico. En esta
implementacin Haskell demostr ser una excelente herramienta para el trabajo, ya que
se hizo posible reemplazar sistemas heredados en forma granular, pieza por pieza, y al
mismo tiempo ofrecer nuevas caractersticas[17].

Continuando con este trabajo, se presenta en la siguiente seccin la demostracin de la


implementacin Haskell Paralelo.

35

CAPTULO IV
4.1. IMPLEMENTACIN Y PRUEBAS DE HASKELL PARALELO A TRAVS
DE UN CDIGO DE EJEMPLO
Para efectos de nuestro ejemplo vamos a realizar la implementacin de la plataforma
Haskell, que contiene el compilador para la realizacin de pruebas, utilizando un cdigo
de ejemplo para representar paralelismo con este lenguaje de programacin.

Con el objetivo de preparar el entorno de desarrollo, primero se realiz la instalacin de


la plataforma Haskell 2014 para Linux - Ubuntu (Haskell Platform 2014.2.0.0 para
Linux, 64bit), que contiene el compilador GHC y la librera Cabal de la siguiente
direccin http://www.haskell.org/platform/linux.html. Luego actualizamos la librera
Cabal con $Cabal Update para hacer uso de las bibliotecas que nos proporciona el
lenguaje. Posteriormente para verificar si ya la instalacin del compilador GHC se haba
realizado correctamente utilizamos el comando $ whereis ghc y lo ejecutamos.

Previamente, decidimos mostrar la ejecucin del mdulo GHC.Conc, el cual exporta una
variable de Haskell, numCapabilities, que nos permite encontrar el nmero de ncleos
disponibles en nuestro equipo, tal y como se muestra a continuacin:

Figura 17. Ejecucin de mdulo GHC.Conc desde un compilador Haskell Online

36

Figura 18. Ejecucin de mdulo GHC.Conc desde un compilador GHC Ubuntu

Luego que conocemos la cantidad de cores con los que cuenta nuestra PC y hemos
instalado el compilador satisfactoriamente, creamos una carpeta donde colocaremos
nuestras funciones, mdulos y programas. Nos cambiamos a ese directorio:
/cd/home/alleyne/PruebasHaskell y empezamos a realizar nuestras pruebas.

Con la idea de ir explicando de lo ms sencillo a lo ms complejo, y dado que Haskell


soporta muy bien la programacin paralela y multincleo, deseamos iniciar con la
escritura de un programa paralelo, aadiendo par y seq a las expresiones. Para ello,
instalamos las libreras paralelas que vamos a utilizar con la instruccin $ cabal install
parallel y realizamos algunas pruebas con la funcin Fib.hs, dndole instrucciones en
paralelo y ejecutamos con 2 ncleos para ver comportamiento.

Figura 19. Cdigo Paralelo Fib,hs

37

Lo compilamos con threades (enhebrados) y optimizadores as: $ ghc -O2 --make Fib.hs
-threaded rtsopts. Luego ejecutamos nuestro programa multincleo Fib.hs con 2
ncleos: $ time ./A +RTS -N2.

Figura 20. Instalacin de librera paralela, compilacin y ejecucin de programa Fib.hs con 2 cores

Considerando que nuestra investigacin trata de describir la programacin paralela


Haskell para evaluar si realmente se obtienen mejores resultados al dividir la solucin y
ejecutar en muchos ncleos a la vez. Para ello, podemos tomar una funcin normal de
Haskell, aplicarle unas cuantas modificaciones y de esta forma evaluarlas en paralelo.

Para nuestro caso, tomaremos el ejemplo del cdigo para ordenar una lista Sort. En la
demostracin usaremos un solo programa SortMain.hs, que contiene la lgica para los
diferentes tipos de ordenacin de listas, con sus respectivas funciones: sort (secuencial),
parSort (programacin paralela), seqSort (secuencia paralela) y parSort2 (para la
optimizacin en paralelo). Se van a crear varios archivos para ejecutar la funcin
Sorting.hs y se irn renombrando cada vez que se alterne la funcin Sort a evaluar en el
38

SortMain.hs; a medida que hagamos las pruebas insertamos la funcin Sorting.hs en


/home/alleyne/PruebasHaskell y vamos ejecutando cada una de las funciones de
ordenamiento de listas para evaluar el tiempo de ejecucin, ya sea de forma secuencial o
paralela y segn el nmero de cores que utilice para ejecutar.

Iniciamos nuestras pruebas con la ordenacin de la lista en forma Secuencial y


ejecutamos la instruccin $ ghc -threaded -O2 --make SortMain, con lo cual se genera
el programa principal SortMain.hs y luego vamos ejecutando las instrucciones que
indican la cantidad de ncleos que deseamos usar en la ejecucin del programa paralelo y
la cantidad de elementos a ordenar (950,000): $ ./SortMain +RTS N2 -RTS 950000.

Esta funcin est inspirada en el algoritmo QuickSort.

Figura 21. Cdigo Sorting.hs (Sort Secuencial)

39

Figura 22. Cdigo SortMain.hs

Figura 23. Compilacin y ejecucin del programa Sort Secuencial

Ahora bien, transformamos nuestro cdigo en una versin en paralelo, aadiendo tres
funciones: par, pseq y force provistas por el mdulo Control.Parallel de Haskell. La
funcin par se compromete a evaluar en paralelo slo si esta expresin tiene sentido y se
le da al sistema la libertad de escoger cuando usarla.

40

Para ejecutar y medir el desempeo de nuestro cdigo en paralelo cargamos a nuestra


carpeta el archivo Sorting.hs que tiene la funcin parSort y editamos el SortMain.hs para
que se ejecute sobre la funcin que contiene el parSort.

Figura 24. Cdigo Sorting.hs (parSort)

Cuando construimos el programa SortMain hacemos posible la optimizacin y el tiempo


de ejecucin de los hilos. Igualmente, cuando ejecutamos el programa, le debemos decir
al compilador GHC cuantos ncleos se van a usar en la ejecucin.

Figura 25. Compilacin y ejecucin del programa parSort

41

Si comparamos los resultados, primeramente del Sort Secuencial, vemos que no hay
diferencias entre la ejecucin del cdigo con uno o varios cores. Luego si lo comparamos
con los resultados del cdigo parSort vemos que prcticamente los resultados son los
mismos y no se ha ganado nada de rendimiento. No se ven tiempos menores de
ejecucin, por el contrario cada vez que se aumentaba la cantidad de ncleos aumentaba
un poco el tiempo, lo que puede deberse a mucho uso del par o es muy costoso aplicarlo.

Para ver cul de las dos posibilidades est dando los resultados negativos a pesar de usar
el par, utilizaremos la funcin seqSort para evaluar los resultados del par.

Figura 26. Cdigo Sorting.hs (seqSort)

Figura 27. Compilacin y ejecucin de la funcin seqSort

42

Analizando los resultados de evaluacin del seqpar, an vemos que los costos de
rendimiento se mantienen prcticamente iguales, por lo que este cdigo tampoco hace la
diferencia. En este caso, se hace necesario ajustar la funcin para obtener mayor
rendimiento, por lo que le damos al parSort el doble de solicitudes y cuando aplicamos
recursividad al parSort aplicamos al mismo tiempo par a la lista de los elementos
individuales. En este caso, el costo de usar par es mayor que cualquier utilidad y para
reducir este efecto se hace necesario hacer switch al cdigo par no paralelo despus de
pasar el gran volumen de elementos.

En consecuencia, probamos con la compilacin y ejecucin de la funcin parSort 2 para


la realizacin y evaluacin de optimizacin, como sigue:

Figura 28. Cdigo Sorting.hs (parSort 2)

43

Figura 29, Compilacin, ejecucin y optimizacin de la funcin seqSort

Se alcanzan los siguientes resultados:

Se concibe un notable rendimiento en los tiempos de ejecucin en el cdigo de


ordenamiento de la lista cuando se agregaron los argumentos de programacin
paralela par y seq al cdigo secuencial. El cdigo para programacin secuencial
en un solo ncleo nos arroj aproximadamente 4.53 segundos, contrario a los
1.96 segundos que nos arroj el mismo cdigo con programacin paralela, ambos
con la misma cantidad de ncleos; lo que nos representa un 43% de optimizacin.

En el programa con dos ncleos, esto nos dio mas o menos un aumento de
velocidad del 46%; de 4.84 s a 2.26 s, por lo que consideramos que esta funcin
de ordenacin nos proporciona un buen rendimiento en programacin paralela.

44

CAPTULO V
5.1. CONCLUSIONES
Hiptesis: Es Haskell Paralelo un entorno de programacin ideal para el contexto
cientfico y comercial.
Hoy por hoy, Haskell es un lenguaje de programacin funcional puro, su evaluacin
perezosa, los mdulos y funciones que provee para la programacin paralela lo
convierten en un entorno de programacin ideal para el rea cientfica y comercial.

De acuerdo a informacin encontrada en el presente documento, Haskell cuenta con un


sitio propio https://www.haskell.org/ con una comunidad activa y un sinnmero de
investigadores que han impulsado el desarrollo de aplicaciones con Haskell, por ejemplo,
NASA est utilizando Haskell para fines acadmicos. De la misma forma, pudimos
observar a travs de los casos de estudios presentados el auge que est teniendo en el
mbito comercial, desde el desarrollo de aplicaciones financieras, energticas hasta su
utilizacin en inteligencia artificial.

Objetivo General: Describir la programacin paralela y concurrente con Haskell


mediante casos de estudio.

Se logr el objetivo general planteado en el presente trabajo, el cual se desarrolla


ampliamente en el captulo III con la presentacin de diez (10) casos de estudios. A lo
largo de este captulo, autores de diversas fuentes nos cuentan los logros obtenidos en sus
empresas al implementar programacin paralela y concurrente con Haskell, sustentndose
de esta forma la aplicacin real del lenguaje de programacin en el mercado actual.

45

Objetivos Especficos:
Definir los antecedentes y base terica de la programacin paralela y concurrente
con Haskell.

La exposicin de los antecedentes del lenguaje de programacin funcional Haskell, sus


principales caractersticas y su evolucin hacia la programacin paralela y concurrente
se obtiene en el estado del arte del captulo II, seccin 2.1, con la revelacin de
innumerables cualidades que hacen de este lenguaje funcional uno de los ms
poderosos a travs de su evaluacin perezosa, tipos de datos estticos, recursin de
datos, inclusin de patrones, y mdulos, entre otros.
Establecer diferencias entre la programacin paralela y concurrente

En la seccin 2.1.1 del captulo II, se consigui establecer la diferencia entre


paralelismo y concurrencia a travs de las definiciones y anlisis de diversos autores
citados, quienes nos aportaron los elementos diferenciadores en un lenguaje sencillo.
Identificar los principales mdulos y funciones de programacin paralela

concurrente que provee Haskell.

Se logr la identificacin de los principales mdulos y funciones que provee Haskell


para la ejecucin de programacin paralela y concurrente a travs de su desarrollo en
el captulo II, Secciones 2.1.2 y 2.1.3. Haskell se vale de mdulos tales como: la
Monada Eval - con dos operaciones rpar y rseq; las Estrategias - un API de alto
nivel para la programacin paralela y un medio para la modularidad del cdigo
paralelo, al separar el algoritmo del paralelismo; Map Reduce - tcnica con alto
grado de procesamiento paralelo sobre grandes volmenes de datos; Dataflow
Parallelism - ayuda a que la granularidad y las dependencias de datos sean ms
46

explcitas para evitar la subordinacin de la evaluacin perezosa; Programacin de


Data Parallel con Repa - matrices paralelas regulares que proporciona un alto
rendimiento; Paralelismo con datos anidados - provee un alto rendimiento y soporta
a gran escala la programacin multicore. Adicional, se describen brevemente los
principales modelos para la ejecucin de programacin concurrente con Haskell con
MVar y Threads (hilos).
Identificar, analizar y presentar casos de estudio que apliquen a la programacin
paralela y concurrente Haskell.

Este objetivo se alcanza y desarrolla a lo largo del captulo III con el testimonio de
diez (10) casos de estudios de corporaciones que utilizan la programacin paralela y
concurrente con Haskell para la resolucin de problemas y ejecucin de sus nuevos
proyectos a saber: Proyecto Haxl Open Source Facebook, el cual permite el acceso
a sus datos de Facebook con Haskell; IMVU que utiliza Haskell desde 2013 para
construir varias de las APIs REST (Cliente 3D) que soportan su sitio web; Barclays
Capital Quantitative Analytics Group est usando Haskell para desarrollar un
lenguaje funcional embebido de dominio especfico llamado FPF, que se utiliza para
especificar las derivadas de la equidad extica en trminos de funciones matemticas;
Parallel Scientific, utiliza Haskell para el desarrollo de un sistema de gestin ultra
escalable de recursos de alta disponibilidad para grandes clsteres (millones de nodos);
Aetion Technologies, contratista de Defensa, cuyas aplicaciones utilizan inteligencia
artificial, maneja Haskell en tres proyectos de gran relevancia para minimizar el
impacto del cdigo de los cambios; Eaton est desarrollando sistemas hbridos
hidrulicos para aumentar el ahorro del combustible bajo el control de un software con
un alto nivel de seguridad, lo cual se ha logrado mediante el uso del lenguaje funcional
Haskell; El proyecto The Big Board: Teleconferencing over High-res Maps con
Haskell reduce la brecha tecnolgica, proporcionando una fotografa area, lo que
facilita la creacin de contenido geo referenciado dinmico y un mecanismo para la
47

difusin simultnea para todos los participantes de la gestin de una emergencia;


Haskell es usado en proyectos internos de Google como soporte de la infraestructura
IT en el proyecto de cdigo abierto Ganeti, el cual representa una herramienta para
la administracin de Clsteres de Servidores Virtuales; el New York Times utiliza la
librera de array de Haskell paralelo, el cual proporciona rapidez de los paquetes
numricos y facilidad de paralelizacin para procesar las imgenes de Semana de la
moda New York 2013; y finalmente, Humane Software, desarrolla sistemas
empresariales con backends asncronos de Haskell y Javascript UIs.
Comparar la programacin Haskell de forma secuencial y paralela a travs de la
ejecucin de un cdigo de ejemplo.

En el captulo IV se representa la instalacin del compilador de Haskell GHC, la


implementacin de la plataforma Haskell y la librera Cabal; herramientas con las
cuales se formaliza la ejecucin de un cdigo de ejemplo tanto en programacin
secuencial como en programacin paralela, con la cual alcanzamos el objetivo
planteado al ejecutar el cdigo de ejemplo, usando la estructura de programacin
paralela. Para esto, se escogi un cdigo para ordenar una lista de elementos, con un
programa piloto llamado SortMain, el cual contiene el llamado a cuatro funciones de
ordenamiento (Sort, parSort, seqSort, parSort2), los cuales fuimos probando uno a uno
para realizar la evaluacin del desempeo y optimizacin del cdigo en secuencial y
en paralelo y as demostrar que con la utilizacin de argumentos y funciones de
programacin paralela nuestro cdigo ejecutado en varios ncleos, dara mejor
rendimiento y rapidez en la ejecucin. Las funciones se convertan en paralelas
siempre que se suministraba + RTS - Nwhatever en el comando de lnea al ejecutar el
programa.

Una vez expuestos los logros alcanzados en el presente trabajo y los resultados obtenidos
en la implementacin y pruebas del cdigo de ejemplo podemos indicar que se lograron
48

los objetivos propuestos y se obtuvieron resultados palpables de que la inclusin de


cdigo paralelo en tiempo de ejecucin, indicando la cantidad de ncleos a utilizar le
brinda mejor rendimiento y tiempos de respuestas ms rpidos. Esto nos lleva a
comprobar nuestra hiptesis, que Haskell representa un entorno ideal de programacin
paralela para el rea cientfica y comercial.

Como trabajo futuro recomendamos seguir experimentando con la amplia cantidad de


ejemplos que la comunidad de Haskell nos ofrece, ya que constituye una importante lnea
de investigacin.

49

BIBLIOGRAFA Y REFERENCIAS
[1]

J. Inca Chiroque, "Estudio del lenguaje de programacin Haskell, ventajas y desventajas


con respecto a otros lenguajes de programacin," Magster en Informtica con mencin
en Ciencias de la Computacin, Escuela de Posgrado, Pontificia Universidad Catlica del
Per, Lima, Per, 2012.

[2]

HaskellWiki.
(2013,
October
2014).
Haskell
http://www.haskell.org/haskellwiki/Introduction

[3]

A. Baicoianu, R. Pandaru, and A. Vasilescu, "Upon the Performance of a Haskell Parallel


Implementation," Bulletin of the Transilvania University of Brasov Vol, vol. 6, 2013.

[4]

R. Loogen, "Eden --- parallel functional programming with haskell," presented at the
Proceedings of the 4th Summer School conference on Central European Functional
Programming School, Budapest, Hungary, 2012.

[5]

H. Ferreiro, V. Janjic, L. M. Castro, and K. Hammond, "Repeating History: Execution


Replay for Parallel Haskell Programs," in Trends in Functional Programming, ed:
Springer, 2013, pp. 231-246.

[6]

G. G. Neves De Oliveira and R. A. Lapellegrini Petri. (2010, Septiembre 13, 2014).


Haskell. Available: http://es.slideshare.net/renzopetri/seminario-haskell

[7]

Wozgeass. (2010, Septiembre 13, 2014). Qu funcin desempea el kernel? Available:


http://wozgeass.wordpress.com/page/4/

[8]

S. Marlow, "Parallel and concurrent programming in Haskell," in Central European


Functional Programming School, ed: Springer, 2012, pp. 339-401.

[9]

B. O'Sullivan, D. Stewart, and J. Goerzen. (2008, September 9, 2014). Real World Haskell.
Available: http://book.realworldhaskell.org/read/

[10]

D. Coutts and A. Loh, "Deterministic parallel programming with Haskell," Computing in


Science & Engineering, vol. 14, pp. 36-43, 2012.

[11]

S. Marlow, Parallel and Concurrent Programming in Haskell: " O'Reilly Media, Inc."
Ebook, 2013.

[12]

HaskellWiki. (2012, September 9, 2014). Applications and libraries/Concurrency and


parallelism.
Available:
http://www.haskell.org/haskellwiki/Libraries_and_tools/Concurrency_and_parallelism

[13]

HaskellWiki. (2014, 9 September 2014). Research papers/Parallelism and concurrency.


Available:

50

Introduction.

Available:

http://www.haskell.org/haskellwiki/Research_papers/Parallelism_and_concurrency#Co
ncurrent_Haskell
[14]

Integrated SCM & Project Management. (2012, September 13, 2014). The Repa Package.
Repa (REgular PArallel arrays). Available: http://repa.ouroborus.net/

[15]

B. J. Svensson and M. Sheeran, "Parallel programming in Haskell almost for free: an


embedding of intel's array building blocks," in Proceedings of the 1st ACM SIGPLAN
workshop on Functional high-performance computing, 2012, pp. 3-14.

[16]

R. Yates, "Improving the Performance of Synchronization in Concurrent Haskell1," Thesis


Proposal, Department of Computer Science, University of Rochester, 2014.

[17]

HaskellWiki.
(2014).
Haskell
in
http://www.haskell.org/haskellwiki/Haskell_in_industry

[18]

S. Marlow. (2014, October 6, 2014). The Haxl Project at Facebook. Available:


http://www.infoq.com/presentations/haxl?utm_source=infoq&utm_medium=related_c
ontent_link&utm_campaign=relatedContent_news_clk

[19]

R. Shenoy. (2014). Facebook Open-sources Haxl: Implicit, Concurrent Data Access Using
Haskell.
Available:
http://www.infoq.com/news/2014/06/haxl?utm_source=infoq&utm_medium=related_
content_link&utm_campaign=relatedContent_presentations_clk

[20]

A. Friesen. (2014, October 2014). What it's like to use Haskell. Available:
http://engineering.imvu.com/2014/03/24/what-its-like-to-use-haskell/

[21]

Barclays Capital Quantitative Analytics Group. (October 2014). Barclays Capital


Quantitative Analytics. Available: https://www.wikijob.co.uk/wiki/barclays-capitalquantitative-analytics

[22]

T. Williams. (2014, 06/10/2014). Haskell at Barclays: Exotic Tools for Exotic Trades.
Available:
http://www.infoq.com/presentations/haskellbarclays?utm_source=infoq&utm_medium=related_content_link&utm_campaign=relat
edContent_presentations_clk

[23]

S. Frankau, D. Spinellis, N. Nassuphis, and C. Burgard. (2008, Commercial Uses: Going


functional on exotic trades. Available: http://www.lexifi.com/downloads/frankau.pdf,
http://lambda-the-ultimate.org/node/3331

[24]

Barclays Capital Quantitative Analytics Group. (2013, October 6, 2014). Barclays are
hiring:
Haskell
developers
in
London
and
Kiev.
Available:
http://www.reddit.com/r/haskell/comments/1p70l3/barclays_are_hiring_haskell_devel
opers_in_london/

51

Industry.

Available:

[25]

J. Epstein, "HA - A Development Experience Report," Parallel Scientific Labs.

[26]

J. Epstein. (2013, 04/10/2014). Building scalable, high-availability distributed systems in


Haskell.
Available:
http://cufp.org/2013/jeff-epstein-parallel-scientific-buildingscalable.html#

[27]

Aetion - Commercial Users of Functional Programming (CUFP), "Artificially Intelligent


Haskell," ed, 2014.

[28]

T. Hawkins. (2008, October 2014). Commercial Users of Functional Programming (CUFP).


Available: http://cufp.galois.com/2008/abstracts.html#HawkinsTom

[29]

T.
Hawkins.
(2008,
October
2014).
Haskell
http://article.gmane.org/gmane.comp.lang.haskell.cafe/37093

[30]

T. Hawkins. (2009, October 2014). Eaton's experiences using a Haskell DSL[Available:


http://www.haskell.org/pipermail/haskell-cafe/2009-April/060602.html

[31]

H. Jefferson. (2009, October 2014). Commercial Users of Functional Programming


(CUFP). Available: http://cufp.galois.com/2009/abstracts.html

[32]

J. Heard. (2009, October 9, 2014). Open Sourcing The Big Board. Available:
http://vis.renci.org/jeff/2009/08/26/open-sourcing-the-big-board/

[33]

(2009, October 9, 2014). The Big Board, by the Renaissance Computing Institue.
Available: http://vis.renci.org/jeff/wp-content/uploads/2009/08/screenshot-1.png

[34]

J. Heard. (2009, October 9, 2014). The Big Board Administrators and Users Guide
v3.0.0.
Available:
http://vis.renci.org/jeff/wpcontent/uploads/2009/08/bbuserguide.pdf

[35]

I. Pop. (October 9, 2014). Experience Report: Haskell as a Reagent. Available:


http://k1024.org/~iusty/papers/icfp10-haskell-reagent.pdf

[36]

E. Hinton. (2014, October 9, 2014). Haskell in the Newsroom. Available:


http://www.infoq.com/presentations/haskell-newsroom-nyt

[37]

E. Hinton. (2013, October 9, 2014). The New York Times Erik Hinton breaks down a
Fashion Week special. Available: https://source.opennews.org/en-US/articles/modelanalysis/

52

Jobs.

Available:

ANEXOS
A continuacin, les dejo algunos de los enlaces que contienen ejemplos de cdigos
paralelos para la adquisicin de mayor conocimiento y experiencia en el uso Haskell
paralelo, que en la actualidad brinda grandes beneficios a la industria del desarrollo de
software:

Para

matrices

paralelas

regulares,

polimrficas

de

alto

rendimiento

http://repa.ouroborus.net o bien en el repositorio https://github.com/DDCSF/repa

http://www.haskell.org/haskellwiki/Numeric_Haskell:_A_Repa_Tutorial

Haskell Gamer 3D http://www.hgamer3d.org/AppendixHGamer3D.html#haskellpackages

http://mainisusuallyafunction.blogspot.com/2011/10/quasicrystals-as-sums-ofwaves-in-plane.html

http://book.realworldhaskell.org/read/concurrent-and-multicoreprogramming.html

53