SCALAPACK 2.2.2
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ runtests()

subroutine runtests ( integer, dimension(memlen)  mem,
integer  memlen,
character*1, dimension(cmemlen)  cmem,
integer  cmemlen,
character*1, dimension(nprec)  prec,
integer  nprec,
integer  outnum,
integer  verb,
logical  testsdrv,
logical  testbsbr,
logical  testcomb,
logical  testaux 
)

Definition at line 178 of file blacstest.f.

181*
182* .. Scalar Arguments ..
183 INTEGER MEMLEN, CMEMLEN, NPREC, OUTNUM, VERB, IAM, NNODES
184 LOGICAL TESTSDRV, TESTBSBR, TESTCOMB, TESTAUX
185* ..
186* .. Array Arguments ..
187 CHARACTER*1 CMEM(CMEMLEN), PREC(NPREC)
188 INTEGER MEM(MEMLEN)
189* ..
190* .. External Functions ..
191 INTEGER IBTNPROCS, IBTMYPROC, IBTMSGID, IBTSIZEOF, SAFEINDEX
192 EXTERNAL ibtnprocs, ibtmyproc, ibtmsgid, ibtsizeof, safeindex
193* ..
194* .. External Subroutines ..
195 EXTERNAL csdrvtest, dsdrvtest, isdrvtest, ssdrvtest, zsdrvtest
196 EXTERNAL cbsbrtest, dbsbrtest, ibsbrtest, sbsbrtest, zbsbrtest
197 EXTERNAL isumtest, ssumtest, dsumtest, csumtest, zsumtest
198 EXTERNAL iamxtest, samxtest, damxtest, camxtest, zamxtest
199 EXTERNAL iamntest, samntest, damntest, camntest, zamntest
200 EXTERNAL auxtest, btsend, btrecv, btinfo
201* ..
202* .. Local Scalars ..
203 INTEGER NSCOPE, NOP, NTOP, NSHAPE, NMAT, NSRC, NDEST, NGRID
204 INTEGER TREP, TCOH, OPPTR, SCOPEPTR, TOPPTR, UPLOPTR, DIAGPTR
205 INTEGER MPTR, NPTR, LDSPTR, LDDPTR, LDIPTR
206 INTEGER RSRCPTR, CSRCPTR, RDESTPTR, CDESTPTR, PPTR, QPTR
207 INTEGER ISEEDPTR, RAPTR, CAPTR, CTXTPTR, WORKPTR, WORKLEN
208 INTEGER MEMUSED, CMEMUSED, I, J, K
209 INTEGER ISIZE, SSIZE, DSIZE, CSIZE, ZSIZE
210* ..
211* .. Local Arrays ..
212 INTEGER ITMP(4)
213* ..
214* .. Executable Statements ..
215*
216 iam = ibtmyproc()
217 nnodes = ibtnprocs()
218 isize = ibtsizeof('I')
219 ssize = ibtsizeof('S')
220 dsize = ibtsizeof('D')
221 csize = ibtsizeof('C')
222 zsize = ibtsizeof('Z')
223*
224 IF( iam.EQ.0 ) THEN
225 CALL blacs_get( 0, 2, i )
226 WRITE(outnum,3000)
227 WRITE(outnum,3000)
228 WRITE(outnum,2000) i
229 WRITE(outnum,3000)
230 WRITE(outnum,3000)
231 END IF
232*
233 IF( testaux ) THEN
234*
235* Each process will make sure that BLACS_PINFO returns
236* the same value as BLACS_SETUP, and send a packet
237* to node 0 saying whether it was.
238*
239 CALL blacs_pinfo( itmp(1), itmp(3) )
240 CALL blacs_setup( itmp(2), itmp(4) )
241 IF( iam .EQ. 0 ) THEN
242 DO 35 i = 0, nnodes-1
243 IF( i .NE. 0 )
244 $ CALL btrecv( 3, 4, itmp, i, ibtmsgid()+2 )
245 IF( itmp(1) .NE. itmp(2) )
246 $ WRITE( outnum, 1000 ) itmp(1), itmp(2)
247 IF( (itmp(3).NE.itmp(4)) .OR. (itmp(3).NE.nnodes) )
248 $ WRITE( outnum, 1000 ) itmp(3), itmp(4), nnodes
249 35 CONTINUE
250 ELSE
251 CALL btsend( 3, 4, itmp, 0, ibtmsgid()+2 )
252 ENDIF
253 ENDIF
254*
255* Run point-to-point tests as appropriate
256*
257 IF( testsdrv ) THEN
258*
259* Get test info
260*
261 CALL btinfo( 'SDRV', memused, mem, memlen, cmemused, cmem,
262 $ cmemlen, outnum, nop, nscope, trep, tcoh, ntop,
263 $ nshape, nmat, nsrc, ngrid, opptr, scopeptr,
264 $ topptr, uploptr, diagptr, mptr, nptr, ldsptr,
265 $ lddptr, ldiptr, rsrcptr, csrcptr, rdestptr,
266 $ cdestptr, pptr, qptr )
267*
268* iseedptr used as tests passed/failed array, so it must
269* be of size NTESTS -- It's not used unless VERB < 2
270*
271 ctxtptr = memused + 1
272 iseedptr = ctxtptr + ngrid
273 memused = iseedptr - 1
274 IF( verb .LT. 2 )
275 $ memused = memused + nshape * nmat * nsrc * ngrid
276*
277 CALL makegrids( mem(ctxtptr), outnum, ngrid, mem(pptr),
278 $ mem(qptr) )
279*
280* Call individual tests as appropriate.
281*
282 DO 10 i = 1, nprec
283 IF( prec(i) .EQ. 'I' ) THEN
284*
285 workptr = safeindex(memused + 1, isize, isize)
286 worklen = ( dsize * (memlen - workptr + 1) ) / isize
287 CALL isdrvtest(outnum, verb, nshape, cmem(uploptr),
288 $ cmem(diagptr), nmat, mem(mptr),
289 $ mem(nptr), mem(ldsptr), mem(lddptr),
290 $ nsrc, mem(rsrcptr), mem(csrcptr),
291 $ mem(rdestptr), mem(cdestptr),
292 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
293 $ mem(iseedptr), mem(workptr), worklen)
294*
295 ELSE IF( prec(i) .EQ. 'S' ) THEN
296*
297 workptr = safeindex(memused + 1, isize, ssize)
298 worklen = ( dsize * (memlen - workptr + 1) ) / ssize
299 CALL ssdrvtest(outnum, verb, nshape, cmem(uploptr),
300 $ cmem(diagptr), nmat, mem(mptr),
301 $ mem(nptr), mem(ldsptr), mem(lddptr),
302 $ nsrc, mem(rsrcptr), mem(csrcptr),
303 $ mem(rdestptr), mem(cdestptr),
304 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
305 $ mem(iseedptr), mem(workptr), worklen)
306*
307 ELSE IF( prec(i) .EQ. 'D' ) THEN
308*
309 workptr = safeindex(memused + 1, isize, dsize)
310 worklen = ( dsize * (memlen - workptr + 1) ) / dsize
311 CALL dsdrvtest(outnum, verb, nshape, cmem(uploptr),
312 $ cmem(diagptr), nmat, mem(mptr),
313 $ mem(nptr), mem(ldsptr), mem(lddptr),
314 $ nsrc, mem(rsrcptr), mem(csrcptr),
315 $ mem(rdestptr), mem(cdestptr),
316 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
317 $ mem(iseedptr), mem(workptr), worklen)
318*
319 ELSE IF( prec(i) .EQ. 'C' ) THEN
320*
321 workptr = safeindex(memused + 1, isize, csize)
322 worklen = ( dsize * (memlen - workptr + 1) ) / csize
323 CALL csdrvtest(outnum, verb, nshape, cmem(uploptr),
324 $ cmem(diagptr), nmat, mem(mptr),
325 $ mem(nptr), mem(ldsptr), mem(lddptr),
326 $ nsrc, mem(rsrcptr), mem(csrcptr),
327 $ mem(rdestptr), mem(cdestptr),
328 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
329 $ mem(iseedptr), mem(workptr), worklen)
330*
331 ELSE IF( prec(i) .EQ. 'Z' ) THEN
332*
333 workptr = safeindex(memused + 1, isize, zsize)
334 worklen = ( dsize * (memlen - workptr + 1) ) / zsize
335 CALL zsdrvtest(outnum, verb, nshape, cmem(uploptr),
336 $ cmem(diagptr), nmat, mem(mptr),
337 $ mem(nptr), mem(ldsptr), mem(lddptr),
338 $ nsrc, mem(rsrcptr), mem(csrcptr),
339 $ mem(rdestptr), mem(cdestptr),
340 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
341 $ mem(iseedptr), mem(workptr), worklen)
342 END IF
343 10 CONTINUE
344 CALL freegrids( ngrid, mem(ctxtptr) )
345 END IF
346*
347 IF( testbsbr ) THEN
348*
349* Get test info
350*
351 CALL btinfo( 'BSBR', memused, mem, memlen, cmemused, cmem,
352 $ cmemlen, outnum, nop, nscope, trep, tcoh, ntop,
353 $ nshape, nmat, nsrc, ngrid, opptr, scopeptr,
354 $ topptr, uploptr, diagptr, mptr, nptr, ldsptr,
355 $ lddptr, ldiptr, rsrcptr, csrcptr, rdestptr,
356 $ cdestptr, pptr, qptr )
357*
358* iseedptr used as tests passed/failed array, so it must
359* be of size NTESTS -- It's not used unless VERB < 2
360*
361 ctxtptr = memused + 1
362 iseedptr = ctxtptr + ngrid
363 memused = iseedptr - 1
364 IF( verb .LT. 2 )
365 $ memused = memused + nscope*ntop*nshape*nmat*nsrc*ngrid
366*
367 CALL makegrids( mem(ctxtptr), outnum, ngrid, mem(pptr),
368 $ mem(qptr) )
369*
370* Call individual tests as appropriate.
371*
372 DO 20 i = 1, nprec
373 IF( prec(i) .EQ. 'I' ) THEN
374*
375 workptr = safeindex(memused + 1, isize, isize)
376 worklen = ( dsize * (memlen - workptr + 1) ) / isize
377 CALL ibsbrtest(outnum, verb, nscope, cmem(scopeptr),
378 $ ntop, cmem(topptr), nshape, cmem(uploptr),
379 $ cmem(diagptr), nmat, mem(mptr),
380 $ mem(nptr), mem(ldsptr), mem(lddptr),
381 $ nsrc, mem(rsrcptr), mem(csrcptr),
382 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
383 $ mem(iseedptr), mem(workptr), worklen)
384*
385 ELSE IF( prec(i) .EQ. 'S' ) THEN
386*
387 workptr = safeindex(memused + 1, isize, ssize)
388 worklen = ( dsize * (memlen - workptr + 1) ) / ssize
389 CALL sbsbrtest(outnum, verb, nscope, cmem(scopeptr),
390 $ ntop, cmem(topptr), nshape, cmem(uploptr),
391 $ cmem(diagptr), nmat, mem(mptr),
392 $ mem(nptr), mem(ldsptr), mem(lddptr),
393 $ nsrc, mem(rsrcptr), mem(csrcptr),
394 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
395 $ mem(iseedptr), mem(workptr), worklen)
396*
397 ELSE IF( prec(i) .EQ. 'D' ) THEN
398*
399 workptr = safeindex(memused + 1, isize, dsize)
400 worklen = ( dsize * (memlen - workptr + 1) ) / dsize
401 CALL dbsbrtest(outnum, verb, nscope, cmem(scopeptr),
402 $ ntop, cmem(topptr), nshape, cmem(uploptr),
403 $ cmem(diagptr), nmat, mem(mptr),
404 $ mem(nptr), mem(ldsptr), mem(lddptr),
405 $ nsrc, mem(rsrcptr), mem(csrcptr),
406 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
407 $ mem(iseedptr), mem(workptr), worklen)
408*
409 ELSE IF( prec(i) .EQ. 'C' ) THEN
410*
411 workptr = safeindex(memused + 1, isize, csize)
412 worklen = ( dsize * (memlen - workptr + 1) ) / csize
413 CALL cbsbrtest(outnum, verb, nscope, cmem(scopeptr),
414 $ ntop, cmem(topptr), nshape, cmem(uploptr),
415 $ cmem(diagptr), nmat, mem(mptr),
416 $ mem(nptr), mem(ldsptr), mem(lddptr),
417 $ nsrc, mem(rsrcptr), mem(csrcptr),
418 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
419 $ mem(iseedptr), mem(workptr), worklen)
420*
421 ELSE IF( prec(i) .EQ. 'Z' ) THEN
422*
423 workptr = safeindex(memused + 1, isize, zsize)
424 worklen = ( dsize * (memlen - workptr + 1) ) / zsize
425 CALL zbsbrtest(outnum, verb, nscope, cmem(scopeptr),
426 $ ntop, cmem(topptr), nshape, cmem(uploptr),
427 $ cmem(diagptr), nmat, mem(mptr),
428 $ mem(nptr), mem(ldsptr), mem(lddptr),
429 $ nsrc, mem(rsrcptr), mem(csrcptr),
430 $ ngrid, mem(ctxtptr), mem(pptr), mem(qptr),
431 $ mem(iseedptr), mem(workptr), worklen)
432*
433 END IF
434*
435 20 CONTINUE
436 CALL freegrids( ngrid, mem(ctxtptr) )
437 END IF
438 IF( testcomb ) THEN
439*
440* Get test info
441*
442 CALL btinfo( 'COMB', memused, mem, memlen, cmemused, cmem,
443 $ cmemlen, outnum, nop, nscope, trep, tcoh, ntop,
444 $ nshape, nmat, ndest, ngrid, opptr, scopeptr,
445 $ topptr, uploptr, diagptr, mptr, nptr, ldsptr,
446 $ lddptr, ldiptr, rsrcptr, csrcptr, rdestptr,
447 $ cdestptr, pptr, qptr )
448 ctxtptr = memused + 1
449 memused = ctxtptr + ngrid - 1
450*
451* Find space required by RA and CA arrays
452*
453 k = 0
454 DO 40 j = 0, nop-1
455 IF( cmem(opptr+j).EQ.'>' .OR. cmem(opptr+j).EQ.'<' ) THEN
456 DO 30 i = 0, nmat
457*
458* NOTE: here we assume ipre+ipost = 4*M
459*
460 k = max0( k, 4*mem(mptr+i) )
461 IF ( mem(ldiptr+i) .NE. -1 )
462 $ k = max0( k, mem(nptr+i)*mem(ldiptr+i) +
463 $ 4*mem(mptr+i) )
464 30 CONTINUE
465 END IF
466 40 CONTINUE
467 raptr = memused + 1
468 captr = raptr + k
469*
470* iseed array also used as tests passed/failed array, so it must
471* be of size MAX( 4*NNODES, NTESTS )
472*
473 iseedptr = captr + k
474 i = 0
475 IF( verb.LT.2 ) i = nscope * ntop * nmat * ndest * ngrid
476 memused = iseedptr + max( 4*nnodes, i )
477*
478 CALL makegrids( mem(ctxtptr), outnum, ngrid, mem(pptr),
479 $ mem(qptr) )
480*
481* Call individual tests as appropriate.
482*
483 DO 60 i = 1, nprec
484 DO 50 j = 0, nop-1
485 IF( prec(i) .EQ. 'I' ) THEN
486 workptr = safeindex(memused, isize, isize)
487 worklen = ( dsize * (memlen - workptr + 1) ) / isize
488 IF( cmem(opptr+j) .EQ. '+' ) THEN
489 CALL isumtest(outnum, verb, trep, tcoh, nscope,
490 $ cmem(scopeptr), ntop, cmem(topptr),
491 $ nmat, mem(mptr), mem(nptr),
492 $ mem(ldsptr), mem(lddptr), ndest,
493 $ mem(rdestptr), mem(cdestptr), ngrid,
494 $ mem(ctxtptr), mem(pptr), mem(qptr),
495 $ mem(iseedptr), mem(workptr),
496 $ worklen)
497 ELSE IF( cmem(opptr+j) .EQ. '>' ) THEN
498 CALL iamxtest(outnum, verb, trep, tcoh, nscope,
499 $ cmem(scopeptr), ntop, cmem(topptr),
500 $ nmat, mem(mptr), mem(nptr),
501 $ mem(ldsptr), mem(lddptr),
502 $ mem(ldiptr), ndest, mem(rdestptr),
503 $ mem(cdestptr), ngrid, mem(ctxtptr),
504 $ mem(pptr), mem(qptr), mem(iseedptr),
505 $ mem(raptr), mem(captr), k,
506 $ mem(workptr), worklen)
507 ELSE IF( cmem(opptr+j) .EQ. '<' ) THEN
508 CALL iamntest(outnum, verb, trep, tcoh, nscope,
509 $ cmem(scopeptr), ntop, cmem(topptr),
510 $ nmat, mem(mptr), mem(nptr),
511 $ mem(ldsptr), mem(lddptr),
512 $ mem(ldiptr), ndest, mem(rdestptr),
513 $ mem(cdestptr), ngrid, mem(ctxtptr),
514 $ mem(pptr), mem(qptr), mem(iseedptr),
515 $ mem(raptr), mem(captr), k,
516 $ mem(workptr), worklen)
517 END IF
518 ELSE IF( prec(i) .EQ. 'S' ) THEN
519 workptr = safeindex(memused, isize, ssize)
520 worklen = ( dsize * (memlen - workptr + 1) ) / ssize
521 IF( cmem(opptr+j) .EQ. '+' ) THEN
522 CALL ssumtest(outnum, verb, trep, tcoh, nscope,
523 $ cmem(scopeptr), ntop, cmem(topptr),
524 $ nmat, mem(mptr), mem(nptr),
525 $ mem(ldsptr), mem(lddptr), ndest,
526 $ mem(rdestptr), mem(cdestptr), ngrid,
527 $ mem(ctxtptr), mem(pptr), mem(qptr),
528 $ mem(iseedptr), mem(workptr),
529 $ worklen)
530 ELSE IF( cmem(opptr+j) .EQ. '>' ) THEN
531 CALL samxtest(outnum, verb, trep, tcoh, nscope,
532 $ cmem(scopeptr), ntop, cmem(topptr),
533 $ nmat, mem(mptr), mem(nptr),
534 $ mem(ldsptr), mem(lddptr),
535 $ mem(ldiptr), ndest, mem(rdestptr),
536 $ mem(cdestptr), ngrid, mem(ctxtptr),
537 $ mem(pptr), mem(qptr), mem(iseedptr),
538 $ mem(raptr), mem(captr), k,
539 $ mem(workptr), worklen)
540 ELSE IF( cmem(opptr+j) .EQ. '<' ) THEN
541 CALL samntest(outnum, verb, trep, tcoh, nscope,
542 $ cmem(scopeptr), ntop, cmem(topptr),
543 $ nmat, mem(mptr), mem(nptr),
544 $ mem(ldsptr), mem(lddptr),
545 $ mem(ldiptr), ndest, mem(rdestptr),
546 $ mem(cdestptr), ngrid, mem(ctxtptr),
547 $ mem(pptr), mem(qptr), mem(iseedptr),
548 $ mem(raptr), mem(captr), k,
549 $ mem(workptr), worklen)
550 END IF
551 ELSE IF( prec(i) .EQ. 'C' ) THEN
552 workptr = safeindex(memused, isize, csize)
553 worklen = ( dsize * (memlen - workptr + 1) ) / csize
554 IF( cmem(opptr+j) .EQ. '+' ) THEN
555 CALL csumtest(outnum, verb, trep, tcoh, nscope,
556 $ cmem(scopeptr), ntop, cmem(topptr),
557 $ nmat, mem(mptr), mem(nptr),
558 $ mem(ldsptr), mem(lddptr), ndest,
559 $ mem(rdestptr), mem(cdestptr), ngrid,
560 $ mem(ctxtptr), mem(pptr), mem(qptr),
561 $ mem(iseedptr), mem(workptr),
562 $ worklen)
563 ELSE IF( cmem(opptr+j) .EQ. '>' ) THEN
564 CALL camxtest(outnum, verb, trep, tcoh, nscope,
565 $ cmem(scopeptr), ntop, cmem(topptr),
566 $ nmat, mem(mptr), mem(nptr),
567 $ mem(ldsptr), mem(lddptr),
568 $ mem(ldiptr), ndest, mem(rdestptr),
569 $ mem(cdestptr), ngrid, mem(ctxtptr),
570 $ mem(pptr), mem(qptr), mem(iseedptr),
571 $ mem(raptr), mem(captr), k,
572 $ mem(workptr), worklen)
573 ELSE IF( cmem(opptr+j) .EQ. '<' ) THEN
574 CALL camntest(outnum, verb, trep, tcoh, nscope,
575 $ cmem(scopeptr), ntop, cmem(topptr),
576 $ nmat, mem(mptr), mem(nptr),
577 $ mem(ldsptr), mem(lddptr),
578 $ mem(ldiptr), ndest, mem(rdestptr),
579 $ mem(cdestptr), ngrid, mem(ctxtptr),
580 $ mem(pptr), mem(qptr), mem(iseedptr),
581 $ mem(raptr), mem(captr), k,
582 $ mem(workptr), worklen)
583 END IF
584 ELSE IF( prec(i) .EQ. 'Z' ) THEN
585 workptr = safeindex(memused, isize, zsize)
586 worklen = ( dsize * (memlen - workptr + 1) ) / zsize
587 IF( cmem(opptr+j) .EQ. '+' ) THEN
588 CALL zsumtest(outnum, verb, trep, tcoh, nscope,
589 $ cmem(scopeptr), ntop, cmem(topptr),
590 $ nmat, mem(mptr), mem(nptr),
591 $ mem(ldsptr), mem(lddptr), ndest,
592 $ mem(rdestptr), mem(cdestptr), ngrid,
593 $ mem(ctxtptr), mem(pptr), mem(qptr),
594 $ mem(iseedptr), mem(workptr),
595 $ worklen)
596 ELSE IF( cmem(opptr+j) .EQ. '>' ) THEN
597 CALL zamxtest(outnum, verb, trep, tcoh, nscope,
598 $ cmem(scopeptr), ntop, cmem(topptr),
599 $ nmat, mem(mptr), mem(nptr),
600 $ mem(ldsptr), mem(lddptr),
601 $ mem(ldiptr), ndest, mem(rdestptr),
602 $ mem(cdestptr), ngrid, mem(ctxtptr),
603 $ mem(pptr), mem(qptr), mem(iseedptr),
604 $ mem(raptr), mem(captr), k,
605 $ mem(workptr), worklen)
606 ELSE IF( cmem(opptr+j) .EQ. '<' ) THEN
607 CALL zamntest(outnum, verb, trep, tcoh, nscope,
608 $ cmem(scopeptr), ntop, cmem(topptr),
609 $ nmat, mem(mptr), mem(nptr),
610 $ mem(ldsptr), mem(lddptr),
611 $ mem(ldiptr), ndest, mem(rdestptr),
612 $ mem(cdestptr), ngrid, mem(ctxtptr),
613 $ mem(pptr), mem(qptr), mem(iseedptr),
614 $ mem(raptr), mem(captr), k,
615 $ mem(workptr), worklen)
616 END IF
617 END IF
618 50 CONTINUE
619 60 CONTINUE
620 CALL freegrids( ngrid, mem(ctxtptr) )
621 END IF
622*
623 IF( testaux ) THEN
624 CALL auxtest( outnum, mem, memlen )
625 END IF
626*
627 1000 FORMAT('AUXILIARY ERROR - IAM MISMATCH: BLACS_PINFO RETURNED',i4,
628 $ /,' BLACS_SETUP RETURNED',i4,'.')
629 1500 FORMAT('AUXILIARY ERROR - NPROC MISMATCH: BLACS_PINFO RETURNED',
630 $ i4,/,' BLACS_SETUP RETURNED',i4,', TESTER THINKS',i4,'.')
631 2000 FORMAT('BEGINNING BLACS TESTING, BLACS DEBUG LEVEL =',i2)
632 3000 FORMAT('==============================================')
633 RETURN
634*
635* End of RUNTESTS
636*
isdrvtest
subroutine isdrvtest(outnum, verb, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, rdest0, cdest0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:2205
ssdrvtest
subroutine ssdrvtest(outnum, verb, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, rdest0, cdest0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:2549
csumtest
subroutine csumtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, mem, memlen)
Definition blacstest.f:13287
zsumtest
subroutine zsumtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, mem, memlen)
Definition blacstest.f:13836
samxtest
subroutine samxtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:15235
dsumtest
subroutine dsumtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, mem, memlen)
Definition blacstest.f:12709
camntest
subroutine camntest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:20433
isumtest
subroutine isumtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, mem, memlen)
Definition blacstest.f:11607
iamxtest
subroutine iamxtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:14386
damntest
subroutine damntest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:19787
damxtest
subroutine damxtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:16050
zamxtest
subroutine zamxtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:17682
samntest
subroutine samntest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:19141
makegrids
subroutine makegrids(contexts, outnum, ngrids, p, q)
Definition blacstest.f:640
freegrids
subroutine freegrids(ngrids, contexts)
Definition blacstest.f:668
safeindex
integer function safeindex(indx, size1, size2)
Definition blacstest.f:1517
btinfo
subroutine btinfo(test, memused, mem, memlen, cmemused, cmem, cmemlen, outnum, nop, nscope, trep, tcoh, ntop, nshape, nmat, nsrc, ngrid, opptr, scopeptr, topptr, uploptr, diagptr, mptr, nptr, ldsptr, lddptr, ldiptr, rsrcptr, csrcptr, rdestptr, cdestptr, pptr, qptr)
Definition blacstest.f:1063
dbsbrtest
subroutine dbsbrtest(outnum, verb, nscope, scope0, ntop, top0, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:4755
ibsbrtest
subroutine ibsbrtest(outnum, verb, nscope, scope0, ntop, top0, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:3925
zamntest
subroutine zamntest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:21081
sbsbrtest
subroutine sbsbrtest(outnum, verb, nscope, scope0, ntop, top0, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:4340
camxtest
subroutine camxtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:16865
csdrvtest
subroutine csdrvtest(outnum, verb, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, rdest0, cdest0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:3237
auxtest
subroutine auxtest(outnum, mem, memlen)
Definition blacstest.f:681
zbsbrtest
subroutine zbsbrtest(outnum, verb, nscope, scope0, ntop, top0, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:5585
dsdrvtest
subroutine dsdrvtest(outnum, verb, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, rdest0, cdest0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:2893
iamntest
subroutine iamntest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ldi0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, rmem, cmem, rclen, mem, memlen)
Definition blacstest.f:18499
cbsbrtest
subroutine cbsbrtest(outnum, verb, nscope, scope0, ntop, top0, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:5170
zsdrvtest
subroutine zsdrvtest(outnum, verb, nshape, uplo0, diag0, nmat, m0, n0, ldas0, ldad0, nsrc, rsrc0, csrc0, rdest0, cdest0, ngrid, context0, p0, q0, tfail, mem, memlen)
Definition blacstest.f:3581
ibtmsgid
integer function ibtmsgid()
Definition blacstest.f:1361
ssumtest
subroutine ssumtest(outnum, verb, topsrepeat, topscohrnt, nscope, scope0, ntop, top0, nmat, m0, n0, ldas0, ldad0, ndest, rdest0, cdest0, ngrid, context0, p0, q0, iseed, mem, memlen)
Definition blacstest.f:12131
btrecv
subroutine btrecv(dtype, n, buff, src, msgid)
Definition btprim.f:207
ibtnprocs
integer function ibtnprocs()
Definition btprim.f:81
ibtmyproc
integer function ibtmyproc()
Definition btprim.f:47
btsend
subroutine btsend(dtype, n, buff, dest, msgid)
Definition btprim.f:115
ibtsizeof
integer function ibtsizeof(type)
Definition btprim.f:286
max
#define max(A, B)
Definition pcgemr.c:180
Here is the call graph for this function:
Here is the caller graph for this function: