Jump to content

Linha de cache L1 - beta testers precisam-se


bsccara

Recommended Posts

Peço a colaboração de interessados em correr o código abaixo para verificar o seu correcto funcionamento. O código deve detectar o tamanho de linha do cache L1 do processador. Interessa-me testar em máquinas com processador de Intel PIII para cima e do AMD Athlon para cima. Basta que compilem o código e postem aqui o resultado da execução, junto com a marca e modelo do processador da máquina. O código deve compilar tanto em Delphi como em Lazarus, tanto em Windows como em Linux. É um programa de consola (para ser executado na linha de comandos).

Caso este pedido seja contra as regras, as minhas desculpas. Quem quiser usar este código está à vontade.

program Cache_CPUID;

{$APPTYPE CONSOLE}
uses
  SysUtils;

type
  Registers = record
    _eax_ : cardinal;
    _ebx_ : cardinal;
    _ecx_ : cardinal;
    _edx_ : cardinal;
  end;

procedure CPUID(var regs : Registers);
begin
     asm
       push esi
       push ebx
       push ecx
       push edx
       mov esi, regs
       mov eax, Registers(esi).&_eax_
       mov ebx, Registers(esi).&_ebx_
       mov ecx, Registers(esi).&_ecx_
       mov edx, Registers(esi).&_edx_
       db $0F,$A2   { CPUID }
       mov Registers(esi).&_edx_, edx
       mov Registers(esi).&_ecx_, ecx
       mov Registers(esi).&_ebx_, ebx
       mov Registers(esi).&_eax_, eax
       pop edx
       pop ecx
       pop ebx
       pop esi
     end;
end;

const
     AMDProcessor = 1143;
     IntelProcessor = 1223;
var
     size : cardinal;
     regs : Registers;
     maker : cardinal;
begin
     { Default }
     size := 64;

     { Get the manufacturer code (1223 for Intel, 1143 for AMD) }
     regs._eax_ := 0;
     CPUID(regs);
     maker := regs._ebx_ and $000000FF + regs._ecx_ and $000000FF + regs._edx_ and $000000FF;
     regs._ebx_ := regs._ebx_ shr 8;
     regs._ecx_ := regs._ecx_ shr 8;
     regs._edx_ := regs._edx_ shr 8;
     maker := maker + regs._ebx_ and $000000FF + regs._ecx_ and $000000FF + regs._edx_ and $000000FF;
     regs._ebx_ := regs._ebx_ shr 8;
     regs._ecx_ := regs._ecx_ shr 8;
     regs._edx_ := regs._edx_ shr 8;
     maker := maker + regs._ebx_ and $000000FF + regs._ecx_ and $000000FF + regs._edx_ and $000000FF;
     regs._ebx_ := regs._ebx_ shr 8;
     regs._ecx_ := regs._ecx_ shr 8;
     regs._edx_ := regs._edx_ shr 8;
     maker := maker + regs._ebx_ and $000000FF + regs._ecx_ and $000000FF + regs._edx_ and $000000FF;
     regs._ebx_ := regs._ebx_ shr 8;
     regs._ecx_ := regs._ecx_ shr 8;
     regs._edx_ := regs._edx_ shr 8;

     { For AMD }
     case maker of
       AMDProcessor  : begin
                         writeln('Processador AMD');
                         { Check for support of the extended function $5 }
                         regs._eax_ := $80000000;
                         CPUID(regs);
                         if regs._eax_ >= $80000005 then begin
                           writeln('Usando a funcao 8000 0005');
                           { Call the function }
                           regs._eax_ := $80000005;
                           CPUID(regs);
                           size := regs._ecx_ and $000000FF;
                         end;
                       end;
       IntelProcessor: begin
                         writeln('Processador Intel');
                         { Check for support of the extended function $1D }
                         regs._eax_ := $80000000;
                         CPUID(regs);
                         if regs._eax_ >= $8000001D then begin
                           writeln('Usando a funcao 8000 001D');
                           { Parse through all caches }
                           regs._eax_ := $8000001D;
                           regs._ecx_ := 0;
                           repeat
                             CPUID(regs);
                             { Is this a Level 1 Data/Unified Cache ? }
                             if ((regs._eax_ and $000000FF) = $21) or ((regs._eax_ and $000000FF) = $23) then begin
                               if (regs._ebx_ and $00000FFF) > size then
                                 size := (regs._ebx_ and $00000FFF);
                             end;
                           until (regs._eax_ and $0000000F) = 0;
                         end else begin
                           writeln('Usando a funcao 0000 0001');
                           { Use the standard function 1 }
                           regs._eax_ := 1;
                           CPUID(regs);
                           size := (regs._ebx_ and $0000FF00) shr 5;
                         end;
                       end;
     end;
     writeln('Linha de Cache L1: ',size);
end.
Link to comment
Share on other sites

Tens aí o resultado no meu Intel E8400, em Win7, com o mesmo resultado tanto em Delphi XE como em Lazarus!

Processador Intel
Usando a funcao 0000 0001
Linha de Cache L1: 64

"A humanidade está a perder os seus génios... Aristóteles morreu, Newton já lá está, Einstein finou-se, e eu hoje não me estou a sentir bem!"

> Não esclareço dúvidas por PM: Indica a tua dúvida no quadro correcto do forum.

Link to comment
Share on other sites

O título foi modificado para conter o assunto relacionado com o código. Não é nenhuma infracção contra as Regras do Fórum, no problem, só uma questão de accuracy. 😄

E @bsccara, como o código não inflige nenhum mal nas nossas máquinas e até tem um propósito lúdico e académico, não só não viola as regras como o passei agora para a Wiki - é um excelente snippet. 😄

Knowledge is free!

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.