 |
FrontISTR
6.0.0
Large-scale structural analysis program with finit element method
|
|
FrontISTR
6.0.0
Large-scale structural analysis program with finit element method
|
Numeric factorization (tiled multifrontal LDLt with threshold pivoting and delayed pivots) and the triangular solves, on the read-only structure of hecmw_mf_symbolic. More...
Functions/Subroutines | |
| subroutine, public | hecmw_mf_numeric_init (graph, sym, tile, blr, eta, fct) |
| Estimates of the factor and stack sizes from the symbolic structure and the work space; tile is the target tile size in DOFs. With blr and eta > 0 the cluster distance cache for the admissibility test is built from the graph, capped at eta (a serial pass over the symbolic structure, identical on every rank). More... | |
| subroutine, public | hecmw_mf_numeric_finalize (fct) |
| subroutine, public | hecmw_mf_numeric_admis_bcast (fct, root) |
| Broadcast the admissibility cache from the rank that built it (the distributed driver builds the graph on the root only); bdptr is rebuilt from the per-front sizes. More... | |
| subroutine, public | hecmw_mf_numeric_factor (hecMAT, sym, fct, ierr) |
| Factor the matrix of hecMAT in the order of sym, in LDLt mode (lower part referenced) or in LU mode when the symmetric flag is off; the mode option overrides either way. ierr is 0 on success, the permuted DOF of a zero pivot (singular matrix), -1 when the block size of hecMAT does not match the structure, or -2 when the structure is not symmetric. More... | |
| subroutine, public | hecmw_mf_numeric_factor_mpi (hecMAT, sym, map, fct, ierr) |
| Factor the matrix with the supernodes distributed by map: every rank first factors its subtrees with the task-parallel code, then every rank of a rank set walks the upper fronts in ascending order. hecMAT may hold the matrix partially: a rank reads the rows of the own columns of its supernodes only, each block paired with its transposed partner, so a matrix reduced to those pairs (with the index arrays kept full length) factors bitwise like the replicated one. The assembly, the factorization and the storage of an upper front are distributed over its rank set by contribution row tiles (1D row distribution), the fully summed part staying with the master (the owner), which keeps the pivot sequence identical to the sequential factorization. MPI calls stay on the master thread outside the parallel regions because hecmw initializes MPI without a threading level. Sends are isend and are consumed within the phase of their front, so a rank blocked in a receive has already issued every send an earlier front needs, which makes the ascending walk deadlock free. Tags encode 16*supernode+kind, relying on a tag space larger than the MPI minimum of 32767, as every mainstream MPI provides. More... | |
| subroutine, public | hecmw_mf_numeric_solve (sym, fct, b, x) |
| x = A^-1 b with the factor; b and x are in the original DOF numbering. The forward solve works on the row DOFs (z, indexed by frow), the backward solve on the column DOFs (xx). A front reads the b entries of its own DOFs only; the forward result of the rows beyond its pivots is kept per supernode (dval) and added by the parent, mirroring the extend-add. More... | |
| subroutine, public | hecmw_mf_numeric_solve_mpi (sym, map, fct, b, x) |
| x = A^-1 b on the supernodes distributed by map; b and x are the replicated global vectors in the original DOF numbering. The solves of the upper fronts follow the 1D row distribution of the factorization: the master runs the fully summed sweeps, every tile owner applies its stored rows, and the forward contributions travel as row slices to the ranks holding the parent rows. In the backward substitution the running right hand side of a tile column travels along the tile owners in ascending order (a token chain), so the reduction keeps the sequential fold order and the solution stays bitwise identical to the sequential solve. The solved pivot values of the owned supernodes are summed over the ranks at the end, which is exact and order independent because every DOF is eliminated on exactly one rank. More... | |
| integer(kind=8) function, public | hecmw_mf_numeric_front_words (fct, s) |
| Stored panel words of supernode s held on this rank (test support). More... | |
| subroutine, public | hecmw_mf_numeric_print (fct) |
Variables | |
| integer(kind=kint), parameter, public | mf_blr_eta = 2 |
| BLR admissibility: default cluster distance threshold, a contribution tile within it of the pivot cluster is expected full rank and skips the compression attempt. More... | |
Numeric factorization (tiled multifrontal LDLt with threshold pivoting and delayed pivots) and the triangular solves, on the read-only structure of hecmw_mf_symbolic.
The positions of a front are the own DOFs of the supernode, the DOFs delayed by its children (together the ncol fully summed positions) and the DOFs of the contribution rows. The front is partitioned into tiles, cut at node boundaries where possible, and only the tiles on or below the diagonal are stored, tile column by tile column, each tile column major. Pivots are eliminated in position order; a fully summed column without an acceptable pivot is exchanged to the end of the fully summed part and joins the contribution block, so that the factor panel of a front is the leading npiv columns of its tile grid. Front sizes, tile partitions and the factor layout therefore depend on the values and are rebuilt by every factorization. The factor panel, the position metadata and the contribution block of a supernode are stored per supernode; a contribution block lives from the factorization of its supernode until the extend-add of the parent consumes it.
A matrix whose symmetric flag is off (the assembly clears it for numerically unsymmetric problems) is factored in LU mode: the part of the front above the diagonal is held transposed in a second grid of the same layout (fvalu, and uval for the stored U panels), pivots are chosen by threshold partial pivoting among the fully summed rows, and the row DOF of a position (frow) may then differ from its column DOF (fsdof). Delayed positions carry both to the parent.
Loop parallelism is written as explicit tasks in a taskgroup, never as a taskloop construct: nvfortran rejects taskloop outright, and ifx (2026.1) miscompiles the reference-argument temporaries of procedure calls in the outlined body of a taskloop.
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_admis_bcast | ( | type(hecmwst_mf_factor), intent(inout) | fct, |
| integer(kind=kint), intent(in) | root | ||
| ) |
Broadcast the admissibility cache from the rank that built it (the distributed driver builds the graph on the root only); bdptr is rebuilt from the per-front sizes.
Definition at line 422 of file hecmw_mf_numeric.f90.
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_factor | ( | type(hecmwst_matrix), intent(in) | hecMAT, |
| type(hecmwst_mf_symbolic), intent(in) | sym, | ||
| type(hecmwst_mf_factor), intent(inout) | fct, | ||
| integer(kind=kint), intent(out) | ierr | ||
| ) |
Factor the matrix of hecMAT in the order of sym, in LDLt mode (lower part referenced) or in LU mode when the symmetric flag is off; the mode option overrides either way. ierr is 0 on success, the permuted DOF of a zero pivot (singular matrix), -1 when the block size of hecMAT does not match the structure, or -2 when the structure is not symmetric.
Definition at line 1112 of file hecmw_mf_numeric.f90.
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_factor_mpi | ( | type(hecmwst_matrix), intent(in) | hecMAT, |
| type(hecmwst_mf_symbolic), intent(in) | sym, | ||
| type(hecmwst_mf_map), intent(in) | map, | ||
| type(hecmwst_mf_factor), intent(inout) | fct, | ||
| integer(kind=kint), intent(out) | ierr | ||
| ) |
Factor the matrix with the supernodes distributed by map: every rank first factors its subtrees with the task-parallel code, then every rank of a rank set walks the upper fronts in ascending order. hecMAT may hold the matrix partially: a rank reads the rows of the own columns of its supernodes only, each block paired with its transposed partner, so a matrix reduced to those pairs (with the index arrays kept full length) factors bitwise like the replicated one. The assembly, the factorization and the storage of an upper front are distributed over its rank set by contribution row tiles (1D row distribution), the fully summed part staying with the master (the owner), which keeps the pivot sequence identical to the sequential factorization. MPI calls stay on the master thread outside the parallel regions because hecmw initializes MPI without a threading level. Sends are isend and are consumed within the phase of their front, so a rank blocked in a receive has already issued every send an earlier front needs, which makes the ascending walk deadlock free. Tags encode 16*supernode+kind, relying on a tag space larger than the MPI minimum of 32767, as every mainstream MPI provides.
Definition at line 1267 of file hecmw_mf_numeric.f90.
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_finalize | ( | type(hecmwst_mf_factor), intent(inout) | fct | ) |
| integer(kind=8) function, public hecmw_mf_numeric::hecmw_mf_numeric_front_words | ( | type(hecmwst_mf_factor), intent(in) | fct, |
| integer(kind=kint), intent(in) | s | ||
| ) |
Stored panel words of supernode s held on this rank (test support).
Definition at line 7506 of file hecmw_mf_numeric.f90.
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_init | ( | type(hecmwst_mf_graph), intent(in) | graph, |
| type(hecmwst_mf_symbolic), intent(in) | sym, | ||
| integer(kind=kint), intent(in) | tile, | ||
| logical, intent(in) | blr, | ||
| integer(kind=kint), intent(in) | eta, | ||
| type(hecmwst_mf_factor), intent(out) | fct | ||
| ) |
Estimates of the factor and stack sizes from the symbolic structure and the work space; tile is the target tile size in DOFs. With blr and eta > 0 the cluster distance cache for the admissibility test is built from the graph, capped at eta (a serial pass over the symbolic structure, identical on every rank).
Definition at line 280 of file hecmw_mf_numeric.f90.
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_print | ( | type(hecmwst_mf_factor), intent(in) | fct | ) |
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_solve | ( | type(hecmwst_mf_symbolic), intent(in) | sym, |
| type(hecmwst_mf_factor), intent(inout) | fct, | ||
| real(kind=kreal), dimension(:), intent(in) | b, | ||
| real(kind=kreal), dimension(:), intent(out) | x | ||
| ) |
x = A^-1 b with the factor; b and x are in the original DOF numbering. The forward solve works on the row DOFs (z, indexed by frow), the backward solve on the column DOFs (xx). A front reads the b entries of its own DOFs only; the forward result of the rows beyond its pivots is kept per supernode (dval) and added by the parent, mirroring the extend-add.
Definition at line 6114 of file hecmw_mf_numeric.f90.
| subroutine, public hecmw_mf_numeric::hecmw_mf_numeric_solve_mpi | ( | type(hecmwst_mf_symbolic), intent(in) | sym, |
| type(hecmwst_mf_map), intent(in) | map, | ||
| type(hecmwst_mf_factor), intent(inout) | fct, | ||
| real(kind=kreal), dimension(:), intent(in) | b, | ||
| real(kind=kreal), dimension(:), intent(out) | x | ||
| ) |
x = A^-1 b on the supernodes distributed by map; b and x are the replicated global vectors in the original DOF numbering. The solves of the upper fronts follow the 1D row distribution of the factorization: the master runs the fully summed sweeps, every tile owner applies its stored rows, and the forward contributions travel as row slices to the ranks holding the parent rows. In the backward substitution the running right hand side of a tile column travels along the tile owners in ascending order (a token chain), so the reduction keeps the sequential fold order and the solution stays bitwise identical to the sequential solve. The solved pivot values of the owned supernodes are summed over the ranks at the end, which is exact and order independent because every DOF is eliminated on exactly one rank.
Definition at line 6224 of file hecmw_mf_numeric.f90.
| integer(kind=kint), parameter, public hecmw_mf_numeric::mf_blr_eta = 2 |
BLR admissibility: default cluster distance threshold, a contribution tile within it of the pivot cluster is expected full rank and skips the compression attempt.
Definition at line 60 of file hecmw_mf_numeric.f90.
1.9.1