Cawen et le web

Une comparaison avec php

Dans cette page,

    • Vous allez tout d’abord pouvoir comparer en temps réel deux pages web. L’une est écrite en PHP et est exécutée par un serveur apache. L’autre, codée en Cawen, est traitée par un serveur mongoose.
    • Vous pourrez ensuite jeter un oeil aux scripts Cawen et PHP correspondants.
    • Nous présentons également les résultats obtenus grâce à siege, un simulateur de charge. Nous avons   soumis Cawen+mongoose et apache+php à un flot constant de 10 requêtes simultanées, pour un total de 10000 requêtes. Pour ce test, nous avons ajouté la solution Cawen + nxweb à la liste des concurrents.

Vous trouverez tout ce dont vous avez besoin pour exécuter notre maquette sur vos propres serveurs (source php et Cawen, code C généré, scripts shells de tests et fichiers de résultats bruts) dans cette archive : cwn_web_benchmark.tgz.

Votre maquette temps réel

Les principes du test

Les pages cawen+mongoose et php+apache réalisent le même traitement : elles enregistrent dans un fichier et affichent dans un seul graphique leur propre temps d’exécution ainsi que les temps d’exécution de la page concurrente. Une moyenne mobile est également calculée sur les deux séries de chiffres.

Les différents serveurs http tournent sur le même serveur :

ubuntu 3.5.0-17-generic / 5,4 Go / AMD E1-12000 APU / 64 bits / Cawen is compiled with gcc 4.7.2

Les temps d’exécution sont enregistrés dans deux fichiers qui sont propres à chaque connexion à la page courante et qui seront remis à zéro si vous la rafraîchissez. Le fichier des temps d’exécution du PHP(resp. Cawen) est écrit par le script PHP(resp. Cawen) et est lu par les deux serveurs.

Les données émises par apache et mongoose sont compressées avec zlib. Les temps d’exécution affichés ne prennent pas en compte la compression car elle a lieu après l’exécution de la dernière ligne du script php.

Avec les différents boutons mis à votre disposition, vous choisirez si les informations affichées doivent provenir des serveurs apache ou mongoose (vous devez obtenir des résultats identiques), si les requêtes doivent être émises à votre demande (“step by step”) ou automatiquement (“automatic”), ou encore si toutes les mesures ou seules les 256 plus récentes doivent être représentées.

La ligne bleu clair est le tracé des temps d’exécution de la page Cawen, la ligne bleu foncé, la moyenne mobile associée. Les lignes orange clair et foncé présentent les résultats du script PHP.

Conclusions du test

Peut-être n’avez vous pas eu une vue complète de la maquette temps réel (apache, mongoose ou notre serveur ont pu partir faire la sieste). Voici le type d’affichage que, nominalement, vous devez obtenir :

On peut noter que :

  • Dès le départ, la page Cawen nécessite des temps d’exécution bien inférieurs à ceux de PHP.  Cependant, au tout début du test, apache traite plus de requêtes par seconde que mongoose.
  • Contrairement à l’exécutable Cawen, le script PHP est extrêmement sensible à l’augmentation de la taille des données à traiter. Au bout de quelques centaines d’enregistrements seulement, mongoose + Cawen devient 20,30,40…etc fois plus rapide que apache + php.
  • Cet écart d’efficacité finit par avoir un impact sur le niveau de service : mongoose + cawen finissent par traiter plus de requêtes qu’apache + php et cet écart se creuse indéfiniment.

En résumé : dans le cadre de ce test, l’exécution de la page Cawen tend à solliciter plusieurs dizaines de fois moins le processeur que la page php.

Nous préciserons plus loin ces conclusions avec un test de charge, moins ludique mais sans doute plus pertinent.

Code source

Vous trouverez ici le code PHP.

Le fichier Cawen est consultable ici.

