pb_numroc()

integer function pb_numroc	(	integer	n,
		integer	i,
		integer	inb,
		integer	nb,
		integer	proc,
		integer	srcproc,
		integer	nprocs
	)

Definition at line 2547 of file pblastst.f.

*
*  -- PBLAS test routine (version 2.0) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     April 1, 1998
*
*     .. Scalar Arguments ..
      INTEGER            I, INB, N, NB, NPROCS, PROC, SRCPROC
*     ..
*
*  Purpose
*  =======
*
*  PB_NUMROC   returns  the  local number of matrix rows/columns process
*  PROC will get  if we give out N rows/columns starting from global in-
*  dex I.
*
*  Arguments
*  =========
*
*  N       (global input) INTEGER
*          On entry, N  specifies the number of rows/columns being dealt
*          out. N must be at least zero.
*
*  I       (global input) INTEGER
*          On entry, I  specifies the global index of the matrix  entry.
*          I must be at least one.
*
*  INB     (global input) INTEGER
*          On entry,  INB  specifies  the size of the first block of the
*          global matrix. INB must be at least one.
*
*  NB      (global input) INTEGER
*          On entry, NB specifies the size of the blocks used to  parti-
*          tion the matrix. NB must be at least one.
*
*  PROC    (local input) INTEGER
*          On entry, PROC specifies  the coordinate of the process whose
*          local portion is determined.  PROC must be at least zero  and
*          strictly less than NPROCS.
*
*  SRCPROC (global input) INTEGER
*          On entry,  SRCPROC  specifies  the coordinate of the  process
*          that possesses the  first row or column  of the matrix.  When
*          SRCPROC = -1, the data  is not  distributed  but  replicated,
*          otherwise  SRCPROC  must be at least zero and  strictly  less
*          than NPROCS.
*
*  NPROCS  (global input) INTEGER
*          On entry,  NPROCS  specifies the total number of process rows
*          or columns over which the matrix is distributed.  NPROCS must
*          be at least one.
*
*  -- Written on April 1, 1998 by
*     Antoine Petitet, University  of  Tennessee, Knoxville 37996, USA.
*
*  =====================================================================
*
*     .. Local Scalars ..
      INTEGER            I1, ILOCBLK, INB1, MYDIST, N1, NBLOCKS,
     $                   SRCPROC1
*     ..
*     .. Executable Statements ..
*
      IF( ( srcproc.EQ.-1 ).OR.( nprocs.EQ.1 ) ) THEN
         pb_numroc = n
         RETURN
      END IF
*
*     Compute coordinate of process owning I and corresponding INB
*
      IF( i.LE.inb ) THEN
*
*        I is in range of first block, i.e SRCPROC owns I.
*
         srcproc1 = srcproc
         inb1 = inb - i + 1
*
      ELSE
*
*        I is not in first block of matrix, figure out who has it
*
         i1 = i - 1 - inb
         nblocks = i1 / nb + 1
         srcproc1 = srcproc + nblocks
         srcproc1 = srcproc1 - ( srcproc1 / nprocs ) * nprocs
         inb1 = nblocks*nb - i1
*
      END IF
*
*     Now everything is just like I=1. Search now who has N-1, Is N-1
*     in the first block ?
*
      IF( n.LE.inb1 ) THEN
         IF( proc.EQ.srcproc1 ) THEN
            pb_numroc = n
         ELSE
            pb_numroc = 0
         END IF
         RETURN
      END IF
*
      n1 = n - inb1
      nblocks = n1 / nb + 1
*
      IF( proc.EQ.srcproc1 ) THEN
         ilocblk = nblocks / nprocs
         IF( ilocblk.GT.0 ) THEN
            IF( ( nblocks - ilocblk * nprocs ).GT.0 ) THEN
               pb_numroc = inb1 + ilocblk * nb
            ELSE
               pb_numroc = n + nb * ( ilocblk - nblocks )
            END IF
         ELSE
            pb_numroc = inb1
         END IF
      ELSE
         mydist = proc - srcproc1
         IF( mydist.LT.0 )
     $      mydist = mydist + nprocs
         ilocblk = nblocks / nprocs
         IF( ilocblk.GT.0 ) THEN
            mydist = mydist - nblocks + ilocblk * nprocs
            IF( mydist.LT.0 ) THEN
               pb_numroc = ( ilocblk + 1 ) * nb
            ELSE IF( mydist.GT.0 ) THEN
               pb_numroc = ilocblk * nb
            ELSE
               pb_numroc = n1 + nb * ( ilocblk - nblocks + 1 )
            END IF
         ELSE
            mydist = mydist - nblocks
            IF( mydist.LT.0 ) THEN
               pb_numroc = nb
            ELSE IF( mydist.GT.0 ) THEN
               pb_numroc = 0
            ELSE
               pb_numroc = n1 + nb * ( 1 - nblocks )
            END IF
         END IF
      END IF
*
      RETURN
*
*     End of PB_NUMROC
*

Here is the call graph for this function:

Here is the caller graph for this function: