DataMuseum.dk Presents historical artifacts from the history of: Rational R1000/400

This is an automatic "excavation" of a thematic subset of artifacts from Datamuseum.dk's BitArchive. See our Wiki for more about Rational R1000/400 Excavated with: AutoArchaeologist - Free & Open Source Software.

top - download

⟦502ddd8c4⟧ Ada Source

    Length: 5120 (0x1400)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, generic, package Concurrent_Map_Generic, seg_01b4b2

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

generic
    Size : Integer;
    -- number of buckets

    type Domain_Type is private;
    type Range_Type is private;
    -- both types are pure values
    -- no initialization or finalization is necessary
    -- = and := can be used for equality and copy

    with function Hash (Key : Domain_Type) return Integer is <>;
    -- for efficiency, spread hash over an interval at least as great as size

    pragma Must_Be_Constrained (Yes => Domain_Type, Range_Type);

package Concurrent_Map_Generic is

    type Map is private;

    type Pair is
        record
            D : Domain_Type;
            R : Range_Type;
        end record;

    function Eval (The_Map : Map; D : Domain_Type) return Range_Type;
    procedure Find (The_Map : Map;
                    D : Domain_Type;
                    R : in out Range_Type;
                    Success : out Boolean);
    procedure Find (The_Map : Map;
                    D : Domain_Type;
                    P : in out Pair;
                    Success : out Boolean);

    procedure Define (The_Map : in out Map;
                      D : Domain_Type;
                      R : Range_Type;
                      Trap_Multiples : Boolean := False);
    procedure Undefine (The_Map : in out Map; D : Domain_Type);

    procedure Initialize (The_Map : out Map);
    function Is_Empty (The_Map : Map) return Boolean;
    procedure Make_Empty (The_Map : in out Map);

    procedure Copy (Target : in out Map; Source : Map);

    type Iterator is private;

    procedure Init (Iter : out Iterator; The_Map : Map);
    procedure Next (Iter : in out Iterator);
    function Value (Iter : Iterator) return Domain_Type;
    function Done (Iter : Iterator) return Boolean;

    Undefined : exception;
    -- raised by eval if the domain value in not in the map

    Multiply_Defined : exception;
    -- raised by define if the domain value is already defined and
    -- the trap_multiples flag has been specified (ie. is true)

    function Nil return Map;
    function Is_Nil (The_Map : Map) return Boolean;

    function Cardinality (The_Map : Map) return Natural;

    ------------------------------------------------------
    -- Implementation Notes and Non-Standard Operations --
    ------------------------------------------------------

    -- := and = operate on references
    --   := implies sharing (introduces an alias)
    --   = means is the same map, not the same value of type map
    -- Initializing a map also makes it empty

    -- Maps must be initialized before use.

    -- garbage may be generated

    -- Concurrent Properties
    --    any number of find/eval/is_empty/copy may be safely done while one
    --   define/undefine/make_empty is taking place.
    --    Define/undefine/make_empty operations are serialized.
    --    Iterators may be used asynchronously, however the sequence of values
    --   yielded may never have been in the map at any one time.

private
    type Node;
    type Set is access Node;

    type Node is
        record
            Value : Pair;
            Link : Set;
        end record;

    type Map_Data;

    type Map is access Map_Data;

    type Iterator is
        record
            The_Map : Map;
            Index_Value : Natural;
            Set_Iter : Set;
            Done : Boolean;
        end record;

    subtype Index is Integer range 0 .. Size - 1;

    type Table is array (Index) of Set;

    type Map_Data is
        record
            Cache : Set; -- of at most one node
            Bucket : Table;
            Size : Natural := 0;
        end record;

end Concurrent_Map_Generic;

    nblk1=4
    nid=0
    hdr6=8
        [0x00] rec0=22 rec1=00 rec2=01 rec3=014
        [0x01] rec0=1b rec1=00 rec2=02 rec3=010
        [0x02] rec0=19 rec1=00 rec2=03 rec3=018
        [0x03] rec0=24 rec1=00 rec2=04 rec3=001
    tail 0x21718b8508363860b9367 0x42a00088462060003