rio/Verif_Herezh
2
0
Fork 0
Code Releases Activity

nouvelle possibilite (fonctionnelle mais a ameliorer) : possibilite d interrompre la batterie en cours avec ctr+c sans alterer les repertoires de tests (grace a des modifs du script Perl/test.pl) voir doc doc_procedure_verification.pdf section 3 pour la procedure et section 6 pour le detail des modifs; nouvel affichage dans le rapport de test : temps de calcul de chaque test (et legere modif de l en-tete du rapport avec affichage du nom de la machine)

Browse source
This commit is contained in:
troufflard 2015-11-25 09:00:06 +00:00
parent a559c16fe9
commit 619bf47a3b
5 changed files with 193 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
Doc/doc_procedure_verification.tex
View file

@ -136,7 +136,7 @@ L'arborescence du projet CVS est la suivante :\\
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Lancement de la batterie de tests}
\section{Lancement de la batterie de tests}\label{section_lancement_batterie_tests}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Il y a actuellement deux scripts permettant de lancer la batterie de tests. Le script \verb|verifier_exeHZ.zsh| est la version originale historique. Le script \verb|verifier_exeHZ.pl| est une version plus récente offrant plus de possibilités sous forme d'options. Pour l'instant, ces deux scripts existent. A terme, si \verb|verifier_exeHZ.pl| s'avère satisfaisant, la version \verb|.zsh| dispara\^itra du projet.\\
@ -147,6 +147,16 @@ Avant de d
\item[2-] exécuter le script \verb|verifier_exeHZ.zsh| ou \verb|verifier_exeHZ.pl [...options...]| en lui indiquant l'exécutable à tester\\
\end{itemize}
Le rapport obtenu après exécution de la batterie indique pour chaque test si il est réussi ainsi que le temps de calcul obtenu par la commande \verb|time|.\\
{\color{blue} \noindent \bf \underline{Interrompre l'exécution de la batterie (**procédure temporaire**)} :\rm
En l'état actuel, il est possible de stopper l'exécution de la batterie avec \verb|ctrl+c|. Cependant, la gestion de cette interruption n'est pas encore bien gérée. Il faut faire un certain nombre de \verb|ctrl+c| jusqu'à ce que le programme s'arr\^ete (typiquement, il faut rester appuyer sur \verb|ctrl+c|). Ensuite, il faut vérifier s'il y a des processus Herezh++ qui persistent en fond de t\^ache et tuer ces processus (\verb|kill -9|). Ces processus sont faciles à repérer avec la commande \verb|ps| gr\^ace au nom de leur commande associée qui est de la forme : \verb|testHZ[un entier] -f fichier.info|. Et enfin, éventuellement, on peut effacer les répertoires temporaires encore présents dans \verb|/tmp| pour éviter leur accumulation (ces répertoires ont un nom de la forme : \verb|/tmp/test.pl_[un entier]|.
\bf NB : cette procédure d'interruption n'altère pas les répertoires originaux de tests de la batterie. Bien que non optimale, cette procédure est s\^ure et n'aura aucune influence sur le prochain lancement de la batterie.\rm
}
\subsubsection*{\underline{Script \texttt{verifier\_exeHZ.zsh}} :}
Le script \verb|verifier_exeHZ.zsh| lance automatiquement tous les tests présents dans le répertoire courant et ses sous-répertoires. Un test est un répertoire dont le nom commence par \verb|Test_R| ou \verb|Test_L| (voir section \ref{section_organisation_tests}). Le script peut \^etre lancé dans n'importe quel répertoire contenant le répertoire \verb|Perl|. Il produit un rapport de tests pour les tests \verb|Test_R| (tests rapides) et un rapport pour les tests \verb|Test_L| (tests longs). Ces rapports sont contenus dans le répertoire \verb|Rapport| (éventuellement créé si il n'existe pas au lancement) sous le nom \verb|rapport_test_R.txt| et \verb|rapport_test_L.txt|. Le script affiche automatiquement ces rapports si l'éditeur de texte \verb|nedit| est disponible.
@ -244,7 +254,8 @@ Le script \verb|verifier_exeHZ.zsh| ou \verb|verifier_exeHZ.pl| a pour fonction
Pour chaque calcul, un éventuel fichier d'extension \verb|.commande|[i] contient des commandes interactives pour répondre aux différents menus interactifs proposés par Herezh++. Par défaut, un calcul Herezh est exécuté avec l'option \verb|-f| suivie du nom du fichier \verb|.info| (calcul classique). Si le fichier \verb|.info| ne contient pas le mot-clé \verb|dimension|, l'option utilisée est \verb|-n| suivie du fichier \verb|.info| (création interactive d'un fichier .info). Il est également possible de définir complètement les arguments donnés à Herezh++ dans un fichier \verb|.argument|[i]. Pour plus d'informations sur les fichiers facultatifs, on peut se référer à la section \ref{section_fichiers_facultatifs}.\\
Une fois un test terminé, le répertoire du test est restauré dans son état d'origine (restauration de l'état initial du fichier \verb|.info| et suppression de tous les fichiers qui n'étaient pas présents à l'origine).
L'exécution d'un test se fait dans un répertoire temporaire dans \verb|/tmp|. On s'assure ainsi que le contenu du répertoire d'origine ne sera jamais altéré, quelque soit le déroulement du test.\\
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsubsection{Vérification}\label{subsubsection_verification}
@ -757,6 +768,18 @@ remarque : modif
2) possibilité d'insérer des formules et caractères mathématiques dans les fichiers \verb|README| entre simples \$ ou doubles \$\$ (voir section \ref{section_fichiers_obligatoires} concernant le fichier \verb|README|)\\
\end{itemize}%tiret
\item[$\bullet$] 2015-11-25 (Julien Troufflard) :
\begin{itemize}
\item[-] modif script \verb|Perl/genere_rapport.pl| : modifification de l'en-t\^ete du rapport de tests avec notamment l'affichage du nom de la machine (via variable environnement \$HOST)
\item[-] modif script \verb|Perl/test.pl| :\\
1) gestion de bugs et améliorations diverses :\\
- remplacement de "\verb|cp -nf|" par l'encha\^inement "\verb|rm -f|" + "\verb|cp|" (car dans certaines versions de \verb|cp|, l'option \verb|-n| n existe pas)\\
- modification majeure : désormais, un test s'éxecute dans un repertoire de travail sur \verb|/tmp| (voir variable \verb|$repertoire_de_travail|). L'intér\^et majeur est de ne jamais modifier le répertoire d'origine du test quelque soit le déroulement du test. Cette stratégie permet actuellement d'interrompre la batterie avec \verb|ctrl+c| sans conséquence sur le contenu des répertoires de test (voir procédure d'interruption à la section \ref{section_lancement_batterie_tests}). De plus, une conséquence indirecte bénéfique de ceci est que m\^eme quand un test se déroule correctement, il se pouvait que certains fichiers soient légèrement modifiés (par exemple : le numéro de version Herezh en en-t\^ete du fichier \verb|cube_soude.her| du test \verb|FONCTION_UNIQUE/UTILITAIRES/Test_R_fusion-noeuds-voisins|). En conséquence, cela générait un archivage CVS supplémentaire avec envoi intempestif d'un mail aux membres du projet pour chacun de ces fichiers, alors qu'en realité, ils n'étaient pas fondamentalement et sciemment modifiés. Ce problème mineur est désormais résolu.\\
- comparaison maple : désormais, si toutes les grandeurs d'un test sont OK, un affichage allégé est produit dans le rapport (juste une ligne pour indiquer que toutes les grandeurs sont OK sans détailler les comparaisons)\\
2) affichage des temps de calcul :\\
- dans la subroutine \verb|lancement_commande()| : lancement de Herezh via la tournure \verb/tsch -c "time HZ -f fic.info" | tee fic.log/ pour récuperer le temps CPU dans le fichier .log (l'utilisation de \verb|tcsh -c|, c'est uniquement pour que le résultat de \verb|time| soit bien récupéré sur \verb|STDOUT|, donc dans \verb|fic.log|)\\
- juste après l'appel à \verb|lancement_commande()| $\Rightarrow$ saisie du temps de calcul dans le \verb|.log| et affichage dans le rapport de test (juste après le nom du test)\\
\end{itemize}%tiret
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%template d ajout d une nouvelle mise à jour (composé d'une puce "bullet" avec Date et auteur de la modif, suivie d une série de puce "-"

12
Perl/genere_rapport.pl
View file

@ -68,6 +68,7 @@ else {#sinon => le label de la version sera : HZpp $no_version
#-------------------------------------------------
#3) ecriture de l en-tete du fichier rapport
# (rq : affichage eventuel du nom de la machine si la variable environnement $HOST existe)
#-------------------------------------------------
open (FSOR,">$file");
print FSOR "---------------------------------------\n";
@ -75,8 +76,13 @@ open (FSOR,">$file");
print FSOR "---------------------------------------\n";
print FSOR "- version HZ++ : $LABEL_VERSION\n";
print FSOR "\n";
print FSOR "- Batterie de tests lancee\n";
print FSOR "- le $mjour/$mois/$annee\n";
print FSOR "- a $heure:$min (heure locale)\n";
print FSOR "- date : $mjour/$mois/$annee\n";
print FSOR "- heure : $heure:$min (heure locale)\n";
if(defined $ENV{'HOST'}) {
print FSOR "- machine : $ENV{'HOST'}\n";
}
else {
print FSOR "- machine : inconnue (variable environnement \"\$HOST\" non definie)\n";
}
print FSOR "---------------------------------------\n\n";
close (FSOR);

206
Perl/test.pl
View file

@ -83,13 +83,18 @@ my $TAILLE_MAX_FIC_REDIR = 250*1024*1024;#octets
########################### Variables de fichier ###########################
my $repertoire_racine = cwd; ###---Repertoire racine (celui dans lequel le script verifier_exeHZ a ete lance)
my $repertoire_test; ###---Repertoire test
my $fichier_test = 'test0'; ###---Fichier .info a tester
my $fichier_rapport = 'rapport_test.txt'; ###---Fichier de rapport des tests
my $fichier_temp_maple = 'xxx_princ.maple'; ###---Fichier pour recuperer $valeur
my @fichiers; ###---Liste du contenu initial du repertoire de test
my $repertoire_racine = cwd; ###---Repertoire racine (celui dans lequel le script verifier_exeHZ a ete lance)
my $repertoire_test; ###---Repertoire test (il s agit du repertoire original, sachant que le test sera concretement execute dans le repertoire $repertoire_de_travail defini par la suite)
my $fichier_test = 'test0'; ###---Fichier .info a tester
my $fichier_rapport = 'rapport_test.txt'; ###---Fichier de rapport des tests
my $fichier_temp_maple = 'xxx_princ.maple'; ###---Fichier pour recuperer $valeur
my @fichiers; ###---Liste du contenu initial du repertoire de test
my $repertoire_de_travail = "/tmp/$NOM_PROG\_$$"; ###---Repertoire de travail dans lequel les tests vont etre reellement executes
### (NE PAS MODIFIER LE FAIT QUE CE SOIT SUR /tmp ... au pire, il faut au moins que ce
### soit un chemin absolu et vers un repertoire facilement disponible sur n importe quelle OS Mac ou Linux)
### Le choix actuel (2015-11-25) a ete de nommer ce repertoire en fonction du nom de ce script suivi du pid
### du processus, ce qui a priori le rend unique)
########################### Variables executable Herezh ###########################
my $exeHZ; ###---Executable Herezh
my $hzchemin; ###---path vers l executable Herezh
@ -182,6 +187,15 @@ $hzchemin = verif_commande($exeHZ);
##########################################################################
##########################################################################
##########################################################################
#verification prealable que le repertoire de travail $repertoire_de_travail specifie dans l en-tete de ce script est bien un
# repertoire en chemin absolu (si ce n est pas le cas, il pourrait y avoir de graves problemes d execution, donc autant bien verifier maintenant)
($repertoire_de_travail =~ /^\s*\//) or do {
printRapport("$repertoire_test\n -> ECHEC : le repertoire de travail ($repertoire_de_travail) specifie dans l en-tete du script $NOM_PROG doit etre en chemin absolu (veuillez modifier la variable \$repertoire_de_travail du script $0)\n\n");
print "**Erreur Test $repertoire_test : le repertoire de travail ($repertoire_de_travail) specifie dans l en-tete du script $NOM_PROG doit etre en chemin absolu (veuillez modifier la variable \$repertoire_de_travail du script $0)\n";
exit;
};
print "\n";
print " TYPE DE CALCUL = $exeHZ\n";
print "############################################################\n";
@ -199,7 +213,7 @@ print " Nom du repertoire racine = $repertoire_racine\n";
print " Deplacement dans le repertoire Test\n";
chdir ("$repertoire_test");
#liste du contenu initial du repertoire de test (rq : servira plus tard a retablir l etat d origine du repertoire avant de terminer ce script)
#liste du contenu initial du repertoire de test
@fichiers = glob("*");
$_ = $#fichiers + 1;
print " Nombre de fichiers dans le repertoire $repertoire_test = $_\n";
@ -209,9 +223,6 @@ $fichier_test = glob("*.info");
$fichier_test =~ s/.info$//;#suppression de l extension
print " Nom du fichier teste dans le repertoire test = $fichier_test.info\n";
#sauvegarde du fichier .info d origine
system ("cp -nf $fichier_test.info $fichier_test.info_OLD");
#nom du fichier .maple
$fichier_temp_maple = $fichier_test."_princ.maple";
@ -263,11 +274,32 @@ print " Nombre de fichiers .CVisu dans le repertoire test = $nb_CVisu\n";
##########################################################################
#
# (DEBUT) LANCEMENT DES TESTS (un test par fichier .CVisu)
# rq : l execution des tests se fait dans le repertoire
# de travail $repertoire_de_travail afin de ne jamais modifier le repertoire d origine
#
##########################################################################
##########################################################################
##########################################################################
#recopie du contenu du repertoire vers le repertoire temporaire (on nomme ce repertoire en fonction de la variable Perl $$ qui est le PID du processus actuel)
system("rm -rf $repertoire_de_travail");#suppression si il existe deja (improbable!!)
mkdir $repertoire_de_travail;#creation du repertoire
#verif de sa creation
(-d $repertoire_de_travail) or do {
printRapport("$repertoire_test\n -> ECHEC : Impossible de creer le repertoire de travail $repertoire_de_travail\n\n");
print "**Erreur Test $repertoire_test : Impossible de creer le repertoire de travail $repertoire_de_travail\n";
exit;
};
#recopie des fichiers vers $repertoire_de_travail
foreach my $fic (@fichiers) {
#cas d un repertoire
if(-d $fic) {system("cp -R $fic $repertoire_de_travail/.");}
#cas d un fichier
else {system("cp $fic $repertoire_de_travail/.");}
}
#deplacement dans le repertoire de travail
chdir $repertoire_de_travail;
################################################
#(debut) boucle de test (sur les numeros de .CVisu)
################################################
@ -281,7 +313,7 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
print "\n";
#ecriture du repertoire de test et .CVisu en cours dans le rapport
printRapport("$repertoire_test/.CVisu$no_test\n");
printRapport("\n\n$repertoire_test/.CVisu$no_test\n");
#####################################################################################################
@ -416,7 +448,7 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
#####################################################################################################
#recopie du .CVisu[$no_test] vers .CVisu
system("cp -nf $fichier_test.CVisu$no_test $fichier_test.CVisu");
system("rm -f $fichier_test.CVisu; cp $fichier_test.CVisu$no_test $fichier_test.CVisu");
#lancement de la commande via subroutine lancement_commande() dont les arguments sont :
# 1- chemin complet vers l executable Herezh
@ -432,6 +464,81 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
# - si le calcul ne s arretait pas alors qu il avait une activite cpu nulle => $status_calcul = "activite cpu nulle"
#####################################################################################################
#----------------------------------------------------------------------------------------------------
# SAISIE DU TEMPS CPU DANS LE FICHIER .log
#----------------------------------------------------------------------------------------------------
#####################################################################################################
#
#commentaires : pour rappel, le temps de calcul est fournie par la commande time
# on va afficher le temps CPU en un format plus lisible que celui fourni par time (i.e conversion en hh:mm:ss.sss)
# la commande time renvoie 4 informations :
# - temps cpu (un reel en secondes suivi de la lettre u)
# - temps systeme (un reel en secondes suivi de la lettre s)
# - temps reel (format variable selon sa taille : secondes, minutes:secondes ou heures:minutes:secondes)
# - pourcentage utilisation processeur (un reel suivi du caractere %)
# IMPORTANT : le "temps cpu" et le "temps systeme" sont a mettre en relation avec le "pourcentage utilisation processeur"
# il y a a peu pres la relation :
# "temps reel" = ("temps cpu" + "temps systeme")/"pourcentage utilisation processeur"
#
printRapport(" -------------------------------------------------------\n");
my $is_time_ok = 0;#indicateur de presence du resultat de la commande time
open(Flog, "<$fichier_test.log");
while(<Flog>) {
next if(not /($format_reel)u/);
my $temps_cpu = $1;
next if(not /($format_reel)s/);
my $temps_systeme = $1;
next if(not /($format_reel)\%/);
my $pourcent_proc = $1;
next if(not /((?:\d+:)?\d+:$format_reel)/);
my @temps_reel = split(/:/, $1);
#commande time ok
$is_time_ok = 1;
#conversion du "temps_cpu" (a mettre en relation avec le pourcentage processeur)
$_[0] = int($temps_cpu/3600.);#nb heures
$_[1] = int(($temps_cpu - $_[0]*3600.)/60.);#nb minutes
$_[2] = sprintf("%.3f", $temps_cpu - $_[0]*3600. - $_[1]*60.);#secondes (avec les milliemes)
for(my $i=0; $i<=2; $i++) {$_[$i] = "0$_[$i]" if($_[$i] < 10);}#retouche cosmetique : rajout d un 0 davant le nombre si il n est constitue que de 1 seul digit
printRapport(" | temps cpu : $_[0]:$_[1]:$_[2] (processeur : $pourcent_proc\%)\n");
#conversion du "temps systeme" (a mettre en relation avec le pourcentage processeur)
$_[0] = int($temps_systeme/3600.);#nb heures
$_[1] = int(($temps_systeme - $_[0]*3600.)/60.);#nb minutes
$_[2] = sprintf("%.3f", $temps_systeme - $_[0]*3600. - $_[1]*60.);#secondes (avec les milliemes)
for(my $i=0; $i<=2; $i++) {$_[$i] = "0$_[$i]" if($_[$i] < 10);}#retouche cosmetique : rajout d un 0 davant le nombre si il n est constitue que de 1 seul digit
printRapport(" | temps systeme : $_[0]:$_[1]:$_[2] (processeur : $pourcent_proc\%)\n");
#conversion en 2 etapes du "temps reel" qui n est pas au meme format que les 2 autres (et il faut gerer les cas ou il manque hh ou mm)
# 1) on commence par etablir sa duree en secondes
my $temps_reel_en_secondes;
#cas ou le "temps reel" n est que en secondes
if($#temps_reel == 0) {$temps_reel_en_secondes = $temps_reel[0];}
#cas ou le "temps reel" est au format minutes:secondes
elsif($#temps_reel == 1) {$temps_reel_en_secondes = $temps_reel[1] + 60.*$temps_reel[0];}
#cas ou le "temps reel" est au format heures:minutes:secondes
elsif($#temps_reel == 2) {$temps_reel_en_secondes = $temps_reel[2] + 60.*$temps_reel[1] + 3600.*$temps_reel[0];}
#autre cas (improbable) => on met 0
else {$temps_reel_en_secondes = 0;}
# 2) maintenant, on traite la conversion comme vu precedemment
$_[0] = int($temps_reel_en_secondes/3600.);#nb heures
$_[1] = int(($temps_reel_en_secondes - $_[0]*3600.)/60.);#nb minutes
$_[2] = sprintf("%.2f", $temps_reel_en_secondes - $_[0]*3600. - $_[1]*60.);#secondes (avec les centiemes)
for(my $i=0; $i<=2; $i++) {$_[$i] = "0$_[$i]" if($_[$i] < 10);}#retouche cosmetique : rajout d un 0 davant le nombre si il n est constitue que de 1 seul digit
printRapport(" | temps reel : $_[0]:$_[1]:$_[2]\n");
}
close(Flog);
#cas ou le resultat de la commande time n a pas ete trouve dans le fichier .log (on ecrit juste un warning dans le rapport)
if(not $is_time_ok) {
printRapport(" (**Attention : impossible de saisir le temps de calcul)\n");
printRapport("\n");
}
printRapport(" -------------------------------------------------------\n");
printRapport("\n");
#####################################################################################################
#----------------------------------------------------------------------------------------------------
# VERIFICATION DU TEST
@ -607,6 +714,13 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
##############################################################
# boucle de comparaison des donnees (test entre chaque valeur des listes @donnees_temp_maple et @donnees_ref_maple)
##############################################################
#Strategie :
# on va accumuler les affichages dans la variable $sortie_rapport et regarder si une des grandeurs est ECHEC
# si une des grandeurs est ECHEC => on affichera le contenu de la variable dans le rapport
# sinon, si toutes les grandeurs sont OK => on fera un affichage leger sur une ligne pour dire que toutes les grandeurs sont OK
my $sortie_rapport = '';#variable tampon qui contiendra l integralite des affichages des resultats de comparaison maple
my $is_grandeur_ECHEC = 0;#indicateur de presence d au moins un ECHEC
for(my $i_valeur=0; $i_valeur<=$#donnees_temp_maple; $i_valeur++) {
#numero de colonne dans le .maple
my $no_colonne_maple = $i_valeur + 1;
@ -641,29 +755,22 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
$diff_relative_pourcent = sprintf("%.${nb_decimales_prec_relative}f", 100.*($valeur_temp-$valeur_ref)/$valeur_ref);
}
#ouverture du rapport de test
open (FSOR, ">> $repertoire_racine/Rapport/$fichier_rapport") || do {
printRapport("$repertoire_test/.CVisu$no_test\n -> ECHEC : Impossible d'ouvrir $repertoire_racine/Rapport/$fichier_rapport\n\n");
print "**Erreur Test $repertoire_test/.CVisu$no_test : Impossible d'ouvrir $repertoire_racine/Rapport/$fichier_rapport\n";
last BOUCLE_TEST;
};
print FSOR " -> grandeur testee : colonne \[$no_colonne_maple\]\n";
$sortie_rapport .= " -> grandeur testee : colonne \[$no_colonne_maple\]\n";
#############################
#comparaison absolue };
#############################
#---OK
if(abs($diff_absolue) <= $PREC_ABSOLU) {
print FSOR " - comparaison absolue (precision : $precision_absolue) -> OK\n";
$sortie_rapport .= " - comparaison absolue (precision : $precision_absolue) -> OK\n";
}
#---ECHEC
else {
print FSOR " - comparaison absolue (precision : $precision_absolue) -> ECHEC\n";
print FSOR " -> Valeur = $valeur_temp\n";
print FSOR " -> Valeur reference = $valeur_ref\n";
print FSOR " -> Difference = $diff_absolue\n";
$is_grandeur_ECHEC = 1;
$sortie_rapport .= " - comparaison absolue (precision : $precision_absolue) -> ECHEC\n";
$sortie_rapport .= " -> Valeur = $valeur_temp\n";
$sortie_rapport .= " -> Valeur reference = $valeur_ref\n";
$sortie_rapport .= " -> Difference = $diff_absolue\n";
}
#############################
@ -671,23 +778,35 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
#############################
#---cas d une comparaison impossible => affichage d un message d erreur (mais pas du mot ECHEC : ce n est pas un echec car la valeur de reference est egale a 0)
if($diff_relative_pourcent =~ /impossible/) {
print FSOR " - comparaison relative : impossible car valeur de reference egale a 0\n";
$sortie_rapport .= " - comparaison relative : impossible car valeur de reference egale a 0\n";
}
#---OK
elsif(abs($diff_relative_pourcent) <= $precision_relative) {
print FSOR " - comparaison relative (precision : $precision_relative\%) -> OK\n";
$sortie_rapport .= " - comparaison relative (precision : $precision_relative\%) -> OK\n";
}
#---ECHEC
else {
print FSOR " - comparaison relative (precision : $precision_relative\%) -> ECHEC\n";
print FSOR " -> Valeur = $valeur_temp\n";
print FSOR " -> Valeur reference = $valeur_ref\n";
print FSOR " -> Difference relative = $diff_relative_pourcent\%\n";
$is_grandeur_ECHEC = 1;
$sortie_rapport .= " - comparaison relative (precision : $precision_relative\%) -> ECHEC\n";
$sortie_rapport .= " -> Valeur = $valeur_temp\n";
$sortie_rapport .= " -> Valeur reference = $valeur_ref\n";
$sortie_rapport .= " -> Difference relative = $diff_relative_pourcent\%\n";
}
print FSOR "\n";
$sortie_rapport .= "\n";
}#for(my $i_valeur=0; $i_valeur<=$#donnees_temp_maple; $i_valeur++)
#si il y a au moins 1 ECHEC => ecriture de tout le contenu de $sortie_rapport
if($is_grandeur_ECHEC) {
printRapport($sortie_rapport);
}
#sinon, on signale que tout est OK
else {
printRapport(" -> pour toutes les grandeurs testees : OK\n\n");
}
close (FSOR);
}#elsif(-e $fichier_temp_maple)
@ -712,7 +831,7 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
#suppression du fichier de redirection
system("rm -f $fichier_test.log");
#suppression des eventuels fichiers resultats (ATTENTION : ne pas supprimer les fichiers .BI et .PI pour permettre un RESTART)
#suppression des eventuels fichiers resultats (ATTENTION : ne pas supprimer les fichiers .BI et .PI pour permettre un RESTART au .CVisu suivant)
#--- fichier .maple
system ("rm -f $fichier_temp_maple");
#--- fichiers Gmsh
@ -752,7 +871,6 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
##########################################################################
##########################################################################
##########################################################################
@ -767,18 +885,8 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
# derniers traitements avant retour au repertoire racine
#####################################################################################################
#restauration du .info d origine
system("mv -f $fichier_test.info_OLD $fichier_test.info");
#suppression de tout ce qui n etait pas present initialement dans le repertoire de test (fichiers et repertoires)
my %TAB_FICHIER_INITIAL;
#---on cree une table d indicateur de presence pour les fichiers initiaux (fichiers et repertoires contenus dans la liste @fichiers qui a ete constituee en debut de script)
foreach my $fic (@fichiers) {$TAB_FICHIER_INITIAL{$fic} = 1;}
#---et on supprime tout ce qui n a pas d indicateur
foreach my $fic (glob("*")) {
next if(defined($TAB_FICHIER_INITIAL{$fic}));#pas de suppression en cas d indicateur
system("rm -rf $fic");
}
#suppression repertoire de travail
system("rm -rf $repertoire_de_travail");
#####################################################################################################
# retour au repertoire racine
@ -862,7 +970,7 @@ sub lancement_commande {
# rq : l utilite de ce lien est qu il permettra de rechercher les pid de processus en reperant ce nom unique genere aleatoirement (pour eviter de tuer d autres processus Herezh qui n ont rien a voir avec la batterie de test)
##############################################################
#creation d un nom aleatoire
my $lien_symbolique_HZ = 'HZ'.int(rand(99999999999));
my $lien_symbolique_HZ = 'testHZ'.int(rand(99999999999));
#creation du lien symbolique
system("ln -s $hzchemin_original $lien_symbolique_HZ");
@ -871,7 +979,7 @@ sub lancement_commande {
#lancement du calcul Herezh dans un pipe
# rq : redirection de l affichage dans le fichier $fredir_tee
##############################################################
open(PIPE, "|$lien_symbolique_HZ $commande | tee $fredir_tee");
open(PIPE, "|tcsh -c \"time $lien_symbolique_HZ $commande\" | tee $fredir_tee");
PIPE->autoflush(1);#forcer a vider le tampon (methode autoflush du package IO::Handle)
#ecriture des reponses interactives si le fichier $fic_commande existe

BIN
doc_procedure_verification.pdf
View file

Binary file not shown.

4
verifier_exeHZ.pl
View file

@ -282,7 +282,7 @@ unless($is_opt_L or $is_opt_rpt) {
#creation du fichier rapport final
system("mv -f Rapport/rapport_test.txt Rapport/rapport_test_R.txt");
#affichage du rapport
system("nedit Rapport/rapport_test_R.txt &");
system("nedit Rapport/rapport_test_R.txt \&");
}
}
@ -324,7 +324,7 @@ unless($is_opt_R or $is_opt_rpt) {
#creation du fichier rapport final
system("mv -f Rapport/rapport_test.txt Rapport/rapport_test_L.txt");
#affichage du rapport
system("nedit Rapport/rapport_test_L.txt &");
system("nedit Rapport/rapport_test_L.txt \&");
}
}