#!/bin/csh
#######################################################################################################################################
# #
# E X E C U T I O N D ' U N E C O M M A N D E S U R U N E L I S T E #
# D E F I C H I E R D E P O S T F I X E D O N N E #
# A L ' E X C L U S I O N D E C E Q U I R E S I D E R A I T D A N S ' $xTG ' : #
# #
# #
# Utilisation : #
# #
# $xcg/FindExec.01$Z AbortFindExec [<Commandes>] #
# $xcg/FindExec.01$Z <directory> <postfixe> "<ComS>[,<ComP>[,<ComV>]]" [<exclusions> [<arguments> [<ListeFichierA>]]] #
# #
# en materialisant par '"$K_VIDE"' les arguments #
# absents lorsque '$ListeFichierA' est present et #
# que le tout est execute via un 'job'... #
# #
# #
# Blocage/Deblocage (en cours d'execution) par : #
# #
# BloqueP $xcg/FindExec.01$Z #
# DBloqueP $xcg/FindExec.01$Z #
# #
# mais ATTENTION, ne fonctionne pas en mode "Parallele 'Linda'" ; dans ce cas, #
# quelque chose de plus specifique existe et le "mode d'emploi" est alors edite, #
# sachant qu'il y a autant de {BloqueP,DBloqueP}s que de branches paralleles #
# possibles (2, 4,...). #
# #
# Mais ATTENTION alors au cas ou les commandes sont executees par #
# paquets ('v $xcs/Linda$vv$Z TaillePaquets') ; il peut alors etre #
# necessaire d'attendre longtemps avant le blocage effectif : c'est en #
# particulier le cas avec les 'Gserveur's... #
# #
# #
# Variables ('setenv') de controle : #
# #
# SFindExec [=$EXIST] : Forcer la definition d'alias et de variables "complementaires". #
# #
# FindExec_InverserOrdre [=$NEXIST] : Inverser l'ordre de traitement des commandes. #
# #
# FindExec_MessagesBP [=$EXIST] : Editer les messages relatifs aux Branches Paralleles. #
# #
# FindExec_Editer [=$NEXIST] : Editer le mode (parallele ou sequentiel utilise), #
# FindExec_Parallele [=$EXIST] : Autoriser le mode parallele (mode par defaut), #
# FindExec_ParalleleLinda [=$EXIST] : En cas de mode parallele, utiliser le mode 'Linda'. #
# #
# ProcessorNumber [=Nombre] : Nombre de processeurs utilisables. #
# #
# #
# Author of '$xcg/FindExec.01$Z' : #
# #
# Jean-Francois COLONNA (LACTAMME, AAAAMMJJhhmmss). #
# #
#######################################################################################################################################
set DiReCtOrY=$1
set PoStFiXe=$2
set CoMmAnDe="$3"
# La mise entre '$K_QD' a ete introduite le 20030514174020 afin de pouvoir utiliser des #
# commandes avec des arguments ('v $xcg/GENERE$EXT$Z FindExec.01.Z' par exemple...). #
set ExClUsIoNs="$4"
# La liste d'exclusion s'utilisera eventuellement de la facon suivante : #
# #
# $xcg/FindExec.01$Z <directory> <postfixe> <commande> "! -name NOM1 ! -name NOM2 ..." #
# #
# ce qui eliminera les noms 'NOM1', 'NOM2',... #
# #
# A compter du 20090207113437, afin de resoudre le probleme de la parallelisation (au passage #
# impossible) de la compilation des '$K' de '$xcp' ('v $xcc/RecompileAll$Z 20090207113809), #
# la liste d'exclusion s'utilisera de la facon plus naturelle suivante : #
# #
# $xcg/FindExec.01$Z <directory> <postfixe> <commande> "NOM1 NOM2 ..." #
# #
# ce qui eliminera les noms 'NOM1', 'NOM2',... #
set ArGuMeNtS="$5"
# Liste d'arguments a communiquer eventuellement "au bout" de la commande '$CoMmAnDe'. Ceci #
# a ete introduit le 20041025141201 pour utiliser 'v $xcc/RecompileAll$Z 20041025144750', #
# par exemple, de facon selective en ne recompilant que les '$K' qui sont du type #
# 'PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES'... #
set ListeFichierA=$6
# Pour pouvoir recuperer une liste anterieure '$ListeFichier' (introduit le 20090615143636), #
# mais evidemment cela n'a de sens que si 'v $xcs/Linda$vv$Z' est utilise, puisque dans ce #
# cas le fichier '$ListeFichier' est progressivement "amaigri", les commandes executees #
# y etant supprimees (on suppose evidemment que le 'v $xcs/Linda$vv$Z' anterieur a ete #
# interrompu proprement, c'est-a-dire en utilisant 'BloqueP'...). #
# #
# ATTENTION, si '$xcg/FindExec.01$Z' est execute via un 'job' et si l'un des arguments (ou #
# les deux...) '$ExClUsIoNs' et '$ArGuMeNtS' sont vides, alors ils doivent etre materialises #
# par '"$K_VIDE"', c'est-a-dire ainsi : #
# #
# job $xcg/FindExec.01$Z DiReC PoSt CoMm '"$K_VIDE"' '"$K_VIDE"' ListeFichierA #
# #
# lorsque '$ListeFichierA' est present... #
if ("$DiReCtOrY" == "AbortFindExec") then
pause "Est-ce bien necessaire d'aborter tous les process de '"'$xcg/FindExec.01$Z'"' sur '$sHOTEex' ?"
pause "Faire tous les 'BloqueP's utiles a bloquer tous les processus et attendre que cela soit effectif."
pause "Est-ce toujours d'accord pour aborter tous les process de '"'$xcg/FindExec.01$Z'"' sur '$sHOTEex' ?"
set Commandes="$PoStFiXe"
# Introduit le 20131128145729... #
(Ps) | \
$EGRE "FindExec.01$Z|Linda$vv$Z|parallele.1N$X$Commandes" | \
$AW ' { print "'"($KILL -$aborte"' " $4 "'") >& $nul"'" } ' | \
$GRE -v " $$)" | \
$CSH -s
# On notera la mise entre parentheses du '$KILL' afin que le '$CSH' ne rende pas la main #
# des qu'un : #
# #
# nnnnn: No such process #
# #
# est rencontre... #
# #
# Le 20131127174432 j'ai supprime le '$xcg/FindExec.01$Z' courant (c'est-a-dire '$$') afin #
# d'eviter le message : #
# #
# Killed #
# #
# d'auto-abort... #
# #
# On notera le 20131128145729, l'introduction de commandes suplementaires a tuer selon #
# la syntaxe : #
# #
# $xcg/FindExec.01$Z AbortFindExec "|valgrind|Mesures.01$vv$Z" #
# $xcg/FindExec.01$Z AbortFindExec "|valgrind|RMesures.01$vv$Z" #
# $xcg/FindExec.01$Z AbortFindExec "|valgrind|Mesures_CDC_seules.01$vv$Z" #
# #
# /|\ /|\ #
# | | #
# ATTENTION au "|" en tete de liste ------- puis - #
# #
# par exemple... #
ATTENTION "Il peut etre necessaire de recommencer une deuxieme fois, voire plus..."
saut 2
exit $OK
# Introduit le 20131125145756 : ce n'est peut-etre pas tres elegant de faire ce 'exit', #
# mais c'est le plus simple... #
else
endif
set VDiReCtOrY=`echo "$DiReCtOrY" | $GRE "^$K_sepS"`
#20131206093713____:if (("$DiReCtOrY" == "$Dcourant") || (! -e $DiReCtOrY)) then #
#20131209162927____:if ("$VDiReCtOrY" == "$K_VIDE") then #
if (("$DiReCtOrY" != "$K_VIDE") && ("$VDiReCtOrY" == "$K_VIDE")) then
# La modification du 20131209162927 est destinee a prendre en compte les cas ou l'on #
# "repart" sur une liste anterieure '$ListeFichierA'... #
#20131206093713____: EROR "Le directory '$DiReCtOrY' n'existe pas ou est le directory courant." #
EROR "Le directory '$DiReCtOrY' doit etre absolu."
# Et ceci a cause de la modification 'v $xcg/FindExec.01$Z 20130923103512' qui force le #
# directory courant ('$xT') et fait donc perdre le directory courant precedent... #
exit $OK
# Ce n'est peut-etre pas tres elegant de faire ce 'exit', mais c'est le plus simple... #
else
endif
unset VDiReCtOrY
if ( ("$DiReCtOrY" == "$K_VIDE") \
&& ("$PoStFiXe" == "$K_VIDE") \
&& ("$CoMmAnDe" == "$K_VIDE") \
&& ("$ExClUsIoNs" == "$K_VIDE") \
&& ("$ArGuMeNtS" == "$K_VIDE") \
&& ("$ListeFichierA" == "$K_VIDE") \
) then
# Test introduit le 20130307181610... #
EROR "Il n'y a aucun arguments."
pause "Doit-on continuer malgre tout (un <CTRL-C><ENTER> arrete tout) ?"
pause "Est-ce bien sur (un <CTRL-C><ENTER> arrete tout) ?"
else
endif
#20190930152626____:set DCoMmAnDe=`GetPath $CoMmAnDe` #
set VCoMmAnDe=($CoMmAnDe)
set DCoMmAnDe=`GetPath $VCoMmAnDe[$#VCoMmAnDe]`
unset VCoMmAnDe
# La modification du 20190930152626 est destinee a traiter, par exemple, le cas ou #
# '$CoMmAnDe' serait : #
# #
# duree $xcc/cbg$Z #
# #
if ("$DCoMmAnDe" == "$xcc") then
# Test introduit le 20190412170519... #
#20220105112608____: ATTENTION "En cas de compilations, il peut etre utile de faire un $K_QS""trouvV""$K_QS au prealable \\c" #
ATTENTION "En cas de compilations, il peut etre utile de faire un $K_QS""trouvV""$K_QS au prealable \c"
echo "au cas ou des fichiers utiles seraient restes verrouilles apres une eventuelle compilation anterieure abortee."
saut 2
# Introduit le 20190412161205 suite a 'v $xcc/cpp$Z 20190412140849' probleme, cause par #
# le fichier 'v $ximd/DerivFormel.1$DEF' qui etait reste verrouille suite a une compilation #
# anterieure abortee. Or malheureusement, on ne peut editer des messages d'avertissement #
# dans 'v $xi/DerivFormel$Z 20190412143041' puisque toutes les sorties sont redirigees #
# vers des "pipes" et/ou des fichiers... D'ou ce message preliminaire... #
else
endif
unset DCoMmAnDe
if ($?SFindExec == $NEXIST) then
setenv SFindExec $EXIST
# Afin de pouvoir forcer la definition d'alias et de variables "complementaires" (introduit #
# le 20150205112002). #
# #
# Le 20150205112935, je note que cela n'a d'utilite qu'en mode sequentiel car, en effet, #
# en mode parallele c'est dans 'v $xcs/Linda$vv$Z SLinda' que c'est utile... #
else
endif
if ($?FindExec_InverserOrdre == $NEXIST) then
setenv FindExec_InverserOrdre $NEXIST
# Afin de pouvoir inverser l'ordre d'execution des commandes (introduit le 20101119092146 #
# sous cette forme...). #
else
endif
if ($?FindExec_MessagesBP == $NEXIST) then
setenv FindExec_MessagesBP $EXIST
# Afin de pouvoir editer les messages relatifs aux Branches Paralleles (introduit le #
# 20150205105239). #
else
endif
if ($?FindExec_Editer == $NEXIST) then
#20090207095538____: set FindExec_Editer=$NEXIST #
setenv FindExec_Editer $NEXIST
# Afin d'editer la methode utilisee (introduit le 20090119164517). #
# #
# Le 'set' fut remplace par un 'setenv' le 20090207095538 afin de rappeler son usage en #
# tant que parametre de configuration "externe" a '$xcg/FindExec.01$Z'... #
else
endif
if ($?FindExec_Parallele == $NEXIST) then
#20090207095538____: set FindExec_Parallele=$EXIST #
#20190106102324____: setenv FindExec_Parallele $EXIST #
# Introduit le 20090119164517 pour autoriser ('$EXIST') ou inhiber ('$NEXIST') la #
# parallelisation... #
# #
# Le 'set' fut remplace par un 'setenv' le 20090207095538 afin de rappeler son usage en #
# tant que parametre de configuration "externe" a '$xcg/FindExec.01$Z'... #
if ($ProcessorNumber > 1) then
# Test introduit le 20190106102324... #
setenv FindExec_Parallele $EXIST
else
setenv FindExec_Parallele $NEXIST
endif
else
endif
if ($?FindExec_ParalleleLinda == $NEXIST) then
#20090207095538____: set FindExec_ParalleleLinda=$NEXIST #
#20090209092816____: setenv FindExec_ParalleleLinda $NEXIST #
setenv FindExec_ParalleleLinda $EXIST
# Introduit le 20090119105236 pour autoriser ('$EXIST') ou inhbier ('$NEXIST') la methode #
# 'v $xcs/Linda$vv$Z'. On notera que cette methode, si elle utilise au mieux le #
# parallelisme (ce que ne fait pas l'autre methode, puisque '$xcg/parallele.1?$X' ne #
# rend la main que lorsque toutes les commandes qu'il lance sont terminees), presente #
# un defaut celui de ne pas sortir les messages {stdout,stderr} dans le bon ordre... #
# Enfin, la directive 'TestP' ne peut etre utilisee ('v $xcg/FindExec.01$Z 20090119105236'). #
# C'est pour toutes ces raisons qu'a priori le parallelisme de type 'Linda' est inhibe... #
# #
# Le 'set' fut remplace par un 'setenv' le 20090207095538 afin de rappeler son usage en #
# tant que parametre de configuration "externe" a '$xcg/FindExec.01$Z'... #
else
endif
set CoMmAnDeS=`echo "$CoMmAnDe" | $AW -F "," ' { print $1 } '`
# Definition de la commande "Serie" (introduite le 20090119081320). #
set CoMmAnDeP=`echo "$CoMmAnDe" | $AW -F "," ' { print $2 } '`
# Definition de la commande "Parallele" (introduite le 20090119081320). #
set CoMmAnDeV=`echo "$CoMmAnDe" | $AW -F "," ' { print $3 } '`
# Afin de valider l'argument '$CoMmAnDe'... #
setArgum CoMmAnDeP "$CoMmAnDeS"
# Definition de la commande "Parallele" par defaut... #
if ("$CoMmAnDeV" != "$K_VIDE") then
EROR "Trop de commandes ont ete precisees : les commandes supplementaires sont ignorees."
else
endif
unset CoMmAnDeV
set ExClUsIoNs=`echo "$ExClUsIoNs" | $SE -e "s/! *-name *//g"`
# Nettoyage a priori (en cas d'usage de type compatibilite) introduit le 20090207113437. #
if ("$ExClUsIoNs" == "!") then
EROR "La liste des exclusions ('$ExClUsIoNs') est incorrecte, elle est donc ignoree."
set ExClUsIoNs="$K_VIDE"
# Introduit le 20070130120852 suite a une tentative de lancer : #
# #
# job $xcg/FindExec.01$Z $x $X $xcc/clg$Z "! -name cpp$X" ... #
# #
# l'argument "! -name cpp$X" etant clairement transforme par 'job'... #
else
endif
#20090207125013____:set ExClUsIoNs=`echo "$ExClUsIoNs" | $SE -e "s/\([^ ]*\)/! -name \1/g"` #
set ExClUsIoNs=`echo "$ExClUsIoNs" | $R "$K_BLANC" "|"`
# Structuration correcte de '$ExClUsIoNs' introduite le 20090207113437. #
#20101012082832____:if ("$ArGuMeNtS" != "$K_VIDE") then #
#20101012082832____: set ArGuMeNtS=" ""$ArGuMeNtS" #
# Afin d'eviter une malheureuse concatenation en queue des commandes... #
#20101012082832____:else #
#20101012082832____:endif #
if ($SFindExec == $EXIST) then
# Test introduit le 20150205112002... #
# #
# Le 20150205112935, je note que cela n'a en fait d'utilite qu'en mode sequentiel car, en #
# effet, en mode parallele c'est dans 'v $xcs/Linda$vv$Z SLinda' que c'est utile. Mais, #
# malheureusement, il est trop pour decider ici quel mode sequentiel ou parallele sera #
# effectivement utilise. #
if ( ("$mHOTE" == "$mDev_WWW") \
|| ($sHOTE == $sPORTABLE_1) \
|| ($sHOTE == $sPORTABLE_2) \
|| ($sHOTE == $sPORTABLE_3) \
|| ($sHOTE == $sPORTABLE_4) \
|| ($sHOTE == $sPORTABLE_5) \
|| ($sHOTE == $sPORTABLE_6) \
|| ($sHOTE == $sPORTABLE_7) \
) then
# Le 20080101102907 furent introduites '$sPORTABLE_3' et '$sPORTABLE_4' car, en effet, ces #
# MACHINEs avaient ete oubliees... #
if (-e $xiMo/serveur.01$vv$Y) then
# Ce test a ete ajoute lors du demarrage a froid de '$LACT15' le 20021212120108... #
set NoCheckServeur=$EXIST
source $xiMo/serveur.01$vv$Y
unset NoCheckServeur
# Et ce afin de pouvoir disposer d'alias du type 'Gserveur' sur '$mDev_WWW'. #
else
endif
else
endif
if (-e $xrC/Definitions.01$vv$Y) then
set No_Sdu=$EXIST
source $xrC/Definitions.01$vv$Y
unset No_Sdu
# Introduit pour 'v $xrC/EffectuerSondelettesMesures.01$vv$Z .xcg.ExecParallele.01.Z' et #
# pour 'v $xrC/EffectuerSplanMesures.01$vv$Z .xcg.ExecParallele.01.Z' le 20141014075503. #
# #
# La gestion de '$No_Sdu' a ete introduite le 20150205103431 pour 'v $xiirs/.MOBI.13.1.$U' #
# (en notant le changement de nom 'v $Dhistory/LACT19$D/20150302102123 20150225084445'...). #
else
endif
else
endif
#20130307175501____:if ($FindExec_Parallele == $EXIST) then #
#20130307175501____: if ($FindExec_ParalleleLinda == $EXIST) then #
#20130307175501____: if ("$ListeFichierA" != "$K_VIDE") then #
#20130307175501____: if (-e $ListeFichierA) then #
#20130307175501____: set UListeFichierA=$EXIST #
# Afin de savoir si une liste anterieure '$ListeFichierA' peut etre utilisee... #
#20130307175501____: else #
#20130307175501____: endif #
#20130307175501____: else #
#20130307175501____: endif #
#20130307175501____: else #
#20130307175501____: endif #
#20130307175501____:else #
#20130307175501____:endif #
if ("$ListeFichierA" != "$K_VIDE") then
if (-e $ListeFichierA) then
set UListeFichierA=$EXIST
# Afin de savoir si une liste anterieure '$ListeFichierA' peut etre utilisee... #
# #
# La modification du 20130307175501 est due a 'v $xiMos/GserveurB$vv$Y 20130307132755'... #
else
endif
else
endif
#20070423085441____:FileTmpB ListeFichier $Y #
#20090115171743____:FileTmpB ListeFichier $Y FindExec #
FileTmpB ListeFichier $T FindListe
# Generation d'un nom de fichier temporaire de sauvegarde... #
setenv ListeFichierEnv $ListeFichier
# Introduit le 20211115113239 afin de permettre un compactage du fichier '$ExecFichier'... #
if ($?UListeFichierA == $NEXIST) then
# Cas ou l'on ne reprend pas une liste anterieure '$ListeFichierA' (test introduit le #
# 20090615143636). #
if ("$DiReCtOrY" == "$x") then
set DiReCt_ExClUs="$ExclusionFINx"
# Ceci fut introduit le 20080129092625 a cause d'un incident sur '$LACT18' lors d'un #
# '$xcc/RecompileAll$Z' (en mode 'PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES'). D'une part, #
# un 'substitue.01$X' fut trouve dans '$xTG' et d'autre part '$xwm' etait monte. En ce qui #
# concerne le 'substitue.01$X', il n'avait pas de 'substitue.01$K' associe (evidemment...) ; #
# quant a '$xwm', la compilation y a eu lieu (ce qui est contraire a la notion de miroir, #
# puisqu'il s'agit d'une arborescence dans laquelle il est interdit de travailler ; au #
# passage les '$X' alors generes etaient 'UNEXEC'...). #
else
set DiReCt_ExClUs="$K_VIDE"
endif
#:$FIN $DiReCtOrY $follow $DiReCt_ExClUs \( -name .\*$PoStFiXe -o -name \*$PoStFiXe \) $ExClUsIoNs \( -type d -o -type f \) -print \ #
#20090207125013____: | $GRE -v "$K_sepS$ESSAIS$K_sepS" \ #
#20090207125013____: | $GRE -v "$K_sepS$TEMPORAIRES$K_sepS" \ #
#20090207125013____: | $SOR -u \ #
#20090207125013____: | $SE -e "s+^\""$Dcourant$K_sepS++" \ #
#20090207125013____: > $ListeFichier #
if ("$ExClUsIoNs" == "$K_VIDE") then
set ExClUrE="$CA"
else
set ExClUrE="$EGRE -v -e $K_QD$ExClUsIoNs$K_QD"
endif
#201011181813:$FIN $DiReCtOrY $follow $DiReCt_ExClUs \( -name .\*$PoStFiXe -o -name \*$PoStFiXe \) \( -type d -o -type f \) -print \ #
#20101118181302____: |& $R "$K_TAB" "$K_BLANC" \ #
#20101118181302____: | $SE -f $Ffind_error \ #
#20101118181302____: | (eval "$ExClUrE") \ #
#20101118181302____: | $GRE -v "$K_sepS$ESSAIS$K_sepS" \ #
#20101118181302____: | $GRE -v "$K_sepS$TEMPORAIRES$K_sepS" \ #
#20101118181302____: | $SOR -u \ #
#20101118181302____: | $SE -e "s+^\""$Dcourant$K_sepS++" \ #
#20101118181302____: > $ListeFichier #
#20101119092146____: if ($?FindExec_InverserOrdre == $NEXIST) then #
if ($FindExec_InverserOrdre == $NEXIST) then
set InVeRsEr="$K_VIDE"
else
set InVeRsEr="-r"
# Ceci fut introduit le 20101118181302 pour 'v $xb/GENERE$Z FindExec_InverserOrdre'. En #
# effet, la librairie 'v $xbmcf/conformes$K' est tres longue a compiler, or elle se #
# retrouvait en dernier sur l'une des branches paralleles, les autres branches etant alors #
# inoccupees et le processus devenant sequentiel. Ainsi, en inversant l'ordre, j'espere #
# faire du parallelisme jusqu'au bout, meme s'il s'agit d'un bricolage un peu specifique, #
# mais je ne vois pas comment faire autrement... #
endif
$FIN $DiReCtOrY $follow $DiReCt_ExClUs \( -name .\*$PoStFiXe -o -name \*$PoStFiXe \) \( -type d -o -type f \) -print \
|& $R "$K_TAB" "$K_BLANC" \
| $SE -f $Ffind_error \
| (eval "$ExClUrE") \
| $GRE -v "$K_sepS$ESSAIS$K_sepS" \
| $GRE -v "$K_sepS$TEMPORAIRES$K_sepS" \
| $SOR -u $InVeRsEr \
| $SE -e "s+^\""$Dcourant$K_sepS++" \
> $ListeFichier
# Generation de la liste des fichiers a traiter (introduit le 20090115171743). #
unset InVeRsEr
unset ExClUrE
unset DiReCt_ExClUs
else
if ("$CoMmAnDeP" != "$K_VIDE") then
$CA $ListeFichierA \
| $SE -e "s+$CoMmAnDeP *++" \
| $SE -e 's/^\([^ ]*\) .*$/\1/' \
> $ListeFichier
# Recuperation d'une liste Anterieure (introduit le 20090615161009). #
# #
# Ainsi il est possible de recuperer une liste anterieure '$ListeFichierA' ce qui permet #
# donc de reprendre un '$xcg/FindExec.01$Z' interrompu (introduit le 20090615143636), mais #
# evidemment cela n'a de sens que si 'v $xcs/Linda$vv$Z' est utilise, puisque dans ce #
# cas le fichier '$ListeFichier' est progressivement "amaigri", les commandes executees #
# y etant supprimees (on suppose evidemment que le 'v $xcs/Linda$vv$Z' anterieur a ete #
# interrompu proprement, c'est-a-dire en utilisant 'BloqueP'...). #
else
$CA $ListeFichierA \
> $ListeFichier
# Possibilite introduite le 20130305105134 pour 'v $xiMos/GserveurB$vv$Y .xcg.FindExec.01.Z'. #
endif
endif
unset UListeFichierA
set NoMbRePrOcEsS=1
# A priori, pas de parallelisation... #
#20090415103801____:set PPaRaLlElE="$xcg/parallele.14$X" #
set PPaRaLlElE="$xcg/parallele.1N$X"
# Definition introduite le 20090415103254... #
if ($FindExec_Parallele == $EXIST) then
#20130924161410____: set NFiLe_DeScRiPtOrS=`limit | $R "$K_TAB" "$K_BLANC" | $GRE "^descriptors " | $AW ' { print $2 } '` #
#20130924161410____: if ("$NFiLe_DeScRiPtOrS" != "$K_VIDE") then #
#20130924161410____: @ RaPpOrTc = $NFiLe_DeScRiPtOrS / $ProcessorNumber #
#20130924161410____: @ RaPpOrTl = 1024 / 8 #
# Calcul du rapport Courant et du rapport Limite (etabli heuristiquement sur '$LACT19' #
# aux alentours du 20130923154324) entre le nombre de fichiers ouvrables et le nombre #
# de processeurs utilisables... #
#20130924161410____: if ($RaPpOrTc < $RaPpOrTl) then #
#20130924161410____: EROR "Le nombre maximal de fichiers ouvrables est peut-etre insuffisant : \c" #
#20130924161410____: @ PrOcEsSoRNuMbEr = $NFiLe_DeScRiPtOrS / $RaPpOrTl #
#20130924161410____: echo "le nombre de processeurs utilisables passe donc de $ProcessorNumber a $PrOcEsSoRNuMbEr." #
#20130924161410____: setenv ProcessorNumber $PrOcEsSoRNuMbEr #
# Suite au probleme 'v $xcg/FindExec.01$Z 20130923095721', ce dispositif "heuristique" #
# fut introduit le 20130923154324... #
#20130924161410____: unset PrOcEsSoRNuMbEr #
#20130924161410____: else #
#20130924161410____: endif #
#20130924161410____: unset RaPpOrTc #
#20130924161410____: unset RaPpOrTl #
#20130924161410____: else #
#20130924161410____: EROR "Le nombre maximal de fichiers ouvrables n'est pas connu." #
#20130924161410____: endif #
#20130924161410____: unset NFiLe_DeScRiPtOrS #
#20090119082722____: set EsT_Ce_un_Z=`echo "$CoMmAnDe" | $GRE "\""$Z"'$'` #
#20090119164359____: set EsT_Ce_un_Z=`echo "$CoMmAnDeP" | $GRE "\""$Z"'$'` #
set EsT_Ce_un_Z=`echo "$CoMmAnDeP" | $AW ' { print $1 } ' | $GRE "\""$Z"'$'`
# Introduit le 20090118092529 a cause du redoutable probleme des alias... #
#20090119105236____: if ("$EsT_Ce_un_Z" != "$K_VIDE") then #
if (($FindExec_ParalleleLinda == $EXIST) || ("$EsT_Ce_un_Z" != "$K_VIDE")) then
# On notera que 'v $xcs/Linda$vv$Z source' etant lui-meme un '$Z', tous les alias y sont #
# definis ; de plus il effectue des 'source's. Ainsi, donc des alias tels 'Gserveur' peuvent #
# etre executes via '$CoMmAnDe'. C'est pourquoi '$xcs/Linda$vv$Z' est la solution la plus #
# "performante" d'une part parce que le parallelisme qu'il permet est le plus efficace et #
# parce que d'autre part il "connait" tous les 'alias's... #
# #
# 'Linda' est autorise ou bien la commande semble etre un '$Z', on peut donc tenter #
# la parallelisation : #
set NoMbRePaRaLlEleS=`GetParam $PPaRaLlElE NombreProcessParalleles`
# Afin de voir s'il est possible de paralleliser sur cette MACHINE... #
#20090119164517____: set VaLiDe=`echo "$NoMbRePaRaLlEleS" | $GRE "NombreProcessParalleles" | $GRE -i "inexistant"` #
set VaLiDe=`echo "$NoMbRePaRaLlEleS" | $GRE "^[$Alphabet_0_9]*"'$'`
# Validation introduite le 20090116130748... #
#20090119164517____: if ("$VaLiDe" == "$K_VIDE") then #
if ("$VaLiDe" != "$K_VIDE") then
set NoMbReFiChIeRs=`$CA $ListeFichier | $WCl`
if ($NoMbReFiChIeRs >= $NoMbRePaRaLlEleS) then
set NoMbRePrOcEsS=$NoMbRePaRaLlEleS
else
set NoMbRePrOcEsS=$NoMbReFiChIeRs
# Introduit le 20131129134909. Avant cette date, lorsqu'il y avait moins de fichiers #
# ('$NoMbReFiChIeRs') que de processeurs ('$NoMbRePaRaLlEleS') on ne parallelisait pas #
# ce qui etait un peu du gachis, mais ce n'est peut-etre pas une bonne idee... #
endif
unset NoMbReFiChIeRs
else
EROR "Commande '"'$xcg/parallele.1?$X'"' inexistante ou "'"NombreProcessParalleles="'" non reconnu."
endif
unset VaLiDe
unset NoMbRePaRaLlEleS
else
# Dans le cas ou la commande n'est pas un '$Z', il y a de grandes chances pour qu'elle soit #
# un alias ('v $xiMo/ReGENEREAll$Z Gserveur'). Alors, dans '$xcg/parallele.1?$X' il #
# conviendrait de lancer, non pas '$CoMmAnDeP', mais quelque chose du type : #
# #
# $CSH -c $CoMmAnDeP #
# #
# mais cela n'est pas aussi simple que cela car il faudrait quoter a cause des arguments : #
# #
# $CSH -c "$CoMmAnDeP $ArGuMeNtS" #
# #
# Or cela semble tres difficile, de par la structure des liste '$LCoMmAnDeS' ci-apres... #
# D'autre part, il faudrait faire les sources, tel : #
# #
# set NoCheckServeur=$EXIST #
# source $xiMo/serveur.01$vv$Y #
# unset NoCheckServeur #
# #
# et enfin, '$CSH' est penalisant au niveau temps d'execution. Donc, provisoirement (?) le #
# parallelisme est inhibe en l'absence de '$Z'... #
# #
# On notera le 20090118114804 'v $xiMo/ReGENEREAll$Z 20090118114614' ou 'Gserveur' a ete #
# remplace par '$xiMo/Gserveur$Z' pour cette raison... #
endif
unset EsT_Ce_un_Z
else
endif
FilSTmpB ExecFichier $Y FindExec
# Generation d'un nom de fichier temporaire de sauvegarde... #
$CA $xcs/csh$Y \
>> $ExecFichier
echo "xT" \
>> $ExecFichier
# Introduit le 20130923103512 afin de reduire la longueur de '$ExecFichier' avant de #
# le "sourcer" en permettant donc de ne donner que le nom relatif (a '$xT') des fichiers #
# temporaires de redirection... #
# #
# On notera le 20131206093713 que c'est ce changement de directory ('xT') qui a contraint #
# a rendre necessaire que '$DiReCtOrY' soit absolu (et ainsi ne soit plus, par exemple, #
# '$Dcourant' comme c'etait un usage tres repandu avant cette date...). #
#20090116130748____:if ($NoMbRePrOcEsS == 1) then #
if ($NoMbRePrOcEsS <= 1) then
# Cas ou la parallelisation n'est pas possible : #
if ($FindExec_Editer == $EXIST) then
#20090120110056____: echo "Mode Sequentiel d'execution des commandes." #
#20090207154407____: echo "Mode Sequentiel d'execution des commandes dans '"'$xcg/FindExec.01$Z'"'." #
#20090208093422____: EcHoR "Mode Sequentiel d\'execution des commandes dans \'$xcg/FindExec.01$Z\'." #
#20090226101118____: EchoJob "Mode Sequentiel d\'execution des commandes dans \\c" #
#20090226101118____: EchoJob "\'$K_DOLLAR""K_DOLLAR$K_QD$K_QD""xcg/FindExec.01$K_DOLLAR""K_DOLLAR$K_QD$K_QD""Z\'." #
EchoJob "Mode Sequentiel d'execution des commandes dans \c"
EchoJob "'$K_DOLLAR""K_DOLLAR$K_QD$K_QD""xcg/FindExec.01$K_DOLLAR""K_DOLLAR$K_QD$K_QD""Z'."
# Message introduit le 20090119164517... #
else
endif
#20090119082722____: $CA $ListeFichier \ #
#20090119082722____: | $SE -e "s+^+TestP ; $CoMmAnDe +" \ #
#20090119082722____: -e 's+$+'"$ArGuMeNtS+" \ #
#20090119082722____: >> $ExecFichier #
#20101012082832____: $CA $ListeFichier \ #
#20101012082832____: | $SE -e "s+^+TestP ; $CoMmAnDeS +" \ #
#20101012082832____: -e 's+$+'"$ArGuMeNtS+" \ #
#20101012082832____: >> $ExecFichier #
if ("$ArGuMeNtS" != "$K_VIDE") then
# Test introduit le 20101230110652... #
$CA $ListeFichier \
| $SE -e "s+^+TestP ; $CoMmAnDeS +" \
-e 's+$+'" $K_QD$ArGuMeNtS$K_QD+" \
>> $ExecFichier
else
$CA $ListeFichier \
| $SE -e "s+^+TestP ; $CoMmAnDeS +" \
>> $ExecFichier
endif
# Generation d'un fichier contenant une commande par fichier repondant aux criteres... #
# On notera que par rapport a : #
# #
# $FIN $DiReCtOrY $follow -name \*$PoStFiXe -type f -exec $CoMmAnDe {} \; #
# #
# cette solution a deux avantages : d'une part, la liste des fichiers est triee, et d'autre #
# part, la liste des fichiers est etablie avant que '$CoMmAnDe' ne s'execute, or cette #
# derniere peut modifier l'arborescence, ce qui peut provoquer des messages du type : #
# #
# No such file or directory #
# #
# qui sont "asynchrones" et donc difficiles a eliminer... #
# #
# L'elimination de '$xTG' (via '$TEMPORAIRES') a ete ajoutee le 20000203164547 ; ceci a ete #
# justifie par le fait que depuis le 19991129165326 ('v $xcc/cl$Z 19991129165326') tous les #
# '$X' generes voient leurs eventuelles versions anterieures sauvegardees dans '$xT'... #
# #
# Le 20000329094634 j'ai ajoute a '-type f' l'option '-type d' afin de permettre a la #
# commande '$xiM/GENERE$Z' de generer les images de '$xiMd' qui sont en fait reperees #
# par des noms de directories '$D' et non par des fichiers '$m4'... #
# #
# Le 20010118174446 j'ai ajoute la recherche des noms commencant par "." ('.\*$PoStFiXe') #
# a cause de la commande 'v $xiMo/CheckAll$Z FindExec.01.Z' car effectivement '$xiMi' #
# contient des structures '$D' commencant par ".". #
# #
# Le 20010316090015 j'ai ajoute la suppression des "./" qui precedente les noms de fichiers #
# lorsque '$DiReCtOrY' est '$Dcourant' et ceci afin de permettre au test du "relai universel" #
# ('v $xiMos/Gserveur$vv$Y ReLaIuNiVeRsEl') de se faire correctement sur '$mDev_WWW'... #
# #
# L'elimination de '$xu' (via '$ESSAIS') a ete ajoutee le 20011205140343 ; ceci a ete #
# justifie par le fait qu'il peut y avoir, par exemple, de nombreux '$X' dans '$xu' (en #
# particulier dans 'v $xu/Felici.M/$Fnota 3D_Acinus.X', v $xu/Baldassarri.A/$Fnota sqetch.X' #
# ou encore dans 'v $xu/Gondran.A/$Fnota'). #
# #
# Le 20030821175800 j'ai introduit 'v $Ffind_error' afin d'eliminer des messages #
# d'erreur de '$FIN' dus, par exemple, au directory '$x/$D_netscape' sur '$CMAP28' et sur #
# '$LACT15'... #
# #
# Le 20060318161818 j'ai introduit un 'TestP' devant la commande '$CoMmAnDe'. L'interet de #
# ceci est de pouvoir mettre periodiquement en attente '$xcg/FindExec.01$Z' avant chaque #
# commande qu'il execute. Ainsi, par exemple, durant un 'v $xcc/RecompileAll$Z', on pourra #
# mettre l'un des '$Z' utilise ('$xcc/cpp$z',...) sans danger. Le blocage se fera par : #
# #
# BloqueP $xcg/FindExec.01$Z #
# #
# et le deblocage par : #
# #
# DBloqueP $xcg/FindExec.01$Z #
# #
# et c'est tout... #
# #
# Le 20080129092625 j'ai introduit '$DiReCt_ExClUs' qui manquait (sur '$LACT18'...). #
# #
# Le 20101230105622 on notera que la presence systematique de '$ArGuMeNtS' peut etre la #
# cause de problemes et par exemple du message d'erreur : #
# #
# ls: : No such file or directory #
# #
# dans le cas ou '$commandeS' serait la commande 'll' et ou '$ArGuMeNtS' serait vide, #
# d'ou la modification du 20101230110652... #
else
# Cas ou la parallelisation est possible (introduite le 20090115173510) : #
set ReDiReCtIoN="%%"
#20130924163909____: FileTmpB FReDiReCtIoN #
FileTmpB FReD
# Definition (arbitraire provisoirement ?) des redirections, en notant qu'il pourrait etre #
# preferable d'utiliser : #
# #
# FileTmpB FReDiReCtIoN $K_QD$K_VIDE$K_QD $K_QD$K_VIDE$K_QD $xTR #
# #
# pour garantir la perennite des fichiers '$FReDiReCtIoN*'... #
# #
# On notera qu'en mode parallele, il est obligatoire de rediriger 'stdout' et 'stderr' car, #
# en effet, sinon les sorties 'stdout' et 'stderr' des processus paralleles se melangeraient #
# a l'ecran... #
# #
# Le 20130924162731, le nom 'FReDiReCtIoN' a ete remplace par 'FReD' afin de raccourcir #
# le plus possible la longueur de '$ExecFichier' avant de le "sourcer"... #
setenv FReDEnv `GetLeaf $FReD`
# Introduit le 20211115113239 afin de permettre un compactage du fichier '$ExecFichier'... #
if ($FindExec_ParalleleLinda == $EXIST) then
# Cas ou l'on va utiliser 'v $xcs/Linda$vv$Z' : #
if ($FindExec_Editer == $EXIST) then
#20090120110056____: echo "Mode Parallele 'Linda' d'execution des commandes." #
#20090207154407____: echo "Mode Parallele 'Linda' d'execution des commandes dans '"'$xcg/FindExec.01$Z'"'." #
#20090208093422____: EcHoR "Mode Parallele \'Linda\' d\'execution des commandes dans \'$xcg/FindExec.01$Z\'." #
#20090226101118____: EchoJob "Mode Parallele \'Linda\' d\'execution des commandes dans \\c" #
#20090226101118____: EchoJob "\'$K_DOLLAR""K_DOLLAR$K_QD$K_QD""xcg/FindExec.01$K_DOLLAR""K_DOLLAR$K_QD$K_QD""Z\'." #
EchoJob "Mode Parallele 'Linda' d'execution des commandes dans \c"
EchoJob "'$K_DOLLAR""K_DOLLAR$K_QD$K_QD""xcg/FindExec.01$K_DOLLAR""K_DOLLAR$K_QD$K_QD""Z'."
# Message introduit le 20090119164517... #
else
endif
FilSTmpB FVeRrOuB
# Definition des verrous de blocage de 'v $xcs/Linda$vv$Z VerrouBlocage' introduits le #
# 20090317101238... #
setenv FVeRrOuBEnv $FVeRrOuB
# Introduit le 20211115113239 afin de permettre un compactage du fichier '$ExecFichier'... #
FileTmpB LiStE_LiNdA
#20090119105236____: $CA $ListeFichier \ #
#20090119105236____: | $SE -e "s+^+TestP ; $CoMmAnDeS +" \ #
#20090119105236____: -e 's+$+'"$ArGuMeNtS+" \ #
#20090119105236____: > $LiStE_LiNdA #
#20101012082832____: $CA $ListeFichier \ #
#20101012082832____: | $SE -e "s+^+$CoMmAnDeS +" \ #
#20101012082832____: -e 's+$+'"$ArGuMeNtS+" \ #
#20101012082832____: > $LiStE_LiNdA #
if ("$ArGuMeNtS" != "$K_VIDE") then
# Test introduit le 20101230110652... #
$CA $ListeFichier \
| $SE -e "s+^+$CoMmAnDeS +" \
-e 's+$+'" $K_QD$ArGuMeNtS$K_QD+" \
> $LiStE_LiNdA
else
$CA $ListeFichier \
| $SE -e "s+^+$CoMmAnDeS +" \
> $LiStE_LiNdA
endif
# On notera que l'on ne peut pas mettre ici 'TestP' car, en effet, ici il est relatif a #
# 'v $xcs/Linda$vv$Z' ; or plusieurs (2, 4,...) occurences de celui-ci vont etre lancees #
# et donc risquer de se mettre mutuellement en attente via ce 'TestP'... #
# #
# Le 20101230105622 on notera que la presence systematique de '$ArGuMeNtS' peut etre la #
# cause de problemes et par exemple du message d'erreur : #
# #
# ls: : No such file or directory #
# #
# dans le cas ou '$commandeS' serait la commande 'll' et ou '$ArGuMeNtS' serait vide, #
# d'ou la modification du 20101230110652... #
$DELETE $ListeFichier
$MV $LiStE_LiNdA $ListeFichier
FileTmpE LiStE_LiNdA $NEXIST
ro $ListeFichier
# Le fichier '$ListeFichier' doit etre en mode 'ro' a cause de 'v $xcs/Linda$vv$Z rwv' et #
# ne contenir que la liste des fichiers (et rien d'autre...). #
#20090415103254____: set En_TeTe='$xcg/parallele.14$X' #
set En_TeTe="$PPaRaLlElE"
#20130923095721____: set CoMmAnDeL="$xcs/Linda$vv$Z" #
set CoMmAnDeL='$xcs/Linda$vv$Z'
# La modification du 20130923095721 est destinee a raccourcir le fichier '$ExecFichier' en #
# cours de generation... #
#20090317101922____: set ArG_ReDiR="$ListeFichier $ReDiReCtIoN" #
set LPoStFiXeS1=`$xci/nombres$X A="$K_sepP" premiere=1 derniere=$NoMbRePrOcEsS`
@ NoMbRePrOcEsSp1 = $NoMbRePrOcEsS + 1
set LPoStFiXeS2=`$xci/nombres$X A="$K_sepP" premiere=1 derniere=$NoMbRePrOcEsSp1`
set LCoMmAnDeS=($LPoStFiXeS2)
# Initialisation arbitraire de '$LCoMmAnDeS' uniquement destinee a faire que cette liste ait #
# le bon nombre d'elements afin de permettre ci-apres son initialisation element par element, #
# sachant que l'on ne peut la definir "globalement", en une seule fois, a cause des '$K_QS's, #
# '$K_QD's et des espaces qu'elle contient... #
set LiMiTeUr="#"
set NBrAn=1
foreach BrAnChE ($LPoStFiXeS2)
@ NBrAn_1 = $NBrAn - 1
if ($NBrAn == 1) then
#20100522103903____: set LCoMmAnDeS[$NBrAn]="$En_TeTe"' commande="'"$CoMmAnDeL " #
#20140419102236____: set LCoMmAnDeS[$NBrAn]="$En_TeTe"' parallele_14=FAUX commande="'"$CoMmAnDeL " #
set LCoMmAnDeS[$NBrAn]="$En_TeTe"' parallele_14=FAUX dupliquer=FAUX commande="'"$CoMmAnDeL "
# Cette facon de proceder utilisant "commande="' et donc un nombre quelconque de processus #
# paralleles a ete introduite le 20090511104936... #
# #
# La modification du 20140419102236 est destinee a ne pas dupliquer '$CoMmAnDeL' N fois #
# (soit '$NoMbRePaRaLlEleS') puisqu'en fait '$CoMmAnDeL' contient deja N fois la "veritable" #
# commande a executer, les occurences etant separees par '$LiMiTeUr'... #
else
if ($NBrAn < $NoMbRePrOcEsSp1) then
set LCoMmAnDeS[$NBrAn]="$ListeFichier"
set LCoMmAnDeS[$NBrAn]="$LCoMmAnDeS[$NBrAn] $FVeRrOuB$LPoStFiXeS2[$NBrAn_1]"
set LCoMmAnDeS[$NBrAn]="$LCoMmAnDeS[$NBrAn] $ReDiReCtIoN"
set LCoMmAnDeS[$NBrAn]="$LCoMmAnDeS[$NBrAn] $LiMiTeUr"
set LCoMmAnDeS[$NBrAn]="$LCoMmAnDeS[$NBrAn] $CoMmAnDeL "
else
set LCoMmAnDeS[$NBrAn]="$ListeFichier"
set LCoMmAnDeS[$NBrAn]="$LCoMmAnDeS[$NBrAn] $FVeRrOuB$LPoStFiXeS2[$NBrAn_1]"
set LCoMmAnDeS[$NBrAn]="$LCoMmAnDeS[$NBrAn] $ReDiReCtIoN"'"'
endif
endif
if ($NBrAn < $NoMbRePrOcEsSp1) then
$CP -p $FVeRrOuB $FVeRrOuB$LPoStFiXeS2[$NBrAn]
# Preparation des verrous de blocage... #
else
endif
@ NBrAn = $NBrAn + 1
unset NBrAn_1
end
unset BrAnChE
unset LiMiTeUr
unset NoMbRePrOcEsSp1
#20090317101922____: unset ArG_ReDiR #
unset En_TeTe
FileTmpB FichierT
# Definition d'une liste de fichiers contenant en parallele les commandes et leurs arguments. #
if ($FindExec_MessagesBP == $EXIST) then
# Test introduit le 20181017151932... #
EchoJob "\n\n"
# Introduit le 20181017145613 pour aerer les mises en page... #
else
endif
set NBrAnChE=1
foreach BrAnChE ($LPoStFiXeS2)
if ($NBrAnChE > 1) then
@ NBrAnChE_1 = $NBrAnChE - 1
# En fait, la redirection n'a de sens qu'a partir de '$LCoMmAnDeS[2]', d'ou le "-1"... #
if ($FindExec_MessagesBP == $EXIST) then
# Test introduit le 20150205105239... #
#20090207154407____: echo "En mode 'parallele' ($NoMbRePrOcEsS branches) la redirection de {'stdout','stderr'} a lieu \c" #
#20090207154407____: echo "automatiquement vers $NoMbRePrOcEsS fichiers dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]'." #
#20090226101118____: EchoJob "En mode 'parallele' \($NoMbRePrOcEsS branches\) la redirection \\c" #
#20090226101118____: EchoJob "de \{\'stdout\',\'stderr\'\} a lieu automatiquement \\c" #
#20090226101118____: EchoJob "vers $NoMbRePrOcEsS fichiers dont \'$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]\'." #
#20101229153147____: EchoJob "En mode 'parallele' ($NoMbRePrOcEsS branches) la redirection \c" #
#20181011131322____: EchoJob "En mode 'parallele' ($NoMbRePrOcEsS branches) $NoMbRePrOcEsS fichiers, \c" #
#20181017145613____: EchoJob "\n\nEn mode 'parallele' ($NoMbRePrOcEsS branches) $NoMbRePrOcEsS fichiers, \c" #
EchoJob "En mode 'parallele' ($NoMbRePrOcEsS branches) $NoMbRePrOcEsS fichiers, \c"
#20090613175806____: EchoJob "de {'stdout','stderr'} a lieu automatiquement \c" #
#20101229153147____: EchoJob "de {'stdout','stderr'} a lieu automatiquement et temporairement \c" #
#20090317110158____: EchoJob "vers $NoMbRePrOcEsS fichiers dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]'." #
#20101229153147____: EchoJob "vers $NoMbRePrOcEsS fichiers dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]' \c" #
#20130924163909____: EchoJob "dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]', sont \c" #
EchoJob "dont '$FReD$LPoStFiXeS2[$NBrAnChE_1]', sont \c"
EchoJob "utilises pour la redirection automatique et temporaire de {'stdout','stderr'} \c"
EchoJob "avec possibilite de blocage/deblocage via :"
EchoJob "$Prompt""BloqueP $FVeRrOuB$LPoStFiXeS2[$NBrAnChE_1]"
EchoJob "$Prompt""DBloqueP $FVeRrOuB$LPoStFiXeS2[$NBrAnChE_1]"
# Possibilites de {BloqueP,DBloqueP} introduite le 20090317101555... #
else
endif
else
@ NBrAnChE_1 = $NBrAnChE
# En fait, cette valeur est indifferente pour '$LCoMmAnDeS[1]'... #
endif
#20130924163909____: (saut) \ #
#20130924163909____: | $SE -e 's+^$'"+$LCoMmAnDeS[$NBrAnChE]+" \ #
#20130924163909____: -e "s+$ReDiReCtIoN+>> $FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1] 2>\&1+" \ #
#20130924163909____: > $FichierT$LPoStFiXeS2[$NBrAnChE] #
(saut) \
| $SE -e 's+^$'"+$LCoMmAnDeS[$NBrAnChE]+" \
-e "s+$ReDiReCtIoN+>> $FReD$LPoStFiXeS2[$NBrAnChE_1] 2>\&1+" \
> $FichierT$LPoStFiXeS2[$NBrAnChE]
# On notera la mise en place de redirections de type '$SHELL_BASH' puisque c'est sous ce #
# "shell" que s'executeront les commandes... #
unset NBrAnChE_1
@ NBrAnChE = $NBrAnChE + 1
end
else
# Cas ou l'on ne va pas utiliser 'v $xcs/Linda$vv$Z' : #
if ($FindExec_Editer == $EXIST) then
#20090120110056____: echo "Mode Parallele 'basique' d'execution des commandes." #
#20090207154407____: echo "Mode Parallele 'basique' d'execution des commandes dans '"'$xcg/FindExec.01$Z'"'." #
#20090208093422____: EcHoR "Mode Parallele \'basique\' d\'execution des commandes dans \'$xcg/FindExec.01$Z\'." #
#20090226101118____: EchoJob "Mode Parallele \'basique\' d\'execution des commandes dans \\c" #
#20090226101118____: EchoJob "\'$K_DOLLAR""K_DOLLAR$K_QD$K_QD""xcg/FindExec.01$K_DOLLAR""K_DOLLAR$K_QD$K_QD""Z\'." #
EchoJob "Mode Parallele 'basique' d'execution des commandes dans \c"
EchoJob "'$K_DOLLAR""K_DOLLAR$K_QD$K_QD""xcg/FindExec.01$K_DOLLAR""K_DOLLAR$K_QD$K_QD""Z'."
# Message introduit le 20090119164517... #
else
endif
#20090118085800____: set NoMbRePrOcEsS=4 #
# Experience faite le 20090118081248 afin de voir si les performances ne sont pas meilleures #
# ainsi. En effet, par exemple sur '$LACT18', le principe est donc de faire deux compilations #
# en parallele via 'v $xcg/parallele.14$K'. Mais evidemment, elles n'ont en general pas la #
# meme duree. Le process qui correspond a la plus courte des deux "perd" donc du temps en #
# attendant celui qui correspond a la plus longue. En essayant de forcer '$NoMbRePrOcEsS' a #
# quatre sur '$LACT18', je voulais voir si statistiquement ces "temps perdus" ne seraient #
# pas ainsi compenses en faisant deux compilations "serie" en paralelle avec deux autres #
# compilations "serie". Le benefice est non signficatif puisque que '$NoMbRePrOcEsS' vaille #
# deux ou quatre, la duree est la meme ('v $xb/GENERE$Z 20090117102153')... La solution pour #
# faire disparaitre ces attentes liees a l'utilisation de 'v $xcg/parallele.14$K' serait de #
# s'orienter vers une solution de type 'v $xcs/Linda$vv$Z'... #
#20090415103254____: set En_TeTe='TestP ; $xcg/parallele.14$X' #
set En_TeTe="TestP ; $PPaRaLlElE"
set ArG_ReDiR="$ArGuMeNtS $ReDiReCtIoN"
if (($NoMbRePrOcEsS > 1) && ($NoMbRePrOcEsS <= 2)) then
# Cas ou il y a 2 possibilites (valeur certaine) : #
set LPoStFiXeS1=(.1 .2)
set LPoStFiXeS2=($LPoStFiXeS1 .3)
# On notera qu'il y a un postfixe de plus (3=2+1) que necessaire parce qu'il faut en fait #
# "fermer" la derniere commande (la seconde)... #
set LCoMmAnDeS=($LPoStFiXeS2)
# Initialisation arbitraire de '$LCoMmAnDeS' uniquement destinee a faire que cette liste ait #
# le bon nombre d'elements afin de permettre ci-apres son initialisation element par element, #
# sachant que l'on ne peut la definir "globalement", en une seule fois, a cause des '$K_QS's, #
# '$K_QD's et des espaces qu'elle contient... #
#20090119082722____: set LCoMmAnDeS[1]="$En_TeTe"' C11="'"$CoMmAnDe " #
#20090119082722____: set LCoMmAnDeS[2]="$ArG_ReDiR"'" C21="'"$CoMmAnDe " #
#20090119082722____: set LCoMmAnDeS[3]="$ArG_ReDiR"'"' #
set LCoMmAnDeS[1]="$En_TeTe"' C11="'"$CoMmAnDeP "
set LCoMmAnDeS[2]="$ArG_ReDiR"'" C21="'"$CoMmAnDeP "
set LCoMmAnDeS[3]="$ArG_ReDiR"'"'
else
# Cas ou il y a 4 possibilites (valeur "majoree" et "limitee") : #
set LPoStFiXeS1=(.1 .2 .3 .4)
set LPoStFiXeS2=($LPoStFiXeS1 .5)
# On notera qu'il y a un postfixe de plus (5=4+1) que necessaire parce qu'il faut en fait #
# "fermer" la derniere commande (la quatrieme)... #
set LCoMmAnDeS=($LPoStFiXeS2)
# Initialisation arbitraire de '$LCoMmAnDeS' uniquement destinee a faire que cette liste ait #
# le bon nombre d'elements afin de permettre ci-apres son initialisation element par element, #
# sachant que l'on ne peut la definir "globalement", en une seule fois, a cause des '$K_QS's, #
# '$K_QD's et des espaces qu'elle contient... #
#20090119082722____: set LCoMmAnDeS[1]="$En_TeTe"' C11="'"$CoMmAnDe " #
#20090119082722____: set LCoMmAnDeS[2]="$ArG_ReDiR"'" C12="'"$CoMmAnDe " #
#20090119082722____: set LCoMmAnDeS[3]="$ArG_ReDiR"'" C21="'"$CoMmAnDe " #
#20090119082722____: set LCoMmAnDeS[4]="$ArG_ReDiR"'" C22="'"$CoMmAnDe " #
#20090119082722____: set LCoMmAnDeS[5]="$ArG_ReDiR"'"' #
set LCoMmAnDeS[1]="$En_TeTe"' C11="'"$CoMmAnDeP "
set LCoMmAnDeS[2]="$ArG_ReDiR"'" C12="'"$CoMmAnDeP "
set LCoMmAnDeS[3]="$ArG_ReDiR"'" C21="'"$CoMmAnDeP "
set LCoMmAnDeS[4]="$ArG_ReDiR"'" C22="'"$CoMmAnDeP "
set LCoMmAnDeS[5]="$ArG_ReDiR"'"'
endif
unset ArG_ReDiR
unset En_TeTe
set SaVe_Egaliser=$Egaliser_Fdeconca
set Egaliser_Fdeconca=$EXIST
# Afin de garantir que tous les fichiers '$ListeFichier.*' aient la meme longueur... #
Fdeconca $ListeFichier $LPoStFiXeS1
# Parallelisation de la liste des fichiers en decoupant '$ListeFichier' en autant de fichiers #
# qu'il y a de '$NoMbRePrOcEsS' plus 1... #
set Egaliser_Fdeconca=$SaVe_Egaliser
unset Egaliser_Fdeconca
FileTmpB FichierT
# Definition d'une liste de fichiers contenant en parallele les commandes et leurs arguments. #
set NBrAnChE=1
foreach BrAnChE ($LPoStFiXeS2)
if (! -e $ListeFichier$LPoStFiXeS2[$NBrAnChE]) then
$CA $ListeFichier$LPoStFiXeS2[1] \
| $SE -e 's+^.*$++' \
> $ListeFichier$LPoStFiXeS2[$NBrAnChE]
# En effet le dernier fichier de la liste de postfixes n'existe pas puisqu'il y a un #
# postfixe de plus que la valeur de '$NoMbRePrOcEsS'. On le cree donc arbitrairement a #
# partir du premier (1) en "vidant" chaque ligne... #
else
endif
if ($NBrAnChE > 1) then
@ NBrAnChE_1 = $NBrAnChE - 1
# En fait, la redirection n'a de sens qu'a partir de '$LCoMmAnDeS[2]', d'ou le "-1"... #
#20090117085037____: echo "En mode 'parallele' la redirection de {'stdout','stderr'} a lieu \c" #
#20090207154407____: echo "En mode 'parallele' ($NoMbRePrOcEsS branches) la redirection de {'stdout','stderr'} a lieu \c" #
#20090226101118____:EchoJob "En mode \'parallele\' \($NoMbRePrOcEsS branches\) la redirection de \{\'stdout\',\'stderr\'\} \\c" #
#20101229153147____: EchoJob "En mode 'parallele' ($NoMbRePrOcEsS branches) la redirection de {'stdout','stderr'} a lieu \c" #
#20181011131322____: EchoJob "En mode 'parallele' ($NoMbRePrOcEsS branches) $NoMbRePrOcEsS fichiers, \c" #
EchoJob "En mode 'parallele' ($NoMbRePrOcEsS branches) $NoMbRePrOcEsS fichiers, \c"
#20090117085037____: echo "automatiquement vers plusieurs fichiers dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]'." #
#20090207154407____: echo "automatiquement vers $NoMbRePrOcEsS fichiers dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]'." #
#20090226101118____: EchoJob "a lieu automatiquement vers $NoMbRePrOcEsS fichiers \\c" #
#20090226101118____: EchoJob "dont \'$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]\'." #
#20090613175806____: EchoJob "automatiquement vers $NoMbRePrOcEsS fichiers \c" #
#20101229153147____: EchoJob "automatiquement et temporairement vers $NoMbRePrOcEsS fichiers \c" #
#20101229153147____: EchoJob "dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]'." #
#20130924163909____: EchoJob "dont '$FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1]', sont \c" #
EchoJob "dont '$FReD$LPoStFiXeS2[$NBrAnChE_1]', sont \c"
EchoJob "utilises pour la redirection automatique et temporaire de {'stdout','stderr'}."
else
@ NBrAnChE_1 = $NBrAnChE
# En fait, cette valeur est indifferente pour '$LCoMmAnDeS[1]'... #
endif
#20130924163909____: $CA $ListeFichier$LPoStFiXeS2[$NBrAnChE] \ #
#20130924163909____: | $SE -e "s+^+$LCoMmAnDeS[$NBrAnChE]+" \ #
#20130924163909____: -e "s+$ReDiReCtIoN+>> $FReDiReCtIoN$LPoStFiXeS2[$NBrAnChE_1] 2>\&1+" \ #
#20130924163909____: > $FichierT$LPoStFiXeS2[$NBrAnChE] #
$CA $ListeFichier$LPoStFiXeS2[$NBrAnChE] \
| $SE -e "s+^+$LCoMmAnDeS[$NBrAnChE]+" \
-e "s+$ReDiReCtIoN+>> $FReD$LPoStFiXeS2[$NBrAnChE_1] 2>\&1+" \
> $FichierT$LPoStFiXeS2[$NBrAnChE]
# On notera la mise en place de redirections de type '$SHELL_BASH' puisque c'est sous ce #
# "shell" que s'executeront les commandes... #
unset NBrAnChE_1
@ NBrAnChE = $NBrAnChE + 1
end
#20090119082722____: $PAST $FichierT* \ #
#20090119082722____: | $R "$K_TAB" "$K_BLANC" \ #
#20090119082722____: | $SE -e "s+ *[Cc][$Alphabet_0_9]*="'"'"$CoMmAnDe *$ArGuMeNtS *>> *$FReDiReCtIoN"'.*$++' \ #
#20090119082722____: >> $ExecFichier #
#20090119105236____:$PAST $FichierT* \ #
#20090119105236____: | $R "$K_TAB" "$K_BLANC" \ #
#20090119105236____: | $SE -e "s+ *[Cc][$Alphabet_0_9]*="'"'"$CoMmAnDeP *$ArGuMeNtS *>> *$FReDiReCtIoN"'.*$++' \ #
#20090119105236____: >> $ExecFichier #
# Generation d'un fichier contenant une commande par fichier repondant aux criteres, mais #
# de facon parallelisee... #
# #
# La suppression finale de certaines commandes apparemment vides est destinee a eliminer #
# certains "fantomes" provenant de l'utilisation de '$Egaliser_Fdeconca' lui-meme destine #
# a donner a tous les fichiers '$FichierT*' la meme longueur permettant par la-meme la #
# generation "propre" de '$ExecFichier' et de ses redirections... #
#20090119105236____: FileTmpE FichierT #
#20090117100347____: FileTmpE FReDiReCtIoN $NEXIST #
# Nettoyage avant le retour, en notant qu'evidemment les fichiers '$FReDiReCtIoN' ne sont #
# pas detruits puisqu'ils contiennent les sorties 'stdout' et 'stderr' des commandes... #
endif
unset BrAnChE
unset NBrAnChE
unset LCoMmAnDeS
unset LPoStFiXeS2
unset LPoStFiXeS1
unset ReDiReCtIoN
#20101012082832____: $PAST $FichierT* \ #
#20101012082832____: | $R "$K_TAB" "$K_BLANC" \ #
#20101012082832____: | $SE -e "s+ *[Cc][$Alphabet_0_9]*="'"'"$CoMmAnDeP *$ArGuMeNtS *>> *$FReDiReCtIoN"'.*$++' \ #
#20101012082832____: >> $ExecFichier #
#20130924163909____: $PAST $FichierT* \ #
#20130924163909____: | $R "$K_TAB" "$K_BLANC" \ #
#20130924163909____: | $SE -e "s+ *[Cc][$Alphabet_0_9]*="'"'"$CoMmAnDeP *$K_QD$ArGuMeNtS$K_QD *>> *$FReDiReCtIoN"'.*$++' \ #
#20130924163909____: >> $ExecFichier #
$PAST $FichierT* \
| $R "$K_TAB" "$K_BLANC" \
| $SE -e "s+ *[Cc][$Alphabet_0_9]*="'"'"$CoMmAnDeP *$K_QD$ArGuMeNtS$K_QD *>> *$FReD"'.*$++' \
>> $ExecFichier
# Generation d'un fichier contenant "tout" ce qui est necessaire a l'execution de la #
# commande argument sur les fichiers arguments. Voici le contenu du fichier '$ExecFichier' #
# suivant les trois modes de fonctionnement : #
# #
# 1-"Mode Sequentiel" : #
# --------------------- #
# #
# (...) #
# TestP ; COMMANDE ARGUMENTS FICHIER(i) #
# (...) #
# #
# pour chaque 'FICHIER(i)'. #
# #
# #
# 2-"Mode Parallele" : #
# -------------------- #
# #
# (...) #
# TestP ; $xcg/parallele.1?$X C11="COMMANDE ARGUMENTS FICHIER(2*i+0) REDIRECT.1" #
# C21="COMMANDE ARGUMENTS FICHIER(2*i+1) REDIRECT.2" #
# (...) #
# #
# pour chaque groupe de 2 fichiers {2*i+0,2*i+1} traites en 2-parallele, ou : #
# #
# (...) #
# TestP ; $xcg/parallele.1?$X C11="COMMANDE ARGUMENTS FICHIER(4*i+0) REDIRECT.1" #
# C12="COMMANDE ARGUMENTS FICHIER(4*i+1) REDIRECT.2" #
# C21="COMMANDE ARGUMENTS FICHIER(4*i+2) REDIRECT.3" #
# C22="COMMANDE ARGUMENTS FICHIER(4*i+3) REDIRECT.4" #
# (...) #
# #
# pour chaque groupe de 4 fichiers {4*i+0,4*i+1,4*i+2,4*i+3} traites en 4-parallele. #
# #
# #
# 3-"Mode Parallele 'Linda'" : #
# ---------------------------- #
# #
# $xcg/parallele.1?$X C11="$xcs/Linda$vv$Z LISTE REDIRECT.1" #
# C21="$xcs/Linda$vv$Z LISTE REDIRECT.2" #
# #
# dans le cas de 2 process paralleles, ou : #
# #
# $xcg/parallele.1?$X C11="$xcs/Linda$vv$Z LISTE REDIRECT.1" #
# C12="$xcs/Linda$vv$Z LISTE REDIRECT.2" #
# C21="$xcs/Linda$vv$Z LISTE REDIRECT.3" #
# C22="$xcs/Linda$vv$Z LISTE REDIRECT.4" #
# #
# dans le cas de 4 process paralleles, et ou 'LISTE' est le fichier contenant : #
# #
# (...) #
# COMMANDE ARGUMENTS FICHIER(i) #
# (...) #
# #
# pour chaque 'FICHIER(i)' (en notant bien l'absence de 'TestP', ce test de blocage etant #
# fait dans 'v $xcs/Linda$vv$Z TestP' APRES l'execution de chaque commande ; au passage #
# anterieurement au 20090615170127, ce test etait fait AVANT l'execution de chaque commande #
# ce qui etait tres mauvais en cas d'interruption durant un 'BloqueP' puisqu'alors la #
# commande courante -en attente d'execution- etait perdue et donc jamais executee...). #
# #
# D'une facon generale, 'REDIRECT.?' representent les redirections de type '$SHELL_BASH'... #
# #
# Le 20101230105622 on notera que la presence systematique de "ARGUMENTS" (qui provient #
# de '$ArGuMeNtS') peut etre la cause de problemes et par exemple du message d'erreur : #
# #
# ls: : No such file or directory #
# #
# dans le cas ou '$commandeS' serait la commande 'll' et ou '$ArGuMeNtS' serait vide... #
FileTmpE FichierT
endif
FilSTmpB ExecFichierCompact
#20130923103512____:$CA $ExecFichier \ #
#20130923103512____: | $SE -e "s+$xT+"'$xT+g' \ #
#20130923103512____: >> $ExecFichierCompact #
#20211115113239____:$CA $ExecFichier \ #
#20211115113239____: | $SE -e "s+\(>> *\)$xT/+\1+g" \ #
#20211115113239____: -e "s+$xT+"'$xT+g' \ #
#20211115113239____: -e "s+\( \) *+\1+g" \ #
#20211115113239____: -e "s+ *\(>>\) *+\1+g" \ #
#20211115113239____: >> $ExecFichierCompact #
if ($?FReD == $EXIST) then
# Test manquant introduit le 20220112095627... #
$CA $ExecFichier \
| $SE -e "s+\(>> *\)$xT/+\1+g" \
-e "s+$ListeFichier+"'$ListeFichierEnv+g' \
-e "s+`GetLeaf $FReD`+"'$FReDEnv+g' \
-e "s+$FVeRrOuB+"'$FVeRrOuBEnv+g' \
-e "s+$xT+"'$xT+g' \
-e "s+\( \) *+\1+g" \
-e "s+ *\(>>\) *+\1+g" \
>> $ExecFichierCompact
else
$CA $ExecFichier \
>> $ExecFichierCompact
endif
# Ceci est destine a compacter le ficher '$ExecFichier' de facon a reduire les risques #
# d'avoir le message : #
# #
# Word too long. #
# #
# lors du 'source' a venir, comme cela s'est vu sur '$CMAP28' ("abbesses.polytechnique.fr") #
# avec le test : #
# #
# setenv ProcessorNumber 12 #
# $xcg/FindExec.01$Z $xi $FON echo #
# #
# la veille du 20130923095721... #
# #
# Malheureusement, je note le 20130923103512 que cela ne sert a rien car, en effet, la #
# chaine definie par l'argument 'v $xcg/parallele.1N$X commande=' est expansee avec la #
# valeur des differentes variables et c'est la longueur apres expansion qui est trop #
# grande et rien n'y fait ! #
# #
# En fait, une solution partielle fut d'introduire le 20130923103512 : #
# #
# xT #
# #
# en tete de '$ExecFichier' et de supprimer '$xT' dans toute les redirections... #
set VaLiDeCompact=`$CA $ExecFichierCompact | $GRE -v '^#' | $GRE -v '^ *$' | $SE -e "s/^.* commande=//" -e 's/"//g' | $WCc`
#20250107122124____:set SVaLiDeCompact=4000 #
set SVaLiDeCompact=4095
if ($VaLiDeCompact > $SVaLiDeCompact) then
# En fait, il doit s'agir de 4096 (test introduit le 20130923101807...). #
#20160610102029____:EROR "La commande a executer est trop volumineuse (plus de $VaLiDeCompact octets) et ne pourra donc s'executer." #
EROR "La commande a executer est tres volumineuse ($VaLiDeCompact octets, soit plus de $SVaLiDeCompact) \c"
echo "et ne pourra peut-etre donc pas s'executer correctement."
# Le 20160610102029, je note que sur '$CMAP28 ex(1) "porte-brancion"' avec 162819 octets #
# tout semble bien se passer... #
# #
# Le 20211115113239, je note que le compactage via {$ListeFichierEnv,$FReDEnv,$FVeRrOuBEnv} #
# ci-dessus va tres certainement faire disparaitre l'apparition de ce message... #
if ($?FindExec_Parallele == $EXIST) then
if ($FindExec_Parallele == $NEXIST) then
EROR "Cela doit etre du au fait que le parallelisme est bloque par '$K_DOLLAR""FindExec_Parallele'."
else
endif
else
endif
else
endif
unset SVaLiDeCompact
unset VaLiDeCompact
FilSTmpE ExecFichier
#20130923095721____:ro $ExecFichier #
ro $ExecFichierCompact
# En general, on aura ici dans '$ExecFichierCompact' quelque chose du genre : #
# #
# xT #
# $xcg/parallele.1N$X parallele_14=FAUX \ #
# commande="$xcs/Linda$vv$Z FICHIERS..." #
# #
# ou 'FICHIERS' designe d'une part le fichier des commandes a executer, le verrou et le #
# fichier de type 'sortie', le tout repete N fois (avec un "#" de separation)... #
#20130923095721____:eval "(source $ExecFichier) $GJobRedirection" #
eval "(source $ExecFichierCompact) $GJobRedirection"
# On notera que c'est ce 'source' qui execute les commandes de '$ExecFichier' et ce quel #
# que soit le mode (parallele ou sequentiel...). #
# #
# Test introduit le 20090207142031 afin de garantir (du moins je l'espere) l'ordre des #
# lignes du fichier genere lors de 'v $xcc/RecompileAll$Z'... #
# #
# On notera le 20090209092816 l'explication d'un defaut de tabulation lors de tests utilisant #
# la commande : #
# #
# $xcg/FindExec.01$Z $xbg $X "$LL" #
# #
# ('$xbg' par exemple). Les sorties sont alors mal tabulees a partir de la colonne de la #
# taille des fichiers. La raison en est evidente ; la commande precedente n'est pas #
# equivalent a : #
# #
# $LL $xbg/*$X #
# #
# En effet, dans le second cas ('$LL' global), la commande '$LL' connait la taille du plus #
# grand fichier (parmi la liste '$xbg/*$X'), d'ou la bonne tabulation. Alors que dans le #
# premier cas, '$LL' est active fichier par fichier et cette taille maximale n'est plus #
# connue... #
#20130923095721____:FilSTmpE ExecFichier #
FilSTmpE ExecFichierCompact
FileTmpE ListeFichier
# Nettoyage avant le retour. #
#20130924163909____:if ($?FReDiReCtIoN == $EXIST) then #
if ($?FReD == $EXIST) then
# Sequence introduite le 20090117100347... #
#20090208101943____: if ($?JobRedirection == $EXIST) then #
#20090207154407____: echo "Ces $NoMbRePrOcEsS fichiers de redirection sont concatenes ci-apres :" #
#20090207154407____: saut #
#20090207154407____: saut #
#20090208101943____: EchoJob "Ces $NoMbRePrOcEsS fichiers de redirection sont concatenes ci-apres :" #
#20090208093422____: EcHoR "" #
#20090208093422____: EcHoR "" #
# Message introduit le 20090117113902... #
#20090208101943____: eval "$CA $FReDiReCtIoN* $GJobRedirection" #
# Ainsi, on genere le fichier resultat attendu (introduit le 20090117101212). #
#20090208101943____: else #
#20090208101943____: endif #
if ($FindExec_MessagesBP == $EXIST) then
# Test introduit le 20150205105239... #
saut 2
# Introduit le 20090613175806... #
#20090226101118____: EchoJob "Ces $NoMbRePrOcEsS fichiers de redirection sont concatenes ci-apres :" #
#20090613175806____: EchoJob "Ces $NoMbRePrOcEsS fichiers de redirection sont concatenes ci-apres :" #
#20101230102551:EchoJob "A la fin des processus paralleles, ces $NoMbRePrOcEsS fichiers de redirection sont concatenes ci-apres :" #
EchoJob "A la fin des processus paralleles, ces $NoMbRePrOcEsS fichiers de redirection sont concatenes ci-apres \c"
#20130924161905____: echo "(la chronologie n'etant donc pas respectee...) :" #
echo "(la chronologie des differentes operations effectuees en parallele n'etant donc pas respectee...) :"
saut 2
# Introduit le 20090613175806... #
source $xo/RecherchG$vv$Y
saut 4
# Introduit le 20230228125711... #
else
endif
#20130924163909____: eval "$CA $FReDiReCtIoN* $GJobRedirection" #
eval "$CA $FReD* $GJobRedirection"
# Ainsi, on genere le fichier resultat attendu (introduit le 20090117101212). #
#20130924163909____: FileTmpE FReDiReCtIoN $NEXIST #
FileTmpE FReD $NEXIST
# Nettoyage avant le retour, en notant qu'evidemment les fichiers '$FReDiReCtIoN' ne sont #
# pas detruits puisqu'ils contiennent les sorties 'stdout' et 'stderr' des commandes... #
else
endif
if ($?FVeRrOuB == $EXIST) then
# Sequence introduite le 20090317101238... #
FilSTmpE FVeRrOuB
# Nettoyage avant le retour... #
else
endif