2005-06-14 Pascal Obry <obry@adacore.com>

	* a-stzunb.adb, a-stwiun.adb, a-strunb.adb (Realloc_For_Chunk): New
	implementation which is slightly more efficient.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@101023 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 26 insertions, 9 deletions

diff --git a/gcc/ada/a-stwiun.adb b/gcc/ada/a-stwiun.adb
index e722111c8db..d0e187eca28 100644
--- a/gcc/ada/a-stwiun.adb
+++ b/gcc/ada/a-stwiun.adb
@@ -1,6 +1,6 @@
 ------------------------------------------------------------------------------
 --                                                                          --
---                         GNAT RUNTIME COMPONENTS                          --
+--                         GNAT RUN-TIME COMPONENTS                         --
 --                                                                          --
 --           A D A . S T R I N G S . W I D E _ U N B O U N D E D            --
 --                                                                          --
@@ -636,7 +636,6 @@ package body Ada.Strings.Wide_Unbounded is
           (Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping);
    end Index;
 
-
    function Index
      (Source  : Unbounded_Wide_String;
       Set     : Wide_Maps.Wide_Character_Set;
@@ -772,17 +771,36 @@ package body Ada.Strings.Wide_Unbounded is
      (Source     : in out Unbounded_Wide_String;
       Chunk_Size : Natural)
    is
-      Growth_Factor : constant := 50;
-      S_Length      : constant Natural := Source.Reference'Length;
+      Growth_Factor : constant := 32;
+      --  The growth factor controls how much extra space is allocated when
+      --  we have to increase the size of an allocated unbounded string. By
+      --  allocating extra space, we avoid the need to reallocate on every
+      --  append, particularly important when a string is built up by repeated
+      --  append operations of small pieces. This is expressed as a factor so
+      --  32 means add 1/32 of the length of the string as growth space.
+
+      Min_Mul_Alloc : constant := Standard'Maximum_Alignment;
+      --  Allocation will be done by a multiple of Min_Mul_Alloc This causes
+      --  no memory loss as most (all?) malloc implementations are obliged to
+      --  align the returned memory on the maximum alignment as malloc does not
+      --  know the target alignment.
+
+      S_Length : constant Natural := Source.Reference'Length;
 
    begin
       if Chunk_Size > S_Length - Source.Last then
          declare
-            Alloc_Chunk_Size : constant Positive :=
-                                 Chunk_Size + (S_Length / Growth_Factor);
-            Tmp : Wide_String_Access;
+            New_Size : constant Positive :=
+                         S_Length + Chunk_Size + (S_Length / Growth_Factor);
+
+            New_Rounded_Up_Size : constant Positive :=
+                                    ((New_Size - 1) / Min_Mul_Alloc + 1) *
+                                       Min_Mul_Alloc;
+
+            Tmp : constant Wide_String_Access :=
+                    new Wide_String (1 .. New_Rounded_Up_Size);
+
          begin
-            Tmp := new Wide_String (1 .. S_Length + Alloc_Chunk_Size);
             Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
             Free (Source.Reference);
             Source.Reference := Tmp;
@@ -935,7 +953,6 @@ package body Ada.Strings.Wide_Unbounded is
       return Source.Reference (1 .. Source.Last);
    end To_Wide_String;
 
-
    ---------------
    -- Translate --
    ---------------