pcgeqpf()

subroutine pcgeqpf	(	integer	m,
		integer	n,
		complex, dimension( * )	a,
		integer	ia,
		integer	ja,
		integer, dimension( * )	desca,
		integer, dimension( * )	ipiv,
		complex, dimension( * )	tau,
		complex, dimension( * )	work,
		integer	lwork,
		real, dimension( * )	rwork,
		integer	lrwork,
		integer	info
	)

Definition at line 1 of file pcgeqpf.f.

*
*  -- ScaLAPACK routine (version 2.1) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     November 20, 2019
*
*     .. Scalar Arguments ..
      INTEGER            IA, JA, INFO, LRWORK, LWORK, M, N
*     ..
*     .. Array Arguments ..
      INTEGER            DESCA( * ), IPIV( * )
      REAL               RWORK( * )
      COMPLEX            A( * ), TAU( * ), WORK( * )
*     ..
*
*  Purpose
*  =======
*
*  PCGEQPF computes a QR factorization with column pivoting of a
*  M-by-N distributed matrix sub( A ) = A(IA:IA+M-1,JA:JA+N-1):
*
*                         sub( A ) * P = Q * R.
*
*  Notes
*  =====
*
*  Each global data object is described by an associated description
*  vector.  This vector stores the information required to establish
*  the mapping 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 assume that its process grid has dimension p x q.
*  LOCr( K ) denotes the number of elements of K that a process
*  would receive 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
*  =========
*
*  M       (global input) INTEGER
*          The number of rows to be operated on, i.e. the number of rows
*          of the distributed submatrix sub( A ). M >= 0.
*
*  N       (global input) INTEGER
*          The number of columns to be operated on, i.e. the number of
*          columns of the distributed submatrix sub( A ). N >= 0.
*
*  A       (local input/local output) COMPLEX pointer into the
*          local memory to an array of dimension (LLD_A, LOCc(JA+N-1)).
*          On entry, the local pieces of the M-by-N distributed matrix
*          sub( A ) which is to be factored. On exit, the elements on
*          and above the diagonal of sub( A ) contain the min(M,N) by N
*          upper trapezoidal matrix R (R is upper triangular if M >= N);
*          the elements below the diagonal, with the array TAU, repre-
*          sent the unitary matrix Q as a product of elementary
*          reflectors (see Further Details).
*
*  IA      (global input) INTEGER
*          The row index in the global array A indicating the first
*          row of sub( A ).
*
*  JA      (global input) INTEGER
*          The column index in the global array A indicating the
*          first column of sub( A ).
*
*  DESCA   (global and local input) INTEGER array of dimension DLEN_.
*          The array descriptor for the distributed matrix A.
*
*  IPIV    (local output) INTEGER array, dimension LOCc(JA+N-1).
*          On exit, if IPIV(I) = K, the local i-th column of sub( A )*P
*          was the global K-th column of sub( A ). IPIV is tied to the
*          distributed matrix A.
*
*  TAU     (local output) COMPLEX, array, dimension
*          LOCc(JA+MIN(M,N)-1). This array contains the scalar factors
*          TAU of the elementary reflectors. TAU is tied to the
*          distributed matrix A.
*
*  WORK    (local workspace/local output) COMPLEX array,
*                                                    dimension (LWORK)
*          On exit, WORK(1) returns the minimal and optimal LWORK.
*
*  LWORK   (local or global input) INTEGER
*          The dimension of the array WORK.
*          LWORK is local input and must be at least
*          LWORK >= MAX(3,Mp0 + Nq0).
*
*          If LWORK = -1, then LWORK is global input and a workspace
*          query is assumed; the routine only calculates the minimum
*          and optimal size for all work arrays. Each of these
*          values is returned in the first entry of the corresponding
*          work array, and no error message is issued by PXERBLA.
*
*  RWORK   (local workspace/local output) REAL array,
*                                                 dimension (LRWORK)
*          On exit, RWORK(1) returns the minimal and optimal LRWORK.
*
*  LRWORK  (local or global input) INTEGER
*          The dimension of the array RWORK.
*          LRWORK is local input and must be at least
*          LRWORK >= LOCc(JA+N-1)+Nq0.
*
*          IROFF = MOD( IA-1, MB_A ), ICOFF = MOD( JA-1, NB_A ),
*          IAROW = INDXG2P( IA, MB_A, MYROW, RSRC_A, NPROW ),
*          IACOL = INDXG2P( JA, NB_A, MYCOL, CSRC_A, NPCOL ),
*          Mp0   = NUMROC( M+IROFF, MB_A, MYROW, IAROW, NPROW ),
*          Nq0   = NUMROC( N+ICOFF, NB_A, MYCOL, IACOL, NPCOL ),
*          LOCc(JA+N-1) = NUMROC( JA+N-1, NB_A, MYCOL, CSRC_A, NPCOL )
*
*          and NUMROC, INDXG2P are ScaLAPACK tool functions;
*          MYROW, MYCOL, NPROW and NPCOL can be determined by calling
*          the subroutine BLACS_GRIDINFO.
*
*          If LRWORK = -1, then LRWORK is global input and a workspace
*          query is assumed; the routine only calculates the minimum
*          and optimal size for all work arrays. Each of these
*          values is returned in the first entry of the corresponding
*          work array, and no error message is issued by PXERBLA.
*
*
*  INFO    (global output) INTEGER
*          = 0:  successful exit
*          < 0:  If the i-th argument is an array and the j-entry had
*                an illegal value, then INFO = -(i*100+j), if the i-th
*                argument is a scalar and had an illegal value, then
*                INFO = -i.
*
*  Further Details
*  ===============
*
*  The matrix Q is represented as a product of elementary reflectors
*
*     Q = H(1) H(2) . . . H(n)
*
*  Each H(i) has the form
*
*     H = I - tau * v * v'
*
*  where tau is a complex scalar, and v is a complex vector with
*  v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in
*  A(ia+i-1:ia+m-1,ja+i-1).
*
*  The matrix P is represented in jpvt as follows: If
*     jpvt(j) = i
*  then the jth column of P is the ith canonical unit vector.
*
*  References
*  ==========
*  
*  For modifications introduced in Scalapack 2.1
*  LAWN 295 
*  New robust ScaLAPACK routine for computing the QR factorization with column pivoting
*  Zvonimir Bujanovic, Zlatko Drmac
*  http://www.netlib.org/lapack/lawnspdf/lawn295.pdf
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            BLOCK_CYCLIC_2D, CSRC_, CTXT_, DLEN_, DTYPE_,
     $                   LLD_, MB_, M_, NB_, N_, RSRC_
      parameter( block_cyclic_2d = 1, dlen_ = 9, dtype_ = 1,
     $                     ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
     $                     rsrc_ = 7, csrc_ = 8, lld_ = 9 )
      REAL               ONE, ZERO
      parameter( one = 1.0e+0, zero = 0.0e+0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            LQUERY
      INTEGER            I, IACOL, IAROW, ICOFF, ICTXT, ICURROW,
     $                   ICURCOL, II, IIA, IOFFA, IPCOL, IROFF, ITEMP,
     $                   J, JB, JJ, JJA, JJPVT, JN, KB, K, KK, KSTART,
     $                   KSTEP, LDA, LL, LRWMIN, LWMIN, MN, MP, MYCOL,
     $                   MYROW, NPCOL, NPROW, NQ, NQ0, PVT
      REAL               TEMP, TEMP2, TOL3Z
      COMPLEX            AJJ, ALPHA
*     ..
*     .. Local Arrays ..
      INTEGER            DESCN( DLEN_ ), IDUM1( 2 ), IDUM2( 2 )
*     ..
*     .. External Subroutines ..
      EXTERNAL           blacs_gridinfo, ccopy, cgebr2d, cgebs2d,
     $                   cgerv2d, cgesd2d, chk1mat, clarfg,
     $                   cswap, descset, igerv2d, igesd2d, infog1l,
     $                   infog2l, pcelset, pchk1mat, pclarfc,
     $                   pclarfg, psamax, pscnrm2, pxerbla
*     ..
*     .. External Functions ..
      INTEGER            ICEIL, INDXG2P, NUMROC
      EXTERNAL           iceil, indxg2p, numroc
      REAL               SLAMCH
      EXTERNAL           slamch
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, cmplx, conjg, ifix, max, min, mod, sqrt
*     ..
*     .. Executable Statements ..
*
*     Get grid parameters
*
      ictxt = desca( ctxt_ )
      CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
*
*     Test the input parameters
*
      info = 0
      IF( nprow.EQ.-1 ) THEN
         info = -(600+ctxt_)
      ELSE
         CALL chk1mat( m, 1, n, 2, ia, ja, desca, 6, info )
         IF( info.EQ.0 ) THEN
            iroff = mod( ia-1, desca( mb_ ) )
            icoff = mod( ja-1, desca( nb_ ) )
            iarow = indxg2p( ia, desca( mb_ ), myrow, desca( rsrc_ ),
     $                       nprow )
            iacol = indxg2p( ja, desca( nb_ ), mycol, desca( csrc_ ),
     $                       npcol )
            mp = numroc( m+iroff, desca( mb_ ), myrow, iarow, nprow )
            nq = numroc( n+icoff, desca( nb_ ), mycol, iacol, npcol )
            nq0 = numroc( ja+n-1, desca( nb_ ), mycol, desca( csrc_ ),
     $                    npcol )
            lwmin = max( 3, mp + nq )
            lrwmin = nq0 + nq
*
            work( 1 ) = cmplx( real( lwmin ) )
            rwork( 1 ) = real( lrwmin )
            lquery = ( lwork.EQ.-1 .OR. lrwork.EQ.-1 )
            IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
               info = -10
            ELSE IF( lrwork.LT.lrwmin .AND. .NOT.lquery ) THEN
               info = -12
            END IF
         END IF
         IF( lwork.EQ.-1 ) THEN
            idum1( 1 ) = -1
         ELSE
            idum1( 1 ) = 1
         END IF
         idum2( 1 ) = 10
         IF( lrwork.EQ.-1 ) THEN
            idum1( 2 ) = -1
         ELSE
            idum1( 2 ) = 1
         END IF
         idum2( 2 ) = 12
         CALL pchk1mat( m, 1, n, 2, ia, ja, desca, 6, 2, idum1, idum2,
     $                  info )
      END IF
*
      IF( info.NE.0 ) THEN
         CALL pxerbla( ictxt, 'PCGEQPF', -info )
         RETURN
      ELSE IF( lquery ) THEN
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( m.EQ.0 .OR. n.EQ.0 )
     $   RETURN
*
      CALL infog2l( ia, ja, desca, nprow, npcol, myrow, mycol, iia, jja,
     $              iarow, iacol )
      IF( myrow.EQ.iarow )
     $   mp = mp - iroff
      IF( mycol.EQ.iacol )
     $   nq = nq - icoff
      mn = min( m, n )
      tol3z = sqrt( slamch('Epsilon') )
*
*     Initialize the array of pivots
*
      lda = desca( lld_ )
      jn = min( iceil( ja, desca( nb_ ) ) * desca( nb_ ), ja+n-1 )
      kstep  = npcol * desca( nb_ )
*
      IF( mycol.EQ.iacol ) THEN
*
*        Handle first block separately
*
         jb = jn - ja + 1
         DO 10 ll = jja, jja+jb-1
            ipiv( ll ) = ja + ll - jja
   10    CONTINUE
         kstart = jn + kstep - desca( nb_ )
*
*        Loop over remaining block of columns
*
         DO 30 kk = jja+jb, jja+nq-1, desca( nb_ )
            kb = min( jja+nq-kk, desca( nb_ ) )
            DO 20 ll = kk, kk+kb-1
               ipiv( ll ) = kstart+ll-kk+1
   20       CONTINUE
            kstart = kstart + kstep
   30    CONTINUE
      ELSE
         kstart = jn + ( mod( mycol-iacol+npcol, npcol )-1 )*
     $                        desca( nb_ )
         DO 50 kk = jja, jja+nq-1, desca( nb_ )
            kb = min( jja+nq-kk, desca( nb_ ) )
            DO 40 ll = kk, kk+kb-1
               ipiv( ll ) = kstart+ll-kk+1
   40       CONTINUE
            kstart = kstart + kstep
   50    CONTINUE
      END IF
*
*     Initialize partial column norms, handle first block separately
*
      CALL descset( descn, 1, desca( n_ ), 1, desca( nb_ ), myrow,
     $              desca( csrc_ ), ictxt, 1 )
*
      jj = jja
      IF( mycol.EQ.iacol ) THEN
         DO 60 kk = 0, jb-1
            CALL pscnrm2( m, rwork( jj+kk ), a, ia, ja+kk, desca, 1 )
            rwork( nq+jj+kk ) = rwork( jj+kk )
   60    CONTINUE
         jj = jj + jb
      END IF
      icurcol = mod( iacol+1, npcol )
*
*     Loop over the remaining blocks of columns
*
      DO 80 j = jn+1, ja+n-1, desca( nb_ )
         jb = min( ja+n-j, desca( nb_ ) )
*
         IF( mycol.EQ.icurcol ) THEN
            DO 70 kk = 0, jb-1
               CALL pscnrm2( m, rwork( jj+kk ), a, ia, j+kk, desca, 1 )
               rwork( nq+jj+kk ) = rwork( jj+kk )
   70       CONTINUE
            jj = jj + jb
         END IF
         icurcol = mod( icurcol+1, npcol )
   80 CONTINUE
*
*     Compute factorization
*
      DO 120 j = ja, ja+mn-1
         i = ia + j - ja
*
         CALL infog1l( j, desca( nb_ ), npcol, mycol, desca( csrc_ ),
     $                 jj, icurcol )
         k = ja + n - j
         IF( k.GT.1 ) THEN
            CALL psamax( k, temp, pvt, rwork, 1, j, descn,
     $                   descn( m_ ) )
         ELSE
            pvt = j
         END IF
         IF( j.NE.pvt ) THEN
            CALL infog1l( pvt, desca( nb_ ), npcol, mycol,
     $                    desca( csrc_ ), jjpvt, ipcol )
            IF( icurcol.EQ.ipcol ) THEN
               IF( mycol.EQ.icurcol ) THEN
                  CALL cswap( mp, a( iia+(jj-1)*lda ), 1,
     $                        a( iia+(jjpvt-1)*lda ), 1 )
                  itemp = ipiv( jjpvt )
                  ipiv( jjpvt ) = ipiv( jj )
                  ipiv( jj ) = itemp
                  rwork( jjpvt ) = rwork( jj )
                  rwork( nq+jjpvt ) = rwork( nq+jj )
               END IF
            ELSE
               IF( mycol.EQ.icurcol ) THEN
*
                  CALL cgesd2d( ictxt, mp, 1, a( iia+(jj-1)*lda ), lda,
     $                          myrow, ipcol )
                  work( 1 ) = cmplx( real( ipiv( jj ) ) )
                  work( 2 ) = cmplx( rwork( jj ) )
                  work( 3 ) = cmplx( rwork( jj + nq ) )
                  CALL cgesd2d( ictxt, 3, 1, work, 3, myrow, ipcol )
*
                  CALL cgerv2d( ictxt, mp, 1, a( iia+(jj-1)*lda ), lda,
     $                          myrow, ipcol )
                  CALL igerv2d( ictxt, 1, 1, ipiv( jj ), 1, myrow,
     $                          ipcol )
*
               ELSE IF( mycol.EQ.ipcol ) THEN
*
                  CALL cgesd2d( ictxt, mp, 1, a( iia+(jjpvt-1)*lda ),
     $                          lda, myrow, icurcol )
                  CALL igesd2d( ictxt, 1, 1, ipiv( jjpvt ), 1, myrow,
     $                          icurcol )
*
                  CALL cgerv2d( ictxt, mp, 1, a( iia+(jjpvt-1)*lda ),
     $                          lda, myrow, icurcol )
                  CALL cgerv2d( ictxt, 3, 1, work, 3, myrow, icurcol )
                  ipiv( jjpvt ) = ifix( real( work( 1 ) ) )
                  rwork( jjpvt ) = real( work( 2 ) )
                  rwork( jjpvt+nq ) = real( work( 3 ) )
*
               END IF
*
            END IF
*
         END IF
*
*        Generate elementary reflector H(i)
*
         CALL infog1l( i, desca( mb_ ), nprow, myrow, desca( rsrc_ ),
     $                 ii, icurrow )
         IF( desca( m_ ).EQ.1 ) THEN
            IF( myrow.EQ.icurrow ) THEN
               IF( mycol.EQ.icurcol ) THEN
                  ioffa = ii+(jj-1)*desca( lld_ )
                  ajj = a( ioffa )
                  CALL clarfg( 1, ajj, a( ioffa ), 1, tau( jj ) )
                  IF( n.GT.1 ) THEN
                     alpha = cmplx( one ) - conjg( tau( jj ) )
                     CALL cgebs2d( ictxt, 'Rowwise', ' ', 1, 1, alpha,
     $                                  1 )
                     CALL cscal( nq-jj, alpha, a( ioffa+desca( lld_ ) ),
     $                           desca( lld_ ) )
                  END IF
                  CALL cgebs2d( ictxt, 'Columnwise', ' ', 1, 1,
     $                          tau( jj ), 1 )
                  a( ioffa ) = ajj
               ELSE
                  IF( n.GT.1 ) THEN
                     CALL cgebr2d( ictxt, 'Rowwise', ' ', 1, 1, alpha,
     $                             1, icurrow, icurcol )
                     CALL cscal( nq-jj+1, alpha, a( i ), desca( lld_ ) )
                  END IF
               END IF
            ELSE IF( mycol.EQ.icurcol ) THEN
               CALL cgebr2d( ictxt, 'Columnwise', ' ', 1, 1, tau( jj ),
     $                       1, icurrow, icurcol )
            END IF
*
         ELSE
*
            CALL pclarfg( m-j+ja, ajj, i, j, a, min( i+1, ia+m-1 ), j,
     $                    desca, 1, tau )
            IF( j.LT.ja+n-1 ) THEN
*
*              Apply H(i) to A(ia+j-ja:ia+m-1,j+1:ja+n-1) from the left
*
               CALL pcelset( a, i, j, desca, cmplx( one ) )
               CALL pclarfc( 'Left', m-j+ja, ja+n-1-j, a, i, j, desca,
     $                       1, tau, a, i, j+1, desca, work )
            END IF
            CALL pcelset( a, i, j, desca, ajj )
*
         END IF
*
*        Update partial columns norms
*
         IF( mycol.EQ.icurcol )
     $      jj = jj + 1
         IF( mod( j, desca( nb_ ) ).EQ.0 )
     $      icurcol = mod( icurcol+1, npcol )
         IF( (jja+nq-jj).GT.0 ) THEN
            IF( myrow.EQ.icurrow ) THEN
               CALL cgebs2d( ictxt, 'Columnwise', ' ', 1, jja+nq-jj,
     $                       a( ii+( min( jja+nq-1, jj )-1 )*lda ),
     $                       lda )
               CALL ccopy( jja+nq-jj, a( ii+( min( jja+nq-1, jj )
     $                     -1)*lda ), lda, work( min( jja+nq-1, jj ) ),
     $                     1 )
            ELSE
               CALL cgebr2d( ictxt, 'Columnwise', ' ', jja+nq-jj, 1,
     $                       work( min( jja+nq-1, jj ) ), max( 1, nq ),
     $                       icurrow, mycol )
            END IF
         END IF
*
         jn = min( iceil( j+1, desca( nb_ ) ) * desca( nb_ ),
     $                    ja + n - 1 )
         IF( mycol.EQ.icurcol ) THEN
            DO 90 ll = jj, jj + jn - j - 1
               IF( rwork( ll ).NE.zero ) THEN
                  temp = abs( work( ll ) ) / rwork( ll )
                  temp = max( zero, ( one+temp )*( one-temp ) )
                  temp2 = temp * ( rwork( ll ) / rwork( nq+ll ) )**2
                  IF( temp2.LE.tol3z ) THEN
                     IF( ia+m-1.GT.i ) THEN
                        CALL pscnrm2( ia+m-i-1, rwork( ll ), a,
     $                                i+1, j+ll-jj+1, desca, 1 )
                        rwork( nq+ll ) = rwork( ll )
                     ELSE
                        rwork( ll ) = zero
                        rwork( nq+ll ) = zero
                     END IF
                  ELSE
                     rwork( ll ) = rwork( ll ) * sqrt( temp )
                  END IF
               END IF
   90       CONTINUE
            jj = jj + jn - j
         END IF
         icurcol = mod( icurcol+1, npcol )
*
         DO 110 k = jn+1, ja+n-1, desca( nb_ )
            kb = min( ja+n-k, desca( nb_ ) )
*
            IF( mycol.EQ.icurcol ) THEN
               DO 100 ll = jj, jj+kb-1
                  IF( rwork(ll).NE.zero ) THEN
                     temp = abs( work( ll ) ) / rwork( ll )
                     temp = max( zero, ( one+temp )*( one-temp ) )
                     temp2 = temp * ( rwork( ll ) / rwork( nq+ll ) )**2
                     IF( temp2.LE.tol3z ) THEN
                        IF( ia+m-1.GT.i ) THEN
                           CALL pscnrm2( ia+m-i-1, rwork( ll ), a,
     $                                   i+1, k+ll-jj, desca, 1 )
                           rwork( nq+ll ) = rwork( ll )
                        ELSE
                           rwork( ll ) = zero
                           rwork( nq+ll ) = zero
                        END IF
                     ELSE
                        rwork( ll ) = rwork( ll ) * sqrt( temp )
                     END IF
                  END IF
  100          CONTINUE
               jj = jj + kb
            END IF
            icurcol = mod( icurcol+1, npcol )
*
  110    CONTINUE
*
  120 CONTINUE
*
      work( 1 ) = cmplx( real( lwmin ) )
      rwork( 1 ) = real( lrwmin )
*
      RETURN
*
*     End of PCGEQPF
*

Here is the call graph for this function:

Here is the caller graph for this function: