Lösung : Prozessorspeed in MHZ
-
ich hab versucht den code
von kingruedi auf linux mit dem gcc zum laufen
zu kriegen.
allerdings wird mir der code nicht uebersetzt.__asm__ __volatile__("rdtsc":"=a"(value1),"=d"(value2)::); // <-- parse error
sleep(1); //POSIX 1 function
__asm__ __volatile__("rdtsc":"=a"(value3),"=d"(value3)::); // <-- parse errorich krieg einen parse error vor dem ::.
was mach ich falsch?
-
hast du vielleicht den Parameter aktiviert, dass der GCC keine eigenen Erweiterungen akzeptiert?
Welche Version hast du?
-
ich hab den gcc 2.95.4.
und uebersetze das ganze mit:
gcc mhz.c
(den quelltext hab ich von hier oben rauskopiert)#include <stdio.h> #include <unistd.h> unsigned long getmhz(void) { unsigned long value1=0,value2=0,value3=0,value4=0; double mhz; __asm__ __volatile__("rdtsc":"=a"(value1),"=d"(value2)::); //<- 41: fehler sleep(1); //POSIX 1 function __asm__ __volatile__("rdtsc":"=a"(value3),"=d"(value3)::); //<- 43: fehler value1=value3-value1; value2=value4-value2; mhz=(value1+(value2*(2^32)))/1000/1000; return (unsigned long)mhz; } int main() { printf("%d\n",getmhz()); return 0; }(da hab ich noch n paar komentare drin deswegen zeile 41)
die genaue fehlrmeldung:
mhz.c: In functiongetmhz': mhz.c:41: parse error before)'
mhz.c:43: parse error before `)'[ Dieser Beitrag wurde am 23.09.2002 um 20:47 Uhr von entelechie editiert. ]
-
Bitte kläre mal einen unwissenden über deinen Code Auf. Erstmal Danke für den genialen Ansatz, aber wenn ich die Sleep - Zeit verändern will, so geht das nicht. Also habe ich einmal mit der Berechnung der MHZ - Zahl ein bischen rumgespielt.
du rechnest:
double MHZ = (value1+(value2*(2^32)))/1000/1000;
value2*(2^32) soll nehme ich an das shiften der höherwertigen Bits darstellen, da ja in value2 die Diffrenz der beiden höherwetigen DWORD - Variablen ist. 2^32 entspricht doch aber nicht 2 hoch 32 sondern dem exklusiven oder Operator oder ( zumindest bei mir beim VC )? Demzufolge hat aus irgendwelchen Gründen bei mir das ganze nur hingehauen, bei genau Sleep(1000). Ich hab die Routine jetzt mal ein bisschen umgeändert, um die Messzeit verlängern zu können, damit die 5ms - Ungenauigkeit des Sleep nicht so sehr ins gewicht fällt.
Wie folgt:
DWORD GetMHZ() { DWORD iDurationMeasure = 12000; DWORD value1 = 0; DWORD value2 = 0; DWORD value3 = 0; DWORD value4 = 0; __asm { rdtsc mov value1, eax //Low order Bits mov value2, edx //High oreder Bits } Sleep(iDurationMeasure); __asm { rdtsc mov value3, eax mov value4, edx } value1 = value3 - value1;//Low order Bytes value2 = value4 - value2;//High Order Bytes ULONGLONG dwHigOrderBytes = ULONGLONG((ULONGLONG)value2 << 32);//shift der höherwetigen Bits ULONGLONG ulTicks = dwHigOrderBytes + value1;//berechnen der Gesamtticks DWORD MHZ = (ulTicks / ( DWORD )( iDurationMeasure * 1000 ) );//Umrechnung in Mhz return (DWORD)MHZ; }Bei Zwölf Sekunden Messzeit habe ich jetzt noch Streuungen von maximal 1Mhz. Vielleicht liege ich ja auch falsch. Bitte klärt mich auf.
Danke
-
#include <iostream> #include <windows.h> #include <conio.h> using namespace std; DWORD GetMHZ() { DWORD value1 = 0; DWORD value2 = 0; DWORD value3 = 0; DWORD value4 = 0; __asm { rdtsc mov value1, eax mov value2, edx } ::Sleep(1000); // HIER GEHÖRT EIN :: hin!! ::Sleep(...); __asm { rdtsc mov value3, eax mov value4, edx } value1 = value3 - value1; //meckert er bei mir das value1 2 3 4 nicht deklariert seien in diesem namensbereich! value2 = value4 - value2; double MHZ = (value1+(value2*(2^32)))/1000/1000; return (DWORD)MHZ; } int main() { cout << (int)GetMHZ << " MHZ"<<endl; getch(); return 0; }
-
Original erstellt von Lars Skiba:
**```cpp
::Sleep(1000); // HIER GEHÖRT EIN :: hin!! ::Sleep(...);Nur bei einem C++-Programm und davon war hier nie die Rede
-
@Lars
nur wenn durch iostream auch eine Sleep Funktion definiert wird
@TheBigW
in C(++) ist ^ der exklusiv oder Operator, dass liegt nicht am VC++ (auch wenn der viel anders macht). pow (aus der math.h bzw. cmath) benutzt man zum potenzieren. (Warum es keinen ** Operator, wie in FORTRAN gibt, versteh ich auch nicht ganz :))@entelchien
Versuchs mal sogcc -O3 -Wall -W -o cpu cpu.c
-
@kingruedi
ok ich habs zum laufen gebracht. erhalte aber auch
unterschiedliche werte... und viel zu hoch...hast du das problem mitlerweile geloest?
-
nö, ich hab mich nicht dran gesetzt. Weiss nicht genau woran es liegt.
-
Könnte man mit dem Code auch messen, wie lange die CPU für einen Befehl braucht, z.b. für ein xor ax,ax oder so?
Ich hab´s mal versucht und das Sleep dagegen ersetzt, aber hab immer nur 11 rausgekriegt, egal was ich statt xor eingesetzt habe, auch bei 30 xor kommt noch 11 raus.#include <iostream> #include <windows.h> #include <conio.h> using namespace std; DWORD GetMHZ() { DWORD value1 = 0; DWORD value2 = 0; DWORD value3 = 0; DWORD value4 = 0; __asm { rdtsc mov value1, eax mov value2, edx } __asm { xor ax,ax xor ax,ax xor ax,ax xor ax,ax } __asm { rdtsc mov value3, eax mov value4, edx } value1 = value3 - value1; value2 = value4 - value2; double MHZ = (value1+(value2*(2^32))); return (DWORD)MHZ; } int main() { cout << (int)GetMHZ() << " Ticks"<<endl; cout << (int)GetMHZ() << " Ticks"<<endl; cout << (int)GetMHZ() << " Ticks"<<endl; cout << (int)GetMHZ() << " Ticks"<<endl; getch(); return 0; }Wieso kommt mir da immer 11 raus?
mfg und thx im Voraus
Noob
-
Hallo Leute,
Der Thread ist schon etwas älter, aber ich habe ein Problem mit diesem Code:
Ich bekomme ca alle 2 bis 4 Sekunden in value4 einen Wert, der um 1 zu groß ist, bzw in value 2 einen, der um 1 zu klein ist.
Da die Differenz dieser beiden Zahlen bei der Berechnung mit 2 hoch 32 malgenommen wird (hab diese Stelle in meinem code berichtigt), hat das natürlich ziemliche auswirkungen ...
Ich dachte erst, das liegt daran, dass Sleep zu ungenau ist, deswegen hab ich mir mit QueryPerformanceFrequency und QueryPerformanceCounter ne eigene Sleep-Funktion gebastelt. Brachte aber keine Besserung. Jemand ne Idee, woran das liegen könnte und wie ich es beheben kann?
Und hat jemand ne Ahnung, was QueryPerformanceFrequency ausliest und ob ich das anstelle dieses Codes irgendwie verwenden kann? Das kann nicht das gleiche sein, da der Wert sehr viel kleiner ist ...
Danke
-
Niemand ne Idee?
-
Mich wundert, dass diese CPU-Speed-messung so ueberhaupt funktionieren soll... Die Interrupts bleiben schliesslich aktiviert, dadurch wird IMHO das Ergebnis verfaelscht
-
wenn ich schreibe:
;vergangene millisekunden messen
mov ecx,10000
loop__:
db 90 dup(10000)
dec ecx
jnz loop__:
;nochmal millisekunden messendamit kriege ich doch die ungefähre zeit raus die die CPU für 100MHZ(wenn ihc mich nicht verrechnet habe) raus oder?
Damit könnte man die geschwindigkeit auf die echte Rechenleistung hoch rechnen.
-
So wie ich das sehe, wuerde diese Prozedur zwischen den beiden Messpunkten ziemlich lange dauern... Da kannst Du dir sicher sein, dass Windows in der Zwischenzeit ein paar Interrupts abhandelt und schon ist das Ergebnis unbrauchbar.
-
Original erstellt von Bigor:
damit kriege ich doch die ungefähre zeit raus die die CPU für 100MHZ(wenn ihc mich nicht verrechnet habe) raus oder?
Damit könnte man die geschwindigkeit auf die echte Rechenleistung hoch rechnen.Jein, nicht wenn dein Prozessor parallelisiert und z.B. drei NOPs gelichzetig ausführt
-
unter Windows,aber unter DOS denke ich würde es gehen.
-
Original erstellt von Bigor:
unter Windows,aber unter DOS denke ich würde es gehen.Eine Drei-Pipeline-CPU ist ein drei-Pipeline-CPU und führt so gut es geht drei Befehle parallel aus, ob Windows, DOS, Linux oder sonstiges
-
wie kann es sein, dass das ueberhaupt funktioniert hat? 2^32 ist doch 34, oder? haben das alle verbessert die hier ergebnisse gepostet haben, oder was ist los?
um die ticks von genau einer sekunde zu kommen, koennte man die zeit, die fuer Sleep(1000) benoetigt wird messen, und davon die fuer Sleep(0) abziehen. dann muesste ja der overhead fehlen.
hat ein prozessor echt nicht irgendwas, was man direkt auslesen kann, um auf die mhz zu kommen?
-
Original erstellt von PeterTheMaster:
um die ticks von genau einer sekunde zu kommen, koennte man die zeit, die fuer Sleep(1000) benoetigt wird messen, und davon die fuer Sleep(0) abziehen. dann muesste ja der overhead fehlen.Sleep wartet zufällig lange, je nach dem, welche anderen Prozesse leben.
Hattu keine hochauflösende Uhr, dann mach so:
-mit while(clock()==t) auf nen clocktickbeginn warten (oder andere genaue uhr)
-Sleep(lange);
-mit while(clock()==t) auf nen clocktickbeginn warten (oder andere genaue uhr)
So haste ne genaue Zeitdifferenz. Dat rult.aber warum nicht einfach ungefähr ne sekunde sleepen, davor und danach sowohl mit rdtsc als auch QueryPerformanceCounter messen.
und dann kommt...
obwohl genügend ******* sagen, ohne mathe könne man proggen...
der gewaltigen DREISATZ!!!und schwups habe ich fertig.
[ Dieser Beitrag wurde am 16.11.2002 um 12:42 Uhr von volkard editiert. ]