source: TOOLS/PACK_IPSL/launch_and_measureTime.sh @ 1880

Last change on this file since 1880 was 1880, checked in by gpincka, 12 years ago

Suppression des donnees traitees correctement. Attention : les cmds rm sont commentees, mais avec les rm, les tests faits sont concluants
  • Property svn:executable set to *
File size: 19.9 KB
Line 
1#!/bin/bash
2
3function update_tasks_list
4{
5   local tasksListFile=$1 # fichier contenant la nouvelle liste de cmds
6   touch $tasksListFile
7   local logFileOfPrevPack=$2 # fichier log de relatif a l'execution de la derniere liste de cmds
8   local tasksListFileOfPrevPack=$3 # fichier contenant la derniere liste de cmds
9   
10   > $tasksListFile
11   
12   old_IFS=$IFS     # sauvegarde du séparateur de champ 
13   IFS=$'\n'     # nouveau séparateur de champ, le caractère fin de ligne   
14   for cmdReport in $( cat $logFileOfPrevPack )
15   do 
16       hasCmdGoodFormat=`echo $cmdReport | grep -e '^#executed by process' | wc -l `
17       if [ "x${hasCmdGoodFormat}" == "x0" ]
18       then
19           continue
20       fi
21       
22       local resCmd=`echo $cmdReport | awk '{print $9}' `
23       
24       if [ "x$resCmd" !=  "x0" ]
25       then
26           local cmdToPrint=`echo $cmdReport | awk '{print $NF}' `
27           case "x$resCmd" in
28           x5)
29               newCmdToPrint=`echo $cmdToPrint | sed 's;output_ncrcat;output_tar;' `
30               echo "./process_list.sh $newCmdToPrint" >> ${tasksListFile}
31           ;;
32           x10)
33               echo "./process_list.sh $cmdToPrint" >> ${tasksListFile}       
34               newCmdToPrint=`echo $cmdToPrint | sed 's;output_ncrcat;output_tar;' `
35               echo "./process_list.sh $newCmdToPrint" >> ${tasksListFile}
36           ;;
37           *)
38               echo "./process_list.sh $cmdToPrint" >> ${tasksListFile}
39           ;;
40           esac
41       fi
42   done
43   IFS=$old_IFS     # rétablissement du séparateur de champ par défaut
44   
45   # Il faut aussi rajouter les cmds qui n'ont pas ete traitees du tout,
46   # par exemple en cas d'interruption du calculateur
47   # Pour cela, on boucle sur la derniere liste de cmds et on cherche dans le
48   # fichier log associe si certaines sont absentes. On remet ces commandes (absentes)
49   # dans la nouvelle liste
50   old_IFS=$IFS     # sauvegarde du séparateur de champ 
51   IFS=$'\n'     # nouveau séparateur de champ, le caractère fin de ligne   
52   for cmd in $( cat $tasksListFileOfPrevPack )
53   do 
54       local list=`echo $cmd | awk '{print $NF}' `
55       hasListBeenTreated=`grep $list $logFileOfPrevPack | wc -l `
56       if [ "x${hasListBeenTreated}" == "x0" ]
57       then
58           echo $cmd  >> ${tasksListFile}
59       fi
60       
61 
62   done
63   IFS=$old_IFS     # rétablissement du séparateur de champ par défaut
64   
65   # Il peut arriver que 2 listes soient identiques, on empeche ce cas
66   cat ${tasksListFile} | sort | uniq > taskFile.txt
67   cat taskFile.txt > ${tasksListFile} 
68
69}
70
71function getNumeroOfCurrentTry
72{
73   local num_try="1"
74   tryNumFile=${USER_OUTPUT_PROGRESS}/numero_current_try.txt
75   if [ ! -e $tryNumFile ]
76   then
77       echo "Le fichier :" >> $badFailureFile
78       echo "$tryNumFile" >> $badFailureFile
79       echo "doit etre present dans le repertoire :" >> $badFailureFile
80       echo "${USER_OUTPUT_PROGRESS}" >> $badFailureFile
81       echo "et il doit contenir un numero d'essai" >> $badFailureFile
82       exit 1
83   fi
84   num_try=`head -n 1 $tryNumFile `
85   echo $num_try
86   
87}
88
89function getNumeroOfLastInstance
90{
91    local num_instance="0"
92    local numTry=$1
93    ici=$PWD
94    local progressDirectory="${USER_OUTPUT_PROGRESS}/TRY__${numTry}"
95    if [ ! -e $progressDirectory ]
96    then
97        echo "fonction getNumeroOfLastInstance :" >> $badFailureFile
98        echo "Le repertoire :" >> $badFailureFile
99        echo "$progressDirectory" >> $badFailureFile
100        echo "devrait exister. Il n'existe pas." >> $badFailureFile
101        exit 1
102    fi   
103    cd $progressDirectory
104   
105    listFiles=`ls | grep -e "inputCmd__try__${numTry}__instance__[[:digit:]]\{1,2\}.list" `
106    for listFile in $listFiles
107    do
108       num=`echo $listFile | awk -F"__" '{print $NF}' | awk -F"." '{print $1}' `
109       if [ $num -gt $num_instance ]
110       then
111           num_instance=$num 
112       fi
113    done 
114    cd $ici
115    echo $num_instance
116
117
118}
119
120
121function check_progress
122{
123   local file1=$1
124   local file2=$2
125   local file_to_get_retCode=$3
126   if [ "x${file1}" == "x" ] || [ "x${file2}" == "x" ] || [ "x${file_to_get_retCode}" == "x" ]
127   then
128       echo "check_progress : Le nom d'au moins 1 des 3 fichiers d'entree est vide" >> $badFailureFile
129       exit 1
130   fi
131     
132   if [ ! -e $file1 ] || [ ! -e $file2 ] || [ ! -e ${file_to_get_retCode} ]
133   then
134       echo "check_progress : au moins un des 3 fichiers suivants n'existe pas :" >> $badFailureFile
135       echo "$file1" >> $badFailureFile
136       echo "$file2" >> $badFailureFile
137       echo "${file_to_get_retCode}" >> $badFailureFile
138       exit 1
139   fi
140   local nbLineFile1=`cat $file1 | wc -l `
141   local nbLineFile2=`cat $file2 | wc -l `
142   if [ $nbLineFile1 -ne $nbLineFile2 ]
143   then
144       echo 1
145       return
146   fi
147   # si l'on parvient a ce stade, c'est les 2 fichiers ont le meme
148   # nombre de lignes
149   
150   old_IFS=$IFS     # sauvegarde du séparateur de champ 
151   IFS=$'\n'     # nouveau séparateur de champ, le caractère fin de ligne   
152   for line in $( cat $file1 )
153   do
154       # echo $line
155       local isLineInFile2=`grep $line $file2 | wc -l `
156       if [ $isLineInFile2 -eq 0 ]
157       then
158           echo 1
159           return
160       fi
161   done
162   IFS=$old_IFS     # rétablissement du séparateur de champ par défaut
163   
164   # Les codes de retour sont-ils != 0 ?
165   nbNonZeroCodes=`cat ${file_to_get_retCode} | grep -e '^#executed by' | awk '{ if ($9 != 0) {print $9} }' | wc -l `
166   if [ $nbNonZeroCodes -gt 0 ]
167   then
168       echo 1
169       return
170   fi
171     
172   echo 0
173}
174
175
176function update_report
177{ 
178    > $reportFile # on vide le fichier rapport
179    echo "Execution of tasks :" >> $reportFile
180    echo "------------------" >> $reportFile
181    cat $inputCmd >> $reportFile
182    echo >> $reportFile
183    echo "Results of tasks :" >> $reportFile 
184    echo "----------------" >> $reportFile
185    cat $output >> $reportFile
186    echo >> $reportFile
187    echo >> $reportFile
188
189}
190
191function searchListsToDestroy
192{
193     outputToSearchIn=$1
194     listToRmvFile=$2
195     cat ${outputToSearchIn} | grep -e '^#executed by' | awk '{ if ($9 == 0) {print $12} }' >> ${listToRmvFile}
196}
197function removeFilesInLists
198{
199     setOfFileLstsToRmv=$1
200     rmvedFiles=$2
201     linksToEraseFile=$3
202     realDataToEraseFile=$4
203     
204     old_IFS=$IFS     # sauvegarde du séparateur de champ 
205     IFS=$'\n'     # nouveau séparateur de champ, le caractère fin de ligne
206     
207     # Suppression des donnees autres que celles de type "debug" et "restart".
208     for lst in $( cat $setOfFileLstsToRmv | grep -v -E '(restart_tar|debug_tar)' )
209     do
210         opt=
211         lstName=$( basename $lst )
212         
213         if [ "${lstName}" == "tar_full_simul.list" ] || [ "${lstName}" == "cp_files.list" ]
214         then
215             opt="r"
216         fi
217                 
218         for file in $( cat $lst )
219         do
220             echo "rm -f${opt} $file" >> ${rmvedFiles}
221             # rm -f${opt} $file
222         done     
223     done
224     
225     # Pour les listes de type "debug" et "restart", les listes ne comportent
226     # que des liens : uniquement leur nom de base, pas leur path
227     # Il faut retrouver leur path, detruire le lien et le fichier qu'il pointe.
228           
229     # Recherche de l'ensemble des fichiers a detruire : les liens + les donnees pointees par les liens
230     for lst in $( cat $setOfFileLstsToRmv | grep -E '(restart_tar|debug_tar)' )
231     do
232         # Recuperation du repertoire contenant les fichiers de liens
233         dir_containing_links=
234         is_debug_tar_lst=`echo $lst | grep "debug_tar" | wc -l `
235         if [ "x${is_debug_tar_lst}" != "x0" ]
236         then
237             dir_containing_links="DEBUG"
238         else
239             dir_containing_links="RESTART"
240         fi
241         
242         tar_dir=$( dirname $lst )
243         simu_dir=$( dirname $tar_dir )
244         
245         LINK_DIR="${simu_dir}/${dir_containing_links}"
246         if [ ! -d  $LINK_DIR ]
247         then
248             echo "Suppression des donnees :" >> $badFailureFile
249             echo "Le repertoire sense contenir des liens symboliques :" >> $badFailureFile
250             echo "${LINK_DIR}" >> $badFailureFile
251             echo "n'existe pas." >> $badFailureFile
252             exit 1
253         fi
254         
255         #
256         # ls sur le reperoire de lien et insertion du path absolu avant chaque lien.
257         ls -1 ${LINK_DIR} | sed "s;^;${LINK_DIR}/;" >> ${linksToEraseFile}
258         
259         # Recuperation des donnees reelles pointees par les liens.
260         ls -1 -lrt ${LINK_DIR} | awk -F"->" '{print $2}' | sed 's;^ ;;' >> ${realDataToEraseFile}
261     done
262     
263     # Destruction des liens et des donnees pointees par les liens pour les listes
264     # de type "debug" et "restart"
265     
266     # Destroy links
267     for file in $( cat ${linksToEraseFile} )
268     do
269         echo "rm -f $file" >> ${rmvedFiles}
270         # rm -f $file
271     done
272     
273     # Destroy real datas
274     for file in $( cat ${realDataToEraseFile} )
275     do
276         echo "rm -f $file" >> ${rmvedFiles}
277         # rm -f $file
278     done     
279     
280     IFS=$old_IFS     # rétablissement du séparateur de champ par défaut
281}
282
283
284export RANDOM=$$ # random seed
285function gives_random_number
286{
287   lim=$1
288   bit=-1
289   let "bit = RANDOM % $lim"
290   bit=$(( $bit + 1 )) # nb entre 1 et $limit
291   echo $bit
292}
293
294########## batch directives : begin ##########
295#MSUB -r pack_ipsl          # Nom du job               
296### mutable directives ###
297#MSUB -o /ccc/dmfbuf/import_data.2/ccrt/dmnfs12/cont003/bacasable/GUILLAUME/PSEUDO_DMNFS_PROGRESS/zIGCM_OUT_only_2_simu/LMDZ4OR_v2/detailed_pack_output/pack_ipsl_%I.o
298#MSUB -e /ccc/dmfbuf/import_data.2/ccrt/dmnfs12/cont003/bacasable/GUILLAUME/PSEUDO_DMNFS_PROGRESS/zIGCM_OUT_only_2_simu/LMDZ4OR_v2/detailed_pack_output/pack_ipsl_%I.e
299#MSUB -n 7
300#MSUB -T 1500
301#MSUB -A tgcc0013
302#MSUB -q standard
303#MSUB -Qos test
304########## batch directives : end ##########
305
306export JOB_DIR=${LS_SUBCWD:-${PWD}}
307export EXE_DIR=${JOB_DIR}
308source ${EXE_DIR}/DEM_utilities.sh
309
310export badFailureFile=${USER_OUTPUT_PROGRESS}/badFailure.txt
311
312export numCurrentTry=$( getNumeroOfCurrentTry )
313export progressDir="${USER_OUTPUT_PROGRESS}/TRY__${numCurrentTry}"
314if [ ! -e $progressDir ]
315then
316   echo "Le repertoire de suivi :" >> $badFailureFile
317   echo "$progressDir" >> $badFailureFile
318   echo "n'existe pas. STOP." >> $badFailureFile   
319   exit 1
320fi
321export numPrevInstance=$( getNumeroOfLastInstance $numCurrentTry )
322export numNewInstance=$(( $numPrevInstance + 1 ))
323
324export inputCmd="${progressDir}/inputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
325export nextInputCmd="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numNewInstance}.list"
326export output="${progressDir}/packOutput__try__${numCurrentTry}__instance__${numNewInstance}.log"
327export reportFile="${progressDir}/report__try__${numCurrentTry}__instance__${numNewInstance}.log"
328export checkFile="${progressDir}/check__try__${numCurrentTry}__instance__${numNewInstance}.log"
329export checkFileTmp="checkTmp__try__${numCurrentTry}__instance__${numNewInstance}.txt"
330
331export listsOfFilesToRemove="${progressDir}/listsToRmv__try__${numCurrentTry}__instance__${numNewInstance}.txt"
332export removedFiles="${progressDir}/removedFiles__try__${numCurrentTry}__instance__${numNewInstance}.txt"
333
334# Les 2 fichiers suivants sont crees pour la destruction des liens et des donnees pointes par ces liens
335# dans le cas de listes de type "debug" ou "restart"
336export linksToDestroyFile="${progressDir}/linksToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
337export realDataToDestroyFile="${progressDir}/realDataToDestroy__try__${numCurrentTry}__instance__${numNewInstance}.txt"
338
339export noInterruptFile="${progressDir}/noInterrupt__try__${numCurrentTry}__instance__${numNewInstance}.txt"
340
341
342if [ ${numCurrentTry} -le 1 ] && [ ${numNewInstance} -le 1 ]
343then
344    # C'est le tout premier essai
345    # on construit la liste des taches a effectuer en inventoriant les fichiers *.liste
346    # dans les rep contenus dans le fichier "config_card.liste"
347    > ${inputCmd}
348    for CONFIG in $( awk '{print $1}' ${IGCM_DEM}/config_card.liste ) ; do
349   
350       PATH_SIMU=$( dirname $CONFIG )
351       # echo "PATH_SIMU=$PATH_SIMU"
352
353       setOfListFiles=`find $PATH_SIMU -type f -name "*.list" `
354       for file in $setOfListFiles
355       do
356            echo "./process_list.sh $file" >> ${inputCmd}
357       done     
358    done
359   
360else
361    # if try > 1 && inst == 1 ==> construction liste cmd avec fichiers try - 1, derniere instance
362    #                             dans ce dernier cas, gerer une eventuelle interruption au try - 1
363    # if try > 1 && inst > 1  ==> construction liste cmd avec fichiers try, instance precedente
364    if [ ${numNewInstance} -ge 2 ]
365    then
366        nextInputCmd_of_PrevInst="${progressDir}/nextInputCmd__try__${numCurrentTry}__instance__${numPrevInstance}.list"
367        if [ ! -e $nextInputCmd_of_PrevInst ]
368        then
369            echo "Le fichier suivant :" >> $badFailureFile
370            echo "$nextInputCmd_of_PrevInst" >> $badFailureFile
371            echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
372            exit 1
373        fi
374        cat $nextInputCmd_of_PrevInst > ${inputCmd}
375   
376    else # numNewInstance == 1
377        numPrevTry=$(( $numCurrentTry - 1 ))
378        numLastInstInstanceInPrevTry=$( getNumeroOfLastInstance $numPrevTry )
379        noInterruptFile_prev_try="${progressDir}/noInterrupt__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
380        if [ ! -e ${noInterruptFile_prev_try} ]
381        then
382            # il y a eu interruption non prevue au dernier essai, il faut recomposer la liste des cmds avec les resultats
383            # de l'essai precedent, derniere instance
384            prevProgressDir="${USER_OUTPUT_PROGRESS}/TRY__${numPrevTry}"
385            nextInputCmd_of_LastInst="${prevProgressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
386            output_of_LastInst="${prevProgressDir}/packOutput__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.log"
387            inputCmd_of_LastInst="${prevProgressDir}/inputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
388            if [ ! -e $output_of_LastInst ] || [ ! -e $inputCmd_of_LastInst ]
389            then
390                echo "Les fichiers suivants :" >> $badFailureFile
391                echo "$output_of_LastInst" >> $badFailureFile
392                echo "$inputCmd_of_LastInst" >> $badFailureFile
393                echo "n'existent pas. Il devrait exister. STOP." >> $badFailureFile
394                exit 1
395            fi
396           
397            update_tasks_list ${nextInputCmd_of_LastInst} ${output_of_LastInst} ${inputCmd_of_LastInst}
398            cat $nextInputCmd_of_LastInst > ${inputCmd}
399           
400           
401            # Il faut aussi detruire les donnees correctement traitement a l'essai precedent, derniere instance.
402            listsOfFilesToRemoveFromPrevTry="${progressDir}/listsToRmvFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
403            removedFilesFromPrevTry="${progressDir}/removedFilesFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
404            linksToDestroyFileFromPrevTry="${progressDir}/linksToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
405            realDataToDestroyFileFromPrevTry="${progressDir}/realDataToDestroyFromPrev__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.txt"
406                   
407            searchListsToDestroy $output_of_LastInst $listsOfFilesToRemoveFromPrevTry
408            removeFilesInLists $listsOfFilesToRemoveFromPrevTry $removedFilesFromPrevTry $linksToDestroyFileFromPrevTry $realDataToDestroyFileFromPrevTry
409           
410        else
411            nextInputCmd_of_LastInst="${progressDir}/nextInputCmd__try__${numPrevTry}__instance__${numLastInstInstanceInPrevTry}.list"
412            if [ ! -e $nextInputCmd_of_LastInst ]
413            then
414                echo "Le fichier suivant :" >> $badFailureFile
415                echo "$nextInputCmd_of_LastInst" >> $badFailureFile
416                echo "n'existe pas. Il devrait exister. STOP." >> $badFailureFile
417                exit 1
418            fi
419            cat $nextInputCmd_of_LastInst > ${inputCmd}
420        fi
421       
422    fi
423fi
424
425# Initialisation du rapport : par defaut, les calculs ont ete interrompus
426echo "No report. Le computation must have been interrupted." > $reportFile
427
428# exit 0 # a virer
429
430# a virer #########################################
431# if [ ${numNewInstance} -ge 10 ]
432# then
433#     echo >> $badFailureFile
434#     echo "10eme instance. STOP." >> $badFailureFile
435#     exit 1
436# fi
437###################################################
438# startTime=$( getDateMilliSeconds ) # suppr
439# echo "start time:$startTime" >> $timeHandlingFile # suppr
440> $timeEndFile # added
441
442ccc_mprun  ./glost_launch -R $timeLimitBeforeEnd ${inputCmd} 2>${output}
443
444### ccc_mprun  ./cmd_launch.exe ${inputCmd} 2>${output}
445
446###    ./cmd_launch.exe ${inputCmd} 2>${output}
447###    ccc_mprun -p standard -n ${BRIDGE_MSUB_NPROC} ./cmd_launch.exe ${inputCmd} 2>myIO/output.log
448###    mpirun -n 4 ./cmd_launch.exe myIO/inputCmd10.list 2>myIO/output.log
449
450# meantime=$( getTimeDiffSeconds $startTime ) # suppr
451
452endExecutionTime=$( getDateMilliSeconds )
453echo "end time:$endExecutionTime" >> $timeEndFile
454
455
456
457# echo "meantime ncrcat = $meantime"
458
459# exit 0 # a virer
460
461# Gestion des reprises :
462# --------------------
463
464update_report
465
466update_tasks_list $nextInputCmd $output $inputCmd
467
468
469# Verifications sur qq listes (dont le traitement semble correct) :
470# ----------------------------------------------------------------------------------------
471if [ "x${doYouWantCheck}" == "xyes" ]
472then
473    if [ "x${nbListsToCheck}" == "x" ]
474    then
475        echo "nbre de listes a checker absent" >> $checkFile
476        echo "nbre de listes a checker absent" >> $badFailureFile
477        exit 1
478    fi
479    > $checkFileTmp
480    # ensemble des listes concatenees correctement
481    set_of_good_lists=`cat $output | grep -e '^#executed by process' | awk '{ if ($9==0){print $12} }' | grep "output_ncrcat" `
482
483    # envoi des cmds de check dans fichier tmp
484    for lst in $set_of_good_lists
485    do
486       echo "./check_ncrcat_list.sh $lst" >> $checkFileTmp
487    done
488
489    # nombre de listes concatenees correctement
490    nb_of_good_lists=`cat $checkFileTmp | wc -l `
491
492    # le nb de listes a checker ne peut exceder le nb de listes disponibles pour le check
493    if [ $nbListsToCheck -ge $nb_of_good_lists ]
494    then
495        nbListsToCheck=$nb_of_good_lists
496    fi
497    nbLstToCheck_tmp=$nbListsToCheck
498
499    while [ $nbLstToCheck_tmp -gt 0 ]
500    do
501        random_number=$( gives_random_number $nbLstToCheck_tmp ) # nb aleatoire entre 1 et $nbLstToCheck_tmp
502        checkCmd=`sed -n "${random_number}p" $checkFileTmp `
503        $checkCmd # on envoie la cmd de check
504        resCmd=$?
505        if [ "x${resCmd}" != "x0" ]
506        then
507            echo "$checkCmd ==> not OK ==> stop everything." >> $checkFile
508            echo "$checkCmd ==> not OK ==> stop everything." >> $badFailureFile
509            exit 1 # a retablir
510        else
511            echo "$checkCmd ==> OK" >> $checkFile
512        fi
513        sed -i "${random_number}d" $checkFileTmp # on retire la cmd qui vient d'etre effectuee du fichier tmp
514        nbLstToCheck_tmp=$(( $nbLstToCheck_tmp - 1 ))
515    done
516
517
518    rm $checkFileTmp
519fi
520# ----- Fin verif ------------------------------------------------------------------------
521
522
523# Suppression des données des fichiers de listes correctement traitees -------------------
524# Recherche des listes de fichiers de donnees a detruire :
525# Parmi celles traitees, celles qui ont ete traitees correctement
526> $listsOfFilesToRemove
527> $removedFiles
528> $linksToDestroyFile
529> $realDataToDestroyFile
530
531searchListsToDestroy $output $listsOfFilesToRemove
532
533removeFilesInLists $listsOfFilesToRemove $removedFiles $linksToDestroyFile $realDataToDestroyFile
534
535
536
537
538
539
540# ----- Fin suppression de donnees -------------------------------------------------------
541
542# Si le fichier dans variable "noInterruptFile" inexistant, une interruption non prevue a eu lieu
543echo "no interruption has occured" > ${noInterruptFile}
544
545# exit 0 # a virer
546
547# Tout s'est bien passe
548# ----------------------
549everythingOK=`cat $nextInputCmd | wc -l `
550if [ "x${everythingOK}" == "x0" ]
551then
552    echo "Tout s'est fini correctement" >> $badFailureFile
553    exit 0
554fi
555
556# Y a t il progression entre avant traitements et apres ?
557# ------------------------------------------------------
558# Dans la fonction 'check_progress', on a besoin de verifier le code
559# de retour du traitement des listes : en effet, si les 2 fichiers a comparer
560# contiennent les memes fichiers de liste, il faut aussi que les codes de
561# retour soient != 0.
562file_to_get_lists_retCode=$output
563resDiff=$( check_progress $inputCmd $nextInputCmd $file_to_get_lists_retCode )
564
565# resDiff == 1 : fichiers differents
566# resDiff == 0 : fichiers identiques
567if [ "x${resDiff}" == "x0" ]
568then
569    echo "Il n'y pas plus de progression" >> $badFailureFile
570    exit 1
571fi
572
573# On enchaine avec le meme script
574ccc_msub launch_and_measureTime.sh
Note: See TracBrowser for help on using the repository browser.