AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren

getters sind langsam

Ein Thema von dpg123 · begonnen am 18. Dez 2018 · letzter Beitrag vom 22. Dez 2018
Antwort Antwort
dpg123

Registriert seit: 13. Apr 2015
22 Beiträge
 
Turbo Delphi für Win32
 
#1

getters sind langsam

  Alt 18. Dez 2018, 15:05
Delphi-Version: 2006
Hallo zusammen,

für ein Number-Cruncher-Projekt brauche ich einen vernünftigen Kompromiss aus Speed und komfortable Code-Wartung bzw Code-Verwendung für den Zugriff auf ein dynamisches Array.

Einerseits soll der Zugriff möglichst schnell sein, andererseits sollten diverse OO-Prinzipien eingehalten werden.

Mit folgendem Demo-Prog hab ich mal die Zeiten vergleichen:

Delphi-Quellcode:
type

  TForm1 = class(TForm)

    procedure FormCreate(Sender: TObject);

  private
    { Private-Deklarationen }

    function getInd( x: integer; aMin: integer ): Integer;

  public
    { Public-Deklarationen }


  end;


type

  TDynValueArray = array of Extended;

  TStatValueArray = array [20..120] of Extended;


  IDynArray = interface( IInterface )
  ['{4F626337-44B1-4340-A05C-711A04A0DEB4}']

    function getMin(): Integer;

    function getMax(): Integer;

    function getVal( x: integer ): Extended;

    procedure setValue( x: Integer; aValue: Extended );

    property val[ index: integer ]: extended read getVal write setValue; default;

    property min: Integer read getMin;

    property max: Integer read getMax;

  end;


  TDynArrayImpl = class(TInterfacedObject,IDynArray)


    var

        Fval: TDynValueArray;

        Fmin: Integer;

        Fmax: Integer;
        

    function getMin(): Integer;

    function getMax(): Integer;


    function getVal( x: integer ): Extended;

    procedure setValue( x: Integer; aValue: Extended );

    
    constructor Create( aMin: Integer; aMax: Integer );

  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}


constructor TDynArrayImpl.Create(aMin, aMax: Integer);
var
  i: integer;
begin


  self.Fmin := aMin;

  self.Fmax := aMax;


  SetLength(

    Self.Fval,

    self.Fmax - self.Fmin + 1

    );


  for i := 0 to Length( self.Fval )-1 do
    self.Fval[ i ] := 0;

end;

function TDynArrayImpl.getMax: Integer;
begin
  Result := self.Fmax;
end;

function TDynArrayImpl.getMin: Integer;
begin
  Result := self.FMin;
end;

function TDynArrayImpl.getVal(x: integer): Extended;
begin

  result := Self.Fval[ x - self.FMin ];

end;

procedure TDynArrayImpl.setValue(x: Integer; aValue: Extended);
begin

  Self.Fval[ x - self.FMin ] := aValue;

end;


procedure TForm1.FormCreate(Sender: TObject);

var

  i: Integer;

  lF: Extended;

  lDynAr: IDynArray;

  lPid: Integer;

  lMin,lMax,x: Integer;

  lDynValAr: TDynValueArray;

  lValArStat: TStatValueArray;


const

  lcAnzZugriffe = High(Integer);


  function toInd(aX: Integer): Integer;
  begin
    Result := x - lMin;
  end;

begin


  lMin := 20;

  lMax := 120;

  x := 80;


  // Variante 1: dyn Array hinter einem Interface kapseln

  lDynAr := TDynArrayImpl.Create(lMin,lMax);

  lPid := gvProfiler.start();

  for i := 1 to lcAnzZugriffe do
    lF := lDynAr[x];

  gvProfiler.stop(lPid,'interface');



  SetLength(

    lDynValAr,

    lMax - lMin + 1

    );


  // Variante 2: direkter Zugriff auf das dyn Array, Indexverschiebung per function kapseln

  lPid := gvProfiler.start();

  for i := 1 to lcAnzZugriffe do
    lF := lDynValAr[ toInd(x) ];

  gvProfiler.stop(lPid,'dynAr direkt, function offset');


  // Variante 3: direkter Zugriff auf das dyn Array, direkte Indexverschiebung

  lPid := gvProfiler.start();

  for i := 1 to lcAnzZugriffe do
    lF := lDynValAr[ x - lMin ];

  gvProfiler.stop(lPid,'dynAr direkt, offset direkt');


  // Zum Vergleich: statisches Array

  lPid := gvProfiler.start();

  for i := 1 to lcAnzZugriffe do
    lF := lValArStat[ x ];

  gvProfiler.stop(lPid,'statAr direkt, ohne offset');

end;

function TForm1.getInd(x: integer; aMin: integer): Integer;
begin

  Result := x - aMin;

end;
Ergebnis:

Variante1: interface
16832 ms

Variante2: dynAr direkt, function offset
8143 ms

Variante3: dynAr direkt, offset direkt
3822 ms

Vergleich: statAr direkt, ohne offset
3791 ms


Was ich mir nicht erklären kann:

Warum ist der getter-Zugriff des Interfaces (var 1) um Faktor 2 langsamer als die Indexberechung per function (var 2)?

Wie würdet ihr es lösen, wenn zumindest die Indexverschiebung gekapselt sein soll?


