Level 2 Cache

[HomerGER]

Hallo
kann mir jemand ein ansatz geben wie ich den Level 2 Cache auslesen kann ?

[Ghostwalker]

Ich glaube nicht das du unter Windows da drann kommst. Schon allein aus dem Grund, weil es (Gerüchte besagen das :mrgreen: :mrgreen: ) Prozessoren geben soll die sowas garnicht haben und darauf auch Windows läuft (zumindest ältere Versionen davon) :)

Die einzige Möglichkeit, die ich mir vorstellen könnte, wäre über Assembler.

[HomerGER]

aber einige haben l2 und die will ich auslesen


ps gibt es nicht gibt es nicht :mrgreen:

[Robert_G]

Zitat:

ps gibt es nicht gibt es nicht :mrgrenn:

Wie soll ich denn das verstehen :?:

Übrigens wäre es IMHO komplett sinnbefreit (ich liebe dieses Wort :mrgreen: ) den L2 auszulesen. Wenn du den Wert hast, hat er sich auch schon wieder geändert. Der Aufruf deiner Funktion könnte den Inhalt natürlich auch verändern (schönen Gruß an Heisenberg ;) ).
Ich als DB'ler kann bei solchen Themen zwar nicht mitreden, aber ich bezweifle, dass es möglich wäre.
Ich bezweifle aber nicht, dass es sinnlos wäre.

[HomerGER]

in denke in der software ist alles möglich

der Level 2 ändert sich ständig ?

also mein amd hat ne level 2 cache von 512 kb
ich glaube die neuen intel 1024 kb

und das möchte ich auslesen

[Robert_G]

:wall: Ach du meinst die Größe!

[tommie-lie]

Zitat:

Zitat von HomerGER

der Level 2 ändert sich ständig ?

Kommt drauf an, wie man "ständig" definiert.
Für den Prozessor ist der L2-Cache schnarchlahm und bleibt verhältnismäßig lange, wie er ist.
Für den Menschen dürften sich aber weitläufige Areale des Caches in einer Sekunde mehrere hundert Mal ändern.
Und shcon allein wenn du deine Funktion zum auslesen aufrufen würdest, würde sich der Cache ändern, du kriegst also nie das gewünschte Ergebnis (Heisenberg ist hier genau der richtige Vergleich).

Außerdem wird der Cache von der Prozessor-Logik verwaltet. Vielleicht haben einige Architekturen einen Opcode zum kompletten resetten, aber weiter wird man kaum an den Cache rankommen, wenn man nicht selbst der Prozessor ist. Und wenn weitere Manipulationen möglich sind, sind sie es mit an Sicherheit grenzender Wahrscheinlichkeit nicht unter Windows, und mit noch größerer Wahrscheinlcihkeit nicht unter NT.

[HomerGER]

selbst die Grösse ist nicht zu ermitteln ?
wenn ich micht nicht täusche liest aber win XP den doch aus und trägt ihn in die registry ein (oder fast immer)

[tommie-lie]

Ach so, die Größe...
Ich dachte du willst den Cache selber auslesen, also die gesamten 512kB deines Prozessors. Das Auslesen der Größe dürfte mit einer Unterfunktion der CPUID funktionieren.
Hilfreich ist vielleicht das hier: http://prioris.mini.pw.edu.pl/~micha...Chapter4a.html
Ein Codeschnipsel der zuverlässig mit Durons und Athlons funktionieren sollte (da er von AMD stammt) ist hier zu finden: http://prioris.mini.pw.edu.pl/~micha...AppendixC.html

Ansonsten ist Google dein Freund und Helfer ;-)


Und wenn du's nur wissen willst und nicht selber auslesen, ist vielleicht dieses kleine Programm (geschrieben in Delphi) das Richtige: http://www.overclockers.com/tips166/cpuid.zip

[HomerGER]

Zitat:

Ansonsten ist Google dein Freund und Helfer

leider nicht oder nur falsch gesucht

aber jetzt hab ich was mit den ich arbeiten kann

thx euch allen


ps
also ich möchte ihn schon selber auslesen
hast du auch denn source ? :angle2: :angle2: :angle2: :angle2: :angle2:

[tommie-lie]

Zitat:

Zitat von HomerGER

hast du auch denn source ?

Da das Programm nicht von mir ist und zusammen mit dem Link, den ich gefunden habe, kein weiterer für die Quellcodes angegeben war, leider nicht.
Aber du könntest vielleicht mal dem Autor 'ne freundliche Mail schicken (siehe About-Fenster), entweder gibt er die die Quellcodes oder er sagt dir, wo er genaue Informationen her hatte.

[Muetze1]

Moin!

Ich habe dir mal eine kleine Unit zusammen gestrickt, die gibt dir die Info als String zurück. Bisher wird nur Intel und AMD unterstützt, da ich die Doku zum Cyrix nicht gefunden habe und für Transmeta/VIA, etc fehlen mir diese noch...

Delphi-Quellcode:

Unit L2Cache;

Interface

  Function GetL2CacheSize : String;

Implementation

uses
  sysutils;

Function CheckForCPUID : Boolean; Assembler;
Asm
  push  ebx
  push  ecx
  pushfd               // save EFLAGS
  pop   eax            // store EFLAGS in EAX
  mov   ebx, eax       // save in EBX for later testing
  xor   eax, 00200000h // toggle bit 21
  push  eax            // put to stack
  popfd                // save changed EAX to ELFAGS
  pushfd               // push EFLAGS on stack
  pop   ecx            // store EFLAGS in EAX
  mov   Result, False
  cmp   ecx, ebx       // see if bit 21 has changed
  jz    @@no_CPUID     // if no change, no CPUID
  mov   Result, True   // set flag
@@no_CPUID:
  pop   ecx
  pop   ebx
End;

Function GetL2CacheSize : String;
Var
  CPUID_VendorID : Array[0..11] Of Char;
  MaxStdLevel,
  MaxExtLevel    : LongWord;

  Function GetIntelCacheInfo : String;
  Var
    CallCtr : Byte;
    Regs    : array[0..3] Of LongWord;
    i       : Integer;
    KBSize  : Word;

    Function CacheInfo(CacheID : Byte): Word;
    Begin
      Case CacheID Of
        $39, $3B,
        $41, $79 : Result := 128;

        $3C, $42,
        $7A, $82 : Result := 256;

        $43, $7B,
        $83, $86 : Result := 512;

        $44, $7C,
        $84, $87 : Result := 1024;

        $85, $45 : Result := 2048;
      Else
        Result := 0;
      End;
    End;

  Begin
    Asm
      push eax
      push ebx
      push ecx
      push edx

      mov  eax, 2
      db 00fh, 0a2h

      mov  CallCtr, al
      mov  Regs[0].longword, eax
      mov  Regs[1].longword, ebx
      mov  Regs[2].longword, ecx
      mov  Regs[3].longword, edx

      pop  edx
      pop  ecx
      pop  ebx
      pop  eax
    End;

    // CallCtr lass ich mal aussen vor, wird bisher noch nicht benutzt von Intel (also noch nicht > 1)

    KBSize := 0;
    If ( Regs[0] And $80000000 ) = 0 Then
    Begin
      If ( ( Regs[0] Shr 8 ) And $ff ) > 0 Then
        Inc(KBSize, CacheInfo(( Regs[0] Shr 8 ) And $ff));
      If ( ( Regs[0] Shr 16 ) And $ff ) > 0 Then
        Inc(KBSize, CacheInfo(( Regs[0] Shr 16 ) And $ff));
      If ( ( Regs[0] Shr 24 ) And $ff ) > 0 Then
        Inc(KBSize, CacheInfo(( Regs[0] Shr 24 ) And $ff));
    End;
    For i := 1 To 3 Do
    Begin
      If ( Regs[i] And $80000000 ) = 0 Then
      Begin
        If ( ( Regs[i] Shr 8 ) And $ff ) > 0 Then
          Inc(KBSize, CacheInfo(( Regs[i] Shr 8 ) And $ff));
        If ( ( Regs[i] Shr 16 ) And $ff ) > 0 Then
          Inc(KBSize, CacheInfo(( Regs[i] Shr 16 ) And $ff));
        If ( ( Regs[i] Shr 24 ) And $ff ) > 0 Then
          Inc(KBSize, CacheInfo(( Regs[i] Shr 24 ) And $ff));
      End;
    End;

    If ( KBSize > 1000 ) Then
      Result := IntToStr(KBSize) + ' KB'
    Else
      Result := IntToStr(KBSize Div 1024) + ' MB';
  End;

  Function GetAMDCacheInfo : String;
  Var
    KBSize : Word;
  Begin
    Asm
      push eax
      push ebx
      push ecx
      push edx

      mov  eax, 080000006h
      db 00fh, 0a2h

      shr  ecx, 16
      mov  KBSize, cx

      pop  edx
      pop  ecx
      pop  ebx
      pop  eax
    End;

    If ( KBSize > 1000 ) Then
      Result := IntToStr(KBSize) + ' KB'
    Else
      Result := IntToStr(KBSize Div 1024) + ' MB';
  End;

Begin
  If ( CheckForCPUID ) Then
  Begin
      // Get Vendor
    Asm
      push eax
      push ebx
      push ecx
      push edx

      xor  eax, eax
      db   00fh, 0a2h  // CPUID

      mov  MaxStdLevel, eax

      push edi
      lea  edi, CPUID_VendorID
      cld      // bx, dx, cx
      mov  eax, ebx
      stosd
      mov  eax, edx
      stosd
      mov  eax, ecx
      stosd
      pop  edi

      mov  eax, 080000000h
      db   00fh, 0a2h  // CPUID
      mov  MaxExtLevel, eax

      pop  edx
      pop  ecx
      pop  ebx
      pop  eax
    End;

    If ( String(CPUID_VendorID) = 'GenuineIntel' ) Then
    Begin
      If ( MaxStdLevel >= 2 ) Then
        Result := GetIntelCacheInfo
      Else
        Result := 'unkown';
    End
    Else If ( String(CPUID_VendorID) = 'AuthenticAMD' ) Then
    Begin
      If ( MaxExtLevel >= $80000006 ) Then   // ab K6-III
        Result := GetAMDCacheInfo
      Else
        Result := 'unkown';
    End
    Else If ( String(CPUID_VendorID) = 'CyrixInstead' ) Then
    Begin
        // habe die M2 doku nicht mehr gefunden und zum C2/C3 habe ich noch keine...
      Result := 'no cache info';
    End;

    // Transmeta und weitere erstmal wegfallen lassen...
  End
  Else
    Result := 'no CPUID support';
End;

End.

MfG
Muetze1

[HomerGER]

wow :thuimb:

[dizzy]

:shock: alter Falter...

[Muetze1]

Moin!

Eine Rückmeldung wäre nicht schlecht - ich habe nur ein Intel P4 hier - falls noch wer diesen Code mal ausprobiert und schreibt ob's klappt - ein AMD'ler wäre gar nicht mal so schlecht, meine AMD Systeme habe ich alle verscherbelt...

Die Unit ist nur mal so schnell hingeschrieben - z.T. aus meinem CPUID Projekt, daher wären die Rückmeldungen recht witzig zu wissen...

MfG
Muetze1

[phlux]

Athlon XP 2000+ oder so 0MB l2 Cache, ka ob das dingen überhaupt l2cache hat oder nicht ;)

[Muetze1]

Moin!

Hmm, sehr komisch. Ich habe nochmal mit der Doku verglichen und den Code durchgeschaut, aber eigentlich sollte alles ok sein. Vor allem wundert es mich, das er MB ausgibt, da dein Athlon entweder 256KB oder 512KB haben kann und daher gar nicht auf MB kommen sollte. Sei mal bitte so nett und nimm mal die IF Anweisung ab Zeile 142 raus und lass es dir mal fest in KB zurückgeben...

Wenn das dann auch nix hilft, dann muss ich mir im nächsten Monat nochmal schnell einen XP zusammen bauen...

Danke schonmal für die Rückmeldung.

MfG
Muetze1

[phlux]

256 KB ;) musst wohl das if statement überarbeiten, würds gerne selbst machen aber rachmaninoff ist hier ;)

:hi: phlux

[Muetze1]

Moin!

