Petit tests de la librairie C decimal (libmpdec)

Bonjour à tous et noyeux joel !

Pour commencer un petit bench de la librairie et le comparatif avec des float (double)

Un petit test que pourront apprécier ceux qui veulent connaître l'impact de l'utilisation des décimaux dans une machine classique.

Il est réalisable par tout un chacun en se rendant sur le site officiel pour obtenir la dernière version à cette adresse http://www.bytereef.org/mpdecimal/quickstart.html

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpdecimal.h>
int main()
{
 mpd_context_t ctx;
 mpd_t *a, *mul;
 double fa=1.01, fmul=1.000001;
 clock_t start_clock, end_clock;
 unsigned long long turns = 100000000;
 mpd_init(&ctx, 16);
 ctx.traps = 0;
 a = mpd_new(&ctx);
 mul=mpd_new(&ctx);
 mpd_set_string(a, "1.01", &ctx);
 mpd_set_string(mul,"1.000001",&ctx);
 start_clock = clock();
 for (unsigned long long u=0; u < turns; u++)
 {
 mpd_mul (a,a,mul,&ctx);
 }
 end_clock = clock();
 printf("Decimal time: %f\n",
 (double)(end_clock-start_clock)/(double)CLOCKS_PER_SEC);
 mpd_del(a);
 start_clock = clock();
 for (unsigned long long u=0; u < turns; u++)
 {
 fa*=fmul;
 }
 end_clock = clock();
 printf("Float time: %f\n %f\n",
 (double)(end_clock-start_clock)/(double)(CLOCKS_PER_SEC),fa); 
 return 0;
}

Le résultat est que la boucle numéro 1, prend en moyenne 43 fois plus de temps que la seconde qui fait la même chose pour les mêmes valeurs d'opérandes.

Vous trouverez sûrement, si vous testez, des ratios parfois inférieurs, parfois très supérieurs aussi (sur une autre machine c'est aux alentours de 70).

Pour comparer ce qui est comparable, j'ai, conformément à la doc de la librairie, initialisé le contexte à MPD_DECIMAL64 qui correspond à une taille des opérandes de 64 bits comme celle des double sur ma machine (64 bits) qui concerne la deuxième boucle. J'ai compilé avec -O2 dans les options de GCC.

Pourquoi utiliser un bench python faisant appel à une librairie C n'a aucun sens

Parce que la boucle python coûte plus cher que ce qu'on souhaite mesurer (environ 30 fois plus)!
Par contre, si on reste cohérent dans le bench, et qu'on fait du "full python" on retrouve le même ratio (obtenu avec la lib libmpdec) comme l'expérience a déjà été faite dans des posts au dessus.

Etait-ce prévisible ?

Bien évidemment, on se doute, que lorsque l'on remplace une seule instruction assembleur d'addition sur des flottants (qui prend maximum 2 cycles d'horloge FPU), par l'arsenal de cette lib, il devient évident, que la librairie décimale ne peut pas ne prendre que 4 cycles (rien que l'appel à mpd_add et les empilements que ça génère, coûte au moins 10 cycles)

Pourquoi on trouve des benchs qui semblent contradictoires sur le site de la lib

D'abord parce que dans les benchs proposés, les calculs sont noyés dans plein d'autres (exemple, le calcul du mandebrot et son algo d'échappement).
Et peut être aussi, parce que sinon c'est moins attractif (pour être taquin).

Conclusion

Je ne cherche à ridiculiser personne ici, je ne suis pas dans la guéguerre, j'interviens sur un sujet que je pense connaître assez, vu que c'est ma formation et accessoirement mon métier. Quand je dis que quelqu'un a des problèmes math, ça peut être tout simplement vrai et çe n'est pas pour autant que je méprise mon interlocuteur. A l'avenir, par contre, ça serait sympa de pas se faire traiter de con ou de guignol ou que sais-je encore, pour des raisons qui tiennent d'avantage de la lutte d'égo que de la recherche de ce qui est vrai ou faux.

Voilà, bonnes fêtes à tous, bons benchs pour les plus malades d'entre vous (!), et mangez pas trop d'huîtres mélangées au foie gras et au chocolat, c'est moyennement digeste :)