Example of wasteful, innefficient string manipulation
I was trying to run an example of wasteful, inefficient string manipulation to see what happens to memory consumption, without Fastmm.
I expected the end result to be high memory consumption, de-fragmented, not leaving much free memory for project to use.
But at the end of parsing the project uses almost the same system memory:
Start:
End:
During the parsing the memory consumption is all over, the highest over 1GB:
Here is example of string manipulation:
uses StrUtils;
const cLoop = 100;
cMultiplyString = 100000;
function MultiplyStr(aStr: string; aMultiplier: integer): string;
var i: Integer;
begin
for i := 1 to aMultiplier do
Result := Result + aStr;
end;
function Parse(aString: string): string;
var s1, s2: string;
i: Integer;
begin
s1 := MidStr(Copy(MidStr(aString, 1, Length(aString) - 2), 1, Length(aString) - 2), 10, Length(aString) div 2);
for i := 1 to 100 do
Delete(s1, 1, 1);
s2 := s1 + s1;
end;
procedure TForm2.Button1Click(Sender: TObject);
var s: string;
i: integer;
begin
for i := 1 to cLoop do
begin
s := '';
s := Parse(MultiplyStr('STRING_TO_PARSE' + i.ToString, cMultiplyString));
end;
end;
Is Delphi's memory manager so good that even if the work is wasteful, inefficient string manipulation, when it ends it cleans up memory very well?
When you ask for memory, MM(FastMM) asks the OS for a large chunks and then it splits them and gives you a piece (based on the size you need). When the object is destroyed (free), the memory is returned to the MM. Now, based on the returned size, the MM may either choose to recycle the object location (if its small) or return the memory to the OS (a real-free-op).
What you're doing in MultiplyStr is not just wasteful but extremely harmful ! For each iteration you're reallocating memory. Allocating a new block and copying the old block to the new one. It's very important to know that small block are implemented as a segregated list. i.e if you ask for a 32 bytes, MM on reality allocates an entire table i.e 32x32=1024 bytes and yields first block. In your example you said you used 1GB ! this is extremely bad because you're not economizing resources and you'll quickly run out of memory i.e another thread that asks for a large chunk.
It's indeed a good practice to pre-allocate memory :
function MultiplyStr(aStr: string; aMultiplier: integer): string;
var i: Integer;
begin
SetLength(Result, length(aStr) * aMultiplier);
for i := 1 to aMultiplier do
Result := Result + aStr;
end;
Please run the above and notice the memory and performance !!!
Also a small remark ! aStr should be const !!!
