[Résolu] Makefile: gérer les cas

s@mson · Le 12/01/2008, à 14:59

Bonjour à chacun,

Je souhaiterai réaliser un Makefile, que je peux modifier rapidement en l'éditant ou que j'invoquerai avec make avec différentes options, afin de choisir une combinaison parmi les 8 possibles, entre :

1- Compilateur A ou compilateur B,
2- Simple ou double précision,
3- Comilation en mode debug ou release.

Que me conseiller vous comme technique pour arriver à mes fins ?

Merci beaucoup

Dernière modification par s@mson (Le 12/01/2008, à 17:33)

slapierre · Le 12/01/2008, à 15:52

Faire plusieurs Makefile, les appeler avec la commande :

make -f mymakefile

Simon

slapierre · Le 12/01/2008, à 16:25

Pour la simple ou double précision, je crois que ça dépend du code (float ou double) et non des options de compilation. J'ai modifié le Makefile que j'utilises toujours pour ajouter tes features, que je trouve par ailleurs très intéressantes!

#******************************************************************************
# AUTEURS       : simon.lapierre@gmail.com
# FICHIER       : Makefile
# COMPILATEUR   : POSIX-Compliant C++ Compiler
# TARGET        : out
# DATE          : 2007-05-25
# VERSION       : 1.0
# MODIFICATIONS : n/a
# DESCRIPTION   : Effectuer la compilation et l'édition des liens pour le projet
#******************************************************************************/

# Compilateur par défaut
# Modifier la macro CC à  l'appel : make "CC= g++"
CC = gcc

# Optimisation : http://developer.apple.com/documentation/DeveloperTools/gcc-3.3/gcc/Optimize-Options.html
CFLAGS = -Wall -O2

# GDB primer : http://www.ecs.syr.edu/faculty/oh/cis586-spring2007/GDB%20Primer.htm
CFLAGS_DBG = -Wall -O2 -g

# Inclusion de math.h (-lm)
LIBS = -lm

# Nom du programme :
TARGET = out

# Liste des fichiers sources :
SRC = main.cc

# Création des fichiers objets : portent même nom que les fichier sources
OBJ = $(SRC:.c=.o)

# Cible par défaut :
all: compile build

# Cible de debug :
dbg: compile_dbg build

compile:
	$(CC) -c $(CFLAGS) $(SRC)

compile_dbg:
	$(CC) -c $(CFLAGS_DBG) $(SRC)

build:
	$(CC) -o $(TARGET) $(LIBS) $(OBJ)

clean:
	rm -f *~ *.o *.gch $(TARGET)

le Makefile ci-dessus ne fonctionne pas directement, étant donné que le compilateur par défaut est gcc et que la SRC est un fichier C++, tu dois donc invoquer make de la façon suivante :

En mode release (cible all par défaut)

     $ make "CC= g++"

ou

     $ make "CC= g++" all

En mode debug : 

     $ make "CC= g++" dbg

Fichier de test (main.cc)

#include <iostream>
using namespace std;

int main (void)
{
	cout<<"allo"<<endl;
	return 0;
}

Simon

s@mson · Le 12/01/2008, à 16:39

Merci slapierre !

Que de bonnes idées pour résoudre mon pb! Moi je m'étais basé sur : http://gl.developpez.com/tutoriel/outil/makefile/ pour écrire mon Makefile. Avec l'aide que tu viens de me donner, je pense pouvoir écrire le Makefile de même rêves... Il faut d'abord que j'arrive a passer mon code en double précision, ce qui me pose par ailleurs des problèmes, et ensuite je posterai le Makefile que j'ai écrit. Le miens est pour le fortran, ça fera de la variété!

Dernière modification par s@mson (Le 12/01/2008, à 16:42)

slapierre · Le 12/01/2008, à 17:24

Je ne comprend toujours pas ton histoire de "passer en double précision", mais bon... Quand tout sera à ton goût, modifie le titre du message et ajoute "résolu".

Tu peux aussi passer voir la discussion suivante :

>> [c] faire un makefile: http://forum.ubuntu-fr.org/viewtopic.php?id=177717

Simon

s@mson · Le 12/01/2008, à 17:33

ok, "passer en double précision" ca doit etre un mauvais jargon... Pour parler de la même chose : Il s'agit de dire si on code un réel sur 4 octet (simple précision) ou 8 octet (double précision). Pour cela, on peut le déclarer directement dans le code, ou passer une option au compilateur.
Par exemple, http://www.idris.fr/ -> support technique -> calcul vectoriel -> Système de compilation fortran -> option principale du compilateur fortran

slapierre · Le 12/01/2008, à 18:37

Très intéressant, vous utilisez F90 ou HPF pour le traitement en parallèle? J'ai entendu de très bonnes choses à propos de fortran pour les architectures parallèle. Vous programmez avec la librairie MPI?

