Télécharger la plaquette Cast3M


fr en

Télécharger IOOPEM.INC

Retour à la liste

Numérotation des lignes : 

  1. C*
  2. C* COMMON DE POINTAGE, CONTIENT LES INFOS PERSONNELLES ET LES POINTEURS 
  3. C* SUR LES SEGMENTS DE BASE
  4. C*
  5.       PARAMETER(MAXFRAGSIZE=100000)
  6.       INTEGER DEBUG
  7.       COMMON /OOOCO2/ MYNUM,DEBUG,MYPID,MYTID,
  8.      1                MZPCL,MZPAC,MZPCP,MZPEV,MZPLO,
  9.      2                NPSEG,LISRC,MSGTAG,NMACH,MMACH,IPQPOS
  10. C
  11. C                           ---------                                      
  12. C                          I CLIENTS I                                     
  13. C                           ---------                                      
  14. C                                                                               
  15. C* LE SEGMENT DES CLIENTS PERMET DE STOCKER LES
  16. C* INFORMATIONS DE BASE POUR LA GESTION DES CLIENTS.
  17. C*
  18. C* LES MOTS D'UN SEGMENT SONT L'ID DE LA TACHE, L'ID DE SON SERVEUR,
  19. C* L'ETAT DE LA TACHE, LE SLOT DANS LEQUEL CETTE TACHE DEPOSE SES REQUETES 
  20. C* ET LIT SES REPONSES
  21. C*
  22. C* SCHEMA D'UN DESCRIPTEUR DE CLIENT.
  23. C*
  24. C* +--------+--------+--------+--------+--------+--------+--------+--------+
  25. C* | TASKID | SERVER | STATUS | <--------TSLOT---------> |  NEXT  |  PREV  | 
  26. C* +--------+--------+--------+--------+--------+--------+--------+--------+
  27. C*      0        1        2        3    ...............      70       71
  28. C*
  29. C*
  30. C* TASKID EST LE NUMERO DE TACHE AU SENS PVM, LES CLIENTS SONT NUMEROTES
  31. C* SEQUENTIELLEMENT A PARTIR DE 1. LES CLIENTS EN ATTENTE SUR UN SEGMENT SONT
  32. C* CHAINES ENTRE EUX, LA TETE DE CHAINE ETANT LE MOT MDQCL DU DESCRIPTEUR
  33. C* DU SEGMENT CONSIDERE.
  34. C*
  35.       SEGMENT , CLIENTS
  36.          INTEGER CLISLOCKED(NCL)
  37.          INTEGER CLLOCKEDBY(NCL)
  38.          REAL*8  CLVLOCK(NCL)
  39.          INTEGER CLPID(NCL)
  40.          INTEGER CLTID(NCL)
  41.          INTEGER CLHOST(NCL)
  42.          INTEGER CLSTATUS(NCL)
  43.          INTEGER CLCACHE(NCL)
  44.          INTEGER RQOPER(NCL)
  45.          INTEGER RQLRET(NCL)
  46.          INTEGER RQPSEG(NCL)
  47.          INTEGER RQKOD(NCL)
  48.          INTEGER RQVERS(NCL)
  49.          INTEGER RQNACC(NCL)
  50.          INTEGER RQNACT(NCL)
  51.          INTEGER RQWORK(65,NCL)
  52.          POINTEUR CLNEXT(NCL).CLIENTS
  53.          POINTEUR CLPREV(NCL).CLIENTS
  54.       ENDSEGMENT
  55.       POINTEUR CL1.CLIENTS,CL2.CLIENTS,CLX.CLIENTS
  56. C*
  57. C* CACHE DU SEGMENT DES DESCRIPTEURS
  58. C* C'EST ICI QUE CHAQUE TACHE LOGGUE SES ACCES A SES SEGMENTS
  59. C* LORSQU'UNE TACHE DECIDE D'AIDER UN SERVEUR EN DIFFICULTE,
  60. C* LES SEGMENTS DONT LA DESACTIVATION EST ATTENDUE SONT CHAINES
  61. C* ENTRE EUX PAR LE SERVEUR LUI-MEME.
  62. C* LE SEGMENT 1 SERT DE TETE DE CHAINE A CE TYPE DE SEGMENTS.
  63. C*
  64.       SEGMENT , CACHE
  65.         INTEGER CSTAT(NSGC)
  66.         INTEGER CNACC(NSGC)
  67.         INTEGER CNACT(NSGC)
  68.         INTEGER CNEXT(NSGC)
  69.         INTEGER CPREV(NSGC)
  70.       ENDSEGMENT
  71. C*
  72. C* MACROS D'ACCES AUX CHAMPS DE L'ETAT DU SEGMENT
  73. C*
  74.       MACRO , MCVERS(ID)
  75.       MCVERS = (CSTAT(((ID)-MDIDX0)/MDLDE)/512)
  76.       PSEUDO , MAVERS
  77.       CSTAT(((ID)-MDIDX0)/MDLDE) =
  78.      2MOD(CSTAT(((ID)-MDIDX0)/MDLDE),512)+(MAVERS)*512
  79.       ENDMACRO
  80.  
  81.       MACRO , MCSTAT(ID)
  82.       MCSTAT=MOD(CSTAT(((ID)-MDIDX0)/MDLDE),256)
  83.       PSEUDO , LESTAT
  84.       CSTAT(((ID)-MDIDX0)/MDLDE) = 
  85.      1(CSTAT(((ID)-MDIDX0)/MDLDE)/256)*256+(LESTAT)
  86.       ENDMACRO 
  87.  
  88.       MACRO , MCDES(ID)
  89.       MCDES=(MOD(CSTAT(((ID)-MDIDX0)/MDLDE),512)/256)
  90.       PSEUDO , LEDES
  91.       CSTAT(((ID)-MDIDX0)/MDLDE) = 
  92.      1(CSTAT(((ID)-MDIDX0)/MDLDE)/512)*512+(LEDES)*256+
  93.      2MOD(CSTAT(((ID)-MDIDX0)/MDLDE),256)
  94.       ENDMACRO
  95.  
  96.       MACRO , MCNACC(ID)
  97.       MCNACC = (CNACC(((ID)-MDIDX0)/MDLDE))
  98.       PSEUDO , MANACC
  99.       CNACC(((ID)-MDIDX0)/MDLDE) = (MANACC)
  100.       ENDMACRO
  101.  
  102.       MACRO , MCNACT(ID)
  103.       MCNACT = (CNACT(((ID)-MDIDX0)/MDLDE))
  104.       PSEUDO , MANACT
  105.       CNACT(((ID)-MDIDX0)/MDLDE) = (MANACT)
  106.       ENDMACRO
  107. C*
  108. C* CHAINAGE DES SEGMENTS
  109. C*
  110. C* METTRE UN SEGMENT DANS LA CHAINE DES SEGMENTS DONT LA DESACTIVATION
  111. C* EST ATTENDUE PAR LE SERVEUR.
  112. C*
  113.       MACRO , MCDDID0=1
  114.       MACRO , MCDDEM(ID)
  115.       IIID=((ID)-MDIDX0)/MDLDE
  116.       IF(CNEXT(IIID).EQ.0) THEN
  117.          IIITMP=CNEXT(MCDDID0)
  118.          CNEXT(MCDDID0)=IIID
  119.          CPREV(IIID)=MCDDID0
  120.          CNEXT(IIID)=IIITMP
  121.          CPREV(IIITMP)=IIID
  122.       ENDIF
  123.       ENDMACRO
  124. C*
  125. C* ENLEVER UN SEGMENT DE LA CHAINE DES SEGMENTS DONT LA DESACTIVATION
  126. C* EST DEMANDEE.
  127. C*
  128.       MACRO , MCDDRM(ID)
  129.       IIID=((ID)-MDIDX0)/MDLDE
  130.       IF(CNEXT(IIID).NE.0) THEN
  131.          IIIPRC=CPREV(IIID)
  132.          IIINXT=CNEXT(IIID)
  133.          CNEXT(IIIPRC)=IIINXT
  134.          CPREV(IIINXT)=IIIPRC
  135.          CNEXT(IIID)=0
  136.          CPREV(IIID)=0
  137.       ENDIF
  138.       ENDMACRO
  139. C*
  140. C* LISTE DES CODES OPERATION LOCAUX
  141. C*
  142.       MACRO ,( U2S_SEGSSG,U2S_SEGSTP,U2S_SEGINI,U2S_SEGACT,U2S_SEGDES,
  143.      1         U2S_SEGSUP,U2S_SEGADJ,U2S_SEGEXT,U2S_SEGETA,U2S_SEGVAL,
  144.      2         U2S_SEGDMP,U2S_SEGACC,U2S_SEGVPN,U2S_VERBOSE,U2S_PEORIG,
  145.      3         U2S_PEPOST,U2S_SEGXDS,U2S_SEGMRU,U2S_SEGLIS,U2S_FORK,
  146.      4         U2S_HELP  ,U2S_ALLOC ,U2S_PEWAIT,U2S_PETERM,
  147. C*)
  148. C*
  149. C* LISTE DES CODES OPERATION RESEAU
  150. C*    
  151. C*    MACRO ,( 
  152.      1         S2M_SEGINI      ,M2S_SEGINI     ,S2M_SEGININACK,
  153.      2         M2S_SEGININACK  ,M2S_SEGINIACK  ,M2S_SEGINIACK2,
  154.      3         M2S_SEGININACK2 ,S2S_SEGCNT     ,M2S_SEGACT,
  155.      4         S2S_SEGACTACK   ,S2S_SEGACTNACK ,S2M_SEGACT,
  156.      5         S2M_SEGACTACK   ,M2S_SEGACTACK  ,S2S_SEGACC,
  157.      6         M2S_SEGACC      ,S2S_SEGACCACK  ,S2S_SEGACCNACK,
  158.      7         S2M_SEGACC      ,S2M_SEGSUP     ,M2S_SEGSUPACK,
  159.      8         S2S_SEGDES      ,S2S_SEGDESACK  ,PEM_DOWN,
  160.      9         S2M_FORK        ,S2M_FORKACK    ,S2M_FORKNACK,
  161.      A         M2S_FORK        ,M2S_FORKACK    ,M2S_FORKNACK,
  162.      A         S2M_INSTALLACK  ,S2M_INSTALLNACK,S2S_INSTALLACK,
  163.      B         S2S_INSTALLNACK ,M2S_SEGACTNACK ,S2M_SEGACTNACK,
  164.      C         S2M_SEGINIACK   ,S2M_PEORIG     ,M2S_PEORIG,
  165.      D         S2M_PEPOST      ,M2S_PEPOST     ,S2M_PEWAIT,
  166.      E         M2S_PEWAIT      ,S2M_PETERM     ,M2S_PETERM)
  167. C*
  168. C* MACROS
  169. C*
  170. C*
  171. C* METTRE UN CLIENT EN ATTENTE SUR UN SEGMENT
  172. C*
  173.       MACRO , ATTEND (CL,PSEG)
  174.          IF(MDQCL(PSEG).EQ.0) THEN
  175.             MDQCL(PSEG)=CL
  176.             CLNEXT(CL)=CL
  177.             CLPREV(CL)=CL
  178.             RQWORK(65,CL)=RQOPER(CL)
  179.          ELSE
  180.             CLX=MDQCL(PSEG)
  181.             III=CLPREV(CLX)
  182.             CLNEXT(III)=CL
  183.             CLPREV(CL)=III
  184.             CLNEXT(CL)=CLX
  185.             CLPREV(CLX)=CL
  186.             RQWORK(65,CL)=RQOPER(CL)
  187.          ENDIF
  188.       ENDMACRO
  189. C*
  190. C* ENLEVER UN CLIENT DU SEGMENT PSEG
  191. C*
  192.       MACRO , MDCLRM(CL,PSEG)
  193.         III=MDQCL(PSEG)
  194.         IF(III.EQ.CL) THEN
  195.            IF(CLPREV(III).EQ.III.AND.CLNEXT(III).EQ.III) THEN
  196.               MDQCL(PSEG)=0
  197.            ELSE
  198.               CLPREV(CLNEXT(CL))=CLPREV(CL)
  199.               CLNEXT(CLPREV(CL))=CLNEXT(CL)
  200.               MDQCL(PSEG)=CLNEXT(CL)
  201.            ENDIF
  202.         ELSE
  203.            CLPREV(CLNEXT(CL))=CLPREV(CL)
  204.            CLNEXT(CLPREV(CL))=CLNEXT(CL)
  205.         ENDIF
  206.       ENDMACRO
  207. C
  208. C                           -------                                      
  209. C                          I ACCES I                                     
  210. C                           -------                                      
  211. C                                                                               
  212. C* LE SEGMENT DES ACCES PERMET DE STOCKER LES
  213. C* INFORMATIONS DE BASE POUR LA GESTION DES ACCES RO LOCAUX. ON SCRUTE
  214. C* LES ACCES LOCAUX ET LES COPIES DISTANTES AVANT DE PRENDRE DES 
  215. C* DECISIONS POUR LE TRAITEMENT DES REQUETES.
  216. C*
  217. C* LES CHAMPS D'UN SEGMENT ACCES SONT L'ID DE LA TACHE QUI ACCEDE LE SEGMENT,
  218. C* LE MODE D'ACCES ET DES POINTEURS AVANT ET ARRIERE 
  219. C* POUR LE CHAINAGE. LE SEGMENT 1 SERT DE TETE DE CHAINE POUR LES 
  220. C* ACCES LIBRES, LES DESCRIPTEURS ATTRIBUES SONT CHAINES SUR LE CHAMP 
  221. C* ACCES DU DESCRIPTEUR DU SEGMENT CONSIDERE.
  222. C*
  223.       SEGMENT , ACCES
  224.         INTEGER ACCLIENT(NAC)
  225.         INTEGER ACMODE(NAC)
  226.         POINTEUR ACNEXT(NAC).ACCES
  227.         POINTEUR ACPREV(NAC).ACCES
  228.       ENDSEGMENT
  229.       POINTEUR IA3.ACCES,IAX.ACCES
  230. C*
  231. C* SCHEMA D'UN SEGMENT ACCES LIBRE.  
  232. C*
  233. C* +--------+--------+--------+--------+
  234. C* |////////|////////|  NEXT  |  PREV  | 
  235. C* +--------+--------+--------+--------+
  236. C*      0        1        2        3
  237. C*
  238. C* SCHEMA D'UN SEGMENT ACCES ATTRIBUE.
  239. C*
  240. C* +--------+--------+--------+--------+
  241. C* | CLIENT |  MODE  |  NEXT  |  PREV  | 
  242. C* +--------+--------+--------+--------+
  243. C*      0        1        2        3
  244. C*
  245.       MACRO , (RO , RW )
  246. C*
  247. C* ZEROISATION
  248. C*
  249.       MACRO , MDACZERO(ID)
  250.         ACCLIENT(ID)=0
  251.         ACMODE(ID)=0
  252.         ACNEXT(ID)=0
  253.         ACPREV(ID)=0
  254.       ENDMACRO
  255. C*
  256. C* MANIPULATION DES CHAINES
  257. C*
  258. C*
  259. C* INTRODUIRE IA1 DANS LA CHAINE DEVANT IA2
  260. C*
  261.       MACRO , MDACCHN(IA1,IA2)
  262.         IA3=ACNEXT(IA2)
  263.         ACPREV(IA3)=IA1
  264.         ACNEXT(IA1)=IA3
  265.         ACPREV(IA1)=IA2
  266.         ACNEXT(IA2)=IA1
  267.       ENDMACRO
  268. C*
  269. C* RAJOUTER UN ACCES RO SUR PSEG PAR NUMCL
  270. C*
  271.       MACRO , ATTACHE (NUMCL,PSEG)
  272.          IA2=ACNEXT(1)
  273.          IA3=ACNEXT(IA2)
  274.          ACNEXT(1)=IA3
  275.          ACPREV(IA3)=1
  276.          ACCLIENT(IA2)=NUMCL
  277.          ACMODE(IA2)=RO
  278.          ACNEXT(IA2)=IA2
  279.          ACPREV(IA2)=IA2
  280.          IF(MDACCS(PSEG).EQ.0) THEN
  281.             MDACCS(PSEG)=IA2
  282.          ELSE
  283.             IA1=MDACCS(PSEG)
  284.             IA3=ACNEXT(IA1)
  285.             ACPREV(IA3)=IA2
  286.             ACNEXT(IA2)=IA3
  287.             ACPREV(IA2)=IA1
  288.             ACNEXT(IA1)=IA2
  289.          ENDIF
  290.       ENDMACRO
  291. C*
  292. C* ENLEVER IA1 DU SEGMENT PSEG
  293. C*
  294.       MACRO , MDACRM(IA1,PSEG)
  295.         IA2=MDACCS(PSEG)
  296.         IF(IA2.EQ.IA1) THEN
  297.            IF(ACPREV(IA2).EQ.IA2.AND.ACNEXT(IA2).EQ.IA2) THEN
  298.               MDACCS(PSEG)=0
  299.            ELSE
  300.               ACPREV(ACNEXT(IA1))=ACPREV(IA1)
  301.               ACNEXT(ACPREV(IA1))=ACNEXT(IA1)
  302.               MDACCS(PSEG)=ACNEXT(IA1)
  303.            ENDIF
  304.         ELSE
  305.            ACPREV(ACNEXT(IA1))=ACPREV(IA1)
  306.            ACNEXT(ACPREV(IA1))=ACNEXT(IA1)
  307.         ENDIF
  308.         IA3=ACNEXT(1)
  309.         ACPREV(IA3)=IA1
  310.         ACNEXT(IA1)=IA3
  311.         ACPREV(IA1)=1
  312.         ACNEXT(1)=IA1
  313.       ENDMACRO
  314. C
  315. C                           --------                                      
  316. C                          I COPIES I                                     
  317. C                           --------                                      
  318. C                                                                               
  319. C* LE SEGMENT DES COPIES PERMET DE STOCKER LES
  320. C* INFORMATIONS DE BASE POUR LA GESTION DES COPIES DE SEGMENTS. ON SCRUTE
  321. C* LES ACCES LOCAUX ET LES COPIES DISTANTES AVANT DE PRENDRE DES 
  322. C* DECISIONS POUR LE TRAITEMENT DES REQUETES. UNE COPIE EST CARACTERISEE
  323. C* PAR UN ETAT QUI PEUT ETRE VALIDE OU NON, UTILISEE OU NON
  324. C*
  325. C* LES MOTS D'UN SEGMENT SONT L'ID DU SERVEUR QUI EST EN COPIE DE CE 
  326. C* SEGMENT, L'ETAT DE LA COPIE ET DES POINTEURS 
  327. C* AVANT ET ARRIERE POUR LE CHAINAGE. LE SEGMENT 1 SERT DE TETE DE 
  328. C* CHAINE POUR LES COPIES LIBRES, LES COPIES ATTRIBUEES SONT 
  329. C* CHAINES SUR LE CHAMP COPIES DU DESCRIPTEUR DU SEGMENT CONSIDERE.
  330. C*
  331. C* SCHEMA D'UN SEGMENT COPIE LIBRE.  
  332. C*
  333. C* +--------+--------+--------+--------+
  334. C* |////////|////////|  NEXT  |  PREV  | 
  335. C* +--------+--------+--------+--------+
  336. C*      0        1        2        3 
  337. C*
  338. C* SCHEMA D'UN SEGMENT COPIE ATTRIBUE.
  339. C*
  340. C* +--------+--------+--------+--------+
  341. C* | SERVER |  MODE  |  NEXT  |  PREV  | 
  342. C* +--------+--------+--------+--------+
  343. C*      0        1        2        3
  344. C*
  345.       SEGMENT COPIES
  346.          INTEGER CPSERVER(NCP)
  347.          INTEGER CPMODE(NCP)
  348.          POINTEUR CPNEXT(NCP).COPIES
  349.          POINTEUR CPPREV(NCP).COPIES
  350.       ENDSEGMENT
  351.       POINTEUR IC3.COPIES,ICX.COPIES
  352. C*
  353. C* ZEROISATION
  354. C*
  355.       MACRO , MDCPZERO(ID)
  356.         CPSERVER(ID)=0
  357.         CPMODE(ID)=0
  358.         CPNEXT(ID)=0
  359.         CPPREV(ID)=0
  360.       ENDMACRO
  361. C*
  362. C* MANIPULATION DES CHAINES
  363. C*
  364. C*
  365. C* INTRODUIRE IC1 DANS LA CHAINE DEVANT IC2
  366. C*
  367.       MACRO , MDCPCHN(IC1,IC2)
  368.         IC3=CPPREV(IC2)
  369.         CPPREV(IC3)=IC1
  370.         CPNEXT(IC1)=IC3
  371.         CPPREV(IC1)=IC2
  372.         CPNEXT(IC2)=IC1
  373.       ENDMACRO
  374. C*
  375. C* RAJOUTER UNE COPIE DE PSEG PAR NUMCL
  376. C*
  377.       MACRO , ENCOPIE (NUMCL,PSEG)
  378.          IC2=CPNEXT(1)
  379.          IC3=CPNEXT(IC2)
  380.          CPNEXT(1)=IC3
  381.          CPPREV(IC3)=1
  382.          CPSERVER(IC2)=NUMCL
  383.          CPMODE(IC2)=RO
  384.          CPPREV(IC2)=IC2
  385.          CPNEXT(IC2)=IC2
  386.          IF(MDRCPY(PSEG).EQ.0) THEN
  387.             MDRCPY(PSEG)=IC2
  388.          ELSE
  389.             IC1=MDRCPY(PSEG)
  390.             IC3=CPNEXT(IC1)
  391.             CPPREV(IC3)=IC2
  392.             CPNEXT(IC2)=IC3
  393.             CPPREV(IC2)=IC1
  394.             CPNEXT(IC1)=IC2
  395.          ENDIF
  396.       ENDMACRO
  397. C*
  398. C* ENLEVER IC1 DU SEGMENT PSEG
  399. C*
  400.       MACRO , MDCPRM(IC1,PSEG)
  401.         IC2=MDRCPY(PSEG)
  402.         IF(IC2.EQ.IC1) THEN
  403.            IF(CPPREV(IC2).EQ.IC2.AND.CPNEXT(IC2).EQ.IC2) THEN
  404.               MDRCPY(PSEG)=0
  405.            ELSE
  406.               CPPREV(CPNEXT(IC1))=CPPREV(IC1)
  407.               CPNEXT(CPPREV(IC1))=CPNEXT(IC1)
  408.               MDRCPY(PSEG)=CPNEXT(IC1)
  409.            ENDIF
  410.         ELSE
  411.            CPPREV(CPNEXT(IC1))=CPPREV(IC1)
  412.            CPNEXT(CPPREV(IC1))=CPNEXT(IC1)
  413.         ENDIF
  414.         IC3=CPNEXT(1)
  415.         CPPREV(IC3)=IC1
  416.         CPNEXT(IC1)=IC3
  417.         CPPREV(IC1)=1
  418.         CPNEXT(1)=IC1
  419.       ENDMACRO
  420. C
  421. C                           -----------------------                       
  422. C                          I EVENEMENTS PARALLELES I                      
  423. C                           -----------------------                      
  424. C*
  425. C* LE SEGMENT DES EVENEMENTS PARALLELES EXISTE UNIQUEMENT CHEZ LE MAITRE
  426. C* IL SERT A STOCKER LES INFORMATIONS RELATIVES AU EVENEMENTS PARALLELES 
  427. C* CREES PAR LES DIFFERENTES TACHES.
  428. C*
  429.       SEGMENT LPEVENT
  430.         INTEGER PEID(NEV)
  431.       ENDSEGMENT
  432.       SEGMENT PEVENT
  433.         INTEGER OWNER
  434.         INTEGER DONE
  435.         INTEGER PCOUNT
  436.         INTEGER PREACH
  437.         INTEGER WCOUNT
  438.         INTEGER WREACH
  439.         INTEGER WCLNT(NWCL)
  440.         INTEGER UNIQUE
  441.       ENDSEGMENT
  442. C
  443. C                           -----------------------                       
  444. C                          I SEGMENT DES LOCKS     I                      
  445. C                           -----------------------                      
  446. C*
  447. C* LE SEGMENT DES LOCKS SERT A TENIR LES VERROUS SUR LES SEGMENTS. IL DEVRAIT
  448. C* ETRE FIXE EN MEMOIRE. LA TAILLE D'UN LOCK DEPEND DU SYSTEME. EN UTILISANT
  449. C* LES msemaphores DE AIX V4, CHAQUE LOCK PREND DEUX ENTIERS.
  450. C*
  451.       SEGMENT PLOCK
  452.         INTEGER ISLOCKED(NLO)
  453.         INTEGER LOCKEDBY(NLO)
  454.         REAL*8 VLOCK(NLO)
  455.       ENDSEGMENT
  456.  

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