Télécharger la plaquette Cast3M


fr en

Télécharger tempor.eso

Retour à la liste

Numérotation des lignes : 

tempor

  1. C TEMPOR    SOURCE    PV        22/06/15    21:15:02     11388          
  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.       PARAMETER   (NBMOT = 7)
  47.       CHARACTER*4 MOT(NBMOT),MDIR(ILON)
  48.       CHARACTER*4 MOT3(2),MOT4(4),MOT5(3)
  49.       INTEGER     NACT,NACTI,NTACT,OOOVAL, IAPPEL
  50.       INTEGER     ittime
  51.       DIMENSION   IAPPEL(ILON,*),IELAPS(ILON,*),ITCPU(ILON,*),NACT(2,*)
  52.       DIMENSION   ittime(4)
  53.  
  54.       CHARACTER*80  COLO80
  55.  
  56.       SEGMENT ITRAV1
  57.         INTEGER IAPCUM(ILON)
  58.         INTEGER IATMP(ILON)
  59.         INTEGER IETMP(ILON)
  60.         INTEGER ITTMP(ILON)
  61.       ENDSEGMENT
  62.  
  63. C
  64. C     tableaux des mots-cles
  65.       DATA MOT /'PLAC','NOEC','IMPR','ZERO','SGAC','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,NBMOT,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(-378)
  135.         RETURN
  136.       ENDIF
  137.  
  138.  
  139. ************************************************************************
  140. c  Operateur TEMPS
  141. ************************************************************************
  142.  
  143.       IF(I.GE.6.AND.IPASS.EQ.0) THEN
  144.         IF (I.EQ.6) ITPS = IECOU0 / 10
  145.         IF (I.EQ.7) ITPS = ITCPU0 / 10
  146.         CALL ECRENT(ITPS)
  147.         SEGSUP,ITRAV1
  148.         RETURN
  149.       ENDIF
  150.  
  151. C  temoin de passage dans la boucle
  152.       IPASS = 1
  153.  
  154.       IF(I.EQ.0) THEN
  155.         SEGSUP,ITRAV1
  156.         RETURN
  157.       ENDIF
  158.  
  159.  
  160. ************************************************************************
  161. C  option 'PLAC'
  162. ************************************************************************
  163.  
  164.       IF(I.EQ.1) THEN
  165.  
  166.          CALL ERREUR(-378)
  167.          CALL OOODMP(0)
  168.  
  169. ************************************************************************
  170. C  option 'NOEC'
  171. ************************************************************************
  172.  
  173.       ELSEIF(I.EQ.2) THEN
  174. C       Ecriture des donnees dans une TABLE avec une structure bien definie
  175.  
  176. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  177. C       Table de sortie
  178. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  179.         M = 0
  180.         SEGINI,MTABLE
  181.  
  182. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  183. C       TABLES : 'TEMPS_HORLOGE', 'TEMPS_CPU', 'TEMPS_ATTENTE', 'APPELS'
  184. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  185.         M = 0
  186.         SEGINI,MTAB1,MTAB2,MTAB3,MTAB4,MTAB5
  187.         COLO80 = 'TEMPS_HORLOGE'
  188.         CALL ECCTAB(MTABLE,'MOT  ',0,0.d0,COLO80 ,.FALSE.,0,
  189.      &                     'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB1)
  190.  
  191.         COLO80='INITIAL'
  192.         CALL ECCTAB(MTAB1,'MOT   ',0        ,0.d0,COLO80 ,.FALSE.,0,
  193.      &                    'ENTIER',IECOU0/10,0.d0,'RIEN' ,.FALSE.,0)
  194.  
  195.         COLO80='DERNIER_APPEL'
  196.         CALL ECCTAB(MTAB1,'MOT   ',0        ,0.d0,COLO80 ,.FALSE.,0,
  197.      &                    'ENTIER',IECOUL/10,0.d0,'RIEN' ,.FALSE.,0)
  198.  
  199. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  200.  
  201.         COLO80 = 'TEMPS_CPU'
  202.         CALL ECCTAB(MTABLE,'MOT  ',0,0.d0,COLO80 ,.FALSE.,0,
  203.      &                     'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB2)
  204.  
  205.         COLO80='INITIAL'
  206.         CALL ECCTAB(MTAB2,'MOT   ',0        ,0.d0,COLO80 ,.FALSE.,0,
  207.      &                    'ENTIER',ITCPU0/10,0.d0,'RIEN' ,.FALSE.,0)
  208.  
  209.         COLO80='DERNIER_APPEL'
  210.         CALL ECCTAB(MTAB2,'MOT   ',0        ,0.d0,COLO80 ,.FALSE.,0,
  211.      &                    'ENTIER',IECCPU/10,0.d0,'RIEN' ,.FALSE.,0)
  212.  
  213.         COLO80 = 'TEMPS_ATTENTE'
  214.         CALL ECCTAB(MTABLE,'MOT  ',0,0.d0,COLO80 ,.FALSE.,0,
  215.      &                     'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB3)
  216.  
  217. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  218.  
  219.         COLO80 = 'APPELS'
  220.         CALL ECCTAB(MTABLE,'MOT  ',0,0.d0,COLO80 ,.FALSE.,0,
  221.      &                     'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB4)
  222.  
  223. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  224.  
  225.         COLO80 = 'EFFICACITE'
  226.         CALL ECCTAB(MTABLE,'MOT  ',0,0.d0,COLO80 ,.FALSE.,0,
  227.      &                     'TABLE',0,0.d0,'RIEN' ,.FALSE.,MTAB5)
  228.  
  229. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  230.  
  231. C       Remplissage des LISTENTI de valeurs
  232.         DO J=1,ILON
  233.           IF (IAPCUM(J) .NE. 0) THEN
  234.             JG = NBESCR+1
  235.             SEGINI,MLENT1,MLENT2,MLENT3,MLENT4,MLREE1
  236.  
  237.             DO II=1,NBESCR+1
  238.               MLENT1.LECT(II) =  IELAPS(J,II) / 10
  239.               MLENT2.LECT(II) =  ITCPU(J,II)  / 10
  240.               MLENT3.LECT(II) = (IELAPS(J,II) - ITCPU(J,II) ) / 10
  241.               MLENT4.LECT(II) =  IAPPEL(J,II)
  242.               IVAL1=IELAPS(J,II)
  243.               RVAL1 = REAL(IVAL1)
  244.               IF(IVAL1 .EQ. 0)THEN
  245.                 RVAL1=1.D0
  246.               ENDIF
  247.               XVAL1=REAL(ITCPU(J,II)) / RVAL1
  248.               MLREE1.PROG(II) = XVAL1
  249.             ENDDO
  250.  
  251. C           Ecriture dans les TABLES des LISTENTI de valeurs par operateur
  252.             COLO80=MDIR(J)
  253.             CALL ECCTAB(MTAB1,'MOT     ',0,0.d0,COLO80 ,.FALSE.,0,
  254.      &                        'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT1)
  255.  
  256.             CALL ECCTAB(MTAB2,'MOT     ',0,0.d0,COLO80 ,.FALSE.,0,
  257.      &                        'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT2)
  258.  
  259.             CALL ECCTAB(MTAB3,'MOT     ',0,0.d0,COLO80 ,.FALSE.,0,
  260.      &                        'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT3)
  261.  
  262.             CALL ECCTAB(MTAB4,'MOT     ',0,0.d0,COLO80 ,.FALSE.,0,
  263.      &                        'LISTENTI',0,0.d0,'RIEN' ,.FALSE.,MLENT4)
  264.  
  265.             CALL ECCTAB(MTAB5,'MOT     ',0,0.d0,COLO80 ,.FALSE.,0,
  266.      &                        'LISTREEL',0,0.d0,'RIEN' ,.FALSE.,MLREE1)
  267.  
  268.             SEGDES,MLENT1,MLENT2,MLENT3,MLENT4,MLREE1
  269.           ENDIF
  270.         ENDDO
  271.         SEGDES,MTAB1,MTAB2,MTAB3,MTAB4,MTAB5
  272.  
  273.         SEGDES,MTABLE
  274. C       Ecriture sur la Pile de l'objet resultat
  275.         CALL ECROBJ('TABLE   ',MTABLE)
  276.         SEGSUP,ITRAV1
  277.         RETURN
  278.  
  279.  
  280. ************************************************************************
  281. C  option 'IMPR'
  282. ************************************************************************
  283.  
  284.       ELSEIF(I.EQ.3) THEN
  285. C       Affichage des valeurs a l'ecran
  286.  
  287. C       Temps dans les procedures ?
  288.         CALL LIRMOT(MOT5,3,I5,0)
  289.         IF    (I5 .EQ. 2) THEN
  290.           CALL TEMBLO(0)
  291.           RETURN
  292.         ELSEIF(I5 .EQ. 3) THEN
  293.           CALL TEMBLO(1)
  294.           RETURN
  295.         ENDIF
  296.  
  297. c       Eventuelle option : MAXI ou SOMM pour synthetiser en 1 seul tableau
  298.         I3=0
  299.         CALL LIRMOT(MOT3,2,I3,0)
  300.  
  301. C****** option 'IMPR' 'MAXI' ou 'IMPR' 'SOMM' *******
  302.         IF(I3.NE.0) THEN
  303.  
  304. c        Eventuelle option de tri : APPE, HORL ou CPU
  305.          I4=0
  306.          CALL LIRMOT(MOT4,3,I4,0)
  307.  
  308.          WRITE(IOIMP,*)
  309. c        'MAXI' ou 'SOMM'
  310.          IF(I3.EQ.1) THEN
  311.            WRITE(IOIMP,FMT='(22X,A)') 'Maxi sur les assistants :'
  312. c          merge "MAXVAL" des tableaux pour devenir 1D
  313.            CALL IMAX2(IAPPEL,ILON,NBESCR+1,IATMP)
  314.            CALL IMAX2(IELAPS,ILON,NBESCR+1,IETMP)
  315.            CALL IMAX2(ITCPU ,ILON,NBESCR+1,ITTMP)
  316.          ELSE
  317.            WRITE(IOIMP,FMT='(22X,A)') 'Somme sur les assistants :'
  318. c          merge "SOMME" des tableaux pour devenir 1D
  319.            CALL ISUM2(IAPPEL,ILON,NBESCR+1,IATMP)
  320. *  pas de somme sur les elaps
  321. *          CALL ISUM2(IELAPS,ILON,NBESCR+1,IETMP)
  322.            CALL IMAX2(IELAPS,ILON,NBESCR+1,IETMP)
  323.            CALL ISUM2(ITCPU ,ILON,NBESCR+1,ITTMP)
  324.          ENDIF
  325.  
  326.          IF (LANGUE .EQ. 'FRAN') THEN
  327.            WRITE(IOIMP,40) 'Operateur','Nombre d appels',
  328.      &                     'Horloge (ms)','Temps CPU (ms)'
  329.          ELSE
  330.            WRITE(IOIMP,40) 'Operator ','Number of Calls',
  331.      &                     'Elapsed (ms)','CPU Time (ms) '
  332.          ENDIF
  333.  40      FORMAT(1X,A9,3X,A16,3X,A12,3X,A14)
  334.  
  335. c    --- souhaite t'on un tri ? ---
  336.          IF(I4.GT.0) THEN
  337.            JG=ILON
  338.            SEGINI,MLENTI,MLENT1
  339. c          option 'IMPR' ('MAXI' ou 'SOMM') 'APPE'
  340.            IF(I4.eq.1) THEN
  341.              DO I=1,ILON
  342.                 MLENTI.LECT(I)=IATMP(I)
  343.                 MLENT1.LECT(I)=I
  344.              ENDDO
  345. c          option 'IMPR' ('MAXI' ou 'SOMM') 'HORL'
  346.            ELSEIF(I4.eq.2) THEN
  347.              DO I=1,ILON
  348.                 MLENTI.LECT(I)=IETMP(I)
  349.                 MLENT1.LECT(I)=I
  350.              ENDDO
  351. c          option 'IMPR' ('MAXI' ou 'SOMM') 'CPU'
  352.            ELSE
  353.              DO I=1,ILON
  354.                 MLENTI.LECT(I)=ITTMP(I)
  355.                 MLENT1.LECT(I)=I
  356.              ENDDO
  357.            ENDIF
  358. c          tri croissant de maniere a avoir les + grandes valeurs en bas
  359.            CALL ORDO04(LECT(1),ILON,.TRUE.,MLENT1.LECT(1))
  360. c          boucle sur les operateurs
  361.            DO J=1,ILON
  362.              K = MLENT1.LECT(J)
  363.              IF (IAPCUM(K) .NE. 0) THEN
  364.              WRITE(IOIMP,41)MDIR(K),IATMP(K),(IETMP(K)/10),(ITTMP(K)/10)
  365.              ENDIF
  366.            ENDDO
  367.            SEGSUP,MLENTI,MLENT1
  368.  
  369. c    --- pas de tri : boucle sur tous les operateurs ---
  370.          ELSE
  371.            DO J=1,ILON
  372.              IF (IAPCUM(J) .NE. 0) THEN
  373.              WRITE(IOIMP,41)MDIR(J),IATMP(J),(IETMP(J)/10),(ITTMP(J)/10)
  374.              ENDIF
  375.            ENDDO
  376.          ENDIF
  377.  41      FORMAT(2X,A4,3(3X,I12))
  378.  
  379.  
  380. C******  option 'IMPR' seule ******
  381.         ELSE
  382.  
  383. c        Eventuelle option de restriction : APPE, HORL, CPU ou EFFI
  384.          I4=0
  385.          CALL LIRMOT(MOT4,4,I4,0)
  386.  
  387.          IF(I4.EQ.0.OR.I4.EQ.2) THEN
  388.          WRITE(IOIMP,*)
  389.          IF (LANGUE .EQ. 'FRAN') THEN
  390.            MOTERR(1:18)='Temps Horloge (ms)'
  391.          ELSE
  392.            MOTERR(1:18)='Elapsed Time  (ms)'
  393.          ENDIF
  394.          CALL ERREUR(-258)
  395.          DO J=1,ILON
  396.            IF (IAPCUM(J) .NE. 0) THEN
  397. C            Ecriture a l'ecran des Temps Elapsed
  398.              WRITE(IOIMP,31)MDIR(J),(IELAPS(J,II) / 10,II=1,NBESCR+1)
  399.  31          FORMAT(2X,A4,65(2X,I11))
  400.            ENDIF
  401.          ENDDO
  402.          ENDIF
  403.  
  404.          IF(I4.EQ.0.OR.I4.EQ.3) THEN
  405.          WRITE(IOIMP,*)
  406.          IF (LANGUE .EQ. 'FRAN') THEN
  407.            MOTERR(1:18)='Temps CPU     (ms)'
  408.          ELSE
  409.            MOTERR(1:18)='CPU Time      (ms)'
  410.          ENDIF
  411.          CALL ERREUR(-258)
  412.          DO J=1,ILON
  413.            IF (IAPCUM(J) .NE. 0) THEN
  414. C            Ecriture a l'ecran des Temps CPU
  415.              WRITE(IOIMP,32)MDIR(J),((ITCPU(J,II) / 10),II=1,NBESCR+1)
  416.  32          FORMAT(2X,A4,65(2X,I11))
  417.            ENDIF
  418.          ENDDO
  419.          ENDIF
  420.  
  421.          IF(I4.EQ.0.OR.I4.EQ.1) THEN
  422.          WRITE(IOIMP,*)
  423.          IF (LANGUE .EQ. 'FRAN') THEN
  424.            MOTERR(1:18)='Nombre appels     '
  425.          ELSE
  426.            MOTERR(1:18)='Number of Calls   '
  427.          ENDIF
  428.          CALL ERREUR(-258)
  429.          DO J=1,ILON
  430.            IF (IAPCUM(J) .NE. 0) THEN
  431. C            Ecriture a l'ecran des nombres d'appels
  432.              WRITE(IOIMP,33)MDIR(J),(IAPPEL(J,II),II=1,NBESCR+1)
  433.  33          FORMAT(2X,A4,65(2X,I11))
  434.            ENDIF
  435.          ENDDO
  436.          ENDIF
  437.  
  438.          IF(I4.EQ.0.OR.I4.EQ.4) THEN
  439.          WRITE(IOIMP,*)
  440.          IF (LANGUE .EQ. 'FRAN') THEN
  441.            MOTERR(1:18)='Efficacite        '
  442.          ELSE
  443.            MOTERR(1:18)='Efficiency        '
  444.          ENDIF
  445.          CALL ERREUR(-258)
  446.          DO J=1,ILON
  447.            IF (IAPCUM(J) .NE. 0) THEN
  448. C            Ecriture a l'ecran des efficacite
  449.              WRITE(IOIMP,34)MDIR(J),
  450.      &           (REAL(ITCPU(J,II)) / MAX(1,IELAPS(J,II)),II=1,NBESCR+1)
  451.  34          FORMAT(2X,A4,65(7X,F6.4))
  452.            ENDIF
  453.          ENDDO
  454.          ENDIF
  455.  
  456.         ENDIF
  457.  
  458.         WRITE(IOIMP,*)
  459.         CALL ERREUR(-378)
  460.  
  461.  
  462. ************************************************************************
  463. C  option 'ZERO'
  464. ************************************************************************
  465.  
  466.       ELSEIF(I.EQ.4) THEN
  467.         ITABS0 = ittime(1) + ittime(2)
  468.         ITCPU0 = 0
  469.         DO 4 J=1,ILON
  470.           NACT(1,J) = 0
  471.           NACT(2,J) = 0
  472.  
  473.           DO II=1,NBESCR+1
  474.             IAPPEL(J,II) = 0
  475.             IELAPS(J,II) = 0
  476.             ITCPU (J,II) = 0
  477.           ENDDO
  478.     4   CONTINUE
  479.  
  480.  
  481. ************************************************************************
  482. C  option 'SGAC'
  483. ************************************************************************
  484.  
  485.       ELSEIF(I.EQ.5) THEN
  486. C     on ecrit le nombre de segments actifs et leur taille
  487.  
  488.         CALL LIRMOT(MOT,5,J,0)
  489.         GOTO (11,12,12,13,12,12),(J+1)
  490. C  il n'y a pas d'autre options on renvoie nbre et taille des segments actifs
  491.   11    NBACTI = OOOVAL(2,3)
  492.         NTACTI = OOOVAL(3,3)
  493.         CALL ECRENT(NBACTI)
  494.         CALL ECRENT(NTACTI)
  495.         SEGSUP,ITRAV1
  496.         RETURN
  497.  
  498. C il y a d'autres options on renvoie nbre et taille des segments actifs
  499.   12    CALL REFUS
  500.         NBACTI = OOOVAL(2,3)
  501.         NTACTI = OOOVAL(3,3)
  502.         CALL ECRENT(NTACTI)
  503.         CALL ECRENT(NBACTI)
  504.         GOTO 1
  505. C option SGAC IMPR statistiques relatives aux segments actifs
  506.   13    WRITE(IOIMP,*)
  507.         CALL ERREUR(-308)
  508.  
  509.         DO 15 J =1,ILON
  510.           IF (IAPCUM(J) .NE. 0) THEN
  511.             NACTI = NACT(1,J)
  512.             NTACT = NACT(2,J) / 1000
  513.             WRITE(IOIMP,14)MDIR(J),IAPCUM(J),NACTI,NTACT
  514.   14        FORMAT(2X,A4,7X,I6,7X,I6,7X,I6)
  515.           ENDIF
  516.   15    CONTINUE
  517.       ENDIF
  518.  
  519. C  on retourne lire d'autres options
  520.       GOTO 1
  521.       END
  522.  
  523.  
  524.  
  525.  
  526.  
  527.  
  528.  
  529.  

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