dmumps_load.F

Go to the documentation of this file.

C
C  This file is part of MUMPS 5.5.1, released
C  on Tue Jul 12 13:17:24 UTC 2022
C
C
C  Copyright 1991-2022 CERFACS, CNRS, ENS Lyon, INP Toulouse, Inria,
C  Mumps Technologies, University of Bordeaux.
C
C  This version of MUMPS is provided to you free of charge. It is
C  released under the CeCILL-C license 
C  (see doc/CeCILL-C_V1-en.txt, doc/CeCILL-C_V1-fr.txt, and
C  https://cecill.info/licences/Licence_CeCILL-C_V1-en.html)
C
      MODULE dmumps_load
      implicit none
      PUBLIC :: dmumps_load_set_inicost, dmumps_load_init,
     &  dmumps_load_set_slaves, dmumps_load_update,
     &  dmumps_load_end, dmumps_load_process_message, 
     &  dmumps_load_less, dmumps_load_less_cand,
     &  dmumps_load_set_slaves_cand, dmumps_load_master_2_all,
     &  dmumps_load_recv_msgs, dmumps_load_mem_update,
     &  dmumps_load_set_partition,
     &  dmumps_split_prep_partition, dmumps_split_post_partition,
     &  dmumps_split_propagate_parti, dmumps_load_pool_upd_new_pool,
     &  dmumps_load_sbtr_upd_new_pool, dmumps_load_pool_check_mem,
     &  dmumps_load_set_sbtr_mem,
     &  dmumps_remove_node, dmumps_upper_predict
     &  ,dmumps_load_send_md_info,
     &  dmumps_load_clean_meminfo_pool, dmumps_load_comp_maxmem_pool,
     &  dmumps_load_chk_memcst_pool, dmumps_check_sbtr_cost,
     &  dmumps_find_best_node_for_mem,
     &  dmumps_load_init_sbtr_struct
      DOUBLE PRECISION, DIMENSION(:),
     &       ALLOCATABLE, SAVE, PRIVATE :: load_flops
      INTEGER, DIMENSION(:), ALLOCATABLE, SAVE, PRIVATE :: buf_load_recv
      INTEGER, SAVE, PRIVATE :: lbuf_load_recv, LBUF_LOAD_RECV_BYTES
      INTEGER, SAVE, PRIVATE :: k50, k69, k35
      INTEGER(8), SAVE, PRIVATE :: max_surf_master
      LOGICAL, SAVE, PRIVATE :: bdc_mem, bdc_pool, bdc_sbtr, 
     &     bdc_pool_mng,
     &     bdc_m2_mem,bdc_m2_flops,bdc_md,remove_node_flag,
     &     REMOVE_NODE_FLAG_MEM
      DOUBLE PRECISION, SAVE, PRIVATE :: remove_node_cost,
     &     remove_node_cost_mem
      INTEGER, SAVE, PRIVATE :: sbtr_which_m
      DOUBLE PRECISION, DIMENSION(:),
     &       ALLOCATABLE, TARGET, SAVE, PRIVATE :: wload
      DOUBLE PRECISION, SAVE, PRIVATE :: delta_load, delta_mem
      LOGICAL, SAVE, PRIVATE :: is_mumps_load_enabled
      PUBLIC:: mumps_load_enable, mumps_load_disable
      INTEGER(8), SAVE, PRIVATE :: check_mem
      INTEGER, DIMENSION(:), ALLOCATABLE, SAVE, TARGET, PRIVATE :: 
     &          idwload
      DOUBLE PRECISION, SAVE, PRIVATE :: cost_subtree
      DOUBLE PRECISION, SAVE, PRIVATE :: alpha
      DOUBLE PRECISION, SAVE, PRIVATE :: beta
      INTEGER, SAVE, PRIVATE :: myid, nprocs, comm_ld
      INTEGER, SAVE, PRIVATE :: comm_nodes
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE, SAVE, 
     &           PRIVATE :: pool_mem
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE, PRIVATE, 
     &           SAVE :: sbtr_mem
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE, 
     &           PRIVATE, SAVE :: sbtr_cur
      INTEGER, DIMENSION(:), ALLOCATABLE, 
     &           PRIVATE, SAVE :: nb_son
      DOUBLE PRECISION, 
     &           PRIVATE, SAVE :: sbtr_cur_local
      DOUBLE PRECISION, 
     &           PRIVATE, SAVE :: peak_sbtr_cur_local
      DOUBLE PRECISION, 
     &           PRIVATE, SAVE :: max_peak_stk
      DOUBLE PRECISION, SAVE, 
     &           PRIVATE :: pool_last_cost_sent
      DOUBLE PRECISION, SAVE, 
     &           PRIVATE :: min_diff
      INTEGER, SAVE :: pos_id,pos_mem
      INTEGER, DIMENSION(:), ALLOCATABLE, SAVE :: cb_cost_id
      INTEGER(8), DIMENSION(:), ALLOCATABLE, save
     &           :: cb_cost_mem
      PUBLIC :: cb_cost_id, cb_cost_mem,pos_mem,pos_id
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: lu_usage
      INTEGER(8), DIMENSION(:), ALLOCATABLE, SAVE,
     &        PRIVATE::md_mem, tab_maxs
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE, SAVE ::mem_subtree
      INTEGER  :: nb_subtrees,niv1_flag
      INTEGER, PRIVATE  :: indice_sbtr,indice_sbtr_array
      INTEGER :: pool_niv2_size
      INTEGER,SAVE :: inside_subtree
      PUBLIC :: nb_subtrees,mem_subtree,inside_subtree,niv1_flag
      DOUBLE PRECISION, SAVE, PRIVATE :: dm_sumlu,
     &                   dm_thres_mem
      DOUBLE PRECISION, DIMENSION(:),
     &   ALLOCATABLE, SAVE , PRIVATE:: dm_mem
      INTEGER, SAVE, PRIVATE :: pool_size,ID_MAX_M2
      DOUBLE PRECISION, SAVE, PRIVATE :: max_m2,tmp_m2
      INTEGER, DIMENSION(:),ALLOCATABLE,SAVE, PRIVATE:: pool_niv2
      DOUBLE PRECISION, DIMENSION(:),ALLOCATABLE,SAVE, 
     &      PRIVATE :: pool_niv2_cost, niv2
      DOUBLE PRECISION, SAVE, PRIVATE  ::      chk_ld
      INTEGER, DIMENSION(:),POINTER, SAVE, PRIVATE  :: 
     &         procnode_load, step_to_niv2_load
      INTEGER, DIMENSION(:),POINTER, SAVE, PRIVATE  :: keep_load
      INTEGER, SAVE, PRIVATE :: n_load
      INTEGER(8), DIMENSION(:), POINTER, SAVE, PRIVATE:: keep8_load
      INTEGER, DIMENSION(:),POINTER, SAVE :: 
     &         fils_load, step_load,
     &         frere_load, nd_load,
     &         ne_load,DAD_LOAD
      INTEGER, DIMENSION(:,:),POINTER, SAVE, PRIVATE :: cand_load
      INTEGER, DIMENSION(:),POINTER, SAVE, 
     &         PRIVATE :: my_first_leaf,my_nb_leaf, my_root_sbtr
      INTEGER, DIMENSION(:),ALLOCATABLE,SAVE, 
     &         PRIVATE ::sbtr_first_pos_in_pool
      DOUBLE PRECISION, DIMENSION(:),ALLOCATABLE,SAVE, 
     &         PRIVATE ::sbtr_peak_array,
     &     sbtr_cur_array
      DOUBLE PRECISION,DIMENSION(:),POINTER, SAVE :: cost_trav
      INTEGER, DIMENSION(:),POINTER, SAVE :: DEPTH_FIRST_LOAD,
     &     depth_first_seq_load,sbtr_id_load
      PUBLIC :: depth_first_load,cost_trav, fils_load,step_load,
     &     frere_load, nd_load,ne_load,dad_load,
     &     depth_first_seq_load,sbtr_id_load
      INTEGER, SAVE     :: root_current_subtree,current_best,
     &     second_current_best
      PUBLIC :: root_current_subtree,current_best,
     &     second_current_best
      CONTAINS
      SUBROUTINE mumps_load_enable()
      IMPLICIT NONE
      is_mumps_load_enabled = .true.
      RETURN
      END SUBROUTINE mumps_load_enable
      SUBROUTINE mumps_load_disable()
      IMPLICIT NONE
      is_mumps_load_enabled = .false.
      RETURN
      END SUBROUTINE mumps_load_disable
      SUBROUTINE dmumps_load_set_inicost( COST_SUBTREE_ARG, K64, DK15,
     &     K375, MAXS )
      IMPLICIT NONE
      DOUBLE PRECISION cost_subtree_arg
      INTEGER, INTENT(IN) :: k64, k375
      DOUBLE PRECISION, INTENT(IN) :: dk15
      INTEGER(8)::maxs
      DOUBLE PRECISION :: t64, t66
      LOGICAL :: avoid_load_messages
      t64 = max( dble(k64), dble(1) )
      t64 = min( t64, dble(1000)  )
      t66 = max(dble(dk15), dble(100))
      min_diff     =  ( t64 / dble(1000)  )* 
     &                  t66 * dble(1000000)
      dm_thres_mem = dble(maxs/300_8)
      cost_subtree = cost_subtree_arg
      avoid_load_messages = .false.
      IF (k375.EQ.1) THEN
        avoid_load_messages = .true.
      ENDIF
      IF (avoid_load_messages) THEN
        min_diff = min_diff * 1000.d0
        dm_thres_mem = dm_thres_mem * 1000_8
      ENDIF
      RETURN
      END SUBROUTINE dmumps_load_set_inicost
      SUBROUTINE dmumps_split_prep_partition ( 
     &      INODE, STEP, N, SLAVEF,
     &      PROCNODE_STEPS, KEEP, DAD, FILS,
     &      CAND, ICNTL, COPY_CAND,
     &      NBSPLIT, NUMORG_SPLIT, SLAVES_LIST,
     &      SIZE_SLAVES_LIST 
     &                                    )
      IMPLICIT NONE
       INTEGER, intent(in) :: inode, n, size_slaves_list, slavef, 
     &                        keep(500)
       INTEGER, intent(in) :: step(n), dad (keep(28)), icntl(60),
     &                        procnode_steps(keep(28)), cand(slavef+1),
     &                        fils(n)
       INTEGER, intent(out)   :: nbsplit, numorg_split
       INTEGER, intent(inout) :: slaves_list(size_slaves_list),
     &                           copy_cand(slavef+1)
       INTEGER :: in, lp, ii
       INTEGER  mumps_typesplit
       EXTERNAL mumps_typesplit
       lp = icntl(1) 
       in = inode
       nbsplit = 0
       numorg_split = 0    
       DO WHILE 
     &      (
     &        ( mumps_typesplit 
     &           (procnode_steps(step(dad(step(in)))),keep(199))
     &           .EQ.5 
     &        ) 
     &        .OR.
     &        ( mumps_typesplit 
     &           (procnode_steps(step(dad(step(in)))),keep(199))
     &           .EQ.6  
     &        ) 
     &      )  
           nbsplit = nbsplit + 1
           in = dad(step(in))
           ii = in
           DO WHILE (ii.GT.0)
             numorg_split = numorg_split + 1
             ii = fils(ii)
           ENDDO
       END DO
      slaves_list(1:nbsplit) = cand(1:nbsplit)
      copy_cand(1:size_slaves_list-nbsplit) = 
     &                   cand(1+nbsplit:size_slaves_list)
      copy_cand(size_slaves_list-nbsplit+1:slavef) = -1
      copy_cand(slavef+1) = size_slaves_list-nbsplit
      RETURN
      END SUBROUTINE dmumps_split_prep_partition
      SUBROUTINE dmumps_split_post_partition ( 
     &      INODE, STEP, N, SLAVEF, NBSPLIT, NCB, 
     &      PROCNODE_STEPS, KEEP, DAD, FILS, ICNTL,
     &      TAB_POS, NSLAVES_NODE
     &                                    )
      IMPLICIT NONE
       INTEGER, intent(in) :: inode, n, slavef, ncb, 
     &                        keep(500), nbsplit
       INTEGER, intent(in) :: step(n), dad (keep(28)), icntl(60),
     &                        procnode_steps(keep(28)), 
     &                        fils(n)
       INTEGER, intent(inout) :: tab_pos ( slavef+2 ), nslaves_node
       INTEGER :: in, lp, ii, numorg, nbsplit_loc, i
       INTEGER  mumps_typesplit
       EXTERNAL mumps_typesplit
       do i= nslaves_node+1, 1, -1
          tab_pos(i+nbsplit) = tab_pos(i) 
       END DO
       lp = icntl(1) 
       in = inode
       nbsplit_loc = 0
       numorg = 0
       tab_pos(1) = 1
       DO WHILE 
     &      (
     &        ( mumps_typesplit 
     &           (procnode_steps(step(dad(step(in)))),keep(199))
     &           .EQ.5 
     &        ) 
     &        .OR.
     &        ( mumps_typesplit 
     &           (procnode_steps(step(dad(step(in)))),keep(199))
     &           .EQ.6  
     &        ) 
     &      )  
           nbsplit_loc = nbsplit_loc + 1
           in = dad(step(in))
           ii = in
           DO WHILE (ii.GT.0)
             numorg = numorg + 1
             ii = fils(ii)
           ENDDO
           tab_pos(nbsplit_loc+1) = numorg + 1
       END DO
       DO i = nbsplit+2, nbsplit+nslaves_node+1
         tab_pos(i) = tab_pos(i) + numorg
       ENDDO
      nslaves_node = nslaves_node + nbsplit
      tab_pos(nslaves_node+2:slavef+1) = -9999
      tab_pos( slavef+2 ) =  nslaves_node
      RETURN
      END SUBROUTINE dmumps_split_post_partition
      SUBROUTINE dmumps_split_propagate_parti (
     &      INODE, TYPESPLIT, IFSON, 
     &      CAND, SIZE_CAND,
     &      SON_SLAVE_LIST, NSLSON,
     &      STEP, N, SLAVEF, 
     &      PROCNODE_STEPS, KEEP, DAD, FILS, ICNTL,
     &      ISTEP_TO_INIV2, INIV2,
     &      TAB_POS_IN_PERE, NSLAVES_NODE,
     &      SLAVES_LIST, SIZE_SLAVES_LIST
     &                                    )
      IMPLICIT NONE
       INTEGER, intent(in) :: inode, typesplit, ifson, n, slavef, 
     &                        keep(500), 
     &                        nslson, size_slaves_list, size_cand
       INTEGER, intent(in) :: step(n), dad (keep(28)), icntl(60),
     &                        procnode_steps(keep(28)), 
     &                        fils(n), iniv2,
     &                        son_slave_list(nslson),
     &                        istep_to_iniv2(keep(71)),
     &                        cand(size_cand)
       INTEGER, intent(out)   ::  nslaves_node
       INTEGER, intent(inout) ::
     &                   tab_pos_in_pere(slavef+2,max(1,keep(56)))
       INTEGER, intent(out)   :: slaves_list (size_slaves_list)
       INTEGER :: in, lp, i, nslaves_sons,
     &            iniv2_fils, ishift
       lp = icntl(1) 
       in = inode
      iniv2_fils = istep_to_iniv2( step( ifson ))
      nslaves_sons = tab_pos_in_pere(slavef+2, iniv2_fils)
      tab_pos_in_pere(1,iniv2) = 1
      ishift  = tab_pos_in_pere(2, iniv2_fils) -1 
      DO i = 2, nslaves_sons
         tab_pos_in_pere(i,iniv2) = 
     &            tab_pos_in_pere(i+1,iniv2_fils) - ishift
         slaves_list(i-1) =  son_slave_list(i)
      END DO
      tab_pos_in_pere(nslaves_sons+1:slavef+1,iniv2) = -9999
      nslaves_node = nslaves_sons - 1
      tab_pos_in_pere(slavef+2, iniv2) = nslaves_node
      RETURN
      END SUBROUTINE dmumps_split_propagate_parti 
      SUBROUTINE dmumps_load_set_partition(
     &  NCBSON_MAX, SLAVEF,
     &  KEEP,KEEP8,ICNTL,
     &  CAND_OF_NODE,
     &  MEM_DISTRIB, NCB, NFRONT, NSLAVES_NODE,
     &  TAB_POS, SLAVES_LIST, SIZE_SLAVES_LIST,INODE
     &)
       IMPLICIT NONE
      INTEGER, intent(in) :: KEEP(500),size_slaves_list
      INTEGER(8) keep8(150)
      INTEGER, intent(in) :: icntl(60)
      INTEGER, intent(in) :: slavef, nfront
      INTEGER, intent (inout) ::ncb   
      INTEGER, intent(in) :: cand_of_node(slavef+1)
      INTEGER, intent(in) :: mem_distrib(0:slavef-1),inode
      INTEGER, intent(in) :: ncbson_max
      INTEGER, intent(out):: slaves_list(size_slaves_list)
      INTEGER, intent(out):: tab_pos(slavef+2)
      INTEGER, intent(out):: nslaves_node
      INTEGER i
      INTEGER lp,mp
      INTEGER(8) dummy1
      INTEGER dummy2
      INTEGER tmp_array(2)
      lp=icntl(4)
      mp=icntl(2)
      IF ( keep(48) == 0 .OR. keep(48) .EQ. 3 ) THEN
         CALL dmumps_load_parti_regular(
     &        slavef,
     &        keep,keep8,
     &        cand_of_node,
     &        mem_distrib, ncb, nfront, nslaves_node,
     &        tab_pos, slaves_list, size_slaves_list)
      ELSE IF ( keep(48) == 4 ) THEN
         CALL dmumps_set_parti_actv_mem(
     &        slavef,
     &        keep,keep8,
     &        cand_of_node,
     &        mem_distrib, ncb, nfront, nslaves_node,
     &        tab_pos, slaves_list, size_slaves_list,myid)
         DO i=1,nslaves_node
            IF(tab_pos(i+1)-tab_pos(i).LE.0)THEN
               WRITE(*,*)'probleme de partition dans 
     &DMUMPS_LOAD_SET_PARTI_ACTV_MEM'
               CALL mumps_abort()
            ENDIF
         ENDDO
      ELSE IF ( keep(48) == 5 ) THEN
         IF (keep(375).EQ.1) THEN 
           GOTO 458
         ENDIF
         CALL dmumps_set_parti_flop_irr(
     &        ncbson_max,
     &        slavef,
     &        keep,keep8,
     &        cand_of_node,
     &        mem_distrib, ncb, nfront, nslaves_node,
     &        tab_pos, slaves_list, size_slaves_list,myid,inode,
     &        mp,lp)
         DO i=1,nslaves_node
            IF(tab_pos(i+1)-tab_pos(i).LE.0)THEN
               WRITE(*,*)'problem with partition in
     &DMUMPS_SET_PARTI_FLOP_IRR'
               CALL mumps_abort()
            ENDIF
         ENDDO
         GOTO 457
 458     CONTINUE
         IF ( keep(375).EQ.1 )THEN 
           tmp_array(1)=0
           tmp_array(2)=0
         ENDIF
         CALL mumps_set_parti_regular(
     &        slavef,
     &        keep,keep8,
     &        cand_of_node,
     &        mem_distrib, ncb, nfront, nslaves_node,
     &        tab_pos, slaves_list, size_slaves_list,myid,inode,
     &        tab_maxs,tmp_array,dummy1,dummy2
     &        )
      ELSE
        WRITE(*,*) "Strategy 6 not implemented"
        CALL mumps_abort()
      ENDIF
 457  CONTINUE
      RETURN
      END SUBROUTINE dmumps_load_set_partition
      SUBROUTINE dmumps_load_parti_regular(
     &  SLAVEF,
     &  KEEP,KEEP8,
     &  CAND_OF_NODE,
     &  MEM_DISTRIB, NCB, NFRONT, NSLAVES_NODE,
     &  TAB_POS, SLAVES_LIST, SIZE_SLAVES_LIST)
      IMPLICIT NONE
      INTEGER, intent(in) :: KEEP(500),SIZE_SLAVES_LIST
      INTEGER(8) KEEP8(150)
      INTEGER, intent(in) :: SLAVEF, NFRONT, NCB
      INTEGER, intent(in) :: CAND_OF_NODE(SLAVEF+1)
      INTEGER, intent(in) :: MEM_DISTRIB(0:SLAVEF-1)
      INTEGER, intent(out):: SLAVES_LIST(SIZE_SLAVES_LIST)
      INTEGER, intent(out):: TAB_POS(SLAVEF+2)
      INTEGER, intent(out):: NSLAVES_NODE
      INTEGER ITEMP, NMB_OF_CAND, NSLAVES_LESS
      DOUBLE PRECISION MSG_SIZE
      LOGICAL FORCE_CAND
      INTEGER  MUMPS_REG_GET_NSLAVES
      EXTERNAL MUMPS_REG_GET_NSLAVES
      IF ( KEEP(48) == 0 .AND. keep(50) .NE. 0) THEN
      write(*,*) "Internal error 2 in DMUMPS_LOAD_PARTI_REGULAR."
      CALL mumps_abort()
      END IF
      IF ( keep(48) == 3 .AND. keep(50) .EQ. 0) THEN
      write(*,*) "Internal error 3 in DMUMPS_LOAD_PARTI_REGULAR."
      CALL mumps_abort()
      END IF
      msg_size = dble( nfront - ncb ) * dble(ncb)
      IF ( keep(24) == 0 .OR. keep(24) == 1 ) THEN
        force_cand = .false.
      ELSE
        force_cand = (mod(keep(24),2).eq.0)
      END IF
      IF (force_cand) THEN
        itemp=dmumps_load_less_cand
     &       (mem_distrib,
     &        cand_of_node,
     &
     &        keep(69), slavef, msg_size,
     &        nmb_of_cand )
      ELSE
        itemp=dmumps_load_less(keep(69),mem_distrib,msg_size)
        nmb_of_cand = slavef - 1
      END IF
      nslaves_less = max(itemp,1)
      nslaves_node = mumps_reg_get_nslaves(keep8(21), keep(48),
     &          keep(50),slavef,
     &          ncb, nfront, nslaves_less, nmb_of_cand,
     &          keep(375), keep(119))
      CALL mumps_bloc2_setpartition(
     &            keep,keep8, slavef,
     &            tab_pos,
     &            nslaves_node, nfront, ncb
     &             )
      IF (force_cand) THEN
        CALL dmumps_load_set_slaves_cand(mem_distrib(0),
     &       cand_of_node, slavef, nslaves_node,
     &       slaves_list)
      ELSE
        CALL dmumps_load_set_slaves(mem_distrib(0),
     &       msg_size, slaves_list, nslaves_node)
      ENDIF
      RETURN
      END SUBROUTINE dmumps_load_parti_regular
      SUBROUTINE dmumps_load_init( id, MEMORY_MD_ARG, MAXS )
      USE dmumps_buf
      USE dmumps_struc_def
      USE mumps_future_niv2
      IMPLICIT NONE
      TYPE(dmumps_struc), TARGET :: id
      INTEGER(8), intent(in) :: memory_md_arg
      INTEGER(8), intent(in) :: maxs
      INTEGER K34_LOC
      INTEGER(8) :: i8size
      INTEGER allocok, ierr, ierr_mpi, i, buf_load_size
      DOUBLE PRECISION :: max_sbtr
      DOUBLE PRECISION zero
      DOUBLE PRECISION memory_sent
      PARAMETER( zero=0.0d0 )
      DOUBLE PRECISION size_dble(2) 
      INTEGER what
      INTEGER(8) memory_md, la
      call mumps_load_enable()
      STEP_TO_NIV2_LOAD=>id%ISTEP_TO_INIV2
      cand_load=>id%CANDIDATES
      nd_load=>id%ND_STEPS
      keep_load=>id%KEEP
      keep8_load=>id%KEEP8
      fils_load=>id%FILS
      frere_load=>id%FRERE_STEPS
      dad_load=>id%DAD_STEPS
      procnode_load=>id%PROCNODE_STEPS
      step_load=>id%STEP
      ne_load=>id%NE_STEPS
      n_load=id%N
      root_current_subtree=-9999
      memory_md=memory_md_arg
      la=maxs
      max_surf_master=id%MAX_SURF_MASTER+
     & (int(id%KEEP(12),8)*int(id%MAX_SURF_MASTER,8)/int(100,8))
      comm_ld    = id%COMM_LOAD
      comm_nodes = id%COMM_NODES
      max_peak_stk = 0.0d0
      k69  = id%KEEP(69)
      IF ( id%KEEP(47) .le. 0 .OR. id%KEEP(47) .gt. 4 ) THEN
        write(*,*) "Internal error 1 in DMUMPS_LOAD_INIT"
        CALL mumps_abort()
      END IF
      chk_ld=dble(0)
      bdc_mem      = ( id%KEEP(47) >= 2 )
      bdc_pool     = ( id%KEEP(47) >= 3 )
      bdc_sbtr     = ( id%KEEP(47) >= 4 )
      bdc_m2_mem   = ( ( id%KEEP(80) == 2 .OR. id%KEEP(80) == 3 )
     &             .AND. id%KEEP(47) == 4 )
      bdc_m2_flops   = ( id%KEEP(80) == 1 
     &             .AND. id%KEEP(47) .GE. 1 )
      bdc_md       = (id%KEEP(86)==1)
      sbtr_which_m       = id%KEEP(90)
      remove_node_flag=.false.
      remove_node_flag_mem=.false.
      remove_node_cost_mem=dble(0)
      remove_node_cost=dble(0)
      IF (id%KEEP(80) .LT. 0 .OR. id%KEEP(80)>3) THEN
        WRITE(*,*) "Unimplemented KEEP(80) Strategy"
        CALL mumps_abort()
      ENDIF
      IF ((id%KEEP(80) == 2 .OR. id%KEEP(80)==3).AND. id%KEEP(47).NE.4)
     &  THEN
        WRITE(*,*) "Internal error 3 in DMUMPS_LOAD_INIT"
        CALL mumps_abort()
      END IF
      IF (id%KEEP(81) == 1 .AND. id%KEEP(47) < 2) THEN
        WRITE(*,*) "Internal error 2 in DMUMPS_LOAD_INIT"
        CALL mumps_abort()
      ENDIF
      bdc_pool_mng = ((id%KEEP(81) == 1).AND.(id%KEEP(47) >= 2))
      IF(id%KEEP(76).EQ.4)THEN
         depth_first_load=>id%DEPTH_FIRST
      ENDIF
      IF(id%KEEP(76).EQ.5)THEN
         cost_trav=>id%COST_TRAV
      ENDIF
      IF(id%KEEP(76).EQ.6)THEN
         depth_first_load=>id%DEPTH_FIRST
         depth_first_seq_load=>id%DEPTH_FIRST_SEQ
         sbtr_id_load=>id%SBTR_ID
      ENDIF
      IF (bdc_m2_mem.OR.bdc_m2_flops) THEN
         pool_niv2_size=max(1,min(id%NBSA+id%KEEP(262),id%NA(1)))
         ALLOCATE(niv2(id%NSLAVES), nb_son(id%KEEP(28)),
     &            pool_niv2(pool_niv2_size),
     &        pool_niv2_cost(pool_niv2_size),
     &            stat=allocok)
         DO i = 1, id%KEEP(28)
           nb_son(i)=id%NE_STEPS(i)
         ENDDO
         niv2=dble(0)
         IF (allocok > 0) THEN
           WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
           id%INFO(1) = -13
           id%INFO(2) = id%NSLAVES + id%KEEP(28) + 200
           RETURN
         ENDIF
      ENDIF
      k50      = id%KEEP(50)
      CALL mpi_comm_rank( comm_ld, myid, ierr_mpi )
      nprocs = id%NSLAVES
      dm_sumlu=zero
      pool_size=0
      IF(bdc_md)THEN
         IF ( allocated(md_mem) ) DEALLOCATE(md_mem)
         ALLOCATE( md_mem( 0: nprocs - 1 ), stat=allocok )
         IF ( allocok .gt. 0 ) THEN
            WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
            id%INFO(1) = -13
            id%INFO(2) = nprocs
            RETURN
         END IF
         IF ( allocated(tab_maxs) ) DEALLOCATE(tab_maxs)
         ALLOCATE( tab_maxs( 0: nprocs - 1 ), stat=allocok )
         IF ( allocok .gt. 0 ) THEN
            WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
            id%INFO(1) = -13
            id%INFO(2) = nprocs
            RETURN
         END IF
         tab_maxs=0_8
         IF ( allocated(lu_usage) ) DEALLOCATE(lu_usage)
         ALLOCATE( lu_usage( 0: nprocs - 1 ), stat=allocok )
         IF ( allocok .gt. 0 ) THEN
            WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
            id%INFO(1) = -13
            id%INFO(2) = nprocs
            RETURN
         END IF
         lu_usage=dble(0)
         md_mem=int(0,8)
      ENDIF
      IF((id%KEEP(81).EQ.2).OR.(id%KEEP(81).EQ.3))THEN
         ALLOCATE(cb_cost_mem(2*2000*id%NSLAVES), 
     &            stat=allocok)
         IF (allocok > 0) THEN
           WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
           id%INFO(1) = -13
           id%INFO(2) = id%NSLAVES 
           RETURN
         ENDIF
         cb_cost_mem=int(0,8)
         ALLOCATE(cb_cost_id(2000*3), 
     &            stat=allocok)
         IF (allocok > 0) THEN
           WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
           id%INFO(1) = -13
           id%INFO(2) = id%NSLAVES 
           RETURN
         ENDIF
         cb_cost_id=0
         pos_mem=1
         pos_id=1
      ENDIF
      ALLOCATE(future_niv2(nprocs), stat=allocok)
      IF (allocok > 0 ) THEN
         WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
         id%INFO(1) = -13
         id%INFO(2) = nprocs
         RETURN
      ENDIF
      DO i = 1, nprocs
        future_niv2(i) = id%FUTURE_NIV2(i)
        IF(bdc_md)THEN
           IF(future_niv2(i).EQ.0)THEN
              md_mem(i-1)=999999999_8
           ENDIF
        ENDIF
      ENDDO
      delta_mem=zero
      delta_load=zero
      check_mem=0_8
      IF(bdc_sbtr.OR.bdc_pool_mng)THEN
         nb_subtrees=id%NBSA_LOCAL
         IF (allocated(mem_subtree)) DEALLOCATE(mem_subtree)
         ALLOCATE(mem_subtree(id%NBSA_LOCAL),stat=allocok)
         IF (allocok > 0 ) THEN
            WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
            id%INFO(1) = -13
            id%INFO(2) = id%NBSA_LOCAL
            RETURN
         ENDIF
         DO i=1,id%NBSA_LOCAL
            mem_subtree(i)=id%MEM_SUBTREE(i)
         ENDDO
         my_first_leaf=>id%MY_FIRST_LEAF
         my_nb_leaf=>id%MY_NB_LEAF
         my_root_sbtr=>id%MY_ROOT_SBTR
         IF (allocated(sbtr_first_pos_in_pool))
     &        DEALLOCATE(sbtr_first_pos_in_pool)
         ALLOCATE(sbtr_first_pos_in_pool(id%NBSA_LOCAL),stat=allocok)
         IF (allocok > 0 ) THEN
            WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
            id%INFO(1) = -13
            id%INFO(2) = id%NBSA_LOCAL
            RETURN
         ENDIF
         inside_subtree=0
         peak_sbtr_cur_local = dble(0)
         sbtr_cur_local      = dble(0)
         IF (allocated(sbtr_peak_array)) DEALLOCATE(sbtr_peak_array)
         ALLOCATE(sbtr_peak_array(id%NBSA_LOCAL),stat=allocok)
         IF (allocok > 0 ) THEN
            WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
            id%INFO(1) = -13
            id%INFO(2) = id%NBSA_LOCAL
            RETURN
         ENDIF
         sbtr_peak_array=dble(0)
         IF (allocated(sbtr_cur_array)) DEALLOCATE(sbtr_cur_array)
         ALLOCATE(sbtr_cur_array(id%NBSA_LOCAL),stat=allocok)
         IF (allocok > 0 ) THEN
            WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
            id%INFO(1) = -13
            id%INFO(2) = id%NBSA_LOCAL
            RETURN
         ENDIF
         sbtr_cur_array=dble(0)
         indice_sbtr_array=1
         niv1_flag=0
         indice_sbtr=1
      ENDIF
      IF ( allocated(load_flops) ) DEALLOCATE( load_flops )
      ALLOCATE( load_flops( 0: nprocs - 1 ), stat=allocok )
      IF ( allocok .gt. 0 ) THEN
         WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
         id%INFO(1) = -13
         id%INFO(2) = nprocs
         RETURN
      END IF
      IF ( allocated(wload) ) DEALLOCATE( wload )
      ALLOCATE( wload( nprocs ), stat=allocok )
      IF ( allocok .gt. 0 ) THEN
         WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
         id%INFO(1) = -13
         id%INFO(2) = nprocs
         RETURN
      END IF
      IF ( allocated(idwload) ) DEALLOCATE( idwload )
      ALLOCATE( idwload( nprocs ), stat=allocok )
      IF ( allocok .gt. 0 ) THEN
         WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
         id%INFO(1) = -13
         id%INFO(2) = nprocs
         RETURN
      END IF
      IF ( bdc_mem ) THEN
        IF ( allocated(dm_mem) ) DEALLOCATE( dm_mem )
        ALLOCATE( dm_mem( 0:nprocs-1 ), stat=allocok )
        IF ( allocok .gt. 0 ) THEN
           WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
           id%INFO(1) = -13
           id%INFO(2) = nprocs
           RETURN
        END IF
      END IF
      IF ( bdc_pool ) THEN
        IF ( allocated(pool_mem) ) DEALLOCATE(pool_mem)
        ALLOCATE( pool_mem(0: nprocs -1), stat=allocok)
        IF ( allocok .gt. 0 ) THEN
           WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
           id%INFO(1) = -13
           id%INFO(2) = nprocs
           RETURN
        END IF
        pool_mem = dble(0) 
        pool_last_cost_sent = dble(0)
      END IF
      IF ( bdc_sbtr ) THEN
        IF ( allocated(sbtr_mem) ) DEALLOCATE(sbtr_mem)
        ALLOCATE( sbtr_mem(0: nprocs -1), stat=allocok)
        IF ( allocok .gt. 0 ) THEN
           WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
           id%INFO(1) = -13
           id%INFO(2) = nprocs
           RETURN
        END IF
        IF ( allocated(sbtr_cur) ) DEALLOCATE(sbtr_cur)
        ALLOCATE( sbtr_cur(0: nprocs -1), stat=allocok)
        IF ( allocok .gt. 0 ) THEN
           WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
           id%INFO(1) = -13
           id%INFO(2) = nprocs
           RETURN
        END IF
        sbtr_cur = dble(0) 
        sbtr_mem = dble(0) 
      END IF
      k34_loc=id%KEEP(34)
      CALL mumps_size_c(size_dble(1),size_dble(2),i8size)
      k35  = int(i8size)
      buf_load_size = k34_loc * 2 * ( nprocs - 1 ) +
     &                nprocs * ( k35 + k34_loc )
      IF (bdc_mem) THEN
        buf_load_size = buf_load_size + nprocs * k35
      END IF
      IF (bdc_sbtr)THEN
        buf_load_size = buf_load_size + nprocs * k35
      ENDIF
      lbuf_load_recv = (buf_load_size+k34_loc)/k34_loc
      lbuf_load_recv_bytes = lbuf_load_recv * k34_loc
      IF ( allocated(buf_load_recv) ) DEALLOCATE(buf_load_recv)
      ALLOCATE( buf_load_recv( lbuf_load_recv), stat=allocok)
      IF ( allocok > 0 ) THEN
        WRITE(*,*) 'PB allocation in DMUMPS_LOAD_INIT'
        id%INFO(1) = -13
        id%INFO(2) = lbuf_load_recv
        RETURN
      ENDIF 
      buf_load_size = buf_load_size * 20
      CALL dmumps_buf_alloc_load_buffer( buf_load_size, ierr )
      IF ( ierr .LT. 0 ) THEN
         id%INFO(1) = -13
         id%INFO(2) = buf_load_size
         RETURN
      END IF
      DO i = 0, nprocs - 1
         load_flops( i ) = zero
      END DO
      IF ( bdc_mem ) THEN
        DO i = 0, nprocs - 1
          dm_mem( i )=zero
        END DO
      ENDIF
      CALL dmumps_init_alpha_beta(id%KEEP(69))
      IF(bdc_md)THEN
         max_sbtr=0.0d0
         IF(bdc_sbtr)THEN
            DO i=1,id%NBSA_LOCAL
               max_sbtr=max(id%MEM_SUBTREE(i),max_sbtr)
            ENDDO
         ENDIF
         md_mem(myid)=memory_md
         what=8
         CALL dmumps_buf_broadcast( what,
     &        comm_ld, nprocs,
     &        future_niv2,
     &        dble(memory_md),dble(0) ,myid, id%KEEP, ierr  )
         what=9
         memory_sent = dble(la-max_surf_master)-max_sbtr
     &      - max( dble(la) * dble(3) / dble(100),
     &      dble(2) *
     &      dble(max(id%KEEP(5),id%KEEP(6))) * dble(id%KEEP(127)))
         IF (id%KEEP(12) > 25) THEN
           memory_sent = memory_sent -
     &                   dble(id%KEEP(12))*0.2d0*dble(la)/100.0d0
         ENDIF
         IF (id%KEEP(375).EQ.1) THEN  
           memory_sent=dble(la)
         ENDIF
         tab_maxs(myid)=int(memory_sent,8)
         CALL dmumps_buf_broadcast( what,
     &        comm_ld, nprocs,
     &        future_niv2,
     &        memory_sent,
     &        dble(0),myid, id%KEEP, ierr  )
      ENDIF
      RETURN
      END SUBROUTINE dmumps_load_init
      SUBROUTINE dmumps_load_update( CHECK_FLOPS,PROCESS_BANDE,
     &     INC_LOAD, KEEP,KEEP8 )
      USE dmumps_buf
      USE mumps_future_niv2
      IMPLICIT NONE
      DOUBLE PRECISION inc_load
      INTEGER keep(500)
      INTEGER(8) keep8(150)
      LOGICAL process_bande
      LOGICAL :: exit_flag
      INTEGER check_flops
      INTEGER ierr
      DOUBLE PRECISION zero, send_mem, send_load,sbtr_tmp
      PARAMETER( zero=0.0d0 )
      INTRINSIC max
      IF (.NOT. is_mumps_load_enabled) RETURN
      IF (inc_load == 0.0d0) THEN
         IF(remove_node_flag)THEN
            remove_node_flag=.false.
         ENDIF
         RETURN
      ENDIF
      IF((check_flops.NE.0).AND.
     &     (check_flops.NE.1).AND.(check_flops.NE.2))THEN
         WRITE(*,*)myid,': Bad value for CHECK_FLOPS'
         CALL mumps_abort()
      ENDIF
      IF(check_flops.EQ.1)THEN
         chk_ld=chk_ld+inc_load
      ELSE 
         IF(check_flops.EQ.2)THEN
            RETURN
         ENDIF
      ENDIF
      IF ( process_bande ) THEN
         RETURN                 
      ENDIF
      load_flops( myid ) = max( load_flops( myid ) + inc_load, zero)
      IF(bdc_m2_flops.AND.remove_node_flag)THEN
         IF(inc_load.NE.remove_node_cost)THEN
            IF(inc_load.GT.remove_node_cost)THEN
               delta_load = delta_load +
     &              (inc_load-remove_node_cost)
               GOTO 888
            ELSE
               delta_load = delta_load -
     &              (remove_node_cost-inc_load)
               GOTO 888
            ENDIF
         ENDIF
         GOTO 333
      ENDIF
      delta_load = delta_load + inc_load
 888  CONTINUE
      IF ( delta_load > min_diff .OR. delta_load < -min_diff) THEN
         send_load = delta_load
         IF (bdc_mem) THEN
           send_mem = delta_mem
         ELSE
           send_mem = zero
         END IF
         IF(bdc_sbtr)THEN
           sbtr_tmp=sbtr_cur(myid)
         ELSE
           sbtr_tmp=dble(0)
         ENDIF
 111     CONTINUE
         CALL dmumps_buf_send_update_load( bdc_sbtr,bdc_mem,
     &        bdc_md,comm_ld, nprocs,
     &        send_load,
     &        send_mem,sbtr_tmp,
     &        dm_sumlu,
     &        future_niv2,
     &        myid, keep, ierr )
         IF ( ierr == -1 )THEN
             CALL dmumps_load_recv_msgs(comm_ld)
             CALL mumps_check_comm_nodes(comm_nodes, exit_flag)
             IF (exit_flag) THEN
               GOTO 333
             ELSE
               GOTO 111
             ENDIF
         ELSE IF ( ierr .NE.0 ) THEN
             WRITE(*,*) "Internal Error in DMUMPS_LOAD_UPDATE",ierr
             CALL mumps_abort()
         ENDIF
         delta_load = zero
         IF (bdc_mem) delta_mem  = zero
      ENDIF
 333  CONTINUE
      IF(remove_node_flag)THEN
         remove_node_flag=.false.
      ENDIF
      RETURN
      END SUBROUTINE dmumps_load_update
      SUBROUTINE dmumps_load_mem_update( SSARBR,
     &           PROCESS_BANDE_ARG, MEM_VALUE, NEW_LU, INC_MEM_ARG,
     &           KEEP,KEEP8,LRLUS)
      USE dmumps_buf
      USE mumps_future_niv2
      IMPLICIT NONE
      INTEGER(8), INTENT(IN) :: mem_value, inc_mem_arg, new_lu,LRLUS
      LOGICAL, INTENT(IN) :: process_bande_arg, ssarbr
      INTEGER ierr, keep(500)
      INTEGER(8) keep8(150)
      DOUBLE PRECISION zero, send_mem, sbtr_tmp
      PARAMETER( zero=0.0d0 )
      INTRINSIC max, abs
      INTEGER(8) :: inc_mem
      LOGICAL process_bande
      LOGICAL :: exit_flag
      IF (.NOT. is_mumps_load_enabled) RETURN
      process_bande=process_bande_arg
      inc_mem = inc_mem_arg
      IF ( process_bande .AND. new_lu .NE. 0_8) THEN
        WRITE(*,*) " Internal Error in DMUMPS_LOAD_MEM_UPDATE."
        WRITE(*,*) " NEW_LU must be zero if called from PROCESS_BANDE"
        CALL mumps_abort()
      ENDIF
      dm_sumlu = dm_sumlu + dble(new_lu)
      IF(keep_load(201).EQ.0)THEN
         check_mem = check_mem + inc_mem
      ELSE 
         check_mem = check_mem + inc_mem - new_lu
      ENDIF
      IF ( mem_value .NE. check_mem ) THEN
         WRITE(*,*)myid,
     &   ':Problem with increments in DMUMPS_LOAD_MEM_UPDATE',
     &   check_mem, mem_value, inc_mem,new_lu
         CALL mumps_abort()
      ENDIF
      IF (process_bande) THEN
         RETURN
      ENDIF
      IF(bdc_pool_mng) THEN
         IF(sbtr_which_m.EQ.0)THEN
            IF (ssarbr) sbtr_cur_local = sbtr_cur_local+
     &                                   dble(inc_mem-new_lu)
         ELSE
            IF (ssarbr) sbtr_cur_local = sbtr_cur_local+
     &                                   dble(inc_mem)
         ENDIF
      ENDIF
      IF ( .NOT. bdc_mem ) THEN
         RETURN
      ENDIF
      IF (bdc_sbtr .AND. ssarbr) THEN
         IF((sbtr_which_m.EQ.0).AND.(keep(201).NE.0))THEN
            sbtr_cur(myid) = sbtr_cur(myid)+dble(inc_mem-new_lu)
         ELSE
            sbtr_cur(myid) = sbtr_cur(myid)+dble(inc_mem)
         ENDIF
         sbtr_tmp = sbtr_cur(myid)
      ELSE
        sbtr_tmp=dble(0)
      ENDIF
      IF ( new_lu > 0_8 ) THEN
        inc_mem = inc_mem - new_lu
      ENDIF
      dm_mem( myid ) = dm_mem(myid) + dble(inc_mem)
      max_peak_stk=max(max_peak_stk,dm_mem(myid))
      IF(bdc_m2_mem.AND.remove_node_flag_mem)THEN
         IF(dble(inc_mem).NE.remove_node_cost_mem)THEN
            IF(dble(inc_mem).GT.remove_node_cost_mem)THEN
               delta_mem = delta_mem +
     &              (dble(inc_mem)-remove_node_cost_mem)
               GOTO 888               
            ELSE
               delta_mem = delta_mem -
     &              (remove_node_cost_mem-dble(inc_mem))
               GOTO 888
            ENDIF
         ENDIF
         GOTO 333
      ENDIF
      delta_mem = delta_mem + dble(inc_mem)
 888  CONTINUE
      IF ((keep(48).NE.5).OR.
     &     ((keep(48).EQ.5).AND.(abs(delta_mem)
     &      .GE.0.2d0*dble(lrlus))))THEN
         IF ( abs(delta_mem) > dm_thres_mem ) THEN
            send_mem = delta_mem
 111        CONTINUE
            CALL dmumps_buf_send_update_load( 
     &           bdc_sbtr,
     &           bdc_mem,bdc_md, comm_ld,
     &           nprocs,
     &           delta_load,
     &           send_mem,sbtr_tmp,
     &           dm_sumlu,
     &           future_niv2,
     &           myid, keep, ierr )
            IF ( ierr == -1 )THEN
              CALL dmumps_load_recv_msgs(comm_ld)
              CALL mumps_check_comm_nodes(comm_nodes, exit_flag)
              IF (exit_flag) THEN
                GOTO 333
              ELSE
                GOTO 111
              ENDIF
            ELSE IF ( ierr .NE. 0 ) THEN
              WRITE(*,*) "Internal Error in DMUMPS_LOAD_MEM_UPDATE",ierr
              CALL mumps_abort()
            ENDIF
            delta_load = zero
            delta_mem  = zero
         ENDIF
      ENDIF
 333  CONTINUE
      IF(remove_node_flag_mem)THEN
         remove_node_flag_mem=.false.
      ENDIF
      END SUBROUTINE dmumps_load_mem_update
      INTEGER FUNCTION dmumps_load_less( K69, MEM_DISTRIB,MSG_SIZE )
      IMPLICIT NONE
      INTEGER i, nless, k69 
      INTEGER, DIMENSION(0:NPROCS-1) :: mem_distrib
      DOUBLE PRECISION lref
      DOUBLE PRECISION msg_size
      nless = 0
      do i=1,nprocs
         idwload(i) = i - 1
      ENDDO
      wload(1:nprocs) = load_flops(0:nprocs-1)
      IF(bdc_m2_flops)THEN
         DO i=1,nprocs
            wload(i)=wload(i)+niv2(i)
         ENDDO
      ENDIF
      IF(k69 .gt. 1) THEN
         CALL dmumps_archgenwload(mem_distrib,msg_size,idwload,nprocs)
      ENDIF
      lref = load_flops(myid)
      DO i=1, nprocs
         IF (wload(i).LT.lref) nless=nless+1
      ENDDO
      dmumps_load_less = nless
      RETURN
      END FUNCTION dmumps_load_less
      SUBROUTINE dmumps_load_set_slaves(MEM_DISTRIB,MSG_SIZE,DEST,
     &     NSLAVES)
      IMPLICIT NONE
      INTEGER nslaves
      INTEGER dest(nslaves)
      INTEGER, DIMENSION(0:NPROCS - 1) :: mem_distrib
      INTEGER i,j,nbdest
      DOUBLE PRECISION msg_size
      IF ( nslaves.eq.nprocs-1 ) THEN
        j = myid+1
        DO i=1,nslaves
           j=j+1
           IF (j.GT.nprocs) j=1
           dest(i) = j - 1
        ENDDO
      ELSE
        DO i=1,nprocs
           idwload(i) = i - 1
        ENDDO
        CALL mumps_sort_doubles(nprocs, wload, idwload)
         nbdest = 0
         DO i=1, nslaves
            j = idwload(i)
            IF (j.NE.myid) THEN
               nbdest = nbdest+1
               dest(nbdest) = j
            ENDIF
         ENDDO
         IF (nbdest.NE.nslaves) THEN
            dest(nslaves) = idwload(nslaves+1)
         ENDIF
         IF(bdc_md)THEN
            j=nslaves+1
            do i=nslaves+1,nprocs
               IF(idwload(i).NE.myid)THEN
                  dest(j)= idwload(i)
                  j=j+1
               ENDIF
            end do
         ENDIF
      ENDIF
      RETURN
      END SUBROUTINE dmumps_load_set_slaves
      SUBROUTINE dmumps_load_end( INFO1, NSLAVES, IERR )
      USE dmumps_buf
      USE mumps_future_niv2
      IMPLICIT NONE
      INTEGER, INTENT(IN)  :: info1
      INTEGER, INTENT(IN)  :: nslaves
      INTEGER, INTENT(OUT) :: ierr
      INTEGER :: dummy_communicator
      ierr=0
      dummy_communicator = -999 
      CALL dmumps_clean_pending( info1, keep_load(1), buf_load_recv(1),
     &     lbuf_load_recv,
     &     lbuf_load_recv_bytes, dummy_communicator, comm_ld,
     &     nslaves,
     &     .false.,  
     &     .true.    
     &     )
      DEALLOCATE( load_flops )
      DEALLOCATE( wload )
      DEALLOCATE( idwload )
      DEALLOCATE(future_niv2)
      IF(bdc_md)THEN
         DEALLOCATE(md_mem)
         DEALLOCATE(lu_usage)
         DEALLOCATE(tab_maxs)
      ENDIF
      IF ( bdc_mem ) DEALLOCATE( dm_mem )
      IF ( bdc_pool) DEALLOCATE( pool_mem )
      IF ( bdc_sbtr) THEN
         DEALLOCATE( sbtr_mem )
         DEALLOCATE( sbtr_cur )
         DEALLOCATE(sbtr_first_pos_in_pool)
         NULLIFY(my_first_leaf)
         NULLIFY(my_nb_leaf)
         NULLIFY(my_root_sbtr)
      ENDIF
      IF(keep_load(76).EQ.4)THEN
         NULLIFY(depth_first_load)
      ENDIF
      IF(keep_load(76).EQ.5)THEN
         NULLIFY(cost_trav)
      ENDIF
      IF((keep_load(76).EQ.4).OR.(keep_load(76).EQ.6))THEN
         NULLIFY(depth_first_load)
         NULLIFY(depth_first_seq_load)
         NULLIFY(sbtr_id_load)
      ENDIF
      IF (bdc_m2_mem.OR.bdc_m2_flops) THEN
        DEALLOCATE(nb_son,pool_niv2,pool_niv2_cost, niv2)
      END IF
      IF((keep_load(81).EQ.2).OR.(keep_load(81).EQ.3))THEN
         DEALLOCATE(cb_cost_mem)
         DEALLOCATE(cb_cost_id)
      ENDIF
      NULLIFY(nd_load)
      NULLIFY(keep_load)
      NULLIFY(keep8_load)
      NULLIFY(fils_load)
      NULLIFY(frere_load)
      NULLIFY(procnode_load)
      NULLIFY(step_load)
      NULLIFY(ne_load)
      NULLIFY(cand_load)
      NULLIFY(step_to_niv2_load)
      NULLIFY(dad_load)
      IF (bdc_sbtr.OR.bdc_pool_mng) THEN
         DEALLOCATE(mem_subtree)
         DEALLOCATE(sbtr_peak_array)
         DEALLOCATE(sbtr_cur_array)
      ENDIF
      CALL dmumps_buf_deall_load_buffer( ierr )
      DEALLOCATE(buf_load_recv)
      RETURN
      END SUBROUTINE dmumps_load_end
      RECURSIVE SUBROUTINE dmumps_load_recv_msgs(COMM)
      IMPLICIT NONE
      include 'mpif.h'
      include 'mumps_tags.h'
      INTEGER msgtag, msglen, msgsou,comm
      INTEGER ierr_mpi
      INTEGER :: status(mpi_status_size)
      LOGICAL flag
 10   CONTINUE
      CALL mpi_iprobe( mpi_any_source, mpi_any_tag, comm,
     &     flag, status, ierr_mpi )
      IF (flag) THEN
        keep_load(65)=keep_load(65)+1
        keep_load(267)=keep_load(267)-1
        msgtag = status( mpi_tag )
        msgsou = status( mpi_source )
        IF ( msgtag .NE. update_load) THEN
          write(*,*) "Internal error 1 in DMUMPS_LOAD_RECV_MSGS",
     &    msgtag
          CALL mumps_abort()
        ENDIF
        CALL mpi_get_count(status, mpi_packed, msglen, ierr_mpi)
        IF ( msglen > lbuf_load_recv_bytes ) THEN
          write(*,*) "Internal error 2 in DMUMPS_LOAD_RECV_MSGS",
     &    msglen, lbuf_load_recv_bytes
          CALL mumps_abort()
        ENDIF
        CALL mpi_recv( buf_load_recv, lbuf_load_recv_bytes,
     &    mpi_packed, msgsou, msgtag, comm_ld, status, ierr_mpi)
        CALL dmumps_load_process_message( msgsou, buf_load_recv,
     &  lbuf_load_recv, lbuf_load_recv_bytes )
        GOTO 10
      ENDIF
      RETURN
      END SUBROUTINE dmumps_load_recv_msgs
      RECURSIVE SUBROUTINE dmumps_load_process_message
     &   ( msgsou, bufr, lbufr, lbufr_bytes )
      USE mumps_future_niv2
      IMPLICIT NONE
      INTEGER MSGSOU, lbufr, lbufr_bytes
      INTEGER bufr( lbufr )
      include 'mpif.h'
      INTEGER position, what, nslaves, i
      INTEGER ierr_mpi
      DOUBLE PRECISION load_received
      INTEGER inode_received,ncb_received
      DOUBLE PRECISION surf
      INTEGER, POINTER, DIMENSION (:) :: list_slaves
      DOUBLE PRECISION, POINTER, DIMENSION (:) :: load_incr
      EXTERNAL mumps_typenode
      INTEGER mumps_typenode
      position = 0
      CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     what, 1, mpi_integer,
     &     comm_ld, ierr_mpi )
      IF ( what == 0 ) THEN
        CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     load_received, 1,
     &     mpi_double_precision,
     &     comm_ld, ierr_mpi )
      load_flops( msgsou ) = load_flops(msgsou) + load_received
        IF ( bdc_mem ) THEN
          CALL mpi_unpack( bufr, lbufr_bytes, position,
     &       load_received, 1, mpi_double_precision,
     &       comm_ld, ierr_mpi )
          dm_mem(msgsou)  = dm_mem(msgsou) + load_received
          max_peak_stk=max(max_peak_stk,dm_mem(msgsou))
        END IF
        IF(bdc_sbtr)THEN
          CALL mpi_unpack( bufr, lbufr_bytes, position,
     &       load_received, 1, mpi_double_precision,
     &       comm_ld, ierr_mpi )
          sbtr_cur(msgsou)=load_received
        ENDIF
        IF(bdc_md)THEN
           CALL mpi_unpack( bufr, lbufr_bytes, position,
     &          load_received, 1, mpi_double_precision,
     &          comm_ld, ierr_mpi )
           IF(keep_load(201).EQ.0)THEN
              lu_usage(msgsou)=load_received
           ENDIF
        ENDIF
      ELSEIF (( what == 1).OR.(what.EQ.19)) THEN
        CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     nslaves, 1, mpi_integer,
     &     comm_ld, ierr_mpi )
        CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     inode_received, 1, mpi_integer,
     &     comm_ld, ierr_mpi )
        list_slaves => idwload
        load_incr => wload
        CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     list_slaves(1), nslaves, mpi_integer,
     &     comm_ld, ierr_mpi)
        CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     load_incr(1), nslaves, mpi_double_precision,
     &     comm_ld, ierr_mpi)
        DO i = 1, nslaves
            load_flops(list_slaves(i)) =
     &      load_flops(list_slaves(i)) + 
     &      load_incr(i)
        END DO
        IF ( bdc_mem ) THEN
          CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     load_incr(1), nslaves, mpi_double_precision,
     &     comm_ld, ierr_mpi)
          DO i = 1, nslaves
              dm_mem(list_slaves(i)) = dm_mem(list_slaves(i)) + 
     &        load_incr(i)
              max_peak_stk=max(max_peak_stk,dm_mem(list_slaves(i)))
          END DO
        END IF
        IF(what.EQ.19)THEN
           CALL mpi_unpack( bufr, lbufr_bytes, position,
     &          load_incr(1), nslaves, mpi_double_precision,
     &          comm_ld, ierr_mpi)
           CALL dmumps_load_clean_meminfo_pool(inode_received)
           cb_cost_id(pos_id)=inode_received
           cb_cost_id(pos_id+1)=nslaves
           cb_cost_id(pos_id+2)=pos_mem
           pos_id=pos_id+3
           DO i=1,nslaves
              WRITE(*,*)myid,':',list_slaves(i),'->',load_incr(i)
              cb_cost_mem(pos_mem)=int(list_slaves(i),8)
              pos_mem=pos_mem+1
              cb_cost_mem(pos_mem)=int(load_incr(i),8)
              pos_mem=pos_mem+1
           ENDDO
        ENDIF
        NULLIFY( list_slaves )
        NULLIFY( load_incr )
      ELSE IF (what == 2 ) THEN
         IF ( .not. bdc_pool ) THEN
          WRITE(*,*) "Internal error 2 in DMUMPS_LOAD_PROCESS_MESSAGE"
          CALL mumps_abort()
        END IF
        CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     load_received, 1,
     &     mpi_double_precision,
     &     comm_ld, ierr_mpi )
        pool_mem(msgsou)=load_received
      ELSE IF ( what == 3 ) THEN
         IF ( .NOT. bdc_sbtr) THEN
          WRITE(*,*) "Internal error 3 in DMUMPS_LOAD_PROCESS_MESSAGE"
          CALL mumps_abort()
        ENDIF
        CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     load_received, 1,
     &     mpi_double_precision,
     &     comm_ld, ierr_mpi )
        sbtr_mem(msgsou)=sbtr_mem(msgsou)+load_received
      ELSE IF (what == 4) THEN
        future_niv2(msgsou+1)=0
        IF(bdc_md)THEN
           CALL mpi_unpack( bufr, lbufr_bytes, position,
     &          surf, 1, mpi_double_precision,
     &          comm_ld, ierr_mpi )
          md_mem(msgsou)=999999999_8
          tab_maxs(msgsou)=tab_maxs(msgsou)+int(surf,8)
        ENDIF
        IF(bdc_m2_mem.OR.bdc_m2_flops)THEN
        ENDIF
      ELSE IF (what == 5) THEN
         IF((.NOT.bdc_m2_mem).AND.(.NOT.bdc_m2_flops))THEN
            WRITE(*,*) "Internal error 7 in DMUMPS_LOAD_PROCESS_MESSAGE"
            CALL mumps_abort()
         ENDIF
         CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     inode_received, 1,
     &     mpi_integer,
     &     comm_ld, ierr_mpi )
         IF(bdc_m2_mem) THEN
            CALL dmumps_process_niv2_mem_msg(inode_received)
         ELSEIF(bdc_m2_flops) THEN
            CALL dmumps_process_niv2_flops_msg(inode_received)
         ENDIF
         IF((keep_load(81).EQ.2).OR.(keep_load(81).EQ.3))THEN
            CALL mpi_unpack( bufr, lbufr_bytes, position,
     &           inode_received, 1,
     &           mpi_integer,
     &           comm_ld, ierr_mpi )   
               CALL mpi_unpack( bufr, lbufr_bytes, position,
     &              ncb_received, 1,
     &              mpi_integer,
     &              comm_ld, ierr_mpi )   
            IF(
     &          mumps_typenode(procnode_load(step_load(inode_received)),
     &                         keep_load(199)).EQ.1
     &        )THEN
               cb_cost_id(pos_id)=inode_received
               cb_cost_id(pos_id+1)=1
               cb_cost_id(pos_id+2)=pos_mem
               pos_id=pos_id+3
               cb_cost_mem(pos_mem)=int(msgsou,8)
               pos_mem=pos_mem+1
               cb_cost_mem(pos_mem)=int(ncb_received,8)*
     &              int(ncb_received,8)
               pos_mem=pos_mem+1
            ENDIF
         ENDIF
      ELSE IF ( what == 6 ) THEN
         IF((.NOT.bdc_m2_mem).AND.(.NOT.bdc_m2_flops))THEN
            WRITE(*,*) "Internal error 8 in DMUMPS_LOAD_PROCESS_MESSAGE"
            CALL mumps_abort()
         ENDIF
         CALL mpi_unpack( bufr, lbufr_bytes, position,
     &     load_received, 1,
     &     mpi_double_precision,
     &     comm_ld, ierr_mpi )
         IF(bdc_m2_mem) THEN
            niv2(msgsou+1) = load_received
         ELSEIF(bdc_m2_flops) THEN
            niv2(msgsou+1) = niv2(msgsou+1) + load_received
            IF(niv2(msgsou+1).LT.0.0d0)THEN
               IF(abs(niv2(msgsou+1)) .LE. 1.0d-3) THEN
                  niv2(msgsou+1)=0.0d0
               ELSE
                  WRITE(*,*)'problem with niv2_flops message',
     &                 NIV2(MSGSOU+1),MSGSOU,LOAD_RECEIVED
                  CALL MUMPS_ABORT()
               ENDIF
            ENDIF
         ENDIF
      ELSEIF(WHAT == 17)THEN
         CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &     LOAD_RECEIVED, 1,
     &     MPI_DOUBLE_PRECISION,
     &     COMM_LD, IERR_MPI )
         IF(BDC_M2_MEM) THEN
            NIV2(MSGSOU+1) = LOAD_RECEIVED
            CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &           LOAD_RECEIVED, 1,
     &           MPI_DOUBLE_PRECISION,
     &           COMM_LD, IERR_MPI )
            IF(BDC_MD)THEN
               DM_MEM(MYID)=DM_MEM(MYID)+LOAD_RECEIVED
            ELSEIF(BDC_POOL)THEN
               POOL_MEM(MSGSOU)=LOAD_RECEIVED
            ENDIF
         ELSEIF(BDC_M2_FLOPS) THEN
            NIV2(MSGSOU+1) = NIV2(MSGSOU+1) + LOAD_RECEIVED            