:wall: Mensch, manchmal wird man auch betriebsblind... Die If Bedingung ist einfach falsch herum gestellt (Wenn mehr als 1000 KB, dann zeige in KB an, ansonsten in MB)...

Ok, ich ändere den Code mal schnell...

@other: Falls ihr den Code schon genutzt habt, If Bedingung 2x ändern (ja ja Copy&Paste) oder nochmals neu kopieren und einfügen...

/EDIT: Ok, ändern geht nicht mehr in diesem Forum und dafür den Mod belästigen muss nicht sein, daher jetzt der funktionierende Code...

Delphi-Quellcode:

Unit L2Cache;

Interface

  Function GetL2CacheSize : String;

Implementation

uses
  sysutils;

  // prüfen, ob die CPU die CPUID Instruktion unterstützt
  //
  // Anmerkung: Bei Cyrix M2 CPU's muss man die Instruktion vorher in einem
  //            Cyrix spezifischen Register enablen, sonst ist sie unbekannt
  //            und die EFlags verhalten sich dem entsprechend. In diesem Falle
  //            ist das aber hinfällig, da Cyrix CPU's keine Cache Informationen
  //            über CPUID zurückliefern sondern nur über ihre Configuration
  //            Register auf Port $FE und $FF...
Function CheckForCPUID : Boolean; Assembler;
Asm
  push  ebx
  push  ecx
  pushfd               // save EFLAGS
  pop   eax            // store EFLAGS in EAX
  mov   ebx, eax       // save in EBX for later testing
  xor   eax, 00200000h // toggle bit 21
  push  eax            // put to stack
  popfd                // save changed EAX to ELFAGS
  pushfd               // push EFLAGS on stack
  pop   ecx            // store EFLAGS in EAX
  mov   Result, False
  cmp   ecx, ebx       // see if bit 21 has changed
  jz    @@no_CPUID     // if no change, no CPUID
  mov   Result, True   // set flag
@@no_CPUID:
  pop   ecx
  pop   ebx
End;

