AccueilAccueil  RechercherRechercher  S'enregistrerS'enregistrer  Connexion  

 

 [Benchmark] Qui qui a la plus petite ?

Aller en bas 
AuteurMessage
Sekigo Le Magnifique
Utilisateur confirmé: Rang *****
Sekigo Le Magnifique

Messages : 1720

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 7 Mar 2011 - 18:08

Bon, j'ouvre un thread pour comparer les différents langages entre eux, niveau performance. Ça évitera de pourrir les topics de présentations de langages.

Donc, ici, c'est le temple des mesures de temps, de trollage entre langage et du AH AH AH envers Game Maker.

Si vous voyez quelque chose d'incorrect, une remarque ou quoi que ce soit d'autres, n'hésitez pas à le signaler !
Et indiquez le matériel nécessaire, sinon, les perfs ne veulent rien dire. Ou alors, un élément de comparaison.
==============================================================
Performance "brut" avec une boucle idiote et des calculs idiots (merci Onilink):
Code c (compiler avec gcc main.c -s -Os -o test_perf.exe):
Spoiler:
 
Code Python :
Spoiler:
 
Code PureBasic :
Spoiler:
 
Résultats :
Code:

# C Sur un dual-core E2220 à 2.4Ghz
Time elapsed: 20.280000
# Python (Python+psyco) Sur un dual-core E2220 à 2.4Ghz
Time elapsed : 234.04 (105.38)
# PureBasic sur un processeur inconnu (celui de blendman)
Time elapsed : ~15
# Game Maker sur un dual-core 2.5GHz
Time elapsed : 1080 (on ne rigole pas, s'il vous plait)
============================================================
Test de scrolling sans but :
Code Python + Pygame :
Spoiler:
 
Résultats :
Code:

=== Utilisation en simple buffer et affichage software ===
# Python + Pygame sur un netbook ATOM 1.6Ghz et carte graphique 945GM (pourri).
FPS : ~28
# Python + Pygame sur un dualcore E2220 à 2,4Ghz et CG Nvidia 9500GS 512Mo.
FPS: ~115


Dernière édition par Sekigo Le Magnifique le Lun 7 Mar 2011 - 20:59, édité 1 fois
Revenir en haut Aller en bas
https://2img.net/image.noelshack.com/old/up/gmzonecbna-3cfbc56d25.jpg
onilink_
Modérateur
onilink_

Messages : 9142
Localisation : Montpellier
Projet Actuel : Planet Centauri
OniDev

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 7 Mar 2011 - 19:24

Ah bonne idée Sekigo.
Pour moi j'ai un dual-core 2.5GHz (et mon os en 32bits)
Et j'avais obtenu 14sec pour le C , donc blendman a du ce gourer dans la compilation (pour se venger de mes résultats lol) et ne pas mettre l'option d'optimisation du code (ça rend le code plus lent)

Ce qui serais a mon avis intéressant serait d'uploader les exécutables de tests dans différents langages, et justement pour différents essais comme calcul idiot, nombre de sprites affichés, etc afin d'avoir des valeurs vraiment précises.

_________________
[Benchmark] Qui qui a la plus petite ? Runningpotato1[Benchmark] Qui qui a la plus petite ? TvF6GED [Benchmark] Qui qui a la plus petite ? MdetltS


Dernière édition par onilink_ le Sam 9 Fév 2013 - 20:34, édité 1 fois
Revenir en haut Aller en bas
Oculus
Utilisateur confirmé: Rang *****


Messages : 1688

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 7 Mar 2011 - 19:37

Faudrait testé gm4 mac qui doit avoir des performances encore plus désastreuse que gm8
Revenir en haut Aller en bas
ombre
Utilisateur confirmé: Rang ***
ombre

Messages : 689
Localisation : Dans sa batcave.

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 7 Mar 2011 - 19:49

onilink_ a écrit:
Et j'avais obtenu 14sec pour le C , donc blendman a du ce gourer dans la compilation (pour ce venger de mes résultats lol) et ne pas mettre l'option d'optimisation du code (ça rend le code plus lent).
Blendman a dit qu'il avait obtenu 13 sec pour l'executable en C ;
Citation :
Appli C : ~13 secondes (via codeblock)
Appli purebasic : ~15 secondes
Revenir en haut Aller en bas
http://www.3arks.com
Sekigo Le Magnifique
Utilisateur confirmé: Rang *****
Sekigo Le Magnifique

Messages : 1720

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 7 Mar 2011 - 19:56

Les 20 secondes pour le C, c'est sur mon processeur.
J'ai essayé de compiler le code sous PureBasic, mais je n'y suis pas encore arrivé.

Ceci dit, j'aimerais bien avoir un petit benchmark qui pourrait être comparé à Pygame. Je pensais particulièrement à la SDL et à la SFML pour voir les différences en utilisation "réelle" (ex:scrolling). Vous pouvez vous inspirer de mon code un peu naze pour le moment sous Pygame, vu que cette dernière est basé en partie sur la SDL.
Après, c'est un peu relou, parce que il y a trop de paramètres d'affichage à gérer. Donc, faudra se mettre d'accord sur deux ou trois modes d'affichage.
Revenir en haut Aller en bas
https://2img.net/image.noelshack.com/old/up/gmzonecbna-3cfbc56d25.jpg
blendman
Utilisateur confirmé: Rang **
blendman

Messages : 432
Projet Actuel : Crée des jeux, logiciels, BD, Romans et nouvelles.

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 8 Mar 2011 - 17:49

Oni : en C, c'est un peu plus rapide qu'en pb Wink (13 seocndes contre 15) et j'ai pas triché Very Happy

Sekigo Le Magnifique a écrit:
J'ai essayé de compiler le code sous PureBasic, mais je n'y suis pas encore arrivé.
où est-ce que tu bloques ?
Tu as essayé de désactivé le debugger (il faut appuyer sur l'insecte vert) ?
Revenir en haut Aller en bas
http://blendman.blogspot.com/
onilink_
Modérateur
onilink_

Messages : 9142
Localisation : Montpellier
Projet Actuel : Planet Centauri
OniDev

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 8 Mar 2011 - 18:00

blendman a écrit:
Oni : en C, c'est un peu plus rapide qu'en pb Wink (13 seocndes contre 15) et j'ai pas triché Very Happy
T'inquiète j'ai compris en fait c'est le 20sec de Sekigo qui m'avais perturbé xD

Faudra essayer le benchmark en D aussi, parait que ce langage est pas mal du tout.
Citation :
« If a language can capture 90% of the power of C++ with 10% of its complexity, I argue that is a worthwhile tradeoff. »
Ce qui a écrit sur la page qui présente le D.

_________________
[Benchmark] Qui qui a la plus petite ? Runningpotato1[Benchmark] Qui qui a la plus petite ? TvF6GED [Benchmark] Qui qui a la plus petite ? MdetltS
Revenir en haut Aller en bas
blendman
Utilisateur confirmé: Rang **
blendman

Messages : 432
Projet Actuel : Crée des jeux, logiciels, BD, Romans et nouvelles.

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 8 Mar 2011 - 18:04

onilink_ a écrit:

Faudra essayer le benchmark en D aussi, parait que ce langage est pas mal du tout.
Citation :
« If a language can capture 90% of the power of C++ with 10% of its complexity, I argue that is a worthwhile tradeoff. »
Ce qui a écrit sur la page qui présente le D.
ah oui,ce D a l'air intéressant, effectivement Smile
je vais zieuter un n'oei'lz
Revenir en haut Aller en bas
http://blendman.blogspot.com/
Sekigo Le Magnifique
Utilisateur confirmé: Rang *****
Sekigo Le Magnifique

Messages : 1720

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 8 Mar 2011 - 19:54

Spoiler:
 
Bon, je viens d'améliorer le code python pour le test de scrolling.
Il faut coller quatres tiles de même tailles dans le même dossier que le code.
Spoiler:
 

Il faut savoir que Pygame est basé sur la SDL. Donc, je pense que les perfs ne doivent pas être énormément différente. Pour les calculs, oui, mais pour l'affichage, j'en doute.

Déjà, les flags (Fullscreen, doublebuffer, etc...) à passé à l'initialisation de Pygame n'ont quasiment pas d'impact sur les performances.

Donc, pour mon netbook netbook ATOM 1.6Ghz et carte graphique 945GM (C'est en affichage brut, je n'ai pas mis de limitateur de FPS donc ça marche au maximum des perf du processeur).
Code:

Tiles de 32px + résolution de 640x480
~ 50 FPS
Tiles de 64px + résolution de 640x480
~ 80 FPS
Je ne sais pas trop quoi pensé de ces performances. Il y a le scrolling d'opérationnel, l'affichage de 2 profondeurs de tiles sur l'ensemble de l'écran et les vérifications des touches.
Dans l'absolu, ce n'est pas trop mauvais. On peut s'en sortir avec 30FPS avec un affichage relativement fluide en 2D.
Mais j'ai peur que si je mets des choses supplémentaires dans les "steps", comme la gestion des ennemis ou les collisions, ça ne laisse pas bcps de marge de manœuvre. De plus, plus on monte en résolution, plus c'est lent. 640x480, c'est un peu light quoi.

Sinon, j'ai vu qu'il était possible d'utiliser OpenGL avec Pygame. Je vais essayer, mais sans promettre, je ne connais pas du tout OpenGL.
J'ai aussi vu qu'il y avait un binding SFML et Allegro (qui existe dans d'autres langages) pour Python. Je vais essayer aussi.
Ça donnera une idée pour les perfs comparé. Et si c'est plus performant en Python, ce sera fatalement plus performant en C++.

Mon but n'est pas la course au FPS le plus élevé, hein. C'est juste que j'aimerais bien refaire un jeu, mais je n'ai pas envi d'un truc vraiment trop bridée niveau perf. ~30FPS avec tout le moteur de jeu complet sur un netbook, ce serait un minimum pour moi.
Revenir en haut Aller en bas
https://2img.net/image.noelshack.com/old/up/gmzonecbna-3cfbc56d25.jpg
Oculus
Utilisateur confirmé: Rang *****


Messages : 1688

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyVen 5 Aoû 2011 - 20:30

Je viens testé un langage et ça mets 10 seconde(processing), dommage il était vraiment bien.
Code:

int timer;
void draw()
{
  timer = millis();
  int i=0;
  for(; i<0xFFFFF; i++)
    bad_sqrt(i);
  println(millis()-timer);
}

float bad_sqrt(float x)
{
    float res = x;
    int i;
    for(i=0; i<1000; i++)
    {
        res = 0.5 * (res + x/res);
    }
    return x;
}
Bon je me suis peut être trompé quelque part ?

Autrement le language est vraiment simple :
Code:
int balleX=320, balleY=320;
int raquetteX=50, raquetteY=50, raquetteW=25, raquetteH=80;
int dirX=round(random(5))-round(random(5)), dirY=round(random(5))-round(random(5)) ;


void setup()

  size(640,480);
  if (dirX<=0)
      dirX-=3;
  if (dirX>=0)
      dirX+=3;
  if (dirY<=0)
      dirY-=3;
  if (dirY>=0)
      dirY+=3;
}

void draw()
{
  refresh();
  balle();
  raquette();
}

void refresh()
{
  background(0);
}

void balle()
{
  balleX += dirX;
  balleY += dirY;
  if (balleX+15>=640)
    dirX = -dirX;
  if (balleY-15<=0)
    dirY = abs(dirY);
  if (balleY+15>=480)
    dirY = -dirY;
  if (balleX<=raquetteX+raquetteW && balleY>=raquetteY && balleY<=raquetteY + raquetteH )
    dirX = abs(dirX);
  if (balleX==0)
  text("perdu");
  smooth();
  fill(255,255,0);
  ellipse(balleX, balleY, 15, 15);
}

void raquette()
{
  if (keyPressed == true)
  {
  if (keyCode == UP && raquetteY >= 0)
      raquetteY -= 5;
  else if (keyCode == DOWN && raquetteY + raquetteH <= 480)
      raquetteY += 5;
  }
  smooth();
  fill(0,80,255);
  rect(raquetteX, raquetteY, raquetteW, raquetteH);
}

edit : enfaite nan je pensais que les résultat était en ms et non en secondes, le résultat est donc vraiment bien même excellent, quelqu'un peut vérifier parce que c'est quand même du java Yum!
Revenir en haut Aller en bas
Sekigo Le Magnifique
Utilisateur confirmé: Rang *****
Sekigo Le Magnifique

Messages : 1720

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptySam 6 Aoû 2011 - 8:32

Faudrait que tu donnes ton processeur. Parce que 10s sur un processeur de Game Boy, c'est excellent, sur un processeur i7, c'est nul. C'est relatif quoi.

Mais je vais tester sur mon pc, j'ignore comment on fait pour utiliser le java, mais ça permettra de comparer.

Après, c'est du calcul, ce qui nous intéresse réellement, c'est surtout l'affichage.
Revenir en haut Aller en bas
https://2img.net/image.noelshack.com/old/up/gmzonecbna-3cfbc56d25.jpg
Oculus
Utilisateur confirmé: Rang *****


Messages : 1688

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptySam 6 Aoû 2011 - 10:21

Sur un e5200 @ 3.75ghz :
En c++ avec mingw 10.467
Avec processing : 6.470
Les résultat sont en seconde. Je viens de remarqué que mon pc n'était pu qu'a 2.5 ghz hier à cause d'un boot faillure, il est repassé à 3.75ghz aujourd'hui(j'ai été dans le bios puis tout s'est remis normalement, ahh je les aimes ces cm gigabyte).

Ah oui et processing est language open source donc gratuit, lorsqu'on compile on le chois entre linux win osx, c'est super pratique.
http://processing.org/download/
Revenir en haut Aller en bas
Morwenn
Très bonne participation
Morwenn

Messages : 151
Projet Actuel : Icare

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptySam 6 Aoû 2011 - 13:15

Le Python utilisé, c'est avant ou après la version 3 ?
Parce que si la version utilisée est la 2.7 ou n'importe quelle version avant la 3, ça peut être accéléré en remplaçant les range par des xrange. Et pareil, le code pourrait être amélioré de façon simple (passé de 24 à 23 secondes sur mon ordinateur, ça change pas grand-chose, mais bon...).
Parce que bon, c'est cool de faire des mauvaises racines carrées pour tester la rapidité, mais c'est quand même mieux si le code, tout en gardant le même algorithme, est optimisé^^

EDIT : En fait, pour Python, je sais pas du tout si comment la différence entre range et xrange peut évoluer quand Psycho est utilisée...

_________________
[Benchmark] Qui qui a la plus petite ? 37115040594310152086589335317875357842n
Dur Dabla, pour qui voudrait écouter un brin de metal celtique.
Revenir en haut Aller en bas
Oculus
Utilisateur confirmé: Rang *****


Messages : 1688

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptySam 6 Aoû 2011 - 22:47

Grâce à ce merveilleux langage j'ai enfin, et très bien compris les principes avancé de la programmation objet(enfin j'avais déjà compris mais maintenant j'ai l'impression que c'est de la rigolade).
Le debugeur est vraiment bien, 'this file is named House.png not house.png, rename the file or change your code' vraiment pratique !
Revenir en haut Aller en bas
Sekigo Le Magnifique
Utilisateur confirmé: Rang *****
Sekigo Le Magnifique

Messages : 1720

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptySam 6 Aoû 2011 - 23:26

Je dois avouer que c'est bien la première fois que j'entends parler de ce langage. Je pensais que tu utilisais du java dans ton post précédent.

Morwenn >
Dans tout les cas, j'utilise Python dans une version inférieur à la 3. À cause incompatibilité avec certaines bibliothèques logicielles.
Mais j'ai retesté le code plus haut, parce que j'oublie toujours ce maudit xrange.
Je suis tombé sur des résultats étrange. Je suis passé à 120s avec la même machine (sachant que j'étais à ~240s plus haut) ! Soit deux fois moins, ce qui est quand même énorme ! J'ignore si c'est parce que des optimisations ont été faite dans python, ou si c'est pour une raison exogène.
Du coup, faut que je refasse des tests. On passe quand même d'un facteur 10 à un facteur 5.

Et le xrange, j'ai quand même essayé. Bah, je grappille 1s. Je passe de 120s à 119s par rapport à un range. Ce qui est quand même négligeable. Mais j'ai utilisé psyco, je refais des tests plus poussés demain sans cela.
Revenir en haut Aller en bas
https://2img.net/image.noelshack.com/old/up/gmzonecbna-3cfbc56d25.jpg
Oculus
Utilisateur confirmé: Rang *****


Messages : 1688

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptySam 6 Aoû 2011 - 23:35

Enfaite j'étais à la recherche d'une extensions pour les rotations avec la sdl, puis je suis tombé sur un thread et j'ai cliqué sur un lien au hasard et je suis tombé sur un big tuto.
J'ai vu que le langage était vraiment simple et puis je l'ai essayé.
J'ai commencé hier et aujourd'hui j'arrive déjà à faire ça (déplacement, collisions, point de direction, objet, angle...):
Spoiler:
 
Ce langage est carrément addictif Yum!
Revenir en haut Aller en bas
Oculus
Utilisateur confirmé: Rang *****


Messages : 1688

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyDim 7 Aoû 2011 - 19:19

Je me permet d'up car j'ai fait un applet du test d'hier :
Clique gauche, pour créer un zombie, clique droit pour détruir un zombie ou une maison, zqsd pour se déplacé.
http://jbg77.kegtux.org/

Je fourni les sources, vous pouvez les utilisés par contre dite le moi(de même pour les sprites qui sont aussi de moi).
Revenir en haut Aller en bas
daminetreg
Administrateur
daminetreg

Messages : 16996
Localisation : Siege du CBNA!
Projet Actuel : Site Web du CBNA, version beta :

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 8 Aoû 2011 - 14:23

Tes résultats m'étonnes parce que avec gcc ou g++ sur Linux j'ai de bien meilleur résultats que toi sous windows, peu importe que j'utilise -Os ou -O3, cependant essaies plutôt de compiler avec -O3 pour le C ou le C++, -Os est une optimisation de la taille pas de la rapidité, mais souvent je le concède petite taille == rapidité, surtout sur de petits processeurs: micro contrôleurs etc.

Donc moi sur le processeur suivant:
Code:

vendor_id      : GenuineIntel
cpu family      : 6
model          : 23
model name      : Intel(R) Core(TM)2 Duo CPU    T6570  @ 2.10GHz
stepping        : 10
cpu MHz        : 1200.000
cache size      : 2048 KB

Pour le même programme que toi sans le pause :

Code:

#include <stdlib.h>
#include <time.h>

float bad_sqrt(float x)
{
    float res = x;
    int i;

    for(i=0; i<1000; i++)
    {
        res = 0.5 * (res + x/res);
    }
    return res;
}

int main()
{
    clock_t start = clock();

    long int i=0;
    for(; i<0xFFFFF; i++)
    bad_sqrt(i);

    printf("Time elapsed: %f and i : %d\n", ((float)clock() - start) / CLOCKS_PER_SEC, i);

    return 0;
}

Code:

daminetreg@daminetreg-exia:~/bench$ gcc -O3 main.c
main.c: In function ‘main’:
main.c:24:5: warning: incompatible implicit declaration of built-in function ‘printf’
main.c:24:5: warning: format ‘%d’ expects type ‘int’, but argument 3 has type ‘long int’
daminetreg@daminetreg-exia:~/bench$ ./a.out
Time elapsed: 0.000000 and i : 1048575

Executé avec time :
Code:

daminetreg@daminetreg-exia:~/bench$ time ./a.out
Time elapsed: 0.000000 and i : 1048575

real    0m0.002s
user    0m0.004s
sys    0m0.000s

Enfin le callgraph généré par valgrind pour le programme avec les optimisations du compilateur permet de comprendre ce qui fait que c'est si rapide, il a généré des tables spécifiques au calcul demandé: valgrind --tool=callgrind puis lu avec kcachegrind:
Les chiffres dans chaque appel représente l'estimation de cycles cpu faite par valgrind :
[Benchmark] Qui qui a la plus petite ? Callgrind.out.withOptimization

Ensuite le même programme sans optimisation du compilateur :
Code:

daminetreg@daminetreg-exia:~/bench$ gcc main.c
daminetreg@daminetreg-exia:~/bench$ time ./a.out
Time elapsed: 18.510000 and i : 1048575

real    0m18.600s
user    0m18.513s
sys    0m0.008s

Enfin le callgraph généré par valgrind pour le programme sans optimisation: valgrind --tool=callgrind puis lu avec kcachegrind:
Les chiffres dans chaque appel représente l'estimation de cycles cpu faite par valgrind :
[Benchmark] Qui qui a la plus petite ? Callgrind.out.withoutOptimization

Donc bon qui dit mieux que 0 ms avec les optimisations compilateurs ? =D
C++ & C rules the world.

_________________
Mon CV : fr - de - en
Le CBNA Tous Ensemble! Réalisons!
[Benchmark] Qui qui a la plus petite ? U3dfr2
Revenir en haut Aller en bas
http://lecbna.org/
onilink_
Modérateur
onilink_

Messages : 9142
Localisation : Montpellier
Projet Actuel : Planet Centauri
OniDev

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 8 Aoû 2011 - 19:47

daminetreg a écrit:
Donc bon qui dit mieux que 0 ms avec les optimisations compilateurs ? =D
C++ & C rules the world.

Awé quand même :p

Sinon moi j'aime surtout le C et le C++ pour leur syntaxe et leur 'logique'.
Le fait qu'ils soient rapide est un énorme plus, mais le fait d'avoir le contrôle sur tout est vraiment super,
même si on peut parfois s'emmêler les pinceaux...

_________________
[Benchmark] Qui qui a la plus petite ? Runningpotato1[Benchmark] Qui qui a la plus petite ? TvF6GED [Benchmark] Qui qui a la plus petite ? MdetltS
Revenir en haut Aller en bas
Qual
Utilisateur confirmé: Rang ****
Qual

Messages : 1450
Projet Actuel : Tower Defence

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 9 Aoû 2011 - 16:59

Spoiler:
 
Spoiler:
 
Spoiler:
 
Spoiler:
 
Spoiler:
 

_________________
[Benchmark] Qui qui a la plus petite ? Icone_114
Revenir en haut Aller en bas
http://www.brainwizz.fr
Gab666
Modérateur 'Zut'
Gab666

Messages : 5339
Localisation : **I move away from the mic to breathe in

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyVen 12 Aoû 2011 - 0:33

daminetreg a écrit:

Donc bon qui dit mieux que 0 ms avec les optimisations compilateurs ? =D
C++ & C rules the world.

Pffft, c'est pas legit. Tu enlèves tous les calculs dans un test de benchmark. crossa

Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

float bad_sqrt(float x)
{
  __volatile__ float res = x;
    int i;

    for(i=0; i<1000; i++)
    {
        res = 0.5 * (res + x/res);
    }
    return res;
}

int main()
{

    long i=0;
    for(i=0; i<1048576; i++)
       bad_sqrt((float)i);

    return 0;
}

Maintenant tu peux aller faire tes tests. heheh

De toute façon peu importe le langage, ça revient au même. On essai pas de minimiser le temps mais plutôt un nombre de cycles de CPU et peu importe le langage, c'est mathématiquement optimisable jusqu'au même point. Au final c'est converti en code machine et ça donne sensiblement le même résultat. La différence majeure va être dans la façon que le code est écrit(si on passe par une fonction ou non, si le compilateur va la changer en inline tout seul). C'est très biaisé comme calcul on ne sait même pas ce qu'on veut savoir.

_________________
PIS MANIAC PREND DES BAINS !
Revenir en haut Aller en bas
http://www.dermanium-online.webou.net/
daminetreg
Administrateur
daminetreg

Messages : 16996
Localisation : Siege du CBNA!
Projet Actuel : Site Web du CBNA, version beta :

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 15 Aoû 2011 - 13:46

Gab666 a écrit:
daminetreg a écrit:

Donc bon qui dit mieux que 0 ms avec les optimisations compilateurs ? =D
C++ & C rules the world.

Pffft, c'est pas legit. Tu enlèves tous les calculs dans un test de benchmark. crossa

Je l'ai fait sans les optimisations également, je voulais simplement montrer une des forces de la philosophie du C++: le maximum qui est faisable à la compilation doit l'être fait à la compilation qui a un net avantage en matière de performance (rapidité) sur les autres philosophies telles que Javae t .Net où le plus se passe à l'exécution. Mais je referai les calculs si tu y tiens avec ta version modifiée, je ne voulais pas faire de guerre des langages, chacun à ses applications Smile.

_________________
Mon CV : fr - de - en
Le CBNA Tous Ensemble! Réalisons!
[Benchmark] Qui qui a la plus petite ? U3dfr2
Revenir en haut Aller en bas
http://lecbna.org/
Gab666
Modérateur 'Zut'
Gab666

Messages : 5339
Localisation : **I move away from the mic to breathe in

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyLun 15 Aoû 2011 - 23:33

daminetreg a écrit:
Gab666 a écrit:
daminetreg a écrit:

Donc bon qui dit mieux que 0 ms avec les optimisations compilateurs ? =D
C++ & C rules the world.

Pffft, c'est pas legit. Tu enlèves tous les calculs dans un test de benchmark. crossa

Je l'ai fait sans les optimisations également, je voulais simplement montrer une des forces de la philosophie du C++: le maximum qui est faisable à la compilation doit l'être fait à la compilation qui a un net avantage en matière de performance (rapidité) sur les autres philosophies telles que Javae t .Net où le plus se passe à l'exécution. Mais je referai les calculs si tu y tiens avec ta version modifiée, je ne voulais pas faire de guerre des langages, chacun à ses applications Smile.

Mouais, vu dans ce sens. C'étais plus pour troller que d'autre chose je vais t'avouer mon post Very Happy. Par contre tu touches un point, si on parle de langages interpretés/semi-interpretés là on peut vraiment faire un test de benchmark.

_________________
PIS MANIAC PREND DES BAINS !
Revenir en haut Aller en bas
http://www.dermanium-online.webou.net/
daminetreg
Administrateur
daminetreg

Messages : 16996
Localisation : Siege du CBNA!
Projet Actuel : Site Web du CBNA, version beta :

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 16 Aoû 2011 - 21:01

Pas de soucis, c'est bon de discuter. Smile Pour ce qui est des performance avec le type volatile il est de même que le code sans optimisation parce que cela empêche le compilateur d'optimiser =D, puisque la variable est susceptible de changer à tout moment de n'importe où. Mais bon le keyword __volatile__ n'est pas trop portable non ? Pourquoi ne pas avoir utilisé volatile sans les __ ?

_________________
Mon CV : fr - de - en
Le CBNA Tous Ensemble! Réalisons!
[Benchmark] Qui qui a la plus petite ? U3dfr2
Revenir en haut Aller en bas
http://lecbna.org/
Qual
Utilisateur confirmé: Rang ****
Qual

Messages : 1450
Projet Actuel : Tower Defence

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 16 Aoû 2011 - 23:52

HS, mais respect pour le fan d'MGS 3, mon jeu préféré crossa

_________________
[Benchmark] Qui qui a la plus petite ? Icone_114
Revenir en haut Aller en bas
http://www.brainwizz.fr
Gab666
Modérateur 'Zut'
Gab666

Messages : 5339
Localisation : **I move away from the mic to breathe in

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyJeu 18 Aoû 2011 - 0:15

daminetreg a écrit:
Pas de soucis, c'est bon de discuter. Smile Pour ce qui est des performance avec le type volatile il est de même que le code sans optimisation parce que cela empêche le compilateur d'optimiser =D, puisque la variable est susceptible de changer à tout moment de n'importe où. Mais bon le keyword __volatile__ n'est pas trop portable non ? Pourquoi ne pas avoir utilisé volatile sans les __ ?

Autre que l'habitude, il n'y en a pas vraiment, la seule fois que j'en ai vraiment eu besoin c'est quand je faisais du développement de kernel. Par contre je sais qu'avec certaines options de gcc, ne pas mettre "__" peut poser problème.
http://gcc.gnu.org/onlinedocs/gcc-4.6.1/gcc/Alternate-Keywords.html#Alternate-Keywords

Qual: Le meilleur ending jamais écrit. J'ai presque pleuré.

_________________
PIS MANIAC PREND DES BAINS !
Revenir en haut Aller en bas
http://www.dermanium-online.webou.net/
onilink_
Modérateur
onilink_

Messages : 9142
Localisation : Montpellier
Projet Actuel : Planet Centauri
OniDev

[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? EmptyMar 3 Juil 2012 - 21:47

Je m'interrogeais sur la vitesse des opérations élémentaires en C/C++, et voici donc un petit bench qui montre vite fait les ordres de grandeur :

Spoiler:
 

Avec le code suivant, et aucune option pour le compilateur (pas d'opti donc)
Code:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>

void callVoid() {}

void callIntDeclare() { int a = 515156, b = 451456, c = 0; }
void callIntAdd() { int a = 515156, b = 451456, c = 0; c = a+b; }
void callIntSub() { int a = 515156, b = 451456, c = 0; c = a-b; }
void callIntMul() { int a = 515156, b = 451456, c = 0; c = a*b; }
void callIntDiv() { int a = 515156, b = 451456, c = 0; c = a/b; }
void callIntMod() { int a = 515156, b = 451456, c = 0; c = a%b; }
void callIntAnd() { int a = 515156, b = 451456, c = 0; c = a&b; }
void callIntOr() { int a = 515156, b = 451456, c = 0; c = a|b; }
void callIntXor() { int a = 515156, b = 451456, c = 0; c = a^b; }

void callFloatDeclare() { float a = 515156, b = 451456, c = 0; }
void callFloatAdd() { float a = 515156, b = 451456, c = 0; c = a+b; }
void callFloatSub() { float a = 515156, b = 451456, c = 0; c = a-b; }
void callFloatMul() { float a = 515156, b = 451456, c = 0; c = a*b; }
void callFloatDiv() { float a = 515156, b = 451456, c = 0; c = a/b; }
void callFloatMod() { float a = 515156, b = 451456, c = 0; c = fmod(a, b); }

void callDoubleDeclare() { double a = 515156, b = 451456, c = 0; }
void callDoubleAdd() { double a = 515156, b = 451456, c = 0; c = a+b; }
void callDoubleSub() { double a = 515156, b = 451456, c = 0; c = a-b; }
void callDoubleMul() { double a = 515156, b = 451456, c = 0; c = a*b; }
void callDoubleDiv() { double a = 515156, b = 451456, c = 0; c = a/b; }
void callDoubleMod() { double a = 515156, b = 451456, c = 0; c = fmod(a, b); }

int main()
{
    const int loop = 5;
    clock_t start = clock();
   
    printf("Show error:\n");
    for(int e=0; e<5; e++) {
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callVoid();
    printf("void: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock(); }
   
    printf("\n(int)\n");
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntDeclare();
    printf("declare: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntAdd();
    printf("add: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntSub();
    printf("sub: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntMul();
    printf("mul: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntDiv();
    printf("div: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntMod();
    printf("mod: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntAnd();
    printf("and: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntOr();
    printf("or: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callIntXor();
    printf("xor: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
   
    printf("\n(float)\n");
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callFloatDeclare();
    printf("declare: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callFloatAdd();
    printf("add: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callFloatSub();
    printf("sub: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callFloatMul();
    printf("mul: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callFloatDiv();
    printf("div: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callFloatMod();
    printf("mod: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
   
    printf("\n(double)\n");
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callDoubleDeclare();
    printf("declare: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callDoubleAdd();
    printf("add: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callDoubleSub();
    printf("sub: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callDoubleMul();
    printf("mul: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callDoubleDiv();
    printf("div: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
    for(int i=0; i<loop; i++) for(unsigned long t=0; t<0xFFFFFFF; t++) callDoubleMod();
    printf("mod: %f\n", ((float)clock() - start) / CLOCKS_PER_SEC); start = clock();
   
    return 0;
}

On remarqueras donc qu'il est largement préférable d'utiliser le type float plutôt que le double, lorsque l'on a pas besoin d'une précision extraordinaire (le float étant déjà bien précis).
J'utilise d'ailleurs le type float dans mon système de particule, et j'arrive a des résultats qu'on ne saurais différencier si c'était avec des type double.
Le float étant donc 2x plus léger que le double, et surtout près de 2x plus rapide, voir 3x plus rapide pour les divisions !
(On comprend maintenat pourquoi GM est lent Yum! )

_________________
[Benchmark] Qui qui a la plus petite ? Runningpotato1[Benchmark] Qui qui a la plus petite ? TvF6GED [Benchmark] Qui qui a la plus petite ? MdetltS
Revenir en haut Aller en bas
Contenu sponsorisé




[Benchmark] Qui qui a la plus petite ? Empty
MessageSujet: Re: [Benchmark] Qui qui a la plus petite ?   [Benchmark] Qui qui a la plus petite ? Empty

Revenir en haut Aller en bas
 
[Benchmark] Qui qui a la plus petite ?
Revenir en haut 
Page 1 sur 1

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
Forum Le CBNA :: Développement :: Programmation-
Sauter vers: