[Delphi] Zagadka odnosnie predkosci

[Toster]

Mamy 3 warianty zapisania pewnej operacji, kto wie ktory bedzie najszybszy ?

 

wariant 1:

Wielokrotne rzutowanie obiektu na okreslony typ (obietk Ob jest przodkiem TGfxAnimatorData)

 

 
for t := 0 to 10000 do begin
    TGfxAnimatorData(ob).DoSomething();
    TGfxAnimatorData(ob).SomeField := TGfxAnimatorData(ob).SomeField+1;
end;
7ó0jxr' Śq!yŚ)(ĄQŃŃ)(ĄQŃŃĄ(Ń
źź(ĄMŃĄ(ĄMąĄMąŹ(
;łŚ)ŃQŃŃĄź(Ńźź(
MŃĄ(MąMąŹ()(

 

No wiec kto wie, co bedzie najszybsze :>

[5corpio]

Jeśli to zagadka to strzelam tylko, że użycie with... nie wiem czemu czysty strzał ;p

[Toster]

Eee tam strzelac to mozna na kolokwium

prosze o troche wiecej wysilku :>

[Blind]

wydaje mi sie, że 3. Jak mnie pamięć nie myli czytałem kiedyś o optymalizacji w delphi i podobno with jest szybkie, jeśli odnosmimy się do jakiegoś obiektu kilka razy.

[Force]

Ja tak samo jak Blind odpowiem, bo czytałem, że przy with to Delphi w rejestrze chyba trzyma adres czy coś takiego więc szybciej działa, a normalnie to by wrzucała do rejestru adres, a potem by ściągał co linijkę. Aczkolwiek może też wersje numer dwa umie zoptymalizować bo nie jest skomplikowana.

[5corpio]

 

Eee tam strzelac to mozna na kolokwium

Widzisz Blind i force są za użyciem with tak jak ja... poprostu oni wiedzą a ja mam ten szósty zmysł do programowania, który mi mówi co jest najlepsze

[Spider100]

Hmm... ja tam nie wiem, ale mam wielką nadzieje że trzecia opcja jest najlepsza bo wszędzie z niej korzystam

[Toster]

Dobra leniuchy teoretycy, zrobilem w wolnym czasie testy i wygladaja one tak:

 

program + TD + Athlon 64 2800, 1GB Ramu, winda XP

 

program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils,
 mmsystem;

type
 TTestClass = class
     fPole:      integer;
     procedure    test;virtual;abstract;
 end;

 TTestClass2 = class(TTestClass)
     procedure    test;override;
 end;

 TTestClass3 = class(TTestClass)
     procedure    test;override;
 end;

procedure test1;
var
  a: TTestClass;
  t: integer;
begin
  a := TTestClass2.Create;
  for t := 1 to 100000000 do begin
     TTestClass2(a).test;
     TTestClass2(a).fPole := TTestClass2(a).fPole + 1;
  end;
  a.Free;
end;

procedure test2;
var
  a: TTestClass;
  b: TTestClass2;
  t: integer;
begin
  a := TTestClass2.Create;
  for t := 1 to 100000000 do begin
     b := TTestClass2(a);
     b.test;
     b.fPole := b.fPole + 1;
  end;
  a.Free;
end;

procedure test3;
var
  a: TTestClass;
  t: integer;
begin
  a := TTestClass2.Create;
  for t := 1 to 100000000 do begin
     with TTestClass2(a) do begin
        test;
        fPole := fPole + 1;
     end;
  end;
  a.Free;
end;

procedure testB_1;
var
  a: TTestClass;
  t: integer;
  x, y, z: REAL;
begin
  a := TTestClass2.Create;
  z := 0;
  for t := 1 to 100000000 do begin
     x := z+t;
     TTestClass2(a).test;
     x := x + 5;
     y := 23 - x;
     TTestClass2(a).fPole := TTestClass2(a).fPole + 1;
     z := Sqrt(x+y);
  end;
  a.Free;
end;

procedure testB_2;
var
  a: TTestClass;
  b: TTestClass2;
  t: integer;
  x, y, z: REAL;
begin
  a := TTestClass2.Create;
  z := 0;
  for t := 1 to 100000000 do begin
     b := TTestClass2(a);
     x := z+t;
     b.test;
     x := x + 5;
     y := 23 - x;
     b.fPole := b.fPole + 1;
     z := Sqrt(x+y);
  end;
  a.Free;
end;

procedure testB_3;
var
  a: TTestClass;
  t: integer;
  x, y, z: REAL;
begin
  a := TTestClass2.Create;
  z := 0;
  for t := 1 to 100000000 do begin
     with TTestClass2(a) do begin
        x := z+t;
        test;
        x := x + 5;
        y := 23 - x;
        fPole := fPole + 1;
        z := Sqrt(x+y);
     end;
  end;
  a.Free;
end;
{ TTestClass3 }

procedure TTestClass3.test;
begin
  fPole := fPole + 1;
end;

{ TTestClass2 }

procedure TTestClass2.test;
begin
  fPole := fPole + 1;
end;

var
  tim1, tim2, tim3: cardinal;
begin
  tim1 := timeGetTime;
  test1;
  tim1 := timeGetTime - tim1;

  tim2 := timeGetTime;
  test2;
  tim2 := timeGetTime - tim2;

  tim3 := timeGetTime;
  test3;
  tim3 := timeGetTime - tim3;
  writeln('Testy proste');
  writeln('Test1:', tim1);
  writeln('Test2:', tim2);
  writeln('Test3:', tim3);

  tim1 := timeGetTime;
  testB_1;
  tim1 := timeGetTime - tim1;

  tim2 := timeGetTime;
  testB_2;
  tim2 := timeGetTime - tim2;

  tim3 := timeGetTime;
  testB_3;
  tim3 := timeGetTime - tim3;
  writeln('Testy trudniejsze');
  writeln('Test1:', tim1);
  writeln('Test2:', tim2);
  writeln('Test3:', tim3);
  readln;
end.

 

kompilacja $O+

 

wyniki:

podejscie pierwsze:

Testy proste

Test1:874

Test2:852

Test3:852

Testy trudniejsze

Test1:6554

Test2:6719

Test3:6816

 

Podejscie drugie:

Testy proste

Test1:970

Test2:877

Test3:876

Testy trudniejsze

Test1:6625

Test2:6740

Test3:6833

 

jak widac cachowanie jest najszybsze czyli stara szkola rulez (dobrze ze jestem stary)

 

kompilacja $O-

podejscie pierwsze:

Testy proste

Test1:1447

Test2:1759

Test3:1434

Testy trudniejsze

Test1:6791

Test2:6731

Test3:6777

 

Podejscie drugie:

Testy proste

Test1:1430

Test2:1751

Test3:1412

Testy trudniejsze

Test1:6796

Test2:6723

Test3:6775

 

ciekawe nieprawdaz

[Force]

Wg mnie testy a są bardziej miarodajne, bo w testach b jest masa kodu, który nie działa na zmiennych klasy, no i ten pierwiastek spłaszcza wyniki bo pewnie najwięcej czasu zajmuje. wg mnie dobrym testem byłby test z życia wzięty np: dodawanie 10 000 razy item-a do listview mającego 5 kolumn, i w każdej kolumnie przypisujemy wartość 'a' na przykład, ale na pewno nie jakiś inttostr bo zabierać będzie czas i spłaszczać wynik. Ale pewnie powiesz "zrób se sam":P

[Toster]

wlasnie mi sie wydaje ze testy b sa bardziej miarodajne bo:

1) w testach a nie ma problemu z rejestrami, dlatego nie ma zabawy z puschowaniem/popowaniem na stosie

2) w testach B naklad na pierwiastki itd jest staly dla wszystkich procedur. wiec tak naprawde dodajemy staly skladnik czasu

3) testy a sa czysto akademickie, bo zazwyczaj w metodzie wrzycasz wiecej operacji i mieszasz na kilku zmiennych i tu zaczyna sie wyzwanie dla optymalizacji kompilatora aby uzywac rejestry tak aby bylo szybko. Dlatego wydaje mi sie ze testy b sa blizesz temu co spotyka sie na codzien

 

takie jest moje postrzeganie tej sprawy

[TSr]

Prawdziwą zaletą cacheowania i witha jest możliwość wyciągnięcia tego poza pętlę i dopiero wtedy zobaczymy przewagę.

[xevil21]

Wg mnie testy a są bardziej miarodajne, bo w testach b jest masa kodu, który nie działa na zmiennych klasy, no i ten pierwiastek spłaszcza wyniki bo pewnie najwięcej czasu zajmuje. wg mnie dobrym testem byłby test z życia wzięty np: dodawanie 10 000 razy item-a do listview mającego 5 kolumn, i w każdej kolumnie przypisujemy wartość 'a' na przykład, ale na pewno nie jakiś inttostr bo zabierać będzie czas i spłaszczać wynik. Ale pewnie powiesz "zrób se sam":P

 

Force..., zastanów się troszkę

 

W proponowanym przez Ciebie sposobie najwięcej czasu zajmie wyświetlenie tych 10 000 itemów o wartości ?a?, a nie ich dodanie. To dopiero spłaszczy wyniki

 

Pozdrawiam wszystkich użytkowników forum

 

P.S. Przepraszam Force, masz racje

[Force]

xevil21. Wcale, że nie, robimy tka:

lv.Beginupdate.

Pobieramy czas

Wykonujemy działania

Pobieramy czas, odejmujemy pokazujemy

lv.EndUpdate

 

Można jeszcze w opcjach listview ustawić, że sami sobie rysujemy

[HNB]

Popieram opinię TSr'a. Test jest nieuczciwy. Z założenia przecież with używa się zamiast konstrukcji w test1 (i właśnie takie jest jego zastosowanie, nie zdziwiłbym się gdyby został wygenerowany identyczny kod jak w test1 jeśli zastosować with tak jak TSr to opisał)

 

Można więc wprowadzić kolejny test dla wyciągniętego with.