Outils de construction pour la recherche

ENVOL - Outils de constructionformation pour le dEveloppemeNt et la ValOrisation des Logiciels en

environnement de rechercheOrganisation par le projet PLUME et les reseaux Calcul et DevLog

Johan Moreau

IRCAD

27 septembre 2010

Johan Moreau (IRCAD) ENVOL - Outils de construction 27 septembre 2010 1 / 98

Le document :

Cette presentation a ete faite avec des outils opensource et libre dansle but de presenter des outils de construction d’applications eux-aussiopensource.

N’hesitez pas a m’envoyer vos remarques ou corrections surjohan.moreau sur gmail.com

Ce document est distribue sous licence Creative CommonsAttribution-ShareAlike 2.0

La session :

Des sequences de slides emmelees avec des exemples de codes

Des questions (et je l’espere des reponses) a tout moment


Sommaire

Sommaire

Le but de cette presentation est de decouvrir les outils de constructiond’applications dans le contexte d’un laboratoire de recherche.

1. La construction d’application

2. Les GNU Autotools

3. CMake

4. SCons

5. QMake, MSBuild, Ant, Maven, ...

Conclusion


La construction d’application

1. La construction d’application



Sommaire


Quelques rappels et remarques

Les ”Makefile”

Les limitations et les solutions


La construction d’application Quelques rappels ...

Les processus de construction simple

On parle ici des logiciels permettant d’automatiser (ordonnancer et piloter)l’ensemble des actions (preprocesseur, compilation, editions des liens, etc.)contribuant, a partir de donnees sources, a la production d’un (ensemble)logiciel.Les termes anglais sont ”Software Build”1 ou ”Build automation”2.



Preprocesseur 3

Il s’agit d’une etape permettant des transformations sur un codesource.

Dans le monde C/C++, la commande du preprocesseur la plusrepandue est ”include” qui a pour but de recopier le contenu du fichierindique en parametre. (A noter la difference avec les ”package” enjava, import en Python et co)

On peut aussi utiliser le preprocesseur pour faire des ”macros” via”define” en C/C++ par exemple, de compilation conditionnelle, de lameta-programmation, etc ...

A noter que les conventions de codage demande souvent de limiterl’usage du preprocesseur (retours d’erreurs du compilateur)



Compilation 5

Il s’agit d’une etape traduisant un code d’un langage vers du code enlangage machine (reel ou virtuel)

Le langage machine est soit directement interprete par la machine soitinterprete par une ”machine virtuelle”4. Dans ce dernier cas on peutciter Java ou DotNet.

Les phases (traditionelles) :

analyses lexicale, syntaxique puis semantique,generation du code intermediaire puis optimisation,generation du code objet



Edition des liens 6

L’edition des liens est un processus qui permet de creer des fichiersexecutables ou des bibliotheques dynamiques ou statiques, a partir defichiers objets.



Un peu de compilation donc ... Exemple en C sous UNIX

Il faut deja organiser un peu ses fichiers, par exemplePour C/C++, speration des declarations et implementationsPour Java, regroupement par package...

Ensuite organiser son code :#ifdef DEBUG pour C par exemple (a activer sur la ligne decommande : gcc -DDEBUG=1 fichier.c)Pour Java, regroupement par package...

cc : Supprime les commentaires, effectue les inclusions et lesmacros,...

cc1 : Converti le code C en assembleur

as : Assemblage des fichiers assembleurs, genere les fichiers objets

ld : Determine les adresses memoires des symboles et lie les fichiersobjets entre eux



La construction dans le monde reel

Cette suite semble fixe et standard et donc totalement automatisable !Mais en realite :

Plusieurs langages avec chacun ses specificites

Des variantes dans les langages (gtk vs Qt par exemple)

Problemes du multiplateforme/architecture/distribution

Grand nombre de fichiers et de cibles

Il faut des outils pour assister le developpeur dans cette phase.



La construction d’applications C/C++

Cette presentation n’illustrera que les principes les plus courants de laconstruction d’applications C/C++

On ne parlera que tres peu des systemes embarques dans les IDE

On laissera les problemes lies aux compilateurs de cotes

On ne parlera que tres peu des outils/besoins post-compilation (testunitaires, ”packaging”, etc ...)



A long time ago, in a galaxy far far away... 9

Jusqu’a la fin des annees 70, les programmes etaient petits.

En 1977, le Dr Stuart I Feldman (Bell Labs) invente l’outil Make

L’outil rencontre un succes immediat.

En 1997, Peter Miller ecrit l’article : ”Recursive Make ConsideredHarmful”7.

Depuis de nombreux outils essayent d’ameliorer de processus 8.


La construction d’application Les ”Makefile”

La syntaxe du Makefile

Le fichier Makefile est compose de plusieurs regles de la forme :

cible : dependances

<TAB> commandes

cible : dependances

<TAB> commandes

Chaque commande est precedee d’une tabulation :

Makefile

prog : main.o functions .ogcc −o prog main.o functions .o

main.o : main.c functions .hgcc −c main.c

functions .o : functions .c functions .hgcc −c functions .c



Les evaluations de regles

Lors de l’utilisation de la commande ”make cible”

Evaluation de la regle dont la cible est passee en argument a make

Evaluation de la premiere regle rencontree (s’il n’y a pas d’argument)

Les dependances sont analysees

Si une dependance n’est pas a jour on tente de la resoudre

Si cette dependance est cible d’une autre regle du Makefile alors cetteregle est a son tour evaluee



Les cibles classiques

all

Generation de toutes les cibles

.PHONY

Les dependances de cette cible sont toujours regenerees

clean

Suppression des fichiers intermediaires

Mproper / distclean

”clean” + suppression des fichiers cibles



Les variables

Declaration de variables via NOM=VALEUR. Les variables traditionnelles :

CFLAGS : options du compilatuer C (CXXFLAGS pour C++)

LDFLAGS : options de l’editeur de liens

...

Les variables internes :

$@ : la cible

$< : la 1ere dependance

$ˆ : la liste des dependances

$* : le nom de la cible sans suffixe



Et plus encore ...

Les conditionnelles :

ifeq .... else .... endif

La recherche de dependances :

Utilisation de la variable VPATH/vpath (VPATH = src :../headers)

Les appels imbriques :

cd $(SRC DIR) && $(MAKE) $@


La construction d’application Les limitations et les solutions

Quels reproches au Make ancestral ?

Pas vraiment portable/multiplateforme : base sur des scripts shell etdes proprietes du systeme de fichiers. De plus les evolutions desdescandants (GNU Make, ...) ont des implementations particulierespour les fonctions manquantes (if-then-else par exemple).

Difficulte a monter en charge : L’evolution du code qui est necessairedans les gros projets s’articule souvent autour de changementd’arborescence ou de renommage de partie de code. Ceci entraine denombreux changements manuels dans les Makefile.

Le langage du Makefile ajoute une complexite qui n’a pas de raisond’etre. De plus il est relativement limite.

Les verifications d’evolutions de code sont superficielles.

Il n’y pas de systeme de detection implicite de dependances



































Ce qui a change aussi ...

Precedement :

Compiler votre codeFaire la liaison avec les librairies (statiques/dynamiques)Distribuer sous forme de sources ou de binaires

Maintenant, en plus :

Executer les tests unitaires (voir fonctionnels)Faire un ”Installeur” (msi, deb, rpm, installshield, ...)Gerer les problematiques d’internationalisationGenerer la documentation developpeur et utilisateur, les metriques, ...

A ceci s’ajoute une tendance depuis 2000 : l’integration continue



La notion d’integration continue 10

L’idee : verifier a chaque modification de code source que le resultat desmodifications ne produit pas de regression du logiciel (donc l’executable,mais aussi la documentation, les metriques, ...)Ceci implique donc une construction

rapide

flexible

standardisee (un minimum d’outils)

identique pour toutes les cibles (OS, architecture, ...)

A partir de la, nous pouvons imaginer la production de livrables, deversions journalieres(”nightly build”), des deploiements automatiques, lageneration automatique de l’historique (release notes), etc ...



Evolution forte au milieu des annees 90

Apparition des methodes agiles

Developpement du marche ”Web”

Augmentation des langages et plateformes

Croissance de l’opensource

L’ensemble de ces facteurs pousse a avoir un systeme optimum pour laconstruction d’application.



Vraiment un probleme nouveau ?

Debut des annees 90 :

imake pour XFree86

Cygnus et les ”gcc configure script” pour les outils GNU

autoconf

C’est cette derniere initiative qui fut la bonne.



La reponse du monde libre

Creation d’autoconf en 1991 par David J. MacKenzie : apparition duscript ”configure” et des fichiers Makefile.in

Utilisation de m4 et adoption des conventions issues de GNU

Puis passage au configure.in

Enfin, ”1994-09-19 First CVS commit”11

Le choix qui a ete fait ici a ete de s’appuyer sur les fonctionnalitespresentes sur le systeme en les testant (la partie configure), d’utiliser desoutils de construction traditionnels (make, ...) et d’installer le produit de lacompilation suivant des standards.De plus, il n’y aucun lien avec les environnements de travail desdeveloppeurs (IDE).



Les autres reponses qui ont suivies

Ant, http://ant.apache.org

CMake, http://www.cmake.org

Jam/BJam, http://www.perforce.com/jam/jam.html

Maven, http://maven.apache.org

MSBuild, http://http://en.wikipedia.org/wiki/MSBuild

Qmake, http://en.wikipedia.org/wiki/Qmake

Scons, http://www.scons.org

Sconspiracy, http://code.google.com/p/sconspiracy

Waf, http://code.google.com/p/waf

Attention au syndrome du NIH : Not Invented Here 12


http://ant.apache.org

http://www.cmake.org

http://www.perforce.com/jam/jam.html

http://maven.apache.org

http://http://en.wikipedia.org/wiki/MSBuild

http://en.wikipedia.org/wiki/Qmake

http://www.scons.org

http://code.google.com/p/sconspiracy

http://code.google.com/p/waf



GNU Autotools

2. GNU Autotools


GNU Autotools

Sommaire

GNU Autotools

Les bases de GNU Autotools

GNU Autotools dans le detail

La gestion des bilbiotheques

Conclusion


GNU Autotools Les bases de GNU Autotools

Les references

Les sources d’informations qui ont ete utilisees pour cette partie :

http ://www.gnu.org/software/autoconf/

http ://en.wikipedia.org/

http ://sourceware.org/autobook/

http ://www.lrde.epita.fr/ adl/autotools.html

http ://www.infres.enst.fr/ dax/polys/configure/

http ://fsmsh.com/2754



GNU Autotools

Licence GPL, cree en 1992

Ecrit en shell + m4

Combinaison d’outils

Generation automatique de makefile

Makefiles generiques, parametrables

Configures automatiquement selon la plateforme

Bonne portabilite des developpements

Construction simple et transparente pour l’utilisateur :./configure,make,make install



GNU Autotools, un ensemble d’outils



On peut simplifier un peu...

On peut simplifier les 1eres etapes : autoreconf

La sequence serait donc :

Creation du ”configure.ac”Creation des ”Makefile.am”Lancement de ”autoreconf –install”Lancement de ”configure”Lancement de ”make”Lnacement de ”make install”

Bon allez, on se lance...



Notre petit Hello World

src/ main.c

#include <stdio.h>int main(int argc , char* argv []){

printf (”Hello World\n”);return 0;}



Les 3 fichiers a editer

configure.ac

AC_INIT([amhello], [1.0], [bug-report@address])

AM_INIT_AUTOMAKE([foreign -Wall -Werror])

AC_PROG_CC

AC_CONFIG_HEADERS([config.h])

AC_CONFIG_FILES([Makefile src/Makefile])

AC_OUTPUT

Makefile.am

SUBDIRS = src

src/ Makefile.am

bin_PROGRAMS = hello

hello_SOURCES = main.c


GNU Autotools GNU Autotools dans le detail

Notre configure.ac

configure.ac



AC_PROG_CC



AC_OUTPUT

Initialisation Autoconf (nom, version, @ de support, ...)

Initialisation Automake (remonte les erreurs, ...)

Utilisation du compilateur C

Declare config.h pour les entetes

Declare Makefile et src/ Makefile

Genere les fichiers specifies



Notre configure.ac

configure.ac



AC_PROG_CC



AC_OUTPUT









Notre configure.ac

configure.ac



AC_PROG_CC



AC_OUTPUT









Notre configure.ac

configure.ac



AC_PROG_CC



AC_OUTPUT









Notre configure.ac

configure.ac



AC_PROG_CC



AC_OUTPUT









Notre configure.ac

configure.ac



AC_PROG_CC



AC_OUTPUT









configure.ac en version plus complete

configure.ac

# Prelude.



# Verifications pour les programmesAC_PROG_CC

# Verifications pour les bibliotheques# Verifications pour les entetes# Verifications pour les typedefs, les structures, les options decompilateurs# Generation de fichiersAC_CONFIG_HEADERS([config.h])


AC_OUTPUT



Exemples de verifications (et affectations) de programmes

AC_PROG_CC, AC_PROG_CXX, AC_PROG_F77, ...Verifications pour les compilateurs

AC_PROG_SED, AC_PROG_YACC, AC_PROG_LEX, ...Verifications pour les utilitaires

AC_CHECK_PROGS(VAR, PROGS, [VAL-IF-NOT-FOUND])

VAR est positionne sur le 1er PROGS trouve, si rien n’est trouve alorsVAL-IF-NOT-FOUND.

AC_CHECK_PROGS([TAR], [tar gtar], [:])

if test "$TAR" = :; then

AC_MSG_ERROR([Ce paquet a besoin de tar.])

