On 1/16/13 4:06 PM, Chema Cortes wrote:
El día 16 de enero de 2013 15:17, Francesc Alted <fal...@gmail.com> escribió:
Yo no puedo opinar mucho de la interacción de LLVM con Julia por que no lo
conozco demasiado, pero sí que puedo decir que en Continuum estamos poniendo
a punto Numba (https://github.com/numba/numba), un compilador al vuelo (JIT)
que traduce código Python al lenguaje intermedio (IR) que usa LLVM
internamente. LLVM, a su vez, compila el IR a código nativo (que depende de
la platforma) y lo ejecuta (o lo puede guardar en un fichero binario, esto
ya depende de la aplicación).
Numba permite, mediante decoradores y anotaciones de tipo, hacer que
funciones puras en Python (ahora mismo no se soporta todo el lenguaje, pero
sí un subconjunto bastante amplio) puedan correr a velocidad de C puro, y lo
que es mejor, de manera completamente interactiva (la compilación al vuelo
es realmente rápida). Numba es completamente open-source, así que
cualquiera puede contribuir al proyecto (de hecho alguien de esta lista ya
menciona que han contribuido ya).
Creo que ya tengo claro cómo usáis LLVM en numba. Incluso veo que
permite la compilación estática además de JIT, lo que seguramente
tiene que dar resultados bastantes buenos.
Sí, pero cuando digo que el JIT de Numba es rápido, es porque lo es, y
mucho. Por ejemplo, en la transparencia 36 y 37 de esta presentación:
https://python.g-node.org/wiki/_media/starving_cpu/starving-cpu.pdf
se puede ver que el tiempo de compilación para el código es de unos 20
ms, que normalmente es despreciable para rutinas que suelen ser el
cuello de botella de cálculos complicados.
Tenía interés en saber si LLVM facilitaba la concurrencia y el cómputo
distribuido. Por lo que veo, Julia tiene estas facilidades, pero debe
ser cosecha propia. También estoy viendo proyectos para portar otros
lenguajes como scala o C# a LLVM, por lo que parece que esta
plataforma empieza a tomar auge y, tal vez, lleguemos a librarnos de
JVM y .Net.
Pero no hay que llevarse a engaño: LLVM realmente no es una tecnología
demasiado útil para PyPy, ya que éste último viene con su propio compilador
JIT, asi no se complementan demasiado bien. En Continuum claramente hemos
apostado más por LLVM (via Numba) que por la vía PyPy. La ventaja de Numba
es que no se tiene por qué renunciar a librerias que son extensiones (el
proyecto de migración de NumPy a PyPy está siendo lento y plagado de
trampas, y ya somos muchos los que dudamos de que se pueda llevar a cabo de
una manera completa). Numba permite compilar de manera selectiva la parte
de código Python que es un cuello de botella, respetando toda la gama de
librerias y extensiones que ya existen ahora mismo.
Por supuesto que Blaze (https://github.com/ContinuumIO/blaze), nuestro
proyecto para reemplazar NumPy para problemas de Big Data, usará Numba como
motor de cálculo de manera que el usuario no tenga que preocuparse de hacer
extensiones para optimizar los cálculos, sino que éstos se efectuarán a
velocidad de C (¡y sin arrays temporales!) directamente. Blaze es otro
desarrollo open source, y aunque todavía está en su infancia, esperamos que
de aquí a no mucho tiempo ya pueda ser posible hace cosas interesantes con
él.
No conocía Blaze. Le echaré un vistazo. Ya solo os falta un proyecto
para computación distribuída ;-)
Bueno, ese el espíritu de Blaze, que nos valga para computación
distribuida. En http://blaze.pydata.org/vision.html se puede leer:
"""
Just as NumPy is the center of an ecosystem of singe-node, in-memory
tools that use the NumPy array as a common shared abstraction around a
single pointer to memory, Blaze is the center of an ecosystem of
multiple-node, multiple-segment, and multiple calculation-unit
algorithms and programs. The common meme in effective use of Blaze is
that developers should think about their data and the operations that
should be done on their data in an array-oriented fashion, and that code
should be moved to data as much as possible.
"""
Así que el tema de computación distribuida está definitavmente en
nuestro radar. En particular, y dado lo caro que es el transporte de
datos, y como se lee arriba, nuestro objetivo es llevar el código donde
están los datos, y no al revés. Ahí es donde Numba (y LLVM) van a ser
realmente importantes.
--
Francesc Alted
_______________________________________________
Python-es mailing list
Python-es@python.org
http://mail.python.org/mailman/listinfo/python-es
FAQ: http://python-es-faq.wikidot.com/
