Lösung : Prozessorspeed in MHZ

PhilippSt

hehe, und ich hab einfach den Code ohne zu überlegen von mynonA übernommen! Aber jetzt stimmt die Ausgabe, nach der Codeveränderung: 1513 MHz

hi,bei mir gehts garnicht? wie habt ihr das gestartet?

gruss

ahhhh...jetzt gehts hatte asm vergessen...wie dumm!! kann jemand den code erklären, oder wär das zu lang??

DANKE im voraus

TriPhoenix

DWORD value1    = 0;  // variablen init
    DWORD value2    = 0;
    DWORD value3    = 0;
    DWORD value4    = 0;
    __asm
        {
        rdtsc             // time stamp counter lesen, s.u.
        mov value1, eax   // und ergebnis in value2:value1 speichern
        mov value2, edx
        }
    Sleep(1000);          // 1 (vom OS definierte ;) Sekunde warten
    __asm
        {
        rdtsc             // time stamp counter lesen, s.u.
        mov value3, eax   // und ergebnis in value2:value1 speichern
        mov value4, edx
        }
    value1          = value3 - value1;  // differenzen berechnen
    value2          = value4 - value2;
    double MHZ      = (value1+(value2*(2^32)))/1000/1000;     // value2:value1 als Wert nehmen und durch 1M teilen
    return (DWORD)MHZ;

RDTSC liest den sogenannten time stamp counter aus, das ist eine interne Prozessorvariable die jeden Takt einfach erhöht wird. Das Programm fragt also, wieviele Takte gewesen sind, wartet dann eine Sekunde und fragt dann nochmal wieviele Takte gewesen sind. Die Differenz ist logischerweise die Zahl an Takten, die in einer Sekunde vergangen ist. Zur freundlicheren darstellung wird das ganze noch in eine MHz-Zahl gerechnet, so dass man nicht das Ergebnis in Hz ablesen muss

hi, ahhh ja. wie würde denn selbiges mit der prozessortemperatur funzen??

gruss und dank

TriPhoenix

Keine Ahnung, dazu muss man sicherlich irgendeinen port ansprechen oder eine Speicherstelle...gibt halt kein rdptm (read processor temperature meter ;))
Auf jeden Fall komplett anders als das hier

hallo, danke.....

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

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. ]

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