cfac_sol_pool.F File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	cmumps_init_pool_last3 (ipool, lpool, leaf)
subroutine	cmumps_insert_pool_n (n, pool, lpool, procnode, slavef, keep199, k28, k76, k80, k47, step, inode)
logical function	cmumps_pool_empty (pool, lpool)
subroutine	cmumps_extract_pool (n, pool, lpool, procnode, slavef, step, inode, keep, keep8, myid, nd, force_extract_top_sbtr)
subroutine	cmumps_mem_cons_mng (inode, pool, lpool, n, step, keep, keep8, procnode, slavef, myid, sbtr, flag_same_proc, min_proc)
subroutine	cmumps_mem_node_select (inode, pool, lpool, n, step, keep, keep8, procnode, slavef, myid, sbtr_flag, proc_flag, min_proc)
subroutine	cmumps_get_inode_from_pool (ipool, lpool, iii, leaf, inode, strategie)

Function/Subroutine Documentation

cmumps_extract_pool()

subroutine cmumps_extract_pool	(	integer	n,
		integer, dimension(lpool)	pool,
		integer	lpool,
		integer, dimension(keep(28))	procnode,
		integer	slavef,
		integer, dimension(n)	step,
		integer	inode,
		integer, dimension(500)	keep,
		integer(8), dimension(150)	keep8,
		integer	myid,
		integer, dimension(keep(28))	nd,
		logical	force_extract_top_sbtr )

Definition at line 168 of file cfac_sol_pool.F.

      USE cmumps_load
      IMPLICIT NONE
      INTEGER INODE, LPOOL, SLAVEF, N
      INTEGER KEEP(500)
      INTEGER(8) KEEP8(150)
      INTEGER STEP(N), POOL(LPOOL), PROCNODE(KEEP(28)),
     &        ND(KEEP(28))
      EXTERNAL mumps_inssarbr, mumps_rootssarbr, cmumps_pool_empty
      LOGICAL MUMPS_INSSARBR, MUMPS_ROOTSSARBR, CMUMPS_POOL_EMPTY
      EXTERNAL mumps_procnode
      INTEGER MUMPS_PROCNODE
      INTEGER NBINSUBTREE, NBTOP, INSUBTREE, INODE_EFF, MYID
      LOGICAL LEFT, ATOMIC_SUBTREE,UPPER,FLAG_MEM,SBTR_FLAG,PROC_FLAG
      LOGICAL FORCE_EXTRACT_TOP_SBTR
      INTEGER NODE_TO_EXTRACT,I,J,MIN_PROC
      nbinsubtree = pool(lpool)
      nbtop       = pool(lpool - 1)
      insubtree   = pool(lpool - 2)
      IF ( keep(76) > 6 .OR. keep(76) < 0 ) THEN
         WRITE(*,*) "Error 2 in CMUMPS_EXTRACT_POOL: unknown strategy"
         CALL mumps_abort()
      ENDIF
      atomic_subtree =  ( keep(76) == 1 .OR. keep(76) == 3)
      IF ( cmumps_pool_empty(pool, lpool) ) THEN
         WRITE(*,*) "Error 1 in CMUMPS_EXTRACT_POOL"
         CALL mumps_abort()
      ENDIF
      IF ( .NOT. atomic_subtree ) THEN
         left = (nbtop == 0)
         IF(.NOT.left)THEN
            IF((keep(76).EQ.4).OR.(keep(76).EQ.5))THEN
               IF(nbinsubtree.EQ.0)THEN
                  left=.false.
               ELSE
                  IF ( pool(nbinsubtree) < 0 ) THEN
                     i = -pool(nbinsubtree)
                  ELSE IF ( pool(nbinsubtree) > n ) THEN
                     i = pool(nbinsubtree) - n
                  ELSE
                     i = pool(nbinsubtree)
                  ENDIF
                  IF ( pool(lpool-2-nbtop) < 0 ) THEN
                     j = -pool(lpool-2-nbtop)
                  ELSE IF ( pool(lpool-2-nbtop) > n ) THEN
                     j = pool(lpool-2-nbtop) - n
                  ELSE
                     j = pool(lpool-2-nbtop)
                  ENDIF
                  IF(keep(76).EQ.4)THEN
                     IF(depth_first_load(step(j)).GE.
     &                    depth_first_load(step(i)))THEN
                        left=.true.
                     ELSE
                        left=.false.
                     ENDIF
                  ENDIF
                  IF(keep(76).EQ.5)THEN
                     IF(cost_trav(step(j)).LE.
     &                    cost_trav(step(i)))THEN
                        left=.true.
                     ELSE
                        left=.false.
                     ENDIF
                  ENDIF
               ENDIF           
            ENDIF
         ENDIF
      ELSE
         IF ( insubtree == 1 ) THEN
            IF (nbinsubtree == 0) THEN
               WRITE(*,*) "error 3 in cmumps_extract_pool"
               CALL MUMPS_ABORT()
            ENDIF
            LEFT = .TRUE.
         ELSE
            LEFT = ( NBTOP == 0)
         ENDIF
      ENDIF
 222  CONTINUE
      IF ( LEFT ) THEN
         INODE = POOL( NBINSUBTREE )