fi











fi











fi



Les macros utiles dans autoconf

AC_MSG_ERROR(ERROR-DESCRIPTION, [EXIT-STATUS])Affiche ERROR-DESCRIPTION (config.log) et arrete ‘configure’.

AC_MSG_WARN(ERROR-DESCRIPTION)Pareil, mais n’arrete pas

AC_DEFINE(VARIABLE, VALUE, DESCRIPTION)Ajoute les informations dans config.h.

/* DESCRIPTION */

#define VARIABLE VALUE

AC_SUBST(VARIABLE, [VALUE])Fixe $(VARIABLE) comme VALUE dans Makefile.

AC_SUBST([FOO], [foo]) FOO=foo

AC_SUBST([FOO])AC_SUBST([FOO])

FOO=foo

Les 3 ecritures sont equivalentes







/* DESCRIPTION */





FOO=foo

Les 3 ecritures sont equivalentes







/* DESCRIPTION */





FOO=foo

Les 3 ecritures sont equivalentesJohan Moreau (IRCAD) ENVOL - Outils de construction 27 septembre 2010 38 / 98


Verification pour les bibliotheques

AC_CHECK_LIB(LIBRARY, FUNCT, [ACT-IF-FOUND], [ACT-IF-NOT])

Verifie si la LIBRARY existe et si elle contient FUNCT. Si oui, executeACT-IF-FOUND sinon ACT-IF-NOT.

AC_CHECK_LIB([efence], [malloc], [EFENCELIB=-lefence])

AC_SUBST([EFENCELIB])

$(EFENCELIB) pourra etre utilise plus tard



Verification pour les bibliotheques

AC_CHECK_LIB(LIBRARY, FUNCT, [ACT-IF-FOUND], [ACT-IF-NOT])

Verifie si la LIBRARY existe et si elle contient FUNCT. Si oui, executeACT-IF-FOUND sinon ACT-IF-NOT.

AC_CHECK_LIB([efence], [malloc], [EFENCELIB=-lefence])

AC_SUBST([EFENCELIB])

$(EFENCELIB) pourra etre utilise plus tard



Verification pour les entetes

AC_CHECK_HEADERS(HEADERS...)Verifie la presence de HEADERS et positionne #define

HAVE_HEADER_H pour chacun.

AC_CHECK_HEADERS([sys/param.h unistd.h])

AC_CHECK_HEADERS([wchar.h])

#define HAVE_SYS_PARAM_H, HAVE_UNISTD_H, and HAVE_WCHAR_H.

#if HAVE UNISTD H# include <unistd.h>#endif

AC_CHECK_HEADER(HEADER, [ACT-IF-FOUND], [ACT-IF-NOT])Utile pour verifier uniquement les entetes (sans les DEFINE)

































Les Makefile.am

Makefile.am

SUBDIRS = src

src/ Makefile.am

bin_PROGRAMS = hello

hello_SOURCES = main.c

SUBDIRS pour les sous-repertoire a prendre en compte

bin PROGRAMS executable a generer (a separer par des espaces)

target SOURCES ....



La declaration des cibles

Makefile.am

option_

lieu_TYPE =

cibles ...

les cibles seront installees dans(”lieu”)

bin_ $(bindir)

lib_ $(libdir)

les cibles seront construitescommes (”TYPE”)

_PROGRAMS

_LIBRARIES

_LTLIBRARIES

_HEADERS

_SCRIPTS

_DATA




Makefile.am

option_

lieu_TYPE =

cibles ...


bin_ $(bindir)

lib_ $(libdir)


_PROGRAMS

_LIBRARIES

_LTLIBRARIES

_HEADERS

_SCRIPTS

_DATA




Makefile.am

option_

lieu_TYPE =

cibles ...


bin_ $(bindir)

lib_ $(libdir)


_PROGRAMS

_LIBRARIES

_LTLIBRARIES

_HEADERS

_SCRIPTS

_DATA


GNU Autotools La gestion des bibliotheques

Les bibliotheques

Ajouter AC_PROG_RANLIB dans configure.ac.

Makefile.am

lib_LIBRARIES = libfoo.a libbar.a

libfoo_a_SOURCES = foo.c privfoo.h

libbar_a_SOURCES = bar.c privbar.h

include_HEADERS = foo.h bar.h

Ces bibliotheques seront installees dans $(libdir).

Le nom des bilbiotheques doivent correspondre a lib*.a.

Les entetes publiques seront installees dans $(includedir).

Les entetes privees ne seront pas installees



Les bibliotheques


Makefile.am











Les bibliotheques


Makefile.am











Les bibliotheques


Makefile.am











Les bibliotheques


Makefile.am











Les bibliotheques


Makefile.am










GNU Autotools Conclusion

Conclusion sur les GNU Autotools

Les contres :

Pour beaucoup Autotools est synonyme d’Autohell 13 : de nombreusesoptions et documentations.

La gestion des dependances et des decouvertes des fichiers est enpartie manuelle si elle n’est pas en arborescence traditionnelle.

L’utilisation de m4 est complexe.

Sous Win32/Win64, seul Cygwin/MinGW est supporte.

Les pours :

De loin, l’outils le plus complet et puissant.

L’utilisation des arborescences de ”distribution”est parfaite. Et donc ladistribution (packaging) quasi-automatique.

La documentation est tres complete.

Ils sont utilises par des milliers de projets.


GNU Autotools Conclusion


CMake

3. CMake


CMake

Sommaire

CMake

Les bases de CMake

La gestion des bibliotheques

CMake dans le detail

Conclusion


CMake Les bases de CMake

Les references


http ://www.projet-plume.org/fr/fiche/cmake

http ://fr.wikipedia.org/wiki/CMake

http ://www.cmake.org/cmake/help/documentation.html

http ://www.elpauer.org/stuff/learning cmake.pdf

Mastering CMake - Published by Kitware, Inc. - ISBN 1-930934-09-2



CMake

Licence BSD

Cree en 2000

Ecrit en C++, se compile avec make/g++ ou Visual C++

Syntaxe ”maison” dans un fichier : CMakeLists.txt

Outil binaire monolithique

Multiplateforme (POSIX systems, Windows)

Generation automatique de ”makefile” en fonction de la plateforme

Makefiles generiques, parametrables

Configures automatiquement selon la plateforme

Bonne portabilite des developpements

Generation des ”espaces de travail” (Kdevelopp, XCode, MSVC, ...)

Petits ”extras” : SWIG, Graphviz, CDash, CPack, CTest



Les projets qui utilisent CMake

ITK, VTK, VXL, ParaView, Slicer, gdcm

KDE 14

Second Life

clang, LLVM

...



Mode operatoire

Creer et parametrer un fichier CMakeLists.txt dans chaque repertoiredu projet.

Utiliser la commande cmakeConstruction dans les sources du projet

cmake .

Construction hors des sources du projet

cmake path vers sources du projet

Generation des fichiers Makefile, ou .dsp, ou .sln, ...

Utilisables par les outils natifs

L’ensemble est mis en cache dans CMakeCache.txt (genere lors du 1erappel a cmake) :

Configuration de la construction (variables et valeurs)

En cas de probleme : modification manuelle ou via ccmake



Les 3 fichiers a editer pour notre petit HelloWorld

src/ main.c



CMakeLists.txt

PROJECT(hello)

SUBDIRS(src)

src/ CMakeLists.txt

ADD_EXECUTABLE(hello main.c)


CMake La gestion des bibliotheques

Un exemple de bibliotheque : libfoo

src/ CMakeLists.txt

INCLUDE_DIRECTORIES($CMAKE_SOURCE_DIR/foo)

LINK_DIRECTORIES($CMAKE_BINARY_DIR/foo)

ADD_EXECUTABLE(hello main.c)

TARGET_LINK_LIBRARIES(hello foo)

CMakeLists.txt

PROJECT(hello)

SUBDIRS(foo src)

foo/ CMakeLists.txt

ADD_LIBRARY(foo STA-

TIC foo.c)

foo/ CMakeLists.txt

ADD_LIBRARY(foo SHA-

RED foo.c)

Librairie statique (.a/.lib) ou librairie dynamique (.so/.dll/.dylib)L’ordre des repertoires est important.


CMake CMake dans le detail

Les possibilites du CMakeLists.txt

Langage de script avec une syntaxe simple

Les commentaires avec : #

Les commandes en : COMMAND(arg1 arg2 ...)

Les listes en : A ;B ;C

Les variables en $VAR



Les structures de controles

Conditionnelles

IF(CONDITION)

MESSAGE("Yes")

ELSE(CONDITION)

MESSAGE("No")

ENDIF(CONDITION)

Boucles

FOREACH(c A B C)

MESSAGE("$c: $$c")

ENDFOREACH(c)

Macros

MACRO(MY_MACRO arg1 arg2)

SET($arg1 "$$arg2")

ENDMACRO(MY_MACRO)

MY_MACRO(A B)



Composition : Macro

Composition de commandes existantes via l’utilisaiton de ”macros”

MACRO (CREATE_EXECUTABLE NAME SOURCES LIBRARIES)

ADD_EXECUTABLE($NAME $SOURCES)

