Zitkosten vom Procedureaufruf?

buSC · Beiträge: 39

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:

markieren

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.

Blackheart666 · Beiträge: 2195 XP D3Prof, D6Pers.

Probiers doch aus (GetTickCount)

buSC · Beiträge: 39

Danke fuer die Antwort auf die erste Frage
und wie sieht es mit dem Zweiten Frage

Danke im Voraus

jaenicke · Verfasst: 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 · Beiträge: 1048 Erhaltene Danke: 4

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.

markieren

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;

_________________
Nur die Menschheit ist arrogant genug, um zu glauben sie sei die einzige intelligente Lebensform im All. Wo nicht mal das nachhaltig bewiesen wurde.

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme