Diferencia de tiempo de ejecución entre funciones encadenadas y una lista de funciones en OCaml
Para registrar funciones de unidad para ser llamadas más tarde, encontré esta solución utilizando un (unit -> unit) ref que encadena las funciones juntas:
let callbacks = ref @@ fun () -> ()
let add_callback f =
let old_callbacks = !callbacks in
callbacks := (fun () -> f (); old_callbacks ())
(* ... llamar a add_callback varias veces ... *)
(* finalmente, ejecutar todas las devoluciones de llamada apiladas: *)
!callbacks ()
Me pregunto cómo se compara con otra solución que utiliza una pila de funciones (unit -> unit) list ref:
let callbacks = ref []
let add_callback f =
callbacks := f :: !callbacks
(* ... llamar a add_callback varias veces ... *)
(* finalmente, ejecutar todas las devoluciones de llamada apiladas: *)
List.iter (fun f -> f ()) !callbacks
¿Hay diferencias en cómo se representan en memoria?
Si tuviera que registrar una gran cantidad de funciones, ¿cuál sería la mejor solución en términos de memoria y tiempo de desapilado? Para estos dos criterios, ¿hay una solución mejor?
davy.ai
Ambas soluciones que presentaste logran el mismo resultado, que es registrar una lista de funciones de unidad para ser llamadas posteriormente. Sin embargo, hay algunas diferencias en cómo se representan en la memoria y cómo funcionan.
La primera solución utiliza una única celda de referencia,
callbacks, que encadena las funciones utilizando clausuras. Cada vez que se agrega una nueva función, se crea una nueva clausura que captura las callbacks antiguas y la nueva función. Cuando se ejecutan todas las callbacks, la clausura llama iterativamente a cada función de la cadena. Una ventaja de este enfoque es que no requiere una estructura de datos separada para almacenar la lista de callbacks. Sin embargo, puede ser más lento y utilizar más memoria si hay muchas funciones registradas, ya que cada clausura crea un nuevo marco de pila en el montículo.La segunda solución utiliza una estructura de datos de pila, representada como una lista de funciones de unidad en una celda de referencia. Cada vez que se agrega una nueva función, se empuja a la pila. Cuando se ejecutan todas las callbacks, se itera a través de la pila y se llama a cada función. Este enfoque puede ser más rápido y más eficiente en memoria que la primera solución, especialmente si hay muchas callbacks registradas, ya que no crea nuevas clausuras ni marcos de pila.
Si tuvieras que registrar una gran cantidad de funciones, es probable que la segunda solución utilizando una estructura de datos de pila sea la mejor en términos de memoria y tiempo de desapilado. Sin embargo, si no conoces la cantidad de funciones de callback de antemano y necesitas redimensionar la pila dinámicamente, podrías considerar el uso de una estructura de datos diferente como una cola doble, que permite un redimensionamiento eficiente y acceso aleatorio.