BENCHMARK C++ vs JAVA...

Pourquoi un autre benchmark

En informatique, les comparaisons sont légion. Qui ne connait pas les guerres Intel vs Amd, Nvidia vs ATI, Windows vs Linux. Les langages de programmation n'y échappent pas. On appose malheureusement souvent qu'un langage est lent après avoir fait quelques tests très ciblés, ce qui n'est souvent pas très représentatif d'un logiciel courant. Le but de ce test est de comparer le code généré par la JVM de Sun, gcc et gcj. Le code sera généré en version optimisée et non optimisé afin de voir ce qu'il peuvent apporter au niveau des performances.

Nous allons utiliser deux versions de Java dont la toute dernière, Java 1.5.
Il n'est pas rare de lire ou d'entendre que Java est lent, que le C++ c'est meilleur... Souvent ce faux préjugé provient d'une application Java GUI qu'on a vue fonctionner. La réactivité n'était pas au rendez-vous... Depuis, de grands changements sont survenus. Le JIT est apparu. JIT signifie just in time compiler. Le JIT prend le fichier *.class généré par la commande Java et compile en natif pour la plateforme utilisée. Cette astuce permet d'avoir de bien meilleures performances. Des outils de développement tel que Intellij, Sun Java creator ou JBuilder sont fait en Java et n'ont pu grand-chose à envier au autre application graphique. Il y a même une version de Quake 2 qui est faite en Java. Il ne faut pas oublier que la vitesse ce n'est pas tout, la facilité de développement est primordiale de nos jours.

Détail de la machine de test

Cpu	Athlon xp 1800+
Carte mère	ECS K7VMM
Mémoire vive	512 meg
Système d'exploitation	Suse Linux 9.1
Système de fichier	Ext3

Information des tests

Les tests réalisés ont été faits à partir des sources disponibles à JavaBench Ces tests comparativement à d'autres sur le net ont l'avantage de toucher à diverses fonctionnalités du langage. Ils vont beaucoup plus loin que ceux qu'on a pu retrouver chez osnews. Leurs tests ne faisaient qu'effectuer des opérations mathématiques sur divers type de donnée, ce qui est très peu pour déterminer les performances d'un langage.

Ackermann

Ackermann est une fonction mathématique. Elle croît plus rapidement qu'une fonction exponentielle. Son implémentation est récursive. Les appels de fonctions sont donc testés.

Fibo

Fibonacci est la fonction très connue en mathématique : F(i)=F(i-1)+F(i-2)...

Hash et Has2

Ces deux fonctions de hachage

Heapsort

Heapsort est le trie qui a une complexité de O (n log(n). Il est donc efficace.

Matrix

Ce test effectue des calculs de matrice.

Methcall

Ce test effectue de nombreux appels de méthode à des classes.

Nestedloop

Ce test est constitué de diverse boucle imbriquée.

Objinst

Ce test instancie de nombreux objets.

Random

Ce test génère des nombres aléatoires

Sieve

Enlève les multiples dans un tableau.

Strcat

Concatène des chaînes de caractère

Wc

Les mots sont comptés.

Protocole

Les tests en C++ ont été compilés avec g++ (GCC) 3.3.3 (SuSE Linux). La version de Java java version 1.4.2_03 et java 1.5. GCJ a aussi été utilisé.
En g++, nous avons compilé les fichiers comme:

g++ [test].cpp -O2 -march=i386 -o [test]-386
g++ [test].cpp -O2 -march=i686 -o [test]-686
g++ -O2 -funroll-all-loops -fomit-frame-pointer -ffast-math -march=i686 -mfpmath=sse [test].cpp -o [test]

En utilisant O3 les résultats étaient souvent inférieurs. L'emploi de l'architecture Athlon au lieu de i686 n'a pas d'impact significatif sur les résultats.
En java, nous avons compilé les fichiers de cette façon :

javac -O [test].java

Les programmes java ont été exécuté en version cliente et serveur.

java [test]
java -server [test]

Des tests ont été fait afin de voir les performances des programmes Java en natif à l'aide du compilateur gnu.

gcj -O2 -march=i686 --main=[test] -o [test] [test].java
gcj -O2 -fomit-frame-pointer -ffast-math -march=i686 -mfpmath=sse  --main=[test] -o [test] [test].java

Paramètre pour chacun des programmes

Ackermann	13
Hash2	3000
Matrix	100000
Objinst	100000000
Strcat	10000000
Hash	3000000
Methcall	1000000000
random	300000000
fibo	45
heapsort	10000000
Nestedloop	45
Sieve	100000

Prenez note que le programme wc doit être exécuté de cette façon: wc < [nom_fichier]. Les crochets ne doivent pas être mis. Le fichier utilisé contenant 5 millions de lignes.

Tableau des résultats

	C++	C++ i686	C++ i686 optimisé	Java	Java -server	Java 1.5	Java 1.5 -server	GCJ	GCJ optimisé
Ackermann	138640	99280	78140	n/d	24586	n/d	24551	269725	258282
Hash2	16770	17410	15980	*24634	*29840	17811	15825	29798	28967
Matrix	17950	14010	8320	32228	24459	32228	24459	40102	30471
Objinst	23220	23170	22600	15888	15854	17718	17122	45400	43617
Strcat	1620	1140	1600	*3511	*4235	3504	3199	4708	5425
Hash	16010	15380	15470	32300	30839	32126	28182	43297	41307
Methcall	22350	14260	11880	21909	2836	21148	2962	28734	22605
random	13330	6000	4870	40261	24129	44447	29137	30494	24567
fibo	35150	28260	22950	24617	18544	31874	18957	70203	61609
heapsort	31020	30170	30270	*32842	*30512	32474	32302	34865	34032
Nestedloop	12380	11740	2610	29388	29813	35959	23834	13631	15814
Sieve	13370	11740	12430	14736	13557	16898	15000	10413	10221
Wc	1220	1250	1260	1260	1110	1685	1238	3714	3627
Total	343030	273810	228380	273574	250314	287872	236768	625084	579544

Une * affiché à côté des tests signifit que le paramètre -Xmx256M ou -Xmx512M a été ajouté à l'exécution. N/D signifie que le test a échoué

Analyse des résultats

Java réussit assez bien pour un langage qu'on dit souvent lent. Ses résultats sont souvent similaires à ceux obtenus à ceux en C++. Les diverses optimisations que Sun a apportées à sa JVM depuis ses débuts sont très bonnes. Qui aurait pu prévoir de tel résultat il y a 5 ans?

Même si Java ne gagne pas tous les tests, il reçoit une note globale très satisfaisante. Le résultat final n'est pas vraiment important. L'essentiel est de remarquer que les performances de Java se sont grandement améliorées. Les performances de Java actuellement sont parfois supérieures à celle de C++ et d'autre fois inférieure. Sans les problèmes de récursion éprouvé par gcc et gcj, leurs résultats globaux seraient encore meilleurs. Le test random et matrix a été pénalisants pour le java.

Gcc semble avoir des problèmes avec la récursion. J'ai été grandement surpris de la faiblesse de leurs résultats. J'ai exécuté les tests à quelques reprises. Les deux tests Java (exécuté sans le paramètre serveur) ont échoué le test, ils n'ont pu le finir. La version i686 du programme est vraiment beaucoup plus rapide que la version sans optimisation. Pas loin de 40 secondes les sépares.

Les versions du logiciel en Java 1.5 obtiennent de bien meilleurs résultats que la précédente version. Un Iterator est utilisé, Sun les aurait semble t'il améliorer. Leurs résultats sont semblables à ceux obtenus en C++.

Les versions C++ sont bon premier. Les exécutions serveur de Java gagnent plus de 10 secondes sur la version 10. La façon de calculer ligne, colonne pénaliserait'elle Java? La version optimisée de GCJ permet d'économiser plus de 10 secondes sur celle moins optimisée. GCJ fait pâle figure avec ses 40 secondes. Étant compilée en natif, sa performance devrait être beaucoup plus près du C++.

Java sort grand gagnant de ce test. Les versions serveur obtiennent les premières places. C++ n'est pas loin dernière. GCJ obtient encore un résultat déplorable.

Les versions C++ gagnent, les autres sont 2,5 à 4 fois plus lent.

C++ est encore le plus rapide dans ce test.

Les résultats des versions serveur de Java sont vraiment incroyable. Les autres sont loin derrière. La jvm doit faire une optimisation vraiment spéciale pour arriver à de tels résultats.

La compilation i686 permet d'être deux fois plus rapides que la version i386 ce qui n'est pas négligeable. Java ne réussit pas trop mal en mode serveur. La version client n'obtient pas d'aussi bon résultat. GCJ est entre les deux.

Tel que mentionné plutôt, étant donnée la récursion utilisée, on pouvait déjà prévoir que Java obtiendrait de bons résultats. L'activation du mode serveur fait gagner quelques secondes sur le mode client. Encore une fois, l'optimisation i686 gruge quelques secondes à son confrère. Les résultats obtenus avec GCJ sont catastrophiques.

Les résultats sont tous similaires, une version récursive aurait peut-être permis à Java de se démarquer.

GCJ obtient enfin de bons résultats, suivent ensuite les versions C++. Java 1.5 en mode serveur réussi à surpasser le mode client et Java 1.4.

GCJ gagne, il réussi à battre les versions du programme en C++.

Mis à part GCJ, les résultats sont similaire.

Nous avons vu que Java 1.5 n'apportait pas de grande révolution au niveau des performances. Le mode serveur en Java 1.5 demeure comme dans sa version précédente, plus rapide que le mode client. GCJ semble avoir quelques lacunes, il est compilé en natif, mais obtiens souvent des résultats inférieurs à Java. Les possibilités d'optimisation qu'offre le compilateur gnu peuvent s'avérer intéressantes dans certains cas.

Les fichiers sources ainsi que les fichiers nécessaires pour compiler et exécuter les programmes sont disponibles ici.

DÉBUTER AVEC CVS

CVS est un système de gestion de fichiers. Il permet de travailler à plusieurs lors d'un développement. Cet outil conserve toutes les révisions apportées au fichier. Il est donc possible de revenir sur une version d'un fichier en particulier. Les sources sont situées sur un serveur. Les développeurs prennent ces sources et les téléchargent afin de pouvoir travailler localement. Ils peuvent ensuite mettre à jour les fichiers se trouvant sur le serveur. Les conflits pouvant survenir sont gérés en partie par CVS. CVS doit être installé avant de pouvoir effectuer les exemples de ce tutoriel.

Préparation

Nous utiliserons les sources de qemu dans cet exemple. Télécharger les sources de qemu et décompressé les. Nous tenons compte ici que les sources sont dans le répertoire qemu. Si aucun repository n'a été créé pour le serveur cvs, il faut en définir un. S'il a déjà été défini, la commande ci-dessus n'endommagera pas le système actuel. Cette commande doit être faite sur le serveur.

cvs -d /opt/cvsroot init

Variable d'environnement

Nous devons maintenant créer une variable d'environnement afin de faciliter l'utilisation de cvs. Ajouter dans le fichier .bashrc de l'usager:
La commande ci-dessus permet de se connecter à un serveur distant.

export CVSROOT=:pserver:ing@linux-sv1:/opt/cvsroot

ing étant le nom du compte de l'usager
linux-sv1 étant le nom du serveur
Le serveur cvs est situé dans: /opt/cvsroot
En terme cvs, /opt/cvsroot est le repository
Au lieu d'utiliser un serveur distant, il est possible d'utiliser un serveur local

export CVSROOT=/opt/cvsroot

Ces valeurs doivent bien sûr être adaptées à votre environnement. Chaque répertoire à la racine du repository est appelé un module.

Type de connexion

Notez qu'il y a diverses techniques pour se connecter à un serveur cvs. Il est possible d'utiliser ssh, pserver, rsh. L'utilisation de pserver n'est pas très sécuritaire, car le mot de passe est envoyé en clair lors de la tentative de connexion.

Commandes cvs

Import

Nous allons maintenant prendre les sources de qemu et les transférer sur le serveur cvs.

ing@ti-engetud-pc:~> cvs import qemu GY start

GY est utilisé comme nom de vendeur est start est utilisé pour spécifier que c'est la première version. Si aucun problème n'est survenu, un message similaire à : No conflicts created by this import devrait être affiché dans la console.

Checkout

De retour dans le répertoire de l'usager nous allons prendre les sources du serveur et les transférer dans son répertoire. L'usager travaillera donc toujours en local sur les fichiers au lieu d'utiliser directement les fichiers sur le serveur. Si le répertoire de source de qemu était au départ dans ce répertoire, effacez-le.

ing@ti-engetud-pc:~> cvs checkout qemu

Cette commande copie les sources du projet qemu du repository spécifié dans la variable d'environnement mentionné plutôt dans le répertoire courant. Il est possible d'utiliser la compression, il suffit d'ajouter z et un chiffre.

ing@ti-engetud-pc:~> cvs -z4 checkout qemu

Dans chaque répertoire se trouvant dans les sources, un répertoire nommé CVS est créé. Ne touchez pas à ce répertoire, il est utilisé par CVS.

Diff et update

Si plusieurs personnes ont accès au source, il est possible que depuis que vous avez pris les sources que certain fichier est été modifié. Nous allons maintenant vérifier si les fichiers local sont à jour par rapport au serveur.

ing@ti-engetud-pc:~> cvs diff -D now qemu

Si les fichiers étaient déjà à jour, vous devriez avoir un message similaire à:

cvs diff: Diffing qemu
cvs diff: Diffing qemu/hw
cvs diff: Diffing qemu/linux-user
cvs diff: Diffing qemu/linux-user/arm
cvs diff: Diffing qemu/linux-user/i386
cvs diff: Diffing qemu/linux-user/ppc
cvs diff: Diffing qemu/linux-user/sparc
cvs diff: Diffing qemu/pc-bios
cvs diff: Diffing qemu/slirp
cvs diff: Diffing qemu/target-arm
cvs diff: Diffing qemu/target-arm/nwfpe
cvs diff: Diffing qemu/target-i386
cvs diff: Diffing qemu/target-ppc
cvs diff: Diffing qemu/target-sparc
cvs diff: Diffing qemu/tests

Nous effaçons le répertoire target-ppc et le fichier ppc.ld sur le serveur. Si vous regardez sur le serveur, ppc.ld a été modifié en ppc.ld,v.

ing@ti-engetud-pc:~> cvs diff -D now qemu
cvs diff: Diffing qemu
cvs diff: Diffing qemu/hw
cvs diff: Diffing qemu/linux-user
cvs diff: Diffing qemu/linux-user/arm
cvs diff: Diffing qemu/linux-user/i386
cvs diff: Diffing qemu/linux-user/ppc
cvs diff: Diffing qemu/linux-user/sparc
cvs diff: Diffing qemu/pc-bios
cvs diff: Diffing qemu/slirp
cvs diff: Diffing qemu/target-arm
cvs diff: Diffing qemu/target-arm/nwfpe
cvs diff: Diffing qemu/target-i386
cvs diff: Diffing qemu/target-ppc
cvs diff: cannot open directory /opt/cvsroot/qemu/target-ppc: No such file or directory
cvs diff: skipping directory qemu/target-ppc
cvs diff: Diffing qemu/target-sparc
cvs diff: Diffing qemu/tests

Le répertoire target-ppc n'est pas effacé sur le poste local. CVS ne prend pas en compte les répertoires. Rien n'avise qu'un fichier a été effacé.
Nous allons maintenant voir ce qui arrive si un fichier a été mis à jour sur le serveur. Nous imaginons ici qu'une autre personne a modifié le fichier a.out.h. Le début du fichier était:

/* a.out.h

 Copyright 1997, 1998, 1999, 2001 Red Hat, Inc.

et est maintenant

/* a.out.h

 Copyright 1997, 1998, 1999, 2001, 2004 Red Hat, Inc.

Nous allons voir maintenant voir la différence entre les deux fichiers.

ing@ti-engetud-pc:~> cvs diff -D now qemu
cvs diff: Diffing qemu
Index: qemu/a.out.h
===================================================================
RCS file: /opt/cvsroot/qemu/a.out.h,v
retrieving revision 1.2
retrieving revision 1.1.1.1
diff -r1.2 -r1.1.1.1
3c3
< Copyright 1997, 1998, 1999, 2001, 2004 Red Hat, Inc.
---
> Copyright 1997, 1998, 1999, 2001 Red Hat, Inc.
cvs diff: cannot find revision control file for qemu/ppc.ld
cvs diff: Diffing qemu/hw
cvs diff: Diffing qemu/linux-user
cvs diff: Diffing qemu/linux-user/arm
cvs diff: Diffing qemu/linux-user/i386
cvs diff: Diffing qemu/linux-user/ppc
cvs diff: Diffing qemu/linux-user/sparc
cvs diff: Diffing qemu/pc-bios
cvs diff: Diffing qemu/slirp
cvs diff: Diffing qemu/target-arm
cvs diff: Diffing qemu/target-arm/nwfpe
cvs diff: Diffing qemu/target-i386
cvs diff: Diffing qemu/target-ppc
cvs diff: cannot open directory /opt/cvsroot/qemu/target-ppc: No such file or directory
cvs diff: skipping directory qemu/target-ppc
cvs diff: Diffing qemu/target-sparc
cvs diff: Diffing qemu/tests

CVS nous indique à l'aide du mot index, le fichier qui a été modifié. Les changements entre notre version et celle disponible sur le serveur sont aussi affichés.
La commande diff nous a indiqué qu'il y avait un fichier plus récent sur le serveur. Nous allons effectuer la mise à jour.

ing@ti-engetud-pc:~>cvs update qemu
cvs update: Updating qemu
P qemu/a.out.h
cvs update: qemu/ppc.ld is no longer in the repository
cvs update: Updating qemu/hw
cvs update: Updating qemu/linux-user
cvs update: Updating qemu/linux-user/arm
cvs update: Updating qemu/linux-user/i386
cvs update: Updating qemu/linux-user/ppc
cvs update: Updating qemu/linux-user/sparc
cvs update: Updating qemu/pc-bios
cvs update: Updating qemu/slirp
cvs update: Updating qemu/target-arm
cvs update: Updating qemu/target-arm/nwfpe
cvs update: Updating qemu/target-i386
cvs update: Updating qemu/target-ppc
cvs update: cannot open directory /opt/cvsroot/qemu/target-ppc: No such file or directory
cvs update: skipping directory qemu/target-ppc
cvs update: Updating qemu/target-sparc
cvs update: Updating qemu/tests

Le fichier a.out.h local a été mis à jour.

Suppression

Dans le répertoire de qemu local, nous effaçons le fichier sparc.ld Ensuite ce changement va être apporté au serveur cvs.

ing@ti-engetud-pc:~/qemu> cvs remove sparc.ld

cvs remove: scheduling `sparc.ld' for removal
cvs remove: use 'cvs commit' to remove this file permanently

Lors du prochain commit, le fichier sparc.ld sera effacé sur le serveur.

Ajout

Créons un fichier info.txt en local. Son contenu sera: ceci est un test. Nous allons maintenant l'ajouter au serveur cvs.

ing@ti-engetud-pc:~/qemu> cvs add info.txt
cvs add: scheduling file `info.txt' for addition
cvs add: use 'cvs commit' to add this file permanently

Commit

La commande commit doit être effectuée afin que les changements soient apportés au serveur.

ing@ti-engetud-pc:~> cvs commit qemu
cvs commit: Examining qemu
cvs commit: Examining qemu/hw
cvs commit: Examining qemu/linux-user
cvs commit: Examining qemu/linux-user/arm
cvs commit: Examining qemu/linux-user/i386
cvs commit: Examining qemu/linux-user/ppc
cvs commit: Examining qemu/linux-user/sparc
cvs commit: Examining qemu/pc-bios
cvs commit: Examining qemu/slirp
cvs commit: Examining qemu/target-arm
cvs commit: Examining qemu/target-arm/nwfpe
cvs commit: Examining qemu/target-i386
cvs commit: Examining qemu/target-ppc
cvs commit: Examining qemu/target-sparc
cvs commit: Examining qemu/tests

Log message unchanged or not specified
a)bort, c)ontinue, e)dit, !)reuse this message unchanged for remaining dirs
Action: (continue)
RCS file: /opt/cvsroot/qemu/info.txt,v
done
Checking in qemu/info.txt;
/opt/cvsroot/qemu/info.txt,v > info.txt
initial revision: 1.1
done
Removing qemu/sparc.ld;
/opt/cvsroot/qemu/sparc.ld,v >-- sparc.ld
new revision: delete; previous revision: 1.1.1.1
done

Noter la présence au début des commandes abort, continue, edit... Nous allons effectuer la commande par défaut: continue. L'ajout du fichier info.txt et la suppression du fichier sparc.ld à été faite.

Gestion des révisions

Les différentes versions de logiciel sont notées par un chiffre. Certaines versions peuvent être plus significatives que d'autre. Un nom peut leur être attribué avec cvs. On appose une étiquette au projet.

ing@ti-engetud-pc:~> cvs rtag pre_alpha qemu
cvs rtag: Tagging qemu
cvs rtag: Tagging qemu/hw
cvs rtag: Tagging qemu/linux-user
cvs rtag: Tagging qemu/linux-user/arm
cvs rtag: Tagging qemu/linux-user/i386
cvs rtag: Tagging qemu/linux-user/ppc
cvs rtag: Tagging qemu/linux-user/sparc
cvs rtag: Tagging qemu/pc-bios
cvs rtag: Tagging qemu/slirp
cvs rtag: Tagging qemu/target-arm
cvs rtag: Tagging qemu/target-arm/nwfpe
cvs rtag: Tagging qemu/target-i386
cvs rtag: Tagging qemu/target-sparc
cvs rtag: Tagging qemu/tests

L'arborescence de qemu va être recréée en local. Nous allons mettre cette version nommée pre_alpha dans un nouveau répertoire.

ing@ti-engetud-pc:~> mkdir tmp
ing@ti-engetud-pc:~> cd tmp
ing2@ti-engetud-pc:~/tmp> cvs export -r pre_alpha qemu

Cette version est maintenant appelée pre_alpha. Nous pouvons par exemple voir les changements qu'il y a avec cette version et celle du serveur.

ing@ti-engetud-pc:~> cvs diff -r pre_alpha qemu

Nettoyer

Il est possible d'enlever ce que nous avons fait en local et de mettre à jour les fichiers du serveur si nécessaire.

ing@ti-engetud-pc:~>cvs release -d qemu

Ignorer des types de fichiers

CVS ignore les fichiers ayant l'extention .old, .bak, .obj... Il est possible d'ajouter d'autre type de fichier. Il suffit de créer un fichier .cvsignore dans le répertoire racine de l'usager

*.bat
!.bak

Les fichiers de type bat ne sont plus pris en compte, mais les fichiers de type bak sont maintenant pris en compte.

CHANGEMENT

Il est possible de voir les différents changements apportés à un fichier. Nous voyons ci-dessous différentes informations à propos d'un fichier. La date, version et auteur qui a apporté un changement. Chaque fois qu'un commit est faite, une autre révision du fichier est faite.

ing@ti-engetud-pc:~/qemu> cvs log oss.c

RCS file: /opt/cvsroot/qemu/oss.c,v
Working file: oss.c
head: 1.1
branch: 1.1.1
locks: strict
access list:
symbolic names:
 pre_alpha: 1.1.1.1
 start: 1.1.1.1
 GY: 1.1.1
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
----------------------------
revision 1.1
date: 2004/10/07 15:15:40; author: engcoop2; state: Exp;
branches: 1.1.1;
Initial revision
----------------------------
revision 1.1.1.1
date: 2004/10/07 15:15:40; author: engcoop2; state: Exp; lines: +0 -0

CONFLITS

Lorsque plusieurs personnes ont accès à un projet sur un serveur cvs, il peut survenir des conflits. Il suffit d'imaginer que deux ou plusieurs personnes modifient le même fichier. CVS va joindre les changements ensemble. Si c'est les mêmes lignes qui ont été modifiées, cvs demandera de résoudre ce conflit. Ce type de problème n'est heureusement pas courant.
Nous avons vu rapidement comment n'ont pas été abordé. Néanmoins, les commandes montrées vous permettent aisément de gérer vos sources et de participer à des projets sur le Web.

INTRODUCTION

Nous allons montrer rapidement la base de Bash afin de pouvoir rapidement commencer à écrire des scripts simples. Nous verrons les concepts présentés plus en détail dans d'autres tutoriels

Commentaire

#Ceci est un commentaire

Variable

#!/bin/bash
nombre=69
chaine="bash"

echo $nombre  #affiche 69
echo $chaine  #affiche bash

69
bash

Condition

#!/bin/bash
os1="linux"
os2="mac"
if [ "$os1" = "$os2" ]; then
 echo "il y a des ressemblances entre ces os"
else
 echo "ces os ne se ressemblent pas"
fi

ces os ne se ressemblent pas

Boucle

Le for est différent des autres langages.

#!/bin/bash
nb="12 13"
for i in $nb; do
  echo item: $i
done

item: 12
item: 13

On va itérer autant de fois qu'il y a d'éléments dans la string.

#!/bin/bash
for i in `seq 1 5`
do
      echo $i
done

1
2
3
4
5

Attention les caractères sont important si vous mettez ' au lieu de ` , vous allez obtenir: seq 1 10
Cette syntaxe permet d'avoir un résultat similaire au langage 10. Les chiffres de 1 à 10 seront affichés.

while
i=0
j=5        
while [ "$i" -lt "$j" ] # tant que i < j
do
  echo "$i"
  i=`expr $i + 1`
done

0
1
2
3
4

#!/bin/bash
i=0
j=5
while [ "$i" -lt "$j" ]
do
  echo "$i"
  i=`expr $i + 1`
done

0
1
2
3
4

#!/bin/bash
i=0
j=5        
while [ "$i" != "$j" ]
do
  echo "$i"
  i=`expr $i + 1`
done

0
1
2
3
4

#!/bin/bash 
FIN=okeefe
until [ "$var1" = "$FIN" ]
do
  echo "($FIN to exit)"
  read var1
done

#!/bin/bash 
COUNTER=15
until [  $COUNTER -lt 10 ];do
   echo COUNTER $COUNTER
   COUNTER=`expr $COUNTER - 1` # peut aussi utiliser: let COUNTER+=1
done

COUNTER 15
COUNTER 14
COUNTER 13
COUNTER 12
COUNTER 11
COUNTER 10

Notez qu'il est possible de mettre le mot: do sur la même ligne que le for, until, while. Il faut alors mettre un ; à la fin de la condition et ensuite on met le do. Cette syntaxe est plus compacte.

case

#!/bin/bash

echo "Appuyer sur une touche et ensuite sur enter."
read Keypress

case "$Keypress" in
  [a-z]   ) echo "Vous avez taper une lettre";;
  [A-Z]   ) echo "Vous avez taper une lettre";;
  [0-9]   ) echo "Vous avez taper un nombre";;
  *       ) echo "Autre";;
esac  

Si vous appuyez sur un chiffre vous obtiendrez

Vous avez tapé un nombre

Fonction

L'utilisation des fonctions est un peu différente sous Windows et Linux.

Windows et Linux

#!/bin/bash 
quit() { 
  echo "allo"
  exit 
}
quit

Linux

#!/bin/bash 
function quit {
  echo "allo" 
  exit 
}
quit

allo

La fonction exit permet de terminer le script.
Vous verrez plus souvent cette dernière syntaxe sous Linux. Nous utiliserons donc la syntaxe de Linux pour le reste des tutoriels.

BASH POUR WINDOWS

Un interpréteur de commande sert d'intermédiaire entre l'utilisateur et le système d'exploitation. Il permet de faire différentes tâches. Nous utiliserons Bash. Il en existe de nombreux autres sous Linux, Unix. C'est souvent le Shell par défaut sous Linux. Ce tutoriel permettra à ceux qui trouvent encore difficile de faire les quelques cliques de souris nécessaire pour l'installation de Linux, de pouvoir utiliser bash sous Windows.

Téléchargement de bash

Il est possible de se procurer bash à Cygwin. Diverses informations se retrouvent sur ce site. Plusieurs conseils de configuration y sont dits, si vous désirez avoir un environnement le plus près possible de votre distribution Linux favorite. Cliquer sur . Le téléchargement du logiciel se fera.

 Installation

Une fois le téléchargement fini, cliquer sur le fichier setup.exe téléchargé. Cette fenêtre
apparaîtra

Cliquez sur next. Ensuite sélectionné la source d'installation, nous choisirons « Install from
 Internet ».

Sélectionner ensuite le lieu d'installation du programme, la permission d'utilisation et le type de fichier par défaut.

Spécifiez ensuite où les fichiers téléchargés d'Internet seront entreposés durant l'installation.

Choissisez le type de branchement Internet voulu.

Indiquer le lieu de la source de téléchargement voulue, habituellement une zone près de chez vous devrait être plus rapide.

Choisisez les paquets voulus, j'ai laissé ceux par défaut.

Les icones se créent sur votre bureau.

 L'installation est réussie.

Démarrez Bash en cliquant sur son icône .
Si tout à bien été installé, vous devriez avoir une fenêtre noir qui apparait

.
Vous pouvez maintenant exécuter des scripts bash. En tapant «help», vous avez une liste de commande existante. Nous allons afficher l'arborescence des fichiers de cygwin. Tapé «cd /» ensuite enter. Entrer la commande «ls -l», vous devriez voir une liste de répertoire très connu des utilisateurs Linux.
Dans une console bash, vous pouvez taper «mount» pour voir la liste des lecteurs disponibles. Par exemple pour aller sur le lecteur c, c'est habituellement cd /cygdrive/c. Vous pouvez par la suite naviguer dans votre lecteur tel que le vous feriez sous Dos ou Linux.

Premier scripts

Dans un éditeur texte, tapez ces commandes

#!/bin/bash
os="Windows"
nb=1
echo "Mon $nb script bash sous $os"

Sauvegardez votre fichier sous le nom script1.sh. Sous bash maintenant, rendez votre fichier exécutable. N'oubliez pas de votre rendre où que votre script se site.

chmod +x script1.sh

Maintenant pour exécuter votre script

./script1.sh

À l'écran vous allez voir:

Mon 1 scripts bash sous Windows

Assignez un éditeur texte tel que vim, notepad... au fichier script de bash.
Nous avons vu comment installer l'environnement cygwin sous Windows afin de pouvoir utiliser Bash. Quelques commandes ont été énumérées. Nous en verrons d'avantages dans les tutoriels à venir.

QEMU ET WINDOWS

QEmu émule un processeur. Il est donc possible d'y installer différents os tels que beos, dos, Windows. Ce programme peut s'avérer très utile pour utiliser un autre os et ses diverses applications sous Linux. Puisqu'il y a beaucoup d'émulation, il y a donc une perte de performance comparativement à l'utilisation du système d'exploitation en natif. Plus le processeur sera rapide et plus il y aura de mémoire vive, mieux seront les performances du système émulé. Un amd 1800+ avec 512meg de ram fait tourner convenablement Windows 98 se.

Nous installerons Windows 98 SE via qemu pour ce tutoriel. Vous pouvez suivre les mêmes instructions pour installer Windows XP, 2000... Si lors de l'installation de Windows 2000 vous avez un problème concernant que le disque est plein alors que c'est faux, démarrez qemu avec l'option: win2k-hack. Cette option est disponible dans la version 0.7.1

Préparation

Installez qemu via un rpm, deb ou les sources. Créez un répertoire où vous allez mettre Windows 98. Ici, nous allons le mettre dans le répertoire/home/collinm/win98se.

cd /home/collinm
mkdir win98se
cd win98se

Nous allons maintenant créer un disque dur virtuel. Ce disque dur sera en fait une image constituant un fichier. L'image sera de 1,9Go ce qui convient bien pour Windows ainsi quelques applications.

dd of=hd.img bs=2048 seek=1000000 count=0

Téléchargez une image de la disquette de Windows 98 SE ou de l'os que vous désirez installer. Plusieurs disquettes de démarrage sont disponible sur le site bootdisk.com.
Nous allons maintenant démarrer sur la disquette créée précédemment

qemu -m 32 -fda win98sec.img -hda hd.img -boot a

le m est pour spécifier la quantité de mémoire virtuelle hda est pour spécifier que le fichier est considéré, comme le premier disque dur.
Cette commande nous amène en dos

On doit maintenant créer une partition, nous allons utiliser la commande fdisk Si votre disque dur a une dimension de plus de 512 mb, vous obtiendrez l'image ci-dessous. Répondez positivement.

Ensuite, sélectionnez le choix 1

Allez dans la fenêtre de qemu et taper q afin de quitte qemu. Redémarrez qemu de la même façon que la première fois. Tapez format c:/s dans la fenêtre dos, répondez de façon affirmative à la question. Quittez de nouveau qemu

Démarrage de l'installation

Il est possible d'installer Windows via une image iso ou le cd. La deuxième solution peut ne pas fonctionner. Si vous désirez tenter cette solution, vous devez lancer qemu avec une syntaxe similaire à:

qemu -hda hd.img  win98sec.img -cdrom /dev/cdrom -boot d -m 64

Le cdrom ne doit pas être monté lorsque vous entrez cette commande. Nous allons utiliser l'autre solution. Créez une image iso de votre cd de Windows 98.

mkisofs -r -o /home/collinm/win98se/win98.iso /dev/cdrom

Nous démarrons l'installation via la commande:

qemu -hda hd.img -fda win98sec.img -cdrom win98.iso -boot a -user-net

entrez dans le lecteur cd à l'aide de la commande r: et tappez setup et ensuite appuyez sur enter

Une vérification du disque dur est faite à l'aide de scandisk. Si cette étape se déroule bien, la fenêtre graphique d'installation de Windows s'affiche.

Nous n’allons pas passez au travers de toutes les étapes de l'installation de Windows. Veuillez aller sur un site web qui traite de ce sujet si vous n' avez jamais fais ce genre d'installation. L'installation peut-être longue selon la puissance de l'ordinateur.Une fois l'installation de Windows terminée, vous retournerez en mode dos. Dans la fenêtre de qemu, quittez.

Démarrez qemu avec la syntaxe suivante:

qemu -hda hd.img -cdrom win98.iso -boot c -user-net

Notez qu'on ne démarre pas sur la disquette ou le cdrom

Option

Quelques options sont disponibles pour Qemu. Vous pouvez lancez qemu sans aucun argument pour les connaitre.

• -k langage Change la disposition du clavier (-k fr)
• -full-screen Démarre en mode plein écran
• -enable-audio Active le son (ne fonctionne pas toujours)

Vous allez devoir spécifier l'heure et la date.... Windows détectera vos périphériques, Windows est maintenant installé et fonctionnel. Il est possible d'utiliser des lecteurs cdrom avec qemu. Ils doivent cependant ne pas être montés sous l'os maitre (ici linux).

Partage de donnée

Il est possible de partager des données entre le système virtuel et le système natif. Il ya quelques possibilités. Le plus simple et le plus sûr est de créer un serveur ftp, serveur samba ou partager des fichiers via le web. Il y a aussi l'utilitaire QEMU-HD-Mount pouvant être trouvé sur le net. Cet utilitaire peut endommager votre partition virtuelle. Il y a donc un risque que vous perdiez votre système virtuel. Il n'y a cependant pas de danger pour votre système d'exploitation natif. Rendez-vous dans le répertoire où vous démarrez habituellement qemu. Connectez-vous en mode root et créez un répertoire pour pouvoir monter votre partition.

mkdir /mnt/qemu
lomount -t vfat -diskimage WIN98SEC.IMG -partition 1 /mnt/qemu

Soyez vigilant en utilisant cet utilitaire. Utilisez les autres méthodes si vous voulez être certain de ne pas endommager le système de qemu.

Introduction Delphi

Delphi est un outil de programmation orienté Windows et maintenant linux. Un peu comme Visual Basic, il est possible de créer des programmes Windows et linux très aisément. C'est un logiciel de développement de type rad (rapid application development).
Delphi est puissant et fiable, grâce à la vcl (virtual composent library), on n'a plus réellement besoin de se soucier des caractéristiques propre à Windows ou linux. On n'a qu'à se concentrer sur l'algorithme à développer. On peut à tout instant décider d'utiliser l'api au lieu de la vcl.

Delphi permet d'utiliser le basic, l'assembleur, les microsoft foundation classes(mfc). Comme on peut voir, il est très polyvalent. La vcl fournit de nombreux composants visuels et non-visuels dans de nombreux domaines : bases de données, communication, réseau, multimédia. Avec l'envolé d'internet, on retrouve de plus en plus de composant gratuit ou à peu de frais sur la toile.

Delphi utilise le pascal objet, qui a fait ses preuves depuis longtemps. Il surpasse dans certains domaines le langage c++. En somme, il possède la puissance du C++ avec la facilité du visual basic, ce qui constitue un rêve pour les programmeurs. Les fichiers exécutables de delphi nécessitent aucunement de bibliothèque supplémentaire enfin de fonctionner, ce qui augmente considérablement leurs vitesses d'exécution.
Delphi pour Windows en est rendu à sa 8 version, on a le choix entre 4 variantes de delphi:

• personnel
• professionnel
• entreprise
• architecte

Le standard étant amplement suffisant pour les besoins d'un programmeur débutant, les autres préféreront la version professionnelle.
Kylix est la version de Delphi et de bcb pour linux,ils sont offert en trois versions:

• Développement Serveur
• Développement Desktop
• Open Edition

La version open edition est offerte gratuitement en téléchargement, si vous voulez découvrir la puissance de delphi, n'hésitez pas à la télécharger.

Même si delphi facilite grandement la programmation, il faudra comme dans tout langage travailler fort enfin de devenir un excellent programmeur. On peut grâce à delphi 6, 7 et kylix développer une application qui fonctionnera sans trop de problème sous les deux systèmes d'exploitation.

Delphi 8 est orienté .NET, le pont avec Win 32 est brisé. Borland utilise le framework MS .Net.

Bonne programmation!

Bash

Ce livre offre un moyen de s'initier et s'améliorer sur le script bash. Les auteurs traitent des concepts de bases telle que les flux de donnée, les entrées/sorties, les options de la ligne de commande...

Des concepts plus avancés telle que la gestion de processus, administration du shell sont aussi passé en revue. Ils traitent même de l'édition en utilisation vi et emacs.

Beaucoup d'exemple y sont présenté même s'il manque d'exemple réelement utile. C'est un livre de référence pour quiconque désire se mettre au scrip sous linux.