NAME

       Ephemeron - Ephemerons and weak hash table

Module

       Module   Ephemeron

Documentation

       Module Ephemeron
        : sig end

       Ephemerons and weak hash table

       ===  Ephemerons  and weak hash table Ephemerons and weak hash table are useful when one wants to cache or
       memorize the computation of a function, as long as the arguments  and  the  function  are  used,  without
       creating memory leaks by continuously keeping old computation results that are not useful anymore because
       one  argument  or  the  function  is  freed.  An  implementation  using  .t  is  not suitable because all
       associations would keep in memory the arguments and the result.  Ephemerons can also be used for adding a
       field to an arbitrary boxed ocaml value: you can attach an information to a value created by an  external
       library  without  memory  leaks.   Ephemerons hold some keys and one or no data. They are all boxed ocaml
       values. The keys of an ephemeron have the same behavior than  weak  pointers  according  to  the  garbage
       collector.  In fact ocaml weak pointers are implemented as ephemerons without data.  The keys and data of
       an ephemeron are said to be full if they point to a value, empty if the value have never been  set,  have
       been  unset, or was erased by the GC. In the function that accesses the keys or data these two states are
       represented by the option type.  The data is considered by the garbage collector alive if  all  the  full
       keys are alive and if the ephemeron is alive. When one of the keys is not considered alive anymore by the
       GC,  the  data is emptied from the ephemeron. The data could be alive for another reason and in that case
       the GC will not free it, but the ephemeron will not hold the data anymore.  The ephemerons complicate the
       notion of liveness of values, because it is not anymore an equivalence with the  reachability  from  root
       value  by  usual  pointers  (not  weak  and  not  ephemerons).  With ephemerons the notion of liveness is
       constructed by the least fixpoint of: A value is alive if: - it is a root value - it  is  reachable  from
       alive  value by usual pointers - it is the data of an alive ephemeron with all its full keys alive Notes:
       - All the types defined in this module cannot be marshaled using Pervasives.output_value or the functions
       of the Marshal module.  Ephemerons are defined in a language  agnostic  way  in  this  paper:  B.  Hayes,
       Ephemerons: a New Finalization Mechanism, OOPSLA'9 ===

       module type S = sig end

       The output signature of the functor Ephemeron.K1.Make and Ephemeron.K2.Make .  These hash tables are weak
       in  the  keys.  If all the keys of a binding are alive the binding is kept, but if one of the keys of the
       binding is dead then the binding is removed.

       module type SeededS = sig end

       The output signature of the functor Ephemeron.K1.MakeSeeded and Ephemeron.K2.MakeSeeded .

       module K1 : sig end

       module K2 : sig end

       module Kn : sig end

       module GenHashTable : sig end

2017-10-20                                           source:                                       Ephemeron(3o)