Lösung : Prozessorspeed in MHZ

[devil667]

hallo, danke.....

[root2]

hi,

ich hab den code con mynonA übernommen, den funktionsaufruf in klammern gesetzt und bei mir kommt folgende fehlermeldung wenn ich das ganze in ein C++ konsoleprogramm packe (mit Borland C++ Builder 5 Enterprise)

[B][C++ Error] Unit1.cpp(13): E2276 ( expected.

das ist an der stelle nach dem __asm, wo die { klammer steht.

__asm
        {                 // <- da will der eine ( klammer haben
        rdtsc
        mov value1, eax
        mov value2, edx
        }
    Sleep(1000);
    __asm
        {                // <- hier auch...
        rdtsc
        mov value3, eax
        mov value4, edx
        }

wenn ich da eine normale klammer hinmache bekomme ich aber immer 0 MHz geliefert...

btw: wann benutze ich asm, _asm bzw. __asm und wo liegen da die unterschiede?

danke euch!

bernd

[devil667]

hi, hast den aufruf der funktion mit klammern gemacht ? im main programm? siehe posting weiter oben!!

gruss

[root2]

Original erstellt von <root2>:
...hab den code con mynonA übernommen, den funktionsaufruf in klammern gesetzt und bei mir kommt folgende fehlermeldung wenn ich das ganze in ein C++ konsoleprogramm packe...

ja, habe ich

trotzdem 0 MHz.

includiert habe ich folgende header:
<stdlib.h>
<stdio.h>
<conio.h>
<iostream.h>
<windows.h>

btw: die variable value3 wird bei mir nie benutzt, deswegen bekomm ich auch für die ein warning. etliche warnings wegen nicht ANSI schlüsselwörtern bekomme ich auch aus: tchar.h , new.h , ostream.h und istream.h ... alles etwas seltsam...

[ Dieser Beitrag wurde am 11.09.2002 um 15:32 Uhr von root2 editiert. ]

[mastercpp]

1334 MHz
1332 MHz
1333 MHz

- sehr genau -

Hab AMD Athlon 1,33 GHz.

[TriPhoenix]

Original erstellt von <root2>:
**
[B][C++ Error] Unit1.cpp(13): E2276 ( expected.
**

Kann es sien dass der Borland-Compiler ne andere inline-asm-Syntax hat?

[root2]

*---

Original erstellt von TriPhoenix:
Kann es sien dass der Borland-Compiler ne andere inline-asm-Syntax hat?

---*

hier mal ein auszug aus der hilfe datei von meinem builder:

Category

C++Builder keyword extensions, C++-Specific Keywords

Syntax

asm <opcode> <operands> <; or newline>

_asm <opcode> <operands> <; or newline>

__asm <opcode> <operands> <; or newline>

Description

Use the asm, _asm, or __asm keyword to place assembly language statements in the middle of your C or C++ source code. Any C++ symbols are replaced by the appropriate assembly language equivalents.

You can group assembly language statements by beginning the block of statements with the asm keyword, then surrounding the statements with braces ({}).

---

Examples

// This example places a single assembler statement in your code:

asm pop dx

// If you want to include several of asm statements,
// surround them with braces:
asm {
  mov ax, 0x0e07
  xor bx, bx
  int 0x10         // makes the system beep

}

so wie ich das lese scheint es die 'übliche' syntax für inline assembler zu sein, oder?
das beispiel das hier angeführt ist klappt übrigneds auch nicht. zumindest beept da nix (mit win98).
und um nochmal auf meine frage von vorhin zurückzukommen: warum gibt es 3 unterschiedliche varianten asm einzubauen? darüber schweigt sich die builder hilfe auch aus...

und zu guter letzt verstehe ich die ganzen warnings auch nicht so ganz...
kanns sein das meine settings durcheinandergeraten sind?
bernd

[ Dieser Beitrag wurde am 11.09.2002 um 18:10 Uhr von root2 editiert. ]

[Christoph]

IMHO kann der Borland Compiler inline assembler nur dann assemblieren, wenn der TASM 5 auf dem rechner vorhanden ist...
Ob es beim builder genauso ist weiß ich nicht.

[root2]

Original erstellt von cd9000:
IMHO kann der Borland Compiler inline assembler nur dann assemblieren, wenn der TASM 5 auf dem rechner vorhanden ist...
Ob es beim builder genauso ist weiß ich nicht.

bei meinem builder ist TASM 5.3 mit dabei... also sollte es eigentlich kein problem geben... tut es aber

[Mr. N]

[KILLED]

[ Dieser Beitrag wurde am 13.09.2002 um 21:57 Uhr von Mr. n editiert. ]

[rüdiger]

Ich hab mal versucht den Code nach C, POSIX.1 und gcc-asm-syntax zu portieren, aber ich erhalte immer die unterschiedlichsten Werte

#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)::);
  sleep(1); //POSIX 1 function
  __asm__ __volatile__("rdtsc":"=a"(value3),"=d"(value3)::);
  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;
}

seht ihr einen Fehler?

[ Dieser Beitrag wurde am 18.09.2002 um 20:31 Uhr von kingruedi editiert. ]

[Mr. CVTPI2PS]

Ich hab mir mal erlaubt das ganze in MASM-ASM zu übersetzen:

.586
.model flat, stdcall
option casemap:none
include C:\masm32\include\windows.inc
include C:\masm32\include\kernel32.inc
include C:\masm32\include\user32.inc
includelib kernel32.lib
includelib user32.lib

.data
value1 dd 0
value2 dd 0
value3 dd 0
value4 dd 0
MsgCaption db "CPU",0
MsgBoxText db "    "
MHZ db " MHz",0

.code

INTTOSTR MACRO INTEGER, STRING
    mov eax, INTEGER
    xor ecx,ecx
    mov ebx,000Ah
    @@DecConvert:
    xor edx,edx
    div ebx 
    add edx,0030h
    push edx
    inc ecx
    or eax,eax
    jnz short @@DecConvert
    mov edi,offset STRING
    @@SortDec:
    pop eax
    stosb 
    loop @@SortDec
ENDM

start:
    rdtsc   
    mov value1, eax
    mov value2, edx
    invoke Sleep, 1000
    rdtsc   
    mov value3, eax
    mov value4, edx

    mov eax,dword ptr [value3]
    sub eax,dword ptr [value1]
    mov dword ptr [value1],eax
    mov edx,dword ptr [value4]
    sub edx,dword ptr [value2]
    mov dword ptr [value2],edx
    imul eax,dword ptr [value2],34
    add eax,dword ptr [value1]
    mov ecx,1000
    cdq
    idiv ecx
    mov ecx,1000
    cdq
    idiv ecx

    INTTOSTR eax, MsgBoxText

    invoke MessageBox, NULL, addr MsgBoxText, addr MsgCaption, MB_OK
    invoke ExitProcess, NULL
end start

[root2]

hab noch ne kleine erweiterung dazugestellt:
es wird jetzt auch die speicherauslastung angezeigt (zumindest bei mir )

#include <iostream>
#include <windows.h>
#include <conio.h>
using namespace std;

#define DIV 1024
#define WIDTH 7

int GetMHz(void);
void GetMemoryStatus(void);

char *divisor = "K";

#pragma argsused
int main(int argc, char* argv[])
{

  while(!kbhit())
  {
    gotoxy(1,1);
    printf("CPU-Speed: %i MHz\n\n", GetMHz());
    GetMemoryStatus();
  }

  return 0;
}
//---------------------------------------------------------------------------

int GetMHz(void)
{
  unsigned long v1, v2, v3, v4;
  double MHz;

  _asm{
        rdtsc
        mov [v1], eax
        mov [v2], edx
      }

  Sleep(500);

    _asm{
        rdtsc
        mov [v3], eax
        mov [v4], edx
      }

  v1=v3-v1;
  v2=v4-v2;
  MHz=(v1+(v2*(2^32)))/1000/500;

  return (int)MHz;
}

void GetMemoryStatus(void)
{
  MEMORYSTATUS stat;

  GlobalMemoryStatus (&stat);

  printf ("%7ld percent of memory in use.\n",
          stat.dwMemoryLoad);

  printf ("%*ld %sbytes total physical memory.\n",
          WIDTH, stat.dwTotalPhys/DIV, divisor);

  printf ("%*ld %sbytes free physical memory.\n",
          WIDTH, stat.dwAvailPhys/DIV, divisor);

  printf ("%*ld %sbytes total paging file.\n",
          WIDTH, stat.dwTotalPageFile/DIV, divisor);

  printf ("%*ld %sbytes free paging file.\n",
          WIDTH, stat.dwAvailPageFile/DIV, divisor);

  printf ("%*ld %sbytes total virtual memory.\n",
          WIDTH, stat.dwTotalVirtual/DIV, divisor);

  printf ("%*ld %sbytes free virtual memory.\n",
          WIDTH, stat.dwAvailVirtual/DIV, divisor);
}

[Netspider]

hm, das erste funktioniert bei mir gut, aber mit dem neuen bekomme ich 1 error 1 warning

erstmal weiß der mit pragma nicht viel anzufangen,
und das andere sag ich, wenn ichs wieder weiß
1536mhz

[entelechie]

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 error

ich krieg einen parse error vor dem ::.
was mach ich falsch?

[rüdiger]

hast du vielleicht den Parameter aktiviert, dass der GCC keine eigenen Erweiterungen akzeptiert?

Welche Version hast du?

[entelechie]

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 function getmhz': 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. ]

[TheBigW]

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

[Lars]

#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;
}

[TriPhoenix]

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