TARGET_LINK_LIBRARIES($NAME $LIBRARIES)

ENDMACRO(CREATE_EXECUTABLE)

ADD_LIBRARY(foo main.c)

CREATE_EXECUTABLE(hell main.c foo)



Creation de variables

Creation de variables booleennes - Utilisation en ligne de commande

OPTION(DEBUG "Programme en mode DEBUG" OFF)

IF(DEBUG)

SET_SOURCE_FILES_PROPERTIES(main.c COMPILE_FLAGS -DDEBUG)

ENDIF(DEBUG)

$ cmake -DDEBUG :BOOL=ON



Quelques remarques sur cmake ...

Pensez a utiliser :

”cmake –help” pour l’aide glolabe

”cmake –help COMMAND” pour une aide detaillee :

”cmake –help IF”

SET(CMAKE VERBOSE MAKEFILE on)

Il est possible de passer des parametres sur la ligne de commande :

par exemple -G pour selectionner le systeme de construction cible

par exemple -D pour mettre des variables en cache

$ cmake ../Foo -G”Visual Studio 10” -DFOOBAR :BOOL=1



La GUI : NCurses



La GUI : Windows



Les modules

CMake propose des modules FIND LIBRARY afin de trouver les librairiesexternes utiles pour votre construction :



Les modules, suite

PROJECT( myProject )

FIND_PACKAGE ( PNG )

IF ( PNG_FOUND )

INCLUDE( $PNG_USE_FILE )

ENDIF( PNG_FOUND )

ADD_EXECUTABLE( myProject myProject.cxx )

TARGET_LINK_LIBRARIES ( myProject PNG)



Generation d’un paquet

Outil annexe : CPack, pour generer des ”paquets” :

Linux RPM, deb et gzip

NSIS (pour Microsoft Windows)

Mac OS X packages (dmg + pkg)

Ajout de INCLUDE(CPack) dans le CMakeLists.txt de base. Puis :

cmake .

make package

make package source

Le parametrage se fait dans CPackSourceConfig.cmake


CMake Conclusion

Conclusion sur CMake

Les contres :

Syntaxe propre

Flexibilite restreinte (bien pense quand meme !)

Comme les GNU Autotools, ce n’est pas un systeme de construction :C’est un generateur de fichier de configuration pour les systemes deconstruction

Les pours :

Communaute croissante (et KDE !)

Tres interessant dans le contexte scientifique (imagerie)

Vrai multiplateforme / pas uniquement POSIX

Les ajouts : CPack, CDash, CTest

Les ”Modules” (+250 dans la derniere version)

GUI de configuration

Autoconfiguration (librairie partagee, debug, etc ...)

Outil tres stableJohan Moreau (IRCAD) ENVOL - Outils de construction 27 septembre 2010 64 / 98

CMake Conclusion


SCons

4. SCons


SCons

Sommaire

SCons

Les bases de SCons

La gestion des bibliotheques

SCons dans le detail

Exemple de specialisation : SConspiracy

Conclusion


SCons Les bases de SCons

Les references


http ://www.projet-plume.org/fr/fiche/scons

http ://fr.wikipedia.org/wiki/SCons

http ://www.scons.org/documentation.php



SCons

Licence MIT

Cree en 2000 (suite au projet Cons en Perl)

Ecrit en python

Syntaxe python dans des fichiers SConstruct

Outil interprete

Multiplateforme (sur toutes les plateformes avec Python)

Remplace make, nmake.exe, msbuild.exe, etc ...

Detection des outils de compilation, d’edition des liens, ...

Generation des ”espaces de travail” Microsoft

Petits ”extras” : SWIG, Graphviz, CDash, CPack, CTest

Support pour C, C++, D, Java, Fortran, Yacc, Tex, Qt, SWIG, ...



Les projets qui utilisent SCons

VMWare

Google Chrome

Doom3

Blender

NumPy/SciPy



Mode operatoire

Creer et parametrer un fichier SConstruct a la racine et des fichiersSConscript dans chaque repertoire du projet.

Utiliser la commande scons

scons

L’ensemble des informations intermediaires est mis en cache dans lefichier .sconsign.dblite



Les 3 fichiers a editer pour notre petit HelloWorld

src/ main.c



SConstruct

SConscript(’src/SConscript’)

src/ SConscript

Program(’hello’, [’main.c’])


SCons La gestion des bibliotheques

Un exemple de bibliotheque : libfoo

src/ SConscript

Program(’hello’, [’main.c’],

LIBS=[’foo’], LIBPATH=[’../foo’], CPPPATH=[’../foo’])

SConstruct

SConscript ([’src/SConscript’,’foo/SConscript’])

