[u/mrichter/AliRoot.git] / MINICERN / packlib / zebra / mqg / mzfgap.F

*
* $Id$
*
* $Log$
* Revision 1.2  1996/04/18 16:12:30  mclareni
* Incorporate changes from J.Zoll for version 3.77
*
* Revision 1.1.1.1  1996/03/06 10:47:20  mclareni
* Zebra
*
*
#include "zebra/pilot.h"
      SUBROUTINE MZFGAP

C-    Find the 4 largest gaps,
C-    gaps 3 + 4 may be inside the moving memory region
C-                   defined by JQSTMV,JQDVM1+2,NQDVMV
C-    gaps 1 + 2 must be outside the moving memory region

C-    Entry 'J' in the table contains :
C-      IQGAP(1,J) = number of words available
C-      IQGAP(2,J) = abs. zebra adr of first word in the gap
C-      IQGAP(3,J) = division number
C-      IQGAP(4,J) = store number
C-      IQGAP(5,J)   user flag

C-    Original meaning of JQSTMV,JQDVM1,JQDVM2,NQDVMV (cf. MZTABS):
C-    unless JQSTMV<0, the divisions JQDVM1 to JQDVM2 inclusive
C-    of the store JQSTMV may have to be shifted by NQDVMV words,
C-    to the left if -ve, to the right if +ve.
C-    NQDVMV=0 means to the left by a yet unknown amount.
C-    It follows that the gaps after divisions JDIV are not available
C-    for the relocation table because they may be over-written
C-    by the memory move, with :
C-       NQDVMV  0, -ve :  JDIV = <JQDVM1-1,JQDVM2-1>
C-                  +ve :  JDIV = <JQDVM1,  JQDVM2  >

C-    MZFGAP is also used for I/O to find a gap where to put the
C-    relocation table on input. In this case there is just one
C-    gap unavailable, namely the one which will receive the data.
C-    This is the gap before a reverse division (JQMODE=1) or after
C-    a forward division (JQMODE=0). To block this gap one can give
C-    JQDVM1=JQDVM2=JDIV and NQDVMV=1-2*JQMODE, setting JQSTMV also.

#include "zebra/zstate.inc"
#include "zebra/zunit.inc"
#include "zebra/mqsys.inc"
#include "zebra/mzct.inc"
C--------------    End CDE                             --------------
      DIMENSION    NGAPV(7), JDIVV(7), JSTOV(7), JPV(7)
      EQUIVALENCE (NGAPV(1),IQUEST(11)), (JDIVV(1),IQUEST(21))
      EQUIVALENCE (JSTOV(1),IQUEST(31)), (JPV(1),  IQUEST(41))
      DIMENSION    NQGAPV(2)
      EQUIVALENCE (NQGAPV(1),NQGAPN)


      CALL VZERO (IQGAP,20)

   15 DO 17  J=1,6
   17 NGAPV(J) = 0

      IF (JQSTMV.LT.0)             GO TO 19
      KT     = NQOFFT(JQSTMV+1)
      JDVSH1 = JQDVM1
      JDVSH2 = JQDVM2
      IF (NQDVMV.GT.0)             GO TO 19
      IF (JDVSH1.EQ.IQTABV(KT+9))  JDVSH1=IQTABV(KT+8)+1
      JDVSH1 = JDVSH1 - 1
      JDVSH2 = JDVSH2 - 1
   19 MINGN  = 0
      MINGV  = 0
      JMINGN = 1
      JMINGV = 5

C------            Loop all stores

      JSTO = -1
   21 JSTO = JSTO + 1
      IF (JSTO.GT.NQSTOR)          GO TO 61
      IF (NQALLO(JSTO+1).LT.0)     GO TO 21

      KT   = NQOFFT(JSTO+1)
      JDVN = 1

C----              Loop all divisions

   31 JDIV = JDVN
      IF (JDIV.EQ.21)              GO TO 21
      JDVN = JDIV + 1
      IF (JDIV.EQ.IQTABV(KT+8))  JDVN=IQTABV(KT+9)

      NWGAP = LQSTA(KT+JDVN) - LQEND(KT+JDIV)
      IF (NWGAP.LT.164)            GO TO 31
      IF (JSTO.NE.JQSTMV)          GO TO 41
      IF (JDIV.LT.JDVSH1)          GO TO 41
      IF (JDIV.GT.JDVSH2)          GO TO 41

