après avoir vu ce topic sur hardware :
http://forum.hardware.fr/forum2.ph [...] h=&subcat=
 
j'ai essayé de le porter en C :
 

 
 
j'ai fait au mieux, mais déjà, en ce qui concerne les fonctions sur l'heure et la date, j'ai l'impression qu'on ne peut pas avoir des trucs commun entre windows et linux
je me trompe ?
 
secundo, il est vraiment pourri ce bench, et j'aimerais faire un truc vraiment poussé si possible
 
intéret ? passer en revue une bonne partie des appels systèmes ou autres, voir comment opimisé son code, voir où sont les pertes de performance au niveau matériel ...
et avoir un truc un peu mieux que les gobopin's pour comparer la taille de notre ...    
 
ça vous intéresse ?
 
 
ah aussi ils ont soulevé dans l'autre topic le pb des optimisations par le compilateur
mais que j'utilise -O3 ou -O0, ça me donne le même temps

ça vous interesse pas ?
à moins que vous n'ayer pas les compétences ?

vu la taille et la complexité du code ca me parrait pas aberrant que -O0 et -O3 ne cahnge rien ...

la commande time tu connais?

 
bah je demande ça parce qu'avec leur super basic ils tappent dans les 28-30sec avec ma config, alors que je suis plutot à 5sec moi  
 
 
bon alors, vous avez des idées de ce qu'on pourrait rajouter pour faire un truc poussé ?

 
oui mais j'aimerais faire un prog portable autant que possible

t'apeele ça propre?
 
(struct timezone *) NULL
 
struct timeval* t0 = (struct timeval*) malloc(sizeof(struct timeval));
struct timeval* t1 = (struct timeval*) malloc(sizeof(struct timeval));
 
en plus d'etre mauvais c inutile
 
et regarde fabs...
 
je vais pas donner un cours de C ici

 
c'est pour ça que j'ai fait le topic, j'ai pas dit que c'est propre  
alors plutot que de critiquer, dit moi plutot ce qui va pas  
 
et c'est quoi fabs

caster c sale (et inutile ici)

 
pour les malloc ?  
on m'a toujours appris comme ça
et pour le NULL, bah je croyais au contraire que c'était plus propre que de laisser just NULL dans un type non concordant
tu ferais comment toi ?

et en quoi y a besoin de malloc dans ce programme?
 
et les types concordent parfaitement puisque qu'en C, les conversions void* <-> type* sont implicites, sures et tout à fait légales

je sais pas : gettimeofday fait lui même l'alloc mémoire ?
comment je peux savoir si une fonction se charge de l'allocation ou pas ?
sinon je suis conscient que j'ai vraiment un niveau ridicule en C etje ne demande qu'à apprendre : t'as un bouquin à me conseiller ? les oreilly sont bien ?
 

à oui, NULL est de type void* c'est ça ? (désolé je savais pas/plus )
 
enfin bon, tu pouvais dire ça sans agresser
 
 
 
EDIT : j'ai viré l'alloc et ça segfault

semblerait que t'es pas compris grand chose, alors commence pas à nous faire des bench s'il te plait, surtout que le calcul flottant, c'est pas significatif. pour quake je veux bien, mais là, ça compare rien si ce n'est celui qui à la plus grosse FPU, ce dont je me fout bien.
 
pi SETI  PAWA

 
j'aime les connards grandes gueules qui peuvent pas s'empecher de dénigrer les autres dès qu'ils savent faire qq'chose un peu mieux que la moyenne  
j'ai jamais dit que je savais programmer correctement, j'ai encore moins dit que ce bench valait qq'chose (regarde bien, c'est écrit en toute lettre qu'il ne demande qu'à être amélioré)
 
alors si tu n'as pas envi d'apporter ta contribution, tu te casses et tu fais pas chier  

rappelle moi de sauter tes topics sur Programmation

 
si ça peut te faire plaisir  

et com ca ? :
 
struct timeval t0;
struct timeval t1;
 
[...]
 
gettimeofday(&t0, NULL);
 
[...]
 
gettimeofday(&t1, NULL);
 
[...]
 
diftime(&t1, &t0));  

 
ah bah oui ... c'est dingue ce qu'on peut perdre quand on ne pratique plus    
 