Function GetL2CacheSize : String;
Var
  CPUID_VendorID : Array[0..11] Of Char;  // für den Vendor-String
  MaxStdLevel,                            // höchstes CPUID Standardlevel
  MaxExtLevel    : LongWord;              // höchstes CPUID erweitertes Level

    // Unterfunktion für Intel CPU's
  Function GetIntelCacheInfo : String;
  Var
    CallCtr : Byte;                      // gibt an, wie oft CPUID 02h aufgerufen
                                         // werden muss, um alle Cache Info's zu
                                         // bekommen
    Regs    : array[0..3] Of LongWord;   // Speicher für die Register nach CPUID 02h
    i       : Integer;                   // Zählvariable
    KBSize  : Word;                      // die Grösse des L2 Caches in KByte

      // die Intel CPU's geben in mehreren Byte Werten ihre Info's an, und
      // es kann mehrere ID's für den selben Cache Typ geben, daher hier anhand
      // der ID die Grösse zurückgeben oder 0, wenn es kein L2 Cache Deskriptor war
    Function CacheInfo(CacheID : Byte): Word;
    Begin
      Case CacheID Of
        $39, $3B,
        $41, $79 : Result := 128;

        $3C, $42,
        $7A, $82 : Result := 256;

        $43, $7B,
        $83, $86 : Result := 512;

        $44, $7C,
        $84, $87 : Result := 1024;

        $85, $45 : Result := 2048;
      Else
        Result := 0;
      End;
    End;

    // ok, ans eingemachte für die Intel Cache Info's
  Begin
    Asm
      push eax  // register sichern - alle - auch wenn in der Delphi Hilfe
      push ebx  // steht, das man einzelne Register frei verändern darf.
      push ecx  // Diese Aussage trifft nur bei nicht optimierte Codes zu, wenn
      push edx  // die Optimierung an ist (default), dann fällt Delphi dadurch
                // gerne auf die Schnauze...

      mov  eax, 2   // Funktion laden (hier: 0000.0002h)
      db 00fh, 0a2h // CPUID

      mov  CallCtr, al            // CallCtr merken
      mov  Regs[0].longword, eax  // Register sichern zum auswerten
      mov  Regs[1].longword, ebx
      mov  Regs[2].longword, ecx
      mov  Regs[3].longword, edx

      pop  edx  // Register wiederherstellen, damit Delphi keine Problem bekommt
      pop  ecx
      pop  ebx
      pop  eax
    End;

    // CallCtr lass ich mal aussen vor, wird bisher noch nicht benutzt von Intel
    // (also noch nicht > 1)

    // ok, dann zählen wir mal die KBytes zusammen der einzelnen Deskriptoren
    KBSize := 0;
    If ( Regs[0] And $80000000 ) = 0 Then  // prüfen ob gültige Angabe
    Begin
      If ( ( Regs[0] Shr 8 ) And $ff ) > 0 Then // wenn was drinne steht ...
        Inc(KBSize, CacheInfo(( Regs[0] Shr 8 ) And $ff)); // ... dann auswerten
      If ( ( Regs[0] Shr 16 ) And $ff ) > 0 Then
        Inc(KBSize, CacheInfo(( Regs[0] Shr 16 ) And $ff));
      If ( ( Regs[0] Shr 24 ) And $ff ) > 0 Then
        Inc(KBSize, CacheInfo(( Regs[0] Shr 24 ) And $ff));
    End;

    // da in EAX der CallCtr mit drinne steht, wird das hier drüber extra behandelt
    // und die restlichen können wir in einem Rutsch durchgehen
    For i := 1 To 3 Do
    Begin
      If ( Regs[i] And $80000000 ) = 0 Then
      Begin
        If ( ( Regs[i] Shr 8 ) And $ff ) > 0 Then
          Inc(KBSize, CacheInfo(( Regs[i] Shr 8 ) And $ff));
        If ( ( Regs[i] Shr 16 ) And $ff ) > 0 Then
          Inc(KBSize, CacheInfo(( Regs[i] Shr 16 ) And $ff));
        If ( ( Regs[i] Shr 24 ) And $ff ) > 0 Then
          Inc(KBSize, CacheInfo(( Regs[i] Shr 24 ) And $ff));
      End;
    End;

    // Ausgabe bilden
    If ( KBSize < 1024 ) Then               // noch im KByte Bereich?
      Result := IntToStr(KBSize) + ' KB'    // ok, dann KByte
    Else
      Result := IntToStr(KBSize Div 1024) + ' MB'; // nein, also MByte
  End;

  // ok, gleiches für AMD
  Function GetAMDCacheInfo : String;
  Var
    KBSize : Word;
  Begin
    // AMD macht es uns einfacher, die haben direkt eine Angabe des L1 und L2
    // Cache-Grösse in KByte als Rückgabewert

    Asm
      push eax  // siehe oben
      push ebx
      push ecx
      push edx

      mov  eax, 080000006h  // Funktionsnummer laden (hier: 8000.0006h)
      db 00fh, 0a2h         // CPUID

      shr  ecx, 16          // in Bits 16..31 steht die Grösse in KByte
      mov  KBSize, cx       // daher: runterschieben und die 16 Bits merken

      pop  edx
      pop  ecx
      pop  ebx
      pop  eax
    End;

    // Ausgabe bilden - same procedure as every cpu... ;-)
    If ( KBSize < 1024 ) Then
      Result := IntToStr(KBSize) + ' KB'
    Else
      Result := IntToStr(KBSize Div 1024) + ' MB';
  End;

Begin
  // ok, hier gehts los

  If ( CheckForCPUID ) Then  // haben wir überhaupt eine Chance, oder anders:
  Begin                      // bietet die CPU einen CPUID Befehl?
    Asm
      push eax   // wieder Register sichern...
      push ebx
      push ecx
      push edx

      // xor eax, eax setzt eax auf 0 - laut AMD Optimizing Doc ist mov eax, 0
      // schneller beim AMD. Laut Intel ist xor eax, eax schneller bei Intel...

      xor  eax, eax    // Funktionsnummer laden (hier: 0000.0000h)
      db   00fh, 0a2h  // CPUID

      // in EAX steht das höchste Standard CPUID Level -> merken
      mov  MaxStdLevel, eax

      // wir wollen den Vendor String speichern - und das geht am einfachsten
      // mit den String Befehlen der CPU...
      push edi                  // enhanced destination index = Zieladresse
                                // vorher aber erstmal sichern...
      lea  edi, CPUID_VendorID  // dann die Adresse der Variablen holen
      cld                       // direction flag löschen, wir wollen EDI erhöhen...
      mov  eax, ebx             // als erstes muss der Inhalt von EBX gespeichert
                                // werden, und da SToreStringDword immer EAX
                                // schreibt, muss EBX in EAX gepackt werden...
      stosd                     // ok, schreiben
      mov  eax, edx             // gleiches mit EDX
      stosd                     // und hinten ranhängen
                                // (EDI ist jetzt schon auf CPUID_VendorID[4])
      mov  eax, ecx             // gleiches mit ECX
      stosd
      pop  edi                  // ok, Inhalt von EDI wiederherstellen

      // auf erweiterten CPUID testen
      mov  eax, 080000000h      // Funktionsnummer laden (hier: 8000.0000h)
      db   00fh, 0a2h           // CPUID
      mov  MaxExtLevel, eax     // maximale Funktionsnummer sichern...

      pop  edx                  // Register wiederherstellen
      pop  ecx
      pop  ebx
      pop  eax
    End;

    // nun gehts an die Auswertung und da kocht jeder Hersteller sein eigenes
    // Süppchen...
    If ( String(CPUID_VendorID) = 'GenuineIntel' ) Then // Intel
    Begin
      If ( MaxStdLevel >= 2 ) Then  // wir brauchen min. CPUID 0000.0002h
        Result := GetIntelCacheInfo
      Else
        Result := 'unkown';
    End
    Else If ( String(CPUID_VendorID) = 'AuthenticAMD' ) Then // AMD
    Begin
      // wir brauchen min. CPUID 8000.0006h
      If ( MaxExtLevel >= $80000006 ) Then   // ab K6-III
        Result := GetAMDCacheInfo
      Else
        Result := 'unkown';
    End
    Else If ( String(CPUID_VendorID) = 'CyrixInstead' ) Then
    Begin
      // tja, die Cyrix'e - keine Cache Info im CPUID, alles per Cyrix
      // specific Register...
      Result := 'no cache info';
    End;

    // Transmeta und weitere erstmal wegfallen lassen...
  End
  Else
    Result := 'no CPUID support';
End;

End.

Ich habe den Code gleich mal ein wenig kommentiert, damit kommt vielleicht ein wenig Klarheit auf über das was ich da überhaupt mache...

MfG
Muetze1

[alcaeus]

Zitat:

Zitat von Muetze1

Delphi-Quellcode:

 If ( KBSize < 1000 ) Then 
      Result := IntToStr(KBSize) + ' KB' 
    Else 
      Result := IntToStr(KBSize Div 1024) + ' MB';

Ich will ja nicht deinen schönen Code ruinieren, aber eines gibt es noch zu sagen. Wenn du die Größe in MB angibst, so solltest du überprüfen, ob die Größe auch größer als 1024 KB ist, und nicht 1000. Hier beim L2 macht das nicht viel Unterschied, da sowieso schöne 2erpotenzen herhalten, aber trotzdem...der Code wäre perfekt wenn du das noch ausbessern würdest.

[Muetze1]

Moin!

Mir ging es nur um die Anzahl der Stellen daher die 1000, aber es wirklich völlig egal, da keine Werte zwischen 1000 und 1024 auftreten werden. Aber egal, ich habe es geändert...

MfG
Muetze1

[Razor]

Delphi-Quellcode:

 Function CacheInfo(CacheID : Byte): Word; 
    Begin
      Case CacheID Of
        $39, $3B,
        $41, $79 : Result := 128;

        $3C, $42,
        $7A, $82 : Result := 256;

        $43, $7B,
        $83, $86 : Result := 512;

        $44, $7C,
        $84, $87 : Result := 1024;

        $85, $45 : Result := 2048;

        $49: Result:=4096;
      Else
        Result := 0;
      End;
    End;

now it will detect even my cpu's cache :zwinker:

[Muetze1]

Zitat:

Zitat von Razor

now it will detect even my cpu's cache :zwinker:

Nice, but who has your CPU? Why do you not do the whole job? Egoist... :wall:

