Functions/Subroutines
subroutine	collect_blocksizes (cut, npartsass, npartscb)
subroutine	upd_flop_decompress (f, cb)
subroutine	upd_flop_compress (lr_b, rec_acc, cb_compress, frswap)
subroutine	upd_flop_trsm (lrb, loru)
subroutine	upd_flop_update (lrb1, lrb2, midblk_compress, rank_in, buildq, is_symdiag, lua_activated, rec_acc)
subroutine	upd_flop_update_lrlr3 (lrb, niv)
subroutine	upd_flop_root (keep50, nfront, npiv, nprow, npcol, myid)
subroutine	init_stats_global (id)
subroutine	upd_mry_lu_fr (nass, ncb, sym, nelim)
subroutine	upd_mry_cb_fr (nrows, ncols, sym)
subroutine	upd_mry_cb_lrgain (lrb)
subroutine	upd_mry_lu_lrgain (blr_panel, nbblocks)
subroutine	upd_flop_facto_fr (nfront, nass, npiv, sym, niv)
subroutine	stats_compute_flop_slave_type2 (nrow1, ncol1, nass1, keep50, inode)
subroutine	upd_flop_frfronts (nfront, npiv, nass, sym, niv)
subroutine	upd_flop_frfront_slave (nrow1, ncol1, nass1, keep50, inode)
subroutine	compute_global_gains (nb_entries_factor, flop_number, nb_entries_factor_withlr, prokg, mpg)
subroutine	saveandwrite_gains (local, k489, dkeep, n, icntl36, depth, bcksz, nassmin, nfrontmin, sym, k486, k472, k475, k478, k480, k481, k483, k484, k8110, k849, nbtreenodes, nprocs, mpg, prokg)

Variables
double precision	mry_cb_fr
double precision	mry_cb_lrgain
double precision	mry_lu_fr
double precision	mry_lu_lrgain
double precision	global_mry_lpro_compr
double precision	global_mry_ltot_compr
integer	cnt_nodes
double precision	flop_lrgain
double precision	flop_facto_fr
double precision	flop_facto_lr
double precision	flop_panel
double precision	flop_trsm
double precision	flop_trsm_fr
double precision	flop_trsm_lr
double precision	flop_update_fr
double precision	flop_update_lr
double precision	flop_update_lrlr1
double precision	flop_update_lrlr2
double precision	flop_update_lrlr3
double precision	flop_update_frlr
double precision	flop_update_frfr
double precision	flop_compress
double precision	flop_cb_compress
double precision	flop_midblk_compress
double precision	flop_frswap_compress
double precision	flop_accum_compress
double precision	flop_decompress
double precision	flop_cb_decompress
double precision	flop_frfronts
double precision	factor_processed_fraction
integer(kind=8)	factor_size
double precision	total_flop
double precision	time_update
double precision	time_update_lrlr1
double precision	time_update_lrlr2
double precision	time_update_lrlr3
double precision	time_update_frlr
double precision	time_update_frfr
double precision	time_compress
double precision	time_midblk_compress
double precision	time_frswap_compress
double precision	time_cb_compress
double precision	time_lr_module
double precision	time_upd_nelim
double precision	time_lrtrsm
double precision	time_frtrsm
double precision	time_panel
double precision	time_fac_i
double precision	time_fac_mq
double precision	time_fac_sq
double precision	time_frfronts
double precision	time_diagcopy
double precision	time_decomp
double precision	time_decomp_ucfs
double precision	time_decomp_asm1
double precision	time_decomp_locasm2
double precision	time_decomp_maplig1
double precision	time_decomp_asms2s
double precision	time_decomp_asms2m
double precision	time_lrana_lrgrouping
double precision	time_lrana_sepgrouping
double precision	time_lrana_gethalo
double precision	time_lrana_kway
double precision	time_lrana_gnew
double precision	avg_flop_facto_lr
double precision	min_flop_facto_lr
double precision	max_flop_facto_lr
integer	total_nblocks_ass
integer	total_nblocks_cb
integer	min_blocksize_ass
integer	max_blocksize_ass
integer	min_blocksize_cb
integer	max_blocksize_cb
double precision	avg_blocksize_ass
double precision	avg_blocksize_cb

Function/Subroutine Documentation

◆ collect_blocksizes()

subroutine smumps_lr_stats::collect_blocksizes	(	integer, dimension(:), pointer	cut,
		integer, intent(in)	npartsass,
		integer, intent(in)	npartscb )

Definition at line 89 of file slr_stats.F.

        INTEGER, INTENT(IN) :: NPARTSASS, NPARTSCB
        INTEGER, POINTER, DIMENSION(:) :: CUT
        INTEGER :: LOC_MIN_ASS, LOC_MIN_CB, LOC_MAX_ASS, LOC_MAX_CB,
     &             LOC_TOT_ASS, LOC_TOT_CB
        DOUBLE PRECISION :: LOC_AVG_ASS, LOC_AVG_CB 
        INTEGER :: I
        loc_tot_ass = 0
        loc_tot_cb = 0
        loc_avg_ass = 0.d0
        loc_avg_cb = 0.d0
        loc_min_ass = 100000
        loc_min_cb = 100000
        loc_max_ass = 0
        loc_max_cb = 0
        DO i = 1,npartsass
          loc_avg_ass = ( loc_tot_ass * loc_avg_ass
     &                        + cut(i+1) - cut(i) )
     &                        / (loc_tot_ass + 1)
          loc_tot_ass = loc_tot_ass + 1
          IF (cut(i+1) - cut(i) .LE. loc_min_ass) THEN
            loc_min_ass = cut(i+1) - cut(i)
          END IF
          IF (cut(i+1) - cut(i) .GE. loc_max_ass) THEN
            loc_max_ass = cut(i+1) - cut(i)
          END IF
        END DO
        DO i = npartsass+1,npartsass+npartscb
          loc_avg_cb = ( loc_tot_cb * loc_avg_cb
     &                        + cut(i+1) - cut(i) )
     &                        / (loc_tot_cb + 1)
          loc_tot_cb = loc_tot_cb + 1
          IF (cut(i+1) - cut(i) .LE. loc_min_cb) THEN
            loc_min_cb = cut(i+1) - cut(i)
          END IF
          IF (cut(i+1) - cut(i) .GE. loc_max_cb) THEN
            loc_max_cb = cut(i+1) - cut(i)
          END IF
        END DO
        avg_blocksize_ass = (total_nblocks_ass*avg_blocksize_ass
     &     + loc_tot_ass*loc_avg_ass) / (total_nblocks_ass+loc_tot_ass)
        avg_blocksize_cb = (total_nblocks_cb*avg_blocksize_cb
     &     + loc_tot_cb*loc_avg_cb) / (total_nblocks_cb+loc_tot_cb)
        total_nblocks_ass = total_nblocks_ass + loc_tot_ass
        total_nblocks_cb = total_nblocks_cb + loc_tot_cb
        min_blocksize_ass = min(min_blocksize_ass,loc_min_ass)
        min_blocksize_cb = min(min_blocksize_cb,loc_min_cb)
        max_blocksize_ass = max(max_blocksize_ass,loc_max_ass)
        max_blocksize_cb = max(max_blocksize_cb,loc_max_cb)

