Entwickler-Ecke :: Thema anzeigen - Zitkosten vom Procedureaufruf?

buSC - Di 26.01.10 08:46
Titel: Zitkosten vom Procedureaufruf?

hallo liebe Forumer

ich habe 2 Fragen:

Frage1:
ich moechte wissen ,wie viel Zeitunterschied gibts ,wenn man eine schleife direkt in eimem Unit benutzt ,und wenn man eine Schleife inderekt durch Aufruf eines Procedures benutzt,wie unten,bei meinem Fall:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

//---------
Fall1,in Unit1:
arr:array of array of double;
setlength(arr);
...
pr(arr,k);
...
end.
//---------
Fall2, in Unit1:
arr:array of array of double;
setlength(arr);
k:=...
...
for i:=k to length(arr)-1 do arr[i-1]:=copy(arr[i]);//anstelle von aufruf von pr
setlength(arr,length(arr)-1);
...
end.
//--------------
//mein procedure loescht k-te Zeile von array und 
//schiebt Zeilen,die nach geloeschte Zeile sind, um ein Zeile nach oben 
//und nach dem Aufruf von Pr ist arr um ein Zeile kleiner geworden.

procedure pr(var arr:array of array double,k:integer);
var i,n:integer
begin 
for i:=k to length(arr)-1 do arr[i-1]:=copy(arr[i]);
setlength(arr,length(arr)-1); 
end
//*******************************************************

Frage2:
und zwar gibts es ein schnellere Verfahren als das,was Procedure "pr" macht?, sodass diese schiebeverfahren schneller gemacht wird .nem

Moderiert von Gausi: Delphi-Tags hinzugefügt
Moderiert von Narses: Überflüssige Zeilenumbrüche/Leerzeilen entfernt.

jaenicke - Di 26.01.10 09:43

Natürlich dauert der Aufruf ein paar Takte länger als ohne den Prozeduraufruf. Das macht sich aber erst bemerkbar, wenn du das sehr oft aufrufst. Und in dem Fall wäre es ohnehin besser (wenn möglich) das besser zu optimieren, z.B. mehrere Löschoperationen zusammenzufassen oder so.

Für Zeitmessungen in dem Bereich eignet sich GetTickCount aufgrund der Ungenauigkeit nicht, sondern eher QueryPerformanceCounter. Und das auch nur bei vielen Aufrufen, sonst ist die Abweichung innerhalb der Messtoleranz.

Wie genau sich das optimieren lässt hängt vom Fall ab, d.h. wie oft die Prozedur aufgerufen ist, ob sich Aufrufe zusammenfassen lassen, ...
Durch direkte Speicheroperationen ließe sich evtl. viel Zeit sparen, ebenso könnte man mit Löschflags arbeiten, aber all das kommt auf den Fall an. Manchmal ist es sinnvoll, manchmal nicht.

Lossy eX - Di 26.01.10 09:45

Blackheart666: Hast du mal geschaut was da in dem Code eigentlich gemacht wird? Sonst wäre dir vermutlich aufgefallen, dass ein Hinweis auf GetTickCount rein gar nichts bringt. Dort wird im zweiten Fall nur der komplette Code ausgelagert. Und das ist eine so nichtige Änderung, dass man das nicht mal mit dem Performance Counter zuverlässig messen könnte. Und erst recht nicht mit einem Teil was eine 16 Millisekunden Auflösung hat und dann auch eher nur zufällige Ergebnisse liefert.

buSC: Was die Geschwindigkeit angeht brauchst du dir gar keine Gedanken machen. Die von dir durchgeführte Änderung sind das normale täglich Brot deiner CPU und werden überhaupt nicht ins Gewicht fallen. Solch eine Änderung kann man kaum wirklich messen. Abgesehen davon ist eine vernünftige Codestruktur wichtig. Die sollte man nur dann vernachlässigen, wenn es eine wirklich zeitkritische Stelle ist.

Zu den Optimierungen. Normal wäre es wohl besser dafür ein extra Thema zu machen. ;) Nichts desto trotz. Es kommt da meiner Meinung nach auch darauf an wie groß da Array innerhalb des Hauptarrays (arr) ist. Um so größer es ist um so mehr Daten muss er natürlich bewegen. Solltest du also eine Stelle löschen müssen alle Daten danach kopiert werden. Das einfachste wäre natürlich, wenn man die Daten nicht kopieren müsste sondern nur deren Zugriff ändern würde. Denn dann müsste bei einem Löschvorgang nicht die kompletten Daten kopiert werden sondern nur die bezüge dazu. Ich persönlich würde eher zu Pointer greifen. Aber wenn du noch nicht viel damit gemacht hast kann das verwirrend wirken und es bietet auch jedem Menge fehlerpotential.

Aber hier mal ein Beispiel was ich machen würde. Das innere Array würde ich als einen seperaten Typen (eine Klasse wäre recht einfach zu handhaben) deklarieren. Und für das Hauptarray würde ich eine TList benutzen. Zur Verwaltung von Daten bietet die schon so ein paar Optimierungen.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

type
  TItem = class
    Data: array of Double;
  end;

var
  List: TList;
  Item: TItem;
begin
  // Liste erstellen
  List := TList.Create;

  // Eintrag erstellen
  Item := TItem.Create;
  SetLength(Item.Data);

  // Eintrag in Liste packen
  List.Add(Item);

  // Eintrag aus Liste werfen
  // das Casten auf TObject ist nötig, da TList nur Pointer speichert.
  Item := TObject(List[Idx]);   // Eintrag aus Liste lesen
  Item.Free;                    // Eintrag löschen (das dynarray wird automatisch von Delphi gelöscht)
  List.Delete(Idx);             // Eintrag aus Liste entfernen.

  // wenn die Liste nicht mehr gebraucht wird, dann TList freigeben.
  // Dazu müssen aber alle Einträge entfernt werden und freigegeben werden.
  List.Free;

Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2026 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!