C--                Gap in moving region

      IF (NWGAP.LE.MINGV)          GO TO 31
      NGAPV(JMINGV) = NWGAP
      JDIVV(JMINGV) = JDIV
      JSTOV(JMINGV) = JSTO
      JMINGV = 5
      MINGV  = NGAPV(5)
      IF (MINGV.LE.NGAPV(6))       GO TO 31
      JMINGV = 6
      MINGV  = NGAPV(6)
      GO TO 31

C--                Gap in non-moving region

   41 IF (NWGAP.LE.MINGN)          GO TO 31
      NGAPV(JMINGN) = NWGAP
      JDIVV(JMINGN) = JDIV
      JSTOV(JMINGN) = JSTO
      JMINGN = 1
      MINGN  = NGAPV(1)
      DO 44  J=2,4
      IF (MINGN.LE.NGAPV(J))       GO TO 44
      JMINGN = J
      MINGN  = NGAPV(J)
   44 CONTINUE
      GO TO 31

C-------           Store the result

   61 DO 62  J=1,6
   62 JPV(J) = J

C--                Sort non-moving gaps

      JG = 1
   65 JF = JPV(JG)
      JN = JPV(JG+1)
      IF (NGAPV(JF).LT.NGAPV(JN))  GO TO 67
      IF (JG.EQ.3)                 GO TO 71
   66 JG = JG + 1
      GO TO 65

   67 JPV(JG)   = JN
      JPV(JG+1) = JF
      IF (JG.EQ.1)                 GO TO 66
      JG = JG - 1
      GO TO 65

C--                Sort moving gaps

   71 JG = 4
   75 JF = JPV(JG)
      JN = JPV(JG+1)
      IF (NGAPV(JF).LT.NGAPV(JN))  GO TO 77
      IF (JG.EQ.5)                 GO TO 81
   76 JG = JG + 1
      GO TO 75

   77 JPV(JG)   = JN
      JPV(JG+1) = JF
      IF (JG.EQ.3)                 GO TO 76
      JG = JG - 1
      GO TO 75

C--                Store 4 biggest gaps

   81 NQGAPN = 0
      NQGAP  = 0
      JSEL   = 1
      DO 87  JG=1,4
      JU   = JPV(JG)
      NWGAP= NGAPV(JU)
      IF (NWGAP.EQ.0)              GO TO 87
      JDIV = JDIVV(JU)
      JSTO = JSTOV(JU)
      KT   = NQOFFT(JSTO+1)
      KS   = NQOFFS(JSTO+1)
      IQGAP(1,JG) = NWGAP
      IQGAP(2,JG) = KS+ LQEND(KT+JDIV)
      IQGAP(3,JG) = JDIV
      IQGAP(4,JG) = JSTO
      IF (JU.GE.5)  JSEL=2
      NQGAPV(JSEL) = JG
   87 CONTINUE
      NQGAP = MAX (NQGAPN,NQGAP)
#if defined(CERNLIB_QDEVZE)
      IF (NQDEVZ.GE.11)
     +WRITE (IQLOG,9888) NQGAPV,(JG,(IQGAP(J,JG),J=1,5),JG=1,NQGAP)
 9888 FORMAT (1X/' DEVZE MZFGAP,  NQGAPN,NQGAP=',2I4
     F/16X,' JGAP    SIZE     LOC JDIV JSTO USED'
     F/(16X,I4,2I8,3I5))
#endif
      RETURN
      END
