package aches

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

package aches

aches
- Library aches
  - Aches
    
    Vache
    
    Rache
- Library aches.rache
  - Rache
    
    TRANSFER
    
    H
    
    BORROW
    
    H
    
    REPLACEMENT
    
    LRU
    
    FIFO
    
    Transfer
    
    H
    
    Borrow
    
    H
    
    EmptyTransferMap
    
    H
    
    SingletonTransferMap
    
    H
    
    EmptyBorrowMap
    
    H
    
    SingletonBorrowMap
    
    H
- Library aches.vache
  - Vache
    
    MAP
    
    H
    
    SET
    
    REPLACEMENT_AND_ACCOUNTING
    
    LRU_Precise
    
    LRU_Sloppy
    
    FIFO_Precise
    
    FIFO_Sloppy
    
    OVERFLOW
    
    Strong
    
    Weak
    
    Map
    
    H
    
    EmptyMap
    
    H
    
    SingletonMap
    
    H
    
    Set
    
    EmptySet
    
    SingletonSet
- Sources
  - aches
    
    aches.ml
  - aches.rache
    
    functors.ml
    
    rache.ml
    
    rache__.ml
    
    sigs.ml
    
    sized.ml
  - aches.vache
    
    functors.ml
    
    sigs.ml
    
    sized.ml
    
    strong_tabler.ml
    
    vache.ml
    
    vache__.ml
    
    weak_tabler.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Rache.Borrow`Source

Borrow(R)(H) is a BORROW indexed by H and govern by the replacement policy R.

A BORROW is similar to a TRANSFER except that:

It only allows borrowing of resources. All resources are under the ownership of the cache. Always.
Resources are created by the cache, on-demand. This allows the cache to have ownership of the resources from the beginning of their lifetime.

It is always unsafe to clean-up resources obtained from a BORROW.

See Rache (or Functors) for more information.

Parameters

module R : REPLACEMENT

module H : Hashtbl.HashedType

Signature

Sourcetype key = H.t

The type of keys on which resources in the cache are indexed.

Sourcetype 'resource t

The type of caches holding bindings from key to 'resource

Sourceval create : (key -> 'resource -> unit) -> int -> 'resource t

create destroy n creates a cache with a size-bound of n. Remember that the size-bound is not upheld strictly by all caches.

Accessing (and implicitely adding elements)

Source

val borrow_or_make : 
  'resource t ->
  key ->
  (key -> 'resource) ->
  ('resource -> 'a) ->
  'a

borrow_or_make c k mk f

If k is bound to r in c then it calls f r.

Otherwise, it generates r using mk, then inserts the binding k-to-r in c, then calls f r.

Note that inserting the binding in c may cause another binding to be removed and its associated resource to be cleaned-up.

It is unsafe to make use of c during the evaluation of f.

It is unsafe to clean-up r.

Note that the in caches with a non-FIFO replacement policy, this may have a side effect on the k-to-r binding. Specifically, in those caches, it might make it less likely to be removed when supernumerary bindings are inserted.

Sourceval borrow : 'resource t -> key -> ('resource -> 'b) -> 'b option

borrow c k f calls f with r if k is bound to r in c. This does not remove the resource from the cache: the cache is still responsible for cleaning-up the resource.

It is unsafe to use the cache from within the function f.

It is unsafe to clean-up r.

Note that the in caches with a non-FIFO replacement policy, this may have a side effect on the k-to-v binding. Specifically, in those caches, it might make it less likely to be removed when supernumerary bindings are inserted.

Sourceval fold : (key -> 'resource -> 'b -> 'b) -> 'resource t -> 'b -> 'b

fold f c init folds the function f and value init over the bindings of c from newest to oldest.

At each called to f, the resource of the traversed binding is borrowed by f. Consequently, the same limitations apply for fold as for borrow.

It is unsafe to clean-up any of the borrowed resources.

It is unsafe to use the cache from within f.

Source

val fold_oldest_first : 
  (key -> 'resource -> 'b -> 'b) ->
  'resource t ->
  'b ->
  'b

fold_oldest_first is like fold but in reversed order: the elements that would be the first to be removed are traversed first. In a FIFO cache, it is oldest-first traversal.

The same limitations and warning applies as for fold.

Removing elements from the cache

The removal functions (remove, clear, and filter) remove the specified elements from the cache. In all cases, the resources are cleaned-up by the cache.

Sourceval remove : 'resource t -> key -> unit

remove c k removes and cleans-up the binding from k in c. If k is not bound in c, it does nothing.

Sourceval clear : 'resource t -> unit

clear c removes and cleans-up all bindings from c.

Sourceval filter : 'resource t -> (key -> 'resource -> bool) -> unit

filter c f removes and cleans-up all the bindings (k, v) such that f k v = false.

Introspecting the cache's state

Sourceval length : 'resource t -> int

length c is the number of bindings held by c.

Sourceval capacity : 'resource t -> int

capacity c is the number of bindings c can hold: capacity (create n) = n

Sourcemodule H : Hashtbl.HashedType with type t = key

package aches

Module Rache.BorrowSource

Parameters

Signature

Accessing (and implicitely adding elements)

Removing elements from the cache

Introspecting the cache's state

Module `Rache.Borrow`Source