◆ compute_global_gains()

subroutine smumps_lr_stats::compute_global_gains	(	integer(8), intent(in)	nb_entries_factor,
		real, intent(in)	flop_number,
		integer(8), intent(out)	nb_entries_factor_withlr,
		logical, intent(in)	prokg,
		integer, intent(in)	mpg )

Definition at line 532 of file slr_stats.F.

        INTEGER(8), INTENT(IN) :: NB_ENTRIES_FACTOR   
        INTEGER, INTENT(IN)    :: MPG
        LOGICAL, INTENT(IN)    :: PROKG
        REAL, INTENT(IN)        :: FLOP_NUMBER   
        INTEGER(8), INTENT(OUT) :: 
     &                  NB_ENTRIES_FACTOR_withLR 
        IF (nb_entries_factor < 0) THEN
         IF (prokg.AND.mpg.GT.0) THEN
          WRITE(mpg,*) "NEGATIVE NUMBER OF ENTRIES IN FACTOR"
          WRITE(mpg,*) "===> OVERFLOW ?"
         END IF
        END IF
        IF (mry_lu_fr .EQ. 0) THEN
           global_mry_lpro_compr = 100.0d0
        ELSE
           global_mry_lpro_compr = 100.0d0 *
     &                             mry_lu_lrgain/mry_lu_fr
        ENDIF
        IF (mry_cb_fr .EQ. 0) THEN 
          mry_cb_fr = 100.0d0
        END IF
        nb_entries_factor_withlr = nb_entries_factor -
     &                             int(mry_lu_lrgain,8)
        IF (nb_entries_factor.EQ.0) THEN
          factor_processed_fraction = 100.0d0
          global_mry_ltot_compr = 100.0d0
        ELSE
          factor_processed_fraction = 100.0d0 *
     &                            mry_lu_fr/dble(nb_entries_factor)
          global_mry_ltot_compr = 
     &            100.0d0*mry_lu_lrgain/dble(nb_entries_factor)
        ENDIF
        total_flop = flop_number
        flop_facto_lr = flop_facto_fr - flop_lrgain + flop_compress 
     &                                              + flop_decompress
        RETURN

◆ init_stats_global()

subroutine smumps_lr_stats::init_stats_global ( type (smumps_struc), target id )

Definition at line 343 of file slr_stats.F.

        USE smumps_struc_def
        TYPE (SMUMPS_STRUC), TARGET :: id
        mry_lu_fr = 0.d0
        mry_lu_lrgain = 0.d0
        mry_cb_fr = 0.d0
        mry_cb_lrgain = 0.d0
        flop_facto_fr = 0.d0 
        flop_facto_lr = 0.d0
        flop_lrgain = 0.d0
        flop_cb_compress = 0.d0
        flop_cb_decompress = 0.d0
        flop_decompress = 0.d0
        flop_update_fr = 0.d0 
        flop_update_lr = 0.d0
        flop_update_lrlr1 = 0.d0
        flop_update_lrlr2 = 0.d0
        flop_update_lrlr3 = 0.d0
        flop_update_frlr = 0.d0
        flop_update_frfr = 0.d0
        flop_midblk_compress = 0.d0
        flop_trsm_fr = 0.d0 
        flop_trsm_lr = 0.d0
        flop_compress = 0.d0
        flop_accum_compress = 0.d0
        flop_frswap_compress = 0.d0
        flop_panel = 0.d0
        flop_trsm = 0.d0
        flop_frfronts = 0.d0
        total_nblocks_ass = 0
        total_nblocks_cb = 0
        avg_blocksize_ass = 0.d0
        avg_blocksize_cb = 0.d0
        min_blocksize_ass = huge(1)
        max_blocksize_ass = 0
        min_blocksize_cb = huge(1)
        max_blocksize_cb = 0
        cnt_nodes = 0
        time_update = 0.d0 
        time_midblk_compress = 0.d0 
        time_update_lrlr1 = 0.d0 
        time_update_lrlr2 = 0.d0 
        time_update_lrlr3 = 0.d0 
        time_update_frlr = 0.d0 
        time_update_frfr = 0.d0 
        time_compress = 0.d0 
        time_cb_compress = 0.d0 
        time_lr_module = 0.d0 
        time_upd_nelim = 0.d0 
        time_lrtrsm = 0.d0 
        time_frtrsm = 0.d0 
        time_panel = 0.d0 
        time_fac_i = 0.d0 
        time_fac_mq = 0.d0 
        time_fac_sq = 0.d0 
        time_frfronts = 0.d0 
        time_diagcopy = 0.d0 
        time_frswap_compress = 0.d0 
        time_decomp = 0.d0 
        time_decomp_ucfs = 0.d0 
        time_decomp_asm1 = 0.d0 
        time_decomp_locasm2 = 0.d0 
        time_decomp_maplig1 = 0.d0 
        time_decomp_asms2s = 0.d0 
        time_decomp_asms2m = 0.d0 

◆ saveandwrite_gains()

subroutine smumps_lr_stats::saveandwrite_gains	(	integer, intent(in)	local,
		integer, intent(in)	k489,
		real, dimension(230)	dkeep,
		integer, intent(in)	n,
		integer, intent(in)	icntl36,
		integer, intent(in)	depth,
		integer, intent(in)	bcksz,
		integer, intent(in)	nassmin,
		integer, intent(in)	nfrontmin,
		integer, intent(in)	sym,
		integer, intent(in)	k486,
		integer, intent(in)	k472,
		integer, intent(in)	k475,
		integer, intent(in)	k478,
		integer, intent(in)	k480,
		integer, intent(in)	k481,
		integer, intent(in)	k483,
		integer, intent(in)	k484,
		integer(8), intent(in)	k8110,
		integer(8), intent(in)	k849,
		integer, intent(in)	nbtreenodes,
		integer, intent(in)	nprocs,
		integer, intent(in)	mpg,
		logical, intent(in)	prokg )

Definition at line 572 of file slr_stats.F.

        INTEGER, INTENT(IN) :: LOCAL,K489,DEPTH, N,
     &      ICNTL36, BCKSZ,NASSMIN,
     &      NFRONTMIN, K486, NBTREENODES, MPG, 
     &      K472, K475, K478, K480, K481, K483, K484, 
     &      SYM, NPROCS
        INTEGER(8), INTENT(IN) :: K8110, K849
        LOGICAL, INTENT(IN) :: PROKG
        REAL :: DKEEP(230)
        LOGICAL PROK
        prok = (prokg.AND.(mpg.GE.0))
        IF (prok) THEN
        WRITE(mpg,'(/A,A)') 
     & '-------------- Beginning of BLR statistics -------------------',
     & '--------------'
        WRITE(mpg,'(A,I2)') 
     & ' ICNTL(36) BLR variant                            = ', icntl36
        WRITE(mpg,'(A,ES8.1)')  
     & ' CNTL(7)   Dropping parameter controlling accuracy = ',
     &                          dkeep(8)
        WRITE(mpg,'(A)') 
     &          ' Statistics after BLR factorization :'
        WRITE(mpg,'(A,I8)') 
     &    '     Number of BLR fronts                     = ',
     &                          cnt_nodes
        ENDIF  
        IF (prok) WRITE(mpg,'(A,F8.1,A)')
     &    '     Fraction of factors in BLR fronts        =',
     &                factor_processed_fraction,'% ' 
        IF (prok) THEN
          WRITE(mpg,'(A)') 
     &  '     Statistics on the number of entries in factors :'
          WRITE(mpg,'(A,ES10.3,A,F5.1,A)') 
     &  '     INFOG(29) Theoretical nb of entries in factors      ='
     &     ,real(k8110),' (100.0%)'
          WRITE(mpg,'(A,ES10.3,A,F5.1,A)') 
     &  '     INFOG(35) Effective nb of entries  (% of INFOG(29)) ='
     &     ,real(k849),' ('
     &     ,real(100)*(real(k849)/real(max(k8110,1_8)))
     &     ,'%)'
        ENDIF
        IF (prok) WRITE(mpg,'(A)')
     &  '     Statistics on operation counts (OPC):'
        total_flop = max(total_flop,epsilon(1.0d0))
        dkeep(55)=real(total_flop)
        dkeep(60)=real(100)
        dkeep(56)=real(flop_facto_lr+flop_frfronts)
        dkeep(61)=real(100*(flop_facto_lr+flop_frfronts)/total_flop)
        IF (prok) THEN 
        WRITE(mpg,'(A,ES10.3,A,F5.1,A)') 
     &  '     RINFOG(3) Total theoretical operations counts       ='
     &     ,total_flop,' (',100*total_flop/total_flop,'%)'
        WRITE(mpg,'(A,ES10.3,A,F5.1,A)') 
     &  '     RINFOG(14) Total effective OPC     (% of RINFOG(3)) ='
     &     ,flop_facto_lr+flop_frfronts,' ('
     &,100*(flop_facto_lr+flop_frfronts)/total_flop
     &,'%)'
        ENDIF
      IF (prok) WRITE(mpg,'(A,A)') 
     & '-------------- End of BLR statistics -------------------------',
     & '--------------'
      RETURN

◆ stats_compute_flop_slave_type2()

subroutine smumps_lr_stats::stats_compute_flop_slave_type2	(	integer, intent(in)	nrow1,
		integer, intent(in)	ncol1,
		integer, intent(in)	nass1,
		integer, intent(in)	keep50,
		integer, intent(in)	inode )

Definition at line 477 of file slr_stats.F.

          INTEGER,INTENT(IN) :: NROW1, NCOL1, KEEP50, NASS1, INODE
          DOUBLE PRECISION   :: NROW2, NCOL2, NASS2
          DOUBLE PRECISION   :: FLOP
          nrow2 = dble(nrow1)
          ncol2 = dble(ncol1)
          nass2 = dble(nass1)
          IF (keep50.EQ.0) THEN
            flop = nrow2*nass2*nass2         
     &              + 2.0d0*nrow2*nass2*(ncol2-nass2) 
          ELSE
             flop =
     &            nrow2*nass2*nass2
     &          + nrow2*nass2*nrow2
     &          + 2.0d0*nrow2*nass2*(ncol2-nass2-nrow2)
          ENDIF
!$OMP     ATOMIC UPDATE
          flop_facto_fr = flop_facto_fr + flop
!$OMP     END ATOMIC
      RETURN

◆ upd_flop_compress()

subroutine smumps_lr_stats::upd_flop_compress	(	type(lrb_type), intent(in)	lr_b,
		logical, optional	rec_acc,
		logical, optional	cb_compress,
		logical, optional	frswap )

Definition at line 152 of file slr_stats.F.

        TYPE(LRB_TYPE),INTENT(IN) :: LR_B
        INTEGER(8) :: M,N,K
        DOUBLE PRECISION :: HR_COST,BUILDQ_COST,
     &  HR_AND_BUILDQ_COST
        LOGICAL, OPTIONAL :: REC_ACC, CB_COMPRESS, FRSWAP
        m = int(lr_b%M,8)
        n = int(lr_b%N,8)
        k = int(lr_b%K,8)
        hr_cost =  dble(k*k*k/3_8 + 4_8*k*m*n - (2_8*m+n)*k*k)
        IF (lr_b%ISLR) THEN 
          buildq_cost = dble(2_8*k*k*m - k*k*k)
        ELSE 
          buildq_cost = 0.0d0
        END IF
        hr_and_buildq_cost = hr_cost + buildq_cost
!$OMP   ATOMIC UPDATE
        flop_compress = flop_compress + hr_and_buildq_cost
!$OMP   END ATOMIC
        IF (present(rec_acc)) THEN
          IF (rec_acc) THEN
!$OMP       ATOMIC UPDATE
            flop_accum_compress = flop_accum_compress +
     &                            hr_and_buildq_cost
!$OMP       END ATOMIC
          ENDIF
        ENDIF
        IF (present(cb_compress)) THEN
          IF (cb_compress) THEN
!$OMP       ATOMIC UPDATE
            flop_cb_compress = flop_cb_compress +
     &                         hr_and_buildq_cost 
!$OMP       END ATOMIC
          ENDIF
        ENDIF
        IF (present(frswap)) THEN
          IF (frswap) THEN