Tu dois dois soit modifier la variable CFLAGS, ou ajouter une macro PRECISION avec une valeur par défaut :

# taille d'un real : 4 octets
PRECISION = -Wf"-A dbl8"

...

$(CC) -c $(CFLAGS) $(PRECISION) $(SRC)

Pour ce qui est de l'invocation de make, il y aura peut-être des problèmes étant donné les guillements doubles, tu dois - sous toute réserve - donc utiliser des guillements simples :

# double précision pour les real? 
    $ make 'PRECISION = -Wf"-A dbl"'

Si tu es (vraiment) paresseux (comme moi), tu peux te faire une script avec un "menu" pour éviter de toujours saisir tes variables, voici un petit exemple :

#!/bin/sh

# http://crazedmonkey.com/blog/programming/multiple-expression-if-statement-in-bash.html

echo -n "Debug (1) ou Release (2) "
read a

echo -n "Précision simple (4) ou double (8)"
read b

if [ $a -eq 1 -a $b -eq 4 ]; then
    echo debug + simple
fi

if [ $a -eq 1 -a $b -eq 8 ]; then
    echo debug + double
fi

if [ $a -eq 2 -a $b -eq 4 ]; then
    echo release + simple
fi

if [ $a -eq 2 -a $b -eq 8 ]; then
    echo release + double
fi

Simon

slapierre · Le 12/01/2008, à 18:40

J'oubliais... pour exécuter le script :

    $ bash test.sh

ou rendre le script exécutable  (pour pouvoir faire $ ./test.sh)

    $ chmod +x test.sh

Aussi, tu remplaces "echo ..." par "make ..."

Simon

JBF · Le 12/01/2008, à 19:29

Bonjour,

voici un exemple de ce que j'ai fait pour produire une version linux ou une version win32 avec le même makefile :

#---------------------------------------------------------------------#
# Directories and Fortran compiler
#---------------------------------------------------------------------#
HOME	=/home/toto
SRCDIR	=$(HOME)/dev
tmp     =$(HOME)/zbin

#VERSION	=win32
VERSION	=Linux

ifeq ($(VERSION),Linux)
  # Version Linux 
  EXEDIR	=$(HOME)/Test/exec_dev
  BINDIR	=$(HOME)/zbin/dev
  FC	= g95
  #FC	= gf95
  #FC	= gfortran
  ligne1	="      CHARACTER(len=9),PARAMETER :: OS = 'Linux-x86'"
  ligne2	="      character(len=1), parameter :: slash = '/'"
else
  # Version win32
  EXEDIR	=$(HOME)/Test/win32
  BINDIR	=$(HOME)/zbin/win32
  FC	= wine g95
  ligne1	="      CHARACTER(len=9),PARAMETER :: OS = 'Win32'"
  ligne2	="      character(len=1), parameter :: slash = '\'"
endif


#---------------------------------------------------------------------#
# Fortran compiler flags
#---------------------------------------------------------------------#
ifeq ($(FC),gf95)
  FFLAGS	= -fno-automatic -O3 -fimplicit-none -fbacktrace -mtune=native -march=native 
  # options pour le linker
  LFLAGS	= -static-libgfortran 
  #module dirs
  MFLAGS	= -J$(BINDIR)/
else ifeq ($(FC),gfortran)
  FFLAGS	= -fimplicit-none -fno-automatic -O3 -malign-double
  # options pour le linker
  LFLAGS	= -static
  #module dirs
  #MFLAGS	= -J$(BINDIR)/  #option sans effet (bug)
else
  FFLAGS	= -O3 -malign-double -fimplicit-none -Wprecision-loss -ftrace=full -fstatic -Werror
  # options pour le linker
  LFLAGS	= -static
  #module dirs
  MFLAGS	= -fmod=$(BINDIR)/
endif

#include dirs
IFLAGS	= -I$(BINDIR)/
.........

Les variables ligne1 et ligne2 servent à modifier le code source pour faire apparaà®tre l'OS dans l'entête du listing et définir le séparateur dans les chemins de fichier.

JBF

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 12/01/2008, à 14:59

[Résolu] Makefile: gérer les cas

#2 Le 12/01/2008, à 15:52

Re : [Résolu] Makefile: gérer les cas

#3 Le 12/01/2008, à 16:25

Re : [Résolu] Makefile: gérer les cas

#4 Le 12/01/2008, à 16:39

Re : [Résolu] Makefile: gérer les cas

#5 Le 12/01/2008, à 17:24

Re : [Résolu] Makefile: gérer les cas

#6 Le 12/01/2008, à 17:33

Re : [Résolu] Makefile: gérer les cas

#7 Le 12/01/2008, à 18:37

Re : [Résolu] Makefile: gérer les cas

#8 Le 12/01/2008, à 18:40

Re : [Résolu] Makefile: gérer les cas

#9 Le 12/01/2008, à 19:29

Re : [Résolu] Makefile: gérer les cas

Pied de page des forums