psgstrf3d.c File Reference

Performs LU factorization in 3D process grid. More...

#include "superlu_sdefs.h"

Include dependency graph for psgstrf3d.c:

Functions
int_t	psgstrf3d (superlu_dist_options_t *options, int m, int n, float anorm, strf3Dpartition_t *trf3Dpartition, SCT_t *SCT, sLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, int *info)

Detailed Description

Performs LU factorization in 3D process grid.

Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)

All rights reserved.

The source code is distributed under BSD license, see the file License.txt at the top-level directory.

   -- Distributed SuperLU routine (version 7.2) --
   Lawrence Berkeley National Lab, Georgia Institute of Technology,
   Oak Ridge National Lab
   May 12, 2021
   Last update: December 12, 2021  v7.2.0
 */


























/*!


   
   Purpose
   =======

   PSGSTRF3D performs the LU factorization in parallel using 3D process grid,
   which is a communication-avoiding algorithm compared to the 2D algorithm.

   Arguments
   =========

   options (input) superlu_dist_options_t*
           The structure defines the input parameters to control
           how the LU decomposition will be performed.
           The following field should be defined:
           o ReplaceTinyPivot (yes_no_t)
             Specifies whether to replace the tiny diagonals by
             sqrt(epsilon)*norm(A) during LU factorization.

   m      (input) int
          Number of rows in the matrix.

   n      (input) int
          Number of columns in the matrix.

   anorm  (input) float
          The norm of the original matrix A, or the scaled A if
          equilibration was done.

   trf3Dpartition (input) trf3Dpartition*
          Matrix partitioning information in 3D process grid.

   SCT    (input/output) SCT_t*
          Various statistics of 3D factorization.

   LUstruct (input/output) sLUstruct_t*
           The data structures to store the distributed L and U factors.
           The following fields should be defined:

           o Glu_persist (input) Glu_persist_t*
             Global data structure (xsup, supno) replicated on all processes,
             describing the supernode partition in the factored matrices
             L and U:
           xsup[s] is the leading column of the s-th supernode,
               supno[i] is the supernode number to which column i belongs.

           o Llu (input/output) sLocalLU_t*
             The distributed data structures to store L and U factors.
             See superlu_sdefs.h for the definition of 'sLocalLU_t'.

   grid3d (input) gridinfo3d_t*
          The 3D process mesh. It contains the MPI communicator, the number
          of process rows (NPROW), the number of process columns (NPCOL),
          and replication factor in Z-dimension. It is an input argument to all
          the 3D parallel routines.
          Grid3d can be initialized by subroutine SUPERLU_GRIDINIT3D.
          See superlu_defs.h for the definition of 'gridinfo3d_t'.

   stat   (output) SuperLUStat_t*
          Record the statistics on runtime and floating-point operation count.
          See util_dist.h for the definition of 'SuperLUStat_t'.

   info   (output) int*
          = 0: successful exit
          < 0: if info = -i, the i-th argument had an illegal value
          > 0: if info = i, U(i,i) is exactly zero. The factorization has
               been completed, but the factor U is exactly singular,
               and division by zero will occur if it is used to solve a
               system of equations.
   
 

Function Documentation

psgstrf3d()

int_t psgstrf3d	(	superlu_dist_options_t *	options,
		int	m,
		int	n,
		float	anorm,
		strf3Dpartition_t *	trf3Dpartition,
		SCT_t *	SCT,
		sLUstruct_t *	LUstruct,
		gridinfo3d_t *	grid3d,
		SuperLUStat_t *	stat,
		int *	info
	)

Here is the call graph for this function: