Tool zum Takte zählen

[Michael S. (freak25)]

Guten Morgen Community,

könnt ihr mir sagen mit welchem Tool ich die Takte meines Programmes 
zählen lassen kann. Ich möchte eine Leistungsberechnung für mein Code, 
welches in ASM(Pentium Architektur) geschrieben ist, dürchführen. Da 
brauche ich die Anzahl der Takte bis mein Programme endet.
Oder gibt es eine Möglichkeit diese Information im Visual Studio 2008 
auszulesen.

Danke im Voraus

MfG

[Hmm (Gast)]

Das ist aus einer Reihe von Gründen nicht trivial.
Aber es gibt die wesentlich einfacherer Möglichkeit ein Testprogramm zu 
schreiben, das Deinen Code auruft und die Zeit wischen Aufruf und return 
zu stoppen. Was für ein Betriebssysstem läuft?

Falls keines, geht das auch mit einer Stoppuhr. Gegebenfalls, rufst Du 
den Code einach zehn, hundert oder tausendmal auf oder auch öfter, damit 
Du eine Zeit erhälst, die Du von Hand stoppen kannst.

[Michael S. (freak25)]

Ok verstehe, diese Möglichkeit werde ich mir merken. Im schlimmsten Fall 
muss ich das wohl so machen. Aber ich würde gerne das Ganze rechnerisch 
lössen wollen, weil ich einen durchschnittlichen CPI Wert brauche.
Ich habe mein ASM Code optimiert. Ich würde gerne ziemlich genau die 
Ausführungszeit beider Codes in µs vergleichen wollen. Gibt es da keine 
Tools dafür.

VTune Performance Analyzer ist eigentlich ziemlich das was ich suche, 
aber bei Intel kann man das nicht mehr downloaden :(...

[Arc N. (arc)]

RDTSC mit div. Einschränkungen
http://en.wikipedia.org/wiki/Time_Stamp_Counter
bzw. QueryPerformanceCounter

Ansonsten mit den Profiling Tools des VS
http://msdn.microsoft.com/en-us/library/bb385770%28v=vs.90%29.aspx

[Sven P. (Gast)]

Michael Schmidt schrieb:
> Ich habe mein ASM Code optimiert.
Läuft das nachher unter einem Betriebssystem?

[Michael S. (freak25)]

Arc Net schrieb:
> RDTSC mit div. Einschränkungen

Danke Arc Net...
RDTSC ist ein Zähler für den Prozessortakt, soweit ich das Verstanden 
habe. Ist RDTSC sozusagen ein Unterprogramme für x86 Prozessoren? Wenn 
ich das in mein Assembler einbinde funktioniert das zwar, aber es 
erfolgt keine Ausgabe. Ich habe mir auch Beispielcodes angeschaut, aber 
funktionieren tut das nicht :S...

Sven P. schrieb:
> Läuft das nachher unter einem Betriebssystem?

Nein...Es ist nur eine Berechnung und Ausgabe von Primzahlen

[Arc N. (arc)]

Michael Schmidt schrieb:
> RDTSC ist ein Zähler für den Prozessortakt, soweit ich das Verstanden
> habe. Ist RDTSC sozusagen ein Unterprogramme für x86 Prozessoren?

Das ist nur ein Befehl zum Auslesen des Zählers, die Frequenz mit der 
der Zähler hochzählt ist dabei u.U. nicht konstant und solange nicht 
alle Interrupts gesperrt sind auch von dem abhängig was sonst noch auf 
dem Prozessor/Kern läuft (unter Windows gäbe es 
SetThreadAffinityMask/SetProcessAffinityMask um festzulegen wo der 
Thread/Prozess läuft).

> Wenn ich das in mein Assembler einbinde funktioniert das zwar, aber es
> erfolgt keine Ausgabe.

?????

> Ich habe mir auch Beispielcodes angeschaut, aber
> funktionieren tut das nicht :S...

Heißt? eax, edx verändern sich nach rdtsc nicht?

> Nein...Es ist nur eine Berechnung und Ausgabe von Primzahlen

Und die Messung?

[Dirk Wolfgang Glomp (Gast)]

Moin.

"Frank Kotler" war so nett ein kleines Demo zu schreiben, um die 
Ausführungsgeschwindigkeit einiger Befehle zu messen.
Genauer gesagt aus dem nun folgenden Listing können zwei 
unterschiedliche Anwendungen erstellt werden(siehe Kommentar zum 
Assemblieren), die jeweils eine Messung der Ausführungsgeschwindigkeit 
bestimmter Befehle vonehmen.
In diesem Fall geht es darum es zu messen, ob eine Kombination aus Push- 
und POP-Befehle schneller ausgeführt werden, als eine vergleichbare 
Kombination von MOV- und MOV-Befehle. Die beiden Anwendungen sind für 
ein 32 Bit-Linux im Intel-Syntax geschrieben worden und zeigen wie der 
RDTSC-Befehl verwendet werden kann.

[quote]
Best,
Frank Kotler

; nasm -f elf pushvsmov.asm -d_MOV (or "-d_PUSH")
; ld -o pushvsmov pushvsmov.o

global _start

section .bss
    eax_sav resd 1
    ebx_sav resd 1
    ecx_sav resd 1
    edx_sav resd 1
    esi_sav resd 1
    edi_sav resd 1

section .text
_start:
    nop
    xor eax, eax
    cpuid
    rdtsc
    push edx
    push eax
%ifdef _MOV
    mov [eax_sav], eax
    mov [ebx_sav], ebx
    mov [ecx_sav], ecx
    mov [edx_sav], edx
    mov [esi_sav], esi
    mov [edi_sav], edi

    mov edi, [edi_sav]
    mov esi, [esi_sav]
    mov edx, [edx_sav]
    mov ecx, [ecx_sav]
    mov ebx, [ebx_sav]
    mov eax, [eax_sav]
%elifdef _PUSH
    push eax
    push ebx
    push ecx
    push edx
    push esi
    push edi

    pop edi
    pop esi
    pop edx
    pop ecx
    pop ebx
    pop eax
%else
    %error 'must define _MOV or _PUSH'
%endif
 
    xor eax, eax
    cpuid
    rdtsc
    pop ebx
    pop ecx
    sub eax, ebx
    sbb edx, ecx

    call showeaxd

    xor ebx, ebx
    mov eax, 1
    int 80h

;---------------------------------
showeaxd:
    push eax
    push ebx
    push ecx
    push edx
    push esi

    sub esp, 10h
    lea ecx, [esp + 12]
    mov ebx, 10
    xor esi, esi
    mov byte [ecx], 0
.top:
    dec ecx
    xor edx, edx
    div ebx
    add dl, '0'
    mov [ecx], dl
    inc esi
    or eax, eax
    jnz .top

    mov edx, esi
    mov ebx, 1
    mov eax, 4
    int 80h

    add esp, 10h

    pop esi
    pop edx
    pop ecx
    pop ebx
    pop eax

    ret
;---------------------------------

[/quote]

Dirk Wolfgang Glomp

[Peter II (Gast)]

Die Takte können aber auf jeder CPU unterschiedlich sein, intel & co 
optimieren ihre CPUs ja ständig. Da kann es durchaus sein, das das 
Programm auf der nächsten CPU (Celeron vs I7 ) sich anders verhält.

Man könnte es einfach in einem emulator laufen lassen 
(http://bochs.sourceforge.net/), eventuell gibt es dort die möglichkeit 
die Takte ausgeben zu lassen.

[Dirk Wolfgang Glomp (Gast)]

Peter II schrieb:
> Die Takte können aber auf jeder CPU unterschiedlich sein, intel & co
> optimieren ihre CPUs ja ständig. Da kann es durchaus sein, das das
> Programm auf der nächsten CPU (Celeron vs I7 ) sich anders verhält.

Ja richtig und so kann man herausfinden bei welchen CPUs bestimmte 
Befehle schneller ausgeführt werden und bei welchen CPUs es langsamer 
wird.

Beispiel: Bis einschliesslich Pentium 3 wird eine Kombination von Mov- 
und Mov-Befehle schneller ausgeführt, als die Kombination von Push- und 
Pop-Befehle. Erst mit dem Pentium 4 änderste sich das. Bei den CPUs von 
AMD verhält sich es vergleichbar.  Beim AMD K6 ist eine Kombination von 
Mov- und Mov-Befehle auch noch schneller.

> Man könnte es einfach in einem emulator laufen lassen
> (http://bochs.sourceforge.net/), eventuell gibt es dort die möglichkeit
> die Takte ausgeben zu lassen.

Damit kann man doch aber nur die Verarbeitungsgeschwindigkeit des 
Emulators bestimmen, für den Fall das wir unsere Anwendung für die 
Umgebung des Emulator optimieren wollen. Ich vemute etwas anderes kann 
man damit nicht testen, als das wie gut eine CPU sich zum Emulieren 
eignet, bzw. wie dort unter einer Emulation unsere Kombination von 
Befehle sich verhalten. Mit der Ausführungsgeschwindigkeit von realen 
und nicht emulierten CPUs läßt sich das vermutlich nicht vergleichen 
bzw. unsere Messergebnisse nicht sinnvoll übertragen.

Dirk

[Rolf Magnus (Gast)]

Es gibt bei solchen Prozessoren so viele Dinge, die Einfluss auf die 
Ausführungsgeschwindigkeit haben, daß es nicht sinnvoll ist, die 
theoretisch benötigten Taktzyklen einzelner Instruktionen 
zusammenzuzählen.
Man denke nur z.B. an Dinge wie Cache, superskalare Architektur, 
Pipeline Stalls, Branch Prediction, TLBs u.s.w.
Manche von diesen Dingen können die Ausführungsgeschwindigkeit 
situationsabhängig stärker beeinflussen als die reine Ausführungsdauer 
der einzelnen Instruktionen. Und nicht nur der Prozessor, sondern auch 
Chipsatz und Speicher beeinflussen das, ggf. auch noch andere 
Peripherie, wenn sie z.B. per DMA auf den Speicher zugreift. Von einem 
evtl. auf dem System laufenden Betriebssystem fangen wir besser gar 
nicht erst an.