L’ordre des repertoires n’est pas important.

foo/ SConscript

StaticLibrary(’foo’,[’foo.c’])

foo/ SConscript

SharedLibrary(’foo’,[’foo.c’])


SCons SCons dans le detail

Les possibilites du SConscript

Pour faire simple, quasiment tout est possible ! C’est un fichier qui estinterprete en Python. Il est par exemple possible de definir desenvironnements de construction :

SConstruct

opt = Environment(CCFLAGS = ’-O2’)

dbg = Environment(CCFLAGS = ’-g’)

opt.Program(’foo’, ’foo.c’)

dbg.Program(’bar’, ’bar.c’)

Al’execution

scons -Q

cc -o bar.o -c -g bar.c

cc -o bar bar.o

cc -o foo.o -c -O2 foo.c

cc -o foo foo.oJohan Moreau (IRCAD) ENVOL - Outils de construction 27 septembre 2010 74 / 98


Afficher les variables ou copier l’environnement

SConstruct

dict = Environment().Dictionary()

keys = dict.keys()

keys.sort()

for key in keys:

print "construction variable = ’%s’, va-

lue = ’%s’" % (key, dict[key])

SConstruct

env = Environment(CC = ’gcc’)

env.Program(’foo’, ’foo.c’)

env.Clone(CCFLAGS = ’-O2’).Program(’foo-opt’, ’foo.c’)

env.Clone(CCFLAGS = ’-g’).Program(’foo-dbg’, ’foo.c’)



La reconstruction

Timestamp comme Makefiles

SConstruct

Decider(’timestamp-newer’)

Decider(’make’)

Decider(’timestamp-match’)

Checksum md5 (methode par defaut)

SConstruct

Decider(’MD5’)

Combinaison des deux

SConstruct

Decider(’MD5-timestamp’)



Quelques remarques sur SCons

Construction hors des sources

SConstruct

SConscript(’src/SConscript’, variant_dir=’build’)

Manipulation des listes

SConstruct

Program(’program’, Glob(’*.c’))

Determiner la localisation d’une librairie (et placer dans CPPPATH)

SConstruct

env = Environment()

env[’CPPPATH’] = [’/lib/compat’]

env.ParseConfig("pkg-config x11 -cflags -libs")



Quelques complements sur SCons

Nettoyage des sources apres construction : scons -c

VariantDir pour avoir un repertoire de sources propre

Possibilite de faire des compilations distribuees

Possibilite de mettre le cache sur un partage reseau

...

Tres grande possibilite d’extension


SCons SConspiracy

Un exemple d’extension : SConspiracy

Yams++ ⇒ SConspiracy (racy)

Construction d’application

C++MultiplateformeOrientee composantEn environnement controle

Open source, Licence BSD

http://code.google.com/p/sconspiracy/

Compatibilite avec Yams++ (ancetre du projet)

Remplace make, cmake, ...

Python 2.6, SCons >=1.3 pour la derniere version


http://code.google.com/p/sconspiracy/

SCons SConspiracy

Les Buts

Utilises les avantages de SCons en essayant d’ajouter :

Ajout/Configuration de projets souple et simple

Respecter au maximum la philosophie DRY (Don’t Repeat Yourself)

Detection automatique de ce qui doit etre compile

Obtenir un workflow de construction optimum

Permettre facilement l’ajout ou l’evolution de fonctionnalite (plugins)

Gestion uniforme et souple des bibliotheques externes

Creation de packages binaires utilisables sous forme de bibliothequesexternes

Gestion de multiples projets independants ou a composants communs


SCons SConspiracy

Base de developpement et projets

Un ou plusieurs repertoires contenant des projets

Arborescence non structuree

Noms de projets uniques, compose par [}a-zA-Z0-9{]+

Un projet ne peut pas se trouver dans le repertoire d’un autre projet

