/* 
**
** Cburner vs 1.1 betah 1 bY ReDaLeRt -- 2004
**
** Executa varios ciclos de instrucoes para CPU/Memoria
**
** Admite parametros de execucao! sintaxe: cburner NUMERO_DE_CICLOS_EM_MILHOES TAMANHO_DOS_BLOCOS_EM_MB
**     ex: cburner 2 2.5
**
** Info: https://sourceforge.net/projects/cburner/
**
** Compilar: gcc -msse -mfpmath=sse cburner_xx_vsxxx-c -o cburner
**
** Agradecimentos ao random (SSE powa!) e resto do ppl do #coderspt @ ptnet :D
**
**
*/

#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <time.h>
#include <xmmintrin.h>

#define VERSAO "1.1 betah 1\0"
#define PRIORIDADE 6
#define CICLOS (10000000 * 60)
#define BLOCOS (3*1024000 * 60)

/* declaraçao de variaveis (vectores "alinhados" a 16bit) */
float vector1[4] __attribute__((aligned(16))) = {0.137368656484769387, 1.336835873646733877, 2.2368368438736486843, 4.3346868431836841374};
float vector2[4] __attribute__((aligned(16))) = {-0.745314534776967435, 2.89976344596456385636, 3.78936456796724563, -4.078783948596332420};
float vector3[4] __attribute__((aligned(16))) = {13684, 3684431, 226718, 384368};
float vector4[4] __attribute__((aligned(16))) = {1, 28, 51, 31};

__m128 bar, bar2, bar3, bar4;
/* fim da declaraçao */


/* retorna a frequencia aprox do CPU em MHz (ESTE CODIGO NAO E MEU! RETIREI-O DO FORUM DO #CODERSPT!!) */
DWORD getFreqFromRegistry() /* esta funcao em linux nao funciona! */
{
  HKEY hKey;
  DWORD cbBuffer;
  LONG rc;
  DWORD freq_mhz;

  rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Hardware\\Description\\System\\CentralProcessor\\0", 0, KEY_READ, &hKey);

  if (rc == ERROR_SUCCESS) {
    cbBuffer = sizeof (DWORD);
    rc = RegQueryValueEx(hKey, "~MHz", NULL, NULL, (LPBYTE)(&freq_mhz), &cbBuffer);
    RegCloseKey (hKey);
  }

  return ((rc == ERROR_SUCCESS)?freq_mhz:0);
}
/* fim de.... */



int main(int argc, char *argv[]){
    /* declaracao e inicializaçao de variaveis*/
    clock_t start, finish;
    double duration;
    double i=0;
    unsigned short *ptr_int = (unsigned short*)calloc(1, sizeof(unsigned short));
    char *ptr_char = (char *)malloc(BLOCOS);
    char *ptr_char_2 = (char *)malloc(BLOCOS);
    char *ptr_void, *ptr_void_2;
    double ciclos = CICLOS;
    double blocos = BLOCOS;
        
        if(argc==3){
            ciclos = atof(argv[1])*1000000;
            blocos = atof(argv[2])*1024000;
        }
        
    /* fim de... */
  
    printf("CBurner vs %s bY ReDaLeRt\n", VERSAO);
    printf("Para mais informacoes: http://sourceforge.net/projects/cburner/\n\n");
    printf("Prima 'Enter' para continuar...");
    getchar(); /* o system("PAUSE") ja era! :P */
                     

    /* bloco de testes de alocacao de memoria */
    printf("\n\n\nCiclos de teste 'a memoria: %.1f milhoes\n", ciclos/1000000);
    printf("Tamanho dos blocos: %.2fMB\n", (blocos)/1024000);
    printf("Teste para memoria em curso. Aguarde por favor...(40 a 150 segs)\n\n");
    
    
    ptr_void = (char *)malloc(blocos);
    ptr_void_2 = (char *)malloc(blocos);
    start = clock();
    
        for(i=ciclos; i>0; i--){
            *ptr_void = *ptr_char;
            *ptr_void_2 = *ptr_void;
            *ptr_void = *ptr_char_2;
            *ptr_void_2 = *ptr_char_2;
            *ptr_void = *ptr_char;
            *ptr_char = *ptr_void_2;
            *ptr_char_2 = *ptr_void;
        }
    
    finish = clock(); 
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    
    printf("Endereços de memoria alocados:  %p %p\n\n", ptr_void, ptr_void_2);
    printf("\t\t\t\t%p %p %p\n", ptr_int, ptr_char_2, ptr_char);
    
    free(ptr_void);
    free(ptr_void_2);
    free(ptr_char);
    free(ptr_char_2);
    
    printf("Tempo: %.3f segundos\n\n", duration);        
    
    /* fim de... */


    /* ciclo infinito! burn, burn!! :P */
    printf("\n\nVelocidade aproximada do CPU: %iMHz\n", getFreqFromRegistry());
    printf("Teste de Burn ao CPU. Ciclo infinito em marcha!... :)\n");
    printf("\nAconcelha-se um Burn *minimo* de 2 horas!\n");
    
    /* converter os vectores em formato acessivel para os registos SSE */
    bar = _mm_load_ps(vector1);
    bar2 = _mm_load_ps(vector2);
    bar3 = _mm_load_ps(vector3);
    bar4 = _mm_load_ps(vector4);
            
        while(1){
           bar3 = _mm_add_ps(bar3, bar4);
           i++; i *= 2;
           bar3 = _mm_xor_ps(bar3, bar4);
           _mm_add_ps(bar, bar2);
           *ptr_int++;
           bar3 = _mm_and_ps(bar3, bar4);
           _mm_sub_ps(bar, bar2);
           i /= 2; i--;
           _mm_mul_ps(bar, bar2);
           bar3 = _mm_or_ps(bar3, bar4);
           *ptr_int--;
           _mm_div_ps(bar, bar2);
        } 
               
    /* fim de.... (ou nao... >) */   
     
    free(ptr_int);
    return 0;
}