!$OMP       ATOMIC UPDATE
            flop_frswap_compress = flop_frswap_compress +
     &                             hr_and_buildq_cost
!$OMP       END ATOMIC
          ENDIF
        ENDIF
      RETURN

◆ upd_flop_decompress()

subroutine smumps_lr_stats::upd_flop_decompress	(	double precision, intent(in)	f,
		logical, intent(in)	cb )

Definition at line 139 of file slr_stats.F.

          DOUBLE PRECISION, INTENT(IN) :: F
          LOGICAL, INTENT(IN) :: CB
!$OMP     ATOMIC UPDATE
          flop_decompress = flop_decompress + f
!$OMP     END ATOMIC
          IF (cb) THEN
!$OMP       ATOMIC UPDATE
            flop_cb_decompress = flop_cb_decompress + f
!$OMP       END ATOMIC
          ENDIF
          RETURN

◆ upd_flop_facto_fr()

subroutine smumps_lr_stats::upd_flop_facto_fr	(	integer, intent(in)	nfront,
		integer, intent(in)	nass,
		integer, intent(in)	npiv,
		integer, intent(in)	sym,
		integer, intent(in)	niv )

Definition at line 468 of file slr_stats.F.

          INTEGER,INTENT(IN) :: NFRONT, SYM, NASS, NPIV, NIV
          DOUBLE PRECISION   :: FLOP
          CALL mumps_get_flops_cost(nfront, npiv, nass, 
     &                              sym, niv, flop)
!$OMP     ATOMIC UPDATE
          flop_facto_fr = flop_facto_fr + flop
!$OMP     END ATOMIC

◆ upd_flop_frfront_slave()

subroutine smumps_lr_stats::upd_flop_frfront_slave	(	integer, intent(in)	nrow1,
		integer, intent(in)	ncol1,
		integer, intent(in)	nass1,
		integer, intent(in)	keep50,
		integer, intent(in)	inode )

Definition at line 510 of file slr_stats.F.

          INTEGER,INTENT(IN) :: NROW1, NCOL1, KEEP50, NASS1, INODE
          DOUBLE PRECISION   :: NROW2, NCOL2, NASS2
          DOUBLE PRECISION   :: FLOP
          nrow2 = dble(nrow1)
          ncol2 = dble(ncol1)
          nass2 = dble(nass1)
          IF (keep50.EQ.0) THEN
            flop = nrow2*nass2*nass2         
     &              + 2.0d0*nrow2*nass2*(ncol2-nass2) 
          ELSE
             flop =
     &            nrow2*nass2*nass2
     &          + nrow2*nass2*nrow2
     &          + 2.0d0*nrow2*nass2*(ncol2-nass2-nrow2)
          ENDIF
!$OMP     ATOMIC UPDATE
          flop_frfronts = flop_frfronts + flop
!$OMP     END ATOMIC
      RETURN

◆ upd_flop_frfronts()

subroutine smumps_lr_stats::upd_flop_frfronts	(	integer, intent(in)	nfront,
		integer, intent(in)	npiv,
		integer, intent(in)	nass,
		integer, intent(in)	sym,
		integer, intent(in)	niv )

Definition at line 499 of file slr_stats.F.

          INTEGER, INTENT(IN) :: NFRONT, NPIV, NASS, SYM, NIV
          DOUBLE PRECISION    :: FLOP_FAC
          CALL mumps_get_flops_cost(nfront, npiv, nass, 
     &                              sym, niv, flop_fac)
!$OMP     ATOMIC UPDATE
          flop_frfronts = flop_frfronts + flop_fac
!$OMP     END ATOMIC
      RETURN

◆ upd_flop_root()

subroutine smumps_lr_stats::upd_flop_root	(	integer, intent(in)	keep50,
		integer, intent(in)	nfront,
		integer, intent(in)	npiv,
		integer, intent(in)	nprow,
		integer, intent(in)	npcol,
		integer, intent(in)	myid )

Definition at line 329 of file slr_stats.F.

        INTEGER, intent(in) :: KEEP50, NFRONT, NPIV,
     &           NPROW, NPCOL, MYID
        DOUBLE PRECISION :: COST, COST_PER_PROC
        INTEGER, PARAMETER :: LEVEL3 = 3
        CALL mumps_get_flops_cost(nfront, npiv, nfront, keep50, level3, 
     &                            cost)
        cost_per_proc = dble(int( cost,8) / int(nprow * npcol,8))
!$OMP   ATOMIC UPDATE
        flop_frfronts = flop_frfronts + cost_per_proc
!$OMP   END ATOMIC
        RETURN

◆ upd_flop_trsm()

subroutine smumps_lr_stats::upd_flop_trsm	(	type(lrb_type), intent(in)	lrb,
		integer, intent(in)	loru )

Definition at line 198 of file slr_stats.F.

          TYPE(LRB_TYPE),INTENT(IN) :: LRB
          INTEGER,INTENT(IN) :: LorU
          DOUBLE PRECISION :: LR_COST, FR_COST, LR_GAIN
          IF (loru.EQ.0) THEN 
            fr_cost = dble(lrb%M*lrb%N*lrb%N)
            IF (lrb%ISLR) THEN
              lr_cost = dble(lrb%K*lrb%N*lrb%N)
            ELSE
              lr_cost = fr_cost
            ENDIF
          ELSE 
            fr_cost = dble(lrb%M-1)*dble(lrb%N*lrb%N)
            IF (lrb%ISLR) THEN
              lr_cost = dble(lrb%N-1)*dble(lrb%N*lrb%K)
            ELSE
              lr_cost = fr_cost
            ENDIF
          ENDIF
          lr_gain = fr_cost - lr_cost
!$OMP     ATOMIC UPDATE
          flop_lrgain  = flop_lrgain + lr_gain
!$OMP     END ATOMIC
      RETURN

◆ upd_flop_update()

subroutine smumps_lr_stats::upd_flop_update	(	type(lrb_type), intent(in)	lrb1,
		type(lrb_type), intent(in)	lrb2,
		integer, intent(in)	midblk_compress,
		integer, intent(in)	rank_in,
		logical, intent(in)	buildq,
		logical, intent(in)	is_symdiag,
		logical, intent(in)	lua_activated,
		logical, intent(in), optional	rec_acc )

