void slave()
{
long i;
long j;
long nstep;
long iindex;
long iday;
double ysca1;
double y;
double factor;
double sintemp;
double curlt;
double ressqr;
long istart;
long iend;
long jstart;
long jend;
long ist;
long ien;
long jst;
long jen;
double fac;
long dayflag=0;
long dhourflag=0;
long endflag=0;
double ttime;
double dhour;
double day;
long firstrow;
long lastrow;
long numrows;
long firstcol;
long lastcol;
long numcols;
long psiindex;
double psibipriv;
long psinum;
long procid;
unsigned long t1;
ressqr = lev_res[numlev-1] * lev_res[numlev-1];
LOCK(locks->idlock)
procid = global->id;
global->id = global->id+1;
UNLOCK(locks->idlock)
/* POSSIBLE ENHANCEMENT: Here is where one might pin processes to
processors to avoid migration. */
/* POSSIBLE ENHANCEMENT: Here is where one might distribute
data structures across physically distributed memories in
a round-robin fashion. */
firstcol = gp[procid].rel_start_x[numlev-1];
lastcol = firstcol + gp[procid].rel_num_x[numlev-1] - 1;
firstrow = gp[procid].rel_start_y[numlev-1];
lastrow = firstrow + gp[procid].rel_num_y[numlev-1] - 1;
numcols = gp[procid].rel_num_x[numlev-1];
numrows = gp[procid].rel_num_y[numlev-1];
if (procid > nprocs/2) {
psinum = 2;
} else {
psinum = 1;
}
/* every process gets its own copy of the timing variables to avoid
contention at shared memory locations. here, these variables
are initialized. */
ttime = 0.0;
dhour = 0.0;
nstep = 0 ;
day = 0.0;
ysca1 = 0.5*ysca;
if (procid == MASTER) {
for(iindex = 0;iindex<=jm-1;iindex++) {
y = ((double) iindex)*res;
wrk2->f[iindex] = f0+beta*(y-ysca1);
}
}
if (procid == MASTER) {
fields2->psium[0][0]=0.0;
}
if (procid == nprocs-xprocs) {
fields2->psium[im-1][0]=0.0;
}
if (procid == xprocs-1) {
fields2->psium[0][jm-1]=0.0;
}
if (procid == nprocs-1) {
fields2->psium[im-1][jm-1]=0.0;
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psium[0][j] = 0.0;
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psium[im-1][j] = 0.0;
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psium[j][0] = 0.0;
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psium[j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
for(iindex=firstcol;iindex<=lastcol;iindex++) {
fields2->psium[i][iindex] = 0.0;
}
}
if (procid == MASTER) {
fields2->psilm[0][0]=0.0;
}
if (procid == nprocs-xprocs) {
fields2->psilm[im-1][0]=0.0;
}
if (procid == xprocs-1) {
fields2->psilm[0][jm-1]=0.0;
}
if (procid == nprocs-1) {
fields2->psilm[im-1][jm-1]=0.0;
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psilm[0][j] = 0.0;
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psilm[im-1][j] = 0.0;
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psilm[j][0] = 0.0;
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psilm[j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
for(iindex=firstcol;iindex<=lastcol;iindex++) {
fields2->psilm[i][iindex] = 0.0;
}
}
if (procid == MASTER) {
wrk1->psib[0][0]=1.0;
}
if (procid == xprocs-1) {
wrk1->psib[0][jm-1]=1.0;
}
if (procid == nprocs-xprocs) {
wrk1->psib[im-1][0]=1.0;
}
if (procid == nprocs-1) {
wrk1->psib[im-1][jm-1]=1.0;
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
wrk1->psib[0][j] = 1.0;
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
wrk1->psib[im-1][j] = 1.0;
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
wrk1->psib[j][0] = 1.0;
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
wrk1->psib[j][jm-1] = 1.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
for(iindex=firstcol;iindex<=lastcol;iindex++) {
wrk1->psib[i][iindex] = 0.0;
}
}
/* wait until all processes have completed the above initialization */
#if defined(MULTIPLE_BARRIERS)
BARRIER(bars->sl_prini,nprocs)
#else
BARRIER(bars->barrier,nprocs)
#endif
istart = gp[procid].rel_start_y[numlev-1];
iend = istart + gp[procid].rel_num_y[numlev-1] - 1;
jstart = gp[procid].rel_start_x[numlev-1];
jend = jstart + gp[procid].rel_num_x[numlev-1] - 1;
ist = istart;
ien = iend;
jst = jstart;
jen = jend;
if (istart == 1) {
istart = 0;
}
if (jstart == 1) {
jstart = 0;
}
if (iend == im-2) {
iend = im-1;
}
if (jend == jm-2) {
jend = jm-1;
}
for(i=istart;i<=iend;i++) {
for(j=jstart;j<=jend;j++) {
multi->rhs_multi[numlev-1][i][j] = wrk1->psib[i][j] * ressqr;
}
}
if (istart == 0) {
for(j=jstart;j<=jend;j++) {
multi->q_multi[numlev-1][0][j] = wrk1->psib[0][j];
}
}
if (iend == im-1) {
for(j=jstart;j<=jend;j++) {
multi->q_multi[numlev-1][im-1][j] = wrk1->psib[im-1][j];
}
}
if (jstart == 0) {
for(i=istart;i<=iend;i++) {
multi->q_multi[numlev-1][i][0] = wrk1->psib[i][0];
}
}
if (jend == jm-1) {
for(i=istart;i<=iend;i++) {
multi->q_multi[numlev-1][i][jm-1] = wrk1->psib[i][jm-1];
}
}
fac = 1.0 / (4.0 - ressqr*eig2);
for(i=ist;i<=ien;i++) {
for(j=jst;j<=jen;j++) {
multi->q_multi[numlev-1][i][j] = fac * (wrk1->psib[i+1][j] +
wrk1->psib[i-1][j] + wrk1->psib[i][j+1] + wrk1->psib[i][j-1] -
ressqr*wrk1->psib[i][j]);
}
}
#if defined(MULTIPLE_BARRIERS)
BARRIER(bars->sl_prini,nprocs)
#else
BARRIER(bars->barrier,nprocs)
#endif
multig(procid);
for(i=istart;i<=iend;i++) {
for(j=jstart;j<=jend;j++) {
wrk1->psib[i][j] = multi->q_multi[numlev-1][i][j];
}
}
#if defined(MULTIPLE_BARRIERS)
BARRIER(bars->sl_psini,nprocs)
#else
BARRIER(bars->barrier,nprocs)
#endif
/* update the local running sum psibipriv by summing all the resulting
values in that process's share of the psib matrix */
psibipriv=0.0;
if (procid == MASTER) {
psibipriv = psibipriv + 0.25*(wrk1->psib[0][0]);
}
if (procid == xprocs-1){
psibipriv = psibipriv + 0.25*(wrk1->psib[0][jm-1]);
}
if (procid == nprocs - xprocs) {
psibipriv=psibipriv+0.25*(wrk1->psib[im-1][0]);
}
if (procid == nprocs-1) {
psibipriv=psibipriv+0.25*(wrk1->psib[im-1][jm-1]);
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
psibipriv = psibipriv + 0.5*wrk1->psib[0][j];
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
psibipriv = psibipriv + 0.5*wrk1->psib[im-1][j];
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
psibipriv = psibipriv + 0.5*wrk1->psib[j][0];
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
psibipriv = psibipriv + 0.5*wrk1->psib[j][jm-1];
}
}
for(iindex=firstcol;iindex<=lastcol;iindex++) {
for(i=firstrow;i<=lastrow;i++) {
psibipriv = psibipriv + wrk1->psib[i][iindex];
}
}
/* update the shared variable psibi by summing all the psibiprivs
of the individual processes into it. note that this combined
private and shared sum method avoids accessing the shared
variable psibi once for every element of the matrix. */
LOCK(locks->psibilock)
global->psibi = global->psibi + psibipriv;
UNLOCK(locks->psibilock)
for(psiindex=0;psiindex<=1;psiindex++) {
if (procid == MASTER) {
fields->psim[psiindex][0][0] = 0.0;
}
if (procid == nprocs-xprocs) {
fields->psim[psiindex][im-1][0] = 0.0;
}
if (procid == xprocs-1) {
fields->psim[psiindex][0][jm-1] = 0.0;
}
if (procid == nprocs-1) {
fields->psim[psiindex][im-1][jm-1] = 0.0;
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
fields->psim[psiindex][0][j] = 0.0;
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
fields->psim[psiindex][im-1][j] = 0.0;
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
fields->psim[psiindex][j][0] = 0.0;
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
fields->psim[psiindex][j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
for(iindex=firstcol;iindex<=lastcol;iindex++) {
fields->psim[psiindex][i][iindex] = 0.0;
}
}
}
/* initialize psi matrices the same way */
for(psiindex=0;psiindex<=1;psiindex++) {
if (procid == MASTER) {
fields->psi[psiindex][0][0] = 0.0;
}
if (procid == xprocs-1) {
fields->psi[psiindex][0][jm-1] = 0.0;
}
if (procid == nprocs-xprocs) {
fields->psi[psiindex][im-1][0] = 0.0;
}
if (procid == nprocs-1) {
fields->psi[psiindex][im-1][jm-1] = 0.0;
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
fields->psi[psiindex][0][j] = 0.0;
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
fields->psi[psiindex][im-1][j] = 0.0;
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
fields->psi[psiindex][j][0] = 0.0;
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
fields->psi[psiindex][j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
for(iindex=firstcol;iindex<=lastcol;iindex++) {
fields->psi[psiindex][i][iindex] = 0.0;
}
}
}
/* compute input curl of wind stress */
ysca1 = .5*ysca;
factor= -t0*pi/ysca1;
if (procid == MASTER) {
frcng->tauz[0][0] = 0.0;
}
if (procid == nprocs-xprocs) {
frcng->tauz[im-1][0] = 0.0;
}
if (procid == xprocs-1) {
sintemp = pi*((double) jmm1)*res/ysca1;
sintemp = sin(sintemp);
frcng->tauz[0][jm-1] = factor*sintemp;
}
if (procid == nprocs-1) {
sintemp = pi*((double) jmm1)*res/ysca1;
sintemp = sin(sintemp);
frcng->tauz[im-1][jm-1] = frcng->tauz[0][jm-1];
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
sintemp = pi*((double) j)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
frcng->tauz[0][j] = curlt;
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
sintemp = pi*((double) j)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
frcng->tauz[im-1][j] = curlt;
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
frcng->tauz[j][0] = 0.0;
}
}
if ((firstcol+numcols) == jm-1) {
sintemp = pi*((double) jmm1)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
for(j=firstrow;j<=lastrow;j++) {
frcng->tauz[j][jm-1] = curlt;
}
}
for(iindex=firstcol;iindex<=lastcol;iindex++) {
sintemp = pi*((double) iindex)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
for(i=firstrow;i<=lastrow;i++) {
frcng->tauz[i][iindex] = curlt;
}
}
#if defined(MULTIPLE_BARRIERS)
BARRIER(bars->sl_onetime,nprocs)
#else
BARRIER(bars->barrier,nprocs)
#endif
/***************************************************************
one-time stuff over at this point
***************************************************************/
while (!endflag) {
while ((!dayflag) || (!dhourflag)) {
dayflag = 0;
dhourflag = 0;
if (nstep == 1) {
if (procid == MASTER) {
CLOCK(global->trackstart)
}
if ((procid == MASTER) || (do_stats)) {
CLOCK(t1);
gp[procid].total_time = t1;
gp[procid].multi_time = 0;
}
/* POSSIBLE ENHANCEMENT: Here is where one might reset the
statistics that one is measuring about the parallel execution */
// Reset Models
CarbonEnableModels();
}
slave2(procid,firstrow,lastrow,numrows,firstcol,lastcol,numcols);
/* update time and step number
note that these time and step variables are private i.e. every
process has its own copy and keeps track of its own time */
ttime = ttime + dtau;
nstep = nstep + 1;
day = ttime/86400.0;
if (day > ((double) outday0)) {
dayflag = 1;
iday = (long) day;
dhour = dhour+dtau;
if (dhour >= 86400.0) {
dhourflag = 1;
}
}
}
dhour = 0.0;
/* update values of psium array to psium + psim{1} */
if (procid == MASTER) {
fields2->psium[0][0] = fields2->psium[0][0]+fields->psim[0][0][0];
}
if (procid == nprocs-xprocs) {
fields2->psium[im-1][0] = fields2->psium[im-1][0]+fields->psim[0][im-1][0];
}
if (procid == xprocs-1) {
fields2->psium[0][jm-1] = fields2->psium[0][jm-1]+fields->psim[0][0][jm-1];
}
if (procid == nprocs-1) {
fields2->psium[im-1][jm-1] = fields2->psium[im-1][jm-1]+fields->psim[0][im-1][jm-1];
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psium[0][j] = fields2->psium[0][j]+fields->psim[0][0][j];
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psium[im-1][j] = fields2->psium[im-1][j]+fields->psim[0][im-1][j];
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psium[j][0] = fields2->psium[j][0]+fields->psim[0][j][0];
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psium[j][jm-1] = fields2->psium[j][jm-1]+fields->psim[0][j][jm-1];
}
}
for(i=firstrow;i<=lastrow;i++) {
for(iindex=firstcol;iindex<=lastcol;iindex++) {
fields2->psium[i][iindex] = fields2->psium[i][iindex]+fields->psim[0][i][iindex];
}
}
/* update values of psilm array to psilm + psim[2] */
if (procid == MASTER) {
fields2->psilm[0][0] = fields2->psilm[0][0]+fields->psim[1][0][0];
}
if (procid == nprocs-xprocs) {
fields2->psilm[im-1][0] = fields2->psilm[im-1][0]+fields->psim[1][im-1][0];
}
if (procid == xprocs-1) {
fields2->psilm[0][jm-1] = fields2->psilm[0][jm-1]+fields->psim[1][0][jm-1];
}
if (procid == nprocs-1) {
fields2->psilm[im-1][jm-1] = fields2->psilm[im-1][jm-1]+fields->psim[1][im-1][jm-1];
}
if (firstrow == 1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psilm[0][j] = fields2->psilm[0][j]+fields->psim[1][0][j];
}
}
if ((firstrow+numrows) == im-1) {
for(j=firstcol;j<=lastcol;j++) {
fields2->psilm[im-1][j] = fields2->psilm[im-1][j]+fields->psim[1][im-1][j];
}
}
if (firstcol == 1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psilm[j][0] = fields2->psilm[j][0]+fields->psim[1][j][0];
}
}
if ((firstcol+numcols) == jm-1) {
for(j=firstrow;j<=lastrow;j++) {
fields2->psilm[j][jm-1] = fields2->psilm[j][jm-1]+fields->psim[1][j][jm-1];
}
}
for(i=firstrow;i<=lastrow;i++) {
for(iindex=firstcol;iindex<=lastcol;iindex++) {
fields2->psilm[i][iindex] = fields2->psilm[i][iindex]+fields->psim[1][i][iindex];
}
}
if (iday >= (long) outday3) {
endflag = 1;
}
}
if ((procid == MASTER) || (do_stats)) {
CLOCK(t1);
gp[procid].total_time = t1-gp[procid].total_time;
}
}
EXTERN_ENV
#include <stdio.h>
#include <math.h>
#include <time.h>
#include "decs.h"
void slave()
{
int i;
int j;
int nstep;
int iindex;
int iday;
double ysca1;
double y;
double factor;
double sintemp;
double curlt;
double ressqr;
int istart;
int iend;
int jstart;
int jend;
int ist;
int ien;
int jst;
int jen;
double fac;
int dayflag=0;
int dhourflag=0;
int endflag=0;
int firstrow;
int lastrow;
int numrows;
int firstcol;
int lastcol;
int numcols;
int psiindex;
double psibipriv;
double ttime;
double dhour;
double day;
int procid;
int psinum;
int i_off = 0;
int j_off = 0;
unsigned long t1;
double **t2a;
double **t2b;
double *t1a;
double *t1b;
double *t1c;
double *t1d;
ressqr = lev_res[numlev-1] * lev_res[numlev-1];
LOCK(locks->idlock)
procid = global->id;
global->id = global->id+1;
UNLOCK(locks->idlock)
BARRIER(bars->sl_prini,nprocs)
/* POSSIBLE ENHANCEMENT: Here is where one might pin processes to
processors to avoid migration. */
/* POSSIBLE ENHANCEMENT: Here is where one might distribute
data structures across physically distributed memories as
desired.
One way to do this is as follows. The function allocate(START,SIZE,I)
is assumed to place all addresses x such that
(START <= x < START+SIZE) on node I.
int d_size;
unsigned int g_size;
unsigned int mg_size;
if (procid == MASTER) {
g_size = ((jmx[numlev-1]-2)/xprocs+2)*((imx[numlev-1]-2)/yprocs+2)*siz
eof(double) +
((imx[numlev-1]-2)/yprocs+2)*sizeof(double *);
mg_size = numlev*sizeof(double **);
for (i=0;i<numlev;i++) {
mg_size+=((imx[i]-2)/yprocs+2)*((jmx[i]-2)/xprocs+2)*sizeof(double)+
((imx[i]-2)/yprocs+2)*sizeof(double *);
}
for (i= 0;i<nprocs;i++) {
d_size = 2*sizeof(double **);
allocate((unsigned int) psi[i],d_size,i);
allocate((unsigned int) psim[i],d_size,i);
allocate((unsigned int) work1[i],d_size,i);
allocate((unsigned int) work4[i],d_size,i);
allocate((unsigned int) work5[i],d_size,i);
allocate((unsigned int) work7[i],d_size,i);
allocate((unsigned int) temparray[i],d_size,i);
allocate((unsigned int) psi[i][0],g_size,i);
allocate((unsigned int) psi[i][1],g_size,i);
allocate((unsigned int) psim[i][0],g_size,i);
allocate((unsigned int) psim[i][1],g_size,i);
allocate((unsigned int) psium[i],g_size,i);
allocate((unsigned int) psilm[i],g_size,i);
allocate((unsigned int) psib[i],g_size,i);
allocate((unsigned int) ga[i],g_size,i);
allocate((unsigned int) gb[i],g_size,i);
allocate((unsigned int) work1[i][0],g_size,i);
allocate((unsigned int) work1[i][1],g_size,i);
allocate((unsigned int) work2[i],g_size,i);
allocate((unsigned int) work3[i],g_size,i);
allocate((unsigned int) work4[i][0],g_size,i);
allocate((unsigned int) work4[i][1],g_size,i);
allocate((unsigned int) work5[i][0],g_size,i);
allocate((unsigned int) work5[i][1],g_size,i);
allocate((unsigned int) work6[i],g_size,i);
allocate((unsigned int) work7[i][0],g_size,i);
allocate((unsigned int) work7[i][1],g_size,i);
allocate((unsigned int) temparray[i][0],g_size,i);
allocate((unsigned int) temparray[i][1],g_size,i);
allocate((unsigned int) tauz[i],g_size,i);
allocate((unsigned int) oldga[i],g_size,i);
allocate((unsigned int) oldgb[i],g_size,i);
d_size = numlev * sizeof(int);
allocate((unsigned int) gp[i].rel_num_x,d_size,i);
allocate((unsigned int) gp[i].rel_num_y,d_size,i);
allocate((unsigned int) gp[i].eist,d_size,i);
allocate((unsigned int) gp[i].ejst,d_size,i);
allocate((unsigned int) gp[i].oist,d_size,i);
allocate((unsigned int) gp[i].ojst,d_size,i);
allocate((unsigned int) gp[i].rlist,d_size,i);
allocate((unsigned int) gp[i].rljst,d_size,i);
allocate((unsigned int) gp[i].rlien,d_size,i);
allocate((unsigned int) gp[i].rljen,d_size,i);
allocate((unsigned int) q_multi[i],mg_size,i);
allocate((unsigned int) rhs_multi[i],mg_size,i);
allocate((unsigned int) &(gp[i]),sizeof(struct Global_Private),i);
}
}
*/
t2a = (double **) oldga[procid];
t2b = (double **) oldgb[procid];
for (i=0;i<im;i++) {
t1a = (double *) t2a[i];
t1b = (double *) t2b[i];
for (j=0;j<jm;j++) {
t1a[j] = 0.0;
t1b[j] = 0.0;
}
}
firstcol = 1;
lastcol = firstcol + gp[procid].rel_num_x[numlev-1] - 1;
firstrow = 1;
lastrow = firstrow + gp[procid].rel_num_y[numlev-1] - 1;
numcols = gp[procid].rel_num_x[numlev-1];
numrows = gp[procid].rel_num_y[numlev-1];
j_off = gp[procid].colnum*numcols;
if (procid > nprocs/2) {
psinum = 2;
} else {
psinum = 1;
}
/* every process gets its own copy of the timing variables to avoid
contention at shared memory locations. here, these variables
are initialized. */
ttime = 0.0;
dhour = 0.0;
nstep = 0 ;
day = 0.0;
ysca1 = 0.5*ysca;
if (procid == MASTER) {
t1a = (double *) f;
for (iindex = 0;iindex<=jmx[numlev-1]-1;iindex++) {
y = ((double) iindex)*res;
t1a[iindex] = f0+beta*(y-ysca1);
}
}
t2a = (double **) psium[procid];
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0]=0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0]=0.0;
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[0][jm-1]=0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[im-1][jm-1]=0.0;
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = 0.0;
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
t1a[iindex] = 0.0;
}
}
t2a = (double **) psilm[procid];
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0]=0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0]=0.0;
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[0][jm-1]=0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[im-1][jm-1]=0.0;
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = 0.0;
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
t1a[iindex] = 0.0;
}
}
t2a = (double **) psib[procid];
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0]=1.0;
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[0][jm-1]=1.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0]=1.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[im-1][jm-1]=1.0;
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 1.0;
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 1.0;
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = 1.0;
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = 1.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
t1a[iindex] = 0.0;
}
}
/* wait until all processes have completed the above initialization */
BARRIER(bars->sl_prini,nprocs)
/* compute psib array (one-time computation) and integrate into psibi */
istart = 1;
iend = istart + gp[procid].rel_num_y[numlev-1] - 1;
jstart = 1;
jend = jstart + gp[procid].rel_num_x[numlev-1] - 1;
ist = istart;
ien = iend;
jst = jstart;
jen = jend;
if (gp[procid].neighbors[UP] == -1) {
istart = 0;
}
if (gp[procid].neighbors[LEFT] == -1) {
jstart = 0;
}
if (gp[procid].neighbors[DOWN] == -1) {
iend = im-1;
}
if (gp[procid].neighbors[RIGHT] == -1) {
jend = jm-1;
}
t2a = (double **) rhs_multi[procid][numlev-1];
t2b = (double **) psib[procid];
for(i=istart;i<=iend;i++) {
t1a = (double *) t2a[i];
t1b = (double *) t2b[i];
for(j=jstart;j<=jend;j++) {
t1a[j] = t1b[j] * ressqr;
}
}
t2a = (double **) q_multi[procid][numlev-1];
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
t1b = (double *) t2b[0];
for(j=jstart;j<=jend;j++) {
t1a[j] = t1b[j];
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
t1b = (double *) t2b[im-1];
for(j=jstart;j<=jend;j++) {
t1a[j] = t1b[j];
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(i=istart;i<=iend;i++) {
t2a[i][0] = t2b[i][0];
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(i=istart;i<=iend;i++) {
t2a[i][jm-1] = t2b[i][jm-1];
}
}
BARRIER(bars->sl_psini,nprocs)
t2a = (double **) psib[procid];
j = gp[procid].neighbors[UP];
if (j != -1) {
t1a = (double *) t2a[0];
t1b = (double *) psib[j][im-2];
for (i=1;i<jm-1;i++) {
t1a[i] = t1b[i];
}
}
j = gp[procid].neighbors[DOWN];
if (j != -1) {
t1a = (double *) t2a[im-1];
t1b = (double *) psib[j][1];
for (i=1;i<jm-1;i++) {
t1a[i] = t1b[i];
}
}
j = gp[procid].neighbors[LEFT];
if (j != -1) {
t2b = (double **) psib[j];
for (i=1;i<im-1;i++) {
t2a[i][0] = t2b[i][jm-2];
}
}
j = gp[procid].neighbors[RIGHT];
if (j != -1) {
t2b = (double **) psib[j];
for (i=1;i<im-1;i++) {
t2a[i][jm-1] = t2b[i][1];
}
}
t2a = (double **) q_multi[procid][numlev-1];
t2b = (double **) psib[procid];
fac = 1.0 / (4.0 - ressqr*eig2);
for(i=ist;i<=ien;i++) {
t1a = (double *) t2a[i];
t1b = (double *) t2b[i];
t1c = (double *) t2b[i-1];
t1d = (double *) t2b[i+1];
for(j=jst;j<=jen;j++) {
t1a[j] = fac * (t1d[j]+t1c[j]+t1b[j+1]+t1b[j-1] -
ressqr*t1b[j]);
}
}
multig(procid);
for(i=istart;i<=iend;i++) {
t1a = (double *) t2a[i];
t1b = (double *) t2b[i];
for(j=jstart;j<=jend;j++) {
t1b[j] = t1a[j];
}
}
BARRIER(bars->sl_prini,nprocs)
/* update the local running sum psibipriv by summing all the resulting
values in that process's share of the psib matrix */
t2a = (double **) psib[procid];
psibipriv=0.0;
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
psibipriv = psibipriv + 0.25*(t2a[0][0]);
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
psibipriv = psibipriv + 0.25*(t2a[0][jm-1]);
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
psibipriv=psibipriv+0.25*(t2a[im-1][0]);
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
psibipriv=psibipriv+0.25*(t2a[im-1][jm-1]);
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
for(j=firstcol;j<=lastcol;j++) {
psibipriv = psibipriv + 0.5*t1a[j];
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
for(j=firstcol;j<=lastcol;j++) {
psibipriv = psibipriv + 0.5*t1a[j];
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
psibipriv = psibipriv + 0.5*t2a[j][0];
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
psibipriv = psibipriv + 0.5*t2a[j][jm-1];
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
psibipriv = psibipriv + t1a[iindex];
}
}
/* update the shared variable psibi by summing all the psibiprivs
of the individual processes into it. note that this combined
private and shared sum method avoids accessing the shared
variable psibi once for every element of the matrix. */
LOCK(locks->psibilock)
global->psibi = global->psibi + psibipriv;
UNLOCK(locks->psibilock)
/* initialize psim matrices
if there is more than one process, then split the processes
between the two psim matrices; otherwise, let the single process
work on one first and then the other */
for(psiindex=0;psiindex<=1;psiindex++) {
t2a = (double **) psim[procid][psiindex];
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0] = 0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0] = 0.0;
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[0][jm-1] = 0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[im-1][jm-1] = 0.0;
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = 0.0;
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
t1a[iindex] = 0.0;
}
}
}
/* initialize psi matrices the same way */
for(psiindex=0;psiindex<=1;psiindex++) {
t2a = (double **) psi[procid][psiindex];
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0] = 0.0;
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[0][jm-1] = 0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0] = 0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[im-1][jm-1] = 0.0;
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = 0.0;
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = 0.0;
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = 0.0;
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
t1a[iindex] = 0.0;
}
}
}
/* compute input curl of wind stress */
t2a = (double **) tauz[procid];
ysca1 = .5*ysca;
factor= -t0*pi/ysca1;
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0] = 0.0;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0] = 0.0;
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
sintemp = pi*((double) jm-1+j_off)*res/ysca1;
sintemp = sin(sintemp);
t2a[0][jm-1] = factor*sintemp;
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
sintemp = pi*((double) jm-1+j_off)*res/ysca1;
sintemp = sin(sintemp);
t2a[im-1][jm-1] = factor*sintemp;
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
for(j=firstcol;j<=lastcol;j++) {
sintemp = pi*((double) j+j_off)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
t1a[j] = curlt;
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
for(j=firstcol;j<=lastcol;j++) {
sintemp = pi*((double) j+j_off)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
t1a[j] = curlt;
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = 0.0;
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
sintemp = pi*((double) jm-1+j_off)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = curlt;
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
sintemp = pi*((double) iindex+j_off)*res/ysca1;
sintemp = sin(sintemp);
curlt = factor*sintemp;
t1a[iindex] = curlt;
}
}
BARRIER(bars->sl_onetime,nprocs)
/***************************************************************
one-time stuff over at this point
***************************************************************/
while (!endflag) {
while ((!dayflag) || (!dhourflag)) {
dayflag = 0;
dhourflag = 0;
if (nstep == 1) {
if (procid == MASTER) {
CLOCK(global->trackstart)
}
if ((procid == MASTER) || (do_stats)) {
CLOCK(t1);
gp[procid].total_time = t1;
gp[procid].multi_time = 0;
}
/* POSSIBLE ENHANCEMENT: Here is where one might reset the
statistics that one is measuring about the parallel execution */
}
slave2(procid,firstrow,lastrow,numrows,firstcol,lastcol,numcols);
/* update time and step number
note that these time and step variables are private i.e. every
process has its own copy and keeps track of its own time */
ttime = ttime + dtau;
nstep = nstep + 1;
day = ttime/86400.0;
if (day > ((double) outday0)) {
dayflag = 1;
iday = (int) day;
dhour = dhour+dtau;
if (dhour >= 86400.0) {
dhourflag = 1;
}
}
}
dhour = 0.0;
t2a = (double **) psium[procid];
t2b = (double **) psim[procid][0];
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0] = t2a[0][0]+t2b[0][0];
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0] = t2a[im-1][0]+t2b[im-1][0];
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[0][jm-1] = t2a[0][jm-1]+t2b[0][jm-1];
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[im-1][jm-1] = t2a[im-1][jm-1] +
t2b[im-1][jm-1];
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
t1b = (double *) t2b[0];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = t1a[j]+t1b[j];
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
t1b = (double *) t2b[im-1];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = t1a[j] + t1b[j];
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = t2a[j][0]+t2b[j][0];
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = t2a[j][jm-1] +
t2b[j][jm-1];
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
t1b = (double *) t2b[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
t1a[iindex] = t1a[iindex] + t1b[iindex];
}
}
/* update values of psilm array to psilm + psim[2] */
t2a = (double **) psilm[procid];
t2b = (double **) psim[procid][1];
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[0][0] = t2a[0][0]+t2b[0][0];
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[LEFT] == -1)) {
t2a[im-1][0] = t2a[im-1][0]+t2b[im-1][0];
}
if ((gp[procid].neighbors[UP] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[0][jm-1] = t2a[0][jm-1]+t2b[0][jm-1];
}
if ((gp[procid].neighbors[DOWN] == -1) && (gp[procid].neighbors[RIGHT] == -1)) {
t2a[im-1][jm-1] = t2a[im-1][jm-1] +
t2b[im-1][jm-1];
}
if (gp[procid].neighbors[UP] == -1) {
t1a = (double *) t2a[0];
t1b = (double *) t2b[0];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = t1a[j]+t1b[j];
}
}
if (gp[procid].neighbors[DOWN] == -1) {
t1a = (double *) t2a[im-1];
t1b = (double *) t2b[im-1];
for(j=firstcol;j<=lastcol;j++) {
t1a[j] = t1a[j]+t1b[j];
}
}
if (gp[procid].neighbors[LEFT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][0] = t2a[j][0]+t2b[j][0];
}
}
if (gp[procid].neighbors[RIGHT] == -1) {
for(j=firstrow;j<=lastrow;j++) {
t2a[j][jm-1] = t2a[j][jm-1] + t2b[j][jm-1];
}
}
for(i=firstrow;i<=lastrow;i++) {
t1a = (double *) t2a[i];
t1b = (double *) t2b[i];
for(iindex=firstcol;iindex<=lastcol;iindex++) {
t1a[iindex] = t1a[iindex] + t1b[iindex];
}
}
if (iday >= (int) outday3) {
endflag = 1;
}
}
if ((procid == MASTER) || (do_stats)) {
CLOCK(t1);
gp[procid].total_time = t1-gp[procid].total_time;
}
}