.EQ.         IF(KEEP(81)2)THEN
.GE..AND..LE.            IF((INODE0)(INODEN))THEN
               CALL CMUMPS_MEM_NODE_SELECT(INODE,POOL,LPOOL,N,
     &              STEP,KEEP,KEEP8,PROCNODE,SLAVEF,MYID,SBTR_FLAG,
     &              PROC_FLAG,MIN_PROC)
.NOT.               IF(SBTR_FLAG)THEN
                  WRITE(*,*)MYID,': ca a change pour moi'
                  LEFT=.FALSE.
                  GOTO 222
               ENDIF
            ENDIF
.EQ.         ELSEIF(KEEP(81)3)THEN
.GE..AND..LE.            IF((INODE0)(INODEN))THEN
               NODE_TO_EXTRACT=INODE
               FLAG_MEM=.FALSE.
               CALL CMUMPS_LOAD_CHK_MEMCST_POOL(FLAG_MEM)
               IF(FLAG_MEM)THEN
                  CALL CMUMPS_MEM_NODE_SELECT(INODE,POOL,LPOOL,N,
     &                 STEP,KEEP,KEEP8,
     &                 PROCNODE,SLAVEF,MYID,SBTR_FLAG,
     &                 PROC_FLAG,MIN_PROC)
.NOT.                  IF(SBTR_FLAG)THEN
                     LEFT=.FALSE.
                     WRITE(*,*)MYID,': ca a change pour moi (2)'
                     GOTO 222
                  ENDIF
               ENDIF
            ENDIF
         ENDIF
         NBINSUBTREE = NBINSUBTREE - 1
         IF ( INODE < 0 ) THEN
            INODE_EFF = -INODE
         ELSE IF ( INODE > N ) THEN
            INODE_EFF = INODE - N
         ELSE
            INODE_EFF = INODE
         ENDIF
         IF ( MUMPS_INSSARBR( PROCNODE(STEP(INODE_EFF)),
     &                        KEEP(199)) ) THEN
.GE..AND..EQ..AND.            IF((KEEP(47)2KEEP(81)1)
.EQ.     &           (INSUBTREE0))THEN
               CALL CMUMPS_LOAD_SET_SBTR_MEM(.TRUE.)
            ENDIF
            INSUBTREE = 1
         ELSE IF ( MUMPS_ROOTSSARBR( PROCNODE(STEP(INODE_EFF)), 
     &           KEEP(199))) THEN
.GE..AND..EQ..AND.            IF((KEEP(47)2KEEP(81)1)
.EQ.     &           (INSUBTREE1))THEN
               CALL CMUMPS_LOAD_SET_SBTR_MEM(.FALSE.)
            ENDIF
            INSUBTREE = 0
         END IF
      ELSE
         IF (NBTOP < 1 ) THEN
            WRITE(*,*) "error 5 in cmumps_extract_pool", NBTOP
            CALL MUMPS_ABORT()
         ENDIF
         INODE = POOL( LPOOL - 2 - NBTOP )
