ouais ca veut dire que le cpu est optimisé pour calculer des cos

pour ce qui est de l'asm en lui-même je pense que c'est indispensable a ce type de projet pour qu'il soit fiable... en effet, je suis loin d'être cultivé sur les compilos mais je pense que si on fait pas gaffe y'a facilement moyen que des accès mémoire se glissent au milieu du processus (et il faut pas - la mémoire [non-cache j'entends] c trop trop lent par rapport au proc), ou d'autres trucs qui font que ça n'utilise pas QUE le proc

cela dit pour revenir au truc des DSE, je pense que des fonctions du type (E(x)-x)^2 doivent pas être DSE autour de certains points (entiers par exemple ? ou entiers + 0.5...) (E(x) étant la partie entière de x - qui se calcule 'facilement' à partir d'un float avec un décalage de bits vers la gauche et un masque)

math spé powaaaa!

......cherchez pas, je suis loin.......

ouais ca veut dire que le cpu est optimisé pour calculer des cos

non, ça veut dire qu'un cpu sait calculer un cosinus

ouais bon d'accord, mais si c'est pas de manière optimisée ça sert a rien, autant le calculer a la main avec des DSE ou des DL...

même un proc sans fcos sait calculer des cos... suffit de lui dire comment....

Mouais, on continue ou on dort ???

perso, ajouter des factorielles à sin*cos*tan******9!

sa déchire encore plus... mais Tcl sait pas faire... sinon on peut se tourner vers le calcul géométrique... mais là c plus de mon ressort...

Je vous propose le bench que j'ai écrit ( assez simple, je débute en C )

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <time.h>
#include <math.h>

int main(int argc, char* argv[])
{  
LARGE_INTEGER frequency;
LARGE_INTEGER startCount;
LARGE_INTEGER endCount;
LONGLONG count;
double nombre_float;
long n;
int score_float;
int score_int;
int nombre_int;
FILE *output;

output = fopen("result.txt", "w");
if (output == NULL) {
 printf("Unable to create result file\n");
 return 1;
}
QueryPerformanceFrequency(&frequency);
nombre_float = 0;
nombre_int = 0;
printf("Benchmarking FPU unit...\n");
//	__asm{int 3};
QueryPerformanceCounter(&startCount);
for (n = 0; n < 2000000000; n++) {
 nombre_float = nombre_float + 1.0000000001;
 nombre_float = nombre_float * 1.0000000001;
}
QueryPerformanceCounter(&endCount);
count = endCount.QuadPart - startCount.QuadPart;
score_float = (long)(frequency.QuadPart * (LONGLONG)1000 / count);
printf("Float Count = %i\nFloat Score = %i\n",
    (long)(count * 1000000 / frequency.LowPart),
    score_float);
fprintf(output, "Float Score = %i\n", score_float);
printf("Benchmarking ALU unit...\n");
//	__asm{int 3};
QueryPerformanceCounter(&startCount);	
//	for (n = 0; n < 2000000000; n++) {
//  nombre_int = nombre_int + 1;
//	}
__asm{
 nop
 nop
 nop
 xor  eax,eax
 mov  ebx,2000000000
 mov  ecx,1
int_loop:
 add  eax,1
 mul  ecx
 dec  ebx
 jnz  int_loop
}
QueryPerformanceCounter(&endCount);
count = endCount.QuadPart - startCount.QuadPart;
score_int = (long)(frequency.QuadPart * (LONGLONG)1000 / count);
printf("Int Count = %i\nInt Score = %i\n",
    (long)(count * 1000000 / frequency.LowPart),
    score_int);
fprintf(output, "Int Score = %i\n", score_int);
printf("Final Score =%i\n",
    (score_float + score_int));
fprintf(output, "Final Score =%i\n",
    (score_float + score_int));
//	__asm{int 3};
fclose(output);
return 0;
}

L'exe est dispo ici.

intéréssant.... c'est downloadé... et approuvé...

mais c'est pas un peuuu.... simple ?

C'est vrai que c'est pas très compliqué : additions et multiplications en entier et flottant.

comme mon premier bench à moi quoi....

mais jvoulais plus évolué... ceci dit, c'est un bon début...

et si tu veux nous aider ne t'enfuies pas...

Jeuuuuu crois que le topic est mooort....

houuuu houuuuu ya kékuuuuuun ?

...

ben, j'ai vraiment pas le temps depuis longtemps...

mais je suis jamais bien loin...

Ben moi non plus mais j'y pense qd. même

Ok, ce topic il est enterré depuis des moins là.... spa bon :o