void FATR PBEGINF_()
/*
Interface routine between FORTRAN and c version of pbegin.
Relies on knowing global address of program argument list ... see farg.h
*/
{
PBEGIN_(ARGC_, ARGV_);
}
int main(int argc, char **argv) {
int heap=300000, stack=300000;
int me, nprocs;
/* Step1: Initialize Message Passing library */
#ifdef MPI
MPI_Init(&argc, &argv); /* initialize MPI */
#else
PBEGIN_(argc, argv); /* initialize TCGMSG */
#endif
/* Step2: Initialize GA */
/* ### intialize the GA library */
GA_Initialize();
/* Step3: Initialize Memory Allocator (MA) */
if(! MA_init(C_DBL, stack, heap) ) GA_Error("MA_init failed",stack+heap);
/* ### assign the local processor ID to the int variable "me"
* ### and the total number of processors to the int variable
* ### "nprocs" */
me = GA_Nodeid();
nprocs = GA_Nnodes();
if(me==0) {
printf("\nUsing %d processes\n\n", nprocs); fflush(stdout);
}
TRANSPOSE1D();
if(me==0)printf("\nTerminating ..\n");
/* ### terminate the GA library */
GA_Terminate();
#ifdef MPI
MPI_Finalize();
#else
PEND_();
#endif
}
void FATR PBEGINF_()
/*
Hewlett Packard Risc box, SparcWorks F77 2.* and Paragon compilers.
Have to construct the argument list by calling FORTRAN.
*/
{
extern char *strdup();
#if defined(WIN32)
int argc = iargc_() + 1;
#elif defined(HPUX)
int argc = hpargc_();
#else
int argc = iargc_() + 1;
#endif
int i, len, maxlen=LEN;
char *argv[LEN], arg[LEN];
for (i=0; i<argc; i++) {
# if defined(HPUX)
len = hpargv_(&i, arg, &maxlen);
# elif defined(WIN32)
short n=(short)i, status;
getarg_(&n, arg, maxlen, &status);
if(status == -1)Error("getarg failed for argument",i);
len = status;
# else
getarg_(&i, arg, maxlen);
for(len = maxlen-2; len && (arg[len] == ' '); len--);
len++;
# endif
arg[len] = '\0'; /* insert string terminator */
/* printf("%10s, len=%d\n", arg, len); fflush(stdout); */
argv[i] = strdup(arg);
}
PBEGIN_(argc, argv);
}
int main(int argc, char **argv) {
int i, matrix_size;
int heap=20000000, stack=200000000;
double *A=NULL;
if(argc != 2)
{
printf("Usage Error\n\t Usage: <program> <matrix_size>\n");
exit(0);
}
matrix_size = atoi(argv[1]);
if(matrix_size <= 0)
{
printf("Error: matrix size (%d) should be > 0\n",
matrix_size);
GA_Error("matrix size should be >0", 1);
}
/* *****************************************************************
* Initialize MPI/TCGMSG-MPI, GA and MA
* *****************************************************************/
#ifdef MPI
#ifdef DCMF
int desired = MPI_THREAD_MULTIPLE;
int provided;
MPI_Init_thread(&argc, &argv, desired, &provided);
if ( provided != MPI_THREAD_MULTIPLE ) printf("provided != MPI_THREAD_MULTIPLE\n");
#else
MPI_Init (&argc, &argv); /* initialize MPI */
#endif
#else
PBEGIN_(argc, argv); /* initialize TCGMSG-MPI */
#endif
GA_Initialize(); /* initialize GA */
me = GA_Nodeid();
nprocs = GA_Nnodes();
heap /= nprocs;
stack /= nprocs;
if(! MA_init(MT_F_DBL, stack, heap)) /* initialize MA */
{
GA_Error("MA_init failed",stack+heap);
}
/* create/initialize the matrix */
if((A = (double*)malloc(matrix_size*matrix_size*sizeof(double))) == NULL)
{
GA_Error("malloc failed", matrix_size*matrix_size*sizeof(double));
}
for(i=0; i<2; i++) /* 5 runs */
{
init_array(A, matrix_size);
#if DEBUG
if(me==0) print_array(A, matrix_size);
#endif
/* *****************************************************************
* Perform LU Factorization
* *****************************************************************/
ga_lu(A, matrix_size);
}
free(A);
/* *****************************************************************
* Terminate MPI/TCGMSG-MPI, GA and MA
* *****************************************************************/
if(me==0)printf("Terminating ..\n");
GA_Terminate();
#ifdef MPI
MPI_Finalize();
#else
PEND_();
#endif
return 0;
}
void tcg_pbegin(int argc, char **argv)
{
PBEGIN_(argc,argv);
}
void Init(ArgStruct *p, int* pargc, char*** pargv)
{
PBEGIN_(*pargc, *pargv);
}