.EQ.         IF(KEEP(81)1)THEN
            CALL CMUMPS_LOAD_POOL_CHECK_MEM
     &           (INODE,UPPER,SLAVEF,KEEP,KEEP8,
     &            STEP,POOL,LPOOL,PROCNODE,N)
            IF(UPPER)THEN
               GOTO 666
            ELSE
               NBINSUBTREE=NBINSUBTREE-1
               IF ( MUMPS_INSSARBR( PROCNODE(STEP(INODE)), 
     &              KEEP(199)) ) THEN
                  INSUBTREE = 1
               ELSE IF ( MUMPS_ROOTSSARBR( PROCNODE(STEP(INODE)), 
     &                 KEEP(199))) THEN
                  INSUBTREE = 0
               ENDIF
               GOTO 777
            ENDIF
         ENDIF
.EQ.         IF(KEEP(81)2)THEN
            CALL CMUMPS_MEM_NODE_SELECT(INODE,POOL,LPOOL,N,STEP,
     &           KEEP,KEEP8,
     &           PROCNODE,SLAVEF,MYID,SBTR_FLAG,PROC_FLAG,MIN_PROC)
            IF(SBTR_FLAG)THEN
               LEFT=.TRUE. 
               WRITE(*,*)MYID,': ca a change pour moi (3)'              
               GOTO 222
            ENDIF
         ELSE
.EQ.            IF(KEEP(81)3)THEN
.GE..AND..LE.               IF((INODE0)(INODEN))THEN
                  NODE_TO_EXTRACT=INODE
                  FLAG_MEM=.FALSE.
                  CALL CMUMPS_LOAD_CHK_MEMCST_POOL(FLAG_MEM)
                  IF(FLAG_MEM)THEN
                     CALL CMUMPS_MEM_NODE_SELECT(INODE,POOL,LPOOL,N,
     &                    STEP,KEEP,KEEP8,
     &                    PROCNODE,SLAVEF,MYID,SBTR_FLAG,
     &                    PROC_FLAG,MIN_PROC)
                     IF(SBTR_FLAG)THEN
                        LEFT=.TRUE.
                        WRITE(*,*)MYID,': ca a change pour moi (4)'
                        GOTO 222
                     ENDIF
                  ELSE
                     CALL CMUMPS_LOAD_CLEAN_MEMINFO_POOL(INODE)
                  ENDIF
               ENDIF
            ENDIF
         ENDIF
 666     CONTINUE
         NBTOP = NBTOP - 1
.GT..AND..LE.         IF((INODE0)(INODEN))THEN
.OR..AND.            IF ((( KEEP(80) == 2  KEEP(80)==3 ) 
     &           ( KEEP(47) == 4 ))) THEN
               CALL CMUMPS_REMOVE_NODE(INODE,2)
            ENDIF
         ENDIF
         IF ( INODE < 0 ) THEN
            INODE_EFF = -INODE
         ELSE IF ( INODE > N ) THEN
            INODE_EFF = INODE - N
         ELSE
            INODE_EFF = INODE
         ENDIF
      END IF
 777  CONTINUE
      POOL(LPOOL)     = NBINSUBTREE 
      POOL(LPOOL - 1) = NBTOP
      POOL(LPOOL - 2) = INSUBTREE
      RETURN

cmumps_get_inode_from_pool()

subroutine cmumps_get_inode_from_pool	(	integer, dimension (lpool)	ipool,
		integer, intent(in)	lpool,
		integer	iii,
		integer	leaf,
		integer, intent(out)	inode,
		integer, intent(in)	strategie )

Definition at line 514 of file cfac_sol_pool.F.

            IMPLICIT NONE
      INTEGER, INTENT(IN) :: STRATEGIE, LPOOL
      INTEGER IPOOL (LPOOL)
      INTEGER III,LEAF
      INTEGER, INTENT(OUT) :: INODE
         leaf  = leaf - 1
         inode = ipool( leaf )
      RETURN

cmumps_init_pool_last3()

subroutine cmumps_init_pool_last3	(	integer, dimension(lpool)	ipool,
		integer	lpool,
		integer	leaf )

Definition at line 14 of file cfac_sol_pool.F.

      USE cmumps_load
      IMPLICIT NONE
      INTEGER LPOOL, LEAF
      INTEGER IPOOL(LPOOL)
      ipool(lpool-2) = 0
      ipool(lpool-1) = 0
      ipool(lpool)   = leaf-1
      RETURN

cmumps_insert_pool_n()

subroutine cmumps_insert_pool_n	(	integer	n,
		integer, dimension(lpool)	pool,
		integer	lpool,
		integer, dimension(k28)	procnode,
		integer	slavef,
		integer	keep199,
		integer	k28,
		integer	k76,
		integer	k80,
		integer	k47,
		integer, dimension(n)	step,
		integer	inode )

