X-Git-Url: https://git.llucax.com/z.facultad/75.00/presentacion.git/blobdiff_plain/39db1a27fc811db16e2fc51cf39ab3771a7c23a3..9e5727f7f74cc5b7ae8b4e27574768d9fa42aa3b:/presentacion.rst diff --git a/presentacion.rst b/presentacion.rst index 41a6e61..3f190bb 100644 --- a/presentacion.rst +++ b/presentacion.rst @@ -17,7 +17,7 @@ Presentación Motivación ~~~~~~~~~~ * Recolección de basura -* Lenguaje de programación **D** +* Lenguaje de programación D * Utilidad → Software Libre → Contribución @@ -42,7 +42,7 @@ Introducción ¿Cómo? -Algoritmos clásicos +Algoritmos Clásicos ~~~~~~~~~~~~~~~~~~~ * Conteo de referencias * **Marcado y barrido** @@ -54,7 +54,7 @@ Algoritmos clásicos .. dummy: para que ande bien el raw de arriba -Estado del arte +Estado del Arte ~~~~~~~~~~~~~~~ * Medio siglo de investigación y desarrollo (3000+ publicaciones) * Objetivo @@ -73,10 +73,10 @@ Estado del arte * Análisis estático -El lenguaje de programación D +El Lenguaje de Programación D -------------------------------------------------- -Características generales +Características Generales ~~~~~~~~~~~~~~~~~~~~~~~~~ * Sintaxis tipo C/C++ * Compilado @@ -92,140 +92,218 @@ Paradigmas * ``extern (C)`` * ``malloc()`` + → Conservativo + Manipulación de *root set* + * Programación de alto nivel ← Python/Ruby/Perl * *GC* * ``T[]``, ``T[K]`` + → Punteros interiores + * Orientación a objetos ← Java * ``~this()`` -* Programación genérica y meta-programación ← C++ -* Programación por contratos ← Eiffel + → Finalización -.. r2b-note:: - * Programación de bajo nivel (*system-programming*) ← C/C++ - * **asm**, ``goto``, **align**, ``struct``, **union**, **link-compitble con C**, - **malloc** +Recolector de Basura de D +============================================================================== - * Programación de alto nivel ← Python/Ruby/Perl +Implementación Actual +-------------------------------------------------- - * **GC**, module/import, ``delegate``, ``lazy``, *strings*, **arreglos dinámicos - y asociativos**, ddoc, inferencia de tipos (ltd), ``foreach`` +Organización del Heap +~~~~~~~~~~~~~~~~~~~~~ +*Heap* → *Pools* → Páginas → Bloques + Listas de libres - * Orientación a objetos ← Java +.. image:: img/heap.pdf + :height: 6.7cm - * Más Java que C++: semántica de referencia, métodos siempre virtuales, herencia - simple + interfaces, clases anidadas, **destructores**... + Properties +Bloques +~~~~~~~ +* Tamaño fijo (por página) - * Programación genérica y meta-programación ← C++ + * Potencias de 2 + * De 16 a 4096 bytes + * Más de 4096 (una página) - * ``static if``, ``typeof``, (*variadic*) ``tamplate``, *CTFE*, (*string*) - ``mixin``\ s, expresiones ``is`` + * Objeto **grande** + * Múltiplo de páginas: 4096, 8192, ... + * En páginas contiguas (y mismo *pool*) - * Programación por contratos ← Eiffel +* Indicadores (*bit sets* en *pool*) - * Excepciones, ``assert``, pre/post condiciones, ``invariant``, ``unittest``, - ``scope``, inicialización garantizada, *RAII*, ``synchronized`` + * Marcado + * *mark* + * *scan* + * *noscan* + * Barrido -Recolección de Basura en D -============================================================================== + * *free* + * *finals* -Requerimientos --------------------------------------------------- +Algoritmo +~~~~~~~~~ +* Marcado y barrido -Según paradigma -~~~~~~~~~~~~~~~ -* Programación de bajo nivel + * Marcado iterativo - * ``asm`` - * ``union`` - * ``extern (C)`` - * ``malloc()`` +* Conservativo - → Conservativo + Manipulación de *root set* + * Con una pizca de *precisión* (``NO_SCAN``) -* Programación de alto nivel ← Python/Ruby/Perl +* *Stop-the-world* - * ``T[]``, ``T[K]`` + * Durante el marcado, en teoría - → Punteros interiores - -* Orientación a objetos ← Java +* *Lock* global - * ``~this()`` - - → Finalización + * Muy propenso a extender el tiempo de *stop-the-world* en la práctica -Implementación Actual +Lo Bueno, lo Malo y lo Feo -------------------------------------------------- -Organización del heap -~~~~~~~~~~~~~~~~~~~~~ -.. image:: img/heap.pdf - :height: 7cm +Lo Bueno +~~~~~~~~ +* Anda :) +* Organización del *heap* (*two-level allocation*) +* Marcado iterativo (!\ *overflow*) +* *Bit set* para indicadores (caché) -Diapositiva 2 -~~~~~~~~~~~~~ -Diapositiva 2 +(bueno != perfecto) +Lo Malo y lo Feo +~~~~~~~~~~~~~~~~ +Lo malo -Lo Bueno, lo Malo y lo Feo --------------------------------------------------- +* ↓ Configurabilidad (*no silver bullet*) +* ↓ Precisión (información de tipos) → Memoria inmortal +* ↓ Concurrencia → Grandes pausas +* ↓ Control sobre el factor de ocupación del *heap* → casos patológicos -Diapositiva 1 -~~~~~~~~~~~~~ -Diapositiva 1 +Lo feo -Diapositiva 2 -~~~~~~~~~~~~~ -Diapositiva 2 +* El código (complejo, intrincado, duplicado, poco documentado) → Difícil de + mantener, modificar y mejorar Modificaciones Propuestas ============================================================================== -Precisión +Concurrencia -------------------------------------------------- -Diapositiva 1 -~~~~~~~~~~~~~ -Diapositiva 1 +fork(2) +~~~~~~~ +* Hijo *nace* con una *fotografía* de la memoria del padre +* Aisla modificaciones en la memoria de padre e hijo +* Minimiza copia efectiva de memoria (*COW*) +* Comienza con un solo hilo (el que llamó a ``fork(2)``) +* Muy eficiente -Diapositiva 2 -~~~~~~~~~~~~~ -Diapositiva 2 +Algoritmo Principal +~~~~~~~~~~~~~~~~~~~ +* Basado en el trabajo de Gustavo Rodriguez-Rivera y Vince Russo (*Non-intrusive + Cloning Garbage Collector with Stock Operating System Support*) +* Minimiza tiempo de pausa realizando fase de marcado **concurrente** vía + ``fork(2)`` +* Proceso padre sigue corriendo el programa +* Proceso hijo realiza fase de marcado +* Se comunican resultados vía memoria compartida +* Sincronización mínima (``fork(2)`` + ``waitpid(2)``) + +Problemas +~~~~~~~~~ +* Hilo que disparó la recolección bloqueado hasta fin de recolección completa + (marcado concurrente inclusive) +* Otros hilos potencialmente bloqueados durante toda la recolección también + (*lock* global) +→ Tiempo de pausa en la práctica ~= tiempo total de recolección -Concurrencia --------------------------------------------------- +Eager Allocation +~~~~~~~~~~~~~~~~ +* Crea un nuevo *pool* de memoria antes de lanzar el marcado concurrente +* Devuelve memoria del nuevo *pool* al programa mientras termina el marcado + concurrente +* Permite al programa (**todos** sus hilos) seguir trabajando mientras se + realiza el marcado concurrente +* Compromiso -Diapositiva 1 -~~~~~~~~~~~~~ -Diapositiva 1 + ↑ Consumo de memoria -Diapositiva 2 -~~~~~~~~~~~~~ -Diapositiva 2 + ↓ Tiempo de pausa real + +Early Collection +~~~~~~~~~~~~~~~~ +* Dispara una recolección *preventiva* antes de que se agote la memoria +* Permite al programa (**todos** sus hilos) seguir trabajando mientras la + recolección *preventiva* está en progreso +* Si se agota la memoria antes de que la recolección *preventiva* finalice, se + vuelve a bloquear +* Combinable con *eager allocation* para evitar bloquear +* Pueden realizarse más recolecciones de las necesarias +* Compromiso + ↑ Consumo de procesador (potencialmente) -Optimizaciones + ↓ Tiempo de pausa real (no garantizado) + + +Otras Mejoras -------------------------------------------------- -Diapositiva 1 -~~~~~~~~~~~~~ -Diapositiva 1 +Precisión +~~~~~~~~~ +Adaptación del trabajo de Vincent Lang y David Simcha: -Diapositiva 2 -~~~~~~~~~~~~~ -Diapositiva 2 +* Compilador genera información sobre ubicación de los punteros en un tipo + + * Indica si una *palabra* debe ser escaneada (uniones) + * Indica si una palabra es un puntero + +* Se pasa esa información al recolector al momento de pedir memoria +* Recolector original utiliza esa información + + * Almacena un puntero a la información al final del bloque + * Utiliza la información para escanear solo palabras que son punteros (con + seguridad o potencialmente) + +Optimizaciones y Otras Mejoras Menores +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +* Mejora del factor de ocupación del *heap* +* Caché de consultas críticas para acelerar cuellos de botella +* Reestructuración, modularización, simplificación y limpieza del código +* Pre-asignación de memoria +* Optimizaciones algorítmicas sobre búsquedas frecuentes +* Registro de pedidos de memoria y recolecciones realizadas + +Configurabilidad +~~~~~~~~~~~~~~~~ +* Configurable en *tiempo de arranque* +* Vía variable de entorno (``D_GC_OPTS``) +* Viejas opciones convertidas + + * ``mem_stop`` + * ``sentinel`` + +* Nuevas opciones + + * ``pre_alloc`` + * ``min_free`` + * ``malloc_stats_file`` + * ``collect_stats_file`` + * ``conservative`` + * ``fork`` + * ``eager_alloc`` + * ``early_collect`` @@ -291,10 +369,10 @@ Resumen * Recolección de basura → Inagotable * D → Multi-paradigma → Desafío * Recolección de basura en D → Fértil -* Mejoras propuestas → Acierto -* Resultados → Esperados + Inesperados +* Mejoras propuestas → Efectivas +* Resultados → Positivos: Esperados + Inesperados -Problemas, limitaciones y Puntos Pendientes +Problemas, Limitaciones y Puntos Pendientes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Predicción de *early collection* * Explosión de uso de memoria con *eager allocation* @@ -310,9 +388,14 @@ Trabajos Relacionados * *Integrate Precise Heap Scanning Into the GC* - David Simcha (GC + diseño) + Vincent Lang (compilador). No formal, *bug + David Simcha (GC + diseño) y Vincent Lang (compilador). No formal, *bug report*, 2009-2010. +* *Non-intrusive Cloning Garbage Collection with Stock Operating System Support* + + Gustavo Rodriguez-Rivera y Vince Russo. Software Practiceand Experience + Volumen 27, Número 8. Agosto 1997. + Trabajos Futuros ~~~~~~~~~~~~~~~~ * Organización de memoria @@ -329,4 +412,5 @@ Fin ~~~ ¡Gracias! + .. vim: set et sw=4 sts=4 spell spelllang=es :