bon par contre on m'a toujours dit que ça revenait au même ... alors je veux bien croire qu'on m'ait mentit, mais pouvez-vous me dire pourquoi c'est plus propre comme ça ? et est-ce qu'on peut faire un free la dessus ?
 
et aussi ma question de toute à l'heure : est-ce que ça arrive qu'une fonction alloue elle même la mémoire, et comment on peut le savoir ?

gné? malloc c'est pour les allocations dynamiques ou de grande taille. sinon, quand la taille de l'espace à allouer est raisonnable et est connue à l'avance, ben on utilise la pile      
 
c'est exactement le meme mécanisme que quand on déclare un int
 
EDIT:

Oui, malloc alloue elle meme la mémoire (en faisant appel à sbrk), strdup aussi, etc. Comment on le sait? on lit la doc

c juste ke tu creer tes variables en dur et k apres tu passe les addrs, c plus pratique et plus propre mais ca:
{
 struct timeval *t0;  
 struct timeval *t1;  
 
 t0 = malloc(sizeof(struct timeval));
 t1 = malloc(sizeof(struct timeval));
}
 
c est correct, c est juste les cast ki ne servaient a rien.
 
sinon pour savoir si une fct alloue de la memoire il faut lire le man de la fonction (man non_de_la_fsct sous unix-like, sous win je sais pas mais de tt facon ils sont dispos sur le net, la plupart en francais)
 
un bon boukin sur le C (la reference en fait) : le language C norme ANSI de Brian Kernighan et Denis Ritchie chez dunod (couverture jaune)

ah je savais pas
j'avoue que c'était vraiment flou dans mon esprit
je sais même plus quand j'utilisais alloc et quand je ne l'utilisais pas (à l'époque où je programmais en C    

ok, donc quand c'est pas précisé dans la doc (parce que ce n'est pas toujours préciser, ou alors ça m'arrive de zapper aussi peut-être), c'est que l'allocation doit être faite à la main ?

raaah ! ça m'ennerve, on m'a toujours appris à faire des casts
en même temps, j'aurais lu le man de malloc, j'aurais vu qu'il renvoyait un void*  
m'enfin c'est bizarre que tous mes profs m'aient toujours dit de faire comme ça ... passons ...
 
pour le man je connais, mais il me semble que c'est pas toujours préciser ... enfin si un jour j'ai un pb, je verrais le moment venu
 
et merci pour le livre, justement j'en cherchais un (bon j'aurais préféré en Français mais je vais voir si la bestiole en vaut la peine )

bon, j'ai édité le bout de code, c'est mieux ?    
 
sinon j'ai vu qu'il y avait aussi une macro timersub, mais j'ai pas compris comment y avoir accès puisqu'apparemment elle est pas dispo par défaut (j'ai pas bien compris le man à ce sujet)
et est-ce qu'un macro comme timersub est mieux ou moins bien que ma fonction diftime qui fait exactement la même chose (sauf que c'est une fonction )
 
mon dieu mais j'ai plein de questions, je dois déjà vous saouler !  

C en Français (ca a ete traduit evidement)

une macro c plus rapide mais la difference doit pas etre enorme.

 
adopter, je l'achete prochainement
en espérant que ça coute pas 500 balles quand même

 
la différence sur un petit prog est toujours minim mais je cherche a avoir les bonnes méthodes
mais comment ça se fait que c'est plus rapide avec une macro
le code d'une fonction est pourtant bien optimisé normalement non ?

- de 30? il me semble
 

aucune idee    

ok  

 
Il y a plus ou moins 2 écoles...
 
J'ai un (vieux) prof de C qui en fait aussi...
Mais ça risque de masquer certaines messages d'erreurs (il me semble).
 
(et là, je viens de lancer une vieille discussion: "faut-il faire un cast après une allocation ?" )

 
ouai moi aussi c'est les vieux
c'est peut-être parce qu'une ancienne définition du malloc ne renvoyait pas un void* mais un int* ou un char* ... va savoir
 
 
enfin bon, tous ces petits détails réglés, on pourrait peut-être attaquer l'évolution du bench, ça vous branche pas ? ça peut être interessant, j'ai déjà appris plein de trucs moi, là

y a peu de chance    
 