Quelques remarques sur le code Cawen présenté ci-dessus :

  • Le nombre de lignes est similaire à celui du source PHP.
  • Ce fichier Cawen ne contient que la partie fonctionnelle du serveur. La partie technique  (mongoose_interface.hwn) qui décrit la traduction de la partie fonctionnelle en fichiers C/mongoose compte 389 lignes.
  • Pour implémenter cette maquette avec un serveur embarqué xxx, dont la langue natale serait le C (nginx, nxweb …) ou pour créer des modules CGI, fast CGI, Zend etc.., il suffit de rédiger la partie technique correspondante xxx_interface.hwn et le fichier principal xxx.cwn : la partie fonctionnelle peut-être réutilisée telle quelle. C’est d’ailleurs ainsi que nous avons codé la solution Cawen + nxweb.
  • Veuillez noter la structure arborescente en ligne 102 et 158. Ici, elle est utilisée pour produire du HTML mais elle peut également grandement faciliter l’implémentation de n’importe quelle autre structure d’arbre ou n’importe quelle  fonctionnalité basée sur des étapes ouvertures/fermetures, début/fin, etc…
  • Notez également la directive #raw en ligne 141 qui permet de coder des transformations utilisateur portant sur des zones brutes du fichier source.
  • Le fichier fonctionnel Cawen (cwn_vs_php.hwn) qui compte 260 lignes génère un fichier C de  843 lignes.

Test de charge

La feuille de route de notre test de charge est la suivante : traiter 10000 requêtes (avec un débit de 10 requêtes simultanées) qui produisent le html correspondant à quatre jeux de données contenant respectivement 10, 100, 200 et 250 enregistrements. Cette fois, les fichiers des temps d’exécution sont seulement lus, ils ne sont plus écrits : 4 fichiers constants ont été préparés sur le serveur et sont exploités en boucle.

Nous avons mesuré l’évolution de la consommation mémoire , le pourcentage de CPU utilisé, la puissance électrique utilisée . Quant au nombre de requêtes par seconde, il est donné par siege à la fin de chaque test unitaire.

Déroulement du test

Les 3 serveurs HTTP ont été lancés et testés l’un après l’autre.

Le serveur tourne 30 secondes sans être sollicité / il traite 10000 requêtes de 10 enregistrements / pause de 30 sec / il traite 10000 requêtes de 100 enregistrements/ pause de 30 sec / il traite 10000 requêtes de 200 enregistrements/ pause de 30 sec / il traite 10000 requêtes de 250 enregistrements/ pause de 30 sec / le serveur est arrêté.

Consommation mémoire

Nous l’avons mesuré très simplement : en enregistrant la colonne “used” extraite du résultat de la commande “free”.

Utilisation du processeur

Nous avons enregistré les résultats d’une commande ps. Pour apache, nous avons sommé les chiffres obtenus pour chacun des différents processus.

Ci-dessousles progressions de l’utilisation du processeur par les trois différentes solutions. On notera les quatre pics correspondants aux quatre étapes du test.

Pour extraire un chiffre unique de chaque étape (correspondant à une phase particulière du test) de ces trois courbes, nous avons cherché un calcul standard qui prendrait en compte le fait qu’utiliser 10% du processeur pendant 10 secondes, ce n’est pas exactement la même chose qu’en utiliser 10% pendant une demi-heure. Comment pouvons-nous estimer le travail total dont chaque serveur HTTP a eu besoin pour traiter chaque phase du test ? Dans les résumés qui suivent, nous avons utilisé la valeur moyenne de l’utilisation du processeur, faute de mieux…

Courbes de puissance

Pour calculer l’énergie consommée par les différentes solutions, nous avons utilisé le module du Green Code Lab et son protocole.

A titre d’exemple, voici la courbe de puissance observée avec Cawen + nxweb. Les quatre étapes du test sont clairement identifiables.

Les résultats

Les graphes multi-axiaux suivants résument les observations pour chaque critère (en pourcentage des résultats de PHP + apache)

Ils sont extraits de ces résultats bruts :

