Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
PSLARED2D(l)			       )			  PSLARED2D(l)

NAME
       PSLARED2D  -  redistribute a 1D array  It assumes that the input	array,
       BYROW, is distributed across columns and	that all process rows  contain
       the same	copy of	BYROW

SYNOPSIS
       SUBROUTINE PSLARED2D( N,	IA, JA,	DESC, BYROW, BYALL, WORK, LWORK	)

	   INTEGER	     IA, JA, LWORK, N

	   INTEGER	     DESC( * )

	   REAL		     BYALL( * ), BYROW(	* ), WORK( LWORK )

PURPOSE
       PSLARED2D redistributes a 1D array It assumes that the input array, BY-
       ROW, is distributed across columns and that all	process	 rows  contain
       the  same  copy of BYROW. The output array, BYALL, will be identical on
       all processes and will contain the entire array.

       Notes
       =====

       Each global data	object is described by an associated description  vec-
       tor.  This vector stores	the information	required to establish the map-
       ping between an object element and its corresponding process and	memory
       location.

       Let  A  be  a generic term for any 2D block cyclicly distributed	array.
       Such a global array has an associated description vector	DESCA.	In the
       following  comments,  the  character _ should be	read as	"of the	global
       array".

       NOTATION	       STORED IN      EXPLANATION
       ---------------	--------------	--------------------------------------
       DTYPE_A(global) DESCA( DTYPE_ )The descriptor type.  In this case,
				      DTYPE_A =	1.
       CTXT_A (global) DESCA( CTXT_ ) The BLACS	context	handle,	indicating
				      the BLACS	process	grid A is distribu-
				      ted over.	The context itself is glo-
				      bal, but the handle (the integer
				      value) may vary.
       M_A    (global) DESCA( M_ )    The number of rows in the	global
				      array A.
       N_A    (global) DESCA( N_ )    The number of columns in the global
				      array A.
       MB_A   (global) DESCA( MB_ )   The blocking factor used to distribute
				      the rows of the array.
       NB_A   (global) DESCA( NB_ )   The blocking factor used to distribute
				      the columns of the array.
       RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
				      row  of  the  array  A  is  distributed.
       CSRC_A (global) DESCA( CSRC_ ) The process column over which the
				      first column of the array	A is
				      distributed.
       LLD_A  (local)  DESCA( LLD_ )  The leading dimension of the local
				      array.  LLD_A >= MAX(1,LOCr(M_A)).

       Let K be	the number of rows or columns of a distributed matrix, and as-
       sume that its process grid has dimension	p x q.
       LOCr(  K	) denotes the number of	elements of K that a process would re-
       ceive if	K were distributed over	the p processes	of its process column.
       Similarly, LOCc(	K ) denotes the	number of elements of K	that a process
       would receive if	K were distributed over	the q processes	of its process
       row.
       The values of LOCr() and	LOCc() may be determined via  a	 call  to  the
       ScaLAPACK tool function,	NUMROC:
	       LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
	       LOCc(  N	) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).  An upper
       bound for these quantities may be computed by:
	       LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
	       LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A

ARGUMENTS
       NP = Number of local rows in BYROW()

       N       (global input) INTEGER
	       The number of elements to be redistributed.  N >= 0.

       IA      (global input) INTEGER
	       IA must be equal	to 1

       JA      (global input) INTEGER
	       JA must be equal	to 1

       DESC    (global/local input) INTEGER Array of dimension DLEN_
	       A 2D array descriptor, which describes BYROW

       BYROW   (local input) distributed block cyclic REAL	      array
	       global dimension	(N), local dimension NP	BYCOL  is  distributed
	       across the process columns All process rows are assumed to con-
	       tain the	same value

       BYALL   (global output) REAL	       global dimension( N )
	       local dimension (N) BYALL is exactly  duplicated	 on  all  pro-
	       cesses  It  contains the	same values as BYCOL, but it is	repli-
	       cated across all	processes rather than being distributed

	       BYALL(i)	= BYCOL(  NUMROC(i,NB,MYROW,0,NPROW  )	on  the	 procs
	       whose MYROW == mod((i-1)/NB,NPROW)

       WORK    (local workspace) REAL		 dimension (LWORK)
	       Used to hold the	buffers	sent from one process to another

       LWORK   (local input) INTEGER size of WORK array	LWORK >=
	       LWORK >=	NUMROC(N, DESC(	NB_ ), 0, 0, NPCOL)

ScaLAPACK version 1.7		13 August 2001			  PSLARED2D(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=pslared2d&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help