? Meine Kiste (i7-4770K) hat nur einen Prozessor, aber wenn ich obiges Testprogramm z.B. auf Core 2 (Core0 = Boot-Core) festnagle, ändert sich nicht die Bohne (na klar).Ich weiß schon wie Du es meinst, aber wir werden zu sehr OT...
Goto sinnvoll nutzen
Re: Goto sinnvoll nutzen
bobobo, hast Du im Lotto gewonnen und Dir einen Multi-Prozessor-PC leisten können ? Meine Kiste (i7-4770K) hat nur einen Prozessor, aber wenn ich obiges Testprogramm z.B. auf Core 2 (Core0 = Boot-Core) festnagle, ändert sich nicht die Bohne (na klar).
Ich weiß schon wie Du es meinst, aber wir werden zu sehr OT...
? Meine Kiste (i7-4770K) hat nur einen Prozessor, aber wenn ich obiges Testprogramm z.B. auf Core 2 (Core0 = Boot-Core) festnagle, ändert sich nicht die Bohne (na klar).Ich weiß schon wie Du es meinst, aber wir werden zu sehr OT...
Re: Goto sinnvoll nutzen
Helle hat geschrieben:Zeiten auf einem 8120-er Bulldozer:
Assembler: 6978
Goto Version 1: 8085
Goto Version 2: 8076
For Next: 8171
While Wend: 8104
Repeat Until: 8200
Ungewöhnlich hohe Werte, ohne Debugger und ohne laufende Programme im Hintergrund.Helle hat geschrieben:Aber jetzt: Ich bin jetzt daheim und habe meinen obigen Code auf einem i7-4770K mit 4.0 GHz getestet (der FX-8120 lief übrigens mit 3.6 GHz). Die Werte:
Assembler: 3673
Goto Version 1: 4403
Goto Version 2: 4248
For Next: 4262
While Wend: 4186
Repeat Until: 4269
Verwendest Du vielleicht Windows, und könnten die PB-String-Funktionen sowie Aufrufkonventionen (Calling Conventions)
auf unterschiedlichen Betriebssystemen den Unterschied machen?
Meine Werte mit Mac Mini Server:
Code: Alles auswählen
; Mac Mini Server (late 2012)
; Mac OS X 10.9.2
; 2.6 GHz quad-core Intel Core i7 (i7-3720QM Turbo Boost up to 3.6 GHz)
; Cache: 6 MB L3
; 16 GB 1600 MHz DDR3
;
; Assembler: 2733
; Goto Version 1: 3485
; Goto Version 2: 3451
; For Next: 3484
; While Wend: 3645
; Repeat Until: 3633cya,
...Danilo
"Ein Genie besteht zu 10% aus Inspiration und zu 90% aus Transpiration" - Max Planck
...Danilo
"Ein Genie besteht zu 10% aus Inspiration und zu 90% aus Transpiration" - Max Planck
-
NicTheQuick
- Ein Admin
- Beiträge: 8807
- Registriert: 29.08.2004 20:20
- Computerausstattung: Ryzen 7 5800X, 64 GB DDR4-3200
Ubuntu 24.04.2 LTS
GeForce RTX 3080 Ti - Wohnort: Saarbrücken
Re: Goto sinnvoll nutzen
Hab es extra noch ein paar Mal getestet. Es ist halt so schnell hier. Da kann ich auch nichts gegen machen. 
Übrigens wechseln bei mir auch die Cores nicht hin und her wie bei bobobo. Es läuft komplett auf einem durch.
Ich hab es gerade noch mal gemacht, immer noch mit der selben Akkuladung. Es ist ein kleines bisschen langsamer geworden, weil ich natürlich gerade einen FullHD-Bildschirmmitschnitt gemacht habe: Helles Schleifen Test-Code in Purebasic und ASM
Also wenn das bei euch an Windows liegt, dann grinse ich mal ein bisschen.
Übrigens wechseln bei mir auch die Cores nicht hin und her wie bei bobobo. Es läuft komplett auf einem durch.
Ich hab es gerade noch mal gemacht, immer noch mit der selben Akkuladung. Es ist ein kleines bisschen langsamer geworden, weil ich natürlich gerade einen FullHD-Bildschirmmitschnitt gemacht habe: Helles Schleifen Test-Code in Purebasic und ASM
Also wenn das bei euch an Windows liegt, dann grinse ich mal ein bisschen.
Re: Goto sinnvoll nutzen
NicTheQuick hat geschrieben:Also wenn das bei euch an Windows liegt, dann grinse ich mal ein bisschen.
:::: WIN 10 :: PB 5.73 :: (x64) ::::
Re: Goto sinnvoll nutzen
Erstmal ein Nachtrag zur ASM-Schleife: Die ist nur deshalb schneller, weil in ihr die Variable "i" nicht geändert wird, machen aber die anderen Schleifen und wird ja für den String im Macro benötigt. Wird dies korrigiert, sind alle Schleifen wieder auf gleichem Zeit-Niveau. Dann kann jeder seinen Favoriten an die schnellste Stelle in der Test-Suite schieben . Ohne Macro ist übrigens "For" bei mir das Schnellste...
Und ja, NicTheQuick und Danilo können ganz breit grinsen
! Andreas21 hat ja wohl auch auf Windows x64 getestet und auch sein Ergebnis ist nicht so berauschend. Selbst in einer VM lief bei mir die 32-Bit-Version schneller.
Habe mir dann mal die 3 verwendeten PB-String-Assemblies (im Macro) angeschaut und da wird dann einiges klar (was ich leider schon öfters gesehen habe): Vorhandener 32-Bit-Code wurde für 64-Bit lauffähig gemacht, aber nicht neu erstellt mit den Möglichkeiten von 64-Bit. Da wird z.B. auf dem Stack mit DWords gearbeitet, die dann bei Gebrauch für 64-Bit-Register erst konvertiert werden müssen usw. So kommt der arme Windows-Fuzzi natürlich auf keinen grünen Zweig...
Ein jetzt trauriger
Helle
. Ohne Macro ist übrigens "For" bei mir das Schnellste...Und ja, NicTheQuick und Danilo können ganz breit grinsen
! Andreas21 hat ja wohl auch auf Windows x64 getestet und auch sein Ergebnis ist nicht so berauschend. Selbst in einer VM lief bei mir die 32-Bit-Version schneller.Habe mir dann mal die 3 verwendeten PB-String-Assemblies (im Macro) angeschaut und da wird dann einiges klar (was ich leider schon öfters gesehen habe): Vorhandener 32-Bit-Code wurde für 64-Bit lauffähig gemacht, aber nicht neu erstellt mit den Möglichkeiten von 64-Bit. Da wird z.B. auf dem Stack mit DWords gearbeitet, die dann bei Gebrauch für 64-Bit-Register erst konvertiert werden müssen usw. So kommt der arme Windows-Fuzzi natürlich auf keinen grünen Zweig...
Ein jetzt trauriger
Helle
-
Andreas21
- Beiträge: 390
- Registriert: 30.08.2004 09:05
- Computerausstattung: Desktop
Windows 10 Pro x64
CPU: AMD Ryzen 5 2600 3.40 GHz
Ram: 16GB RAM
Grafik: NVIDA Geforce 1060
PB: 5.72 X86/X64 - Wohnort: Heidelberg
Re: Goto sinnvoll nutzen
Ja es war Windows 7 Home Premi x64
Ohne Unicode:
Hier mal mit LinuX Mint 16 (Live CD)Assembler: 6206
Goto Version 1: 7755
Goto Version 2: 7712
For Next: 7728
While Wend: 7847
Repeat Until: 7778
Ohne Unicode:
Mit Unicode:Assembler: 2635
Goto Version 1: 3874
Goto Version 2: 3851
For Next: 3902
While Wend: 3876
Repeat Until: 3865
Assembler: 2449
Goto Version 1: 4121
Goto Version 2: 4076
For Next: 4096
While Wend: 4089
Repeat Until: 4061
Windows 10 x64 Pro - PB 5.61 X64 / x32 - PB 4.6 x32
-
TroaX
- Beiträge: 684
- Registriert: 08.03.2013 14:27
- Computerausstattung: PC: Ryzen 9 3950X, 96 GB RAM, RX6800XT, 2.5 TB SSD, 21:9 Display, Linux Mint | Lappi: Ryzen 7 5800H, 16 GB RAM, 1 TB SSD, Linux Mint
- Wohnort: NRW
- Kontaktdaten:
Re: Goto sinnvoll nutzen
Da sieht man mal wieder die Unterschiede zwischen Mac, Windoof und Linux. Aber wenn Linux und Schwanzvergleich in Sachen Leistung, dann bitte mit einem Debian oder Arch ohne GUI laufen lassen. Hätte ich Zeit, würde ich es mal testen. Habe ich nur leider nicht
Würde aber sicher noch einiges an Zeit gut machen
UPDATE: Ich habe es mal selbst getestet unter Windows x64. Jetzt wirds traurig
Würde aber sicher noch einiges an Zeit gut machen
UPDATE: Ich habe es mal selbst getestet unter Windows x64. Jetzt wirds traurig
PC: Ryzen 9 3950X | 96 GB RAM | RX6800XT | 2,5 TB NVMe | Linux Mint
Notebook: 16" 3:2 | Ryzen 7 5800H | 16 GB RAM | Radeon Vega | 1TB NVMe | Linux Mint
NAS: Fritz.Box 5690 Pro (Nur für Keepass-DB)
Coding: Purebasic, Spiderbasic, GDevelop, Javascript/Node
Notebook: 16" 3:2 | Ryzen 7 5800H | 16 GB RAM | Radeon Vega | 1TB NVMe | Linux Mint
NAS: Fritz.Box 5690 Pro (Nur für Keepass-DB)
Coding: Purebasic, Spiderbasic, GDevelop, Javascript/Node
Re: Goto sinnvoll nutzen
schön, wenn folgendes ginge:
Ich habe aber hier noch eine hoch optimierte Version:
Code: Alles auswählen
Macro makro(_k)
CompilerIf _k > 0
a$ = "o_something_" + Str(_k)
makro(_k-1)
CompilerEndIf
EndMacro
time = ElapsedMilliseconds()
makro(500)
time = ElapsedMilliseconds() - time
Debug time
Code: Alles auswählen
Debug 0
Re: Goto sinnvoll nutzen
Helle, kannst du das einmal verdeutlichen und in kurzen Auszügen hier posten ?Helle hat geschrieben:.....Habe mir dann mal die 3 verwendeten PB-String-Assemblies (im Macro) angeschaut und da wird dann einiges klar (was ich leider schon öfters gesehen habe): Vorhandener 32-Bit-Code wurde für 64-Bit lauffähig gemacht, aber nicht neu erstellt mit den Möglichkeiten von 64-Bit. Da wird z.B. auf dem Stack mit DWords gearbeitet, die dann bei Gebrauch für 64-Bit-Register erst konvertiert werden müssen usw. So kommt der arme Windows-Fuzzi natürlich auf keinen grünen Zweig...
Ein jetzt trauriger
Helle
Schliesslich ist uns allen gelegen das fred das auch im Compiler bei der
Codegenerierung anwendet .
Solche (man kanns noch nichteinmal als Optimierugen bezeichnen ssondern als Anwendung der 64 Bit Programmierung)
Veränderungen kommen wahrscheinlich überall an.
Danke...
Rings hat geschrieben:ziert sich nich beim zitieren
Re: Goto sinnvoll nutzen
@Rings: Das ist aber ganz stark OT und ich möchte nicht als böser Hacker dastehen, aber sei es drum (kann ja von euch gelöscht werden). Nehmen wir gleich mal das erste Call vom Macro, SYS_CopyString. Dieser Aufruf macht nichts weiter als a$="do_something_" zu setzen. So sieht der ASM-Code aus; und strlen habe ich noch aussen vor gelassen:
Sorry, aber das muss auch einfacher und damit schneller gehen!
Code: Alles auswählen
Call SYS_CopyString, setzt a$ = "do_something_"
$000000014000107E E8 9D 11 00 00 CALL 00 00 00 01 40 00 22 20
$0000000140002220 48 89 4C 24 08 MOV qword ptr [ RSP + 08 ] , RCX
$0000000140002225 48 83 EC 38 SUB RSP , 00 00 00 00 00 00 00 38
$0000000140002229 48 83 7C 24 40 00 CMP qword ptr [ RSP + 40 ] , 00 00 00 00 00 00 00 00
$000000014000222F 74 38 JE 00 00 00 01 40 00 22 69 ( short ) ( = JZ )
$0000000140002231 48 8B 4C 24 40 MOV RCX , qword ptr [ RSP + 40 ]
$0000000140002236 E8 58 02 00 00 CALL 00 00 00 01 40 00 24 93
$000000014000223B 89 44 24 28 MOV dword ptr [ RSP + 28 ] , EAX
$000000014000223F 8B 15 AB 2F 00 00 MOV EDX , dword ptr [ 00 00 00 01 40 00 51 F0 ]
$0000000140002245 8B 4C 24 28 MOV ECX , dword ptr [ RSP + 28 ]
$0000000140002249 E8 02 01 00 00 CALL 00 00 00 01 40 00 23 50
$000000014000224E 48 89 44 24 20 MOV qword ptr [ RSP + 20 ] , RAX
$0000000140002253 44 8B 44 24 28 MOV R8D , dword ptr [ RSP + 28 ]
$0000000140002258 48 8B 54 24 40 MOV RDX , qword ptr [ RSP + 40 ]
$000000014000225D 48 8B 4C 24 20 MOV RCX , qword ptr [ RSP + 20 ]
$0000000140002262 E8 B9 01 00 00 CALL 00 00 00 01 40 00 24 20
$0000000140002267 EB 17 JMP 00 00 00 01 40 00 22 80 ( short )
$0000000140002269 48 8B 05 80 2F 00 00 MOV RAX , qword ptr [ 00 00 00 01 40 00 51 F0 ]
$0000000140002270 48 8B 0D 89 2F 00 00 MOV RCX , qword ptr [ 00 00 00 01 40 00 52 00 ]
$0000000140002277 48 03 C8 ADD RCX , RAX
$000000014000227A 48 8B C1 MOV RAX , RCX
$000000014000227D C6 00 00 MOV byte ptr [ RAX ] , 00
$0000000140002280 48 83 C4 38 ADD RSP , 00 00 00 00 00 00 00 38
$0000000140002284 C3 RET (near)
$0000000140002493 strlen
$0000000140002350 89 54 24 10 MOV dword ptr [ RSP + 10 ] , EDX
$0000000140002354 89 4C 24 08 MOV dword ptr [ RSP + 08 ] , ECX
$0000000140002358 48 83 EC 38 SUB RSP , 00 00 00 00 00 00 00 38
$000000014000235C 48 63 44 24 40 MOVSXD RAX , dword ptr [ RSP + 40 ]
$0000000140002361 48 8B 0D 88 2E 00 00 MOV RCX , qword ptr [ 00 00 00 01 40 00 51 F0 ]
$0000000140002368 48 03 C8 ADD RCX , RAX
$000000014000236B 48 8B C1 MOV RAX , RCX
$000000014000236E 89 44 24 28 MOV dword ptr [ RSP + 28 ] , EAX
$0000000140002372 48 63 44 24 28 MOVSXD RAX , dword ptr [ RSP + 28 ]
$0000000140002377 48 8B 0D A2 2E 00 00 MOV RCX , qword ptr [ 00 00 00 01 40 00 52 20 ]
$000000014000237E 48 83 E9 04 SUB RCX , 00 00 00 00 00 00 00 04
$0000000140002382 48 3B C1 CMP RAX , RCX
$0000000140002385 7C 3D JL 00 00 00 01 40 00 23 C4 ( short ) ( = JNGE )
$0000000140002387 8B 44 24 28 MOV EAX , dword ptr [ RSP + 28 ]
$000000014000238B 05 00 40 00 00 ADD EAX , 00 00 40 00
$0000000140002390 48 98 CDQE
$0000000140002392 48 89 05 87 2E 00 00 MOV qword ptr [ 00 00 00 01 40 00 52 20 ] , RAX
$0000000140002399 48 8B 05 80 2E 00 00 MOV RAX , qword ptr [ 00 00 00 01 40 00 52 20 ]
$00000001400023A0 48 83 C0 05 ADD RAX , 00 00 00 00 00 00 00 05
$00000001400023A4 4C 8B C8 MOV R9 , RAX
$00000001400023A7 4C 8B 05 52 2E 00 00 MOV R8 , qword ptr [ 00 00 00 01 40 00 52 00 ]
$00000001400023AE 33 D2 XOr EDX , EDX
$00000001400023B0 48 8B 0D 59 2E 00 00 MOV RCX , qword ptr [ 00 00 00 01 40 00 52 10 ]
$00000001400023B7 FF 15 5F 2D 00 00 CALL qword ptr [ 00 00 00 01 40 00 51 1C ] ("HeapReAlloc") ( near )
$00000001400023BD 48 89 05 3C 2E 00 00 MOV qword ptr [ 00 00 00 01 40 00 52 00 ] , RAX
$00000001400023C4 48 63 44 24 48 MOVSXD RAX , dword ptr [ RSP + 48 ]
$00000001400023C9 48 8B 0D 30 2E 00 00 MOV RCX , qword ptr [ 00 00 00 01 40 00 52 00 ]
$00000001400023D0 48 03 C8 ADD RCX , RAX
$00000001400023D3 48 8B C1 MOV RAX , RCX
$00000001400023D6 48 89 44 24 20 MOV qword ptr [ RSP + 20 ] , RAX
$00000001400023DB 48 63 44 24 48 MOVSXD RAX , dword ptr [ RSP + 48 ]
$00000001400023E0 48 63 4C 24 40 MOVSXD RCX , dword ptr [ RSP + 40 ]
$00000001400023E5 48 03 C1 ADD RAX , RCX
$00000001400023E8 48 89 05 01 2E 00 00 MOV qword ptr [ 00 00 00 01 40 00 51 F0 ] , RAX
$00000001400023EF 48 8B 44 24 20 MOV RAX , qword ptr [ RSP + 20 ]
$00000001400023F4 48 83 C4 38 ADD RSP , 00 00 00 00 00 00 00 38
$00000001400023F8 C3 RET (near)
$0000000140002420 44 89 44 24 18 MOV dword ptr [ RSP + 18 ] , R8D
$0000000140002425 48 89 54 24 10 MOV qword ptr [ RSP + 10 ] , RDX
$000000014000242A 48 89 4C 24 08 MOV qword ptr [ RSP + 08 ] , RCX
$000000014000242F 48 83 EC 18 SUB RSP , 00 00 00 00 00 00 00 18
$0000000140002433 48 63 44 24 30 MOVSXD RAX , dword ptr [ RSP + 30 ]
$0000000140002438 48 8B 4C 24 20 MOV RCX , qword ptr [ RSP + 20 ]
$000000014000243D 48 03 C8 ADD RCX , RAX
$0000000140002440 48 8B C1 MOV RAX , RCX
$0000000140002443 48 89 04 24 MOV qword ptr [ RSP ] , RAX
$0000000140002447 83 7C 24 30 00 CMP dword ptr [ RSP + 30 ] , 00 00 00 00
$000000014000244C 7E 39 JLE 00 00 00 01 40 00 24 87 ( short ) ( = JNG )
$000000014000244E 48 8B 44 24 20 MOV RAX , qword ptr [ RSP + 20 ]
$0000000140002453 48 8B 4C 24 28 MOV RCX , qword ptr [ RSP + 28 ]
$0000000140002458 8B 09 MOV ECX , dword ptr [ RCX ]
$000000014000245A 89 08 MOV dword ptr [ RAX ] , ECX
$000000014000245C 48 8B 44 24 20 MOV RAX , qword ptr [ RSP + 20 ]
$0000000140002461 48 83 C0 04 ADD RAX , 00 00 00 00 00 00 00 04
$0000000140002465 48 89 44 24 20 MOV qword ptr [ RSP + 20 ] , RAX
$000000014000246A 48 8B 44 24 28 MOV RAX , qword ptr [ RSP + 28 ]
$000000014000246F 48 83 C0 04 ADD RAX , 00 00 00 00 00 00 00 04
$0000000140002473 48 89 44 24 28 MOV qword ptr [ RSP + 28 ] , RAX
$0000000140002478 48 63 44 24 30 MOVSXD RAX , dword ptr [ RSP + 30 ]
$000000014000247D 48 83 E8 04 SUB RAX , 00 00 00 00 00 00 00 04
$0000000140002481 89 44 24 30 MOV dword ptr [ RSP + 30 ] , EAX
$0000000140002485 EB C0 JMP 00 00 00 01 40 00 24 47 ( short )
$0000000140002487 48 8B 04 24 MOV RAX , qword ptr [ RSP ]
$000000014000248B C6 00 00 MOV byte ptr [ RAX ] , 00
$000000014000248E 48 83 C4 18 ADD RSP , 00 00 00 00 00 00 00 18
$0000000140002492 C3 RET (near)