Télécharger tempor.eso

Retour à la liste

Numérotation des lignes :

  1. C TEMPOR SOURCE PV 20/09/14 21:15:05 10712
  2. C
  3. C temps ecoule depuis le dernier appel
  4. C occupation memoire
  5. C utilisation des operateurs
  6. C
  7. SUBROUTINE TEMPOR(ITABS0,ITABSO,MDIR,IAPPEL,IELAPS,ITCPU,ITCPU0,
  8. & NACT,ILON,ith)
  9.  
  10. C en entree on a les informations stockees (SAVE) par pilot
  11. C sur les operateurs
  12. C
  13. C entree
  14. C ITABS0 : date absolue depuis l'initialisation de TEMP (TEMP ZERO)
  15. C ITABSO : date absolue depuis le dernier appel a TEMP
  16. C MDIR : tableau des noms de tous les operateurs
  17. C IAPPEL : nombre d'appel a chaque operateur pour chaque ASSISTANT
  18. C IELAPS : temps total passe dans chaque operateur pour chaque ASSISTANT (pris a l'horloge "murale")
  19. C ITCPU : temps CPU passe dans chaque operateur pour chaque ASSISTANT
  20. C ITCPU0 : temps CPU global depuis le premier passage dans pilot.eso
  21. C NACT(1): nombre de segments actifs en + après l'appel a l'operateur
  22. C NACT(2): taille correspondante en MOTS
  23. C ILON : Nombre d'operateurs connus dans pilot
  24. C ith : numero du thread sur lequel est lance TEMPS
  25. C
  26. C include
  27. IMPLICIT INTEGER(I-N)
  28. IMPLICIT real*8 (a-h,o-z)
  29.  
  30. -INC PPARAM
  31. -INC CCOPTIO
  32. -INC CCASSIS
  33. -INC SMTABLE
  34. POINTEUR MTAB4.MTABLE, MTAB5.MTABLE
  35. -INC SMLENTI
  36. POINTEUR MLENT4.MLENTI
  37. -INC SMLREEL
  38.  
  39.  
  40. C variables declarees
  41. REAL*8 XRAP
  42. INTEGER IELAPS, ITABS0, ITABSO, ITCPU, ITCPU0
  43. INTEGER IMAX , IECCPU, IECOU0, IECOUL
  44.  
  45.  
  46. CHARACTER*4 MOT(6),MDIR(ILON)
  47. CHARACTER*4 MOT2(2),MOT3(2),MOT4(4),MOT5(3)
  48. INTEGER NACT,NACTI,NTACT,OOOVAL, IAPPEL
  49. INTEGER ittime
  50. DIMENSION IAPPEL(ILON,*),IELAPS(ILON,*),ITCPU(ILON,*),NACT(2,*)
  51. DIMENSION ittime(4)
  52.  
  53. CHARACTER*80 COLO80
  54.  
  55. SEGMENT ITRAV1
  56. INTEGER IAPCUM(ILON)
  57. INTEGER IATMP(ILON)
  58. INTEGER IETMP(ILON)
  59. INTEGER ITTMP(ILON)
  60. ENDSEGMENT
  61.  
  62. C
  63. C tableaux des mots-cles
  64. DATA MOT /'PLAC','NOEC','IMPR','ZERO','SGAC','ENTI'/
  65. DATA MOT2/'HORL','CPU'/
  66. DATA MOT3/'MAXI','SOMM'/
  67. DATA MOT4/'APPE','HORL','CPU','EFFI'/
  68. DATA MOT5/'OPER','PROC','BOUC'/
  69. C
  70. C ERREUR si ith n'est pas egal a 0 (Thread 0)
  71. IF (ith .NE. 0) THEN
  72. CALL ERREUR(915)
  73. RETURN
  74. ENDIF
  75.  
  76. ************************************************************************
  77. * Travail de recuperation des valeurs
  78. ************************************************************************
  79. SEGINI,ITRAV1
  80.  
  81. IPASS = 0
  82. call timespv(ittime,oothrd)
  83. IECOU0 = (ittime(1) + ittime(2)) - ITABS0
  84. IECOUL = (ittime(1) + ittime(2)) - ITABSO
  85.  
  86. ITABSO = (ittime(1) + ittime(2))
  87.  
  88. C Valeurs cumulees pour le temps Elapsed et le temps CPU
  89. IECCPU = -ITCPU0
  90. DO J=1,ILON
  91.  
  92. INDICE = 0
  93. DO II=1,NBESCR + 1
  94. INDICE = INDICE + IAPPEL(J,II)
  95. IECCPU = IECCPU + ITCPU(J,II)
  96. ENDDO
  97.  
  98. IAPCUM(J)= INDICE
  99. ENDDO
  100.  
  101. C Preparation pour l'appel au message d'ERREUR -259
  102. ITCPU0 = ITCPU0 + IECCPU
  103.  
  104. IF ((IECOUL / 10) .EQ. 0) THEN
  105. C Cas du tout premier appel a temps impr
  106. INTERR(1)= IECOU0 / 10
  107. ELSE
  108. INTERR(1)= IECOUL / 10
  109. ENDIF
  110. IF ((IECCPU / 10) .EQ. 0) THEN
  111. C Cas du tout premier appel a temps impr
  112. INTERR(2)= ITCPU0 / 10
  113. ELSE
  114. INTERR(2)= IECCPU / 10
  115. ENDIF
  116.  
  117.  
  118. ************************************************************************
  119. * Lecture des ARGUMENTS
  120. ************************************************************************
  121.  
  122. I = 0
  123. 1 CONTINUE
  124. CALL LIRMOT(MOT,6,I,0)
  125.  
  126.  
  127. ************************************************************************
  128. c pas d'option : TEMP;
  129. ************************************************************************
  130.  
  131. IF(I.EQ.0.AND.IPASS.EQ.0) THEN
  132. c Temps horloge %i1 ms / Temps CPU %i2 ms (depuis le dernier APPEL)
  133. SEGSUP,ITRAV1
  134. CALL ERREUR(-259)
  135. RETURN
  136. ENDIF
  137.  
  138.  
  139. ************************************************************************
  140. c option 'ENTI'
  141. ************************************************************************
  142.  
  143. IF(I.EQ.6.AND.IPASS.EQ.0) THEN
  144. I2=0
  145. CALL LIRMOT(MOT2,2,I2,0)
  146. c par defaut on retourne le temps CPU
  147. IF(I2.eq.0) I2=2
  148. CALL ECRENT(INTERR(I2))
  149. SEGSUP,ITRAV1
  150. RETURN
  151. ENDIF
  152.  
  153. C temoin de passage dans la boucle
  154. IPASS = 1
  155.  
  156. IF(I.EQ.0) THEN
  157. SEGSUP,ITRAV1
  158. RETURN
  159. ENDIF
  160.  
  161.  
  162. ************************************************************************
  163. C option 'PLAC'
  164. ************************************************************************
  165.  
  166. IF(I.EQ.1) THEN
  167.  
  168. CALL ERREUR(-259)
  169. CALL OOODMP(0)
  170.  
  171. ************************************************************************
  172. C option 'NOEC'
  173. ************************************************************************
  174.  
  175. ELSEIF(I.EQ.2) THEN
  176. C Ecriture des donnees dans une TABLE avec une structure bien definie
  177.  
  178. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  179. C Table de sortie
  180. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  181. M = 0
  182. SEGINI,MTABLE
  183.  
  184. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  185. C TABLES : 'TEMPS_HORLOGE', 'TEMPS_CPU', 'TEMPS_ATTENTE', 'APPELS'
  186. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  187. M = 0
  188. SEGINI,MTAB1,MTAB2,MTAB3,MTAB4,MTAB5
  189. COLO80 = 'TEMPS_HORLOGE'
  190. CALL ECCTAB(MTABLE,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  191. & 'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB1)
  192.  
  193. COLO80='INITIAL'
  194. CALL ECCTAB(MTAB1,'MOT ',0 ,0.d0,COLO80 ,.FALSE.,0,
  195. & 'ENTIER',IECOU0/10,0.d0,'RIEN' ,.FALSE.,0)
  196.  
  197. COLO80='DERNIER_APPEL'
  198. CALL ECCTAB(MTAB1,'MOT ',0 ,0.d0,COLO80 ,.FALSE.,0,
  199. & 'ENTIER',IECOUL/10,0.d0,'RIEN' ,.FALSE.,0)
  200.  
  201. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  202.  
  203. COLO80 = 'TEMPS_CPU'
  204. CALL ECCTAB(MTABLE,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  205. & 'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB2)
  206.  
  207. COLO80='INITIAL'
  208. CALL ECCTAB(MTAB2,'MOT ',0 ,0.d0,COLO80 ,.FALSE.,0,
  209. & 'ENTIER',ITCPU0/10,0.d0,'RIEN' ,.FALSE.,0)
  210.  
  211. COLO80='DERNIER_APPEL'
  212. CALL ECCTAB(MTAB2,'MOT ',0 ,0.d0,COLO80 ,.FALSE.,0,
  213. & 'ENTIER',IECCPU/10,0.d0,'RIEN' ,.FALSE.,0)
  214.  
  215. COLO80 = 'TEMPS_ATTENTE'
  216. CALL ECCTAB(MTABLE,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  217. & 'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB3)
  218.  
  219. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  220.  
  221. COLO80 = 'APPELS'
  222. CALL ECCTAB(MTABLE,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  223. & 'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB4)
  224.  
  225. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  226.  
  227. COLO80 = 'EFFICACITE'
  228. CALL ECCTAB(MTABLE,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  229. & 'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB5)
  230.  
  231. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  232.  
  233. C Remplissage des LISTENTI de valeurs
  234. DO J=1,ILON
  235. IF (IAPCUM(J) .NE. 0) THEN
  236. JG = NBESCR+1
  237. SEGINI,MLENT1,MLENT2,MLENT3,MLENT4,MLREE1
  238.  
  239. DO II=1,NBESCR+1
  240. MLENT1.LECT(II) = IELAPS(J,II) / 10
  241. MLENT2.LECT(II) = ITCPU(J,II) / 10
  242. MLENT3.LECT(II) = (IELAPS(J,II) - ITCPU(J,II) ) / 10
  243. MLENT4.LECT(II) = IAPPEL(J,II)
  244. IVAL1=IELAPS(J,II)
  245. IF(IVAL1 .EQ. 0)THEN
  246. XVAL1=1.D0
  247. ELSE
  248. XVAL1=REAL(ITCPU(J,II)) / REAL(IVAL1)
  249. ENDIF
  250. MLREE1.PROG(II) = XVAL1
  251. ENDDO
  252.  
  253. C Ecriture dans les TABLES des LISTENTI de valeurs par operateur
  254. COLO80=MDIR(J)
  255. CALL ECCTAB(MTAB1,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  256. & 'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT1)
  257.  
  258. CALL ECCTAB(MTAB2,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  259. & 'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT2)
  260.  
  261. CALL ECCTAB(MTAB3,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  262. & 'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT3)
  263.  
  264. CALL ECCTAB(MTAB4,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  265. & 'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT4)
  266.  
  267. CALL ECCTAB(MTAB5,'MOT ',0,0.d0,COLO80 ,.FALSE.,0,
  268. & 'LISTREEL',0,0.d0,'RIEN' ,.FALSE.,MLREE1)
  269.  
  270. SEGDES,MLENT1,MLENT2,MLENT3,MLENT4,MLREE1
  271. ENDIF
  272. ENDDO
  273. SEGDES,MTAB1,MTAB2,MTAB3,MTAB4,MTAB5
  274.  
  275. SEGDES,MTABLE
  276. C Ecriture sur la Pile de l'objet resultat
  277. CALL ECROBJ('TABLE ',MTABLE)
  278. SEGSUP,ITRAV1
  279. RETURN
  280.  
  281.  
  282. ************************************************************************
  283. C option 'IMPR'
  284. ************************************************************************
  285.  
  286. ELSEIF(I.EQ.3) THEN
  287. C Affichage des valeurs a l'ecran
  288.  
  289. C Temps dans les procedures ?
  290. CALL LIRMOT(MOT5,3,I5,0)
  291. IF (I5 .EQ. 2) THEN
  292. CALL TEMBLO(0)
  293. RETURN
  294. ELSEIF(I5 .EQ. 3) THEN
  295. CALL TEMBLO(1)
  296. RETURN
  297. ENDIF
  298.  
  299. c Eventuelle option : MAXI ou SOMM pour synthetiser en 1 seul tableau
  300. I3=0
  301. CALL LIRMOT(MOT3,2,I3,0)
  302.  
  303. C****** option 'IMPR' 'MAXI' ou 'IMPR' 'SOMM' *******
  304. IF(I3.NE.0) THEN
  305.  
  306. c Eventuelle option de tri : APPE, HORL ou CPU
  307. I4=0
  308. CALL LIRMOT(MOT4,3,I4,0)
  309.  
  310. WRITE(IOIMP,*)
  311. c 'MAXI' ou 'SOMM'
  312. IF(I3.EQ.1) THEN
  313. WRITE(IOIMP,FMT='(22X,A)') 'Maxi sur les assistants :'
  314. c merge "MAXVAL" des tableaux pour devenir 1D
  315. CALL IMAX2(IAPPEL,ILON,NBESCR+1,IATMP)
  316. CALL IMAX2(IELAPS,ILON,NBESCR+1,IETMP)
  317. CALL IMAX2(ITCPU ,ILON,NBESCR+1,ITTMP)
  318. ELSE
  319. WRITE(IOIMP,FMT='(22X,A)') 'Somme sur les assistants :'
  320. c merge "SOMME" des tableaux pour devenir 1D
  321. CALL ISUM2(IAPPEL,ILON,NBESCR+1,IATMP)
  322. * pas de somme sur les elaps
  323. * CALL ISUM2(IELAPS,ILON,NBESCR+1,IETMP)
  324. CALL IMAX2(IELAPS,ILON,NBESCR+1,IETMP)
  325. CALL ISUM2(ITCPU ,ILON,NBESCR+1,ITTMP)
  326. ENDIF
  327.  
  328. IF (LANGUE .EQ. 'FRAN') THEN
  329. WRITE(IOIMP,40) 'Operateur','Nombre d appels',
  330. & 'Horloge (ms)','Temps CPU (ms)'
  331. ELSE
  332. WRITE(IOIMP,40) 'Operator ','Number of Calls',
  333. & 'Elapsed (ms)','CPU Time (ms) '
  334. ENDIF
  335. 40 FORMAT(1X,A9,3X,A16,3X,A12,3X,A14)
  336.  
  337. c --- souhaite t'on un tri ? ---
  338. IF(I4.GT.0) THEN
  339. JG=ILON
  340. SEGINI,MLENTI,MLENT1
  341. c option 'IMPR' ('MAXI' ou 'SOMM') 'APPE'
  342. IF(I4.eq.1) THEN
  343. DO I=1,ILON
  344. MLENTI.LECT(I)=IATMP(I)
  345. MLENT1.LECT(I)=I
  346. ENDDO
  347. c option 'IMPR' ('MAXI' ou 'SOMM') 'HORL'
  348. ELSEIF(I4.eq.2) THEN
  349. DO I=1,ILON
  350. MLENTI.LECT(I)=IETMP(I)
  351. MLENT1.LECT(I)=I
  352. ENDDO
  353. c option 'IMPR' ('MAXI' ou 'SOMM') 'CPU'
  354. ELSE
  355. DO I=1,ILON
  356. MLENTI.LECT(I)=ITTMP(I)
  357. MLENT1.LECT(I)=I
  358. ENDDO
  359. ENDIF
  360. c tri croissant de maniere a avoir les + grandes valeurs en bas
  361. CALL ORDO04(LECT(1),ILON,.TRUE.,MLENT1.LECT(1))
  362. c boucle sur les operateurs
  363. DO J=1,ILON
  364. K = MLENT1.LECT(J)
  365. IF (IAPCUM(K) .NE. 0) THEN
  366. WRITE(IOIMP,41)MDIR(K),IATMP(K),(IETMP(K)/10),(ITTMP(K)/10)
  367. ENDIF
  368. ENDDO
  369. SEGSUP,MLENTI,MLENT1
  370.  
  371. c --- pas de tri : boucle sur tous les operateurs ---
  372. ELSE
  373. DO J=1,ILON
  374. IF (IAPCUM(J) .NE. 0) THEN
  375. WRITE(IOIMP,41)MDIR(J),IATMP(J),(IETMP(J)/10),(ITTMP(J)/10)
  376. ENDIF
  377. ENDDO
  378. ENDIF
  379. 41 FORMAT(2X,A4,3(3X,I12))
  380.  
  381.  
  382. C****** option 'IMPR' seule ******
  383. ELSE
  384.  
  385. c Eventuelle option de restriction : APPE, HORL, CPU ou EFFI
  386. I4=0
  387. CALL LIRMOT(MOT4,4,I4,0)
  388.  
  389. IF(I4.EQ.0.OR.I4.EQ.2) THEN
  390. WRITE(IOIMP,*)
  391. IF (LANGUE .EQ. 'FRAN') THEN
  392. MOTERR(1:18)='Temps Horloge (ms)'
  393. ELSE
  394. MOTERR(1:18)='Elapsed Time (ms)'
  395. ENDIF
  396. CALL ERREUR(-258)
  397. DO J=1,ILON
  398. IF (IAPCUM(J) .NE. 0) THEN
  399. C Ecriture a l'ecran des Temps Elapsed
  400. WRITE(IOIMP,31)MDIR(J),(IELAPS(J,II) / 10,II=1,NBESCR+1)
  401. 31 FORMAT(2X,A4,65(2X,I11))
  402. ENDIF
  403. ENDDO
  404. ENDIF
  405.  
  406. IF(I4.EQ.0.OR.I4.EQ.3) THEN
  407. WRITE(IOIMP,*)
  408. IF (LANGUE .EQ. 'FRAN') THEN
  409. MOTERR(1:18)='Temps CPU (ms)'
  410. ELSE
  411. MOTERR(1:18)='CPU Time (ms)'
  412. ENDIF
  413. CALL ERREUR(-258)
  414. DO J=1,ILON
  415. IF (IAPCUM(J) .NE. 0) THEN
  416. C Ecriture a l'ecran des Temps CPU
  417. WRITE(IOIMP,32)MDIR(J),((ITCPU(J,II) / 10),II=1,NBESCR+1)
  418. 32 FORMAT(2X,A4,65(2X,I11))
  419. ENDIF
  420. ENDDO
  421. ENDIF
  422.  
  423. IF(I4.EQ.0.OR.I4.EQ.1) THEN
  424. WRITE(IOIMP,*)
  425. IF (LANGUE .EQ. 'FRAN') THEN
  426. MOTERR(1:18)='Nombre appels '
  427. ELSE
  428. MOTERR(1:18)='Number of Calls '
  429. ENDIF
  430. CALL ERREUR(-258)
  431. DO J=1,ILON
  432. IF (IAPCUM(J) .NE. 0) THEN
  433. C Ecriture a l'ecran des nombres d'appels
  434. WRITE(IOIMP,33)MDIR(J),(IAPPEL(J,II),II=1,NBESCR+1)
  435. 33 FORMAT(2X,A4,65(2X,I11))
  436. ENDIF
  437. ENDDO
  438. ENDIF
  439.  
  440. IF(I4.EQ.0.OR.I4.EQ.4) THEN
  441. WRITE(IOIMP,*)
  442. IF (LANGUE .EQ. 'FRAN') THEN
  443. MOTERR(1:18)='Efficacite '
  444. ELSE
  445. MOTERR(1:18)='Efficiency '
  446. ENDIF
  447. CALL ERREUR(-258)
  448. DO J=1,ILON
  449. IF (IAPCUM(J) .NE. 0) THEN
  450. C Ecriture a l'ecran des efficacite
  451. WRITE(IOIMP,34)MDIR(J),
  452. & (REAL(ITCPU(J,II)) / MAX(1,IELAPS(J,II)),II=1,NBESCR+1)
  453. 34 FORMAT(2X,A4,65(7X,F6.4))
  454. ENDIF
  455. ENDDO
  456. ENDIF
  457.  
  458. ENDIF
  459.  
  460. WRITE(IOIMP,*)
  461. CALL ERREUR(-259)
  462.  
  463.  
  464. ************************************************************************
  465. C option 'ZERO'
  466. ************************************************************************
  467.  
  468. ELSEIF(I.EQ.4) THEN
  469. ITABS0 = ittime(1) + ittime(2)
  470. ITCPU0 = 0
  471. DO 4 J=1,ILON
  472. NACT(1,J) = 0
  473. NACT(2,J) = 0
  474.  
  475. DO II=1,NBESCR+1
  476. IAPPEL(J,II) = 0
  477. IELAPS(J,II) = 0
  478. ITCPU (J,II) = 0
  479. ENDDO
  480. 4 CONTINUE
  481.  
  482.  
  483. ************************************************************************
  484. C option 'SGAC'
  485. ************************************************************************
  486.  
  487. ELSEIF(I.EQ.5) THEN
  488. C on ecrit le nombre de segments actifs et leur taille
  489.  
  490. CALL LIRMOT(MOT,5,J,0)
  491. GOTO (11,12,12,13,12,12),(J+1)
  492. C il n'y a pas d'autre options on renvoie nbre et taille des segments actifs
  493. 11 NBACTI = OOOVAL(2,3)
  494. NTACTI = OOOVAL(3,3)
  495. CALL ECRENT(NBACTI)
  496. CALL ECRENT(NTACTI)
  497. SEGSUP,ITRAV1
  498. RETURN
  499.  
  500. C il y a d'autres options on renvoie nbre et taille des segments actifs
  501. 12 CALL REFUS
  502. NBACTI = OOOVAL(2,3)
  503. NTACTI = OOOVAL(3,3)
  504. CALL ECRENT(NTACTI)
  505. CALL ECRENT(NBACTI)
  506. GOTO 1
  507. C option SGAC IMPR statistiques relatives aux segments actifs
  508. 13 WRITE(IOIMP,*)
  509. CALL ERREUR(-308)
  510.  
  511. DO 15 J =1,ILON
  512. IF (IAPCUM(J) .NE. 0) THEN
  513. NACTI = NACT(1,J)
  514. NTACT = NACT(2,J) / 1000
  515. WRITE(IOIMP,14)MDIR(J),IAPCUM(J),NACTI,NTACT
  516. 14 FORMAT(2X,A4,7X,I6,7X,I6,7X,I6)
  517. ENDIF
  518. 15 CONTINUE
  519. ENDIF
  520.  
  521. C on retourne lire d'autres options
  522. GOTO 1
  523. END
  524.  
  525.  
  526.  
  527.  
  528.  

© Cast3M 2003 - Tous droits réservés.
Mentions légales