Schleifen, Compiler und Geschwindigkeit

[Kaeru Gaman]

Lebostein
> Da führt er die Addition vorher aus, so wie es auch sein sollte

beziehst du das auf die angabe per variablen?

mag ja sein, das es compiler gibt, die sowas vorher checken, und ggf. zur compilezeit ausrechnen...

aber sich auf sowas verlassen zu müssen, halt ich nicht für sinnvoll..


Dr.Shrek
> Idealerweise sollte bereits der 'Entwickler' wissen ob es konstante Werte sind

a) es sind konstante werte,
dann übergebe ich die als konstanten,
oder sogar als komplett berechnete zahl.

b) es sind variablen, die sich aber während der schleife nicht ändern,
dann packe ich das ergebnis in eine dritte variable,
die ich an die schleife übergebe

c) es sind variablen, die sich während der schleife ändern (können),
dann schreib ich das so wie hier.


bevor ich es wußte, habe ich mich nicht einmal darauf verlassen, daß der compiler
die addition zweier #konstanten zur compilezeit und nicht zur laufzeit ausführt.

[NicTheQuick]

@remi_meier:
Und was macht so ein Compiler, wenn meine Schleife so aussieht?

Code: Alles auswählen

Global resumeThread.l

Procedure Thread(dummy.l)
  Protected a.l
  a = 1
  
  Debug "Ich wurde gestartet"
  resumeThread = 0
  While resumeThread ! a
    Delay(1000)
    Debug "Ich laufe noch"
  Wend
  Debug "Ich wurde beendet"
EndProcedure

MessageRequester("Thread", "Klicken um Thread zu starten")
Thread.l = CreateThread(@Thread(), 0)

MessageRequester("Thread", "Klicken um Thread zu beenden.")
resumeThread = 1

While IsThread(Thread) : Delay(10) : Wend
MessageRequester("Thread", "Klicken um Hauptprogramm zu beenden.")

[c]resumeThread[/c] und [c]a[/c] wird in der Schleife nicht geändert, darf
aber auch nicht nur einmal berechnet werden, weil ein anderen Thread
[c]resumeThread[/c] noch ändern kann. Ich glaube kaum, dass ein
optimierender Compiler sowas durchblickt.

Oder hier wird [c]a[/c] auch nicht direkt, aber indirekt geändert:

Code: Alles auswählen

a.l = 10
*l.Long = @a
While a
  Debug *l\l
  *l\l - 1
Wend

Da sollte der Compiler [c]a[/c] auch nicht als konstant ansehen.


Sorry für die schlechten Beispiele, aber es kann ja noch komplexer
aussehen.

[remi_meier]

@Nic:
Der Compiler kann erkennen, wenn eine Variable global ist, der Compiler
kann erkennen, ob einmal eine Adresse von dieser Variable angefordert
wurde (auf legalem Weg), usw. Falls ein Mensch das erkennen kann, ist
es auch möglich, dass ein Compiler das erkennt.

Wobei aber meist (AFAIK) der Compiler das nur auf lokale Variablen
anwendet.

@Kaeru:
Ich finde die Leserlichkeit bei

Code: Alles auswählen

While a < b+c

besser als bei

Code: Alles auswählen

d=b+c
While a < d

noch dazu wird eine zusätzliche Variable benötigt, ausser ein Compiler
ist mal wieder so klug (PB isses nicht) und erkennt, dass 'd' nur hier ver-
wendet wird und somit in ein Register geladen sowie keine Variable 'd'
erzeugt wird.

Es ist wirklich erstaunlich, was sich auf dem Gebiet der Optimierung in
Compilern in den letzten Jahren getan hat! Wenn man alles in bestimmte
Graphen "lädt", kann man extrem viel Informationen rausholen!

greetz
Remi