Fenster zentrieren

[AND51]

Anstelle von /2 kannst du auch das SchiftRight >>1 verwenden.

Das klingt aber spannend!
Dazu würde ich gern die Meinung eines "Experten" hören.
Ich persönlich würde ja sagen, das ist schneller, weil das / zeichen ein Float-Ergebnis hervorruft, während >> bei Integers/Longs bleibt.
Kann das sein oder war das gerade leicht daneben?

[Falko]

Ich habe mal folgendes getestet und wundere mich über die Ergebnisse.
Normal sollte ein >> schneller sein, als ein / . Beim Shiften werden
alle Bits um einen Platz nach rechts verschoben, sodass ein Bit herausfällt.
In der Hilfe ist es auch noch etwas genauer beschrieben.
Nun dachte ich, man könnte sich mal das ASM-Ergebnis nach einem
pbcompiler "ShiftTest.pb" /COMMENTED mal anschauen, wie es im
ASM aussieht.

Ich hoffe das ausgeben des kommentierten ASM-Souce ist soweit korrekt
PS: Den Kopf habe ich weggelassen

Hier mal der PB-Testsouce:

Code: Alles auswählen

For a=0 To 9
start=0
Wert=0
start=ElapsedMilliseconds()
For i = 0 To 1000000
 Wert = 569878993>>1
Next i
Debug ElapsedMilliseconds()-start
;Debug Wert
;
start=0
Wert=0
start=ElapsedMilliseconds()
For i = 0 To 1000000
 Wert = 569878993/2
Next i

Debug ElapsedMilliseconds()-start
;Debug Wert
Debug"------------------------"
Next a

Die ASM-Ausgabe dazu hier:
Wenn ich das richtig sehe, wird hier nicht geteilt, sondern nur der schon
vorher ausgerechnete Wert in den Schleifen wiederholt.

Code: Alles auswählen

PureBasicStart:
; 
  PUSH   dword I_BSSEnd-I_BSSStart
  PUSH   dword 0
  PUSH   dword I_BSSStart
  CALL  _memset
  ADD    esp,12
  PUSH   dword 0
  CALL  _GetModuleHandleA@4
  MOV    [_PB_Instance],eax
  PUSH   dword 0
  PUSH   dword 4096
  PUSH   dword 0
  CALL  _HeapCreate@12
  MOV    [PB_MemoryBase],eax
; :
; For a=0 To 9
  MOV    dword [v_a],0
_For1:
  MOV    eax,9
  CMP    eax,dword [v_a]
  JL    _Next2
; start=0
  MOV    dword [v_start],0
; Wert=0
  MOV    dword [v_Wert],0
; start=ElapsedMilliseconds()
  CALL  _PB_ElapsedMilliseconds@0
  MOV    dword [v_start],eax
; For i = 0 To 1000000
  MOV    dword [v_i],0
_For3:
  MOV    eax,1000000
  CMP    eax,dword [v_i]
  JL    _Next4
; Wert = 569878993>>1
  MOV    dword [v_Wert],284939496
; Next i
_NextContinue4:
  INC    dword [v_i]
  JMP   _For3
_Next4:
; Debug ElapsedMilliseconds()-start
;Debug Wert
;
; start=0
  MOV    dword [v_start],0
; Wert=0
  MOV    dword [v_Wert],0
; start=ElapsedMilliseconds()
  CALL  _PB_ElapsedMilliseconds@0
  MOV    dword [v_start],eax
; For i = 0 To 1000000
  MOV    dword [v_i],0
_For5:
  MOV    eax,1000000
  CMP    eax,dword [v_i]
  JL    _Next6
; Wert = 569878993/2
  MOV    dword [v_Wert],284939496
; Next i
_NextContinue6:
  INC    dword [v_i]
  JMP   _For5
_Next6:
; 
; Debug ElapsedMilliseconds()-start
;Debug Wert
; Debug"------------------------"
; Next a
_NextContinue2:
  INC    dword [v_a]
  JMP   _For1
_Next2:
; 
_PB_EOP_NoValue:
  PUSH   dword 0
_PB_EOP:
  CALL  _PB_EndFunctions
  PUSH   dword [PB_MemoryBase]
  CALL  _HeapDestroy@4
  CALL  _ExitProcess@4
