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

FreeBSD Manual Pages

  
 
  

home | help
PDLARED1D(l)			       )			  PDLARED1D(l)

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

SYNOPSIS
       SUBROUTINE PDLARED1D( N,	IA, JA,	DESC, BYCOL, BYALL, WORK, LWORK	)

	   INTEGER	     IA, JA, LWORK, N

	   INTEGER	     DESC( * )

	   DOUBLE	     PRECISION BYALL( *	), BYCOL( * ), WORK( LWORK )

PURPOSE
       PDLARED1D redistributes a 1D array It assumes that the input array, BY-
       COL, is distributed across rows and that	all process column contain the
       same  copy  of BYCOL. 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 BYCOL()

       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 8
	       A 2D array descirptor, which describes BYCOL

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

       BYALL   (global output) DOUBLE PRECISION	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) DOUBLE	PRECISION dimension (LWORK)
	       Used to hold the	buffers	sent from one process to another

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

ScaLAPACK version 1.7		13 August 2001			  PDLARED1D(l)

NAME | SYNOPSIS | PURPOSE | ARGUMENTS

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

home | help