Prozessor-String auslesen

[Helle]

Dafür schwirrt in den verschiedenen Foren natürlich schon einiges herum, aber wer es noch nicht kennt:

Code: Alles auswählen

;- Prozessor-String mittels CPUID direkt auslesen
;- "Helle" Klaus Helbing, 24.06.2007, PB v4.02

Procedure Get_Prozessor_String(StringAdresse)
    !mov eax,80000000h       ;Test, ob CPU aktuell genug ist um den String zu liefern
    !cpuid
    !cmp eax,80000004h
    !jae @f                  ;alles o.K.
    !xor eax,eax             ;Rückgabewert = Null für eventuelle Auswertung Fehlschlag 
  ProcedureReturn
!@@:
    !mov esi,[p.v_StringAdresse]
    !xor edi,edi
!@@:    
    !mov eax,80000002h
    !add eax,edi
    !cpuid        
    !mov [esi],eax
    !mov [esi+4],ebx    
    !mov [esi+8],ecx
    !mov [esi+12],edx
    !inc edi
    !cmp edi,3
    !je @f
    !add esi,16
    !jmp @b
!@@:
    !mov eax,1               ;Rückgabewert <> Null für Erfolg
  ProcedureReturn    
EndProcedure 

ProzessorString$ = Space(48)    ;der String kann max.48 Zeichen lang sein
Get_Prozessor_String(@ProzessorString$)
MessageRequester("Prozessor-String mittels CPUID auslesen", ProzessorString$)

Gruss
Helle

[ts-soft]

Hier mal eine Unicode-taugliche Version. Der Code stammt aus irgend-
einem Forum oder CodeArchiv?
Habs nur leicht angepaßt das es auch mit Unicode funktioniert.

Code: Alles auswählen

