From: Hristian Kirtchev Date: Mon, 1 Jul 2019 13:34:55 +0000 (+0000) Subject: [Ada] Clean up of GNAT.Dynamic_HTables X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=7f070fc469c71b0d3e435cf23964b6de7cd9943e;p=gcc.git [Ada] Clean up of GNAT.Dynamic_HTables ------------ -- Source -- ------------ -- operations.adb with Ada.Text_IO; use Ada.Text_IO; with GNAT; use GNAT; with GNAT.Dynamic_HTables; use GNAT.Dynamic_HTables; procedure Operations is procedure Destroy (Val : in out Integer) is null; function Hash (Key : Integer) return Bucket_Range_Type; package DHT is new Dynamic_Hash_Tables (Key_Type => Integer, Value_Type => Integer, No_Value => 0, Expansion_Threshold => 1.3, Expansion_Factor => 2, Compression_Threshold => 0.3, Compression_Factor => 2, "=" => "=", Destroy_Value => Destroy, Hash => Hash); use DHT; function Create_And_Populate (Low_Key : Integer; High_Key : Integer; Init_Size : Positive) return Dynamic_Hash_Table; -- Create a hash table with initial size Init_Size and populate it with -- key-value pairs where both keys and values are in the range Low_Key -- .. High_Key. procedure Check_Empty (Caller : String; T : Dynamic_Hash_Table; Low_Key : Integer; High_Key : Integer); -- Ensure that -- -- * The key-value pairs count of hash table T is 0. -- * All values for the keys in range Low_Key .. High_Key are 0. procedure Check_Keys (Caller : String; Iter : in out Iterator; Low_Key : Integer; High_Key : Integer); -- Ensure that iterator Iter visits every key in the range Low_Key .. -- High_Key exactly once. procedure Check_Locked_Mutations (Caller : String; T : in out Dynamic_Hash_Table); -- Ensure that all mutation operations of hash table T are locked procedure Check_Size (Caller : String; T : Dynamic_Hash_Table; Exp_Count : Natural); -- Ensure that the count of key-value pairs of hash table T matches -- expected count Exp_Count. Emit an error if this is not the case. procedure Test_Create (Init_Size : Positive); -- Verify that all dynamic hash table operations fail on a non-created -- table of size Init_Size. procedure Test_Delete_Get_Put_Size (Low_Key : Integer; High_Key : Integer; Exp_Count : Natural; Init_Size : Positive); -- Verify that -- -- * Put properly inserts values in the hash table. -- * Get properly retrieves all values inserted in the table. -- * Delete properly deletes values. -- * The size of the hash table properly reflects the number of key-value -- pairs. -- -- Low_Key and High_Key denote the range of keys to be inserted, retrieved, -- and deleted. Exp_Count is the expected count of key-value pairs n the -- hash table. Init_Size denotes the initial size of the table. procedure Test_Iterate (Low_Key : Integer; High_Key : Integer; Init_Size : Positive); -- Verify that iterators -- -- * Properly visit each key exactly once. -- * Mutation operations are properly locked and unlocked during -- iteration. -- -- Low_Key and High_Key denote the range of keys to be inserted, retrieved, -- and deleted. Init_Size denotes the initial size of the table. procedure Test_Iterate_Empty (Init_Size : Positive); -- Verify that an iterator over an empty hash table -- -- * Does not visit any key -- * Mutation operations are properly locked and unlocked during -- iteration. -- -- Init_Size denotes the initial size of the table. procedure Test_Iterate_Forced (Low_Key : Integer; High_Key : Integer; Init_Size : Positive); -- Verify that an iterator that is forcefully advanced by just Next -- -- * Properly visit each key exactly once. -- * Mutation operations are properly locked and unlocked during -- iteration. -- -- Low_Key and High_Key denote the range of keys to be inserted, retrieved, -- and deleted. Init_Size denotes the initial size of the table. procedure Test_Replace (Low_Val : Integer; High_Val : Integer; Init_Size : Positive); -- Verify that Put properly updates the value of a particular key. Low_Val -- and High_Val denote the range of values to be updated. Init_Size denotes -- the initial size of the table. procedure Test_Reset (Low_Key : Integer; High_Key : Integer; Init_Size : Positive); -- Verify that Reset properly destroy and recreats a hash table. Low_Key -- and High_Key denote the range of keys to be inserted in the hash table. -- Init_Size denotes the initial size of the table. ------------------------- -- Create_And_Populate -- ------------------------- function Create_And_Populate (Low_Key : Integer; High_Key : Integer; Init_Size : Positive) return Dynamic_Hash_Table is T : Dynamic_Hash_Table; begin T := Create (Init_Size); for Key in Low_Key .. High_Key loop Put (T, Key, Key); end loop; return T; end Create_And_Populate; ----------------- -- Check_Empty -- ----------------- procedure Check_Empty (Caller : String; T : Dynamic_Hash_Table; Low_Key : Integer; High_Key : Integer) is Val : Integer; begin Check_Size (Caller => Caller, T => T, Exp_Count => 0); for Key in Low_Key .. High_Key loop Val := Get (T, Key); if Val /= 0 then Put_Line ("ERROR: " & Caller & ": wrong value"); Put_Line ("expected: 0"); Put_Line ("got :" & Val'Img); end if; end loop; end Check_Empty; ---------------- -- Check_Keys -- ---------------- procedure Check_Keys (Caller : String; Iter : in out Iterator; Low_Key : Integer; High_Key : Integer) is type Bit_Vector is array (Low_Key .. High_Key) of Boolean; pragma Pack (Bit_Vector); Count : Natural; Key : Integer; Seen : Bit_Vector := (others => False); begin -- Compute the number of outstanding keys that have to be iterated on Count := High_Key - Low_Key + 1; while Has_Next (Iter) loop Next (Iter, Key); if Seen (Key) then Put_Line ("ERROR: " & Caller & ": Check_Keys: duplicate key" & Key'Img); else Seen (Key) := True; Count := Count - 1; end if; end loop; -- In the end, all keys must have been iterated on if Count /= 0 then for Key in Seen'Range loop if not Seen (Key) then Put_Line ("ERROR: " & Caller & ": Check_Keys: missing key" & Key'Img); end if; end loop; end if; end Check_Keys; ---------------------------- -- Check_Locked_Mutations -- ---------------------------- procedure Check_Locked_Mutations (Caller : String; T : in out Dynamic_Hash_Table) is begin begin Delete (T, 1); Put_Line ("ERROR: " & Caller & ": Delete: no exception raised"); exception when Iterated => null; when others => Put_Line ("ERROR: " & Caller & ": Delete: unexpected exception"); end; begin Destroy (T); Put_Line ("ERROR: " & Caller & ": Destroy: no exception raised"); exception when Iterated => null; when others => Put_Line ("ERROR: " & Caller & ": Destroy: unexpected exception"); end; begin Put (T, 1, 1); Put_Line ("ERROR: " & Caller & ": Put: no exception raised"); exception when Iterated => null; when others => Put_Line ("ERROR: " & Caller & ": Put: unexpected exception"); end; begin Reset (T); Put_Line ("ERROR: " & Caller & ": Reset: no exception raised"); exception when Iterated => null; when others => Put_Line ("ERROR: " & Caller & ": Reset: unexpected exception"); end; end Check_Locked_Mutations; ---------------- -- Check_Size -- ---------------- procedure Check_Size (Caller : String; T : Dynamic_Hash_Table; Exp_Count : Natural) is Count : constant Natural := Size (T); begin if Count /= Exp_Count then Put_Line ("ERROR: " & Caller & ": Size: wrong value"); Put_Line ("expected:" & Exp_Count'Img); Put_Line ("got :" & Count'Img); end if; end Check_Size; ---------- -- Hash -- ---------- function Hash (Key : Integer) return Bucket_Range_Type is begin return Bucket_Range_Type (Key); end Hash; ----------------- -- Test_Create -- ----------------- procedure Test_Create (Init_Size : Positive) is Count : Natural; Iter : Iterator; T : Dynamic_Hash_Table; Val : Integer; begin -- Ensure that every routine defined in the API fails on a hash table -- which has not been created yet. begin Delete (T, 1); Put_Line ("ERROR: Test_Create: Delete: no exception raised"); exception when Not_Created => null; when others => Put_Line ("ERROR: Test_Create: Delete: unexpected exception"); end; begin Destroy (T); Put_Line ("ERROR: Test_Create: Destroy: no exception raised"); exception when Not_Created => null; when others => Put_Line ("ERROR: Test_Create: Destroy: unexpected exception"); end; begin Val := Get (T, 1); Put_Line ("ERROR: Test_Create: Get: no exception raised"); exception when Not_Created => null; when others => Put_Line ("ERROR: Test_Create: Get: unexpected exception"); end; begin Iter := Iterate (T); Put_Line ("ERROR: Test_Create: Iterate: no exception raised"); exception when Not_Created => null; when others => Put_Line ("ERROR: Test_Create: Iterate: unexpected exception"); end; begin Put (T, 1, 1); Put_Line ("ERROR: Test_Create: Put: no exception raised"); exception when Not_Created => null; when others => Put_Line ("ERROR: Test_Create: Put: unexpected exception"); end; begin Reset (T); Put_Line ("ERROR: Test_Create: Reset: no exception raised"); exception when Not_Created => null; when others => Put_Line ("ERROR: Test_Create: Reset: unexpected exception"); end; begin Count := Size (T); Put_Line ("ERROR: Test_Create: Size: no exception raised"); exception when Not_Created => null; when others => Put_Line ("ERROR: Test_Create: Size: unexpected exception"); end; -- Test create T := Create (Init_Size); -- Clean up the hash table to prevent memory leaks Destroy (T); end Test_Create; ------------------------------ -- Test_Delete_Get_Put_Size -- ------------------------------ procedure Test_Delete_Get_Put_Size (Low_Key : Integer; High_Key : Integer; Exp_Count : Natural; Init_Size : Positive) is Exp_Val : Integer; T : Dynamic_Hash_Table; Val : Integer; begin T := Create_And_Populate (Low_Key, High_Key, Init_Size); -- Ensure that its size matches an expected value Check_Size (Caller => "Test_Delete_Get_Put_Size", T => T, Exp_Count => Exp_Count); -- Ensure that every value for the range of keys exists for Key in Low_Key .. High_Key loop Val := Get (T, Key); if Val /= Key then Put_Line ("ERROR: Test_Delete_Get_Put_Size: Get: wrong value"); Put_Line ("expected:" & Key'Img); Put_Line ("got :" & Val'Img); end if; end loop; -- Delete values whose keys are divisible by 10 for Key in Low_Key .. High_Key loop if Key mod 10 = 0 then Delete (T, Key); end if; end loop; -- Ensure that all values whose keys were not deleted still exist for Key in Low_Key .. High_Key loop if Key mod 10 = 0 then Exp_Val := 0; else Exp_Val := Key; end if; Val := Get (T, Key); if Val /= Exp_Val then Put_Line ("ERROR: Test_Delete_Get_Put_Size: Get: wrong value"); Put_Line ("expected:" & Exp_Val'Img); Put_Line ("got :" & Val'Img); end if; end loop; -- Delete all values for Key in Low_Key .. High_Key loop Delete (T, Key); end loop; -- Ensure that the hash table is empty Check_Empty (Caller => "Test_Delete_Get_Put_Size", T => T, Low_Key => Low_Key, High_Key => High_Key); -- Clean up the hash table to prevent memory leaks Destroy (T); end Test_Delete_Get_Put_Size; ------------------ -- Test_Iterate -- ------------------ procedure Test_Iterate (Low_Key : Integer; High_Key : Integer; Init_Size : Positive) is Iter_1 : Iterator; Iter_2 : Iterator; T : Dynamic_Hash_Table; begin T := Create_And_Populate (Low_Key, High_Key, Init_Size); -- Obtain an iterator. This action must lock all mutation operations of -- the hash table. Iter_1 := Iterate (T); -- Ensure that every mutation routine defined in the API fails on a hash -- table with at least one outstanding iterator. Check_Locked_Mutations (Caller => "Test_Iterate", T => T); -- Obtain another iterator Iter_2 := Iterate (T); -- Ensure that every mutation is still locked Check_Locked_Mutations (Caller => "Test_Iterate", T => T); -- Ensure that all keys are iterable. Note that this does not unlock the -- mutation operations of the hash table because Iter_2 is not exhausted -- yet. Check_Keys (Caller => "Test_Iterate", Iter => Iter_1, Low_Key => Low_Key, High_Key => High_Key); Check_Locked_Mutations (Caller => "Test_Iterate", T => T); -- Ensure that all keys are iterable. This action unlocks all mutation -- operations of the hash table because all outstanding iterators have -- been exhausted. Check_Keys (Caller => "Test_Iterate", Iter => Iter_2, Low_Key => Low_Key, High_Key => High_Key); -- Ensure that all mutation operations are once again callable Delete (T, Low_Key); Put (T, Low_Key, Low_Key); Reset (T); -- Clean up the hash table to prevent memory leaks Destroy (T); end Test_Iterate; ------------------------ -- Test_Iterate_Empty -- ------------------------ procedure Test_Iterate_Empty (Init_Size : Positive) is Iter : Iterator; Key : Integer; T : Dynamic_Hash_Table; begin T := Create_And_Populate (0, -1, Init_Size); -- Obtain an iterator. This action must lock all mutation operations of -- the hash table. Iter := Iterate (T); -- Ensure that every mutation routine defined in the API fails on a hash -- table with at least one outstanding iterator. Check_Locked_Mutations (Caller => "Test_Iterate_Empty", T => T); -- Attempt to iterate over the keys while Has_Next (Iter) loop Next (Iter, Key); Put_Line ("ERROR: Test_Iterate_Empty: key" & Key'Img & " exists"); end loop; -- Ensure that all mutation operations are once again callable Delete (T, 1); Put (T, 1, 1); Reset (T); -- Clean up the hash table to prevent memory leaks Destroy (T); end Test_Iterate_Empty; ------------------------- -- Test_Iterate_Forced -- ------------------------- procedure Test_Iterate_Forced (Low_Key : Integer; High_Key : Integer; Init_Size : Positive) is Iter : Iterator; Key : Integer; T : Dynamic_Hash_Table; begin T := Create_And_Populate (Low_Key, High_Key, Init_Size); -- Obtain an iterator. This action must lock all mutation operations of -- the hash table. Iter := Iterate (T); -- Ensure that every mutation routine defined in the API fails on a hash -- table with at least one outstanding iterator. Check_Locked_Mutations (Caller => "Test_Iterate_Forced", T => T); -- Forcibly advance the iterator until it raises an exception begin for Guard in Low_Key .. High_Key + 1 loop Next (Iter, Key); end loop; Put_Line ("ERROR: Test_Iterate_Forced: Iterator_Exhausted not raised"); exception when Iterator_Exhausted => null; when others => Put_Line ("ERROR: Test_Iterate_Forced: unexpected exception"); end; -- Ensure that all mutation operations are once again callable Delete (T, Low_Key); Put (T, Low_Key, Low_Key); Reset (T); -- Clean up the hash table to prevent memory leaks Destroy (T); end Test_Iterate_Forced; ------------------ -- Test_Replace -- ------------------ procedure Test_Replace (Low_Val : Integer; High_Val : Integer; Init_Size : Positive) is Key : constant Integer := 1; T : Dynamic_Hash_Table; Val : Integer; begin T := Create (Init_Size); -- Ensure the Put properly updates values with the same key for Exp_Val in Low_Val .. High_Val loop Put (T, Key, Exp_Val); Val := Get (T, Key); if Val /= Exp_Val then Put_Line ("ERROR: Test_Replace: Get: wrong value"); Put_Line ("expected:" & Exp_Val'Img); Put_Line ("got :" & Val'Img); end if; end loop; -- Clean up the hash table to prevent memory leaks Destroy (T); end Test_Replace; ---------------- -- Test_Reset -- ---------------- procedure Test_Reset (Low_Key : Integer; High_Key : Integer; Init_Size : Positive) is T : Dynamic_Hash_Table; begin T := Create_And_Populate (Low_Key, High_Key, Init_Size); -- Reset the contents of the hash table Reset (T); -- Ensure that the hash table is empty Check_Empty (Caller => "Test_Reset", T => T, Low_Key => Low_Key, High_Key => High_Key); -- Clean up the hash table to prevent memory leaks Destroy (T); end Test_Reset; -- Start of processing for Operations begin Test_Create (Init_Size => 1); Test_Create (Init_Size => 100); Test_Delete_Get_Put_Size (Low_Key => 1, High_Key => 1, Exp_Count => 1, Init_Size => 1); Test_Delete_Get_Put_Size (Low_Key => 1, High_Key => 1000, Exp_Count => 1000, Init_Size => 32); Test_Iterate (Low_Key => 1, High_Key => 32, Init_Size => 32); Test_Iterate_Empty (Init_Size => 32); Test_Iterate_Forced (Low_Key => 1, High_Key => 32, Init_Size => 32); Test_Replace (Low_Val => 1, High_Val => 10, Init_Size => 32); Test_Reset (Low_Key => 1, High_Key => 1000, Init_Size => 100); end Operations; ---------------------------- -- Compilation and output -- ---------------------------- $ gnatmake -q operations.adb -largs -lgmem $ ./operations $ gnatmem operations > leaks.txt $ grep -c "non freed allocations" leaks.txt 0 2019-07-01 Hristian Kirtchev gcc/ada/ * libgnat/g-dynhta.adb: Use type Dynamic_Hash_Table rather than Instance in various routines. * libgnat/g-dynhta.ads: Change type Instance to Dynamic_Hash_Table. Update various routines that mention the type. gcc/testsuite/ * gnat.dg/dynhash.adb, gnat.dg/dynhash1.adb: Update. From-SVN: r272860 --- diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 95b52b6ac6d..c527b80bc36 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,11 @@ +2019-07-01 Hristian Kirtchev + + * libgnat/g-dynhta.adb: Use type Dynamic_Hash_Table rather than + Instance in various routines. + * libgnat/g-dynhta.ads: Change type Instance to + Dynamic_Hash_Table. Update various routines that mention the + type. + 2019-07-01 Hristian Kirtchev * exp_attr.adb, exp_ch7.adb, exp_unst.adb, sem_ch3.adb, diff --git a/gcc/ada/libgnat/g-dynhta.adb b/gcc/ada/libgnat/g-dynhta.adb index 31b77de11eb..6cb4182d979 100644 --- a/gcc/ada/libgnat/g-dynhta.adb +++ b/gcc/ada/libgnat/g-dynhta.adb @@ -364,11 +364,11 @@ package body GNAT.Dynamic_HTables is end Set_Next; end Simple_HTable; - -------------------- - -- Dynamic_HTable -- - -------------------- + ------------------------- + -- Dynamic_Hash_Tables -- + ------------------------- - package body Dynamic_HTable is + package body Dynamic_Hash_Tables is Minimum_Size : constant Bucket_Range_Type := 8; -- Minimum size of the buckets @@ -382,7 +382,9 @@ package body GNAT.Dynamic_HTables is -- Maximum safe size for hash table expansion. Beyond this size, an -- expansion will overflow the buckets. - procedure Delete_Node (T : Instance; Nod : Node_Ptr); + procedure Delete_Node + (T : Dynamic_Hash_Table; + Nod : Node_Ptr); pragma Inline (Delete_Node); -- Detach and delete node Nod from table T @@ -398,12 +400,12 @@ package body GNAT.Dynamic_HTables is pragma Inline (Ensure_Circular); -- Ensure that dummy head Head is circular with respect to itself - procedure Ensure_Created (T : Instance); + procedure Ensure_Created (T : Dynamic_Hash_Table); pragma Inline (Ensure_Created); -- Verify that hash table T is created. Raise Not_Created if this is not -- the case. - procedure Ensure_Unlocked (T : Instance); + procedure Ensure_Unlocked (T : Dynamic_Hash_Table); pragma Inline (Ensure_Unlocked); -- Verify that hash table T is unlocked. Raise Iterated if this is not -- the case. @@ -422,7 +424,7 @@ package body GNAT.Dynamic_HTables is -- otherwise return null. procedure First_Valid_Node - (T : Instance; + (T : Dynamic_Hash_Table; Low_Bkt : Bucket_Range_Type; High_Bkt : Bucket_Range_Type; Idx : out Bucket_Range_Type; @@ -437,7 +439,8 @@ package body GNAT.Dynamic_HTables is new Ada.Unchecked_Deallocation (Bucket_Table, Bucket_Table_Ptr); procedure Free is - new Ada.Unchecked_Deallocation (Hash_Table, Instance); + new Ada.Unchecked_Deallocation + (Dynamic_Hash_Table_Attributes, Dynamic_Hash_Table); procedure Free is new Ada.Unchecked_Deallocation (Node, Node_Ptr); @@ -451,15 +454,17 @@ package body GNAT.Dynamic_HTables is -- Determine whether node Nod is non-null and does not refer to dummy -- head Head, thus making it valid. - function Load_Factor (T : Instance) return Threshold_Type; + function Load_Factor (T : Dynamic_Hash_Table) return Threshold_Type; pragma Inline (Load_Factor); -- Calculate the load factor of hash table T - procedure Lock (T : Instance); + procedure Lock (T : Dynamic_Hash_Table); pragma Inline (Lock); -- Lock all mutation functionality of hash table T - procedure Mutate_And_Rehash (T : Instance; Size : Bucket_Range_Type); + procedure Mutate_And_Rehash + (T : Dynamic_Hash_Table; + Size : Bucket_Range_Type); pragma Inline (Mutate_And_Rehash); -- Replace the buckets of hash table T with a new set of buckets of size -- Size. Rehash all key-value pairs from the old to the new buckets. @@ -476,7 +481,7 @@ package body GNAT.Dynamic_HTables is pragma Inline (Present); -- Determine whether node Nod exists - procedure Unlock (T : Instance); + procedure Unlock (T : Dynamic_Hash_Table); pragma Inline (Unlock); -- Unlock all mutation functionality of hash table T @@ -484,13 +489,13 @@ package body GNAT.Dynamic_HTables is -- Create -- ------------ - function Create (Initial_Size : Positive) return Instance is + function Create (Initial_Size : Positive) return Dynamic_Hash_Table is Size : constant Bucket_Range_Type := Bucket_Range_Type'Max (Bucket_Range_Type (Initial_Size), Minimum_Size); -- Ensure that the buckets meet a minimum size - T : constant Instance := new Hash_Table; + T : constant Dynamic_Hash_Table := new Dynamic_Hash_Table_Attributes; begin T.Buckets := new Bucket_Table (0 .. Size - 1); @@ -503,7 +508,10 @@ package body GNAT.Dynamic_HTables is -- Delete -- ------------ - procedure Delete (T : Instance; Key : Key_Type) is + procedure Delete + (T : Dynamic_Hash_Table; + Key : Key_Type) + is Head : Node_Ptr; Nod : Node_Ptr; @@ -531,7 +539,10 @@ package body GNAT.Dynamic_HTables is -- Delete_Node -- ----------------- - procedure Delete_Node (T : Instance; Nod : Node_Ptr) is + procedure Delete_Node + (T : Dynamic_Hash_Table; + Nod : Node_Ptr) + is procedure Compress; pragma Inline (Compress); -- Determine whether hash table T requires compression, and if so, @@ -586,7 +597,7 @@ package body GNAT.Dynamic_HTables is -- Destroy -- ------------- - procedure Destroy (T : in out Instance) is + procedure Destroy (T : in out Dynamic_Hash_Table) is begin Ensure_Created (T); Ensure_Unlocked (T); @@ -678,7 +689,7 @@ package body GNAT.Dynamic_HTables is -- Ensure_Created -- -------------------- - procedure Ensure_Created (T : Instance) is + procedure Ensure_Created (T : Dynamic_Hash_Table) is begin if not Present (T) then raise Not_Created; @@ -689,7 +700,7 @@ package body GNAT.Dynamic_HTables is -- Ensure_Unlocked -- --------------------- - procedure Ensure_Unlocked (T : Instance) is + procedure Ensure_Unlocked (T : Dynamic_Hash_Table) is begin pragma Assert (Present (T)); @@ -746,7 +757,7 @@ package body GNAT.Dynamic_HTables is ---------------------- procedure First_Valid_Node - (T : Instance; + (T : Dynamic_Hash_Table; Low_Bkt : Bucket_Range_Type; High_Bkt : Bucket_Range_Type; Idx : out Bucket_Range_Type; @@ -784,7 +795,10 @@ package body GNAT.Dynamic_HTables is -- Get -- --------- - function Get (T : Instance; Key : Key_Type) return Value_Type is + function Get + (T : Dynamic_Hash_Table; + Key : Key_Type) return Value_Type + is Head : Node_Ptr; Nod : Node_Ptr; @@ -814,8 +828,8 @@ package body GNAT.Dynamic_HTables is -------------- function Has_Next (Iter : Iterator) return Boolean is - Is_OK : constant Boolean := Is_Valid (Iter); - T : constant Instance := Iter.Table; + Is_OK : constant Boolean := Is_Valid (Iter); + T : constant Dynamic_Hash_Table := Iter.Table; begin pragma Assert (Present (T)); @@ -835,7 +849,7 @@ package body GNAT.Dynamic_HTables is -- Is_Empty -- -------------- - function Is_Empty (T : Instance) return Boolean is + function Is_Empty (T : Dynamic_Hash_Table) return Boolean is begin Ensure_Created (T); @@ -870,7 +884,7 @@ package body GNAT.Dynamic_HTables is -- Iterate -- ------------- - function Iterate (T : Instance) return Iterator is + function Iterate (T : Dynamic_Hash_Table) return Iterator is Iter : Iterator; begin @@ -906,7 +920,7 @@ package body GNAT.Dynamic_HTables is -- Load_Factor -- ----------------- - function Load_Factor (T : Instance) return Threshold_Type is + function Load_Factor (T : Dynamic_Hash_Table) return Threshold_Type is pragma Assert (Present (T)); pragma Assert (Present (T.Buckets)); @@ -920,7 +934,7 @@ package body GNAT.Dynamic_HTables is -- Lock -- ---------- - procedure Lock (T : Instance) is + procedure Lock (T : Dynamic_Hash_Table) is begin -- The hash table may be locked multiple times if multiple iterators -- are operating over it. @@ -932,7 +946,10 @@ package body GNAT.Dynamic_HTables is -- Mutate_And_Rehash -- ----------------------- - procedure Mutate_And_Rehash (T : Instance; Size : Bucket_Range_Type) is + procedure Mutate_And_Rehash + (T : Dynamic_Hash_Table; + Size : Bucket_Range_Type) + is procedure Rehash (From : Bucket_Table_Ptr; To : Bucket_Table_Ptr); pragma Inline (Rehash); -- Remove all nodes from buckets From and rehash them into buckets To @@ -1031,7 +1048,7 @@ package body GNAT.Dynamic_HTables is procedure Next (Iter : in out Iterator; Key : out Key_Type) is Is_OK : constant Boolean := Is_Valid (Iter); Saved : constant Node_Ptr := Iter.Curr_Nod; - T : constant Instance := Iter.Table; + T : constant Dynamic_Hash_Table := Iter.Table; Head : Node_Ptr; begin @@ -1109,7 +1126,7 @@ package body GNAT.Dynamic_HTables is -- Present -- ------------- - function Present (T : Instance) return Boolean is + function Present (T : Dynamic_Hash_Table) return Boolean is begin return T /= Nil; end Present; @@ -1118,7 +1135,11 @@ package body GNAT.Dynamic_HTables is -- Put -- --------- - procedure Put (T : Instance; Key : Key_Type; Value : Value_Type) is + procedure Put + (T : Dynamic_Hash_Table; + Key : Key_Type; + Value : Value_Type) + is procedure Expand; pragma Inline (Expand); -- Determine whether hash table T requires expansion, and if so, @@ -1223,7 +1244,7 @@ package body GNAT.Dynamic_HTables is -- Reset -- ----------- - procedure Reset (T : Instance) is + procedure Reset (T : Dynamic_Hash_Table) is begin Ensure_Created (T); Ensure_Unlocked (T); @@ -1243,7 +1264,7 @@ package body GNAT.Dynamic_HTables is -- Size -- ---------- - function Size (T : Instance) return Natural is + function Size (T : Dynamic_Hash_Table) return Natural is begin Ensure_Created (T); @@ -1254,13 +1275,13 @@ package body GNAT.Dynamic_HTables is -- Unlock -- ------------ - procedure Unlock (T : Instance) is + procedure Unlock (T : Dynamic_Hash_Table) is begin -- The hash table may be locked multiple times if multiple iterators -- are operating over it. T.Iterators := T.Iterators - 1; end Unlock; - end Dynamic_HTable; + end Dynamic_Hash_Tables; end GNAT.Dynamic_HTables; diff --git a/gcc/ada/libgnat/g-dynhta.ads b/gcc/ada/libgnat/g-dynhta.ads index 7b8d1d84087..6c19f0f370e 100644 --- a/gcc/ada/libgnat/g-dynhta.ads +++ b/gcc/ada/libgnat/g-dynhta.ads @@ -258,9 +258,9 @@ package GNAT.Dynamic_HTables is Nil : constant Instance := Instance (Tab.Nil); end Simple_HTable; - -------------------- - -- Dynamic_HTable -- - -------------------- + ------------------------- + -- Dynamic_Hash_Tables -- + ------------------------- -- The following package offers a hash table abstraction with the following -- characteristics: @@ -275,7 +275,7 @@ package GNAT.Dynamic_HTables is -- -- The following use pattern must be employed when operating this table: -- - -- Table : Instance := Create (); + -- Table : Dynamic_Hash_Table := Create (); -- -- -- @@ -333,7 +333,7 @@ package GNAT.Dynamic_HTables is with function Hash (Key : Key_Type) return Bucket_Range_Type; -- Map an arbitrary key into the range of buckets - package Dynamic_HTable is + package Dynamic_Hash_Tables is ---------------------- -- Table operations -- @@ -342,37 +342,44 @@ package GNAT.Dynamic_HTables is -- The following type denotes a hash table handle. Each instance must be -- created using routine Create. - type Instance is private; - Nil : constant Instance; + type Dynamic_Hash_Table is private; + Nil : constant Dynamic_Hash_Table; - function Create (Initial_Size : Positive) return Instance; + function Create (Initial_Size : Positive) return Dynamic_Hash_Table; -- Create a new table with bucket capacity Initial_Size. This routine -- must be called at the start of a hash table's lifetime. - procedure Delete (T : Instance; Key : Key_Type); + procedure Delete + (T : Dynamic_Hash_Table; + Key : Key_Type); -- Delete the value which corresponds to key Key from hash table T. The -- routine has no effect if the value is not present in the hash table. -- This action will raise Iterated if the hash table has outstanding -- iterators. If the load factor drops below Compression_Threshold, the -- size of the buckets is decreased by Copression_Factor. - procedure Destroy (T : in out Instance); + procedure Destroy (T : in out Dynamic_Hash_Table); -- Destroy the contents of hash table T, rendering it unusable. This -- routine must be called at the end of a hash table's lifetime. This -- action will raise Iterated if the hash table has outstanding -- iterators. - function Get (T : Instance; Key : Key_Type) return Value_Type; + function Get + (T : Dynamic_Hash_Table; + Key : Key_Type) return Value_Type; -- Obtain the value which corresponds to key Key from hash table T. If -- the value does not exist, return No_Value. - function Is_Empty (T : Instance) return Boolean; + function Is_Empty (T : Dynamic_Hash_Table) return Boolean; -- Determine whether hash table T is empty - function Present (T : Instance) return Boolean; + function Present (T : Dynamic_Hash_Table) return Boolean; -- Determine whether hash table T exists - procedure Put (T : Instance; Key : Key_Type; Value : Value_Type); + procedure Put + (T : Dynamic_Hash_Table; + Key : Key_Type; + Value : Value_Type); -- Associate value Value with key Key in hash table T. If the table -- already contains a mapping of the same key to a previous value, the -- previous value is overwritten. This action will raise Iterated if @@ -380,12 +387,12 @@ package GNAT.Dynamic_HTables is -- over Expansion_Threshold, the size of the buckets is increased by -- Expansion_Factor. - procedure Reset (T : Instance); + procedure Reset (T : Dynamic_Hash_Table); -- Destroy the contents of hash table T, and reset it to its initial -- created state. This action will raise Iterated if the hash table -- has outstanding iterators. - function Size (T : Instance) return Natural; + function Size (T : Dynamic_Hash_Table) return Natural; -- Obtain the number of key-value pairs in hash table T ------------------------- @@ -412,7 +419,7 @@ package GNAT.Dynamic_HTables is -- iterator has been exhausted, restore all mutation functionality of -- the associated hash table. - function Iterate (T : Instance) return Iterator; + function Iterate (T : Dynamic_Hash_Table) return Iterator; -- Obtain an iterator over the keys of hash table T. This action locks -- all mutation functionality of the associated hash table. @@ -461,7 +468,7 @@ package GNAT.Dynamic_HTables is -- The following type represents a hash table - type Hash_Table is record + type Dynamic_Hash_Table_Attributes is record Buckets : Bucket_Table_Ptr := null; -- Reference to the compressing / expanding buckets @@ -475,8 +482,8 @@ package GNAT.Dynamic_HTables is -- Number of key-value pairs in the buckets end record; - type Instance is access Hash_Table; - Nil : constant Instance := null; + type Dynamic_Hash_Table is access Dynamic_Hash_Table_Attributes; + Nil : constant Dynamic_Hash_Table := null; -- The following type represents a key iterator @@ -491,9 +498,9 @@ package GNAT.Dynamic_HTables is -- always point to a valid node. A value of null indicates that the -- iterator is exhausted. - Table : Instance := null; + Table : Dynamic_Hash_Table := null; -- Reference to the associated hash table end record; - end Dynamic_HTable; + end Dynamic_Hash_Tables; end GNAT.Dynamic_HTables; diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index a64cb528b27..edc2bd6ac6f 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,7 @@ +2019-07-01 Hristian Kirtchev + + * gnat.dg/dynhash.adb, gnat.dg/dynhash1.adb: Update. + 2019-07-01 Hristian Kirtchev * gnat.dg/freezing1.adb, gnat.dg/freezing1.ads, diff --git a/gcc/testsuite/gnat.dg/dynhash.adb b/gcc/testsuite/gnat.dg/dynhash.adb index c51e6e218e1..8b229c4c8a8 100644 --- a/gcc/testsuite/gnat.dg/dynhash.adb +++ b/gcc/testsuite/gnat.dg/dynhash.adb @@ -5,9 +5,10 @@ with GNAT; use GNAT; with GNAT.Dynamic_HTables; use GNAT.Dynamic_HTables; procedure Dynhash is + procedure Destroy (Val : in out Integer) is null; function Hash (Key : Integer) return Bucket_Range_Type; - package DHT is new Dynamic_HTable + package DHT is new Dynamic_Hash_Tables (Key_Type => Integer, Value_Type => Integer, No_Value => 0, @@ -16,20 +17,21 @@ procedure Dynhash is Compression_Threshold => 0.3, Compression_Factor => 2, "=" => "=", + Destroy_Value => Destroy, Hash => Hash); use DHT; function Create_And_Populate (Low_Key : Integer; High_Key : Integer; - Init_Size : Positive) return Instance; + Init_Size : Positive) return Dynamic_Hash_Table; -- Create a hash table with initial size Init_Size and populate it with -- key-value pairs where both keys and values are in the range Low_Key -- .. High_Key. procedure Check_Empty (Caller : String; - T : Instance; + T : Dynamic_Hash_Table; Low_Key : Integer; High_Key : Integer); -- Ensure that @@ -45,12 +47,14 @@ procedure Dynhash is -- Ensure that iterator Iter visits every key in the range Low_Key .. -- High_Key exactly once. - procedure Check_Locked_Mutations (Caller : String; T : in out Instance); + procedure Check_Locked_Mutations + (Caller : String; + T : in out Dynamic_Hash_Table); -- Ensure that all mutation operations of hash table T are locked procedure Check_Size (Caller : String; - T : Instance; + T : Dynamic_Hash_Table; Exp_Count : Natural); -- Ensure that the count of key-value pairs of hash table T matches -- expected count Exp_Count. Emit an error if this is not the case. @@ -134,9 +138,9 @@ procedure Dynhash is function Create_And_Populate (Low_Key : Integer; High_Key : Integer; - Init_Size : Positive) return Instance + Init_Size : Positive) return Dynamic_Hash_Table is - T : Instance; + T : Dynamic_Hash_Table; begin T := Create (Init_Size); @@ -154,7 +158,7 @@ procedure Dynhash is procedure Check_Empty (Caller : String; - T : Instance; + T : Dynamic_Hash_Table; Low_Key : Integer; High_Key : Integer) is @@ -227,7 +231,10 @@ procedure Dynhash is -- Check_Locked_Mutations -- ---------------------------- - procedure Check_Locked_Mutations (Caller : String; T : in out Instance) is + procedure Check_Locked_Mutations + (Caller : String; + T : in out Dynamic_Hash_Table) + is begin begin Delete (T, 1); @@ -276,7 +283,7 @@ procedure Dynhash is procedure Check_Size (Caller : String; - T : Instance; + T : Dynamic_Hash_Table; Exp_Count : Natural) is Count : constant Natural := Size (T); @@ -305,7 +312,7 @@ procedure Dynhash is procedure Test_Create (Init_Size : Positive) is Count : Natural; Iter : Iterator; - T : Instance; + T : Dynamic_Hash_Table; Val : Integer; begin @@ -402,7 +409,7 @@ procedure Dynhash is Init_Size : Positive) is Exp_Val : Integer; - T : Instance; + T : Dynamic_Hash_Table; Val : Integer; begin @@ -483,7 +490,7 @@ procedure Dynhash is is Iter_1 : Iterator; Iter_2 : Iterator; - T : Instance; + T : Dynamic_Hash_Table; begin T := Create_And_Populate (Low_Key, High_Key, Init_Size); @@ -552,7 +559,7 @@ procedure Dynhash is procedure Test_Iterate_Empty (Init_Size : Positive) is Iter : Iterator; Key : Integer; - T : Instance; + T : Dynamic_Hash_Table; begin T := Create_And_Populate (0, -1, Init_Size); @@ -599,7 +606,7 @@ procedure Dynhash is is Iter : Iterator; Key : Integer; - T : Instance; + T : Dynamic_Hash_Table; begin T := Create_And_Populate (Low_Key, High_Key, Init_Size); @@ -653,7 +660,7 @@ procedure Dynhash is Init_Size : Positive) is Key : constant Integer := 1; - T : Instance; + T : Dynamic_Hash_Table; Val : Integer; begin @@ -687,7 +694,7 @@ procedure Dynhash is High_Key : Integer; Init_Size : Positive) is - T : Instance; + T : Dynamic_Hash_Table; begin T := Create_And_Populate (Low_Key, High_Key, Init_Size); diff --git a/gcc/testsuite/gnat.dg/dynhash1.adb b/gcc/testsuite/gnat.dg/dynhash1.adb index cbe241a4c7c..e2010de91f7 100644 --- a/gcc/testsuite/gnat.dg/dynhash1.adb +++ b/gcc/testsuite/gnat.dg/dynhash1.adb @@ -1,14 +1,17 @@ +-- { dg-do run } + with Ada.Text_IO; use Ada.Text_IO; with GNAT; use GNAT; with GNAT.Dynamic_HTables; use GNAT.Dynamic_HTables; procedure Dynhash1 is + procedure Destroy (Val : in out Integer) is null; function Hash (Key : Integer) return Bucket_Range_Type is begin return Bucket_Range_Type (Key); end Hash; - package Integer_Hash_Tables is new Dynamic_HTable + package Integer_Hash_Tables is new Dynamic_Hash_Tables (Key_Type => Integer, Value_Type => Integer, No_Value => 0, @@ -17,11 +20,12 @@ procedure Dynhash1 is Compression_Threshold => 0.3, Compression_Factor => 2, "=" => "=", + Destroy_Value => Destroy, Hash => Hash); use Integer_Hash_Tables; Siz : Natural; - T : Instance; + T : Dynamic_Hash_Table; begin T := Create (8);