Definition at line 223 of file slr_stats.F.

        TYPE(LRB_TYPE),INTENT(IN) :: LRB1,LRB2
        LOGICAL, INTENT(IN) :: BUILDQ, IS_SYMDIAG, LUA_ACTIVATED
        INTEGER, INTENT(IN) :: RANK_IN, MIDBLK_COMPRESS
        LOGICAL, INTENT(IN), OPTIONAL :: REC_ACC
        DOUBLE PRECISION :: COST_FR, COST_LR, COST_LRLR1, COST_LRLR2,
     &                      COST_LRLR3, COST_FRLR, COST_FRFR, 
     &                      COST_COMPRESS, COST_LR_AND_COMPRESS, LR_GAIN
        DOUBLE PRECISION :: M1,N1,K1,M2,N2,K2,RANK
        LOGICAL :: REC_ACC_LOC
        m1 = dble(lrb1%M)
        n1 = dble(lrb1%N)
        k1 = dble(lrb1%K)
        m2 = dble(lrb2%M)
        n2 = dble(lrb2%N)
        k2 = dble(lrb2%K)
        rank = dble(rank_in)
        cost_lrlr1 = 0.0d0
        cost_lrlr2 = 0.0d0
        cost_lrlr3 = 0.0d0
        cost_frlr = 0.0d0
        cost_frfr = 0.0d0
        cost_compress = 0.0d0
        IF (present(rec_acc)) THEN
          rec_acc_loc = rec_acc
        ELSE
          rec_acc_loc = .false.
        ENDIF
        IF ((.NOT.lrb1%ISLR).AND.(.NOT.lrb2%ISLR)) THEN
          cost_frfr = 2.0d0*m1*m2*n1
          cost_lr = 2.0d0*m1*m2*n1
          cost_fr = 2.0d0*m1*m2*n1
        ELSEIF (lrb1%ISLR.AND.(.NOT.lrb2%ISLR)) THEN
          cost_frlr = 2.0d0*k1*m2*n1
          cost_lrlr3 = 2.0d0*m1*m2*k1
          cost_lr = cost_frlr + cost_lrlr3
          cost_fr = 2.0d0*m1*m2*n1
        ELSEIF ((.NOT.lrb1%ISLR).AND.lrb2%ISLR) THEN
          cost_frlr = 2.0d0*m1*k2*n1 
          cost_lrlr3 = 2.0d0*m1*m2*k2
          cost_lr = cost_frlr + cost_lrlr3
          cost_fr = 2.0d0*m1*m2*n1
        ELSE
          IF (midblk_compress.GE.1) THEN
            cost_compress =  rank*rank*rank/3.0d0 + 
     &                       4.0d0*rank*k1*k2 - 
     &                       (2.0d0*k1+k2)*rank*rank
            IF (buildq) THEN
              cost_compress = cost_compress + 4.0d0*rank*rank*k1 
     &                                      - rank*rank*rank
            ENDIF
          ENDIF
          cost_lrlr1 = 2.0d0*k1*k2*n1
          IF ((midblk_compress.GE.1).AND.buildq) THEN
            cost_lrlr2 = 2.0d0*k1*m1*rank + 2.0d0*k2*m2*rank
            cost_lrlr3 = 2.0d0*m1*m2*rank
          ELSE
            IF (k1 .GE. k2) THEN
              cost_lrlr2 = 2.0d0*k1*m1*k2
              cost_lrlr3 = 2.0d0*m1*m2*k2
            ELSE
              cost_lrlr2 = 2.0d0*k1*m2*k2
              cost_lrlr3 = 2.0d0*m1*m2*k1
            ENDIF
          ENDIF
          cost_lr = cost_lrlr1 + cost_lrlr2 + cost_lrlr3
          cost_fr = 2.0d0*m1*m2*n1
        ENDIF
        IF (is_symdiag) THEN
          cost_fr = cost_fr/2.0d0
          cost_lrlr3 = cost_lrlr3/2.0d0
          cost_frfr = cost_frfr/2.0d0
          cost_lr = cost_lr - cost_lrlr3 - cost_frfr
        ENDIF
        IF (lua_activated) THEN
          cost_lr = cost_lr - cost_lrlr3
          cost_lrlr3 = 0.0d0
          IF (rec_acc_loc) THEN
            cost_lr_and_compress = cost_lr + cost_compress
!$OMP       ATOMIC UPDATE
            flop_compress  = flop_compress + cost_lr_and_compress
!$OMP       END ATOMIC
          ENDIF
        ENDIF
        IF (.NOT.rec_acc_loc) THEN
!$OMP     ATOMIC UPDATE
          flop_compress  = flop_compress  + cost_compress
!$OMP     END ATOMIC
          lr_gain = cost_fr - cost_lr
!$OMP     ATOMIC UPDATE
          flop_lrgain = flop_lrgain + lr_gain
!$OMP     END ATOMIC
        ENDIF

◆ upd_flop_update_lrlr3()

subroutine smumps_lr_stats::upd_flop_update_lrlr3	(	type(lrb_type), intent(in)	lrb,
		integer, intent(in)	niv )

Definition at line 319 of file slr_stats.F.

        TYPE(LRB_TYPE),INTENT(IN) :: LRB
        INTEGER,INTENT(IN) :: NIV
        DOUBLE PRECISION :: FLOP_COST
        flop_cost = 2.0d0*dble(lrb%M)*dble(lrb%N)*dble(lrb%K)
!$OMP   ATOMIC UPDATE
        flop_lrgain = flop_lrgain - flop_cost
!$OMP   END ATOMIC
        RETURN

◆ upd_mry_cb_fr()

subroutine smumps_lr_stats::upd_mry_cb_fr	(	integer, intent(in)	nrows,
		integer, intent(in)	ncols,
		integer, intent(in)	sym )

Definition at line 426 of file slr_stats.F.

        INTEGER,INTENT(IN) :: NROWS, NCOLS, SYM
        DOUBLE PRECISION :: MRY
        IF (sym.EQ.0) THEN
          mry = dble(ncols)*dble(nrows)
        ELSE
          mry = dble(ncols-nrows)*dble(nrows) +
     &                dble(nrows)*dble(nrows+1)/2.d0
        ENDIF
!$OMP   ATOMIC UPDATE
        mry_cb_fr = mry_cb_fr + mry
!$OMP   END ATOMIC
        RETURN

◆ upd_mry_cb_lrgain()

subroutine smumps_lr_stats::upd_mry_cb_lrgain ( type(lrb_type), intent(in) lrb )

Definition at line 440 of file slr_stats.F.

        TYPE(LRB_TYPE),  INTENT(IN) :: LRB
        DOUBLE PRECISION :: LRGAIND
        lrgaind = dble(lrb%M*lrb%N-(lrb%M+lrb%N)*lrb%K)