Repertoire structure (Sources + ressources + configuration-

Nom du repertoire ⇒ nom du projet

Structure du repertoireprj/bin/build.optionsprj/includeprj/srcprj/rc

build.options (equivalent a un SConstruct ou CMakeLists.txt)variable necessaire : TYPE (shared, static, exec, bundle, ...)variables optionnelles : VERSION, LIB, USE, ...


SCons SConspiracy

Exemple de build.options

Exemple de fichier build.options :

build.options

TYPE = ’shared’VERSION = ’0-4’LIB = [’core’,’utils’]USE = [’boost’, ’vtk’]

Tout ceci est du code Python, comme pour SConstruct


SCons SConspiracy

Exemple d’utilisation de SConspiracy

build.options - ’hello’

TYPE = ’exec’LIB = [’sconspirator 0.1’]

build.options - ’sconspirator’

TYPE = ’shared’VERSION = ’0.1’

build.options - ’hello’

hello/bin/build.optionshello/src/program.cpp

build.options - ’sconspirator’

sconspirator/bin/build.optionssconspirator/include/SConspirator.hppsconspirator/src/SConspirator.cpp


SCons SConspiracy

Application + libs

IndenterObj

A

instance de A::IndenterInstance de A::Obj

ObjB

instance de A::IndenterInstance de B::Obj

ObjF


ObjC


ObjD

instance de A::IndenterInstance de D::ObjInstance de F::Obj

ObjE

Instance de E::ObjApp


SCons SConspiracy

Application + libs + libext

IndenterObj

A

instance de A::IndenterInstance de A::Obj

ObjB

Shared_ptr sur une instance de A::IndenterShared_ptr sur une Instance de B::Obj

ObjG

Instance de E::ObjAppBoost

Boost


SCons Conclusion

Conclusion sur SCons

Les contres :

Si mal configure, il peut-etre lent sur des gros projets

Necessaire de le ”specialiser” a partir d’une certaine taille de projet.

Generateur d’espace de travail pas aussi performant que CMake

La recherche de librairie n’a pas les ajouts de CMake

Avoir Python d’installe

Les pours :

Vraiment multiplateforme et extensible avec un langage connu

Il ne produit pas des fichiers pour construire, il construit

Permet d’avoir des processus de construction ”maison”, ce qui estnecessaire a partir d’une certaine taille de projet/equipe

Autoconfiguration (librairie partagee, warnings, etc ...)

Complements extremement interessants (scons-addons, SConspiracy,sbf, swtoolkit, scons-plusplus, ...)


SCons Conclusion


Les autres

5. Les autres


Les autres

Sommaire

Les autres

Ant

Maven

Qmake

Et de nombreux autres


Les autres Ant

Ant : Another Neat Tool 16

Ant 15 est sous licence Apache et a ete cree en 2000.

Le projet est heberge par la fondation Apache et est ecrit en Java.

Il permet de faire l’appel aux compilateurs, aux generateurs dedocumentation (Javadoc), aux generateurs de rapports, auxverificateurs de style (checkstyle), ...

Il peut etre utilise avec C/C++ via des contributions au projet

Il est devenu omnipresent dans le monde Java.


Les autres Maven

Maven 17

Maven est sous licence Apache et a ete cree en 2002.

En gros, il reprend tout ce que fait Ant, mais essaye d’en simplifier laconfiguration pour les gros projets.

Il essaye de standardiser les projets.

Il apporte une tres bonne gestion des dependances.

Il a une orientation reseau (si les sources ne sont pas la, il va leschercher)

Il n’y a plus de support pour C/C++ mais il en existe pour .Net

La version 3 devrait support Ruby et Groovy


Les autres qmake

qmake 19

Outil de construction fournit avec Qt

A l’origine TMake (un script Perl)

Meme architecture que TMake, difficile a maintenir

Semble se faire petit a petit remplacer par CMake 18


Les autres Et de nombreux autres

Waf

Il s’agit d’un ”fork” de SCons.

Waf 20 est portable, leger, n’a que Python comme dependance.

Il propose un vrai langage (Python) pour la configuration.

Il support les cibles traditionnelles (buid, clean, install, ...)

Il determine les dependances pour C/C++.

Il supporte le langage D et OCaml.

Il propose un mode ”daemon” et un systeme de cache.

Il est plus rapide que SCons dans certains cas



MSBuild et NAnt

Pour les environnements DotNET, 2 outils interessant existent :

MSBuild 21 a ete introduit avec Visual 2005. Il permet de generer lecode .Net (C#, VB, ...). Ses fichiers de configurations s’ecrivent enXML. Il a pour but de remplacer l’outils nmake.exe

Le principal concurrent est NAnt. Il s’agit du pendant du projet Ant,mais celui est plus specialise pour .Net et est fait en C#.



Et ce n’est pas fini

J’en passe des dizaines :

Gant

Gradle

Buildr

Rant

Rake

...




Conclusion

Conclusion


Conclusion

Conclusion

Synthese :

CMake et SCons sont tres interessants et performants.

Autotools est complexe mais impeccable sur POSIX.

Pour du pur Java, Ruby, Python, etc ... Il existe des processus deconstruction specialisess.

Conseils :

Ne pas utiliser les systemes integres des IDE.

Etudier en fonction de vos besoins.

On peut remettre en cause le choix de l’outils, meme si c’est difficile.

Vous pouvez gagner en efficacite et en visibilite sur votre projet.
