| Lib-DVM interface description (contents) | Part 1 (1-5) |
Part 2 (6-7) |
Part 3 (8-11) |
Part 4 (12-13) |
Part 5 (14-15) |
Part 6 (16-18) |
Part 7 (19) |
| created: february, 2001 | - last edited 03.05.01 - |
19 Examples of programs using Run-Time System functions
19.1 Solution of Laplas equation by Jacobi method
The usage of main functions of Run-Time System is shown on the example of numerical solution of two-dimensional Laplas equation in specified rectangular area with specified boundary conditions (Dirixle task)
| ¶ 2U ¾ ¾ + ¶ x2 |
¶ 2U ¾ ¾ = 0 (1) ¶ y2 |
Three-point approximation of partial derivatives of the equation (1) on squared grid using five-point pattern
(i-1,j) , (i+1,j) , (i,j) , (i,j-1) , (i,j+1)
gives differential equation ("cross" scheme), reduced to the equation
ui,j = (ui+1,j + ui-1,j + ui,j+1 + ui,j-1)/4 (i,j=1, ... , k-2) (2) ,
where:
| k | - | a number of grid points of each dimension; |
| ui,j | - | a value of grid function in a node (i,j). |
The values of the grid function
u0,j , uk-1,j , ui,0 , ui,k-1 (i,j=0, ... , k-1)
are determined by boundary conditions.
In the programs below (Fortran and C) the solution of the equation (1) is seached by formulas (2) using method of sequential approximations. The iterational proccess is completed if maximal diviation of the grid function ui,j on all knots for to sequential iterations will become less, then a value of variable maxeps. The initial values of the grid functoin are ui,j = 1+i+j (i,j = 1, … , k-2). The boundary conditions are zero: u0,j=0, uk-1,j=0, ui,0=0, ui,k-1=0 (i,j = 0, ... , k-1). The solution is searched on square [0:7, 0:7].
PROGRAM IN FORTRAM LANGUAGE
program cross
integer linit, lexit, getam, getps, crtamv, distr, crtda, align,
+ crtpl, dvmadr, mappl, endpl, exfrst, imlast, dopl,
+ tstio, crtrg, crtred, insred, strtrd, waitrd,
+ crtshg, inssh, strtsh, waitsh, delrg, delshg
real bptr(1)
integer dvm
integer amref, psref, mvref, plref, rgref, redref, shgref
integer amdim(2), disaxs(2), dispar(2)
integer shwdth(2), axis(2), coeff(2), const(2)
integer lvaddr(2), lvtype(2), iiniti(2), ilasti(2), istep(2)
integer oiniti(2), olasti(2), ostep(2)
C A number of grid points by each dimension and C maximal number of iterations
parameter (k = 8, itmax = 20)
real eps, maxeps
C Array header with previous values of the grid function
integer ahdr(3)
C Array header with next values of the grid function
integer bhdr(3)
maxeps = 0.5e-7
C Run-Time System initialisation
dvm = linit (0)
C Creating abstract machine representation C and mapping it onto processor subsystem
amref = getam ()
psref = getps (amref)
amdim(1) = k
amdim(2) = k
mvref = crtamv (amref, 2, amdim,0)
disaxs(1) = 1
disaxs(2) = 2
dispar(1) = 0
dispar(2) = 0
dvm = distr (mvref, psref, 2, disaxs, dispar)
C Creating and mapping arrays C with the values of the grid function
shwdth(1) = 1
shwdth(2) = 1
dvm = crtda (ahdr, 1, bptr, 2, 4, amdim, 0, 0, shwdth, shwdth)
dvm = crtda (bhdr, 1, bptr, 2, 4, amdim, 0, 0, shwdth, shwdth)
axis(1) = 1
axis(2) = 2
coeff(1) = 1
coeff(2) = 1
const(1) = 0
const(2) = 0
dvm = align (ahdr, mvref, axis, coeff, const)
dvm = align (bhdr, mvref, axis, coeff, const)
C Parallel loop of initializing arrays C with values of the grid function C (parallel loop with the base array ahdr)
plref = crtpl (2)
lvaddr(1) = dvmadr (j)
lvaddr(2) = dvmadr (i)
lvtype(1) = 1
lvtype(2) = 1
iiniti(1) = 0
iiniti(2) = 0
ilasti(1) = k - 1
ilasti(2) = k - 1
istep(1) = 1
istep(2) = 1
dvm = mappl (plref, ahdr, axis, coeff, const, lvaddr, lvtype,
+ iiniti, ilasti, istep, oiniti, olasti, ostep)
4 if (dopl (plref) .eq. 0) goto 5
do 1 j = oiniti(1), olasti(1), ostep(1)
do 1 i = oiniti(2), olasti(2), ostep(2)
bptr( ahdr(3) + 1 + i + ahdr(2) * j ) = 0.
bptr( bhdr(3) + 1 + i + bhdr(2) * j ) = 1. + i + j
1 continue
goto 4
5 dvm = endpl (plref)
C Creating reduction variable and reduction group C to calculate maximal deviation of the grid function for C two sequential iterations
redref = crtred ( 3, eps, 3, 1, 0, 0, 0)
rgref = crtrg (0, 0)
dvm = insred (rgref, redref, 0)
C Creating shadow edge group for renewing shadow edges
shgref = crtshg (0)
dvm = inssh (shgref, ahdr, shwdth, shwdth, 0)
C MAIN ITERATION LOOP
do 2 it = 1,itmax
C Parallel loop to calculate maximal deviation C of the grid function in variable eps C (parallel loop with base array ahdr)
plref = crtpl (2)
iiniti(1) = 1
iiniti(2) = 1
ilasti(1) = k - 2
ilasti(2) = k - 2
dvm = mappl (plref, ahdr, axis, coeff, const, lvaddr, lvtype,
+ iiniti, ilasti, istep, oiniti, olasti, ostep)
eps = 0.
6 if (dopl (plref) .eq. 0) goto 8
do 7 j = oiniti(1), olasti(1), ostep(1)
do 7 i = oiniti(2), olasti(2), ostep(2)
eps = max(eps, abs(bptr( bhdr(3)+1+i+bhdr(2)*j )
+ - bptr( ahdr(3)+1+i+ahdr(2)*j )))
bptr( ahdr(3) + 1 + i + ahdr(2) * j ) =
+ bptr( bhdr(3) + 1 + i + bhdr(2) * j )
7 continue
goto 6
8 dvm = endpl (plref)
C Calculation of reductional maximum
dvm = strtrd (rgref)
dvm = waitrd (rgref)
C Shadow edge exchange
dvm = strtsh (shgref)
dvm = waitsh (shgref)
C Parallel loop to calculate new values C of the grid function in array bhdr C (parallel loop with base array bhdr)
plref = crtpl (2)
dvm = mappl ( plref, bhdr, axis, coeff, const, lvaddr, lvtype,
+ iiniti, ilasti, istep, oiniti, olasti, ostep)
9 if (dopl (plref) .eq. 0) goto 11
do 10 j = oiniti(1), olasti(1), ostep(1)
do 10 i = oiniti(2), olasti(2), ostep(2)
bptr(bhdr(3) + 1 + i + bhdr(2) * j) =
+ ( bptr(ahdr(3) + 1 + (i - 1) + ahdr(2) * j) +
+ bptr(ahdr(3) + 1 + i + ahdr(2) * (j - 1)) +
+ bptr(ahdr(3) + 1 + (i + 1) + ahdr(2) * j) +
+ bptr(ahdr(3) + 1 + i + ahdr(2) * (j + 1)) ) / 4.
10 continue
goto 9
11 dvm = endpl (plref)
C Printing current deviation of the grid function
if (tstio ()) print *,'IT = ',it,' EPS = ',eps
C Exit, if specified precision is achieved
if (eps .lt. maxeps) goto 3
2 continue
C END OF MAIN ITERATION LOOP
C End of dealing with Run-Time System
3 dvm = lexit (0)
end
PROGRAM IN C LANGUAGE
#include "dvmlib.h"
int main(int argc, char *argv[])
{
long InitPar = 0, UserRes = 0, ExtHdr = 0;
long StaticMV = 0, StaticDA = 0, ReDistrDA = 0, StaticRV = 0,
DelRed = 0, StaticRG = 0, StaticShG = 0, FullShd = 0;
long i, j, it, Rank2 = 2, Long0 = 0, TypeSize = sizeof(float);
long RedFunc = rf_MAX, RVType = rt_FLOAT, RedArrayLength = 1;
AMRef amref;
PSRef psref;
AMViewRef mvref;
LoopRef plref;
RedGroupRef rgref;
RedRef redref;
ShadowGroupRef shgref;
AddrType lvaddr[2];
long lvtype[2] = {0,0};
long amdim[2], disaxs[2], dispar[2];
long shwdth[2], axis[2], coeff[2], cnst[2];
long iiniti[2], ilasti[2], istep[2];
long oiniti[2], olasti[2], ostep[2];
DVMFILE *OutFile;
float eps; /* current precision of calculation */
long k = 8; /* a number of grid points by every dimension */
float maxeps = 0.5e-2f; /* requied precision of calculation */ long itmax = 200; /* maximal number of iterations */
long Ahdr[3]; /* header of array with previous values of the grid function */
long Bhdr[3]; /* header of array with next values of the grid function */
rtl_init(InitPar, argc, argv); /* Run-Time System initialization */
/* Creating abstract machine representation and its mapping on processor subsystem */
amref = getam_ (); psref = getps_ (&amref); amdim[0] = k; amdim[1] = k; mvref = crtamv_ (&amref, &Rank2, amdim, &StaticMV); disaxs[0] = 1; disaxs[1] = 2; dispar[0] = 0; dispar[1] = 0; distr_ (&mvref, &psref, &Rank2, disaxs, dispar);
/* Creation and distribution of arrays with values of the grid function */
shwdth[0] = 1; shwdth[1] = 1;
/* Array with previous values of the grig function */
crtda_ (Ahdr, &ExtHdr, NULL, &Rank2, &TypeSize, amdim,
&StaticDA, &ReDistrDA,shwdth, shwdth);
/* Array with next values of grid function */
crtda_ (Bhdr, &ExtHdr, NULL, &Rank2, &TypeSize, amdim,
&StaticDA, &ReDistrDA, shwdth, shwdth);
axis[0] = 1;
axis[1] = 2;
coeff[0] = 1;
coeff[1] = 1;
cnst[0] = 0;
cnst[1] = 0;
align_ (Ahdr,&mvref,axis,coeff,cnst);
align_ (Bhdr,&mvref,axis,coeff,cnst);
/* Parallel loop of initializing arrays with values of the grid function (parallel loop with base array Ahdr) */
plref = crtpl_ (&Rank2);
lvaddr[0] = (AddrType)&j;
lvaddr[1] = (AddrType)&i;
iiniti[0] = 0;
iiniti[1] = 0;
ilasti[0] = k - 1;
ilasti[1] = k - 1;
istep[0] = 1;
istep[1] = 1;
mappl_ (&plref, (PatternRef *)Ahdr, axis, coeff, cnst, lvaddr,
lvtype, iiniti, ilasti, istep, oiniti, olasti, ostep);
while (dopl_ (&plref))
for ( j = oiniti[0]; j <= olasti[0]; j += ostep[0] )
for ( i = oiniti[1]; i <= olasti[1]; i += ostep[1] )
{ DAElm2(Ahdr, float, j, i) = 0.;
DAElm2(Bhdr, float, j, i) = 1.f + i + j;
}
endpl_ (&plref);
/* Creating reduction variable and reduction group
to calculate maximal deviation of the grid function for
two sequential iterations */
redref = crtred_ (&RedFunc, &eps, &RVType, &RedArrayLength,
NULL, &Long0, &StaticRV);
rgref = crtrg_ (&StaticRG, &DelRed);
insred_ (&rgref, &redref, NULL);
/* Creating shadow edge group for renewing shadow edges */
shgref = crtshg_ (&StaticShG); inssh_ (&shgref, Ahdr, shwdth, shwdth, &FullShd);
/* MAIN ITERATION LOOP */
for (it = 1; it <= itmax; it++)
{
/* Parallel loop to calculate maximal deviation
of the grid function in variable eps
(parallel loop with base array Ahdr) */
plref = crtpl_ (&Rank2);
iiniti[0] = 1;
iiniti[1] = 1;
ilasti[0] = k - 2;
ilasti[1] = k - 2;
mappl_ (&plref, (PatternRef *)Ahdr, axis, coeff, cnst, lvaddr,
lvtype, iiniti, ilasti, istep, oiniti, olasti, ostep);
eps = 0.;
while (dopl_ (&plref))
for ( j = oiniti[0]; j <= olasti[0]; j += ostep[0] )
for ( i = oiniti[1]; i <= olasti[1]; i += ostep[1] )
{ eps = max(eps, dvm_abs( DAElm2(Bhdr,float,j,i) -
DAElm2(Ahdr,float,j,i) ));
DAElm2(Ahdr, float, j, i) =
DAElm2(Bhdr, float, j, i);
}
endpl_ (&plref);
/* Calculation of reductional maximum */
strtrd_ (&rgref);
waitrd_ (&rgref);
/* Shadow edges exchange */
strtsh_ (&shgref);
waitsh_ (&shgref);
/* Parallel loop to calculate new values of the grid function in array Bhdr (parallel loop with base array Bhdr) */
plref = crtpl_ (&Rank2);
mappl_ (&plref, (PatternRef *)Bhdr, axis, coeff, cnst, lvaddr,
lvtype, iiniti, ilasti, istep, oiniti, olasti, ostep);
while (dopl_ (&plref))
for ( j = oiniti[0]; j <= olasti[0]; j += ostep[0] )
for ( i = oiniti[1]; i <= olasti[1]; i += ostep[1] )
DAElm2(Bhdr, float, j, i) =
( DAElm2(Ahdr, float, j, i-1) +
DAElm2(Ahdr, float, j-1, i) +
DAElm2(Ahdr, float, j, i+1) +
DAElm2(Ahdr, float, j+1, i) ) / 4.f;
endpl_ (&plref);
/* Printing current deviation of grid function */
dvm_printf("IT = %ld EPS = %e\n", it, eps);
if (eps < maxeps)
break; /* exit, if specified precision is achieved */
}
/* END OF MAIN ITERATION LOOP */
/* Writing solution in the file and end of work with Run-Time System */
OutFile = dvm_fopen("cross.dat", "w+b");
if (OutFile)
{ dvm_dfwrite(Bhdr, 0, OutFile);
dvm_fclose(OutFile);
}
lexit_ (&UserRes); return (int)UserRes;
}
19.2 Parallel loop with regular data dependence between iterations
The (C and Fortran) programs, considered below, are the examples of implementation of parallel loop with data (flow) dependence and anti-dependence between iterations using Run-Time System functions. The parallel loop is two-dimensional loop of the form
| for( | j = 1; j <= k-2; j++ ) | ||||
| for( | i = 1; i <= k-2; i++ ) | ||||
| A[j,i] = ( | A[j- FDL1, i] + | /* flow dependence on dimension 1 */ | |||
| A[j+ ADL1, i] + | /* anti-dependence on dimension 1 */ | ||||
| A[j, i- FDL2] + | /* flow dependence on dimension 2 */ | ||||
| A[j, i+ ADL2] | /* anti-dependence on dimension 2 */ | ||||
| ) | / 4; | ||||
Where:
| k | – | size of A array dimensions; |
| FDL1 | – | dependence length for dimension 1; |
| ADL1 | – | anti-dependence length for dimension 1; |
| FDL2 | – | dependence length for dimension 2; |
| ADL2 | – | anti-dependence length for dimension 2. |
PROGRAM IN FORTRAM LANGUAGE
program across
integer linit, lexit,getam, getps, crtamv, distr, crtda, align,
+ crtpl, dvmadr, mappl, endpl, dopl,
+ crtshg, inssh, insshd, strtsh, recvsh, sendsh, waitsh
real bptr(1)
integer dvm
integer amref, psref, mvref, plref, shgref
integer amdim(2), disaxs(2), dispar(2)
integer lshwd(2), hshwd(2), shsign(2), axis(2), coeff(2),
+ const(2)
integer lvaddr(2), lvtype(2), iiniti(2), ilasti(2), istep(2)
integer oiniti(2), olasti(2), ostep(2)
integer FDL1, FDL2, ADL1, ADL2, finssh
C Size of each array dimension C with regular data dependence
parameter (k = 200)
C Header of array with regular data dependence
integer ahdr(6)
ahdr(5) = 1
ahdr(6) = 1
C Length of data dependence for dimension 1
FDL1 = 4
C Length of data dependence for dimension 2
FDL2 = 3
C Length of data anti-dependence for dimension 1
ADL1 = 2
C Length of data anti-dependence for dimension 2
ADL2 = 1
C Flag to use inssh_ function to registrate array C in shadow edge group; C If finssh=0, insshd_ function is used
finssh = 0
C Run-Time System initialization
dvm = linit (1)
C Creating abstract machine representation and C its mapping on processor subsystem
amref = getam ()
psref = getps (amref)
amdim(1) = k
amdim(2) = k
mvref = crtamv (amref, 2, amdim,0)
disaxs(1) = 1
disaxs(2) = 2
dispar(1) = 0
dispar(2) = 0
dvm = distr (mvref, psref, 2, disaxs, dispar)
C Creation and distribution of array C with regular data dependence
C Width of low shadow edge for dimension 1 is C length of data dependence for dimension 1
lshwd(1) = FDL1
C Width of low shadow edge for dimension 2 is C length of data dependence for dimension 2
lshwd(2) = FDL2
C Width of high shadow edge for dimension 1 is C length of data anti-dependence for dimension 1
hshwd(1) = ADL1
C Width of high shadow edge for dimension 2 is C length of data anti-dependence for dimension 2
hshwd(2) = ADL2
dvm = crtda (ahdr, 1, bptr, 2, 4, amdim, 0, 0, lshwd, hshwd)
axis(1) = 1
axis(2) = 2
coeff(1) = 1
coeff(2) = 1
const(1) = 0
const(2) = 0
dvm = align (ahdr, mvref, axis, coeff, const)
C Parallel loop of array initialization C with regular data dependence
plref = crtpl (2)
lvaddr(1) = dvmadr (j)
lvaddr(2) = dvmadr (i)
lvtype(1) = 1
lvtype(2) = 1
iiniti(1) = 0
iiniti(2) = 0
ilasti(1) = k - 1
ilasti(2) = k - 1
istep(1) = 1
istep(2) = 1
dvm = mappl (plref, ahdr, axis, coeff, const, lvaddr, lvtype
+ iiniti, ilasti, istep, oiniti, olasti, ostep)
2 if (dopl (plref) .eq. 0) goto 3
do 1 j = oiniti(1), olasti(1), ostep(1)
do 1 i = oiniti(2), olasti(2), ostep(2)
bptr( ahdr(3) + 1 + i + ahdr(2) * j ) = 1.
1 continue
goto 2
3 dvm = endpl (plref)
C Creation of shadow edge group to supply C data anti-dependence
shgref = crtshg (0)
C Zero width of low shadow edge for dimension 1
lshwd(1) = 0
C Zero width of low shadow edge for dimension 2
lshwd(2) = 0
C Width of high shadow edge for dimension 1 is C length of data anti-dependence for dimension 1
hshwd(1) = ADL1
C Width of high shadow edge for dimension 2 is C length of data anti-dependence for dimension 2
hshwd(2) = ADL2
dvm = inssh (shgref, ahdr, lshwd, hshwd, 0)
C Initialization of shadow edges to support C data anti-dependence
dvm = strtsh (shgref)
dvm = waitsh (shgref)
C Creation of shadow edge group to support C data dependence
shgref = crtshg (0)
C Width of low shadow edge for dimension 1 is C length of data dependence for dimension 1
lshwd(1) = FDL1
C Width of low shadow edge for dimension 2 is C length of data dependence for dimension 2
lshwd(2) = FDL2
C Zero width of high shadow edge for dimension 1
hshwd(1) = 0
C Zero width of high shadow edge for dimension 2
hshwd(2) = 0
if (finssh .eq. 0) goto 4
C inssh_ is used to registrate array in shadow edge group
dvm = inssh (shgref, ahdr, lshwd, hshwd, 0)
goto 5
C insshd_ is used to registrate array in shadow edge group C Only low edge is used for dimensions 1 and 2
4 shsign(1) = 3
shsign(2) = 3
dvm = insshd (shgref, ahdr, lshwd, hshwd, 1, shsign)
goto 5
C Receiving imported elements C to support data dependence
5 dvm = recvsh (shgref)
dvm = waitsh (shgref)
C PARALLEL LOOP WITH DATA DEPENDENCE AND C ANTI-DEPENDENCE BETWEEN ITERATIONS
plref = crtpl (2)
iiniti(1) = 1
iiniti(2) = 1
ilasti(1) = k - 2
ilasti(2) = k - 2
dvm = mappl (plref, ahdr, axis, coeff, const, lvaddr, lvtype,
+ iiniti, ilasti, istep, oiniti, olasti, ostep)
6 if (dopl (plref) .eq. 0) goto 7
do 8 j = oiniti(1), olasti(1), ostep(1)
do 8 i = oiniti(2), olasti(2), ostep(2)
bptr(ahdr(3) + 1 + i + ahdr(2) * j) =
+ ( bptr(ahdr(3) + 1 + (i - FDL2) + ahdr(2) * j) +
+ bptr(ahdr(3) + 1 + i + ahdr(2) * (j - FDL1)) +
+ bptr(ahdr(3) + 1 + (i + ADL2) + ahdr(2) * j) +
+ bptr(ahdr(3) + 1 + i + ahdr(2) * (j + ADL1)) ) / 4.
8 continue
goto 6
7 dvm = endpl (plref)
C Sending exported elements C to support data dependence
dvm = sendsh (shgref)
dvm = waitsh (shgref)
C Run-Time System termination
dvm = lexit (0)
end
PROGRAM IN C LANGUAGE
#include "dvmlib.h"
int main(int argc, char *argv[])
{
long InitPar = 0, UserRes = 0;
long StaticMV = 0, StaticDA = 0, ReDistrDA = 0,
StaticShG = 0, FullShd = 0, MaxShdCount = 1;
long ShdSignArray[2];
long i, j, Rank2 = 2, TypeSize = sizeof(float);
AMRef amref;
PSRef psref;
AMViewRef mvref;
LoopRef plref;
ShadowGroupRef fshgref, ashgref;
AddrType lvaddr[2];
long lvtype[2] = {0,0};
long amdim[2], disaxs[2], dispar[2];
long lshwdth[2], hshwdth[2], axis[2], coeff[2], cnst[2];
long iiniti[2], ilasti[2], istep[2];
long oiniti[2], olasti[2], ostep[2];
long ExtHdrSign = 0;
DVMFILE *OutFile;
long k = 200; /* size of each array dimension
with regular data dependence */
long FDL1 = 4; /* length of data
dependence for dimension 1 */
long FDL2 = 3; /* length of data
dependence for dimension 2 */
long ADL1 = 2; /* length of data anti-dependence
for dimension 1 */
long ADL2 = 1; /* length of data anti-dependence
for dimension 2 */
int f_inssh = 0; /* flag to use inssh_ function to registrate
array in the shadow edge group if f_inssh = 0,
insshd_ function is used */
long Ahdr[3]; /* header of array with
regular data dependence */
rtl_init(InitPar, argc, argv); /* Run-Time System initialization */
/* Creation of abstract machine representation
and its mapping on processor subsystem */
amref = getam_ (); psref = getps_ (&amref);
amdim[0] = k; amdim[1] = k; mvref = crtamv_ (&amref, &Rank2, amdim, &StaticMV);
disaxs[0] = 1; disaxs[1] = 2; dispar[0] = 0; dispar[1] = 0;
distr_ (&mvref, &psref, &Rank2, disaxs, dispar);
/* Creation and distribution of array
with regular data dependence */
lshwdth[0] = FDL1; /* width of low shadow edge for dimension 1 is
length of data dependence for dimension 1 */
lshwdth[1] = FDL2; /* width of low shadow edge for dimension 2 is
length of data dependence for dimension 2 */
hshwdth[0] = ADL1; /* width of high shadow edge for
dimension 1 is length of data
anti-dependence for dimension 1 */
hshwdth[1] = ADL2; /* width of high shadow edge for
dimension 2 is length of data
anti-dependence for dimension 2 */
crtda_ (Ahdr, &ExtHdrSign, NULL, &Rank2, &TypeSize, amdim,
&StaticDA, &ReDistrDA, lshwdth, hshwdth);
axis[0] = 1; axis[1] = 2; coeff[0] = 1; coeff[1] = 1; cnst[0] = 0; cnst[1] = 0;
align_ (Ahdr,&mvref,axis,coeff,cnst);
/* Parallel loop of array initialization
with regular data dependence */
plref = crtpl_ (&Rank2); lvaddr[0] = (AddrType)&j; lvaddr[1] = (AddrType)&i; iiniti[0] = 0; iiniti[1] = 0; ilasti[0] = k - 1; ilasti[1] = k - 1; istep[0] = 1; istep[1] = 1;
mappl_ (&plref, (PatternRef *)Ahdr, axis, coeff, cnst, lvaddr,
lvtype, iiniti, ilasti, istep, oiniti, olasti, ostep);
while (dopl_ (&plref))
for ( j = oiniti[0]; j <= olasti[0]; j += ostep[0] )
for ( i = oiniti[1]; i <= olasti[1]; i += ostep[1] )
DAElm2(Ahdr, float, j, i) = 1.f;
endpl_ (&plref);
/* Creation of shadow edge group
to support data anti-dependence */
ashgref = crtshg_ (&StaticShG);
lshwdth[0] = 0; /* zero width of low shadow edge for dimension 1 */
lshwdth[1] = 0; /* zero width of low shadow edge for dimension 2 */
hshwdth[0] = ADL1; /* width of high shadow edge for
dimension 1 is length of data anti-dependence
for dimension 1 */
hshwdth[1] = ADL2; /* width of high shadow edge
for dimension 2 is length
of data anti-dependence for dimension 2 */
inssh_ (&ashgref, Ahdr, lshwdth, hshwdth, &FullShd);
/* Initialization of shadow edges to support
data anti-dependence */
strtsh_ (&ashgref); waitsh_ (&ashgref);
/* Creation of shadow edge group
to support data dependence */
fshgref = crtshg_ (&StaticShG);
lshwdth[0] = FDL1; /* width of low shadow edge for
dimension 1 is length of data
dependence for dimension 1 */
lshwdth[1] = FDL2; /* width of low shadow edge for
dimension 2 is length of data
dependence for dimension 2 */
hshwdth[0] = 0; /* zero width of high shadow
edge for dimension 1 */
hshwdth[1] = 0; /* zero width of high shadow
edge for dimension 2 */
if(f_inssh) /* inssh_ or insshd_ function is used */
{
/* inssh_ is used to registrate array in shadow edge group */
inssh_ (&fshgref, Ahdr, lshwdth, hshwdth, &FullShd);
}
else
{
/* insshd_ is used to registrate array in shadow edge group */
ShdSignArray[0] = 3; /* only low shadow edge is
used for dimension 1 */
ShdSignArray[1] = 3; /* only low shadow edge is
used for dimension 2 */
insshd_ (&fshgref, Ahdr, lshwdth, hshwdth, &MaxShdCount,
ShdSignArray);
}
/* Receiving imported elements to support data dependence */
recvsh_ (&fshgref); waitsh_ (&fshgref);
/* PARALLEL LOOP WITH DATA DEPENDENCE AND
ANTI-DEPENDENCE BETWEEN ITERATIONS */
plref = crtpl_ (&Rank2);
iiniti[0] = 1; iiniti[1] = 1; ilasti[0] = k - 2; ilasti[1] = k - 2;
mappl_ (&plref, (PatternRef *)Ahdr, axis, coeff, cnst, lvaddr,
lvtype, iiniti, ilasti, istep, oiniti, olasti, ostep);
while (dopl_ (&plref))
for ( j = oiniti[0]; j <= olasti[0]; j += ostep[0] )
for ( i = oiniti[1]; i <= olasti[1]; i += ostep[1] )
DAElm2(Ahdr, float, j, i) =
( DAElm2(Ahdr, float, j, i-FDL2) +
DAElm2(Ahdr, float, j-FDL1, i) +
DAElm2(Ahdr, float, j, i+ADL2) +
DAElm2(Ahdr, float, j+ADL1, i) ) / 4.f;
endpl_ (&plref);
/* Sending exported elements to support data dependence */
sendsh_ (&fshgref); waitsh_ (&fshgref);
/* Writing result array into the file
and Run-Time System termination */
OutFile = dvm_fopen("across.dat", "w+b");
if(OutFile)
{ dvm_dfwrite(Ahdr, 0, OutFile);
dvm_fclose(OutFile);
}
lexit_ (&UserRes); return (int)UserRes; }