Vielen Dank und Grüße
  Mit Zitat antworten Zitat
freimatz

Registriert seit: 20. Mai 2010
1.032 Beiträge
 
Delphi 10.2 Tokyo Professional
 
#2

AW: getters sind langsam

  Alt 18. Dez 2018, 15:24
bischen OT, aber hast Du schon mal inline probiert?
http://docwiki.embarcadero.com/RADSt...rufen_(Delphi)

Ansonsten ist mir dein Beispiel zu sehr entgegen meinen Gewohnheiten (Leerzeilen, zu kurze Namen), als dass ich das innerhalb nützlicher Frist genau verstehen würde was du da machst.
  Mit Zitat antworten Zitat
dpg123

Registriert seit: 13. Apr 2015
22 Beiträge
 
Turbo Delphi für Win32
 
#3

AW: getters sind langsam

  Alt 18. Dez 2018, 15:44
bischen OT, aber hast Du schon mal inline probiert?
http://docwiki.embarcadero.com/RADSt...rufen_(Delphi)

Ansonsten ist mir dein Beispiel zu sehr entgegen meinen Gewohnheiten (Leerzeilen, zu kurze Namen), als dass ich das innerhalb nützlicher Frist genau verstehen würde was du da machst.
Vielen Dank Freimatz für deinen Hinweis auf inline. schaue ich mir an und experimentiere damit mal.

Entschuldigt, falls meine Nomenklatur komplett gegen den Standard ist!

Und bitte nicht von der gvProfiler - Variable verwirren lassen. Die verwaltet nur getTickCounts. Da das nichts mit dem Problem zu tun hat, hab ich den Code nicht aufgeführt.
  Mit Zitat antworten Zitat
TiGü

Registriert seit: 6. Apr 2011
Ort: Berlin
2.830 Beiträge
 
Delphi 10.2 Tokyo Enterprise
 
#4

AW: getters sind langsam

  Alt 18. Dez 2018, 15:47
Du testet mit High(Integer)-1. Also rund 4,29 Milliarden mal.
Ist das später auch eine Größenordnung die ein Standardfall darstellt?
Oder reden wir dann eher von 1000 bis 1000000 Schleifendurchläufen?
  Mit Zitat antworten Zitat
dpg123

Registriert seit: 13. Apr 2015
22 Beiträge
 
Turbo Delphi für Win32
 
#5

AW: getters sind langsam

  Alt 18. Dez 2018, 15:56
Du testet mit High(Integer)-1. Also rund 4,29 Milliarden mal.
Ist das später auch eine Größenordnung die ein Standardfall darstellt?
Oder reden wir dann eher von 1000 bis 1000000 Schleifendurchläufen?
Die Schleifendurchläufe sollen einfach nur eine hohe Zugriffsanzahl simulieren. Die ist vorhanden. Ob genau in der Größenordung, kann ich nicht genau sagen. Auf jeden Fall ist dabei die Kapselung hinter einem Interface schon deutlich spürbar. So bin ich ja erst auf diesen Test gekommen.
  Mit Zitat antworten Zitat
Namenloser

Registriert seit: 7. Jun 2006
Ort: Karlsruhe
3.724 Beiträge
 
FreePascal / Lazarus
 
#6

AW: getters sind langsam

  Alt 22. Dez 2018, 16:16
Was ich mir nicht erklären kann:

Warum ist der getter-Zugriff des Interfaces (var 1) um Faktor 2 langsamer als die Indexberechung per function (var 2)?
Direkter Funktionsaufruf vs. indirekter Funktionsaufruf. Bei deinem Funktionsaufruf generiert der Compiler eine CALL-Instruktion zu einer bekannten Adresse. Beim Interface hingegen weiß der Compiler zur Compile-Zeit noch nicht, welche Implementierung sich dahinter zur Laufzeit verbergen wird. Deshalb besteht der Funktionsaufruf zur Laufzeit aus zwei Teilen: Zuerst wird der Funktionspointer aus dem Interface ausgelesen und im zweiten Schritt wird er dann angesprungen.

In Assember-Form sieht das ungefähr so aus:

Variante 1
Code:
MOV EAX, [interface.getval] // Funktionsadresse ins Register EAX laden
CALL EAX // Springe zur Adresse im Register EAX
Variante 2
Code:
CALL toInd
Möglich, dass der echte Assember-Code etwas anders aussieht, aber das Prinzip sollte klar werden.
  Mit Zitat antworten Zitat
Benutzerbild von Zacherl
Zacherl

Registriert seit: 3. Sep 2004
4.629 Beiträge
 
Delphi 10.2 Tokyo Starter
 
#7

AW: getters sind langsam

  Alt 22. Dez 2018, 18:32
bischen OT, aber hast Du schon mal inline probiert?
Interface Methoden (virtual ) werden das inline leider ziemlich sicher ignorieren. Das beißt sich mit dem Konzept der VMT (Virtual Method Table). Sollte einleuchten, wenn man sich Namenlosers Erklärung dazu durchliest.
Projekte:
- GitHub (Profil, zyantific)
- zYan Disassembler Engine ( Zydis Online, Zydis GitHub)
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 22:35 Uhr.
Powered by vBulletin® Copyright ©2000 - 2021, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2021 by Daniel R. Wolf