.LT.            IF(NIV2(MSGSOU+1)0.0D0)THEN
.LE.               IF(abs(NIV2(MSGSOU+1))  1.0D-3) THEN
                  NIV2(MSGSOU+1)=0.0D0
               ELSE
                  WRITE(*,*)'problem with niv2_flops message',
     &                 NIV2(MSGSOU+1),MSGSOU,LOAD_RECEIVED
                  CALL MUMPS_ABORT()
               ENDIF
            ENDIF
            CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &           LOAD_RECEIVED, 1,
     &           MPI_DOUBLE_PRECISION,
     &           COMM_LD, IERR_MPI )
            LOAD_FLOPS( MSGSOU ) = LOAD_FLOPS(MSGSOU) + LOAD_RECEIVED
         ENDIF
      ELSEIF ( WHAT == 7 ) THEN
.NOT.         IF(BDC_MD)THEN
            WRITE(*,*)MYID,': internal error 4
     &in dmumps_load_process_message'
            CALL MUMPS_ABORT()
         ENDIF
        CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &     NSLAVES, 1, MPI_INTEGER,
     &     COMM_LD, IERR_MPI )
        CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &     INODE_RECEIVED, 1, MPI_INTEGER,
     &     COMM_LD, IERR_MPI )
        LIST_SLAVES => IDWLOAD
        LOAD_INCR => WLOAD
        CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &     LIST_SLAVES(1), NSLAVES, MPI_INTEGER,
     &     COMM_LD, IERR_MPI )
        CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &     LOAD_INCR(1), NSLAVES, MPI_DOUBLE_PRECISION,
     &     COMM_LD, IERR_MPI )
        DO i = 1, NSLAVES
            MD_MEM(LIST_SLAVES(i)) =
     &      MD_MEM(LIST_SLAVES(i)) + 
     &      int(LOAD_INCR(i),8)
.EQ.            IF(FUTURE_NIV2(LIST_SLAVES(i)+1)0)THEN
               MD_MEM(LIST_SLAVES(i))=999999999_8
            ENDIF
        END DO
      ELSEIF ( WHAT == 8 ) THEN
.NOT.         IF(BDC_MD)THEN
            WRITE(*,*)MYID,': internal error 5
     &in dmumps_load_process_message'
            CALL MUMPS_ABORT()
         ENDIF
        CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &     LOAD_RECEIVED, 1,
     &     MPI_DOUBLE_PRECISION,
     &     COMM_LD, IERR_MPI )
        MD_MEM(MSGSOU)=MD_MEM(MSGSOU)+int(LOAD_RECEIVED,8)
.EQ.        IF(FUTURE_NIV2(MSGSOU+1)0)THEN
           MD_MEM(MSGSOU)=999999999_8
        ENDIF
      ELSEIF ( WHAT == 9 ) THEN
.NOT.         IF(BDC_MD)THEN
            WRITE(*,*)MYID,': internal error 6
     &in dmumps_load_process_message'
            CALL MUMPS_ABORT()
         ENDIF
        CALL MPI_UNPACK( BUFR, LBUFR_BYTES, POSITION,
     &     LOAD_RECEIVED, 1,
     &     MPI_DOUBLE_PRECISION,
     &     COMM_LD, IERR_MPI )
        TAB_MAXS(MSGSOU)=int(LOAD_RECEIVED,8)
      ELSE
          WRITE(*,*) "Internal error 1 in DMUMPS_LOAD_PROCESS_MESSAGE"
          CALL MUMPS_ABORT()
      END IF
      RETURN
      END SUBROUTINE DMUMPS_LOAD_PROCESS_MESSAGE
      integer function DMUMPS_LOAD_LESS_CAND
     &                 (MEM_DISTRIB,CAND,
     &                  K69,
     &                  SLAVEF,MSG_SIZE,
     &                  NMB_OF_CAND )
      implicit none      
      integer, intent(in) :: K69, SLAVEF
      INTEGER, intent(in) :: CAND(SLAVEF+1)
      INTEGER, DIMENSION(0:NPROCS - 1), intent(in) :: MEM_DISTRIB
      INTEGER, intent(out) :: NMB_OF_CAND
      integer i,nless
      DOUBLE PRECISION lref
      DOUBLE PRECISION MSG_SIZE
      nless = 0 
      NMB_OF_CAND=CAND(SLAVEF+1)
      do i=1,NMB_OF_CAND
         WLOAD(i)=LOAD_FLOPS(CAND(i))
         IF(BDC_M2_FLOPS)THEN
            WLOAD(i)=WLOAD(i)+NIV2(CAND(i)+1)
         ENDIF
      end do
.gt.      IF(K69  1) THEN
         CALL DMUMPS_ARCHGENWLOAD(MEM_DISTRIB,MSG_SIZE,
     &        CAND,NMB_OF_CAND)
      ENDIF
      lref = LOAD_FLOPS(MYID)
      do i=1, NMB_OF_CAND
.lt.         if (WLOAD(i)lref) nless=nless+1
      end do 
      DMUMPS_LOAD_LESS_CAND = nless
      return
      end function DMUMPS_LOAD_LESS_CAND
      subroutine DMUMPS_LOAD_SET_SLAVES_CAND
     &           (MEM_DISTRIB,CAND, 
     &
     &            SLAVEF,
     &            nslaves_inode, DEST)
      implicit none
      integer, intent(in) :: nslaves_inode, SLAVEF
      integer, intent(in) :: CAND(SLAVEF+1)
      integer, dimension(0:NPROCS - 1), intent(in) :: MEM_DISTRIB
      integer, intent(out) :: DEST(CAND(SLAVEF+1))
      integer i,j,NMB_OF_CAND
      external MUMPS_SORT_DOUBLES
      NMB_OF_CAND = CAND(SLAVEF+1)
.ge..or.      if(nslaves_inodeNPROCS 
.gt.     &     nslaves_inodeNMB_OF_CAND) then
         write(*,*)'internal error in dmumps_load_set_slaves_cand',
     &   nslaves_inode, NPROCS, NMB_OF_CAND
         CALL MUMPS_ABORT()
      end if
.eq.      if (nslaves_inodeNPROCS-1) then
         j=MYID+1
         do i=1,nslaves_inode
.ge.            if(jNPROCS) j=0
            DEST(i)=j
            j=j+1
         end do
      else
        do i=1,NMB_OF_CAND
               IDWLOAD(i)=i
        end do
        call MUMPS_SORT_DOUBLES(NMB_OF_CAND,
     &       WLOAD(1),IDWLOAD(1) )
        do i=1,nslaves_inode
           DEST(i)= CAND(IDWLOAD(i))
        end do
        IF(BDC_MD)THEN
           do i=nslaves_inode+1,NMB_OF_CAND
              DEST(i)= CAND(IDWLOAD(i))
           end do
        ENDIF
      end if   
      return
      end subroutine DMUMPS_LOAD_SET_SLAVES_CAND
      SUBROUTINE DMUMPS_INIT_ALPHA_BETA(K69)
      IMPLICIT NONE
      INTEGER K69
.LE.      IF (K69  4) THEN
         ALPHA = 0.0d0
         BETA = 0.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  5) THEN
         ALPHA = 0.5d0
         BETA = 50000.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  6) THEN
         ALPHA = 0.5d0
         BETA = 100000.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  7) THEN
         ALPHA = 0.5d0
         BETA = 150000.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  8) THEN
         ALPHA = 1.0d0
         BETA = 50000.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  9) THEN
         ALPHA = 1.0d0
         BETA = 100000.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  10) THEN
         ALPHA = 1.0d0
         BETA = 150000.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  11) THEN
         ALPHA = 1.5d0
         BETA = 50000.0d0
         RETURN
      ENDIF
.EQ.      IF (K69  12) THEN
         ALPHA = 1.5d0
         BETA = 100000.0d0
         RETURN
      ENDIF
      ALPHA = 1.5d0
      BETA = 150000.0d0
      RETURN
      END SUBROUTINE DMUMPS_INIT_ALPHA_BETA
      SUBROUTINE DMUMPS_ARCHGENWLOAD(MEM_DISTRIB,MSG_SIZE,ARRAY_ADM,LEN)
      IMPLICIT NONE
      INTEGER i,LEN
      INTEGER, DIMENSION(0:NPROCS-1) :: MEM_DISTRIB
      DOUBLE PRECISION MSG_SIZE,FORBIGMSG
      INTEGER ARRAY_ADM(LEN)
      DOUBLE PRECISION MY_LOAD
      FORBIGMSG = 1.0d0
.lt.      IF (K69 2) THEN
         RETURN
      ENDIF
      IF(BDC_M2_FLOPS)THEN
         MY_LOAD=LOAD_FLOPS(MYID)+NIV2(MYID+1)
      ELSE
         MY_LOAD=LOAD_FLOPS(MYID)
      ENDIF
.gt.      IF((MSG_SIZE * dble(K35) )  3200000.0d0) THEN
         FORBIGMSG = 2.0d0
      ENDIF
.le.      IF (K69  4) THEN
         DO i = 1,LEN
.EQ..AND.            IF ((MEM_DISTRIB(ARRAY_ADM(i))  1) 
.LT.     &      WLOAD(i)  MY_LOAD ) THEN
               WLOAD(i) = WLOAD(i)/MY_LOAD
            ELSE
.NE.              IF ( MEM_DISTRIB(ARRAY_ADM(i))  1 ) THEN
                WLOAD(i) = WLOAD(i) *
     &              dble(MEM_DISTRIB(ARRAY_ADM(i)))
     &              * FORBIGMSG
     &              + dble(2)
              ENDIF
            ENDIF
         ENDDO
         RETURN
      ENDIF
      DO i = 1,LEN
.EQ..AND.         IF ((MEM_DISTRIB(ARRAY_ADM(i))  1) 
.LT.     &        WLOAD(i)  MY_LOAD ) THEN
            WLOAD(i) = WLOAD(i) /  MY_LOAD
         ELSE
.NE.            IF(MEM_DISTRIB(ARRAY_ADM(i))  1) THEN     
               WLOAD(i) = (WLOAD(i) +
     &              ALPHA * MSG_SIZE * dble(K35)  +
     &              BETA) * FORBIGMSG
            ENDIF
         ENDIF
      ENDDO  
      RETURN
      END SUBROUTINE DMUMPS_ARCHGENWLOAD
      SUBROUTINE DMUMPS_LOAD_MASTER_2_ALL(MYID, SLAVEF, COMM,
     &     TAB_POS, NASS, KEEP,KEEP8, LIST_SLAVES, NSLAVES,INODE)
      USE DMUMPS_BUF
      USE MUMPS_FUTURE_NIV2
      IMPLICIT NONE
      INTEGER, INTENT (IN) :: MYID, SLAVEF, COMM, NASS, NSLAVES
      INTEGER, INTENT (IN) :: TAB_POS(SLAVEF+2)
      INTEGER, INTENT (IN) :: LIST_SLAVES( NSLAVES )
      INTEGER KEEP(500)
      INTEGER(8) KEEP8(150)
      INTEGER NCB, NFRONT, NBROWS_SLAVE
      INTEGER i, IERR,WHAT,INODE, allocok
      LOGICAL :: EXIT_FLAG
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: MEM_INCREMENT
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: FLOPS_INCREMENT
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: CB_BAND
      ALLOCATE(MEM_INCREMENT(NSLAVES), stat=allocok)
.ne.      if(allocok0) then
         WRITE(6,*) ' allocation error of mem_increment '
     &        //  'in routine dmumps_load_master_2_all'
         CALL MUMPS_ABORT()
      endif
      ALLOCATE(FLOPS_INCREMENT(NSLAVES), stat=allocok)
.ne.      if(allocok0) then
         WRITE(6,*) ' allocation error of flops_increment '
     &        //    'in routine dmumps_load_master_2_all'
         CALL MUMPS_ABORT()
      endif
      ALLOCATE(CB_BAND(NSLAVES), stat=allocok)
.ne.      if(allocok0) then
         WRITE(6,*) ' allocation error of cb_band '
     &        //    'in routine dmumps_load_master_2_all'
         CALL MUMPS_ABORT()
      endif
.NE..AND..NE.      IF((KEEP(81)2)(KEEP(81)3))THEN
         WHAT=1
      ELSE
         WHAT=19
      ENDIF
      FUTURE_NIV2(MYID+1) = FUTURE_NIV2(MYID+1) - 1
      IF ( FUTURE_NIV2(MYID+1) < 0 ) THEN
        WRITE(*,*) "Internal error in DMUMPS_LOAD_MASTER_2_ALL"
        CALL MUMPS_ABORT()
      ENDIF
      IF ( FUTURE_NIV2(MYID + 1) == 0 ) THEN
 112    CONTINUE
        CALL DMUMPS_BUF_SEND_NOT_MSTR(COMM,MYID,SLAVEF,
     &       dble(MAX_SURF_MASTER),KEEP,IERR)
        IF (IERR == -1 ) THEN
          CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
          CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
          IF (EXIT_FLAG) THEN
             GOTO 100 
          ELSE
             GOTO 112
          ENDIF
.NE.       ELSE IF ( IERR  0 ) THEN
          WRITE(*,*) "Internal Error in DMUMPS_LOAD_MASTER_2_ALL",
     &    IERR
          CALL MUMPS_ABORT()
        ENDIF
      TAB_MAXS(MYID) = TAB_MAXS(MYID) + int(MAX_SURF_MASTER,8)
      ENDIF
      IF ( NSLAVES /= TAB_POS(SLAVEF + 2) ) THEN
        write(*,*) "Error 1 in DMUMPS_LOAD_MASTER_2_ALL",
     &             NSLAVES, TAB_POS(SLAVEF+2)
        CALL MUMPS_ABORT()
      ENDIF
      NCB = TAB_POS(NSLAVES+1) - 1
      NFRONT = NCB + NASS
      DO i = 1, NSLAVES
         NBROWS_SLAVE = TAB_POS(i+1) - TAB_POS(i)
         IF ( KEEP(50) == 0 ) THEN
            FLOPS_INCREMENT( i ) = (dble(NBROWS_SLAVE)*dble( NASS ))+
     &           dble(NBROWS_SLAVE) * dble(NASS) *
     &           dble(2*NFRONT-NASS-1)
         ELSE
            FLOPS_INCREMENT( i ) = dble(NBROWS_SLAVE) * dble(NASS ) *
     &           dble( 2 * ( NASS + TAB_POS(i+1) - 1 ) 
     &           - NBROWS_SLAVE - NASS + 1 )
         ENDIF
         IF ( BDC_MEM ) THEN
            IF ( KEEP(50) == 0 ) THEN
               MEM_INCREMENT( i ) = dble(NBROWS_SLAVE) *
     &              dble(NFRONT)
            ELSE
               MEM_INCREMENT( i ) = dble(NBROWS_SLAVE) *
     &              dble( NASS + TAB_POS(i+1) - 1 )
            END IF
         ENDIF
.NE..AND..NE.         IF((KEEP(81)2)(KEEP(81)3))THEN
            CB_BAND(i)=dble(-999999)
         ELSE
            IF ( KEEP(50) == 0 ) THEN
               CB_BAND( i ) = dble(NBROWS_SLAVE) *
     &              dble(NFRONT-NASS)
            ELSE
               CB_BAND( i ) = dble(NBROWS_SLAVE) *
     &              dble(TAB_POS(i+1)-1)
            END IF
         ENDIF
      END DO
.EQ..OR..EQ.      IF((KEEP(81)2)(KEEP(81)3))THEN
         CB_COST_ID(POS_ID)=INODE
         CB_COST_ID(POS_ID+1)=NSLAVES
         CB_COST_ID(POS_ID+2)=POS_MEM
         POS_ID=POS_ID+3
         DO i=1,NSLAVES
            CB_COST_MEM(POS_MEM)=int(LIST_SLAVES(i),8)
            POS_MEM=POS_MEM+1
            CB_COST_MEM(POS_MEM)=int(CB_BAND(i),8)
            POS_MEM=POS_MEM+1
         ENDDO
      ENDIF
 111  CONTINUE
      CALL DMUMPS_BUF_BCAST_ARRAY(BDC_MEM, COMM, MYID, SLAVEF,
     &     FUTURE_NIV2,
     &     NSLAVES, LIST_SLAVES,INODE,
     &     MEM_INCREMENT,
     &     FLOPS_INCREMENT,CB_BAND, WHAT, KEEP, IERR)
        IF ( IERR == -1 ) THEN
          CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
          CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
          IF (EXIT_FLAG) THEN
             GOTO 100
           ELSE
             GOTO 111
           ENDIF
.NE.       ELSE IF ( IERR  0 ) THEN
          WRITE(*,*) "Internal Error in DMUMPS_LOAD_MASTER_2_ALL",
     &    IERR
          CALL MUMPS_ABORT()
        ENDIF
.NE.      IF (FUTURE_NIV2(MYID+1)  0) THEN
        DO i = 1, NSLAVES
          LOAD_FLOPS(LIST_SLAVES(i)) = LOAD_FLOPS(LIST_SLAVES(i))
     &       +  FLOPS_INCREMENT(i)
          IF ( BDC_MEM ) THEN
            DM_MEM(LIST_SLAVES(i)) = DM_MEM(LIST_SLAVES(i))
     &       +  MEM_INCREMENT(i)
          END IF
        ENDDO
      ENDIF
 100  CONTINUE
      DEALLOCATE(MEM_INCREMENT,FLOPS_INCREMENT,CB_BAND)
      RETURN
      END SUBROUTINE DMUMPS_LOAD_MASTER_2_ALL
      SUBROUTINE DMUMPS_LOAD_POOL_UPD_NEW_POOL(
     &     POOL, LPOOL,
     &     PROCNODE, KEEP,KEEP8, SLAVEF, COMM, MYID, STEP, N,
     &     ND, FILS )
      USE DMUMPS_BUF
      USE MUMPS_FUTURE_NIV2
      IMPLICIT NONE
      INTEGER LPOOL, SLAVEF, COMM, MYID 
      INTEGER N, KEEP(500)
      INTEGER(8) KEEP8(150)
      INTEGER POOL( LPOOL ), PROCNODE( KEEP(28) ), STEP( N )
      INTEGER ND( KEEP(28) ), FILS( N )
      INTEGER i, INODE, NELIM, NFR, LEVEL, IERR, WHAT
      DOUBLE PRECISION COST
      LOGICAL :: EXIT_FLAG
      INTEGER NBINSUBTREE,NBTOP,INSUBTREE
      INTEGER MUMPS_TYPENODE
      EXTERNAL MUMPS_TYPENODE
      NBINSUBTREE = POOL(LPOOL)
      NBTOP       = POOL(LPOOL - 1)
      INSUBTREE   = POOL(LPOOL - 2)
      IF(BDC_MD)THEN
         RETURN
      ENDIF
.EQ..OR..EQ.      IF((KEEP(76)0)(KEEP(76)2))THEN
.NE.         IF(NBTOP0)THEN
            DO i = LPOOL-NBTOP-2, min(LPOOL-3,LPOOL-NBTOP-2+3)
               INODE = POOL( i )
.LE..AND..GE.               IF (INODE  N  INODE  1 ) THEN
                  GOTO 20
               END IF
            END DO
            COST=dble(0) 
            GOTO 30
         ELSE
            DO i = NBINSUBTREE, max(1,NBINSUBTREE-3), -1
               INODE = POOL( i )
.LE..AND..GE.               IF (INODE  N  INODE  1 ) THEN
                  GOTO 20
               END IF
            END DO
            COST=dble(0) 
            GOTO 30
         ENDIF
      ELSE
.EQ.         IF(KEEP(76)1)THEN
.EQ.            IF(INSUBTREE1)THEN
               DO i = NBINSUBTREE, max(1,NBINSUBTREE-3), -1
                  INODE = POOL( i )
.LE..AND..GE.                  IF (INODE  N  INODE  1 ) THEN
                     GOTO 20
                  END IF
               END DO
               COST=dble(0) 
               GOTO 30
            ELSE
               DO i = LPOOL-NBTOP-2, min(LPOOL-3,LPOOL-NBTOP-2+3)
                  INODE = POOL( i )
.LE..AND..GE.                  IF (INODE  N  INODE  1 ) THEN
                     GOTO 20
                  END IF
               END DO
               COST=dble(0) 
               GOTO 30
            ENDIF
         ELSE
            WRITE(*,*)
     &      'internal error: unknown pool management strategy'
            CALL MUMPS_ABORT()
         ENDIF
      ENDIF
 20   CONTINUE
        i = INODE
        NELIM = 0
 10     CONTINUE
        IF ( i > 0 ) THEN
          NELIM = NELIM + 1
          i = FILS(i)
          GOTO 10
        ENDIF
        NFR = ND( STEP(INODE) )
        LEVEL = MUMPS_TYPENODE( PROCNODE(STEP(INODE)), KEEP(199) )
.EQ.        IF (LEVEL  1) THEN
          COST = dble( NFR ) * dble( NFR )
        ELSE
          IF ( KEEP(50) == 0 ) THEN
            COST = dble( NFR ) * dble( NELIM )
          ELSE
            COST = dble( NELIM ) * dble( NELIM )
          ENDIF
        ENDIF
 30   CONTINUE
.GT.      IF ( abs(POOL_LAST_COST_SENT-COST)DM_THRES_MEM ) THEN
        WHAT = 2
 111    CONTINUE
        CALL DMUMPS_BUF_BROADCAST( WHAT,
     &         COMM, SLAVEF,
     &               FUTURE_NIV2,
     &         COST, dble(0), MYID, KEEP, IERR  )
        POOL_LAST_COST_SENT = COST
        POOL_MEM(MYID)=COST
        IF ( IERR == -1 )THEN
          CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
          CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
          IF (EXIT_FLAG) THEN
          ELSE
             GOTO 111
          ENDIF
.NE.       ELSE IF ( IERR  0 ) THEN
          WRITE(*,*) "Internal Error in DMUMPS_LOAD_POOL_UPD_NEW_POOL",
     &    IERR
          CALL MUMPS_ABORT()
        ENDIF
      ENDIF
      RETURN
      END SUBROUTINE DMUMPS_LOAD_POOL_UPD_NEW_POOL
      SUBROUTINE DMUMPS_LOAD_SBTR_UPD_NEW_POOL(
     &     OK,INODE,POOL,LPOOL,MYID,SLAVEF,COMM,KEEP,KEEP8)
      USE DMUMPS_BUF
      USE MUMPS_FUTURE_NIV2
      IMPLICIT NONE
      INTEGER LPOOL,MYID,SLAVEF,COMM,INODE
      INTEGER POOL(LPOOL),KEEP(500)
      INTEGER(8) KEEP8(150)
      INTEGER WHAT,IERR
      LOGICAL OK
      DOUBLE PRECISION COST
      LOGICAL FLAG, EXIT_FLAG
      EXTERNAL MUMPS_ROOTSSARBR,MUMPS_IN_OR_ROOT_SSARBR
      LOGICAL MUMPS_ROOTSSARBR,MUMPS_IN_OR_ROOT_SSARBR
.LE..OR..GT.      IF((INODE0)(INODEN_LOAD)) THEN
         RETURN
      ENDIF
.NOT.      IF (MUMPS_IN_OR_ROOT_SSARBR(
     &     PROCNODE_LOAD(STEP_LOAD(INODE)), KEEP(199))
     &   ) THEN
         RETURN         
      ENDIF
      IF(MUMPS_ROOTSSARBR(PROCNODE_LOAD(STEP_LOAD(INODE)),
     &         KEEP(199)))THEN
.EQ.         IF(NE_LOAD(STEP_LOAD(INODE))0)THEN
            RETURN
         ENDIF
      ENDIF
      FLAG=.FALSE.
.LE.      IF(INDICE_SBTRNB_SUBTREES)THEN
.EQ.         IF(INODEMY_FIRST_LEAF(INDICE_SBTR))THEN
            FLAG=.TRUE.
         ENDIF
      ENDIF
      IF(FLAG)THEN
         SBTR_PEAK_ARRAY(INDICE_SBTR_ARRAY)=MEM_SUBTREE(INDICE_SBTR)
         SBTR_CUR_ARRAY(INDICE_SBTR_ARRAY)=SBTR_CUR(MYID)
         INDICE_SBTR_ARRAY=INDICE_SBTR_ARRAY+1
         WHAT = 3
.GE.         IF(dble(MEM_SUBTREE(INDICE_SBTR))DM_THRES_MEM)THEN
 111        CONTINUE
            CALL DMUMPS_BUF_BROADCAST(
     &           WHAT, COMM, SLAVEF,
     &           FUTURE_NIV2,
     &           dble(MEM_SUBTREE(INDICE_SBTR)), dble(0),
     &           MYID, KEEP, IERR  )
            IF ( IERR == -1 )THEN
               CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
               CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
               IF (EXIT_FLAG) THEN
               ELSE
                  GOTO 111
               ENDIF
.NE.            ELSE IF ( IERR  0 ) THEN
               WRITE(*,*)
     &         "Internal Error 1 in DMUMPS_LOAD_SBTR_UPD_NEW_POOL",
     &         IERR
               CALL MUMPS_ABORT()
            ENDIF
         ENDIF
         SBTR_MEM(MYID)=SBTR_MEM(MYID)+
     &        dble(MEM_SUBTREE(INDICE_SBTR))
         INDICE_SBTR=INDICE_SBTR+1
.EQ.         IF(INSIDE_SUBTREE0)THEN
            INSIDE_SUBTREE=1
         ENDIF
      ELSE 
.EQ.         IF(INODEMY_ROOT_SBTR(INDICE_SBTR-1))THEN
            WHAT = 3
            COST=-SBTR_PEAK_ARRAY(INDICE_SBTR_ARRAY-1)
.GE.            IF(abs(COST)DM_THRES_MEM)THEN
 112           CONTINUE
               CALL DMUMPS_BUF_BROADCAST(
     &              WHAT, COMM, SLAVEF,
     &              FUTURE_NIV2,
     &              COST, dble(0), MYID, KEEP, IERR  )
               IF ( IERR == -1 )THEN
                  CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
                  CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
                  IF (EXIT_FLAG) THEN
                  ELSE
                     GOTO 112
                  ENDIF
.NE.               ELSE IF ( IERR  0 ) THEN
                  WRITE(*,*)
     &        "Internal Error 3 in DMUMPS_LOAD_SBTR_UPD_NEW_POOL",
     &        IERR
                  CALL MUMPS_ABORT()
               ENDIF
            ENDIF
            INDICE_SBTR_ARRAY=INDICE_SBTR_ARRAY-1            
            SBTR_MEM(MYID)=SBTR_MEM(MYID)-
     &           SBTR_PEAK_ARRAY(INDICE_SBTR_ARRAY)
            SBTR_CUR(MYID)=SBTR_CUR_ARRAY(INDICE_SBTR_ARRAY)
.EQ.            IF(INDICE_SBTR_ARRAY1)THEN
               SBTR_CUR(MYID)=dble(0)
               INSIDE_SUBTREE=0
            ENDIF
         ENDIF
         ENDIF 
      RETURN
      END SUBROUTINE DMUMPS_LOAD_SBTR_UPD_NEW_POOL
      SUBROUTINE DMUMPS_SET_PARTI_ACTV_MEM
     &      (SLAVEF,KEEP,KEEP8,PROCS,MEM_DISTRIB,NCB,NFRONT,
     &       NSLAVES_NODE,TAB_POS,
     &       SLAVES_LIST,SIZE_SLAVES_LIST,MYID)
      IMPLICIT NONE
      INTEGER, intent(in) :: KEEP(500),SIZE_SLAVES_LIST
      INTEGER(8) KEEP8(150)
      INTEGER, intent(in) :: SLAVEF, NFRONT, NCB,MYID
      INTEGER, intent(in) :: PROCS(SLAVEF+1)
      INTEGER, intent(in) :: MEM_DISTRIB(0:SLAVEF-1)
      INTEGER, intent(out):: SLAVES_LIST(SIZE_SLAVES_LIST)
      INTEGER, intent(out):: TAB_POS(SLAVEF+2)
      INTEGER, intent(out):: NSLAVES_NODE
      INTEGER NUMBER_OF_PROCS,K47, K48, K50
      INTEGER(8) :: K821
      DOUBLE PRECISION DK821
      INTEGER J
      INTEGER KMIN, KMAX
      INTEGER OTHERS,CHOSEN,SMALL_SET,ACC
      DOUBLE PRECISION SOMME,TMP_SUM
      INTEGER AFFECTED
      INTEGER ADDITIONNAL_ROWS,i,X,REF,POS
      INTEGER(8)::TOTAL_MEM
      LOGICAL FORCE_CAND
      DOUBLE PRECISION TEMP(SLAVEF),PEAK
      INTEGER TEMP_ID(SLAVEF),NB_ROWS(SLAVEF)
      EXTERNAL MPI_WTIME
      DOUBLE PRECISION MPI_WTIME
.GT.      IF (KEEP8(21)  0_8) THEN
      write(*,*)MYID,
     & ": Internal Error 1 in DMUMPS_SET_PARTI_ACTV_MEM"
      CALL MUMPS_ABORT()
      ENDIF
      K821=abs(KEEP8(21))
      DK821=dble(K821)
      K50=KEEP(50)
      K48=KEEP(48)
      K47=KEEP(47)
.OR.      IF ( KEEP(24) == 0  KEEP(24) == 1 ) THEN
        FORCE_CAND = .FALSE.
      ELSE
.eq.        FORCE_CAND = (mod(KEEP(24),2)0)
      END IF
.NE.      IF(K484)THEN
         WRITE(*,*)'dmumps_compute_parti_actv_mem_k821
     &      should be called with keep(48) different from 4'
         CALL MUMPS_ABORT()
      ENDIF
         KMIN=1
         KMAX=int(K821/int(NFRONT,8))
         IF(FORCE_CAND)THEN
            DO i=1,PROCS(SLAVEF+1)
               WLOAD(i)=DM_MEM(PROCS(i))
               IDWLOAD(i)=PROCS(i)
            ENDDO
            NUMBER_OF_PROCS=PROCS(SLAVEF+1)
            OTHERS=NUMBER_OF_PROCS
         ELSE
            NUMBER_OF_PROCS=SLAVEF
            WLOAD(1:SLAVEF) = DM_MEM(0:NUMBER_OF_PROCS-1)
            DO i=1,NUMBER_OF_PROCS
               IDWLOAD(i) = i - 1
            ENDDO
            OTHERS=NUMBER_OF_PROCS-1
         ENDIF
         NB_ROWS=0
         CALL MUMPS_SORT_DOUBLES(NUMBER_OF_PROCS, WLOAD, IDWLOAD)
         TOTAL_MEM=int(NCB,8)*int(NFRONT,8)
         SOMME=dble(0)
         J=1
         PEAK=dble(0)
         DO i=1,NUMBER_OF_PROCS
.NE.            IF((IDWLOAD(i)MYID))THEN
               PEAK=max(PEAK,WLOAD(i))
               TEMP_ID(J)=IDWLOAD(i)
               TEMP(J)=WLOAD(i)
                IF(BDC_SBTR)THEN
                   TEMP(J)=TEMP(J)+SBTR_MEM(IDWLOAD(i))-
     &                  SBTR_CUR(IDWLOAD(i))
                ENDIF
                IF(BDC_POOL)THEN
                   TEMP(J)=TEMP(J)+POOL_MEM(TEMP_ID(J))
                ENDIF
                IF(BDC_M2_MEM)THEN
                   TEMP(J)=TEMP(J)+NIV2(TEMP_ID(J)+1)
                ENDIF
                J=J+1
            ENDIF
         ENDDO
         NUMBER_OF_PROCS=J-1
         CALL MUMPS_SORT_DOUBLES(NUMBER_OF_PROCS, TEMP, TEMP_ID)
.EQ.         IF(K500)THEN
           PEAK=max(PEAK,
     &       DM_MEM(MYID)+dble(NFRONT)*dble(NFRONT-NCB))
         ELSE
           PEAK=max(PEAK,
     &       DM_MEM(MYID)+dble(NFRONT-NCB)*dble(NFRONT-NCB))
         ENDIF
         PEAK=max(PEAK,TEMP(OTHERS))
         SOMME=dble(0)
         DO i=1,NUMBER_OF_PROCS
           SOMME=SOMME+TEMP(OTHERS)-TEMP(i)
         ENDDO               
.LE.         IF(SOMMEdble(TOTAL_MEM)) THEN
            GOTO 096
         ENDIF
 096     CONTINUE
         SOMME=dble(0)
         DO i=1,OTHERS
            SOMME=SOMME+TEMP(OTHERS)-TEMP(i)
         ENDDO
.GE.         IF(dble(TOTAL_MEM)SOMME) THEN
            AFFECTED=0
            CHOSEN=0
            ACC=0
            DO i=1,OTHERS
.EQ.               IF(K500)THEN
.GT.                  IF((TEMP(OTHERS)-TEMP(i))DK821)THEN
                     TMP_SUM=DK821
                  ELSE
                     TMP_SUM=TEMP(OTHERS)-TEMP(i)
                  ENDIF
                  X=int(TMP_SUM/dble(NFRONT))
.GT.                  IF((ACC+X)NCB) X=NCB-ACC
               ENDIF
.NE.               IF(K500)THEN
.GT.                  IF((TEMP(OTHERS)-TEMP(i))DK821)THEN
                     TMP_SUM=DK821
                  ELSE
                     TMP_SUM=TEMP(OTHERS)-TEMP(i)
                  ENDIF
                  X=int((-dble(NFRONT-NCB+ACC)
     &                 +sqrt(((dble(NFRONT-NCB+ACC)*
     &                 dble(NFRONT-NCB+ACC))+dble(4)*
     &                 (TMP_SUM))))/
     &                 dble(2))
.GT.                  IF((ACC+X)NCB) X=NCB-ACC
.LE.                  IF(X0) THEN
                     WRITE(*,*)"Internal Error 2 in
     &                    DMUMPS_SET_PARTI_ACTV_MEM"
                    CALL MUMPS_ABORT()
                  ENDIF
               ENDIF
               NB_ROWS(i)=X
               CHOSEN=CHOSEN+1
               ACC=ACC+X
.LT.               IF(NCB-ACCKMIN) GOTO 111
.EQ.               IF(NCBACC) GOTO 111
               ENDDO
 111           CONTINUE
.GT.               IF((ACCNCB))THEN
                  X=0
                  DO i=1,OTHERS
                     X=X+NB_ROWS(i)
                  ENDDO
                  WRITE(*,*)'ncb=',NCB,',somme=',X
                  WRITE(*,*)MYID,
     &               ": Internal Error 3 in DMUMPS_SET_PARTI_ACTV_MEM"
                  CALL MUMPS_ABORT()
               ENDIF
.NE.               IF((NCBACC))THEN
.NE.                  IF(K500)THEN
.NE.                     IF(CHOSEN0)THEN
                        ADDITIONNAL_ROWS=NCB-ACC
                        NB_ROWS(CHOSEN)=NB_ROWS(CHOSEN)+ADDITIONNAL_ROWS
                     ELSE
                        TMP_SUM=dble(TOTAL_MEM)/dble(NUMBER_OF_PROCS)
                        CHOSEN=0
                        ACC=0
                        DO i=1,OTHERS
                           X=int((-dble(NFRONT-NCB+ACC)
     &                          +sqrt(((dble(NFRONT-NCB+ACC)*
     &                          dble(NFRONT-NCB+ACC))+dble(4)*
     &                          (TMP_SUM))))/
     &                          dble(2))
.GT.                           IF((ACC+X)NCB) X=NCB-ACC
                           NB_ROWS(i)=X
                           CHOSEN=CHOSEN+1
                           ACC=ACC+X
.LT.                           IF(NCB-ACCKMIN) GOTO 002
.EQ.                           IF(NCBACC) GOTO 002
                        ENDDO
 002                    CONTINUE
.LT.                        IF(ACCNCB)THEN
                           NB_ROWS(CHOSEN)=NB_ROWS(CHOSEN)+(NCB-ACC)
                        ENDIF
                     ENDIF
                     GOTO 333
                  ENDIF
                  ADDITIONNAL_ROWS=NCB-ACC
                  DO i=CHOSEN,1,-1
                     IF(int(dble(ADDITIONNAL_ROWS)/
.NE.     &                    dble(i))0)THEN
                        GOTO 222 
                     ENDIF
                  ENDDO
 222              CONTINUE
                  X=int(dble(ADDITIONNAL_ROWS)/dble(i))
                  DO J=1,i
                     NB_ROWS(J)=NB_ROWS(J)+X
                     ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                  ENDDO 
.NE.                  IF(ADDITIONNAL_ROWS0) THEN
                     NB_ROWS(1)=NB_ROWS(1)+ADDITIONNAL_ROWS
                  ENDIF    
               ENDIF
 333           CONTINUE
.EQ.               IF(NB_ROWS(CHOSEN)0) CHOSEN=CHOSEN-1
               GOTO 889
            ELSE
               DO i=OTHERS,1,-1
                  SOMME=dble(0)
                  DO J=1,i
                     SOMME=SOMME+TEMP(J)
                  ENDDO
                  SOMME=(dble(i)*TEMP(i))-SOMME
.GE.                  IF(dble(TOTAL_MEM)SOMME) GOTO 444
               ENDDO
 444           CONTINUE
               REF=i
               DO J=1,i
.EQ.                  IF(TEMP(J)TEMP(i)) THEN
                     SMALL_SET=J
                     GOTO 123
                  ENDIF
               ENDDO
 123           CONTINUE
.EQ.               IF(i1)THEN 
                  NB_ROWS(i)=NCB
                  CHOSEN=1
                  GOTO 666
               ENDIF
 323           CONTINUE
               AFFECTED=0
               CHOSEN=0
               ACC=0
               DO i=1,SMALL_SET
.EQ.                  IF(K500)THEN
.GT.                     IF((TEMP(SMALL_SET)-TEMP(i))DK821)THEN
                        TMP_SUM=DK821
                     ELSE
                        TMP_SUM=TEMP(SMALL_SET)-TEMP(i)
                     ENDIF
                     X=int(TMP_SUM/dble(NFRONT))
.GT.                     IF((ACC+X)NCB) X=NCB-ACC
                  ENDIF
.NE.                  IF(K500)THEN
.GT.                     IF((TEMP(SMALL_SET)-TEMP(i))DK821)THEN
                        TMP_SUM=DK821
                     ELSE
                        TMP_SUM=TEMP(SMALL_SET)-TEMP(i)
                     ENDIF
                      X=int((-dble(NFRONT-NCB+ACC)
     &                  +sqrt(((dble(NFRONT-NCB+ACC)*
     &                  dble(NFRONT-NCB+ACC))+dble(4)*
     &                  (TMP_SUM))))/
     &                  dble(2))
.LT.                      IF(X0)THEN
                        WRITE(*,*)MYID,
     &             ': internal error 4 in dmumps_set_parti_actv_mem'
                        CALL MUMPS_ABORT()
                     ENDIF
.GT.                     IF((ACC+X)NCB) X=NCB-ACC
                  ENDIF
                  NB_ROWS(i)=X
                  ACC=ACC+X
                  CHOSEN=CHOSEN+1
.LT.                  IF(NCB-ACCKMIN) GOTO 888
.EQ.                  IF(NCBACC) GOTO 888
.GT.                  IF(ACCNCB) THEN
                    WRITE(*,*)MYID,
     &            ': internal error 5 in dmumps_set_parti_actv_mem'
                    CALL MUMPS_ABORT()
                  ENDIF
               ENDDO
 888           CONTINUE
               SOMME=dble(0)
               X=NFRONT-NCB
.GT.               IF((ACCNCB))THEN
                  WRITE(*,*)MYID,
     &           ':internal error 6 in dmumps_set_parti_actv_mem'
                  CALL MUMPS_ABORT()
               ENDIF
.LT.               IF((ACCNCB))THEN
.NE.                  IF(K500)THEN
.LT.                     IF(SMALL_SETOTHERS)THEN
                       SMALL_SET=REF+1
                       REF=SMALL_SET
                       GOTO 323
                     ELSE
                       NB_ROWS(CHOSEN)=NB_ROWS(CHOSEN)+NCB-ACC
                       GOTO 666
                     ENDIF
                 ENDIF
                 ADDITIONNAL_ROWS=NCB-ACC
                 i=CHOSEN+1
.NE.                 DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LE.     &                (iNUMBER_OF_PROCS))
                    J=1
                    X=int(ADDITIONNAL_ROWS/(i-1))
.EQ..AND..NE.                    IF((X0)(ADDITIONNAL_ROWS0))THEN
.LT..AND..GT.                       DO WHILE ((Ji)(ADDITIONNAL_ROWS0))
                         NB_ROWS(J)=NB_ROWS(J)+1
                         ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-1
                         J=J+1
                       ENDDO
.NE.                       IF(ADDITIONNAL_ROWS0)THEN
                          WRITE(*,*)MYID,
     &             ':internal error 7 in dmumps_set_parti_actv_mem'
                          CALL MUMPS_ABORT()
                      ENDIF
                      GOTO 047
                    ENDIF
.LE.                    IF((TEMP(1)+dble((NB_ROWS(1)+X)*NFRONT))
     &                   TEMP(i))THEN
.NE.                       DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LT.     &                      (Ji))
                          AFFECTED=X
.GT.                          IF((AFFECTED+NB_ROWS(J))
     &                         KMAX)THEN
                             AFFECTED=KMAX-NB_ROWS(J)
                          ENDIF
                          NB_ROWS(J)=NB_ROWS(J)+AFFECTED
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                         AFFECTED
                          J=J+1
                       ENDDO
                    ELSE
.NE.                       DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LE.     &                      (Ji))
                          AFFECTED=int((TEMP(i)-(TEMP(J)+
     &                         (dble(NB_ROWS(J))*dble(NFRONT))))
     &                         /dble(NFRONT))
.GT.                          IF((AFFECTED+NB_ROWS(J))KMAX)THEN
                             AFFECTED=KMAX-NB_ROWS(J)
                          ENDIF
.GT.                          IF(AFFECTEDADDITIONNAL_ROWS)THEN
                             AFFECTED=ADDITIONNAL_ROWS
                          ENDIF
                          NB_ROWS(J)=NB_ROWS(J)+AFFECTED
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-AFFECTED
                          J=J+1
                       ENDDO
                    ENDIF
                    i=i+1
                 ENDDO
 047             CONTINUE
.EQ..AND.                 IF((ADDITIONNAL_ROWS0)
.LT.     &                (iNUMBER_OF_PROCS))THEN
                    CHOSEN=i-1
                 ELSE
                    CHOSEN=i-2
                 ENDIF
.EQ..AND.                 IF((CHOSENNUMBER_OF_PROCS-1)
.NE.     &                 (ADDITIONNAL_ROWS0))THEN
                    DO i=1,CHOSEN
                       NB_ROWS(i)=NB_ROWS(i)+1
                       ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-1
.EQ.                       IF(ADDITIONNAL_ROWS0) GOTO 048
                    ENDDO
 048                CONTINUE
                 ENDIF
.EQ..AND.                 IF((CHOSENNUMBER_OF_PROCS-1)
.NE.     &                (ADDITIONNAL_ROWS0))THEN
                    i=CHOSEN+1
.NE.                    DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LE.     &                   (iNUMBER_OF_PROCS))
                       J=1
.NE.                       DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LE.     &                      (Ji))
                          AFFECTED=int((TEMP(i)-(TEMP(J)+
     &                         (dble(NB_ROWS(J))*
     &                         dble(NFRONT))))/dble(NFRONT))
.GT.                          IF(AFFECTEDADDITIONNAL_ROWS)THEN
                             AFFECTED=ADDITIONNAL_ROWS
                          ENDIF
                          NB_ROWS(J)=NB_ROWS(J)+AFFECTED
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-AFFECTED
                          J=J+1
                       ENDDO
                       i=i+1
                    ENDDO
                    CHOSEN=i-2
                 ENDIF
                 CONTINUE
              ENDIF
 666          CONTINUE
              SOMME=dble(0)
              X=0
              POS=0
              DO i=1,CHOSEN
.NE.                 IF(K500) THEN
                    IF((TEMP(i)+dble(NB_ROWS(i))
     &                   *dble(X+NB_ROWS(i)+NFRONT-NCB))
.GT.     &                   PEAK)THEN
                       SMALL_SET=SMALL_SET+1
                    ENDIF
                 ENDIF
.EQ.                 IF(K500) THEN
                    IF((TEMP(i)+dble(NB_ROWS(i))*dble(NFRONT))
.GT.     &                   PEAK)THEN
                       SMALL_SET=SMALL_SET+1
                    ENDIF
                 ENDIF
                 X=X+NB_ROWS(i)
                 SOMME=SOMME+ dble(NB_ROWS(i))
              ENDDO
           ENDIF
 889       CONTINUE
           J=CHOSEN
           X=0
           DO i=J,1,-1
.EQ.             IF(NB_ROWS(i)0)THEN
.EQ.                IF(X1)THEN
                  WRITE(*,*)MYID,
     &         ':internal error 12 in dmumps_set_parti_actv_mem'
                  CALL MUMPS_ABORT()
                ENDIF
                CHOSEN=CHOSEN-1
             ELSE 
.GT.                  IF(NB_ROWS(i)0)THEN
                    X=1
                 ELSE
                    WRITE(*,*)
     &            'internal error 13 in dmumps_set_parti_actv_mem'
                    CALL MUMPS_ABORT()
                  ENDIF
             ENDIF
          ENDDO
           NSLAVES_NODE=CHOSEN
           TAB_POS(NSLAVES_NODE+1)= NCB+1
           TAB_POS(SLAVEF+2) = CHOSEN
           POS=1
           DO i=1,CHOSEN
              SLAVES_LIST(i)=TEMP_ID(i)
              TAB_POS(i)=POS
              POS=POS+NB_ROWS(i) 
.LE.              IF(NB_ROWS(i)0)THEN
                WRITE(*,*)
     &          'internal error 14 in dmumps_set_parti_actv_mem'
                CALL MUMPS_ABORT()
              ENDIF
           ENDDO
           DO i=CHOSEN+1,NUMBER_OF_PROCS
              SLAVES_LIST(i)=TEMP_ID(i)
           ENDDO
.NE.           IF(POS(NCB+1))THEN
              WRITE(*,*)
     &        'internal error 15 in dmumps_set_parti_actv_mem'
              CALL MUMPS_ABORT()
           ENDIF
      END SUBROUTINE DMUMPS_SET_PARTI_ACTV_MEM
      SUBROUTINE DMUMPS_SET_PARTI_FLOP_IRR
     &      (NCBSON_MAX,SLAVEF,KEEP,KEEP8,
     &       PROCS,MEM_DISTRIB,NCB,NFRONT,
     &       NSLAVES_NODE,TAB_POS,
     &       SLAVES_LIST,SIZE_SLAVES_LIST,MYID,INODE,MP,LP)
      IMPLICIT NONE
      INTEGER, intent(in) :: KEEP(500),SIZE_SLAVES_LIST
      INTEGER(8) KEEP8(150)
      INTEGER, intent(in) :: SLAVEF, NFRONT, NCB,MYID
      INTEGER, intent(in) :: NCBSON_MAX
      INTEGER, intent(in) :: PROCS(SLAVEF+1)
      INTEGER, intent(in) :: MEM_DISTRIB(0:SLAVEF-1),INODE
      INTEGER, intent(in) :: MP,LP
      INTEGER, intent(out):: SLAVES_LIST(SIZE_SLAVES_LIST)
      INTEGER, intent(out):: TAB_POS(SLAVEF+2)
      INTEGER, intent(out):: NSLAVES_NODE
      INTEGER NUMBER_OF_PROCS,K47,K48, K50,K83,K69
      INTEGER(8) :: K821
      INTEGER J
      INTEGER KMIN, KMAX
      INTEGER OTHERS,CHOSEN,SMALL_SET,ACC
      DOUBLE PRECISION SOMME,TMP_SUM,DELTA,A,B,C,MASTER_WORK
      INTEGER AFFECTED
      INTEGER ADDITIONNAL_ROWS,i,X,REF,POS,NELIM
      INTEGER(8) X8
      LOGICAL FORCE_CAND,SMP
      DOUBLE PRECISION BANDE_K821
      INTEGER NB_SAT,NB_ZERO
      DOUBLE PRECISION TEMP(SLAVEF),TOTAL_COST, MAX_MEM_ALLOW
      INTEGER TEMP_ID(SLAVEF),NB_ROWS(SLAVEF)
      INTEGER NSLAVES_REF,NCB_FILS
      EXTERNAL MPI_WTIME,MUMPS_GETKMIN
      INTEGER MUMPS_GETKMIN
      INTEGER POS_MIN_LOAD,SIZE_MY_SMP,WHAT
      LOGICAL HAVE_TYPE1_SON
      DOUBLE PRECISION MIN_LOAD,MAX_LOAD,TEMP_MAX_LOAD
      DOUBLE PRECISION MPI_WTIME
      DOUBLE PRECISION BUF_SIZE,NELIM_MEM_SIZE
      DOUBLE PRECISION MEM_SIZE_STRONG(SLAVEF),MEM_SIZE_WEAK(SLAVEF)
      K821=abs(KEEP8(21))
      TEMP_MAX_LOAD=dble(0)
      K50=KEEP(50)
      K48=KEEP(48)
      K47=KEEP(47)
      K83=KEEP(83)
      K69=0
      NCB_FILS=NCBSON_MAX
.GT.      IF(int(NCB_FILS,8)*int(min(NCB,NCB_FILS),8)K821)THEN
         HAVE_TYPE1_SON=.TRUE.
      ELSE
         HAVE_TYPE1_SON=.FALSE.
      ENDIF
.NE.      SMP=(K690)
.OR.      IF ( KEEP(24) == 0  KEEP(24) == 1 ) THEN
        FORCE_CAND = .FALSE.
      ELSE
.eq.        FORCE_CAND = (mod(KEEP(24),2)0)
      END IF
      NELIM=NFRONT-NCB
         KMAX=int(K821/int(NCB,8))
         IF(FORCE_CAND)THEN
           DO i=1,PROCS(SLAVEF+1)
              WLOAD(i)=LOAD_FLOPS(PROCS(i))
              IDWLOAD(i)=PROCS(i)
              WLOAD(i)=max(WLOAD(i),0.0d0)
           ENDDO
           NUMBER_OF_PROCS=PROCS(SLAVEF+1)
            OTHERS=NUMBER_OF_PROCS
         ELSE
            NUMBER_OF_PROCS=SLAVEF
            WLOAD(1:SLAVEF) = LOAD_FLOPS(0:NUMBER_OF_PROCS-1)
            DO i=1,NUMBER_OF_PROCS
               IDWLOAD(i) = i - 1
               IF (WLOAD(i) < -0.5d0 ) THEN
.GT..AND..GE.                  IF((MP0)(LP2))THEN
                     WRITE(MP,*)MYID,': negative load ',
     &                    WLOAD(i)
                  ENDIF
               ENDIF 
               WLOAD(i)=max(WLOAD(i),0.0d0)
            ENDDO
            OTHERS=NUMBER_OF_PROCS-1
         ENDIF
         KMAX=int(NCB/OTHERS)
         KMIN=MUMPS_GETKMIN(int(NCB,8)*int(KMAX,8),K50,KMAX,NCB)
         NB_ROWS=0
         CALL MUMPS_SORT_DOUBLES(NUMBER_OF_PROCS, WLOAD, IDWLOAD)
.EQ.         IF(K500)THEN
            TOTAL_COST=dble( NELIM ) * dble ( NCB ) +
     &           dble(NCB) * dble(NELIM)*dble(2*NFRONT-NELIM-1)
         ELSE
            TOTAL_COST=dble(NELIM) * dble ( NCB ) *
     &           dble(NFRONT+1)
         ENDIF
         CALL MUMPS_GET_FLOPS_COST(NFRONT,NELIM,NELIM,K50,
     &        2,MASTER_WORK)
         SOMME=dble(0)
         J=1
.AND..GT.         IF(FORCE_CAND(NUMBER_OF_PROCSK83))THEN
            MASTER_WORK=dble(KEEP(88))*MASTER_WORK/dble(100)
         ENDIF
.AND..LE.         IF(FORCE_CAND(NUMBER_OF_PROCSK83))THEN
            MASTER_WORK=dble(KEEP(87))*MASTER_WORK/dble(100)
         ENDIF
.LT.         IF(MASTER_WORKdble(1))THEN
            MASTER_WORK=dble(1)
         ENDIF
         NSLAVES_REF=int(TOTAL_COST/MASTER_WORK)+1
         IF(FORCE_CAND)THEN
            NSLAVES_REF=min(NSLAVES_REF,NUMBER_OF_PROCS)
         ELSE
            NSLAVES_REF=min(NSLAVES_REF,NUMBER_OF_PROCS-1)
         ENDIF
        DO i=1,NUMBER_OF_PROCS
.NE.           IF((IDWLOAD(i)MYID))THEN
              TEMP_ID(J)=IDWLOAD(i)
              TEMP(J)=WLOAD(i)
              IF(BDC_M2_FLOPS)THEN
                 TEMP(J)=TEMP(J)+NIV2(TEMP_ID(J)+1)
              ENDIF
              J=J+1
           ENDIF
        ENDDO               
        NUMBER_OF_PROCS=J-1
        CALL MUMPS_SORT_DOUBLES(NUMBER_OF_PROCS, TEMP, TEMP_ID)
        SOMME=dble(0)
        TMP_SUM=dble(0)
        DO i=1,OTHERS
            SOMME=SOMME+TEMP(OTHERS)-TEMP(i)
            TMP_SUM=TMP_SUM+TEMP(i)
        ENDDO
         TMP_SUM=(TMP_SUM/dble(OTHERS))+
     &        (TOTAL_COST/dble(OTHERS))
         SIZE_MY_SMP=OTHERS
         MIN_LOAD=TEMP(1)
         POS_MIN_LOAD=1
.NOT.         IF(SMP) MAX_LOAD=TEMP(OTHERS)
         IF(SMP)THEN
            J=1
            DO i=1,OTHERS
.EQ.               IF(MEM_DISTRIB(TEMP_ID(i))1)THEN
.LE.                  IF(TEMP(i)TMP_SUM)THEN
                     WLOAD(J)=TEMP(i)
                     IDWLOAD(J)=TEMP_ID(i)
                     J=J+1
                  ELSE
                  ENDIF
               ENDIF
            ENDDO
            MAX_LOAD=WLOAD(J-1)
            SIZE_MY_SMP=J-1
            DO i=1,OTHERS
.NE..OR.               IF((MEM_DISTRIB(TEMP_ID(i))1)
.EQ..AND.     &              ((MEM_DISTRIB(TEMP_ID(i))1)
.GE.     &              (TEMP(i)TMP_SUM)))THEN
                  WLOAD(J)=TEMP(i)
                  IDWLOAD(J)=TEMP_ID(i)
                  J=J+1
               ENDIF
            ENDDO
            TEMP=WLOAD
            TEMP_ID=IDWLOAD
         ENDIF
        IF(BDC_MD)THEN
           BUF_SIZE=dble(K821)
.EQ.           IF (KEEP(201)2) THEN
              A=dble(int((dble(KEEP(100))/dble(2))/dble(NELIM)))
.EQ.              IF(K500)THEN
                 BUF_SIZE=min(BUF_SIZE,A*dble(NCB))
              ELSE
                 BUF_SIZE=min(BUF_SIZE,A*A)
              ENDIF
           ENDIF
           BUF_SIZE=dble(K821)
           DO i=1,NUMBER_OF_PROCS
              A=dble(MD_MEM(TEMP_ID(i)))/
     &             dble(NELIM)
              A=A*dble(NFRONT)
.EQ.              IF(K500)THEN
                 B=dble(int(dble(NCB)/dble(NUMBER_OF_PROCS))+1)*
     &                dble(NFRONT)
              ELSE
                 WHAT = 5 
                 CALL MUMPS_MAX_SURFCB_NBROWS(WHAT, KEEP,KEEP8, NCB,
     &                NFRONT, min(NCB,OTHERS), J, X8)
                 B=dble(X8)+(dble(J)*dble(NELIM))
              ENDIF
              NELIM_MEM_SIZE=A+B
              MEM_SIZE_WEAK(i)=NELIM_MEM_SIZE
.EQ..OR..NOT.            IF((SBTR_WHICH_M0)(BDC_SBTR))THEN
               IF(BDC_M2_MEM)THEN
                  MEM_SIZE_STRONG(i)=
     &                 dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                 LU_USAGE(TEMP_ID(i))-NIV2(TEMP_ID(i)+1)
               ELSE
                  MEM_SIZE_STRONG(i)=
     &                 dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                 LU_USAGE(TEMP_ID(i))
               ENDIF
            ELSE
               IF(BDC_SBTR)THEN
                  IF(BDC_M2_MEM)THEN
                     MEM_SIZE_STRONG(i)=
     &                    dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                    LU_USAGE(TEMP_ID(i))-NIV2(TEMP_ID(i)+1)-
     &                    (SBTR_MEM(TEMP_ID(i))-SBTR_CUR(TEMP_ID(i)))
                  ELSE
                     MEM_SIZE_STRONG(i)=
     &                    dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                    LU_USAGE(TEMP_ID(i))-
     &                    (SBTR_MEM(TEMP_ID(i))-SBTR_CUR(TEMP_ID(i)))
                  ENDIF
               ENDIF
            ENDIF
.LT.            IF(min(MEM_SIZE_STRONG(i),MEM_SIZE_WEAK(i))dble(0))THEN
.LT.                IF(MEM_SIZE_STRONG(i)0.0d0)THEN
                   MEM_SIZE_STRONG(i)=dble(0)
                ELSE
                   MEM_SIZE_WEAK(i)=dble(0)
                ENDIF
             ENDIF
          ENDDO
       ELSE
          BUF_SIZE=dble(K821)
          DO i=1,NUMBER_OF_PROCS