*      ==================================================
#include "zebra/qcardl.inc"
Commit	Line	Data
fe4da5cc	1	*
	2	* $Id$
	3	*
	4	* $Log$
	5	* Revision 1.2 1996/04/18 16:12:30 mclareni
	6	* Incorporate changes from J.Zoll for version 3.77
	7	*
	8	* Revision 1.1.1.1 1996/03/06 10:47:20 mclareni
	9	* Zebra
	10	*
	11	*
	12	#include "zebra/pilot.h"
	13	SUBROUTINE MZFGAP
	14
	15	C- Find the 4 largest gaps,
	16	C- gaps 3 + 4 may be inside the moving memory region
	17	C- defined by JQSTMV,JQDVM1+2,NQDVMV
	18	C- gaps 1 + 2 must be outside the moving memory region
	19
	20	C- Entry 'J' in the table contains :
	21	C- IQGAP(1,J) = number of words available
	22	C- IQGAP(2,J) = abs. zebra adr of first word in the gap
	23	C- IQGAP(3,J) = division number
	24	C- IQGAP(4,J) = store number
	25	C- IQGAP(5,J) user flag
	26
	27	C- Original meaning of JQSTMV,JQDVM1,JQDVM2,NQDVMV (cf. MZTABS):
	28	C- unless JQSTMV<0, the divisions JQDVM1 to JQDVM2 inclusive
	29	C- of the store JQSTMV may have to be shifted by NQDVMV words,
	30	C- to the left if -ve, to the right if +ve.
	31	C- NQDVMV=0 means to the left by a yet unknown amount.
	32	C- It follows that the gaps after divisions JDIV are not available
	33	C- for the relocation table because they may be over-written
	34	C- by the memory move, with :
	35	C- NQDVMV 0, -ve : JDIV = <JQDVM1-1,JQDVM2-1>
	36	C- +ve : JDIV = <JQDVM1, JQDVM2 >
	37
	38	C- MZFGAP is also used for I/O to find a gap where to put the
	39	C- relocation table on input. In this case there is just one
	40	C- gap unavailable, namely the one which will receive the data.
	41	C- This is the gap before a reverse division (JQMODE=1) or after
	42	C- a forward division (JQMODE=0). To block this gap one can give
	43	C- JQDVM1=JQDVM2=JDIV and NQDVMV=1-2*JQMODE, setting JQSTMV also.
	44
	45	#include "zebra/zstate.inc"
	46	#include "zebra/zunit.inc"
	47	#include "zebra/mqsys.inc"
	48	#include "zebra/mzct.inc"
	49	C-------------- End CDE --------------
	50	DIMENSION NGAPV(7), JDIVV(7), JSTOV(7), JPV(7)
	51	EQUIVALENCE (NGAPV(1),IQUEST(11)), (JDIVV(1),IQUEST(21))
	52	EQUIVALENCE (JSTOV(1),IQUEST(31)), (JPV(1), IQUEST(41))
	53	DIMENSION NQGAPV(2)
	54	EQUIVALENCE (NQGAPV(1),NQGAPN)
	55
	56
	57	CALL VZERO (IQGAP,20)
	58
	59	15 DO 17 J=1,6
	60	17 NGAPV(J) = 0
	61
	62	IF (JQSTMV.LT.0) GO TO 19
	63	KT = NQOFFT(JQSTMV+1)
	64	JDVSH1 = JQDVM1