en tt cas tu devrai faire une moyenne de res de tests plutot, ca me parrait mieux pour un test de calcul.
 
EDIT : un truc genre ca :
-----------------------------------------------------------
#include <stdio.h>
#include <math.h>
#include <sys/time.h>
 
double diftime(struct timeval *t1, struct timeval *t0)
{
 return ( (t1->tv_sec + (double)t1->tv_usec / 1000000) - (t0->tv_sec + (double)t0->tv_usec / 1000000) );
}
 
int  main(int ac, char **av)
{
 int tot;
 int res;
 
 if (ac == 2)
  {
     tot = do_tests(atoi(av[1]));
     printf("Résultat du test : %f secondes\n", tot / res);
  }
        else
         printf("Usage : ./prog [nbr]" );
 return (0);
}
 
double  do_tests(int n)
{
 double tot;
 
 for (tot = 0; n: n--)
   tot = tot + test();
 return (tot);
}
 
double  test()
{
 struct timeval t0;
 struct timeval t1;
 int i,j,k;
 double x,y,z,a,b,c,d,e,f,s;
 
 puts("Exécution du test..." );
 
 gettimeofday(&t0, NULL);
 for (i=0;i<640;i++)
  {
   for (j=0;j<3092;j++)
   {
     x = exp(cos(i * 7 + 1) / 2) + tan(j * i + .4);
     y = x + 51 * j - 55 + 2 * i;
     z = (abs(y * x) - cos(y * x) + sin(y) - tan(x));
     a = exp(cos(i * 7 + 1) / 2) + tan(j * i + .4);
     b = x + 51 * j - 55 + 2 * i;
     c = (abs(y * a) - cos(y * b) + sin(z) - tan(a));
     d = exp(cos(i * c + 1) / 2) + tan(j * i + b);
     e = d + 51 * j - 55 + 2 * i;
     f = (abs(y * e) - cos(a * j) + sin(i) - tan(x));
       for (k=0;k<12;k++) s=(x+y+z+a+b+c+d+e+f)*x;
   }
            gettimeofday(&t1, NULL);
            printf(" -- %d -- temps écoulé : %f secondes\n",i,diftime(&t1,&t0));
           }
//printf("Résultat du test : %f secondes\n",diftime(&t1,&t0));
//printf("s=%f\n",s);
return (diftime(&t1,&t0));
}
 
(desole c fait sous wordpad, ma copine a besoin de windows   )

 
spa bete
euuuh, res il vaut quoi dans ton printf ?

mais bon, je recherche des trucs plus poussé, qui pourrait représenter un besoin réelle, pour tester les limites du proc, de la mémoire, du DD ... mais peut-être que je vois trop gros là, je vois même pas comment faire ça

a mon avis, oui tu demande beaucoup faire un test qui pourra etre utilisé sur tous les pc pour voir chaque limite de chaque pc de chaque matériel, c'est un peu plus hard que ca maintenant, j'te souhaite bonne chance  

desole
 
int  main(int ac, char **av)  
{  
int tot;  
int nbr;  
 
if (ac == 2)  
 {  
    nbr = atoi(av[1]);
    tot = do_tests(nbr);  
    printf("Résultat du test : %f secondes\n", tot / nbr);  
 }  
       else  
        printf("Usage : ./prog [nbr]" );  
return (0);  
}  

 
c'est paske qd t'utilises une macro, le préprocesseur change directement le code source, avant la compilation...alors qu'une fonction, ça te coute l'appel à la fonction, + d'autres trucs, comme la copie des paramètres dans les variables locales, etc..
Bon j'y connais rien du tout, n'ayant pas fait bcp de C, mais ça me parait logique comme ça.

 
ah oui, là je comprends mieux
 
 
 
(bon, j'avais compris ce que tu voulais faire quand même )

 
bah je sais pas moi, mais avec le -finline-functions, ça me parait un peu équivalent quand même ...
enfin on va pas se battre, non plus

c'est pour ça que le C a introduit dans ses dernières révisions le mot clef inline as-fast-as-macro  
 
 
edit: et pi fo proscire l'usage de atoi, qui renvoie 0 en cas d'erreur de conversion. le problème, c'est que 0 est une valeur accpetable. meme remarque pour les fonctions ato*. utilisez sscanf