TEST 10
APACHE
MONGOOSE
NXWEB
ENERGIE (mWh)
50,47
14,74 (div 3,4)
9 (div 5,6)
UTILISATION CPU (%)
61,97
5,16 ( div 12)
16,47 (div 3,7)
UTILISATION MEMOIRE (kb)
22245
2192 (div 10,1)
2424 (div 9,1)
TEMPS D’EXECUTION (sec)
70,34
210,23 (mul 2,9 )
15,51 ( div 4,5 )
TAILLE DU SOURCE (lignes)
267
242 (-9%)
242 (-9%)
TEST 100
APACHE
MONGOOSE
NXWEB
ENERGIE (mWh)
651,6
29,34 (div 22,2)
19,1(div 34,1)
UTILISATION CPU (%)
109,8
11,5 (div 9,5)
27,6 (div 4)
UTILISATION MEMOIRE (ko)
28688
3363 (div 8,53)
2544 (div 11,3)
TEMPS d’EXECUTION (sec)
330,25
50,29 (div 6,6)
33,7( div 9,8)
TEST 200
APACHE
MONGOOSE
NXWEB
ENERGIE (mWh)
2640,75
59,19 (div 44,61)
30,28(div 87,2)
UTILISATION CPU (%)
142,3
20,6 (div 6,9)
33,2 (div 4,2)
UTILISATION MEMOIRE(ko)
61515
4144 (div 14,8)
2620 (div 23,5)
TEMPS D’EXECUTION (sec)
1167,75
59,86 (div 19,5)
60,26( div 19,4)
TEST 250
APACHE
MONGOOSE
NXWEB
ENERGIE (mWh)
3862,9
68,77 (div 56,17)
35,44 (div 109)
UTILISATION CPU (%)
151,6
28,59 (div 5,3)
36,08(div 4,2)
UTILISATION MEMOIRE (ko)
63376
4794 (div 13,2)
2843 (div 22,3)
TEMPS d’EXECUTION (sec)
1710,83
68,77 (div 24,9)
65.22( div 26,2)

Cawen associé aux serveurs HTTP “légers” obtient de bien meilleurs résultats que PHP associé à apache, à l’exception d’une seule mesure :  le temps d’exécution de mongoose dans le test 10. Nous allons investiguer, car il est très surprenant que mongoose traite nettement moins vite 10000 requêtes de “taille 10″ que 10000 requêtes de “taille 100″.

Pour tous les autres cas, l’utilisation de Cawen et d’un serveur léger, de préférence à PHP et apache,  a permis de :

  • diviser au minimum par 3,4  et jusqu’à 109 la consommation électrique
  • diviser au minimum par 3,7 et jusqu’à 12 l’utilisation moyenne du processeur
  • diviser au minimum par 8,5 et jusqu’à 26,2 les temps d’exécution

Et ces résultats ont été obtenus avec un code 9% plus court que la page PHP de référence.

Remarques et reste à faire

Plutôt que deux langages (Cawen et php) nous avons comparé trois couples serveur http + langage, ce qui complique l’interprétation de nos résultats. Qui doit on applaudir, Cawen ou nxweb ? Nous n’avons pas utilisé Cawen avec des serveurs http plus efficaces qu’apache pour nous assurer que leurs associations gagnent la course, mais parce que tout serveur http efficace offre la possibilité de coder des pages web directement en C…

3 pistes restent à explorer pour améliorer la solution php + apache que nous présentons ici :

    • Nous avons utilisé la configuration apache par défaut, à deux exceptions près : nous avons positionné le paramètre KeepAliveTimeOut à 2 secondes et MaxKeepAliveRequests à 0 (illimité). Cette configuration peut certainement être améliorée, nous sommes ouverts à toutes propositions.
    • Nous n’avons pas utilisé d’accélérateur php. Peut-être aurons nous le temps un jour d’en tester quelques uns ?
    • Le code php lui-même peut sans doute être optimisé. Toute suggestion est la bienvenue.

Nous serions très heureux d’ajouter de nouveaux résultats à ce rapide aperçu. N’hésitez pas à nous envoyer vos propres solutions : mongoose + lua, python + nxweb, python + apache, CGI/FastCGI + apache etc….

A l’avenir, nous rassemblerons toutes nos expériences web dans cette page.

Conclusion

Mémoire, CPU, énergie : les solutions Cawen+nxweb et Cawen+mongoose sollicitent incroyablement moins les ressources du serveur que le duo  PHP + apache. Elles résistent également beaucoup mieux à la montée en charge.

Du point de vue du développeur, Cawen s’avère aussi concis que PHP. Certains raccourcis (le typage dynamique, par exemple) ne seront jamais implémentés par défaut dans Cawen qui s’honore d’être un outil de précompilation du C. Si bien que Cawen demandera toujours au débutant un meilleur niveau de connaissances et un peu plus d’effort pour produire une application que php, lua, python ou Java.

Mais une fois que l’on a assimilé quelques mécanismes simples, est-il plus facile d’écrire “< ?php echo "Hello world!"; php > ou @output(“Hello world!”); ? Rassurez-vous, nous ne lancerons pas de sondage sur le sujet…

Répondre

*


trois × 9 =

-Votre adresse ne sera pas visible-