65	JDVSH2 = JQDVM2
66	IF (NQDVMV.GT.0) GO TO 19
67	IF (JDVSH1.EQ.IQTABV(KT+9)) JDVSH1=IQTABV(KT+8)+1
68	JDVSH1 = JDVSH1 - 1
69	JDVSH2 = JDVSH2 - 1
70	19 MINGN = 0
71	MINGV = 0
72	JMINGN = 1
73	JMINGV = 5
74
75	C------ Loop all stores
76
77	JSTO = -1
78	21 JSTO = JSTO + 1
79	IF (JSTO.GT.NQSTOR) GO TO 61
80	IF (NQALLO(JSTO+1).LT.0) GO TO 21
81
82	KT = NQOFFT(JSTO+1)
83	JDVN = 1
84
85	C---- Loop all divisions
86
87	31 JDIV = JDVN
88	IF (JDIV.EQ.21) GO TO 21
89	JDVN = JDIV + 1
90	IF (JDIV.EQ.IQTABV(KT+8)) JDVN=IQTABV(KT+9)
91
92	NWGAP = LQSTA(KT+JDVN) - LQEND(KT+JDIV)
93	IF (NWGAP.LT.164) GO TO 31
94	IF (JSTO.NE.JQSTMV) GO TO 41
95	IF (JDIV.LT.JDVSH1) GO TO 41
96	IF (JDIV.GT.JDVSH2) GO TO 41
97
98	C-- Gap in moving region
99
100	IF (NWGAP.LE.MINGV) GO TO 31
101	NGAPV(JMINGV) = NWGAP
102	JDIVV(JMINGV) = JDIV
103	JSTOV(JMINGV) = JSTO
104	JMINGV = 5
105	MINGV = NGAPV(5)
106	IF (MINGV.LE.NGAPV(6)) GO TO 31
107	JMINGV = 6
108	MINGV = NGAPV(6)
109	GO TO 31
110
111	C-- Gap in non-moving region
112
113	41 IF (NWGAP.LE.MINGN) GO TO 31
114	NGAPV(JMINGN) = NWGAP
115	JDIVV(JMINGN) = JDIV
116	JSTOV(JMINGN) = JSTO
117	JMINGN = 1
118	MINGN = NGAPV(1)
119	DO 44 J=2,4
120	IF (MINGN.LE.NGAPV(J)) GO TO 44
121	JMINGN = J
122	MINGN = NGAPV(J)
123	44 CONTINUE
124	GO TO 31
125
126	C------- Store the result
127
128	61 DO 62 J=1,6
129	62 JPV(J) = J
130
131	C-- Sort non-moving gaps
132
133	JG = 1
134	65 JF = JPV(JG)
135	JN = JPV(JG+1)
136	IF (NGAPV(JF).LT.NGAPV(JN)) GO TO 67
137	IF (JG.EQ.3) GO TO 71
138	66 JG = JG + 1
139	GO TO 65
140
141	67 JPV(JG) = JN
142	JPV(JG+1) = JF
143	IF (JG.EQ.1) GO TO 66
144	JG = JG - 1
145	GO TO 65
146
147	C-- Sort moving gaps
148
149	71 JG = 4
150	75 JF = JPV(JG)
151	JN = JPV(JG+1)
152	IF (NGAPV(JF).LT.NGAPV(JN)) GO TO 77
153	IF (JG.EQ.5) GO TO 81
154	76 JG = JG + 1
155	GO TO 75
156
157	77 JPV(JG) = JN
158	JPV(JG+1) = JF
159	IF (JG.EQ.3) GO TO 76
160	JG = JG - 1
161	GO TO 75
162
163	C-- Store 4 biggest gaps
164
165	81 NQGAPN = 0
166	NQGAP = 0
167	JSEL = 1
168	DO 87 JG=1,4
169	JU = JPV(JG)
170	NWGAP= NGAPV(JU)
171	IF (NWGAP.EQ.0) GO TO 87
172	JDIV = JDIVV(JU)
173	JSTO = JSTOV(JU)
174	KT = NQOFFT(JSTO+1)
175	KS = NQOFFS(JSTO+1)
176	IQGAP(1,JG) = NWGAP
177	IQGAP(2,JG) = KS+ LQEND(KT+JDIV)
178	IQGAP(3,JG) = JDIV
179	IQGAP(4,JG) = JSTO
180	IF (JU.GE.5) JSEL=2
181	NQGAPV(JSEL) = JG
182	87 CONTINUE
183	NQGAP = MAX (NQGAPN,NQGAP)
184	#if defined(CERNLIB_QDEVZE)
185	IF (NQDEVZ.GE.11)
186	+WRITE (IQLOG,9888) NQGAPV,(JG,(IQGAP(J,JG),J=1,5),JG=1,NQGAP)
187	9888 FORMAT (1X/' DEVZE MZFGAP, NQGAPN,NQGAP=',2I4
188	F/16X,' JGAP SIZE LOC JDIV JSTO USED'
189	F/(16X,I4,2I8,3I5))
190	#endif
191	RETURN
192	END
193	* ==================================================
194	#include "zebra/qcardl.inc"