Procedure.s GetCPUName()
  Protected sBuffer.s
  Protected Zeiger1.l, Zeiger2.l, Zeiger3.l, Zeiger4.l

  !MOV eax, $80000002
  !CPUID
  ; the CPU-Name is now stored in EAX-EBX-ECX-EDX
  !MOV [p.v_Zeiger1], EAX ; move eax to the buffer
  !MOV [p.v_Zeiger2], EBX ; move ebx to the buffer
  !MOV [p.v_Zeiger3], ECX ; move ecx to the buffer
  !MOV [p.v_Zeiger4], EDX ; move edx to the buffer

  ;Now move the content of Zeiger (4*4=16 Bytes to a string
  sBuffer = PeekS(@Zeiger1, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger2, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger3, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger4, 4, #PB_Ascii)

  ;Second Part of the Name
  !MOV eax, $80000003
  !CPUID
  ; the CPU-Name is now stored in EAX-EBX-ECX-EDX
  !MOV [p.v_Zeiger1], EAX ; move eax to the buffer
  !MOV [p.v_Zeiger2], EBX ; move ebx to the buffer
  !MOV [p.v_Zeiger3], ECX ; move ecx to the buffer
  !MOV [p.v_Zeiger4], EDX ; move edx to the buffer

  ;Now move the content of Zeiger (4*4=16 Bytes to a string
  sBuffer + PeekS(@Zeiger1, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger2, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger3, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger4, 4, #PB_Ascii)


  ;Third Part of the Name
  !MOV eax, $80000004
  !CPUID
  ; the CPU-Name is now stored in EAX-EBX-ECX-EDX
  !MOV [p.v_Zeiger1], EAX ; move eax to the buffer
  !MOV [p.v_Zeiger2], EBX ; move ebx to the buffer
  !MOV [p.v_Zeiger3], ECX ; move ecx to the buffer
  !MOV [p.v_Zeiger4], EDX ; move edx to the buffer

  ;Now move the content of Zeiger (4*4=16 Bytes to a string
  sBuffer + PeekS(@Zeiger1, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger2, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger3, 4, #PB_Ascii)
  sBuffer + PeekS(@Zeiger4, 4, #PB_Ascii)

  ProcedureReturn sBuffer
EndProcedure

Debug GetCPUName()

[Helle]

Der Preis für Unicode ist aber ganz schön hoch: Meine Prozedur ist 30-mal schneller und überprüft dabei noch die Ausführbarkeit !

Gruss
Helle

[ts-soft]

Ich kann leider kein ASM, sollte Dich eher dazu anregen zu berücksichten,
das PB4 Code Unicode können sollte

Vielleicht machste ja noch eine 30x schnellere Unicodetaugliche Version?

Gruß
Thomas

// Nachtrag: habs jetzt mit Deinem Code auch hinbekommen

Code: Alles auswählen

;- Prozessor-String mittels CPUID direkt auslesen
;- "Helle" Klaus Helbing, 24.06.2007, PB v4.02
;- Unicode-Support by ts-soft

Procedure Get_Prozessor_String(StringAdresse)
  !mov eax,80000000h       ;Test, ob CPU aktuell genug ist um den String zu liefern
  !cpuid
  !cmp eax,80000004h
  !jae @f                  ;alles o.K.
  !xor eax,eax             ;Rückgabewert = Null für eventuelle Auswertung Fehlschlag
  ProcedureReturn
  !@@:
  !mov esi,[p.v_StringAdresse]
  !xor edi,edi
  !@@:
  !mov eax,80000002h
  !add eax,edi
  !cpuid
  !mov [esi],eax
  !mov [esi+4],ebx
  !mov [esi+8],ecx
  !mov [esi+12],edx
  !inc edi
  !cmp edi,3
  !je @f
  !add esi,16
  !jmp @b
  !@@:
  !mov eax,1               ;Rückgabewert <> Null für Erfolg
  ProcedureReturn
EndProcedure

Define ProzessorString = AllocateMemory(48)
If ProzessorString
  Get_Prozessor_String(ProzessorString)
  MessageRequester("Prozessor-String mittels CPUID auslesen", PeekS(ProzessorString, -1, #PB_Ascii))
  FreeMemory(ProzessorString)
EndIf

[Helle]

Ahh, sehr schön ! Habe ich gerade erst gesehen. In der Mittagspause habe ich eben folgendes geschrieben:

Code: Alles auswählen

;- Prozessor-String mittels CPUID direkt auslesen
;- erstellt einen UNICODE-String! (Oder, was ich dafür halte)
;- Also dementsprechende Einstellung vornehmen! 
;- "Helle" Klaus Helbing, 25.06.2007, PB v4.02

Procedure Get_Prozessor_String_W(StringAdresse)
    !mov eax,80000000h       ;Test, ob CPU aktuell genug ist um den String zu liefern
    !cpuid
    !cmp eax,80000004h
    !jae @f                  ;alles o.K.
    !xor eax,eax             ;Rückgabewert = Null für eventuelle Auswertung Fehlschlag 
  ProcedureReturn
!@@:
    !mov esi,[p.v_StringAdresse]
    !xor edi,edi
    !pxor xmm7,xmm7
!@@:    
    !mov eax,80000002h
    !add eax,edi
    !cpuid        
    !movd xmm0,eax
    !punpcklbw xmm0,xmm7     ;wenn die CPU obigen Test bestanden hat, sollte auch dies funktionieren (SSE2)
    !movq [esi],xmm0    
    !movd xmm0,ebx
    !punpcklbw xmm0,xmm7
    !movq [esi+8],xmm0         
    !movd xmm0,ecx
    !punpcklbw xmm0,xmm7
    !movq [esi+16],xmm0    
    !movd xmm0,edx
    !punpcklbw xmm0,xmm7
    !movq [esi+24],xmm0            
   
    !inc edi
    !cmp edi,3
    !je @f
    !add esi,32
    !jmp @b
!@@:
    !mov byte[esi+32],0      ;Zero-Byte; mal ganz vorbildlich, obwohl hier im speziellen Fall nicht nötig
    !mov eax,1               ;Rückgabewert <> Null für Erfolg
  ProcedureReturn   
EndProcedure 

ProzessorString$ = Space(49) ;der String kann max.48 Zeichen lang sein plus ein Zero-Byte zum Abschluss
                             ;ich hoffe, das ist hier so richtig mit der Anzahl
Get_Prozessor_String_W(@ProzessorString$)
MessageRequester("Prozessor-String mittels CPUID auslesen - Unicode-Variante", ProzessorString$)

Ist nicht 30, sondern "nur" 25-mal schneller.
Unicode ist an mir bisher spurlos vorbeigegangen; wenn´s falsch ist, bitte sagen!

Gruss
Helle

[ts-soft]

>> wenn´s falsch ist, bitte sagen!
Krieg nur IMA

[Leonhard]

bei mir klappt alles

[Helle]

Fehlende SSE2-Unterstützung würde keinen IMA erzeugen, also kommt nur Space in Frage (verdoppeln!). Da war (bin) ich mir eben nicht sicher, ab Space im Unicode-Modus pro Zeichen 2 Bytes reserviert oder nicht. Ich kann Space bei mir auch auf 1 setzen und es funktioniert immer noch, aber das hängt natürlich von der momentanen Speicherverwaltung des Betriebssystems ab.

Gruss
Helle

[ChristianK]

>Krieg nur IMA Mr. Green

dein zweiter von zwei 32MB-Riegel hat ein Speicherfehler

[ts-soft]

Hab keine 2 Riegel

Line : 47 - Illegal instruction, (executing binary data?)