Jump to content

Analisador de CPU [Contribuam!]


thoga31
 Share

Recommended Posts

Tenho aqui uma ideia.

Os Windows Vista e 7 fazem uma análise do nosso sistema e fazem um ranking do PC.

Que tal juntarmo-nos e fazermos um analisador da CPU (e possivelmente do HDD)?

A ideia seria ver a rapidez da CPU quando forçada a um nível normal e quando forçada ao limite em determinadas situações.

Um pequeno excerto-exemplo do output:

4000000 cálculos simples por segundo
1000000 cálculos cíclicos por segundo
500000 cálculos em função por segundo

Em 2009 fiz esta tentativa e nunca mais lhe peguei... Nem os segundos conseguia calcular bem, não liguem 😉

program CRRC_Tester_001;
uses crt,dos;
var hour,min,sec,csec:word;
    hour0,min0,sec0,csec0:word;
    h1,m1,s1,cs1:integer;
    a,b,c:longint;
    i,j,l,m:integer;
    key:char;

    crrc_1,crrc_2,crrc_3,crrc_4:real;
    time:real;

    reg:text;

label start,options;

procedure calc_time;
begin
     gettime(hour,min,sec,csec);

     if (hour>=hour0) then begin
        h1:=(hour-hour0)*60*60*100;
     end
     else begin
          h1:=((24-hour0)+hour)*60*60*100;
     end;

     if (min>=min0) then begin
        m1:=(min-min0)*60*100;
     end
     else begin
          m1:=((60-min0)+min)*60*100;
     end;

     if (sec>=sec0) then begin
        s1:=(sec-sec0)*100;
     end
     else begin
          s1:=((60-sec0)+sec)*100;
     end;

     if (csec>=csec0) then begin
        cs1:=(csec-csec0);
     end
     else begin
          cs1:=((100-csec0)+csec);
     end;

     time:=(h1+m1+s1+cs1)/100;
end;