Here the complete updated sub statement:

Delphi-Quellcode:

 Function CacheInfo(CacheID : Byte): Word; 
    Begin
      Case CacheID Of
        $39, $3B,
        $41, $79 : Result := 128;

        $3A      : result := 192;

        $3C, $42,
        $7A, $82 : Result := 256;

        $3d      : result := 384;

        $3E, $43, 
        $7B, $7f,
        $83, $86 : Result := 512;

        $44, $78,
        $7C,
        $84, $87 : Result := 1024;

        $85, $45,
        $7d      : Result := 2048;

        $49      : Result := 4096;

        $4e      : result := 6144;
      Else
        Result := 0;
      End;
    End;

[Razor]

Sorry Muetze :| but i was only testing for my cpu,forgot to update it although i have lots of info about cache.My cpu is Intel Core 2 Q6600.

Do you have something similar for Level3 or 1?

[Muetze1]

Zitat:

Zitat von Razor

Do you have something similar for Level3 or 1?

Zitat:

Zitat von Razor

although i have lots of info about cache.

I know you got the documentation from intel, so do it. It is similar to the existing code...

[Razor]

If i have time ill do it.No promise.

[DevidEspenschied]

We here in germany say: "Wer lesen kann, ist klar im Vorteil".

Simply have a look at Intels document #241618 (here). Table 3-7 on page 29 displays all Intel cache descriptors.

[Weazy]

Wie wärs mit WMI? Wenn du den L2 Cache willst (Data und Instruction Memory) brauchst du viellecht eh noch mehr system informationen wie z.B L2 Cache Geschindigkeit, L1 Cache, CPU allgmein,... Mit WMI kann man schon ein recht umfangreiches System informationstool bauen :-D

[DevidEspenschied]

Because this thread is written in english language, I'll answer in english too:

WMI would be another way, but via the CPUID instruction you have the direct access to the CPU. WMI gets some details from Windows, but that in a more general way. One advantage of the CPUID instruction is that you have special functions e.g. for the Intel Core2 processors or AMD Phenom processors, which aren't detectable in detail via WMI.

WMI and the CPUID instructrion are both very good documented. There is no disadvantage here.

To create a general information tool, WMI could be the first choice. But for a specific tool (and I believe he does develop such one) you need to access the CPU directly. Or do you believe that programs like CPU-Z, HWInfo32 or Everest detect their CPU data based upon WMI ? I don't think so.

[Muetze1]

Zitat:

Zitat von Weazy

Wie wärs mit WMI? Wenn du den L2 Cache willst (Data und Instruction Memory) brauchst du viellecht eh noch mehr system informationen wie z.B L2 Cache Geschindigkeit, L1 Cache, CPU allgmein,... Mit WMI kann man schon ein recht umfangreiches System informationstool bauen :-D

1. L2 Cache hat keine Instruction/Data Aufteilung. Dies hat nur der L1 Cache
2. Wozu ein vorhandenes System komplett umstellen, vor allem da alle CPUs entsprechend diese Informationen im Ring 3 liefern?
3. Mich kotzen diese allgemeinen Threads an, wo mit dem Schlagwort WMI alle Antworten erschlagen werden. Das WMI System ist nicht wirklich aussagekräftig bzw. genau, da dort viele Informationen aus anderen Quellen gesammelt sind, welche von manchen Herstellern mehr und vielerorts auch minder nur mit Daten befüttert werden.

Meine persönliche Meinung: Geht mir weg mit dem WMI Mist. Entweder ich begebe mich in die Abhängigkeit der Gutwilligkeit der Hersteller oder anderer Leute oder ich ermittle mir die Daten selbst - und genau das ist hier nicht das Problem.

Ich kann eine Tür aufschliessen mit einem Schlüssel - genausogut kann ich die Scheibe der Tür mit einem Stein einwerfen oder die Tür auftreten - zur Not anzünden - rein kommen tue ich auch ohne Schlüssel - klar. Also ich bevorzuge den Schlüssel (CPUID) und ihr könnt von mir aus kokeln, treten und werfen mit dem WMI.

[Razor]

This is why its soo hard making it compatible for every every cpu otherwise i would have done it already..crap.. :)