Definition at line 24 of file cfac_sol_pool.F.

      USE cmumps_load
      IMPLICIT NONE
      INTEGER N, INODE, LPOOL, K28, SLAVEF, K76, K80, K47, KEEP199
      INTEGER STEP(N), POOL(LPOOL), PROCNODE(K28)
      EXTERNAL mumps_in_or_root_ssarbr
      LOGICAL MUMPS_IN_OR_ROOT_SSARBR, ATM_CURRENT_NODE
      INTEGER NBINSUBTREE, NBTOP, INODE_EFF,POS_TO_INSERT
      INTEGER IPOS1, IPOS2, ISWAP
      INTEGER NODE,J,I
      atm_current_node = ( k76 == 2 .OR. k76 ==3 .OR.
     &     k76==4 .OR. k76==5)
      nbinsubtree = pool(lpool)
      nbtop       = pool(lpool - 1)
      IF (inode > n ) THEN
        inode_eff = inode - n
      ELSE IF (inode < 0) THEN
        inode_eff = - inode
      ELSE
        inode_eff = inode
      ENDIF
      IF(((inode.GT.0).AND.(inode.LE.n)).AND.(.NOT.
     &     mumps_in_or_root_ssarbr(procnode(step(inode_eff)),
     &               keep199))
     &  ) THEN
         IF ((k80 == 1 .AND. k47 .GE. 1) .OR.
     &     (( k80 == 2 .OR. k80==3 ) .AND.
     &          ( k47 == 4 ))) THEN
            CALL cmumps_remove_node(inode,1)
         ENDIF
      ENDIF
      IF ( mumps_in_or_root_ssarbr(procnode(step(inode_eff)),
     &                             keep199) ) THEN
        pool(nbinsubtree + 1 ) = inode
        nbinsubtree = nbinsubtree + 1
      ELSE
         pos_to_insert=nbtop+1
         IF((k76.EQ.4).OR.(k76.EQ.5).OR.(k76.EQ.6))THEN
            IF((inode.GT.n).OR.(inode.LE.0))THEN
               DO j=nbtop,1,-1
                  IF((pool(lpool-2-j).GT.0)
     &                 .AND.(pool(lpool-2-j).LE.n))THEN
                     GOTO 333
                  ENDIF
                  IF ( pool(lpool-2-j) < 0 ) THEN
                     node=-pool(lpool-2-j)
                  ELSE IF ( pool(lpool-2-j) > n ) THEN
                     node = pool(lpool-2-j) - n
                  ELSE
                     node = pool(lpool-2-j)
                  ENDIF
                  IF((k76.EQ.4).OR.(k76.EQ.6))THEN
                     IF(depth_first_load(step(node)).GE.
     &                    depth_first_load(step(inode_eff)))THEN
                        GOTO 333
                     ENDIF
                  ENDIF
                  IF(k76.EQ.5)THEN
                     IF(cost_trav(step(node)).LE.
     &                    cost_trav(step(inode_eff)))THEN
                        GOTO 333
                     ENDIF
                  ENDIF
                  pos_to_insert=pos_to_insert-1
               ENDDO
               IF(j.EQ.0) j=1
 333           CONTINUE
               DO i=nbtop,pos_to_insert,-1
                  pool(lpool-2-i-1)=pool(lpool-2-i)
               ENDDO
               pool(lpool-2-pos_to_insert)=inode
               nbtop = nbtop + 1
               GOTO 20 
            ENDIF
            DO j=nbtop,1,-1
               IF((pool(lpool-2-j).GT.0).AND.(pool(lpool-2-j).LE.n))THEN
                  GOTO 888
               ENDIF
               pos_to_insert=pos_to_insert-1
            ENDDO
 888        CONTINUE
            DO i=j,1,-1
               node=pool(lpool-2-i)
               IF((k76.EQ.4).OR.(k76.EQ.6))THEN
                  IF(depth_first_load(step(node)).GE.
     &                 depth_first_load(step(inode_eff)))THEN
                     GOTO 999
                  ENDIF
               ENDIF
               IF(k76.EQ.5)THEN
                  IF(cost_trav(step(node)).LE.
     &                 cost_trav(step(inode_eff)))THEN
                     GOTO 999
                  ENDIF
               ENDIF
               pos_to_insert=pos_to_insert-1
            ENDDO
            IF(i.EQ.0) i=1
 999        CONTINUE
            DO j=nbtop,pos_to_insert,-1
               pool(lpool-2-j-1)=pool(lpool-2-j)
            ENDDO
            pool(lpool-2-pos_to_insert)=inode
            nbtop = nbtop + 1
            GOTO 20
         ENDIF
         pool( lpool - 2 - ( nbtop + 1 ) ) = inode
         nbtop = nbtop + 1
        ipos1 = lpool - 2 - nbtop
        ipos2 = lpool - 2 - nbtop + 1
 10     CONTINUE
        IF ( ipos2 == lpool - 2 ) GOTO 20
        IF ( pool(ipos1) < 0 ) GOTO 20
        IF ( pool(ipos2) < 0 ) GOTO 30
        IF ( atm_current_node ) THEN
          IF ( pool(ipos1) > n ) GOTO 20
          IF ( pool(ipos2) > n ) GOTO 30
        END IF
        GOTO 20
 30     CONTINUE
        iswap = pool(ipos1)
        pool(ipos1) = pool(ipos2)
        pool(ipos2) = iswap
        ipos1 = ipos1 + 1
        ipos2 = ipos2 + 1
        GOTO 10
 20     CONTINUE
      ENDIF
      pool(lpool) = nbinsubtree 
      pool(lpool - 1) = nbtop
      RETURN

cmumps_mem_cons_mng()

subroutine cmumps_mem_cons_mng	(	integer	inode,
		integer, dimension(lpool)	pool,
		integer	lpool,
		integer	n,
		integer, dimension(n)	step,
		integer, dimension(500)	keep,
		integer(8), dimension(150)	keep8,
		integer, dimension(keep(28))	procnode,
		integer	slavef,
		integer	myid,
		logical	sbtr,
		logical	flag_same_proc,
		integer	min_proc )

Definition at line 381 of file cfac_sol_pool.F.

      USE cmumps_load
      IMPLICIT NONE
      INTEGER INODE,LPOOL,N,MYID,SLAVEF,PROC,MIN_PROC
      INTEGER POOL(LPOOL),KEEP(500),STEP(N),PROCNODE(KEEP(28))
      INTEGER(8) KEEP8(150)
      INTEGER MUMPS_PROCNODE
      EXTERNAL mumps_procnode
      LOGICAL SBTR,FLAG_SAME_PROC
      INTEGER POS_TO_EXTRACT,NODE_TO_EXTRACT,NBTOP,I,INSUBTREE,
     &     NBINSUBTREE
      DOUBLE PRECISION MIN_COST, TMP_COST
      nbinsubtree = pool(lpool)
      nbtop       = pool(lpool - 1)
      insubtree   = pool(lpool - 2)
      min_cost=huge(min_cost) 
      tmp_cost=huge(tmp_cost)
      flag_same_proc=.false.
      sbtr=.false.
      min_proc=-9999
      IF((inode.GT.0).AND.(inode.LE.n))THEN
         pos_to_extract=-1
         node_to_extract=-1
         DO i=nbtop,1,-1
            IF(node_to_extract.LT.0)THEN
               pos_to_extract=i
               node_to_extract=pool(lpool-2-i)
               CALL cmumps_load_comp_maxmem_pool(node_to_extract,
     &                                       tmp_cost,proc)
               min_cost=tmp_cost
               min_proc=proc
            ELSE
               CALL cmumps_load_comp_maxmem_pool(pool(lpool-2-i),
     &                                       tmp_cost,proc)
               IF((proc.NE.min_proc).OR.(tmp_cost.NE.min_cost))THEN
                  flag_same_proc=.true.
               ENDIF
               IF(tmp_cost.GT.min_cost)THEN
                  pos_to_extract=i
                  node_to_extract=pool(lpool-2-i)
                  min_cost=tmp_cost
                  min_proc=proc
               ENDIF
            ENDIF
         ENDDO
         IF((keep(47).EQ.4).AND.(nbinsubtree.NE.0))THEN
            CALL cmumps_check_sbtr_cost(nbinsubtree,insubtree,nbtop,
     &           min_cost,sbtr)
            IF(sbtr)THEN
               WRITE(*,*)myid,': selecting from subtree'
               RETURN
            ENDIF
         ENDIF
         IF((.NOT.sbtr).AND.(.NOT.flag_same_proc))THEN
            WRITE(*,*)myid,': I must search for a task
     &           to save My friend'
            RETURN
         ENDIF
         inode = node_to_extract
         DO i=pos_to_extract,nbtop
            IF(i.NE.nbtop)THEN
               pool(lpool-2-i)=pool(lpool-2-i-1)
            ENDIF
         ENDDO
         pool(lpool-2-nbtop)=inode
         CALL cmumps_load_clean_meminfo_pool(inode)
      ELSE
      ENDIF

