Inline VS Linear String processing performance in Object Oriented Pascal - Delphi

Because of the close ending of one of my projects I wanned set up some discussion ( in case Rob does not provide very detailed answer :D ), I am more focusing of some memory and cycle optimizations in some hungry string processing areas. In my case I am interested in some performace tests, if anyone has made something like that, for particularry performance diff for two cases:

Case 1: I use string processing in in-line way so I have one extra lengthy line, for example,

RichEdit1.SelText := stringfunction1(stringfunction2(stringfunction3(stringfunction4, stringfunction5), stringfunction6, stringfunction7(stringfunction8))))

or

Case 2:

I just split all those functions so each has executed in seperate line and therefore I have 开发者_StackOverflow中文版to declare the variable that would buffer the return of each function.

P.S. I hope I have not mistaken with the brackets in Case 1.

So, what is your findings / opinion / critics about this question?

Maybe it is not simply worth time to gain some extra nanosecond?

---

Declaring variables wouldn't make any difference I believe.

When you call functions like this, the compiler needs to generate implicit string variables to keep the result of your functions. The way you are doing it, the main advantage would be that the compiler can decide to reuse a temp variable once it's done using it, but nothing prevent the compiler to do the same with explicit variables.

Actually, every time you call a function with a string result, the compiler need to create a temp variables, because function returning a string are actually implemented as a procedure with an additional var parameter.

For exemple:

function GetTempPath : string;

is really implemented this way

procedure GetTempPath(var S : string);

so, given following procedure:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Memo1.Lines.Text := GetTempPath;
end;

The compiler first allocate a temporary string variable. Calls GetTempPath with said temp variable in parameter. Once it returns, it takes this variable and set it to Memo1.Lines.Text. Essentially, what it really does is this:

procedure TForm1.Button1Click(Sender: TObject);
var S : string;
begin
  GetTempPath(S);
  Memo1.Lines.Text := S;
end;

and if you actually declare the function like the following, the compiler is smart enough to not create an additionnal variable.

procedure TForm1.Button1Click(Sender: TObject);
var S : string;
begin
  S := GetTempPath;
  Memo1.Lines.Text := S;
end;

---

The code

var
  s1, s2: string;
begin
  s1 := 'This is a very long string...';
  s2 := s1;
end;

does not copy the string s1 into s2 (which could be a performance issue in a tight loop), but it simply instructs s2 to point to the same location in memory as s1. That is, in general, assigning strings to variables isn't a very bad thing.

In fact, I am not sure what method would produce the most efficient assembly code (if they are not identical!). Even in the in-lined case, the intermediate results have to be stored somewhere...

All-in-all, I definitely think you should go for the approach that is the most readble one (to a human programmer). The difference in performance should not even be detectable.

---

Okay.

I will try to put things together within two sentences. :)

• String optimization basically is premature optimmization because of fact that it is bottleneck of performance in VERY VERY VERY rear situations or usecases.

• Inline string usages main advantage is to use compilers features that allow to reuse previous return ( temp ) variables in further paramteric function calls. Still - if we intend to use linear operation(s), we should add GetTempPath() procedure before main string equalization code to make sure we use old temp variables still accessible in memory.