begin
     ;start:
     textbackground(7); clrscr;
     textcolor(2);
     writeln('CRRC Tester 0.01');
     writeln;
     textcolor(16);
     writeln('O programa vai testar o seu computador, de modo a calcular o CRRC.');
     writeln;
     writeln('O CRRC, Coeficiente Relativo de Rapidez de Calculo, e um indicador da');
     writeln('quantidade de calculos que o computador efectua por segundo ou outra unidade');
     writeln('de tempo.');
     writeln;
     writeln('O CRRC pode ter varios subvalores. O programa analisara a capacidade do');
     writeln('computador na realizacao de Calculos e no processamento de Comandos');
     writeln('Programacionais.');
     writeln;
     writeln('O teste vai ser dividido por 4 fases:');
     writeln('   1 - Calculos simples;');
     writeln('   2 - Ciclos de calculo;');
     writeln('   3 - Ciclos temporais;');
     writeln('   4 - Ciclos complexos.');
     writeln;
     write('Quando quiser inciar o Teste, pressione ENTER. ');

     repeat
           key:=readkey;
     until (key=#13);

     clrscr;

     write('O Teste vai iniciar dentro de');
     for i:=5 downto 0 do begin
         gotoxy(31,1);
         write(i,' segundos... ');
         delay(1000);
     end;

     gotoxy(1,1); clreol;
     writeln('O CRRC Tester vai agora testar o seu computador.');
     writeln;
     write('Fase 1 de 4: Calculos simples... ');

     gettime(hour0,min0,sec0,csec0);

     a:=0;

     while NOT (a=1000000000) do begin
           a:=a+1;
     end;

     calc_time;

     crrc_1:=ABS(a/time);

     writeln('[Concluido]');

     delay(2000);

     writeln;
     write('Fase 2 de 4: Ciclos de calculo... ');

     gettime(hour0,min0,sec0,csec0);

     a:=0;
     b:=0;

     c:=0;

     repeat
           a:=a+1;
           c:=c+1;
           b:=b-3;
           c:=c+1;
           if (a MOD 3 = 0) then begin a:=a+2; c:=c+1; end;
           if (b MOD 9 = 0) then begin b:=b+5; c:=c+1; end;
     until (ABS(a)>=1000000000) and (ABS(b)>=200000000);

     a:=0;
     b:=0;

     calc_time;

     crrc_2:=ABS(c/time);

     writeln('[Concluido]');
     writeln;

     delay(2000);

     write('Fase 3 de 4: Ciclos temporais... ');

     gettime(hour0,min0,sec0,csec0);

     for i:=0 to 10000 do begin
         delay(10);
         i:=i+10;
     end;

     calc_time;

     crrc_3:=ABS((10/time)*100);

     writeln('[Concluido]');
     writeln;
     delay(2000);
     write('Fase 4 de 4: Ciclos complexos... ');

     gettime(hour0,min0,sec0,csec0);

     i:=0;

     repeat
           a:=0;
           i:=i+1;

           for j:=1 to 10 do begin
               for l:=1 to 1000 do begin
                   for m:=1 to 10000 do begin
                       a:=a+1;
                       c:=c+1;
                   end;
               end;
           end;

           j:=0; l:=0; m:=0;

           while NOT j=10 do begin
                 j:=j+1;
                 l:=0;
                 while NOT l=1000 do begin
                       l:=l+1;
                       m:=0;
                       while NOT m=10000 do begin
                             m:=m+1;
                             a:=a+1;
                             c:=c+1;
                       end;
                 end;
           end;

     until i=100;

     calc_time;

     crrc_4:=ABS(c/time);

     writeln('[Concluido]');
     writeln;
     delay(3000);

     writeln;
     writeln('O CRRC Tester terminou o teste.');
     write('Prima ENTER para consultar os resultados. ');

     repeat
           key:=readkey;
     until (key=#13);

     clrscr;

     writeln('Inicio: ',hour0,' ',min0,' ',sec0,' ',csec0);
     writeln('Fim:    ',hour,' ',min,' ',sec,' ',csec);
     writeln('Time:   ',h1,' ',m1,' ',s1,' ',cs1,' = ',time:0:5);

     textcolor(2);
     writeln('RESULTADOS');
     writeln;
     textcolor(4); writeln('Fase 1');
     textcolor(16);
     write('CRRC = '); textcolor(9); write(crrc_1:0:4,' calculos por segundo');

     writeln;

     textcolor(4); writeln('Fase 2');
     textcolor(16);
     write('CRRC = '); textcolor(9); write(crrc_2:0:4,' calculos em ciclo por segundo');

     writeln;

     textcolor(4); writeln('Fase 3');
     textcolor(16);
     write('CRRC = '); textcolor(9); write(crrc_3:0:4,'% de rapidez instantanea em 10 segundos');

     writeln;

     textcolor(4); writeln('Fase 4');
     textcolor(16);
     write('CRRC = '); textcolor(9); write(crrc_4:0:4,' calculos em ciclo complexo por segundo');

     ;options:

     for i:=12 to 20 do begin
         gotoxy(i,1); clreol;
     end;

     gotoxy(1,18);

     textcolor(16);

     writeln('ESCOLHA O QUE PRETENDE FAZER:'); {line 12}
     writeln('   1 > Repetir o teste.');
     writeln('   2 > Gravar num ficheiro TXT os resultados.');
     writeln(' ESC > Sair do programa.');

     repeat
           gotoxy(1,16);
           key:=readkey;
     until (key=#49) or (key=#50) or (key=#27);

     case key of
          #49:goto start;
          #50:begin

              end;
     end;

     clrscr;

     delay(300);

end.

Ideias de parâmetros a avaliar? Métodos para os realizar? Força nisto! Quero um pequeno projecto nosso a fim de ter um analisados de CPU (e HDD).

Contribuam! 😉

Cumprimentos,

thoga31

Knowledge is free!

Link to comment
Share on other sites

Não verdade já existem vários programas de benchmarking, e não é fácil fazer um programa de benchmarking que dê indicações úteis no mundo real.  Em aplicações reais, questões como a cache e largura de banda de memória são bastante importantes, e ao mesmo tempo difíceis de simular.  Parece-me que no programa que tens, nas fases intensivas a cache L1 seria suficiente, pelo que te daria indicadores muito realistas.

No caso dos discos acontece algo semelhante.  Não é fácil simular padrões reais de acesso a disco.

A melhor solução talvez seja usar aplicações reais nos testes.

Link to comment
Share on other sites

Aleluia uma resposta, ahahah 😄

@Rui Carlos, eu entendo a dificuldade. Mas pode ser possível analisar o comportamento da CPU neste género de processos que são os mais habituais no mundo académico.

Por exemplo, com uns melhoramentos a esse programa consegui prever quanto tempo demoraria, com uma precisão de milésimos de segundo, calcular todas as chaves do euromilhões no meu PC e no PC de um amigo - e como previ, e bem, no dele foi cerca de 0,150 milissegundos mais rápido, salvo erro. 😉

Para fins académicos e simples, acho que o ser muito realista não é o mais importante. O objectivo seria mesmo comparar o tempo levado a cabo para calcular as mesmas coisas com métodos diferentes - mais ou menos realista, os resultados relativos deverão concordar com os absolutos, não mensuráveis neste programa. 🙂

Knowledge is free!

Link to comment
Share on other sites

Falando em problemas académicos, pega em algoritmos de grafo ou algoritmos de ordenação, usando inputs de alguma dimensão.

É que muitas vezes até com o mesmo programa, de complexidade linear, tens variações que são muito complicadas de prever.

Adicionalmente, não estou mesmo a ver a utilidade disso.  Se queres comparar algoritmos, tem métricas como a complexidade, operações executadas, ou outros.

Este tipo de valores só seria útil para comparar diferentes máquinas.  Mas aí, caímos no problema dos valores dizerem muito pouco, e de arquitecturas diferentes levarem a que máquinas diferentes obtenham o melhor resultado.

Link to comment
Share on other sites

?

Estou a ver... Bem, parece que contar cálculos por segundo tem mais do que se lhe diga do que aquilo que aparenta.

Ainda pensei em fazer uma análise para cada género de processo, sem estar a prever algoritmos mais complexos, para se ter uma ideia do que pode vir a acontecer com certos programas... Mas ok, isto é mais complexo que isso... ?

Knowledge is free!

Link to comment
Share on other sites

Eu acho que estão a ir ao fundo da expressão "análise da CPU". 😄

A minha ideia era mais simples que isso.

Imagina um programa em Pascal que realiza uma série de cálculos cíclicos para chegar a um determinado resultado. Contudo, deparaste com dois métodos: qual será o mais rápido?

Com um pequeno "analisador", terias uma ideia relativa de qual seria mais rápido em menos de um minuto.

Em suma: não são as operações assembly, mas as operações "Pascal". Ou seja, e por exemplo, quantas somas em pascal faz o meu computador por segundo? 🙂

É que eu acho que estão a complicar algo que era suposto ser simples... 😉  Não me interessam resultados absolutos nem "ultra-realistas" - apenas uma forma de ter uma ideia relativista do comportamento da CPU.

Knowledge is free!

Link to comment
Share on other sites

As somas que o teu pc faz por segundo é algo que pode ser determinado a partir das especificações do CPU.  O problema é que isso seria um máximo teórico, que na prático, só em programas muitos simples, ou em programas relativamente simples e altamente optimizados, consegues atingir.

Isto é "algo que era suposto ser simples", mas que infelizmente não é.  E eu que o diga, que já passei muitos dias a tentar perceber por que é que até programas que eram simples e que deviam atingir os valores teóricos, ficavam na verdade muito longe disso.  E isto era com programas com comportamento previsível (tal como os teus).  Quando tens um programa como uma ordenação, em que as operações dependem do input, as coisas são ainda mais complicadas.

E para te dar um exemplo ainda mais simples de como não é fácil comparar hardware, os GPU costumam ter muito mais capacidade de cálculo do que os CPU (basta ver as maravilhas que fazem num folding@home).  Mesmo assim, a generalidade do software que temos a correr no PC corre no CPU, pois a generalidade do software tem eficiências muito mais baixas em GPUs do que em CPUs.

Link to comment
Share on other sites

Ainda não percebi muito bem a utilidade da tua ideia: se é para comparar a velocidade de execução do mesmo código em máquinas diferentes, se para comparar algoritmos diferentes.

Se é para comparar máquinas, já existem muitos e nenhum deles serve de muito. Apenas para ter uma vaga ideia. A velocidade de execução dum programa depende de muito mais coisas do que da velocidade do CPU ou disco.

Se é para comparar algoritmos, ainda serve para menos. A escolha dum algoritmo não deve depender unicamente da velocidade de execução, mas sim de todas as condicionantes expressas e previsíveis. De que te serve ter um algoritmo rapidíssimo com poucos dados mas que com mais dados gasta tanta memória que provoca uma 'swap storm' ?

Para além do mais a ideia de que é possível prever o tempo de execução dum programa complexo é errada. Os programas complexos pela sua própria natureza são impossíveis de prever em termos de tempo de execução; é possível ter uma ideia aproximada mas de utilidade muito restrita.

Obviamente é possível escolher algoritmos com base na sua análise matemática, mas só para algoritmos simples (ordenação, etc.). Para sistemas complexos temos de nos basear na compreensão do que o computador irá fazer para executar o código e na medição, à posteriori, da distribuição do tempo de execução pelo código ('profiling').

Uma pesquisa neste fórum não encontrou nenhum 'post' que fale de 'profilers' e isso é curioso, pois quem queira optimizar o seu código tem de saber utilizá-los. Será que isso não é ensinado ?

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
 Share

×
×
  • 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.