cmumps_mem_node_select()

subroutine cmumps_mem_node_select	(	integer	inode,
		integer, dimension(lpool)	pool,
		integer	lpool,
		integer	n,
		integer, dimension(n)	step,
		integer, dimension(500)	keep,
		integer(8), dimension(150)	keep8,
		integer, dimension(keep(28))	procnode,
		integer	slavef,
		integer	myid,
		logical	sbtr_flag,
		logical	proc_flag,
		integer	min_proc )

Definition at line 452 of file cfac_sol_pool.F.

      USE cmumps_load
      IMPLICIT NONE
      INTEGER INODE,LPOOL,N,SLAVEF,MYID,MIN_PROC
      INTEGER POOL(LPOOL),KEEP(500),PROCNODE(KEEP(28)),STEP(N)
      INTEGER(8) KEEP8(150)
      LOGICAL SBTR_FLAG,PROC_FLAG
      EXTERNAL mumps_inssarbr
      LOGICAL MUMPS_INSSARBR
      INTEGER NODE_TO_EXTRACT,I,POS_TO_EXTRACT,NBTOP,NBINSUBTREE
      nbtop= pool(lpool - 1)
      nbinsubtree = pool(lpool)
      IF(nbtop.GT.0)THEN
         WRITE(*,*)myid,': NBTOP=',nbtop
      ENDIF
      sbtr_flag=.false.
      proc_flag=.false.
      CALL cmumps_mem_cons_mng(inode,pool,lpool,n,step,keep,keep8,
     &     procnode,slavef,myid,sbtr_flag,proc_flag,min_proc)
      IF(sbtr_flag)THEN
         RETURN
      ENDIF
      IF(min_proc.EQ.-9999)THEN
         IF((inode.GT.0).AND.(inode.LT.n))THEN
            sbtr_flag=(nbinsubtree.NE.0)
         ENDIF
         RETURN
      ENDIF
      IF(.NOT.proc_flag)THEN
         node_to_extract=inode
         IF((inode.GE.0).AND.(inode.LE.n))THEN
            CALL cmumps_find_best_node_for_mem(min_proc,pool,
     &           lpool,inode)
            IF(mumps_inssarbr(procnode(step(inode)),
     &           keep(199)))THEN
               WRITE(*,*)myid,': Extracting from a subtree
     &              for helping',min_proc
               sbtr_flag=.true.
               RETURN
            ELSE
               IF(node_to_extract.NE.inode)THEN
                  WRITE(*,*)myid,': Extracting from top
     &                 inode=',inode,'for helping',min_proc
               ENDIF
               CALL cmumps_load_clean_meminfo_pool(inode)
            ENDIF
         ENDIF
         DO i=1,nbtop
            IF (pool(lpool-2-i).EQ.inode)THEN
               GOTO 452
            ENDIF
         ENDDO
 452     CONTINUE
         pos_to_extract=i
         DO i=pos_to_extract,nbtop-1
            pool(lpool-2-i)=pool(lpool-2-i-1)
         ENDDO
         pool(lpool-2-nbtop)=inode
      ENDIF

cmumps_pool_empty()

logical function cmumps_pool_empty	(	integer, dimension(lpool)	pool,
		integer	lpool )

Definition at line 158 of file cfac_sol_pool.F.

      IMPLICIT NONE
      INTEGER LPOOL
      INTEGER POOL(LPOOL)
      INTEGER NBINSUBTREE, NBTOP
      nbinsubtree = pool(lpool)
      nbtop       = pool(lpool - 1)
      cmumps_pool_empty = (nbinsubtree + nbtop == 0)
      RETURN