_PB_EndFunctions:
  RET
; 
; 
section '.data' data readable writeable
; 
_PB_DataSection:
_PB_DEBUGGER_LineNumber: dd -1
_PB_DEBUGGER_IncludedFiles: dd 0
_PB_ExecutableType: dd 0
pb_align 4
pb_align 4
s_s:
  dd     0
  dd     -1
pb_align 4
; 
section '.bss' readable writeable
_PB_BSSSection:
pb_bssalign 4
; 
I_BSSStart:
_PB_MemoryBase:
PB_MemoryBase: rd 1
_PB_Instance:
PB_Instance: rd 1
; 
pb_bssalign 4
PB_DataPointer rd 1
v_a rd 1
v_i rd 1
v_start rd 1
v_Wert rd 1
pb_bssalign 4
pb_bssalign 4
pb_bssalign 4
pb_bssalign 4
I_BSSEnd:
section '.data' data readable writeable
SYS_EndDataSection:

Gruß, Falko

[Thomas]

Jetzt bringt doch den armen KinkMike nicht mit euren ASM-Codes durcheinander ... er ist doch noch Anfänger^^

[Rings]

ich das richtig sehe, wird hier nicht geteilt, sondern nur der schon
vorher ausgerechnete Wert in den Schleifen wiederholt.

Alles was vorher berechnet werden kann (und das ist in diesem Falle so)
wird natürlich auch vorher ausgerechnet und eingesetzt.
Ein wenig optimiert arbeitet PureBasic denn doch .

wenn mans also test will, dann mit Variablen

v=569878993
For i = 0 To 1000000
Wert = v>>1
Next i

[#NULL]

is schon erheblich schneller

Code: Alles auswählen

max=120100100

DisableDebugger
t1=ElapsedMilliseconds()
  For n=0 To max
    val = max >> 2
  Next
t1=ElapsedMilliseconds()-t1
EnableDebugger

Debug Str(t1)

DisableDebugger
t1=ElapsedMilliseconds()
  For n=0 To max
    val = max/2
  Next
t1=ElapsedMilliseconds()-t1
EnableDebugger

Debug Str(t1)

[Falko]

@Rings

Man lernt nie aus . Jetzt ist es auch logisch. Die Optimierung in
PB bei festen Werten ist somit beim Dividieren und Shiften gleich schnell.

Erst beim Einsatz der Werte durch Variablen kann man den waren Unterschied erkennen.
Ist eigentlich auch Sinnvoll.
Nochmals vielen Dank für den Hinweis.

@Thomas, sorry, du hast eigentlich Recht. Da ich ebenfalls Anfänger bin,
wenn es um ASM geht passte es hier gerade gut hinein .
Ich denke aber trotzdem, das hier auch die Anfänger davon profitieren.

Gruß Falko

[KinkMike]

is ja eigentlich alles schön und gut nur ich check irg wie nich was ihr jetzt genau damit bezwecken wollt

noch ne frage:

kann man in PB 3.30 eigentlich soetwas wie eine uhr einbauen ?

[Thomas]

Jep, ganz einfach mit API:

Code: Alles auswählen

; Gibt die aktuelle SYSTEM-ZEIT aus, im Format "hh:mm:ss" 
Procedure.s Zeit() 
 time$=Space(1000) 
 GetTimeFormat_(#LOCALE_USER_DEFAULT,0,0,"HH':'mm':'ss",@time$,1000) 
 ProcedureReturn time$ 
EndProcedure 

; Gibt das aktuelle SYSTEM-DATUM aus, im Format "dd.mm.yyyy" 
Procedure.s Datum() 
 Date$=Space(1000) 
 GetDateFormat_(#LOCALE_USER_DEFAULT ,0 ,0,"dd'.'MM'.'yyyy",@Date$,1000) 
 ProcedureReturn Date$ 
EndProcedure 

[STARGÅTE]

weitere Hilfreiche 3.3 Proceduren findest du auch hier

[KinkMike]

Ah gut, das ist genau das was ich gesucht hab thomas

und auch danke STARGÅTE für deinen Link, sind echt ein paar hilfreiche sachen dabei