!$OMP   ATOMIC UPDATE
        mry_cb_lrgain = mry_cb_lrgain + lrgaind
!$OMP   END ATOMIC
        RETURN

◆ upd_mry_lu_fr()

subroutine smumps_lr_stats::upd_mry_lu_fr	(	integer, intent(in)	nass,
		integer, intent(in)	ncb,
		integer, intent(in)	sym,
		integer, intent(in)	nelim )

Definition at line 409 of file slr_stats.F.

        INTEGER,INTENT(IN) :: NASS, NCB, SYM, NELIM
        DOUBLE PRECISION :: MRY
        INTEGER :: NPIV
        npiv = nass - nelim
        IF (sym .GT. 0) THEN
           mry = dble(npiv)*(dble(npiv)+1.d0)/2.d0 
     &         + dble(npiv)*dble(ncb+nelim)
        ELSE
           mry = dble(npiv)*dble(npiv) 
     &         + 2.0d0*dble(npiv)*dble(ncb+nelim)
        END IF
!$OMP   ATOMIC UPDATE
        mry_lu_fr  = mry_lu_fr + mry
!$OMP   END ATOMIC
      RETURN

◆ upd_mry_lu_lrgain()

subroutine smumps_lr_stats::upd_mry_lu_lrgain	(	type(lrb_type), dimension(:), intent(in)	blr_panel,
		integer, intent(in)	nbblocks )

Definition at line 450 of file slr_stats.F.

        INTEGER,INTENT(IN) :: NBBLOCKS
        TYPE(LRB_TYPE),  INTENT(IN) :: BLR_PANEL(:)
        DOUBLE PRECISION :: MRY
        INTEGER :: I
        mry    = 0.0d0
        DO i = 1, nbblocks
          IF (blr_panel(i)%ISLR) THEN
            mry = mry + dble(blr_panel(i)%M*blr_panel(i)%N 
     &            - blr_panel(i)%K*(blr_panel(i)%M + blr_panel(i)%N)) 
          ENDIF
        ENDDO
!$OMP   ATOMIC UPDATE
        mry_lu_lrgain  = mry_lu_lrgain  + mry
!$OMP   END ATOMIC
      RETURN

Variable Documentation

◆ avg_blocksize_ass

double precision smumps_lr_stats::avg_blocksize_ass

Definition at line 87 of file slr_stats.F.

87 DOUBLE PRECISION :: AVG_BLOCKSIZE_ASS, AVG_BLOCKSIZE_CB

◆ avg_blocksize_cb

double precision smumps_lr_stats::avg_blocksize_cb

Definition at line 87 of file slr_stats.F.

◆ avg_flop_facto_lr

double precision smumps_lr_stats::avg_flop_facto_lr

Definition at line 81 of file slr_stats.F.

81 DOUBLE PRECISION :: AVG_FLOP_FACTO_LR

◆ cnt_nodes

integer smumps_lr_stats::cnt_nodes

Definition at line 23 of file slr_stats.F.

23 INTEGER :: CNT_NODES

◆ factor_processed_fraction

double precision smumps_lr_stats::factor_processed_fraction

Definition at line 46 of file slr_stats.F.

46 DOUBLE PRECISION :: FACTOR_PROCESSED_FRACTION

◆ factor_size

integer(kind=8) smumps_lr_stats::factor_size

Definition at line 47 of file slr_stats.F.

47 INTEGER(KIND=8) :: FACTOR_SIZE

◆ flop_accum_compress

double precision smumps_lr_stats::flop_accum_compress

Definition at line 38 of file slr_stats.F.

◆ flop_cb_compress

double precision smumps_lr_stats::flop_cb_compress

Definition at line 38 of file slr_stats.F.

◆ flop_cb_decompress

double precision smumps_lr_stats::flop_cb_decompress

Definition at line 38 of file slr_stats.F.

◆ flop_compress

double precision smumps_lr_stats::flop_compress

Definition at line 38 of file slr_stats.F.

      DOUBLE PRECISION :: FLOP_COMPRESS,
     &                    FLOP_CB_COMPRESS,
     &                    FLOP_MIDBLK_COMPRESS,
     &                    FLOP_FRSWAP_COMPRESS,
     &                    FLOP_ACCUM_COMPRESS,
     &                    FLOP_DECOMPRESS,
     &                    FLOP_CB_DECOMPRESS,
     &                    FLOP_FRFRONTS

◆ flop_decompress

double precision smumps_lr_stats::flop_decompress

Definition at line 38 of file slr_stats.F.

◆ flop_facto_fr

double precision smumps_lr_stats::flop_facto_fr

Definition at line 24 of file slr_stats.F.

◆ flop_facto_lr

double precision smumps_lr_stats::flop_facto_lr

Definition at line 24 of file slr_stats.F.

◆ flop_frfronts

double precision smumps_lr_stats::flop_frfronts

Definition at line 38 of file slr_stats.F.

◆ flop_frswap_compress

double precision smumps_lr_stats::flop_frswap_compress

Definition at line 38 of file slr_stats.F.

◆ flop_lrgain

double precision smumps_lr_stats::flop_lrgain

Definition at line 24 of file slr_stats.F.

      DOUBLE PRECISION :: FLOP_LRGAIN,
     &                    FLOP_FACTO_FR,
     &                    FLOP_FACTO_LR,
     &                    FLOP_PANEL,
     &                    FLOP_TRSM,
     &                    FLOP_TRSM_FR,
     &                    FLOP_TRSM_LR,
     &                    FLOP_UPDATE_FR,
     &                    FLOP_UPDATE_LR,
     &                    FLOP_UPDATE_LRLR1,
     &                    FLOP_UPDATE_LRLR2,
     &                    FLOP_UPDATE_LRLR3,
     &                    FLOP_UPDATE_FRLR,
     &                    FLOP_UPDATE_FRFR

◆ flop_midblk_compress

double precision smumps_lr_stats::flop_midblk_compress

Definition at line 38 of file slr_stats.F.

◆ flop_panel

double precision smumps_lr_stats::flop_panel

Definition at line 24 of file slr_stats.F.

◆ flop_trsm

double precision smumps_lr_stats::flop_trsm

Definition at line 24 of file slr_stats.F.

◆ flop_trsm_fr

double precision smumps_lr_stats::flop_trsm_fr

Definition at line 24 of file slr_stats.F.

◆ flop_trsm_lr

double precision smumps_lr_stats::flop_trsm_lr

Definition at line 24 of file slr_stats.F.

◆ flop_update_fr

double precision smumps_lr_stats::flop_update_fr

Definition at line 24 of file slr_stats.F.

◆ flop_update_frfr

double precision smumps_lr_stats::flop_update_frfr

Definition at line 24 of file slr_stats.F.

◆ flop_update_frlr

double precision smumps_lr_stats::flop_update_frlr

Definition at line 24 of file slr_stats.F.

◆ flop_update_lr

double precision smumps_lr_stats::flop_update_lr

Definition at line 24 of file slr_stats.F.

◆ flop_update_lrlr1

double precision smumps_lr_stats::flop_update_lrlr1

Definition at line 24 of file slr_stats.F.

◆ flop_update_lrlr2

double precision smumps_lr_stats::flop_update_lrlr2

Definition at line 24 of file slr_stats.F.

◆ flop_update_lrlr3

double precision smumps_lr_stats::flop_update_lrlr3

Definition at line 24 of file slr_stats.F.

◆ global_mry_lpro_compr

double precision smumps_lr_stats::global_mry_lpro_compr

Definition at line 17 of file slr_stats.F.

◆ global_mry_ltot_compr

double precision smumps_lr_stats::global_mry_ltot_compr

Definition at line 17 of file slr_stats.F.

◆ max_blocksize_ass

integer smumps_lr_stats::max_blocksize_ass

Definition at line 85 of file slr_stats.F.

◆ max_blocksize_cb

integer smumps_lr_stats::max_blocksize_cb

Definition at line 86 of file slr_stats.F.

◆ max_flop_facto_lr

double precision smumps_lr_stats::max_flop_facto_lr

Definition at line 83 of file slr_stats.F.

83 DOUBLE PRECISION :: MAX_FLOP_FACTO_LR

◆ min_blocksize_ass

integer smumps_lr_stats::min_blocksize_ass

Definition at line 85 of file slr_stats.F.

85 INTEGER :: MIN_BLOCKSIZE_ASS, MAX_BLOCKSIZE_ASS

◆ min_blocksize_cb

integer smumps_lr_stats::min_blocksize_cb

Definition at line 86 of file slr_stats.F.

86 INTEGER :: MIN_BLOCKSIZE_CB, MAX_BLOCKSIZE_CB

◆ min_flop_facto_lr

double precision smumps_lr_stats::min_flop_facto_lr

Definition at line 82 of file slr_stats.F.

82 DOUBLE PRECISION :: MIN_FLOP_FACTO_LR

◆ mry_cb_fr

double precision smumps_lr_stats::mry_cb_fr

Definition at line 17 of file slr_stats.F.

      DOUBLE PRECISION :: MRY_CB_FR, 
     &                    MRY_CB_LRGAIN,
     &                    MRY_LU_FR,
     &                    MRY_LU_LRGAIN,
     &                    GLOBAL_MRY_LPRO_COMPR,
     &                    GLOBAL_MRY_LTOT_COMPR

◆ mry_cb_lrgain

double precision smumps_lr_stats::mry_cb_lrgain

Definition at line 17 of file slr_stats.F.

◆ mry_lu_fr

double precision smumps_lr_stats::mry_lu_fr

Definition at line 17 of file slr_stats.F.

◆ mry_lu_lrgain

double precision smumps_lr_stats::mry_lu_lrgain

Definition at line 17 of file slr_stats.F.

◆ time_cb_compress

double precision smumps_lr_stats::time_cb_compress

Definition at line 58 of file slr_stats.F.

58 DOUBLE PRECISION :: TIME_CB_COMPRESS

◆ time_compress

double precision smumps_lr_stats::time_compress

Definition at line 55 of file slr_stats.F.

55 DOUBLE PRECISION :: TIME_COMPRESS

◆ time_decomp

double precision smumps_lr_stats::time_decomp

Definition at line 69 of file slr_stats.F.

69 DOUBLE PRECISION :: TIME_DECOMP

◆ time_decomp_asm1

double precision smumps_lr_stats::time_decomp_asm1

Definition at line 71 of file slr_stats.F.

71 DOUBLE PRECISION :: TIME_DECOMP_ASM1

◆ time_decomp_asms2m

double precision smumps_lr_stats::time_decomp_asms2m

Definition at line 75 of file slr_stats.F.

75 DOUBLE PRECISION :: TIME_DECOMP_ASMS2M

◆ time_decomp_asms2s

double precision smumps_lr_stats::time_decomp_asms2s

Definition at line 74 of file slr_stats.F.

74 DOUBLE PRECISION :: TIME_DECOMP_ASMS2S

◆ time_decomp_locasm2

double precision smumps_lr_stats::time_decomp_locasm2

Definition at line 72 of file slr_stats.F.

72 DOUBLE PRECISION :: TIME_DECOMP_LOCASM2

◆ time_decomp_maplig1

double precision smumps_lr_stats::time_decomp_maplig1

Definition at line 73 of file slr_stats.F.

73 DOUBLE PRECISION :: TIME_DECOMP_MAPLIG1

◆ time_decomp_ucfs

double precision smumps_lr_stats::time_decomp_ucfs

Definition at line 70 of file slr_stats.F.

70 DOUBLE PRECISION :: TIME_DECOMP_UCFS

◆ time_diagcopy

double precision smumps_lr_stats::time_diagcopy

Definition at line 68 of file slr_stats.F.

68 DOUBLE PRECISION :: TIME_DIAGCOPY

◆ time_fac_i

double precision smumps_lr_stats::time_fac_i

Definition at line 64 of file slr_stats.F.

64 DOUBLE PRECISION :: TIME_FAC_I

◆ time_fac_mq

double precision smumps_lr_stats::time_fac_mq

Definition at line 65 of file slr_stats.F.

65 DOUBLE PRECISION :: TIME_FAC_MQ

◆ time_fac_sq

double precision smumps_lr_stats::time_fac_sq

Definition at line 66 of file slr_stats.F.

66 DOUBLE PRECISION :: TIME_FAC_SQ

◆ time_frfronts

double precision smumps_lr_stats::time_frfronts

Definition at line 67 of file slr_stats.F.

67 DOUBLE PRECISION :: TIME_FRFRONTS

◆ time_frswap_compress

double precision smumps_lr_stats::time_frswap_compress

Definition at line 57 of file slr_stats.F.

57 DOUBLE PRECISION :: TIME_FRSWAP_COMPRESS

◆ time_frtrsm

double precision smumps_lr_stats::time_frtrsm

Definition at line 62 of file slr_stats.F.

62 DOUBLE PRECISION :: TIME_FRTRSM

◆ time_lr_module

double precision smumps_lr_stats::time_lr_module

Definition at line 59 of file slr_stats.F.

59 DOUBLE PRECISION :: TIME_LR_MODULE

◆ time_lrana_gethalo

double precision smumps_lr_stats::time_lrana_gethalo

Definition at line 78 of file slr_stats.F.

78 DOUBLE PRECISION :: TIME_LRANA_GETHALO

◆ time_lrana_gnew

double precision smumps_lr_stats::time_lrana_gnew

Definition at line 80 of file slr_stats.F.

80 DOUBLE PRECISION :: TIME_LRANA_GNEW

◆ time_lrana_kway

double precision smumps_lr_stats::time_lrana_kway

Definition at line 79 of file slr_stats.F.

79 DOUBLE PRECISION :: TIME_LRANA_KWAY

◆ time_lrana_lrgrouping

double precision smumps_lr_stats::time_lrana_lrgrouping

Definition at line 76 of file slr_stats.F.

76 DOUBLE PRECISION :: TIME_LRANA_LRGROUPING

◆ time_lrana_sepgrouping

double precision smumps_lr_stats::time_lrana_sepgrouping

Definition at line 77 of file slr_stats.F.

77 DOUBLE PRECISION :: TIME_LRANA_SEPGROUPING

◆ time_lrtrsm

double precision smumps_lr_stats::time_lrtrsm

Definition at line 61 of file slr_stats.F.

61 DOUBLE PRECISION :: TIME_LRTRSM

◆ time_midblk_compress

double precision smumps_lr_stats::time_midblk_compress

Definition at line 56 of file slr_stats.F.

56 DOUBLE PRECISION :: TIME_MIDBLK_COMPRESS

◆ time_panel

double precision smumps_lr_stats::time_panel

Definition at line 63 of file slr_stats.F.

63 DOUBLE PRECISION :: TIME_PANEL

◆ time_upd_nelim

double precision smumps_lr_stats::time_upd_nelim

Definition at line 60 of file slr_stats.F.

60 DOUBLE PRECISION :: TIME_UPD_NELIM

◆ time_update

double precision smumps_lr_stats::time_update

Definition at line 49 of file slr_stats.F.

49 DOUBLE PRECISION :: TIME_UPDATE

◆ time_update_frfr

double precision smumps_lr_stats::time_update_frfr

Definition at line 54 of file slr_stats.F.

54 DOUBLE PRECISION :: TIME_UPDATE_FRFR

◆ time_update_frlr

double precision smumps_lr_stats::time_update_frlr

Definition at line 53 of file slr_stats.F.

53 DOUBLE PRECISION :: TIME_UPDATE_FRLR

◆ time_update_lrlr1

double precision smumps_lr_stats::time_update_lrlr1

Definition at line 50 of file slr_stats.F.

50 DOUBLE PRECISION :: TIME_UPDATE_LRLR1

◆ time_update_lrlr2

double precision smumps_lr_stats::time_update_lrlr2

Definition at line 51 of file slr_stats.F.

51 DOUBLE PRECISION :: TIME_UPDATE_LRLR2

◆ time_update_lrlr3

double precision smumps_lr_stats::time_update_lrlr3

Definition at line 52 of file slr_stats.F.

52 DOUBLE PRECISION :: TIME_UPDATE_LRLR3

◆ total_flop

double precision smumps_lr_stats::total_flop

Definition at line 48 of file slr_stats.F.

48 DOUBLE PRECISION :: TOTAL_FLOP

◆ total_nblocks_ass

integer smumps_lr_stats::total_nblocks_ass

Definition at line 84 of file slr_stats.F.

84 INTEGER :: TOTAL_NBLOCKS_ASS, TOTAL_NBLOCKS_CB

◆ total_nblocks_cb

integer smumps_lr_stats::total_nblocks_cb

Definition at line 84 of file slr_stats.F.

OpenRadioss 2025.1.11 OpenRadioss project

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ collect_blocksizes()

◆ compute_global_gains()

◆ init_stats_global()

◆ saveandwrite_gains()

◆ stats_compute_flop_slave_type2()

◆ upd_flop_compress()

◆ upd_flop_decompress()

◆ upd_flop_facto_fr()

◆ upd_flop_frfront_slave()

◆ upd_flop_frfronts()

◆ upd_flop_root()

◆ upd_flop_trsm()

◆ upd_flop_update()

◆ upd_flop_update_lrlr3()

◆ upd_mry_cb_fr()

◆ upd_mry_cb_lrgain()

◆ upd_mry_lu_fr()

◆ upd_mry_lu_lrgain()

Variable Documentation

◆ avg_blocksize_ass

◆ avg_blocksize_cb

◆ avg_flop_facto_lr

◆ cnt_nodes

◆ factor_processed_fraction

◆ factor_size

◆ flop_accum_compress

◆ flop_cb_compress

◆ flop_cb_decompress

◆ flop_compress

◆ flop_decompress

◆ flop_facto_fr

◆ flop_facto_lr

◆ flop_frfronts

◆ flop_frswap_compress

◆ flop_lrgain

◆ flop_midblk_compress

◆ flop_panel

◆ flop_trsm

◆ flop_trsm_fr

◆ flop_trsm_lr

◆ flop_update_fr

◆ flop_update_frfr

◆ flop_update_frlr

◆ flop_update_lr

◆ flop_update_lrlr1

◆ flop_update_lrlr2

◆ flop_update_lrlr3

◆ global_mry_lpro_compr

◆ global_mry_ltot_compr

◆ max_blocksize_ass

◆ max_blocksize_cb

◆ max_flop_facto_lr

◆ min_blocksize_ass

◆ min_blocksize_cb

◆ min_flop_facto_lr

◆ mry_cb_fr

◆ mry_cb_lrgain

◆ mry_lu_fr

◆ mry_lu_lrgain

◆ time_cb_compress

◆ time_compress

◆ time_decomp

◆ time_decomp_asm1

◆ time_decomp_asms2m

◆ time_decomp_asms2s

◆ time_decomp_locasm2

◆ time_decomp_maplig1

◆ time_decomp_ucfs

◆ time_diagcopy

◆ time_fac_i

◆ time_fac_mq

◆ time_fac_sq

◆ time_frfronts

◆ time_frswap_compress

◆ time_frtrsm

◆ time_lr_module

◆ time_lrana_gethalo