.EQ..OR..NOT.            IF((SBTR_WHICH_M0)(BDC_SBTR))THEN
               IF(BDC_M2_MEM)THEN
                  MEM_SIZE_STRONG(i)=
     &                 dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                 LU_USAGE(TEMP_ID(i))-NIV2(TEMP_ID(i)+1)
               ELSE
                  MEM_SIZE_STRONG(i)=
     &                 dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                 LU_USAGE(TEMP_ID(i))
               ENDIF
            ELSE
               IF(BDC_SBTR)THEN
                  IF(BDC_M2_MEM)THEN
                     MEM_SIZE_STRONG(i)=
     &                    dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                    LU_USAGE(TEMP_ID(i))-NIV2(TEMP_ID(i)+1)-
     &                    (SBTR_MEM(TEMP_ID(i))-SBTR_CUR(TEMP_ID(i)))
                  ELSE
                     MEM_SIZE_STRONG(i)=
     &                    dble(TAB_MAXS(TEMP_ID(i)))-DM_MEM(TEMP_ID(i))-
     &                    LU_USAGE(TEMP_ID(i))-
     &                    (SBTR_MEM(TEMP_ID(i))-SBTR_CUR(TEMP_ID(i)))
                  ENDIF
               ENDIF
            ENDIF
            MEM_SIZE_STRONG(i)=max(dble(0),MEM_SIZE_STRONG(i))
            MEM_SIZE_WEAK(i)=huge(MEM_SIZE_WEAK(i))
          ENDDO
       ENDIF
.LE..AND..AND.       IF((((NUMBER_OF_PROCSK83)FORCE_CAND)
.GE..OR.     &      (TOTAL_COSTSOMME))
.NOT..OR.     &      (FORCE_CAND)
.GT..AND.     &      (((NUMBER_OF_PROCS+1)K83)FORCE_CAND))THEN
               REF=NSLAVES_REF
               SMALL_SET=NSLAVES_REF
.NOT.               IF(SMP)THEN
                  DO i=NSLAVES_REF,1,-1
                     SOMME=dble(0)
                     DO J=1,i
                        SOMME=SOMME+TEMP(J)
                     ENDDO
                     SOMME=(dble(i)*TEMP(i))-SOMME
.GE.                     IF(TOTAL_COSTSOMME) GOTO 444
                  ENDDO
 444              CONTINUE
                  REF=i
                  SMALL_SET=REF
                  MAX_LOAD=TEMP(SMALL_SET)
               ELSE
                  X=min(SIZE_MY_SMP,NSLAVES_REF)
 450              CONTINUE
                  SOMME=dble(0)
                  DO J=1,X
                     SOMME=SOMME+(TEMP(X)-TEMP(J))
                  ENDDO
.GT.                  IF(SOMMETOTAL_COST)THEN
                     X=X-1
                     GOTO 450
                  ELSE
.LT.                     IF(XSIZE_MY_SMP) THEN
                        REF=X
                        SMALL_SET=REF
                        MAX_LOAD=TEMP(SMALL_SET)
                     ELSE
                        X=min(SIZE_MY_SMP,NSLAVES_REF)
                        J=X+1
                        MAX_LOAD=TEMP(X)
                        TMP_SUM=MAX_LOAD
                        DO i=X+1,OTHERS
.GT.                           IF(TEMP(i)MAX_LOAD)THEN
                              SOMME=SOMME+(dble(i-1)*(TEMP(i)-MAX_LOAD))
                              TMP_SUM=MAX_LOAD
                              MAX_LOAD=TEMP(i)
                           ELSE
                              SOMME=SOMME+(MAX_LOAD-TEMP(i))
                           ENDIF
.EQ.                           IF(iNSLAVES_REF)THEN
                              SMALL_SET=NSLAVES_REF
                              REF=SMALL_SET
                              GOTO 323
                           ENDIF
.GT.                           IF(SOMMETOTAL_COST)THEN
                              REF=i-1
                              SMALL_SET=i-1
                              MAX_LOAD=TMP_SUM
                              GOTO 323
                           ENDIF
                        ENDDO
                     ENDIF
                  ENDIF
               ENDIF
 323           CONTINUE
               MAX_LOAD=dble(0)
               DO i=1,SMALL_SET
                  MAX_LOAD=max(MAX_LOAD,TEMP(i))
               ENDDO
               TEMP_MAX_LOAD=MAX_LOAD
               NB_ROWS=0
               TMP_SUM=dble(0)
               CHOSEN=0
               ACC=0
               NB_SAT=0
               NB_ZERO=0
               DO i=1,SMALL_SET
.EQ.                  IF(K500)THEN
                     X=int(BUF_SIZE/dble(NCB+1))-1
                     BANDE_K821=dble(X)*dble(NFRONT)
                  ELSE
                     A=dble(1)
                     B=dble(ACC+2)
                     C=-BUF_SIZE+dble(ACC+NELIM)
                     DELTA=(B*B)-(dble(4)*A*C)
                     X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                     IF(XNCB-ACC) X=NCB-ACC
                     BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                  ENDIF
                  IF(HAVE_TYPE1_SON)THEN
.EQ.                     IF(K500)THEN
                        X=int((BUF_SIZE-dble(NFRONT))/dble(NFRONT+1))
                        BANDE_K821=dble(X)*dble(NFRONT)
                     ELSE
                        A=dble(1)
                        B=dble(ACC+2+NELIM)
                        C=-BUF_SIZE+dble(ACC+NELIM)
                        DELTA=(B*B)-(dble(4)*A*C)
                        X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                        IF(XNCB-ACC) X=NCB-ACC
                        BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                     ENDIF
                  ENDIF
                  MAX_MEM_ALLOW=BANDE_K821
                  IF(BDC_MD)THEN
                     MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                    BANDE_K821)
                     MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                  ENDIF
.EQ.                  IF(K500)THEN
                     KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
                     X=int((MAX_LOAD-TEMP(i))/
     &                    (dble(NELIM)*dble(2*NFRONT-NELIM)))
.GE.                     IF(XKMAX)THEN
.GE.                        IF(KMAXKMIN)THEN
                           X=KMAX
                           NB_SAT=NB_SAT+1
                        ELSE
                           X=0
                        ENDIF
                     ELSE
.LT.                        IF(XKMIN)THEN
                           X=0
                        ENDIF                        
                     ENDIF
.GT.                     IF((ACC+X)NCB) X=NCB-ACC
                  ENDIF
.NE.                  IF(K500)THEN
                        A=dble(1)
                        B=dble(ACC+NELIM)
                        C=dble(-MAX_MEM_ALLOW)
                        DELTA=((B*B)-(dble(4)*A*C))
                        KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                     A=dble(NELIM)
                     B=dble(NELIM)*(dble(NELIM)+dble(2*ACC+1))
                     C=-(MAX_LOAD-TEMP(i))
                     DELTA=(B*B-(dble(4)*A*C))
                     X=int((-B+sqrt(DELTA))/(dble(2)*A))
.LT.                     IF(X0) THEN
                        WRITE(*,*)MYID,
     &    ': internal error 1 in dmumps_set_parti_flop_irr'
                        CALL MUMPS_ABORT()
                     ENDIF
.GE.                     IF(XKMAX)THEN
.GE.                        IF(KMAXKMIN)THEN
                           X=KMAX
                           NB_SAT=NB_SAT+1
                        ELSE
                           X=0
                        ENDIF
                     ELSE
.LT.                        IF(XKMIN)THEN
                           X=0
                        ENDIF
                     ENDIF
.GT.                     IF((ACC+X)NCB) X=NCB-ACC
                  ENDIF                  
                  NB_ROWS(i)=X
                  ACC=ACC+X
                  CHOSEN=CHOSEN+1
                  IF(SMP)THEN
.GT.                     IF(MIN_LOADTEMP(i))THEN
                        MIN_LOAD=TEMP(i)
                        POS_MIN_LOAD=i
                     ENDIF
                  ENDIF
                  TMP_SUM=MAX_LOAD
.EQ.                  IF(K500)THEN
                     MAX_LOAD=max(MAX_LOAD,
     &                    (TEMP(i)+(dble(NELIM) *
     &                    dble(NB_ROWS(i)))+
     &                    (dble(NB_ROWS(i))*dble(NELIM)*
     &                    dble(2*NFRONT-NELIM-1))))
                  ELSE
                     MAX_LOAD=max(MAX_LOAD,
     &               TEMP(i)+(dble(NELIM) * dble(NB_ROWS(i)))*
     &                    dble(2*(NELIM+ACC)-NB_ROWS(i)
     &                    -NELIM+1))
                  ENDIF
.LT.                  IF(TMP_SUMMAX_LOAD)THEN
                  ENDIF
.LT.                  IF(NCB-ACCKMIN) GOTO 888
.EQ.                  IF(NCBACC) GOTO 888
.GT.                  IF(ACCNCB) THEN
                    WRITE(*,*)MYID,
     &      ': internal error 2 in dmumps_set_parti_flop_irr'
                    CALL MUMPS_ABORT()
                  ENDIF
               ENDDO
 888           CONTINUE
               SOMME=dble(0)
               X=NFRONT-NCB
.GT.               IF((ACCNCB))THEN
                  WRITE(*,*)MYID,
     &          ': internal error 3 in dmumps_set_parti_flop_irr'
                  CALL MUMPS_ABORT()
               ENDIF
.LT.               IF((ACCNCB))THEN
.NE.                  IF(K500)THEN
.LE.                     IF(SMALL_SETOTHERS)THEN
.EQ..AND..LT.                       IF((NB_SATSMALL_SET)(SMALL_SET
     &                      NSLAVES_REF))THEN
                          SMALL_SET=REF+1
                          REF=REF+1
                          NB_ROWS=0
                          GOTO 323
                       ENDIF
                       DO i=1,SMALL_SET
                          MAX_LOAD=TEMP_MAX_LOAD
                          ADDITIONNAL_ROWS=NCB-ACC
                          SOMME=dble(NELIM)*
     &                         dble(ADDITIONNAL_ROWS)*
     &                         dble(2*NFRONT-ADDITIONNAL_ROWS-NELIM
     &                         +1)
                          SOMME=SOMME/dble(SMALL_SET-NB_SAT)
                          NB_ROWS=0
                          NB_ZERO=0
                          ACC=0
                          CHOSEN=0
                          NB_SAT=0
                          IF(SMP)THEN
                             MIN_LOAD=TEMP(1)
                             POS_MIN_LOAD=1
                          ENDIF
                          DO J=1,SMALL_SET
                             A=dble(1)
                             B=dble(ACC+2)
                             C=-BUF_SIZE+dble(ACC+NELIM)
                             DELTA=(B*B)-(dble(4)*A*C)
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                             IF(XNCB-ACC) X=NCB-ACC
                             BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             IF(HAVE_TYPE1_SON)THEN
                                A=dble(1)
                                B=dble(ACC+2+NELIM)
                                C=-BUF_SIZE+dble(ACC+NELIM)
                                DELTA=(B*B)-(dble(4)*A*C)
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                IF(XNCB-ACC) X=NCB-ACC
                                BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             ENDIF
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(
     &                        min(MEM_SIZE_WEAK(J),MEM_SIZE_STRONG(J)),
     &                               BANDE_K821)
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             A=dble(1)
                             B=dble(ACC+NELIM)
                             C=dble(-MAX_MEM_ALLOW)
                             DELTA=((B*B)-(dble(4)*A*C))
                             KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                             A=dble(NELIM)
                             B=(dble(NELIM)*dble(NELIM+2*ACC+1))
                             C=-(MAX_LOAD-TEMP(J)+SOMME)
                             DELTA=(B*B-(dble(4)*A*C))
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
                             X=X+1
.LT.                             IF(X0) THEN
                                WRITE(*,*)MYID,
     &    ': internal error 4 in dmumps_set_parti_flop_irr'
                                CALL MUMPS_ABORT()
                             ENDIF
.GE.                             IF(XKMAX)THEN
.GE.                                IF(KMAXKMIN)THEN
                                   X=KMAX
                                   NB_SAT=NB_SAT+1
                                ELSE
                                   NB_ZERO=NB_ZERO+1
                                   X=0
                                ENDIF
                             ELSE
.LT.                                IF(Xmin(KMIN,KMAX))THEN
                                   NB_ZERO=NB_ZERO+1
                                   X=0
                                ENDIF
                             ENDIF
.GT.                             IF((ACC+X)NCB) X=NCB-ACC
                             NB_ROWS(J)=X
                             IF(SMP)THEN
.GT.                                IF(MIN_LOADTEMP(J))THEN
                                   MIN_LOAD=TEMP(J)
                                   POS_MIN_LOAD=i
                                ENDIF
                             ENDIF
                             CHOSEN=CHOSEN+1
                             ACC=ACC+X
                             TMP_SUM=MAX_LOAD
                             TEMP_MAX_LOAD=max(TEMP_MAX_LOAD,
     &                            TEMP(J)+(dble(NELIM) *
     &                            dble(NB_ROWS(J)))*
     &                            dble(2*(NELIM+
     &                            ACC)-NB_ROWS(J)
     &                            -NELIM+1))
.LE.                             IF(REFNUMBER_OF_PROCS-1)THEN
.GT.                                IF(TEMP_MAX_LOADTEMP(REF+1))THEN
.LT.                                   IF(SMALL_SETNSLAVES_REF)THEN
                                      SMALL_SET=REF+1
                                      REF=REF+1
                                      NB_ROWS=0
                                      GOTO 323
                                   ENDIF
                                ENDIF
                             ENDIF
.EQ.                             IF(NCBACC) GOTO 666
                          ENDDO
.EQ.                          IF(NB_SATSMALL_SET)THEN
.LT.                             IF(SMALL_SETNSLAVES_REF)THEN
                                SMALL_SET=REF+1
                                REF=REF+1
                                NB_ROWS=0
                                GOTO 323
                             ELSE
                                GOTO 434
                             ENDIF
                          ENDIF
.EQ.                          IF(NB_ZEROSMALL_SET)THEN
.LT.                             IF(SMALL_SETNSLAVES_REF)THEN
                                SMALL_SET=REF+1
                                REF=REF+1
                                NB_ROWS=0
                                GOTO 323
                             ELSE
                                GOTO 434
                             ENDIF
                          ENDIF
.EQ.                          IF((NB_SAT+NB_ZERO)SMALL_SET)THEN
.LT.                             IF(SMALL_SETNSLAVES_REF)THEN
                                SMALL_SET=REF+1
                                REF=REF+1
                                NB_ROWS=0
                                GOTO 323
                             ELSE
                                GOTO 434
                             ENDIF
                          ENDIF
                       ENDDO
 434                   CONTINUE
                       ADDITIONNAL_ROWS=NCB-ACC
.NE.                       IF(ADDITIONNAL_ROWS0)THEN
.LT.                          IF(ADDITIONNAL_ROWSKMIN)THEN
                             i=CHOSEN
                             J=ACC
 436                         CONTINUE
.NE.                             IF(NB_ROWS(i)0)THEN
                                J=J-NB_ROWS(i)
                                A=dble(1)
                                B=dble(J+2)
                                C=-BUF_SIZE+dble(J+NELIM)
                                DELTA=(B*B)-(dble(4)*A*C)
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                IF(XNCB-J) X=NCB-J
                                BANDE_K821=dble(X)*dble(NELIM+J+X)
                                IF(HAVE_TYPE1_SON)THEN
                                   A=dble(1)
                                   B=dble(J+2+NELIM)
                                   C=-BUF_SIZE+dble(J+NELIM)
                                   DELTA=(B*B)-(dble(4)*A*C)
                                   X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                   IF(XNCB-J) X=NCB-J
                                   BANDE_K821=dble(X)*dble(NELIM+J+X)
                                ENDIF
                                MAX_MEM_ALLOW=BANDE_K821
                                IF(BDC_MD)THEN
                                   MAX_MEM_ALLOW=min(
     &                         min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                                  BANDE_K821)
                                   MAX_MEM_ALLOW=max(dble(0),
     &                                  MAX_MEM_ALLOW)
                                ENDIF
                                A=dble(1)
                                B=dble(J+NELIM)
                                C=dble(-MAX_MEM_ALLOW)
                                DELTA=((B*B)-(dble(4)*A*C))
                                KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
.NE.                                IF(NB_ROWS(i)KMAX)THEN
.LE.                                   IF(NCB-JKMAX)THEN
                                      NB_ROWS(i)=+NCB-J
                                      ADDITIONNAL_ROWS=0
                                   ENDIF
                                ENDIF
                                TEMP_MAX_LOAD=max(TEMP_MAX_LOAD,
     &                               TEMP(i)+
     &                               (dble(NELIM) * dble(NB_ROWS(i)))*
     &                               dble(2*(NELIM+
     &                               ACC)-NB_ROWS(i)
     &                               -NELIM+1))
.LE.                                IF(REFNUMBER_OF_PROCS-1)THEN
.GT.                                   IF(TEMP_MAX_LOADTEMP(REF+1))THEN
.LT.                                      IF(SMALL_SETNSLAVES_REF)THEN
                                         SMALL_SET=REF+1
                                         REF=REF+1
                                         NB_ROWS=0
                                         GOTO 323
                                      ENDIF
                                   ENDIF
                                ENDIF
                             ELSE
                                i=i-1
.NE.                                IF(i0)GOTO 436
                             ENDIF
.NE.                             IF(ADDITIONNAL_ROWS0)THEN
                                i=CHOSEN
.NE.                                IF(iSMALL_SET)THEN
                                   i=i+1
.NE.                                   IF(NB_ROWS(i)0)THEN
                                      WRITE(*,*)MYID,
     &    ': internal error 5 in dmumps_set_parti_flop_irr'
                                      CALL MUMPS_ABORT()
                                   ENDIF
                                ENDIF
                                NB_ROWS(i)=NB_ROWS(i)+ADDITIONNAL_ROWS
                                ADDITIONNAL_ROWS=0
                             ENDIF
                             CHOSEN=i
                          ENDIF
                       ENDIF
                       i=CHOSEN+1
.NE.                       DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LE.     &                      (iNUMBER_OF_PROCS))
.LE.                          IF((TEMP(i)MAX_LOAD))THEN
                             A=dble(1)
                             B=dble(ACC+2)
                             C=-BUF_SIZE+dble(ACC+NELIM)
                             DELTA=(B*B)-(dble(4)*A*C)
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                             IF(XNCB-ACC) X=NCB-ACC
                             BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             IF(HAVE_TYPE1_SON)THEN
                                A=dble(1)
                                B=dble(ACC+2+NELIM)
                                C=-BUF_SIZE+dble(ACC+NELIM)
                                DELTA=(B*B)-(dble(4)*A*C)
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                IF(XNCB-ACC) X=NCB-ACC
                                BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             ENDIF
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                               BANDE_K821)
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             A=dble(1)
                             B=dble(ACC+NELIM)
                             C=dble(-MAX_MEM_ALLOW)
                             DELTA=((B*B)-(dble(4)*A*C))
                             KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                             A=dble(NELIM)
                             B=dble(NELIM)*dble(NELIM+2*ACC+1)
                             C=-(MAX_LOAD-TEMP(i))
                             DELTA=(B*B-(dble(4)*A*C))
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GE.                             IF(XKMAX)THEN
.GE.                                IF(KMAXKMIN)THEN
                                   X=KMAX
                                ELSE
                                   X=0
                                ENDIF
                             ELSE
.LT.                                IF(XKMIN)THEN
                                   X=0
                                ENDIF
                             ENDIF
.GT.                             IF((ACC+X)NCB) X=NCB-ACC
                             NB_ROWS(i)=X
                             ACC=ACC+X
                             ADDITIONNAL_ROWS=NCB-ACC
.GT.                          ELSE IF((TEMP(i)MAX_LOAD))THEN
                             MAX_LOAD=TEMP(i)
                             NB_SAT=0
                             ACC=0
                             NB_ROWS=0
                             DO J=1,i
                                A=dble(1)
                                B=dble(ACC+2)
                                C=-BUF_SIZE+dble(ACC+NELIM)
                                DELTA=(B*B)-(dble(4)*A*C)
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                IF(XNCB-ACC) X=NCB-ACC
                                BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                                IF(HAVE_TYPE1_SON)THEN
                                   A=dble(1)
                                   B=dble(ACC+2+NELIM)
                                   C=-BUF_SIZE+dble(ACC+NELIM)
                                   DELTA=(B*B)-(dble(4)*A*C)
                                   X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                   IF(XNCB-ACC) X=NCB-ACC
                                   BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                                ENDIF
                                MAX_MEM_ALLOW=BANDE_K821
                                IF(BDC_MD)THEN
                                   MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(J),MEM_SIZE_STRONG(J)),
     &                                  BANDE_K821)
                                   MAX_MEM_ALLOW=max(dble(0),
     &                                  MAX_MEM_ALLOW)
                                ENDIF
                                A=dble(1)
                                B=dble(ACC+NELIM)
                                C=dble(-MAX_MEM_ALLOW)
                                DELTA=((B*B)-(dble(4)*A*C))
                                KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                                A=dble(NELIM)
                                B=dble(NELIM)*dble(NELIM+2*ACC+1)
                                C=-(MAX_LOAD-TEMP(J))
                                DELTA=(B*B-(dble(4)*A*C))
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.LT.                                IF(X0) THEN
                                   WRITE(*,*)MYID,
     &    ': internal error 6 in dmumps_set_parti_flop_irr'
                                   CALL MUMPS_ABORT()
                                ENDIF
.GE.                                IF(XKMAX)THEN
.GE.                                   IF(KMAXKMIN)THEN
                                      X=KMAX
                                      NB_SAT=NB_SAT+1
                                   ELSE
                                      X=0
                                   ENDIF
                                ELSE
.LT.                                   IF(Xmin(KMIN,KMAX))THEN
                                      X=0
                                   ENDIF
                                ENDIF
.GT.                                IF((ACC+X)NCB) X=NCB-ACC
                                NB_ROWS(J)=X
                                IF(SMP)THEN
.GT.                                   IF(MIN_LOADTEMP(J))THEN
                                      MIN_LOAD=TEMP(J)
                                      POS_MIN_LOAD=i
                                   ENDIF
                                ENDIF
                                ACC=ACC+X
                                MAX_LOAD=max(MAX_LOAD,
     &                               TEMP(J)+
     &                               (dble(NELIM)*dble(NB_ROWS(J)))*
     &                               dble(2*(NELIM+
     &                               ACC)-NB_ROWS(J)
     &                               -NELIM+1))
.EQ.                                IF(NCBACC) GOTO 741
.LT.                                IF(NCB-ACCKMIN) GOTO 210
                             ENDDO
 210                         CONTINUE
                          ENDIF
 741                      CONTINUE
                          i=i+1
                          ADDITIONNAL_ROWS=NCB-ACC
                       ENDDO
                       CHOSEN=i-1
.NE.                       IF(ADDITIONNAL_ROWS0)THEN
                          ADDITIONNAL_ROWS=NCB-ACC
                          SOMME=dble(NELIM)*dble(ADDITIONNAL_ROWS)*
     &                         dble(2*NFRONT-ADDITIONNAL_ROWS-
     &                         NELIM+1)
                          SOMME=SOMME/dble(NUMBER_OF_PROCS)
                          NB_ROWS=0
                          ACC=0
                          CHOSEN=0
                          IF(SMP)THEN
                             MIN_LOAD=TEMP(1)
                             POS_MIN_LOAD=1
                          ENDIF
                          DO i=1,OTHERS
                             A=dble(1)
                             B=dble(ACC+2)
                             C=-BUF_SIZE+dble(ACC+NELIM)
                             DELTA=(B*B)-(dble(4)*A*C)
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                             IF(XNCB-ACC) X=NCB-ACC
                             BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             IF(HAVE_TYPE1_SON)THEN
                                A=dble(1)
                                B=dble(ACC+2+NELIM)
                                C=-BUF_SIZE+dble(ACC+NELIM)
                                DELTA=(B*B)-(dble(4)*A*C)
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                IF(XNCB-ACC) X=NCB-ACC
                                BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             ENDIF
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                               BANDE_K821)
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             A=dble(1)
                             B=dble(ACC+NELIM)
                             C=dble(-MAX_MEM_ALLOW)
                             DELTA=((B*B)-(dble(4)*A*C))
                             KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                             A=dble(NELIM)
                             B=dble(NELIM)*dble(NELIM+2*ACC+1)
                             C=-(MAX_LOAD-TEMP(i)+SOMME)
                             DELTA=(B*B-(dble(4)*A*C))
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
.LT.                             IF(X0) THEN
                                WRITE(*,*)MYID,
     &    ': internal error 7 in dmumps_set_parti_flop_irr'
                                CALL MUMPS_ABORT()
                             ENDIF
.GE.                             IF(XKMAX)THEN
.GE.                                IF(KMAXKMIN)THEN
                                   X=KMAX
                                ELSE
                                   X=0
                                ENDIF
                             ELSE
.LT.                                IF(Xmin(KMIN,KMAX))THEN
                                   X=min(KMAX,KMIN)
                                ENDIF
                             ENDIF
.GT.                             IF((ACC+X)NCB) X=NCB-ACC
                             NB_ROWS(i)=X
                             IF(SMP)THEN
.GT.                                IF(MIN_LOADTEMP(i))THEN
                                   MIN_LOAD=TEMP(i)
                                   POS_MIN_LOAD=i
                                ENDIF
                             ENDIF
                             CHOSEN=CHOSEN+1
                             ACC=ACC+X
.EQ.                             IF(NCBACC) GOTO 666
.LT.                             IF(NCB-ACCKMIN) GOTO 488
                          ENDDO
 488                      CONTINUE
                          ADDITIONNAL_ROWS=NCB-ACC
                          SOMME=dble(NELIM)*
     &                         dble(ADDITIONNAL_ROWS)*
     &                         dble(2*NFRONT-ADDITIONNAL_ROWS-
     &                         NELIM+1)
                          SOMME=SOMME/dble(NUMBER_OF_PROCS)
                          NB_ROWS=0
                          ACC=0
                          CHOSEN=0
                          IF(SMP)THEN
                             MIN_LOAD=TEMP(1)
                             POS_MIN_LOAD=1
                          ENDIF
                          DO i=1,OTHERS
                             A=dble(1)
                             B=dble(ACC+2)
                             C=-BUF_SIZE+dble(ACC+NELIM)
                             DELTA=(B*B)-(dble(4)*A*C)
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                             IF(XNCB-ACC) X=NCB-ACC
                             BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             IF(HAVE_TYPE1_SON)THEN
                                A=dble(1)
                                B=dble(ACC+2+NELIM)
                                C=-BUF_SIZE+dble(ACC+NELIM)
                                DELTA=(B*B)-(dble(4)*A*C)
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                IF(XNCB-ACC) X=NCB-ACC
                                BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                             ENDIF
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(BANDE_K821,
     &                               MEM_SIZE_STRONG(i))
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             A=dble(1)
                             B=dble(ACC+NELIM)
                             C=dble(-MAX_MEM_ALLOW)
                             DELTA=((B*B)-(dble(4)*A*C))
                             KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                             A=dble(NELIM)
                             B=dble(NELIM)*dble(NELIM+2*ACC+1)
                             C=-(MAX_LOAD-TEMP(i)+SOMME)
                             DELTA=(B*B-(dble(4)*A*C))
                             X=int((-B+sqrt(DELTA))/(dble(2)*A))
.LT.                             IF(X0) THEN
                                WRITE(*,*)MYID,
     &    ': internal error 8 in dmumps_set_parti_flop_irr'
                                CALL MUMPS_ABORT()
                             ENDIF
.GE.                             IF(XKMAX)THEN
                                X=KMAX
                             ELSE
.LT.                                IF(XKMIN)THEN
                                   X=KMIN
                                ENDIF
                             ENDIF
.GT.                             IF((ACC+X)NCB) X=NCB-ACC
                             NB_ROWS(i)=X
                             IF(SMP)THEN
.GT.                                IF(MIN_LOADTEMP(i))THEN
                                   MIN_LOAD=TEMP(i)
                                   POS_MIN_LOAD=i
                                ENDIF
                             ENDIF
                             CHOSEN=CHOSEN+1
                             ACC=ACC+X
.EQ.                             IF(NCBACC) GOTO 666
.LT.                             IF(NCB-ACCKMIN) GOTO 477
                          ENDDO
 477                      CONTINUE
.NE.                          IF(ACCNCB)THEN
                             NB_SAT=0
                             ACC=0
                             CHOSEN=0
                             IF(SMP)THEN
                                MIN_LOAD=TEMP(1)
                                POS_MIN_LOAD=1
                             ENDIF
                             DO i=1,OTHERS
                                A=dble(1)
                                B=dble(ACC+2)
                                C=-BUF_SIZE+dble(ACC+NELIM)
                                DELTA=(B*B)-(dble(4)*A*C)
                                X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                IF(XNCB-ACC) X=NCB-ACC
                                BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                                IF(HAVE_TYPE1_SON)THEN
                                   A=dble(1)
                                   B=dble(ACC+2+NELIM)
                                   C=-BUF_SIZE+dble(ACC+NELIM)
                                   DELTA=(B*B)-(dble(4)*A*C)
                                   X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                   IF(XNCB-ACC) X=NCB-ACC
                                   BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                                ENDIF
                                MAX_MEM_ALLOW=BANDE_K821
                                IF(BDC_MD)THEN
                                   MAX_MEM_ALLOW=min(BANDE_K821,
     &                                  MEM_SIZE_STRONG(i))
                                   MAX_MEM_ALLOW=max(dble(0),
     &                                  MAX_MEM_ALLOW)
                                ENDIF
                                A=dble(1)
                                B=dble(ACC+NELIM)
                                C=dble(-MAX_MEM_ALLOW)
                                DELTA=((B*B)-(dble(4)*A*C))
                                KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                                X=KMAX-NB_ROWS(i)
.GT.                                IF((ACC+NB_ROWS(i)+X)NCB)
     &                               X=NCB-(ACC+NB_ROWS(i))
                                NB_ROWS(i)=NB_ROWS(i)+X
                                IF((dble(NB_ROWS(i))*
.EQ.     &                               dble(NB_ROWS(i)+ACC))
     &                               BANDE_K821)THEN
                                   NB_SAT=NB_SAT+1
                                ENDIF
                                ACC=ACC+NB_ROWS(i)
                                IF(SMP)THEN
.GT.                                   IF(MIN_LOADTEMP(i))THEN
                                      MIN_LOAD=TEMP(i)
                                      POS_MIN_LOAD=i
                                   ENDIF
                                ENDIF
                                CHOSEN=CHOSEN+1
.EQ.                                IF(NCBACC) GOTO 666
.LT.                                IF(NCB-ACCKMIN) GOTO 834
                             ENDDO
 834                         CONTINUE
                          ENDIF
.NE.                          IF(ACCNCB)THEN
                            ADDITIONNAL_ROWS=NCB-ACC
                            SOMME=dble(NELIM)*
     &                           dble(ADDITIONNAL_ROWS)*
     &                           dble(2*NFRONT-ADDITIONNAL_ROWS-
     &                           NELIM+1)
                            SOMME=SOMME/dble(NUMBER_OF_PROCS-NB_SAT)
                            ACC=0
                            DO i=1,CHOSEN
                               A=dble(1)
                               B=dble(ACC+2)
                               C=-BUF_SIZE+dble(ACC+NELIM)
                               DELTA=(B*B)-(dble(4)*A*C)
                               X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                               IF(XNCB-ACC) X=NCB-ACC
                               BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                               IF(HAVE_TYPE1_SON)THEN
                                  A=dble(1)
                                  B=dble(ACC+2+NELIM)
                                  C=-BUF_SIZE+dble(ACC+NELIM)
                                  DELTA=(B*B)-(dble(4)*A*C)
                                  X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                                  IF(XNCB-ACC) X=NCB-ACC
                                  BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                               ENDIF
                               IF((dble(NB_ROWS(i))*
.EQ.     &                              dble(NB_ROWS(i)+ACC))
     &                              BANDE_K821)THEN
                                  GOTO 102
                               ENDIF
                               A=dble(NELIM)
                               B=dble(NELIM)*
     &                              dble(NELIM+2*(ACC+NB_ROWS(i))+1)
                               C=-(SOMME)
                               DELTA=(B*B-(dble(4)*A*C))
                               X=int((-B+sqrt(DELTA))/(dble(2)*A))
                               A=dble(1)
                               B=dble(ACC+NELIM)
                               C=dble(-BANDE_K821)
                               DELTA=((B*B)-(dble(4)*A*C))
                               KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
.LT.                               IF(X0) THEN
                                  WRITE(*,*)MYID,
     &    ': internal error 9 in dmumps_set_parti_flop_irr'
                                  CALL MUMPS_ABORT()
                               ENDIF
.GT.                               IF((ACC+X+NB_ROWS(i))NCB)THEN
.GT.                                  IF((NCB-ACC)KMAX)THEN
                                     NB_ROWS(i)=KMAX
                                  ELSE
                                     NB_ROWS(i)=NCB-ACC
                                  ENDIF
                               ELSE
.GT.                                  IF((NB_ROWS(i)+X)KMAX)THEN
                                     NB_ROWS(i)=KMAX
                                  ELSE
                                     NB_ROWS(i)=NB_ROWS(i)+X
                                  ENDIF
                               ENDIF
 102                           CONTINUE
                               ACC=ACC+NB_ROWS(i)
.EQ.                               IF(NCBACC) THEN
                                  CHOSEN=i
                                  GOTO 666
                               ENDIF
.LT.                               IF(NCB-ACCKMIN) THEN
                                  CHOSEN=i
                                  GOTO 007
                               ENDIF
                            ENDDO
 007                        CONTINUE
                            DO i=1,CHOSEN
                               NB_ROWS(i)=NB_ROWS(i)+1
                               ACC=ACC+1
.EQ.                               IF(ACCNCB)GOTO 666
                            ENDDO
.LT.                            IF(ACCNCB)THEN
                               IF(SMP)THEN
                                  NB_ROWS(1)=NB_ROWS(1)+NCB-ACC
                               ELSE
                                  NB_ROWS(POS_MIN_LOAD)=
     &                                 NB_ROWS(POS_MIN_LOAD)+NCB-ACC
                               ENDIF
                            ENDIF
                         ENDIF
                         GOTO 666
                     ENDIF
                  ENDIF
                  GOTO 666
                 ENDIF
                 ADDITIONNAL_ROWS=NCB-ACC
                 i=CHOSEN+1
.EQ.                 IF(NB_SATSMALL_SET) GOTO 777
                 DO i=1,SMALL_SET
                    IDWLOAD(i)=i
                    AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                    BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                    IF(HAVE_TYPE1_SON)THEN
                       AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                      (dble(NFRONT+1)))
                       BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                    ENDIF
                    MAX_MEM_ALLOW=BANDE_K821
                    IF(BDC_MD)THEN
                       MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                      BANDE_K821)
                       MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                    ENDIF
                    WLOAD(i)=MAX_MEM_ALLOW
                 ENDDO
                 CALL MUMPS_SORT_DOUBLES(SMALL_SET, WLOAD, IDWLOAD)
                 NB_ZERO=0
.EQ..AND.                 IF((NB_SATSMALL_SET)
.LT.     &                (SMALL_SETNSLAVES_REF))THEN
                    SMALL_SET=REF+1
                    REF=REF+1
                    NB_ROWS=0
                    GOTO 323
                 ENDIF
.EQ..AND.                 IF((NB_SATSMALL_SET)
.LE.     &                (SMALL_SETNUMBER_OF_PROCS))GOTO 777
                 AFFECTED=int(ADDITIONNAL_ROWS/(SMALL_SET-NB_SAT))
                 AFFECTED=max(AFFECTED,1)
                 DO i=1,SMALL_SET
                    KMAX=int(WLOAD(i)/dble(NFRONT))
.EQ.                    IF(NB_ROWS(IDWLOAD(i))KMAX)THEN 
                       GOTO 912
                    ENDIF
                    IF((NB_ROWS(IDWLOAD(i))+min(AFFECTED,
.GT.     &                   ADDITIONNAL_ROWS))KMAX)THEN
.GT.                       IF(NB_ROWS(IDWLOAD(i))KMAX)THEN
                       ENDIF
                       ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                      (KMAX-NB_ROWS(IDWLOAD(i)))
                       NB_ROWS(IDWLOAD(i))=KMAX
                       NB_SAT=NB_SAT+1
.EQ.                       IF(NB_SATSMALL_SET)THEN
.NE.                          IF(SMALL_SETNSLAVES_REF)THEN
                             SMALL_SET=REF+1
                             REF=REF+1
                             NB_ROWS=0
                             GOTO 323
                          ELSE
                             MAX_LOAD=max(MAX_LOAD,
     &                            (TEMP(IDWLOAD(i))+(dble(NELIM) *
     &                            dble(NB_ROWS(IDWLOAD(i))))+
     &                            (dble(NB_ROWS(IDWLOAD(i)))*
     &                            dble(NELIM))*
     &                            dble(2*NFRONT-NELIM-1)))
                             GOTO 777
                          ENDIF
                       ENDIF
                       AFFECTED=int(ADDITIONNAL_ROWS/(SMALL_SET-NB_SAT))
                       AFFECTED=max(AFFECTED,1)
                    ELSE
                       IF((NB_ROWS(IDWLOAD(i))+min(AFFECTED,
.GE.     &                      ADDITIONNAL_ROWS))KMIN)THEN
                          X=min(AFFECTED,ADDITIONNAL_ROWS)
                          NB_ROWS(IDWLOAD(i))=NB_ROWS(IDWLOAD(i))+
     &                         X
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                       ELSE
                          X=int((MAX_LOAD-TEMP(IDWLOAD(i)))/
     &                         (dble(NELIM)*dble(2*NFRONT-NELIM)))
.GT.                          IF(X+AFFECTEDADDITIONNAL_ROWS)THEN
                             X=ADDITIONNAL_ROWS
                          ELSE
                             X=AFFECTED+X
                          ENDIF
.GE.                          IF(XKMIN)THEN
                             NB_ROWS(IDWLOAD(i))=NB_ROWS(IDWLOAD(i))+
     &                            X
                             ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                            X
                          ELSE
                             NB_ZERO=NB_ZERO+1
                          ENDIF
                       ENDIF
                    ENDIF
 912                CONTINUE
                    MAX_LOAD=max(MAX_LOAD,
     &                   (TEMP(IDWLOAD(i))+(dble(NELIM)*
     &                   dble(NB_ROWS(IDWLOAD(i))))+
     &                   (dble(NB_ROWS(IDWLOAD(i)))*dble(NELIM))*
     &                   dble(2*NFRONT-NELIM-1)))
.LT.                    IF(SMALL_SETNUMBER_OF_PROCS)THEN
.GT.                       IF(MAX_LOADTEMP(SMALL_SET+1))THEN
.LT.                          IF(SMALL_SETNSLAVES_REF)THEN
                             SMALL_SET=REF+1
                             REF=REF+1
                             NB_ROWS=0
                             GOTO 323
                          ENDIF
                       ENDIF
                    ENDIF
.EQ.                    IF(SMALL_SETNB_SAT)GOTO 777
.EQ.                    IF(ADDITIONNAL_ROWS0)THEN
                       CHOSEN=SMALL_SET
                       GOTO 049
                    ENDIF
                 ENDDO
 777             CONTINUE
.NE..AND..GE.                 IF((NB_ZERO0)(ADDITIONNAL_ROWSKMIN))THEN
                    J=NB_ZERO
 732                CONTINUE
                    X=int(ADDITIONNAL_ROWS/(J))
.LT.                    IF(XKMIN)THEN
                       J=J-1
                       GOTO 732
                    ENDIF
.LT.                    IF(X*JADDITIONNAL_ROWS)THEN
                       X=X+1
                    ENDIF
                    DO i=1,SMALL_SET
                       AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                       BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       IF(HAVE_TYPE1_SON)THEN
                          AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                         dble(NFRONT+1))
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       ENDIF
                       MAX_MEM_ALLOW=BANDE_K821
                       IF(BDC_MD)THEN
                          MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                         dble(BANDE_K821))
                          MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                       ENDIF
                       KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.EQ.                       IF(NB_ROWS(i)0)THEN
.GT.                          IF(XADDITIONNAL_ROWS)THEN
                             X=ADDITIONNAL_ROWS
                          ENDIF
.GT.                          IF(XKMAX)THEN
                             X=KMAX
                          ENDIF
.GT.                          IF(XKMIN)THEN
                             NB_ROWS(i)=X
                             ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                             MAX_LOAD=max(MAX_LOAD,
     &                            (TEMP(i)+(dble(NELIM) *
     &                            dble(NB_ROWS(i)))+
     &                            (dble(NB_ROWS(i))*dble(NELIM))*
     &                            dble(2*NFRONT-NELIM-1)))
                          ENDIF
                       ENDIF
                    ENDDO
                 ENDIF
                 i=CHOSEN+1
.NE.                 DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LE.     &                (iNUMBER_OF_PROCS))
.LE.                    IF((TEMP(i)MAX_LOAD))THEN
                       AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                       BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       IF(HAVE_TYPE1_SON)THEN
                          AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                         dble(NFRONT+1))
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       ENDIF
                       MAX_MEM_ALLOW=BANDE_K821
                       IF(BDC_MD)THEN
                          MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                         BANDE_K821)
                          MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                       ENDIF
                       KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
                       AFFECTED=int((MAX_LOAD-TEMP(i))/
     &                      (dble(NELIM)*dble(2*NFRONT-NELIM)))
.GT.                       IF(AFFECTEDADDITIONNAL_ROWS)THEN
                          AFFECTED=ADDITIONNAL_ROWS
                       ENDIF
.LT.                       IF(NB_ROWS(i)KMAX)THEN
.GT.                          IF((AFFECTED+NB_ROWS(i))KMAX)THEN
                             AFFECTED=KMAX-NB_ROWS(i)
                             NB_SAT=NB_SAT+1
                          ELSE
.LT.                             IF((AFFECTED+NB_ROWS(i))
     &                            KMIN)THEN
                                AFFECTED=0
                             ENDIF
                          ENDIF
                          NB_ROWS(i)=NB_ROWS(i)+AFFECTED
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-AFFECTED
                       ENDIF
.GT.                    ELSE IF((TEMP(i)MAX_LOAD))THEN
.EQ.                       IF(NB_SATi-1) GOTO 218
                       X=(ADDITIONNAL_ROWS/(i-1-NB_SAT))
                       ACC=1
                       DO J=1,i-1
                          TMP_SUM=((dble(NELIM) * dble(NB_ROWS(J)+X))
     &                         +(dble(NB_ROWS(J)+X)*dble(NELIM))*
     &                         dble(2*NFRONT-NELIM-1))
.GT.                          IF((TEMP(J)+TMP_SUM)MAX_LOAD)THEN
                             ACC=0
                          ENDIF
                       ENDDO
.EQ.                       IF(ACC1)THEN
                          MAX_LOAD=TEMP(i)
                          J=1
.NE.                          DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LT.     &                         (Ji))
                             AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                             BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                             IF(HAVE_TYPE1_SON)THEN
                                AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                               dble(NFRONT+1))
                                BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                             ENDIF
                             AFFECTED=X
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(J),MEM_SIZE_STRONG(J)),
     &                               BANDE_K821)
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.GT.                             IF(AFFECTEDADDITIONNAL_ROWS)THEN
                                AFFECTED=ADDITIONNAL_ROWS
                             ENDIF
.LT.                             IF(NB_ROWS(J)KMAX)THEN
.GT.                                IF((AFFECTED+NB_ROWS(J))KMAX)THEN
                                   AFFECTED=KMAX-NB_ROWS(J)
                                   NB_SAT=NB_SAT+1
                                ELSE
.LT.                                   IF((AFFECTED+NB_ROWS(J))
     &                                  KMIN)THEN
                                      AFFECTED=0
                                   ENDIF
                                ENDIF
                                NB_ROWS(J)=NB_ROWS(J)+AFFECTED
                                ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                               AFFECTED
                             ENDIF
                             J=J+1
                          ENDDO                          
                       ELSE
                          MAX_LOAD=TEMP(i)
                          J=1
.NE.                          DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LT.     &                         (Ji))
                             AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                             BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                             IF(HAVE_TYPE1_SON)THEN
                                AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                               dble(NFRONT+1))
                                BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                             ENDIF
                             TMP_SUM=((dble(NELIM)* dble(NB_ROWS(J)))
     &                            +(dble(NB_ROWS(J))*dble(NELIM))*
     &                            dble(2*NFRONT-NELIM-1))
                             X=int((MAX_LOAD-(TEMP(J)+TMP_SUM))/
     &                            (dble(NELIM)*dble(2*NFRONT-NELIM)))
.LT.                             IF(X0)THEN
                                WRITE(*,*)MYID,
     &    ': internal error 10 in dmumps_set_parti_flop_irr'
                                CALL MUMPS_ABORT()
                             ENDIF
                             AFFECTED=X
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(J),MEM_SIZE_STRONG(J)),
     &                               BANDE_K821)
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.GT.                             IF(AFFECTEDADDITIONNAL_ROWS)THEN
                                AFFECTED=ADDITIONNAL_ROWS
                             ENDIF
.LT.                             IF(NB_ROWS(J)KMAX)THEN
.GT.                                IF((AFFECTED+NB_ROWS(J))KMAX)THEN
                                   AFFECTED=KMAX-NB_ROWS(J)
                                   NB_SAT=NB_SAT+1
                                ELSE
.LT.                                   IF((AFFECTED+NB_ROWS(J))
     &                                  KMIN)THEN
                                      AFFECTED=0
                                   ENDIF
                                ENDIF
                                NB_ROWS(J)=NB_ROWS(J)+AFFECTED
                                ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                               AFFECTED
                             ENDIF
                             J=J+1
                          ENDDO
                       ENDIF
                    ENDIF
 218                CONTINUE
                    i=i+1
                 ENDDO
                 CHOSEN=i-1
.EQ..AND.                 IF((CHOSENNUMBER_OF_PROCS-1)
.NE.     &                 (ADDITIONNAL_ROWS0))THEN
                    DO i=1,CHOSEN
.GE.                       IF(NB_ROWS(i)+1KMIN)THEN
                          NB_ROWS(i)=NB_ROWS(i)+1
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-1
                       ENDIF
                       MAX_LOAD=max(MAX_LOAD,
     &                      (TEMP(i)+(dble(NELIM) *
     &                      dble(NB_ROWS(i)))+
     &                      (dble(NB_ROWS(i))*dble(NELIM))*
     &                      dble(2*NFRONT-NELIM-1)))
.EQ.                       IF(ADDITIONNAL_ROWS0) GOTO 048
                    ENDDO
 048                CONTINUE
                 ENDIF
.NE.                 IF((ADDITIONNAL_ROWS0))THEN
.LT.                    IF(CHOSENNUMBER_OF_PROCS)THEN
                       i=CHOSEN+1
                    ELSE
.NE.                       IF(CHOSENNUMBER_OF_PROCS)THEN
                          WRITE(*,*)MYID,
     &    ': internal error 11 in dmumps_set_parti_flop_irr'
                          CALL MUMPS_ABORT()
                       ENDIF
                       i=CHOSEN
                    ENDIF
.NE.                    DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LE.     &                   (iNUMBER_OF_PROCS))
.LE.                       IF(TEMP(i)MAX_LOAD)THEN
                          AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                          IF(HAVE_TYPE1_SON)THEN
                             AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                            dble(NFRONT+1))
                             BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                          ENDIF
                          MAX_MEM_ALLOW=BANDE_K821
                          IF(BDC_MD)THEN
                             MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                            BANDE_K821)
                             MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                          ENDIF
                          KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
                          TMP_SUM=((dble(NELIM) * dble(NB_ROWS(i)))
     &                         +(dble(NB_ROWS(i))*dble(NELIM))*
     &                         dble(2*NFRONT-NELIM-1))
                          X=int((MAX_LOAD-(TEMP(i)+TMP_SUM))/
     &                         (dble(NELIM)*dble(2*NFRONT-NELIM)))
                          AFFECTED=X
.LT.                          IF(X0)THEN
                             WRITE(*,*)MYID,
     &    ': internal error 12 in dmumps_set_parti_flop_irr'
                             CALL MUMPS_ABORT()
                          ENDIF
.GT.                          IF(AFFECTEDADDITIONNAL_ROWS)THEN
                             AFFECTED=ADDITIONNAL_ROWS
                          ENDIF
.LT.                          IF(NB_ROWS(i)KMAX)THEN
.GT.                             IF((AFFECTED+NB_ROWS(i))KMAX)THEN
                                AFFECTED=KMAX-NB_ROWS(i)
                             ELSE
.LT.                                IF((AFFECTED+NB_ROWS(i))
     &                               KMIN)THEN
                                   AFFECTED=0
                                ENDIF
                             ENDIF
                             NB_ROWS(i)=NB_ROWS(i)+AFFECTED
                             ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-AFFECTED
                          ENDIF
.NE.                          IF(iNUMBER_OF_PROCS) GOTO 624
.GT.                       ELSE IF((TEMP(i)MAX_LOAD))THEN
                          X=int(ADDITIONNAL_ROWS/i-1)
                          X=max(X,1)
                          IF((MAX_LOAD+((dble(NELIM)*
     &                         dble(X))+(dble(
     &                         X)*dble(NELIM))*dble(
.LE.     &                         (2*NFRONT-NELIM-1))))TEMP(i))THEN
                             AFFECTED=X
                             POS=1
                          ELSE
                             POS=0
                          ENDIF
                          MAX_LOAD=TEMP(i)
                          J=1
.NE.                          DO WHILE ((ADDITIONNAL_ROWS0)
.AND..LT.     &                         (Ji))
                             X=int(BUF_SIZE/dble(NCB+1))-1
                             BANDE_K821=dble(X)*dble(NFRONT)
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(HAVE_TYPE1_SON)THEN
                                X=int((BUF_SIZE-dble(NFRONT))/
     &                               dble(NFRONT+1))
                                BANDE_K821=dble(X)*dble(NFRONT)
                             ENDIF
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(J),MEM_SIZE_STRONG(J)),
     &                               BANDE_K821)
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.EQ.                             IF(POS0)THEN
                                TMP_SUM=((dble(NELIM) *
     &                               dble(NB_ROWS(J)))
     &                               +(dble(NB_ROWS(J))*dble(NELIM))*
     &                               dble(2*NFRONT-NELIM-1))
                                X=int((TEMP(i)-(TEMP(J)+TMP_SUM))/
     &                               (dble(NELIM)*dble(2*NFRONT-
     &                               NELIM)))
                             ELSE
                                X=int(TMP_SUM)
                             ENDIF
.GT.                             IF(XADDITIONNAL_ROWS)THEN
                                X=ADDITIONNAL_ROWS
                             ENDIF
.LT.                             IF(NB_ROWS(J)KMAX)THEN
.GT.                                IF((X+NB_ROWS(J))KMAX)THEN
                                   X=KMAX-NB_ROWS(J)
                                ELSE
.LT.                                   IF((NB_ROWS(J)+X)
     &                                  KMIN)THEN
                                     X=0
                                  ENDIF
                               ENDIF
                               NB_ROWS(J)=NB_ROWS(J)+X
                               ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                            ENDIF
                            J=J+1
                         ENDDO
                       ENDIF
 624                   CONTINUE
                       i=i+1
                    ENDDO
                    CHOSEN=i-1
.NE.                    IF(ADDITIONNAL_ROWS0)THEN
                       ACC=0
                       DO i=1,CHOSEN
                          X=int(BUF_SIZE/dble(NCB+1))-1
                          BANDE_K821=dble(X)*dble(NFRONT)
                          IF(HAVE_TYPE1_SON)THEN
                             X=int((BUF_SIZE-dble(NFRONT))/
     &                            dble(NFRONT+1))
                             BANDE_K821=dble(X)*dble(NFRONT)
                          ENDIF
                          MAX_MEM_ALLOW=BANDE_K821
                          IF(BDC_MD)THEN
                             MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                            BANDE_K821)
                             MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                          ENDIF
                             KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
                          TMP_SUM=((dble(NELIM) * dble(NB_ROWS(i)))
     &                    +(dble(NB_ROWS(i))*dble(NELIM))*
     &                    dble(2*NFRONT-NELIM-1))
                          X=int((MAX_LOAD-
     &                         (TEMP(i)+TMP_SUM))/
     &                         (dble(NELIM)*dble(2*NFRONT-NELIM)))
.LT.                          IF(X0)THEN
                             WRITE(*,*)MYID,
     &    ': internal error 13 in dmumps_set_parti_flop_irr'
                             CALL MUMPS_ABORT()
                          ENDIF
.GT.                          IF(XADDITIONNAL_ROWS)THEN
                             X=ADDITIONNAL_ROWS
                          ENDIF
.LT.                          IF(NB_ROWS(i)KMAX)THEN
.GE.                             IF((X+NB_ROWS(i))KMAX)THEN
                                ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                               (KMAX-NB_ROWS(i))
                                NB_ROWS(i)=KMAX
                             ELSE
.GE.                                IF((X+NB_ROWS(i))
     &                               KMIN)THEN
                                   NB_ROWS(i)=NB_ROWS(i)+X
                                   ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                                   ACC=ACC+1
                                ELSE
                                   ACC=ACC+1
                                ENDIF
                             ENDIF
                          ENDIF
.EQ.                          IF(ADDITIONNAL_ROWS0)GOTO 049
                       ENDDO
.LT.                       IF(CHOSENNUMBER_OF_PROCS)THEN
                          CHOSEN=CHOSEN+1
                       ENDIF
.EQ.                       IF(ACC0)THEN
                          ACC=1
                       ENDIF
                       X=int(ADDITIONNAL_ROWS/ACC)
                       X=max(X,1)
                       ACC=0
                       DO i=1,CHOSEN
                          J=int(BUF_SIZE/dble(NCB+1))-1
                          BANDE_K821=dble(J)*dble(NFRONT)
                          IF(HAVE_TYPE1_SON)THEN
                             J=int((BUF_SIZE-dble(NFRONT))/
     &                            dble(NFRONT+1))
                             BANDE_K821=dble(J)*dble(NFRONT)
                          ENDIF
                          MAX_MEM_ALLOW=BANDE_K821
                          IF(BDC_MD)THEN
                             MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                            BANDE_K821)
                             MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                          ENDIF
                          KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
                          TMP_SUM=((dble(NELIM) * dble(NB_ROWS(i)))
     &                         +(dble(NB_ROWS(i))*dble(NELIM))*
     &                         dble(2*NFRONT-NELIM-1))
                          J=int((MAX_LOAD-
     &                         (TEMP(i)+TMP_SUM))/
     &                         (dble(NELIM)*dble(2*NFRONT-NELIM)))
.LT.                          IF(NB_ROWS(i)KMAX)THEN
.GE.                             IF((min(X,J)+NB_ROWS(i))KMAX)THEN
.GT.                                IF((KMAX-NB_ROWS(i))
     &                               ADDITIONNAL_ROWS)THEN
                                   NB_ROWS(i)=NB_ROWS(i)+
     &                                  ADDITIONNAL_ROWS
                                   ADDITIONNAL_ROWS=0
                                ELSE
                                   ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                                  (KMAX-NB_ROWS(i))
                                   NB_ROWS(i)=KMAX
                                ENDIF
                             ELSE
.GE.                                IF((min(X,J)+NB_ROWS(i))
     &                            KMIN)THEN
                                   NB_ROWS(i)=NB_ROWS(i)+min(X,J)
                                   ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                                  min(X,J)
                                   ACC=ACC+1
                                ENDIF
                             ENDIF
                          ENDIF
.EQ.                          IF(ADDITIONNAL_ROWS0)GOTO 049
                       ENDDO
.GT.                       IF(ACC0)THEN
                          DO i=1,CHOSEN
                             X=int(BUF_SIZE/dble(NCB+1))-1
                             BANDE_K821=dble(X)*dble(NFRONT)
                             IF(HAVE_TYPE1_SON)THEN
                                X=int((BUF_SIZE-dble(NFRONT))/
     &                               dble(NFRONT+1))
                                BANDE_K821=dble(X)*dble(NFRONT)
                             ENDIF
                             MAX_MEM_ALLOW=BANDE_K821
                             IF(BDC_MD)THEN
                                MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)),
     &                               BANDE_K821)
                                MAX_MEM_ALLOW=max(dble(0),
     &                               MAX_MEM_ALLOW)
                             ENDIF
                             KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.LT.                             IF(KMAX-NB_ROWS(i)
     &                            ADDITIONNAL_ROWS)THEN
                                ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                               (KMAX-NB_ROWS(i))
                                NB_ROWS(i)=KMAX
                             ELSE
.EQ.                                IF(NB_ROWS(i)0)THEN
.LT.                                   IF(min(KMIN,KMAX)
     &                                  ADDITIONNAL_ROWS)THEN
                                      NB_ROWS(i)=min(KMIN,KMAX)
                                      ADDITIONNAL_ROWS=
     &                                     ADDITIONNAL_ROWS-
     &                                     min(KMIN,KMAX)
                                   ENDIF
                                ELSE
                                   NB_ROWS(i)=NB_ROWS(i)+
     &                                  ADDITIONNAL_ROWS
                                   ADDITIONNAL_ROWS=0
                                ENDIF
                             ENDIF
.EQ.                             IF(ADDITIONNAL_ROWS0)GOTO 049
                          ENDDO
                       ENDIF
                       DO i=1,CHOSEN
                          IDWLOAD(i)=i
                          AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                          IF(HAVE_TYPE1_SON)THEN
                             AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                            dble(NFRONT+1))
                             BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                          ENDIF                          
                          WLOAD(i)=(BANDE_K821-dble(NB_ROWS(i)*NFRONT))
                       ENDDO
                       CALL MUMPS_SORT_DOUBLES(NUMBER_OF_PROCS, WLOAD,
     &                      IDWLOAD)
                       NB_SAT=0
                       DO i=1,CHOSEN
                          X=int(ADDITIONNAL_ROWS/(CHOSEN-NB_SAT))
                          X=max(X,1)
                          AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                          IF(HAVE_TYPE1_SON)THEN
                             AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                            dble(NFRONT+1))
                             BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                          ENDIF
                          IF(BDC_MD)THEN
                             MAX_MEM_ALLOW=min(BANDE_K821,
     &                            MEM_SIZE_STRONG(i))
                             MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                          ENDIF
                          KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.LT.                          IF(NB_ROWS(IDWLOAD(i))KMAX)THEN
.LT.                             IF((NB_ROWS(IDWLOAD(i))+X)KMAX)THEN
                                NB_ROWS(IDWLOAD(i))=
     &                               NB_ROWS(IDWLOAD(i))+X
                                ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                             ELSE
                                ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                               (KMAX-NB_ROWS(IDWLOAD(i)))
                                NB_ROWS(IDWLOAD(i))=KMAX
                             ENDIF
                          ENDIF
.EQ.                          IF(NB_ROWS(IDWLOAD(i))KMAX)THEN
                             NB_SAT=NB_SAT+1
                          ENDIF
.EQ.                          IF(ADDITIONNAL_ROWS0) GOTO 049
                       ENDDO
                       DO i=1,CHOSEN
                          X=int(BUF_SIZE/dble(NCB+1))-1
                          BANDE_K821=dble(X)*dble(NFRONT)
                          IF(HAVE_TYPE1_SON)THEN
                             X=int((BUF_SIZE-dble(NFRONT))/
     &                            dble(NFRONT+1))
                             BANDE_K821=dble(X)*dble(NFRONT)
                          ENDIF
                          MAX_MEM_ALLOW=BANDE_K821
                          IF(BDC_MD)THEN
                             MAX_MEM_ALLOW=min(BANDE_K821,
     &                            MEM_SIZE_STRONG(i))
                             MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                          ENDIF
                          KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.LT.                          IF(KMAX-NB_ROWS(i)ADDITIONNAL_ROWS)THEN
                             ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                            (KMAX-NB_ROWS(i))
                             NB_ROWS(i)=KMAX
                          ELSE
                             NB_ROWS(i)=NB_ROWS(i)+ADDITIONNAL_ROWS
                             ADDITIONNAL_ROWS=0
                          ENDIF
.EQ.                          IF(ADDITIONNAL_ROWS0)GOTO 049
                       ENDDO
                       X=int(ADDITIONNAL_ROWS/CHOSEN)
                       X=max(X,1)
                       DO i=1,CHOSEN
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                          NB_ROWS(i)=NB_ROWS(i)+X
.EQ.                          IF(ADDITIONNAL_ROWS0)GOTO 049
                       ENDDO
                       NB_ROWS(1)=NB_ROWS(1)+ADDITIONNAL_ROWS
                    ENDIF
                 ENDIF
 049             CONTINUE
              ENDIF
 666          CONTINUE
              SOMME=dble(0)
              X=0
              POS=0
              DO i=1,CHOSEN
                 X=X+NB_ROWS(i)
                 SOMME=SOMME+ dble(NB_ROWS(i))
              ENDDO
              GOTO 890
.GE..AND.           ELSE IF((KEEP(83)NUMBER_OF_PROCS)FORCE_CAND)THEN
              MAX_LOAD=dble(0)
              DO i=1,OTHERS
                 MAX_LOAD=max(MAX_LOAD,TEMP(i))
              ENDDO
              ACC=0
              CHOSEN=0
              X=1
              DO i=1,OTHERS
              ENDDO
              DO i=2,OTHERS 
.EQ.                 IF(TEMP(i)TEMP(1))THEN
                    X=X+1
                 ELSE 
                    GOTO 329
                 ENDIF
              ENDDO
 329          CONTINUE
              TMP_SUM=TOTAL_COST/dble(X)
              TEMP_MAX_LOAD=dble(0)
              DO i=1,OTHERS
.EQ.                 IF(K500)THEN
                    X=int(BUF_SIZE/dble(NCB+1))-1
                    BANDE_K821=dble(X)*dble(NFRONT)
                 ELSE
                    A=dble(1)
                    B=dble(ACC+2)
                    C=-BUF_SIZE+dble(ACC+NELIM)
                    DELTA=(B*B)-(dble(4)*A*C)
                    X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                    IF(XNCB-ACC) X=NCB-ACC
                    BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                 ENDIF
                 IF(HAVE_TYPE1_SON)THEN
.EQ.                    IF(K500)THEN
                       X=int((BUF_SIZE-dble(NFRONT))/dble(NFRONT+1))
                       BANDE_K821=dble(X)*dble(NFRONT)
                    ELSE
                       A=dble(1)
                       B=dble(ACC+2+NELIM)
                       C=-BUF_SIZE+dble(ACC+NELIM)
                       DELTA=(B*B)-(dble(4)*A*C)
                       X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                       IF(XNCB-ACC) X=NCB-ACC
                       BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                    ENDIF
                 ENDIF
                 MAX_MEM_ALLOW=BANDE_K821
                 IF(BDC_MD)THEN
                    MAX_MEM_ALLOW=min(BANDE_K821,
     &                    min(MEM_SIZE_WEAK(i),MEM_SIZE_STRONG(i)))
                    MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                 ENDIF
.EQ.                 IF(K500)THEN
                       KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.GT.                    IF(TMP_SUM+TEMP(i)MAX_LOAD)THEN
                       SOMME=MAX_LOAD-TEMP(i)
                    ELSE
                       SOMME=TMP_SUM
                    ENDIF
                    X=int(SOMME/
     &                   (dble(NELIM)*dble(2*NFRONT-NELIM)))
.GT.                    IF(XKMAX)THEN
                       X=KMAX
                    ELSE
.LT.                       IF(XKMIN)THEN
                          X=min(KMIN,KMAX)
                       ENDIF
                    ENDIF
.GT.                    IF((ACC+X)NCB) X=NCB-ACC
                 ENDIF
.NE.                 IF(K500)THEN
                       A=dble(1)
                       B=dble(ACC+NELIM)
                       C=dble(-MAX_MEM_ALLOW)
                       DELTA=((B*B)-(dble(4)*A*C))
                       KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                    A=dble(NELIM)
                    B=dble(NELIM)*dble(NELIM+2*ACC+1)
.GT.                    IF(TMP_SUM+TEMP(i)MAX_LOAD)THEN
                       C=-(MAX_LOAD-TEMP(i))
                    ELSE
                       C=-TMP_SUM
                    ENDIF
                    DELTA=(B*B-(dble(4)*A*C))
                    X=int((-B+sqrt(DELTA))/(dble(2)*A))
.LT.                    IF(X0) THEN
                       WRITE(*,*)MYID,
     &    ': internal error 14 in dmumps_set_parti_flop_irr'
                       CALL MUMPS_ABORT()
                    ENDIF
.GE.                    IF(XKMAX)THEN
.GT.                       IF(KMAXKMIN)THEN
                          X=KMAX
                       ELSE
                          X=0
                       ENDIF
                    ELSE
.LE.                       IF(Xmin(KMIN,KMAX))THEN
.LT.                          IF(KMAXKMIN)THEN
                             X=0
                          ELSE
                             X=min(KMIN,KMAX)
                          ENDIF
                       ENDIF
                    ENDIF
.GT.                    IF((ACC+X)NCB) X=NCB-ACC
                 ENDIF
                 TEMP_MAX_LOAD=max(TEMP_MAX_LOAD,TEMP(i))
                 NB_ROWS(i)=X
                 CHOSEN=CHOSEN+1
                 ACC=ACC+X
.EQ.                 IF(ACCNCB) GOTO 541
              ENDDO
 541          CONTINUE
.LT.              IF(ACCNCB)THEN
.EQ.                 IF(K500)THEN
                    ADDITIONNAL_ROWS=NCB-ACC
                    DO J=1,CHOSEN
                       AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                       BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       IF(HAVE_TYPE1_SON)THEN
                          AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                         dble(NFRONT+1))
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       ENDIF
                       MAX_MEM_ALLOW=BANDE_K821
                       IF(BDC_MD)THEN
                          MAX_MEM_ALLOW=min(
     &                    min(MEM_SIZE_WEAK(J),MEM_SIZE_STRONG(J)),
     &                         dble(BANDE_K821))
                          MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                       ENDIF
                       KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.LT.                       IF((NB_ROWS(J))KMAX)THEN
.GT.                          IF(ADDITIONNAL_ROWS(KMAX-NB_ROWS(J)))THEN
                             ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                            (KMAX-NB_ROWS(J))
                             NB_ROWS(J)=KMAX
                          ELSE
                             NB_ROWS(J)=NB_ROWS(J)+ADDITIONNAL_ROWS
                             ADDITIONNAL_ROWS=0
                          ENDIF
                       ENDIF
.EQ.                       IF(ADDITIONNAL_ROWS0)GOTO 889
                    ENDDO 
                    X=int(ADDITIONNAL_ROWS/CHOSEN)
                    X=max(X,1)
                    DO J=1,CHOSEN
                       AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                       BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       IF(HAVE_TYPE1_SON)THEN
                          AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                         dble(NFRONT+1))
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       ENDIF
                       MAX_MEM_ALLOW=BANDE_K821
                       IF(BDC_MD)THEN
                          MAX_MEM_ALLOW=min(BANDE_K821,
     &                         MEM_SIZE_STRONG(J))
                          MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                       ENDIF
                       KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.GT.                       IF((NB_ROWS(J)+X)KMAX)THEN
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                         (KMAX-NB_ROWS(J))
                          NB_ROWS(J)=KMAX
                       ELSE
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                          NB_ROWS(J)=NB_ROWS(J)+X
                       ENDIF
.EQ.                       IF(ADDITIONNAL_ROWS0)GOTO 889
                    ENDDO 
                    DO i=1,CHOSEN
                       X=int(BUF_SIZE/dble(NCB+1))-1
                       BANDE_K821=dble(X)*dble(NFRONT)
                       IF(HAVE_TYPE1_SON)THEN
                          X=int((BUF_SIZE-dble(NFRONT))/
     &                         dble(NFRONT+1))
                          BANDE_K821=dble(X)*dble(NFRONT)
                       ENDIF
                       MAX_MEM_ALLOW=BANDE_K821
                       IF(BDC_MD)THEN
                          MAX_MEM_ALLOW=min(BANDE_K821,
     &                         MEM_SIZE_STRONG(i))
                          MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                       ENDIF
                       KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.LT.                       IF(KMAX-NB_ROWS(i)ADDITIONNAL_ROWS)THEN
                          ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                         (KMAX-NB_ROWS(i))
                          NB_ROWS(i)=KMAX
                       ELSE
                          NB_ROWS(i)=NB_ROWS(i)+ADDITIONNAL_ROWS
                          ADDITIONNAL_ROWS=0
                       ENDIF
.EQ.                       IF(ADDITIONNAL_ROWS0)GOTO 889
                    ENDDO
                    DO i=1,NUMBER_OF_PROCS
                       IDWLOAD(i)=i
                       AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                       BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       IF(HAVE_TYPE1_SON)THEN
                          AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                         dble(NFRONT+1))
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       ENDIF                          
                       WLOAD(i)=(BANDE_K821-(dble(NB_ROWS(i))*
     &                      dble(NFRONT)))
                    ENDDO
                    CALL MUMPS_SORT_DOUBLES(NUMBER_OF_PROCS, WLOAD,
     &                   IDWLOAD)
                    NB_SAT=0
                    DO i=1,CHOSEN
                       X=int(ADDITIONNAL_ROWS/(CHOSEN-NB_SAT))
                       X=max(X,1)
                       AFFECTED=int(BUF_SIZE/dble(NCB+1))-1
                       BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       IF(HAVE_TYPE1_SON)THEN
                          AFFECTED=int((BUF_SIZE-dble(NFRONT))/
     &                         dble(NFRONT+1))
                          BANDE_K821=dble(AFFECTED)*dble(NFRONT)
                       ENDIF
                       MAX_MEM_ALLOW=BANDE_K821
                       KMAX=int(MAX_MEM_ALLOW/dble(NFRONT))
.LT.                       IF(NB_ROWS(IDWLOAD(i))KMAX)THEN
.LT.                          IF((NB_ROWS(IDWLOAD(i))+X)KMAX)THEN
                             NB_ROWS(IDWLOAD(i))=
     &                            NB_ROWS(IDWLOAD(i))+X
                             ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
                          ELSE
                             ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-
     &                            (KMAX-NB_ROWS(IDWLOAD(i)))
                             NB_ROWS(IDWLOAD(i))=KMAX
                          ENDIF
                       ENDIF
.EQ.                       IF(NB_ROWS(IDWLOAD(i))KMAX)THEN
                          NB_SAT=NB_SAT+1
                       ENDIF
.EQ.                       IF(ADDITIONNAL_ROWS0) GOTO 889
                    ENDDO
                    GOTO 994
                 ELSE
                    ACC=0
                    CHOSEN=0
                    DO i=1,OTHERS
                       A=dble(1)
                       B=dble(ACC+2)
                       C=-BUF_SIZE+dble(ACC+NELIM)
                       DELTA=(B*B)-(dble(4)*A*C)
                       X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                       IF(XNCB-ACC) X=NCB-ACC
                       BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                       IF(HAVE_TYPE1_SON)THEN
                          A=dble(1)
                          B=dble(ACC+2+NELIM)
                          C=-BUF_SIZE+dble(ACC+NELIM)
                          DELTA=(B*B)-(dble(4)*A*C)
                          X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                          IF(XNCB-ACC) X=NCB-ACC
                          BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                       ENDIF
                       MAX_MEM_ALLOW=BANDE_K821
                       IF(BDC_MD)THEN
                          MAX_MEM_ALLOW=min(BANDE_K821,
     &                         MEM_SIZE_STRONG(i))
                          MAX_MEM_ALLOW=max(dble(0),MAX_MEM_ALLOW)
                       ENDIF
                       A=dble(1)
                       B=dble(ACC+NELIM)
                       C=dble(-MAX_MEM_ALLOW)
                       DELTA=((B*B)-(dble(4)*A*C))
                       KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                       X=KMAX-NB_ROWS(i)
.GT.                       IF((ACC+NB_ROWS(i)+X)NCB)
     &                            X=NCB-(ACC+NB_ROWS(i))
                       NB_ROWS(i)=NB_ROWS(i)+X
                       ACC=ACC+NB_ROWS(i)
                       CHOSEN=CHOSEN+1
.EQ.                       IF(NCBACC) GOTO 889
                    ENDDO
                    ADDITIONNAL_ROWS=NCB-ACC
                 ENDIF
                 ACC=0
                 CHOSEN=0
                 DO i=1,OTHERS
                    A=dble(1)
                    B=dble(ACC+2)
                    C=-BUF_SIZE+dble(ACC+NELIM)
                    DELTA=(B*B)-(dble(4)*A*C)
                    X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                    IF(XNCB-ACC) X=NCB-ACC
                    BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                    IF(HAVE_TYPE1_SON)THEN
                       A=dble(1)
                       B=dble(ACC+2+NELIM)
                       C=-BUF_SIZE+dble(ACC+NELIM)
                       DELTA=(B*B)-(dble(4)*A*C)
                       X=int((-B+sqrt(DELTA))/(dble(2)*A))
.GT.                       IF(XNCB-ACC) X=NCB-ACC
                       BANDE_K821=dble(X)*dble(NELIM+ACC+X)
                    ENDIF
                    MAX_MEM_ALLOW=BANDE_K821
                    A=dble(1)
                    B=dble(ACC+NELIM)
                    C=dble(-MAX_MEM_ALLOW)
                    DELTA=((B*B)-(dble(4)*A*C))
                    KMAX=int((-B+sqrt(DELTA))/(dble(2)*A))
                    X=KMAX-NB_ROWS(i)
.GT.                    IF((ACC+NB_ROWS(i)+X)NCB)
     &                   X=NCB-(ACC+NB_ROWS(i))
                    NB_ROWS(i)=NB_ROWS(i)+X
                    ACC=ACC+NB_ROWS(i)
                    CHOSEN=CHOSEN+1
.EQ.                    IF(NCBACC) GOTO 889
                 ENDDO
                 ADDITIONNAL_ROWS=NCB-ACC
 994             CONTINUE
                 X=int(dble(ADDITIONNAL_ROWS)/dble(OTHERS))
.LT.                 IF((X*OTHERS)ADDITIONNAL_ROWS)THEN
                    X=X+1
                 ENDIF
                 DO i=1,OTHERS
                    NB_ROWS(i)=NB_ROWS(i)+X
                    ADDITIONNAL_ROWS=ADDITIONNAL_ROWS-X
.LT.                    IF(ADDITIONNAL_ROWSX)X=ADDITIONNAL_ROWS
                 ENDDO
                 CHOSEN=OTHERS
              ENDIF
           ENDIF
 889       CONTINUE
           MAX_LOAD=TEMP_MAX_LOAD
 890       CONTINUE
           J=CHOSEN
           X=0
              DO i=J,1,-1
.EQ.                 IF(NB_ROWS(i)0)THEN
                    CHOSEN=CHOSEN-1
                    ELSE 
.GT.                       IF(NB_ROWS(i)0)THEN
                          X=1
                       ELSE
                          WRITE(*,*)MYID,
     &    ': internal error 15 in dmumps_set_parti_flop_irr'
                          CALL MUMPS_ABORT()
                       ENDIF
                    ENDIF
                 ENDDO
           NSLAVES_NODE=CHOSEN
           TAB_POS(NSLAVES_NODE+1)= NCB+1
           TAB_POS(SLAVEF+2) = CHOSEN
           POS=1
           X=1
           DO i=1,J
.NE.              IF(NB_ROWS(i)0)THEN
                 SLAVES_LIST(X)=TEMP_ID(i)
                 TAB_POS(X)=POS
                 POS=POS+NB_ROWS(i) 
.LE.                 IF(NB_ROWS(i)0)THEN
                    WRITE(*,*)MYID,
     &    ': internal error 16 in dmumps_set_parti_flop_irr'
                    CALL MUMPS_ABORT()
                 ENDIF
                 X=X+1
               ENDIF
           ENDDO
.NE.           IF(POS(NCB+1))THEN
              WRITE(*,*)MYID,
     &    ': internal error 17 in dmumps_set_parti_flop_irr',
     &             POS,NCB+1
              CALL MUMPS_ABORT()
           ENDIF
      END SUBROUTINE DMUMPS_SET_PARTI_FLOP_IRR
      SUBROUTINE DMUMPS_LOAD_POOL_CHECK_MEM
     &      (INODE,UPPER,SLAVEF,KEEP,KEEP8,
     &       STEP,POOL,LPOOL,PROCNODE,N)
      IMPLICIT NONE
      INTEGER INODE, LPOOL, SLAVEF, N
      INTEGER KEEP(500)
      INTEGER(8) KEEP8(150)
      INTEGER STEP(KEEP(28)), POOL(LPOOL), PROCNODE(KEEP(28))
      LOGICAL UPPER
      INTEGER J
      DOUBLE PRECISION MEM_COST
      INTEGER NBINSUBTREE,i,NBTOP
      EXTERNAL DMUMPS_POOL_EMPTY,
     & MUMPS_IN_OR_ROOT_SSARBR
      LOGICAL DMUMPS_POOL_EMPTY,
     & MUMPS_IN_OR_ROOT_SSARBR
      NBINSUBTREE = POOL(LPOOL)
      NBTOP       = POOL(LPOOL - 1)
.LT.      IF(KEEP(47)2)THEN
         WRITE(*,*)'dmumps_load_pool_check_mem must
     &        be called with k47>=2'
         CALL MUMPS_ABORT()
      ENDIF        
.GT..AND..LE.      IF((INODE0)(INODEN))THEN
      MEM_COST=DMUMPS_LOAD_GET_MEM(INODE)
         IF((DM_MEM(MYID)+dble(MEM_COST)+ PEAK_SBTR_CUR_LOCAL-
     &        SBTR_CUR_LOCAL)
.GT.     &        MAX_PEAK_STK)THEN
            DO i=NBTOP-1,1,-1
               INODE = POOL( LPOOL - 2 - i)
               MEM_COST=DMUMPS_LOAD_GET_MEM(INODE)
.LT..OR..GT.               IF((INODE0)(INODEN)) THEN
                  DO J=i+1,NBTOP,-1
                     POOL(J-1)=POOL(J)
                  ENDDO
                  UPPER=.TRUE.
                  RETURN
               ENDIF
               IF((DM_MEM(MYID)+dble(MEM_COST)+PEAK_SBTR_CUR_LOCAL-
.LE.     &              SBTR_CUR_LOCAL)
     &              MAX_PEAK_STK) THEN
                  DO J=i+1,NBTOP,-1
                     POOL(J-1)=POOL(J)
                  ENDDO
                  UPPER=.TRUE.
                  RETURN
               ENDIF
            ENDDO
.NE.            IF(NBINSUBTREE0)THEN
               INODE = POOL( NBINSUBTREE )
.NOT.               IF(MUMPS_IN_OR_ROOT_SSARBR(PROCNODE(STEP(INODE)),
     &              KEEP(199)))THEN
                  WRITE(*,*)
     &        'internal error 1 in dmumps_load_pool_check_mem'
                  CALL MUMPS_ABORT()
               ENDIF
               UPPER=.FALSE.
               RETURN
            ENDIF
            INODE=POOL(LPOOL-2-NBTOP)
            UPPER=.TRUE.
            RETURN
         ENDIF
      ENDIF
      UPPER=.TRUE.
      END SUBROUTINE DMUMPS_LOAD_POOL_CHECK_MEM
      SUBROUTINE DMUMPS_LOAD_SET_SBTR_MEM(WHAT)
      IMPLICIT NONE
      LOGICAL WHAT
.NOT.      IF(BDC_POOL_MNG)THEN
         WRITE(*,*)'dmumps_load_set_sbtr_mem
     &        should be called when k81>0 and k47>2'
      ENDIF
      IF(WHAT)THEN
         PEAK_SBTR_CUR_LOCAL=PEAK_SBTR_CUR_LOCAL+
     &        dble(MEM_SUBTREE(INDICE_SBTR))
.NOT.         IF(BDC_SBTR) INDICE_SBTR=INDICE_SBTR+1
      ELSE
         PEAK_SBTR_CUR_LOCAL=dble(0)
         SBTR_CUR_LOCAL=dble(0)
      ENDIF
      END SUBROUTINE DMUMPS_LOAD_SET_SBTR_MEM
      DOUBLE PRECISION FUNCTION DMUMPS_LOAD_GET_MEM( INODE )
      IMPLICIT NONE
      INTEGER INODE,LEVEL,i,NELIM,NFR
      DOUBLE PRECISION COST
      EXTERNAL MUMPS_TYPENODE
      INTEGER MUMPS_TYPENODE
      i = INODE
      NELIM = 0
 10   CONTINUE
      IF ( i > 0 ) THEN
        NELIM = NELIM + 1
        i = FILS_LOAD(i)
        GOTO 10
      ENDIF
      NFR = ND_LOAD( STEP_LOAD(INODE) ) + KEEP_LOAD(253)
      LEVEL = MUMPS_TYPENODE( PROCNODE_LOAD(STEP_LOAD(INODE)),
     &                        KEEP_LOAD(199) )
.EQ.      IF (LEVEL  1) THEN
        COST =  dble(NFR) * dble(NFR)
      ELSE
        IF ( K50 == 0 ) THEN
           COST =  dble(NFR) * dble(NELIM)
        ELSE
           COST = dble(NELIM) * dble(NELIM)
        ENDIF
      ENDIF
      DMUMPS_LOAD_GET_MEM=COST
      RETURN
      END FUNCTION DMUMPS_LOAD_GET_MEM
      RECURSIVE SUBROUTINE DMUMPS_NEXT_NODE(FLAG,COST,COMM)
      USE DMUMPS_BUF
      USE MUMPS_FUTURE_NIV2
      IMPLICIT NONE
      INTEGER COMM,WHAT,IERR
      LOGICAL FLAG, EXIT_FLAG
      DOUBLE PRECISION COST
      DOUBLE PRECISION TO_BE_SENT
      EXTERNAL MUMPS_TYPENODE
      INTEGER MUMPS_TYPENODE
      IF(FLAG)THEN
         WHAT=17 
         IF(BDC_M2_FLOPS)THEN
            TO_BE_SENT=DELTA_LOAD-COST
            DELTA_LOAD=dble(0)
         ELSE IF(BDC_M2_MEM)THEN
.AND..NOT.            IF(BDC_POOL(BDC_MD))THEN
               TO_BE_SENT=max(TMP_M2,POOL_LAST_COST_SENT)
               POOL_LAST_COST_SENT=TO_BE_SENT
            ELSE IF(BDC_MD)THEN
               DELTA_MEM=DELTA_MEM+TMP_M2
               TO_BE_SENT=DELTA_MEM
            ELSE
               TO_BE_SENT=dble(0)
            ENDIF
         ENDIF
      ELSE
         WHAT=6
         TO_BE_SENT=dble(0)
      ENDIF
 111  CONTINUE
      CALL DMUMPS_BUF_BROADCAST( WHAT,
     &         COMM, NPROCS,
     &               FUTURE_NIV2,
     &         COST, 
     &         TO_BE_SENT, 
     &         MYID, KEEP_LOAD, IERR  )
      IF ( IERR == -1 )THEN
         CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
         CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
         IF (EXIT_FLAG) THEN
            GOTO 100
         ELSE
            GOTO 111
         ENDIF
.NE.      ELSE IF ( IERR  0 ) THEN
         WRITE(*,*) "Internal Error in DMUMPS_LOAD_POOL_UPD_NEW_POOL",
     &   IERR
         CALL MUMPS_ABORT()
      ENDIF
 100  CONTINUE
      RETURN
      END SUBROUTINE DMUMPS_NEXT_NODE
      SUBROUTINE DMUMPS_UPPER_PREDICT(INODE,STEP,NSTEPS,PROCNODE,FRERE,
     &     NE,COMM,SLAVEF,MYID,KEEP,KEEP8,N)
      USE DMUMPS_BUF
      IMPLICIT NONE
      INTEGER INODE,NSTEPS,MYID,SLAVEF,COMM,N
      INTEGER KEEP(500)
      INTEGER(8) KEEP8(150)
      INTEGER FRERE(NSTEPS),NE(NSTEPS),STEP(N),PROCNODE(NSTEPS)
      EXTERNAL MUMPS_IN_OR_ROOT_SSARBR,MUMPS_PROCNODE
      LOGICAL MUMPS_IN_OR_ROOT_SSARBR
      INTEGER i,NCB,NELIM
      INTEGER MUMPS_PROCNODE
      INTEGER FATHER_NODE,FATHER,WHAT,IERR
      EXTERNAL MUMPS_TYPENODE
      INTEGER MUMPS_TYPENODE
      LOGICAL :: EXIT_FLAG
.NOT..AND..NOT.      IF((BDC_M2_MEM)(BDC_M2_FLOPS))THEN
         WRITE(*,*)MYID,': problem in dmumps_upper_predict'
         CALL MUMPS_ABORT()
      ENDIF
.LT..OR..GT.      IF((INODE0)(INODEN)) THEN
         RETURN
      ENDIF
      i=INODE
      NELIM = 0
 10   CONTINUE
      IF ( i > 0 ) THEN
         NELIM = NELIM + 1
         i = FILS_LOAD(i)
         GOTO 10
      ENDIF
      NCB=ND_LOAD(STEP_LOAD(INODE))-NELIM + KEEP_LOAD(253)
      WHAT=5
      FATHER_NODE=DAD_LOAD(STEP_LOAD(INODE))
.EQ.      IF (FATHER_NODE0) THEN
         RETURN
      ENDIF
.EQ..AND.      IF((FRERE(STEP(FATHER_NODE))0)
.EQ..OR.     &     ((FATHER_NODEKEEP(38))
.EQ.     &     (FATHER_NODEKEEP(20))))THEN
         RETURN 
      ENDIF
      IF(MUMPS_IN_OR_ROOT_SSARBR(PROCNODE(STEP(FATHER_NODE)),
     &            KEEP(199))) THEN
         RETURN
      ENDIF
      FATHER=MUMPS_PROCNODE(PROCNODE(STEP(FATHER_NODE)),KEEP(199))
.EQ.      IF(FATHERMYID)THEN
        IF(BDC_M2_MEM)THEN
           CALL DMUMPS_PROCESS_NIV2_MEM_MSG(FATHER_NODE)
        ELSEIF(BDC_M2_FLOPS)THEN
           CALL DMUMPS_PROCESS_NIV2_FLOPS_MSG(FATHER_NODE)
        ENDIF
.EQ..OR..EQ.        IF((KEEP(81)2)(KEEP(81)3))THEN
           IF(MUMPS_TYPENODE(PROCNODE_LOAD(STEP_LOAD(INODE)),
.EQ.     &          KEEP(199))1)THEN
              CB_COST_ID(POS_ID)=INODE
              CB_COST_ID(POS_ID+1)=1
              CB_COST_ID(POS_ID+2)=POS_MEM
              POS_ID=POS_ID+3
              CB_COST_MEM(POS_MEM)=int(MYID,8)
              POS_MEM=POS_MEM+1
              CB_COST_MEM(POS_MEM)=int(NCB,8)*int(NCB,8)
              POS_MEM=POS_MEM+1
           ENDIF
        ENDIF
        GOTO 666
      ENDIF
 111  CONTINUE      
      CALL DMUMPS_BUF_SEND_FILS(WHAT, COMM, NPROCS,
     &     FATHER_NODE,INODE,NCB, KEEP,MYID,
     &     FATHER, IERR)
      IF (IERR == -1 ) THEN
        CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
        CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
        IF (EXIT_FLAG) THEN
           GOTO 666
        ELSE
           GOTO 111
        ENDIF
.NE.      ELSE IF ( IERR  0 ) THEN
        WRITE(*,*) "Internal Error in DMUMPS_UPPER_PREDICT",
     &  IERR
        CALL MUMPS_ABORT()
      ENDIF 
 666  CONTINUE
      RETURN
      END SUBROUTINE DMUMPS_UPPER_PREDICT
      SUBROUTINE DMUMPS_REMOVE_NODE(INODE,NUM_CALL)
      IMPLICIT NONE
      DOUBLE PRECISION MAXI
      INTEGER i,J,IND_MAXI
      INTEGER INODE,NUM_CALL
      IF(BDC_M2_MEM)THEN
.EQ..AND..OR.         IF(((NUM_CALL1)(BDC_MD))
.EQ..AND..NOT.     &       ((NUM_CALL2)(BDC_MD)))THEN
            RETURN
         ENDIF
      ENDIF
.EQ..AND.      IF((FRERE_LOAD(STEP_LOAD(INODE))0)
.EQ..OR.     &     ((INODEKEEP_LOAD(38))
.EQ.     &     (INODEKEEP_LOAD(20)))) THEN
         RETURN
      ENDIF
      DO i=POOL_SIZE,1,-1
.EQ.         IF(POOL_NIV2(i)INODE) GOTO 666
      ENDDO
         NB_SON(STEP_LOAD(INODE))=-1
      RETURN         
 666  CONTINUE
      IF(BDC_M2_MEM)THEN
.EQ.         IF(POOL_NIV2_COST(i)MAX_M2)THEN
            TMP_M2=MAX_M2
            MAXI=dble(0)
            IND_MAXI=-9999
            DO J=POOL_SIZE,1,-1
.NE.               IF(Ji) THEN
.GT.                  IF(POOL_NIV2_COST(J)MAXI)THEN
                     MAXI=POOL_NIV2_COST(J)
                     IND_MAXI=J
                  ENDIF
               ENDIF
            ENDDO
            MAX_M2=MAXI
            J=IND_MAXI
            REMOVE_NODE_FLAG_MEM=.TRUE.
            REMOVE_NODE_COST_MEM=TMP_M2
            CALL DMUMPS_NEXT_NODE(REMOVE_NODE_FLAG,MAX_M2,COMM_LD)
            NIV2(MYID+1)=MAX_M2
         ENDIF
      ELSEIF(BDC_M2_FLOPS)THEN
         REMOVE_NODE_COST=POOL_NIV2_COST(i)
         REMOVE_NODE_FLAG=.TRUE.
         CALL DMUMPS_NEXT_NODE(REMOVE_NODE_FLAG,
     &        -POOL_NIV2_COST(i),COMM_LD)
         NIV2(MYID+1)=NIV2(MYID+1)-POOL_NIV2_COST(i)
      ENDIF
      DO J=i+1,POOL_SIZE
         POOL_NIV2(J-1)=POOL_NIV2(J)
         POOL_NIV2_COST(J-1)=POOL_NIV2_COST(J)
      ENDDO
      POOL_SIZE=POOL_SIZE-1
      END SUBROUTINE DMUMPS_REMOVE_NODE
      RECURSIVE SUBROUTINE DMUMPS_PROCESS_NIV2_MEM_MSG(INODE)
      IMPLICIT NONE
      INTEGER INODE
      EXTERNAL MUMPS_TYPENODE
      INTEGER MUMPS_TYPENODE
