Skip to content

R
riscv-gcc-1
Commit 0ba5b393 by Pascal Obry Committed by Arnaud Charlet
Options

a-stzunb.adb, [...] (Realloc_For_Chunk): New implementation which is slightly more efficient. 

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.

From-SVN: r101023
parent 00109226
Showing with 83 additions and 31 deletions
gcc/ada/a-strunb.adb
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
-- -- -- --
-- GNAT RUNTIME COMPONENTS -- -- GNAT RUN-TIME COMPONENTS --
-- -- -- --
-- A D A . S T R I N G S . U N B O U N D E D -- -- A D A . S T R I N G S . U N B O U N D E D --
-- -- -- --
-- B o d y -- -- B o d y --
-- -- -- --
...@@ -623,7 +623,6 @@ package body Ada.Strings.Unbounded is ...@@ -623,7 +623,6 @@ package body Ada.Strings.Unbounded is
(Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping); (Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping);
end Index; end Index;
function Index function Index
(Source : Unbounded_String; (Source : Unbounded_String;
Set : Maps.Character_Set; Set : Maps.Character_Set;
...@@ -755,17 +754,36 @@ package body Ada.Strings.Unbounded is ...@@ -755,17 +754,36 @@ package body Ada.Strings.Unbounded is
(Source : in out Unbounded_String; (Source : in out Unbounded_String;
Chunk_Size : Natural) Chunk_Size : Natural)
is is
Growth_Factor : constant := 50; Growth_Factor : constant := 32;
S_Length : constant Natural := Source.Reference'Length; -- 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 begin
if Chunk_Size > S_Length - Source.Last then if Chunk_Size > S_Length - Source.Last then
declare declare
Alloc_Chunk_Size : constant Positive := New_Size : constant Positive :=
Chunk_Size + (S_Length / Growth_Factor); S_Length + Chunk_Size + (S_Length / Growth_Factor);
Tmp : String_Access;
New_Rounded_Up_Size : constant Positive :=
((New_Size - 1) / Min_Mul_Alloc + 1) *
Min_Mul_Alloc;
Tmp : constant String_Access :=
new String (1 .. New_Rounded_Up_Size);
begin begin
Tmp := new String (1 .. S_Length + Alloc_Chunk_Size);
Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last); Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
Free (Source.Reference); Free (Source.Reference);
Source.Reference := Tmp; Source.Reference := Tmp;
......
gcc/ada/a-stwiun.adb
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
-- -- -- --
-- 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 -- -- 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 ...@@ -636,7 +636,6 @@ package body Ada.Strings.Wide_Unbounded is
(Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping); (Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping);
end Index; end Index;
function Index function Index
(Source : Unbounded_Wide_String; (Source : Unbounded_Wide_String;
Set : Wide_Maps.Wide_Character_Set; Set : Wide_Maps.Wide_Character_Set;
...@@ -772,17 +771,36 @@ package body Ada.Strings.Wide_Unbounded is ...@@ -772,17 +771,36 @@ package body Ada.Strings.Wide_Unbounded is
(Source : in out Unbounded_Wide_String; (Source : in out Unbounded_Wide_String;
Chunk_Size : Natural) Chunk_Size : Natural)
is is
Growth_Factor : constant := 50; Growth_Factor : constant := 32;
S_Length : constant Natural := Source.Reference'Length; -- 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 begin
if Chunk_Size > S_Length - Source.Last then if Chunk_Size > S_Length - Source.Last then
declare declare
Alloc_Chunk_Size : constant Positive := New_Size : constant Positive :=
Chunk_Size + (S_Length / Growth_Factor); S_Length + Chunk_Size + (S_Length / Growth_Factor);
Tmp : Wide_String_Access;
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 begin
Tmp := new Wide_String (1 .. S_Length + Alloc_Chunk_Size);
Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last); Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
Free (Source.Reference); Free (Source.Reference);
Source.Reference := Tmp; Source.Reference := Tmp;
...@@ -935,7 +953,6 @@ package body Ada.Strings.Wide_Unbounded is ...@@ -935,7 +953,6 @@ package body Ada.Strings.Wide_Unbounded is
return Source.Reference (1 .. Source.Last); return Source.Reference (1 .. Source.Last);
end To_Wide_String; end To_Wide_String;
--------------- ---------------
-- Translate -- -- Translate --
--------------- ---------------
......
gcc/ada/a-stzunb.adb
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
-- -- -- --
-- GNAT RUNTIME COMPONENTS -- -- GNAT RUN-TIME COMPONENTS --
-- -- -- --
-- A D A . S T R I N G S . W I D E _ W I D E _ U N B O U N D E D -- -- A D A . S T R I N G S . W I D E _ W I D E _ U N B O U N D E D --
-- -- -- --
...@@ -647,7 +647,6 @@ package body Ada.Strings.Wide_Wide_Unbounded is ...@@ -647,7 +647,6 @@ package body Ada.Strings.Wide_Wide_Unbounded is
(Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping); (Source.Reference (1 .. Source.Last), Pattern, From, Going, Mapping);
end Index; end Index;
function Index function Index
(Source : Unbounded_Wide_Wide_String; (Source : Unbounded_Wide_Wide_String;
Set : Wide_Wide_Maps.Wide_Wide_Character_Set; Set : Wide_Wide_Maps.Wide_Wide_Character_Set;
...@@ -783,17 +782,36 @@ package body Ada.Strings.Wide_Wide_Unbounded is ...@@ -783,17 +782,36 @@ package body Ada.Strings.Wide_Wide_Unbounded is
(Source : in out Unbounded_Wide_Wide_String; (Source : in out Unbounded_Wide_Wide_String;
Chunk_Size : Natural) Chunk_Size : Natural)
is is
Growth_Factor : constant := 50; Growth_Factor : constant := 32;
S_Length : constant Natural := Source.Reference'Length; -- 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 begin
if Chunk_Size > S_Length - Source.Last then if Chunk_Size > S_Length - Source.Last then
declare declare
Alloc_Chunk_Size : constant Positive := New_Size : constant Positive :=
Chunk_Size + (S_Length / Growth_Factor); S_Length + Chunk_Size + (S_Length / Growth_Factor);
Tmp : Wide_Wide_String_Access;
New_Rounded_Up_Size : constant Positive :=
((New_Size - 1) / Min_Mul_Alloc + 1) *
Min_Mul_Alloc;
Tmp : constant Wide_Wide_String_Access :=
new Wide_Wide_String (1 .. New_Rounded_Up_Size);
begin begin
Tmp := new Wide_Wide_String (1 .. S_Length + Alloc_Chunk_Size);
Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last); Tmp (1 .. Source.Last) := Source.Reference (1 .. Source.Last);
Free (Source.Reference); Free (Source.Reference);
Source.Reference := Tmp; Source.Reference := Tmp;
...@@ -911,9 +929,9 @@ package body Ada.Strings.Wide_Wide_Unbounded is ...@@ -911,9 +929,9 @@ package body Ada.Strings.Wide_Wide_Unbounded is
Free (Old); Free (Old);
end Tail; end Tail;
------------------------------ -----------------------------------
-- To_Unbounded_Wide_Wide_String -- -- To_Unbounded_Wide_Wide_String --
------------------------------ -----------------------------------
function To_Unbounded_Wide_Wide_String function To_Unbounded_Wide_Wide_String
(Source : Wide_Wide_String) return Unbounded_Wide_Wide_String (Source : Wide_Wide_String) return Unbounded_Wide_Wide_String
...@@ -936,9 +954,9 @@ package body Ada.Strings.Wide_Wide_Unbounded is ...@@ -936,9 +954,9 @@ package body Ada.Strings.Wide_Wide_Unbounded is
return Result; return Result;
end To_Unbounded_Wide_Wide_String; end To_Unbounded_Wide_Wide_String;
------------------- -------------------------
-- To_Wide_Wide_String -- -- To_Wide_Wide_String --
-------------------- -------------------------
function To_Wide_Wide_String function To_Wide_Wide_String
(Source : Unbounded_Wide_Wide_String) return Wide_Wide_String (Source : Unbounded_Wide_Wide_String) return Wide_Wide_String
...@@ -947,7 +965,6 @@ package body Ada.Strings.Wide_Wide_Unbounded is ...@@ -947,7 +965,6 @@ package body Ada.Strings.Wide_Wide_Unbounded is
return Source.Reference (1 .. Source.Last); return Source.Reference (1 .. Source.Last);
end To_Wide_Wide_String; end To_Wide_Wide_String;
--------------- ---------------
-- Translate -- -- Translate --
--------------- ---------------
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment