peta - palabras reservadas haskell
Hacer pequeños ejecutables Haskell? (7)
¿Hay alguna buena forma de hacer pequeños ejecutables haskell? Con ghc6, un simple programa hello world parece llegar a unos 370kB (523kB antes de la tira). Hola mundo en C es de aproximadamente 4kB (9kB antes de la tira).
Con la rama de desarrollo de GHC (¿alguien sabe exactamente en qué versión se ha agregado esto?):
$ ghc -o hello hello.hs
$ strip -p --strip-unneeded --remove-section=.comment -o hello-small hello
$ du hello hello-small
700 hello
476 hello-small
Agregue la bandera -dinámica para un RTS dinámicamente vinculado:
$ ghc -dynamic -o hello hello.hs
$ strip -p --strip-unneeded --remove-section=.comment -o hello-small hello
$ du hello hello-small
24 hello
16 hello-small
Ver también: http://hackage.haskell.org/trac/ghc/wiki/SharedLibraries/PlatformSupport
Para la comparación con C:
$ gcc hello.c -o hello
$ strip -p --strip-unneeded --remove-section=.comment -o hello-small hello
$ du hello hello-small
12 hello
8 hello-small
Deberías contar tus bendiciones (370Kb? Luuuxury):
bash$ sbcl This is SBCL 1.0.24, an implementation of ANSI Common Lisp. * (sb-ext:save-lisp-and-die "my.core") [undoing binding stack and other enclosing state... done] [saving current Lisp image into ./my.core: ... done] bash$ du -sh my.core 25M my.core bash$
En serio, aunque es probable que sacudas un poco los binarios haskell, en realidad no es una comparación justa con C. Hay algo más que hacer allí.
La última vez que jugué con ghc (y esto podría estar desactualizado) fue vincular estáticamente todo, lo cual será un factor.
El tamaño que está viendo es el tiempo de ejecución de Haskell (libHSrts.a), que está enlazado estáticamente en cada ejecutable de Haskell. Si fuera un objeto compartido, como librt.o para C, su binario sería solo de unos k (el tamaño de un archivo .o dividido en el origen de la biblioteca).
A menos que implemente la vinculación dinámica de libHSrts.a en su plataforma, puede hacer que sus ejecutables sean más pequeños a través de la tira.
GHC está enlazando estáticamente todo (excepto las bibliotecas utilizadas por el tiempo de ejecución, que están vinculadas dinámicamente).
En las edades antiguas, GHC vinculó la biblioteca completa (haskell) tan pronto como usaste algo de ella. Hace algún tiempo, GHC comenzó a vincular "por archivo obj", lo que redujo drásticamente el tamaño del binario. A juzgar por el tamaño, debes haber estado usando el GHC más nuevo.
En el lado positivo, ya tienes muchas cosas en esos 500K, como núcleo multiproceso, recolector de basura, etc.
Agregue al menos recolector de basura a su código C, luego compárelos de nuevo :)
Las cosas están cambiando: esté atento a this curso.
Si el tamaño de tu binario realmente importa, puedes usar la herramienta gzexe que empaqueta un ejecutable (preferiblemente ya eliminado) con la compresión gzip. En mi caja Linux de 64 bits, el programa hello world original toma 552 KB, después de eliminar 393 KB, y después de pelar y descomprimir 125 KB. El lado más oscuro de gzipping está en el rendimiento: primero hay que desempaquetar el archivo ejecutable.
strip -p --strip-unneeded --remove-section=.comment -o your_executable_small your_executable
También intente mirar ldd -dr your_executable