.EQ..OR.      IF((INODEKEEP_LOAD(20))
.EQ.     &     (INODEKEEP_LOAD(38)))THEN
         RETURN
      ENDIF
.EQ.      IF(NB_SON(STEP_LOAD(INODE))-1)THEN
         RETURN
      ELSE
.LT.         IF(NB_SON(STEP_LOAD(INODE))0)THEN
            WRITE(*,*)
     &        'internal error 1 in dmumps_process_niv2_mem_msg'
            CALL MUMPS_ABORT()
         ENDIF
      ENDIF
      NB_SON(STEP_LOAD(INODE))=
     &     NB_SON(STEP_LOAD(INODE))-1
.EQ.      IF(NB_SON(STEP_LOAD(INODE))0)THEN
.EQ.         IF(POOL_SIZEPOOL_NIV2_SIZE)THEN
            WRITE(*,*)MYID,': internal error 2 in
     &dmumps_process_niv2_mem_msg'
            CALL MUMPS_ABORT()
         ENDIF
         POOL_NIV2(POOL_SIZE+1)=INODE
         POOL_NIV2_COST(POOL_SIZE+1)=
     &        DMUMPS_LOAD_GET_MEM(INODE)
         POOL_SIZE=POOL_SIZE+1
.GT.         IF(POOL_NIV2_COST(POOL_SIZE)MAX_M2)THEN
            MAX_M2=POOL_NIV2_COST(POOL_SIZE)
            ID_MAX_M2=POOL_NIV2(POOL_SIZE)
            CALL DMUMPS_NEXT_NODE(REMOVE_NODE_FLAG_MEM,MAX_M2,COMM_LD)
            NIV2(1+MYID)=MAX_M2
         ENDIF
      ENDIF
      RETURN
      END SUBROUTINE DMUMPS_PROCESS_NIV2_MEM_MSG    
      RECURSIVE SUBROUTINE DMUMPS_PROCESS_NIV2_FLOPS_MSG(INODE)
      IMPLICIT NONE
      INTEGER INODE
      EXTERNAL MUMPS_TYPENODE
      INTEGER MUMPS_TYPENODE
.EQ..OR.      IF((INODEKEEP_LOAD(20))
.EQ.     &     (INODEKEEP_LOAD(38)))THEN
         RETURN
      ENDIF
.EQ.      IF(NB_SON(STEP_LOAD(INODE))-1)THEN
         RETURN
      ELSE
.LT.         IF(NB_SON(STEP_LOAD(INODE))0)THEN
            WRITE(*,*)
     &        'internal error 1 in dmumps_process_niv2_flops_msg'
            CALL MUMPS_ABORT()
         ENDIF
      ENDIF
      NB_SON(STEP_LOAD(INODE))=
     &     NB_SON(STEP_LOAD(INODE))-1
.EQ.      IF(NB_SON(STEP_LOAD(INODE))0)THEN
.EQ.         IF(POOL_SIZEPOOL_NIV2_SIZE)THEN
            WRITE(*,*)MYID,': internal error 2 in
     &dmumps_process_niv2_flops_msg',POOL_NIV2_SIZE,
     &           POOL_SIZE
            CALL MUMPS_ABORT()
         ENDIF
         POOL_NIV2(POOL_SIZE+1)=INODE
         POOL_NIV2_COST(POOL_SIZE+1)=
     &        DMUMPS_LOAD_GET_FLOPS_COST(INODE)
         POOL_SIZE=POOL_SIZE+1
         MAX_M2=POOL_NIV2_COST(POOL_SIZE)
         ID_MAX_M2=POOL_NIV2(POOL_SIZE)
         CALL DMUMPS_NEXT_NODE(REMOVE_NODE_FLAG,
     &           POOL_NIV2_COST(POOL_SIZE),
     &        COMM_LD)
         NIV2(MYID+1)=POOL_NIV2_COST(POOL_SIZE)+NIV2(MYID+1)
      ENDIF
      RETURN
      END SUBROUTINE DMUMPS_PROCESS_NIV2_FLOPS_MSG
      DOUBLE PRECISION FUNCTION DMUMPS_LOAD_GET_FLOPS_COST(INODE)
      USE MUMPS_FUTURE_NIV2
      INTEGER INODE
      INTEGER NFRONT,NELIM,i,LEVEL
      EXTERNAL MUMPS_TYPENODE
      INTEGER MUMPS_TYPENODE
      DOUBLE PRECISION COST
      i = INODE
      NELIM = 0
 10   CONTINUE
      IF ( i > 0 ) THEN
        NELIM = NELIM + 1
        i = FILS_LOAD(i)
        GOTO 10
      ENDIF
      NFRONT = ND_LOAD( STEP_LOAD(INODE) ) + KEEP_LOAD(253)
      LEVEL = MUMPS_TYPENODE( PROCNODE_LOAD(STEP_LOAD(INODE)),
     &        KEEP_LOAD(199) )
      COST=dble(0)
      CALL MUMPS_GET_FLOPS_COST(NFRONT,NELIM,NELIM,
     &                          KEEP_LOAD(50),LEVEL,COST)
      DMUMPS_LOAD_GET_FLOPS_COST=COST
      RETURN
      END FUNCTION DMUMPS_LOAD_GET_FLOPS_COST
      INTEGER FUNCTION DMUMPS_LOAD_GET_CB_FREED( INODE )
      IMPLICIT NONE
      INTEGER INODE,NELIM,NFR,SON,IN,i
      INTEGER COST_CB
      COST_CB=0
      i = INODE
 10   CONTINUE
      IF ( i > 0 ) THEN
        i = FILS_LOAD(i)
        GOTO 10
      ENDIF
      SON=-i
      DO i=1, NE_LOAD(STEP_LOAD(INODE))
         NFR = ND_LOAD( STEP_LOAD(SON) ) + KEEP_LOAD(253)
         IN=SON
         NELIM = 0
 20      CONTINUE
         IF ( IN > 0 ) THEN
            NELIM = NELIM + 1
            IN = FILS_LOAD(IN)
            GOTO 20
         ENDIF
         COST_CB=COST_CB+((NFR-NELIM)*(NFR-NELIM))
         SON=FRERE_LOAD(STEP_LOAD(SON))
      ENDDO
      DMUMPS_LOAD_GET_CB_FREED=COST_CB
      RETURN
      END FUNCTION DMUMPS_LOAD_GET_CB_FREED
      SUBROUTINE DMUMPS_LOAD_SEND_MD_INFO(SLAVEF,NMB_OF_CAND,
     &     LIST_OF_CAND,
     &     TAB_POS, NASS, KEEP,KEEP8, LIST_SLAVES,
     &     NSLAVES,INODE)
      USE DMUMPS_BUF
      USE MUMPS_FUTURE_NIV2
      IMPLICIT NONE
      INTEGER, INTENT (IN) :: SLAVEF, NASS, NSLAVES
      INTEGER, INTENT (IN) :: NMB_OF_CAND
      INTEGER, INTENT (IN) :: LIST_OF_CAND(NMB_OF_CAND)
      INTEGER, INTENT (IN) :: TAB_POS(SLAVEF+2)
      INTEGER, INTENT (IN) :: LIST_SLAVES(NSLAVES)
      INTEGER KEEP(500),INODE
      INTEGER(8) KEEP8(150)
      INTEGER allocok
      DOUBLE PRECISION MEM_COST,FCT_COST
      DOUBLE PRECISION, DIMENSION(:),ALLOCATABLE :: DELTA_MD
      INTEGER, DIMENSION(:), ALLOCATABLE :: IPROC2POSINDELTAMD
      INTEGER, DIMENSION(:), ALLOCATABLE :: P_TO_UPDATE
      INTEGER NBROWS_SLAVE,i,WHAT,IERR
      INTEGER :: NP_TO_UPDATE, K
      LOGICAL FORCE_CAND
      LOGICAL :: EXIT_FLAG
      MEM_COST=dble(0)
      FCT_COST=dble(0)
.OR.      IF ( KEEP(24) == 0  KEEP(24) == 1 ) THEN
        FORCE_CAND = .FALSE.
      ELSE
.eq.        FORCE_CAND = (mod(KEEP(24),2)0)
      END IF
      CALL DMUMPS_LOAD_GET_ESTIM_MEM_COST(INODE,FCT_COST,
     &        MEM_COST,NMB_OF_CAND,NASS)
      ALLOCATE(IPROC2POSINDELTAMD(0:SLAVEF-1),
     & DELTA_MD(min(SLAVEF, NMB_OF_CAND+NSLAVES)),
     & P_TO_UPDATE(min(SLAVEF, NMB_OF_CAND+NSLAVES)),
     & stat=allocok)
      IF (allocok > 0 ) THEN
        WRITE(*,*) "PB ALLOC IN DMUMPS_LOAD_SEND_MD_INFO",
     &  SLAVEF, NMB_OF_CAND, NSLAVES
        CALL MUMPS_ABORT()
      ENDIF
      IPROC2POSINDELTAMD = -99
      NP_TO_UPDATE = 0
      DO i = 1, NSLAVES
        NP_TO_UPDATE = NP_TO_UPDATE + 1
        IPROC2POSINDELTAMD (LIST_SLAVES(i)) = NP_TO_UPDATE
        NBROWS_SLAVE = TAB_POS(i+1) - TAB_POS(i)
        DELTA_MD(NP_TO_UPDATE)=-dble(NBROWS_SLAVE)*
     &           dble(NASS)
        P_TO_UPDATE(NP_TO_UPDATE) = LIST_SLAVES(i)
      ENDDO
      DO i = 1, NMB_OF_CAND
        K = IPROC2POSINDELTAMD(LIST_OF_CAND(i))
        IF ( K > 0 ) THEN
          DELTA_MD(K)=DELTA_MD(K)+FCT_COST
        ELSE
          NP_TO_UPDATE = NP_TO_UPDATE + 1
          IPROC2POSINDELTAMD (LIST_OF_CAND(i)) = NP_TO_UPDATE
          DELTA_MD   (NP_TO_UPDATE) = FCT_COST
          P_TO_UPDATE(NP_TO_UPDATE) = LIST_OF_CAND(i)
        ENDIF
      ENDDO
      WHAT=7
 111  CONTINUE
      CALL DMUMPS_BUF_BCAST_ARRAY(.FALSE., COMM_LD, MYID, SLAVEF,
     &     FUTURE_NIV2,
     &     NP_TO_UPDATE, P_TO_UPDATE,0,
     &     DELTA_MD, 
     &     DELTA_MD, 
     &     DELTA_MD, 
     &     WHAT, KEEP, IERR)
      IF ( IERR == -1 ) THEN
          CALL DMUMPS_LOAD_RECV_MSGS(COMM_LD)
          CALL MUMPS_CHECK_COMM_NODES(COMM_NODES, EXIT_FLAG)
          IF (EXIT_FLAG) THEN
             GOTO 100
          ELSE
             GOTO 111
          ENDIF
.NE.       ELSE IF ( IERR  0 ) THEN
         WRITE(*,*) "Internal Error 2 in DMUMPS_LOAD_SEND_MD_INFO",
     &   IERR
         CALL MUMPS_ABORT()
      ENDIF
.NE.      IF (FUTURE_NIV2(MYID+1)  0) THEN
        DO i = 1, NP_TO_UPDATE
           MD_MEM(P_TO_UPDATE(i))=MD_MEM(P_TO_UPDATE(i))+
     &          int(DELTA_MD( i ),8)
.EQ.           IF(FUTURE_NIV2(P_TO_UPDATE(i)+1)0)THEN
              MD_MEM(P_TO_UPDATE(i))=999999999_8
           ENDIF
        ENDDO
      ENDIF
 100  CONTINUE
      DEALLOCATE(DELTA_MD,P_TO_UPDATE,IPROC2POSINDELTAMD)
      RETURN
      END SUBROUTINE DMUMPS_LOAD_SEND_MD_INFO
      SUBROUTINE DMUMPS_LOAD_GET_ESTIM_MEM_COST(INODE,FCT_COST,
     &     MEM_COST,NSLAVES,NELIM)
      IMPLICIT NONE
      INTEGER INODE,NSLAVES,NFR,NELIM,IN
      DOUBLE PRECISION MEM_COST,FCT_COST
      NFR=ND_LOAD(STEP_LOAD(INODE)) + KEEP_LOAD(253)
      IN = INODE
      FCT_COST=dble(int(dble(NFR-NELIM)/dble(NSLAVES))+1)*
     &     dble(NELIM)
      MEM_COST=dble(int(dble(NFR-NELIM)/dble(NSLAVES))+1)*
     &     dble(NFR)
      END SUBROUTINE DMUMPS_LOAD_GET_ESTIM_MEM_COST
      SUBROUTINE DMUMPS_LOAD_CLEAN_MEMINFO_POOL(INODE)
      USE MUMPS_FUTURE_NIV2
      IMPLICIT NONE
      INTEGER INODE
      INTEGER i,J,SON,NSLAVES_TEMP,POS_TEMP,K
      INTEGER MUMPS_PROCNODE
      EXTERNAL MUMPS_PROCNODE
.LT..OR..GT.      IF((INODE0)(INODEN_LOAD))THEN
         RETURN
      ENDIF
.GT.      IF(POS_ID1)THEN
         i=INODE
 10      CONTINUE
         IF ( i > 0 ) THEN
            i = FILS_LOAD(i)
            GOTO 10
         ENDIF
         SON=-i
.LT.         IF(POS_IDNE_LOAD(STEP_LOAD(INODE))*3)THEN
            i=1
         ENDIF
         DO i=1, NE_LOAD(STEP_LOAD(INODE))
            J=1
.LT.            DO WHILE (JPOS_ID)
.EQ.               IF(CB_COST_ID(J)SON)GOTO 295 
               J=J+3
            ENDDO
 295        CONTINUE
.GE.            IF(JPOS_ID)THEN
               IF ( MUMPS_PROCNODE(
     &                PROCNODE_LOAD(STEP_LOAD(INODE)),
.EQ.     &                KEEP_LOAD(199) )  MYID ) THEN
.EQ.                  IF(INODEKEEP_LOAD(38))THEN
                     GOTO 666
                  ELSE
.NE.                     IF(FUTURE_NIV2(MYID+1)0)THEN
                        WRITE(*,*)MYID,': i did not find ',SON
                        CALL MUMPS_ABORT()
                     ENDIF
                     GOTO 666
                  ENDIF
               ELSE
                  GOTO 666
               ENDIF
            ENDIF
            NSLAVES_TEMP=CB_COST_ID(J+1)       
            POS_TEMP=CB_COST_ID(J+2)
            DO K=J,POS_ID-1
               CB_COST_ID(K)=CB_COST_ID(K+3)
            ENDDO
            K=POS_TEMP
.LE.            DO WHILE (KPOS_MEM-1)
               CB_COST_MEM(K)=CB_COST_MEM(K+2*NSLAVES_TEMP)
               K=K+1
            ENDDO
            POS_MEM=POS_MEM-2*NSLAVES_TEMP
            POS_ID=POS_ID-3
.LT..OR..LT.            IF((POS_MEM1)(POS_ID1))THEN
               WRITE(*,*)MYID,': negative pos_mem or pos_id'
               CALL MUMPS_ABORT()
            ENDIF
 666        CONTINUE
            SON=FRERE_LOAD(STEP_LOAD(SON))
         ENDDO
      ENDIF
      END SUBROUTINE DMUMPS_LOAD_CLEAN_MEMINFO_POOL
      SUBROUTINE DMUMPS_LOAD_CHK_MEMCST_POOL(FLAG)
      IMPLICIT NONE
      LOGICAL FLAG
      INTEGER i
      DOUBLE PRECISION MEM
      FLAG=.FALSE.
      DO i=0,NPROCS-1
         MEM=DM_MEM(i)+LU_USAGE(i)
         IF(BDC_SBTR)THEN
            MEM=MEM+SBTR_MEM(i)-SBTR_CUR(i)
         ENDIF
.GT.         IF((MEM/dble(TAB_MAXS(i)))0.8d0)THEN
            FLAG=.TRUE.
            GOTO 666
         ENDIF
      ENDDO
 666  CONTINUE
      END SUBROUTINE DMUMPS_LOAD_CHK_MEMCST_POOL
      SUBROUTINE DMUMPS_CHECK_SBTR_COST(NBINSUBTREE,INSUBTREE,NBTOP,
     &           MIN_COST,SBTR)
      IMPLICIT NONE
      INTEGER NBINSUBTREE,INSUBTREE,NBTOP
      DOUBLE PRECISION MIN_COST
      LOGICAL SBTR
      INTEGER i
      DOUBLE PRECISION TMP_COST,TMP_MIN
      TMP_MIN=huge(TMP_MIN)
      DO i=0,NPROCS-1
.NE.         IF(iMYID)THEN
            IF(BDC_SBTR)THEN
               TMP_MIN=min(TMP_MIN,dble(TAB_MAXS(i))-(DM_MEM(i)+
     &              LU_USAGE(i))-(SBTR_MEM(i)-SBTR_CUR(i)))
            ELSE
               TMP_MIN=min(TMP_MIN,dble(TAB_MAXS(i))-
     &              (DM_MEM(i)+LU_USAGE(i)))
            ENDIF
         ENDIF
      ENDDO
.GT.      IF(NBINSUBTREE0)THEN
.EQ.         IF(INSUBTREE1)THEN
            TMP_COST=dble(TAB_MAXS(MYID))-(DM_MEM(MYID)+
     &           LU_USAGE(MYID))
     &           -(SBTR_MEM(MYID)-SBTR_CUR(MYID))
         ELSE
            SBTR=.FALSE.
            GOTO 777
         ENDIF
      ENDIF
      TMP_MIN=min(TMP_COST,TMP_MIN)
.GT.      IF(TMP_MINMIN_COST) SBTR=.TRUE.
 777  CONTINUE
      END SUBROUTINE DMUMPS_CHECK_SBTR_COST
      SUBROUTINE DMUMPS_LOAD_COMP_MAXMEM_POOL(INODE,MAX_MEM,PROC)
      USE MUMPS_FUTURE_NIV2
      IMPLICIT NONE
      INTEGER INODE,PROC
      INTEGER i,POS,NSLAVES,SLAVE,NCAND,J,NELIM,NCB,NFRONT,SON,K
      INTEGER allocok
      EXTERNAL MUMPS_TYPENODE
      INTEGER  MUMPS_TYPENODE
      DOUBLE PRECISION MAX_MEM
      DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: MEM_ON_PROCS,
     &     RECV_BUF
      LOGICAL, DIMENSION(:), ALLOCATABLE :: CONCERNED
      DOUBLE PRECISION MAX_SENT_MSG
.EQ.      IF((FRERE_LOAD(STEP_LOAD(INODE))0)
.AND..EQ.     &           (INODEKEEP_LOAD(38)))THEN
         RETURN
      ENDIF
      ALLOCATE( MEM_ON_PROCS(0:NPROCS-1), stat=allocok)
      IF ( allocok > 0 ) THEN
        WRITE(*,*) 'pb allocation in dmumps_load_comp_maxmem_pool'
        CALL MUMPS_ABORT()
      ENDIF 
      ALLOCATE( CONCERNED(0:NPROCS-1), stat=allocok)
      IF ( allocok > 0 ) THEN
        WRITE(*,*) 'pb allocation in dmumps_load_comp_maxmem_pool'
        CALL MUMPS_ABORT()
      ENDIF 
      ALLOCATE( RECV_BUF(0:NPROCS-1), stat=allocok)
      IF ( allocok > 0 ) THEN
        WRITE(*,*) 'pb allocation in dmumps_load_comp_maxmem_pool'
        CALL MUMPS_ABORT()
      ENDIF 
      RECV_BUF=dble(0)
      MAX_SENT_MSG=dble(0)
      i = INODE
      NELIM = 0
 10   CONTINUE
      IF ( i > 0 ) THEN
        NELIM = NELIM + 1
        i = FILS_LOAD(i)
        GOTO 10
      ENDIF
      SON=-i
      NFRONT=ND_LOAD(STEP_LOAD(INODE)) + KEEP_LOAD(253)
      NCB=NFRONT-NELIM
      IF(MUMPS_TYPENODE(PROCNODE_LOAD(STEP_LOAD(INODE)),
.EQ.     &     KEEP_LOAD(199))2)THEN
         NCAND=CAND_LOAD(NPROCS+1, STEP_TO_NIV2_LOAD(STEP_LOAD(INODE)))
      ENDIF
      DO i=0,NPROCS-1
.EQ.         IF(iMYID)THEN
            MEM_ON_PROCS(i)=dble(TAB_MAXS(i))-(DM_MEM(i)+
     &           LU_USAGE(i)+
     &           DMUMPS_LOAD_GET_MEM(INODE))
            IF(BDC_SBTR)THEN
               MEM_ON_PROCS(i)=MEM_ON_PROCS(i)-(SBTR_MEM(i)-SBTR_CUR(i))
            ENDIF
            CONCERNED(i)=.TRUE.
         ELSE
            MEM_ON_PROCS(i)=dble(TAB_MAXS(i))-(DM_MEM(i)+LU_USAGE(i))
            IF(BDC_SBTR)THEN
               MEM_ON_PROCS(i)=MEM_ON_PROCS(i)-(SBTR_MEM(i)-SBTR_CUR(i))
            ENDIF
            IF(BDC_M2_MEM)THEN
               MEM_ON_PROCS(i)=MEM_ON_PROCS(i)-NIV2(i+1)
            ENDIF
         ENDIF
         IF(MUMPS_TYPENODE(PROCNODE_LOAD(STEP_LOAD(INODE)),
.EQ.     &        KEEP_LOAD(199))2)THEN
.AND..EQ.            IF(BDC_MD(KEEP_LOAD(48)5))THEN
               DO J=1,NCAND
                  IF(CAND_LOAD(J, STEP_TO_NIV2_LOAD(STEP_LOAD(INODE)))
.EQ.     &                 i)THEN
                     MEM_ON_PROCS(i)=MEM_ON_PROCS(i)-
     &                 ((dble(NFRONT)*dble(NCB))/dble(NCAND))
                     CONCERNED(i)=.TRUE.
                     GOTO 666
                  ENDIF
               ENDDO
            ENDIF
         ENDIF
 666     CONTINUE
      ENDDO
      DO K=1, NE_LOAD(STEP_LOAD(INODE))
         i=1
.LE.         DO WHILE (iPOS_ID)
.EQ.            IF(CB_COST_ID(i)SON)GOTO 295
            i=i+3
         ENDDO
 295     CONTINUE
.GE.         IF(iPOS_ID)THEN
.NE.            IF(FUTURE_NIV2(MYID+1)0)THEN
               WRITE(*,*)MYID,': ',SON,'has not been found
     & in dmumps_load_comp_maxmem_pool'
               CALL MUMPS_ABORT()
            ENDIF
            GOTO 777
         ENDIF
         NSLAVES=CB_COST_ID(i+1)
         POS=CB_COST_ID(i+2)
         DO i=1,NSLAVES
            SLAVE=int(CB_COST_MEM(POS))
.NOT.            IF(CONCERNED(SLAVE))THEN
               MEM_ON_PROCS(SLAVE)=MEM_ON_PROCS(SLAVE)+
     &              dble(CB_COST_MEM(POS+1))
            ENDIF
            DO J=0,NPROCS-1
               IF(CONCERNED(J))THEN
.NE.                  IF(SLAVEJ)THEN
                     RECV_BUF(J)=max(RECV_BUF(J),
     &                    dble(CB_COST_MEM(POS+1)))
                  ENDIF
               ENDIF
            ENDDO
            POS=POS+2
         ENDDO
 777     CONTINUE
         SON=FRERE_LOAD(STEP_LOAD(SON))
      ENDDO
      MAX_MEM=huge(MAX_MEM)
      WRITE(*,*)'nprocs=',NPROCS,MAX_MEM
      DO i=0,NPROCS-1
.GT.         IF(MAX_MEMMEM_ON_PROCS(i))THEN
            PROC=i
         ENDIF
         MAX_MEM=min(MEM_ON_PROCS(i),MAX_MEM)
      ENDDO
      DEALLOCATE(MEM_ON_PROCS)
      DEALLOCATE(CONCERNED)
      DEALLOCATE(RECV_BUF)
      END SUBROUTINE DMUMPS_LOAD_COMP_MAXMEM_POOL
      SUBROUTINE DMUMPS_FIND_BEST_NODE_FOR_MEM(MIN_PROC,POOL,
     &                      LPOOL,INODE)
      IMPLICIT NONE
      INTEGER INODE,LPOOL,MIN_PROC
      INTEGER POOL(LPOOL)
      EXTERNAL MUMPS_PROCNODE
      INTEGER MUMPS_PROCNODE
      INTEGER i,NBTOP,INSUBTREE,NBINSUBTREE,NODE,FATHER,SON,J
      INTEGER SBTR_NB_LEAF,POS,K,allocok,L
      INTEGER, ALLOCATABLE, DIMENSION (:) ::  TMP_SBTR
      NBINSUBTREE = POOL(LPOOL)
      NBTOP       = POOL(LPOOL - 1)
      INSUBTREE   = POOL(LPOOL - 2)
.EQ..AND.      IF((KEEP_LOAD(47)4)
.NE.     &     ((NBINSUBTREE0)))THEN
         DO J=INDICE_SBTR,NB_SUBTREES
            NODE=MY_ROOT_SBTR(J) 
            FATHER=DAD_LOAD(STEP_LOAD(NODE))
            i=FATHER
 110        CONTINUE
            IF ( i > 0 ) THEN
               i = FILS_LOAD(i)
               GOTO 110
            ENDIF
            SON=-i
            i=SON
 120        CONTINUE
            IF ( i > 0 ) THEN
               IF( MUMPS_PROCNODE(PROCNODE_LOAD(STEP_LOAD(i)),
.EQ.     &             KEEP_LOAD(199))   MIN_PROC ) THEN
                  SBTR_NB_LEAF=MY_NB_LEAF(J)
                  POS=SBTR_FIRST_POS_IN_POOL(J)
.NE.                  IF(POOL(POS+SBTR_NB_LEAF)MY_FIRST_LEAF(J))THEN
                     WRITE(*,*)MYID,': the first leaf is not ok'
                     CALL MUMPS_ABORT()
                  ENDIF
                  ALLOCATE (TMP_SBTR(SBTR_NB_LEAF), stat=allocok)
                  IF (allocok > 0 ) THEN
                     WRITE(*,*)MYID,': not enough space
     &                    for allocation'
                     CALL MUMPS_ABORT()
                  ENDIF
                  POS=SBTR_FIRST_POS_IN_POOL(J)
                  DO K=1,SBTR_NB_LEAF
                     TMP_SBTR(K)=POOL(POS+K-1)
                  ENDDO
                  DO K=POS+1,NBINSUBTREE-SBTR_NB_LEAF
                     POOL(K)=POOL(K+SBTR_NB_LEAF)
                  ENDDO
                  POS=1
                  DO K=NBINSUBTREE-SBTR_NB_LEAF+1,NBINSUBTREE
                     POOL(K)=TMP_SBTR(POS)
                     POS=POS+1
                  ENDDO
                  DO K=INDICE_SBTR,J
                     SBTR_FIRST_POS_IN_POOL(K)=SBTR_FIRST_POS_IN_POOL(K)
     &                    -SBTR_FIRST_POS_IN_POOL(J)
                  ENDDO
                  SBTR_FIRST_POS_IN_POOL(J)=NBINSUBTREE-SBTR_NB_LEAF
                  POS=MY_FIRST_LEAF(J)
                  L=MY_NB_LEAF(J)
                  DO K=INDICE_SBTR,J
                     MY_FIRST_LEAF(J)=MY_FIRST_LEAF(J+1)
                     MY_NB_LEAF(J)=MY_NB_LEAF(J+1)
                  ENDDO
                  MY_FIRST_LEAF(INDICE_SBTR)=POS
                  MY_NB_LEAF(INDICE_SBTR)=L
                  INODE=POOL(NBINSUBTREE)
                  DEALLOCATE(TMP_SBTR)
                  RETURN
               ENDIF
               i = FRERE_LOAD(STEP_LOAD(i))
               GOTO 120
            ENDIF           
         ENDDO
      ENDIF
      DO J=NBTOP,1,-1
         NODE=POOL(LPOOL-2-J)
         FATHER=DAD_LOAD(STEP_LOAD(NODE))
         i=FATHER
 11      CONTINUE
         IF ( i > 0 ) THEN
            i = FILS_LOAD(i)
            GOTO 11
         ENDIF
         SON=-i
         i=SON
 12      CONTINUE
         IF ( i > 0 ) THEN
            IF( MUMPS_PROCNODE(PROCNODE_LOAD(STEP_LOAD(i)),
.EQ.     &          KEEP_LOAD(199))  MIN_PROC ) THEN
               INODE=NODE
               RETURN
            ENDIF
            i = FRERE_LOAD(STEP_LOAD(i))
            GOTO 12
         ENDIF
      ENDDO
      END SUBROUTINE DMUMPS_FIND_BEST_NODE_FOR_MEM
      SUBROUTINE DMUMPS_LOAD_INIT_SBTR_STRUCT(POOL, LPOOL,KEEP,KEEP8)
      IMPLICIT NONE
      INTEGER LPOOL,POOL(LPOOL),KEEP(500)
      INTEGER(8) KEEP8(150)
      INTEGER i,POS
      EXTERNAL MUMPS_ROOTSSARBR
      LOGICAL MUMPS_ROOTSSARBR
.NOT.      IF(BDC_SBTR) RETURN
      POS=0
      DO i=NB_SUBTREES,1,-1
         DO WHILE(MUMPS_ROOTSSARBR(
     &            PROCNODE_LOAD(STEP_LOAD(POOL(POS+1))),
     &            KEEP(199)))
            POS=POS+1
         ENDDO
         SBTR_FIRST_POS_IN_POOL(i)=POS+1
         POS=POS+MY_NB_LEAF(i)
      ENDDO
      END SUBROUTINE DMUMPS_LOAD_INIT_SBTR_STRUCT
      END MODULE DMUMPS_LOAD