HPF Livermore Loop 18 Kernel
Generated Code
(Explicit Hydrodynamics)
program liv18
parameter (n = 1024)
double precision t, s
double precision time, dclock, tbuf(1), sum
CHPF$ processors p (4, 8)
CHPF$ template templ (n, n)
CHPF$ align za (i, j) with templ(i, j)
CHPF$ align zr (i, j) with templ(i, j)
CHPF$ align zb (i, j) with templ(i, j)
CHPF$ align zu (i, j) with templ(i, j)
CHPF$ align zz (i, j) with templ(i, j)
CHPF$ align zv (i, j) with templ(i, j)
CHPF$ align zq (i, j) with templ(i, j)
CHPF$ align zm (i, j) with templ(i, j)
CHPF$ align zp (i, j) with templ(i, j)
CHPF$ distribute templ(block, block) onto p
C --------------------------------------------------------------
C declarations for heap-based runtime dynamic storage allocation
C --------------------------------------------------------------
common /hpf$heap$common/ hpf$heap
dimension hpf$heap$integer(0:0)
equivalence (hpf$heap$integer(0), hpf$heap)
dimension hpf$heap$double(0:0)
equivalence (hpf$heap$double(0), hpf$heap)
#include
integer status(MPI_STATUS_SIZE)
C -----------------------------------------------
C declarations for compiler-generated temporaries
C -----------------------------------------------
external hpf_arrayrtd_get_lextent, hpf_arrayrtd_get_gextent
save za, zb, zm, zp, zq, zr, zu, zv, zz
logical p$wrap
integer counter$zp$814, send$buf$zp$814$index, i1, i2, p$q1
integer p$q2, counter$zq$815, send$buf$zq$815$index
integer counter$zr$816, send$buf$zr$816$index, counter$zm$817
integer send$buf$zm$817$index, counter$zp$818
integer send$buf$zp$818$index, counter$zq$819
integer send$buf$zq$819$index, counter$zr$833
integer send$buf$zr$833$index, counter$zm$821
integer send$buf$zm$821$index, counter$zz$822
integer send$buf$zz$822$index, counter$zz$824
integer send$buf$zz$824$index, counter$zz$825
integer send$buf$zz$825$index, counter$zz$827
integer send$buf$zz$827$index, counter$zr$828
integer send$buf$zr$828$index, counter$zr$830
integer send$buf$zr$830$index, counter$zr$834
integer send$buf$zr$834$index, recv$buf$zp$814$index
integer recv$buf$zq$815$index, recv$buf$zr$816$index
integer recv$buf$zm$817$index, recv$buf$zp$818$index
integer recv$buf$zq$819$index, recv$buf$zr$833$index
integer recv$buf$zm$821$index, recv$buf$zr$828$index
integer recv$buf$zr$830$index, recv$buf$zr$834$index
integer counter$za$813, send$buf$za$813$index
integer recv$buf$za$813$index, counter$za$835
integer send$buf$za$835$index, counter$zb$836
integer send$buf$zb$836$index, recv$buf$zz$822$index
integer recv$buf$zz$824$index, recv$buf$zz$825$index
integer recv$buf$zz$827$index, recv$buf$za$835$index
integer recv$buf$zb$836$index, za$coord$0, za$coord$1
integer hpf_arrayrtd_get_lextent, hpf_arrayrtd_get_gextent
integer za$local$extent$0, za$global$extent$0, zb$coord$0
integer zb$coord$1, zb$local$extent$0, zb$global$extent$0
integer zm$coord$0, zm$coord$1, zm$local$extent$0
integer zm$global$extent$0, zp$coord$0, zp$coord$1
integer zp$local$extent$0, zp$global$extent$0, zq$coord$0
integer zq$coord$1, zq$local$extent$0, zq$global$extent$0
integer zr$coord$0, zr$coord$1, zr$local$extent$0
integer zr$global$extent$0, zu$coord$0, zu$coord$1
integer zu$local$extent$0, zu$global$extent$0, zv$coord$0
integer zv$coord$1, zv$local$extent$0, zv$global$extent$0
integer zz$coord$0, zz$coord$1, zz$local$extent$0
integer zz$global$extent$0, p$myid1, p$myid2
integer hpf$heap$integer, p$cmap, p$dims, sendproc, recvproc
integer myid, ierr, request, n, i, j, k
integer*4 za$data, za$coord, zb$data, zb$coord, zm$data
integer*4 zm$coord, zp$data, zp$coord, zq$data, zq$coord
integer*4 zr$data, zr$coord, zu$data, zu$coord, zv$data
integer*4 zv$coord, zz$data, zz$coord, p$coord
real*8 hpf$heap$double, lnltmp1, lnltmp2, lnltmp3
real*8 hpf_nonlocal_lookupd, lnltmp4, lnltmp5, lnltmp6
real*8 lnltmp7, lnltmp8, lnltmp9, lnltmp10, lnltmp11
real*8 lnltmp12, lnltmp13, lnltmp14, lnltmp15, lnltmp16
real*8 lnltmp17, lnltmp18, lnltmp19, lnltmp20, lnltmp21
real*8 lnltmp22, lnltmp23, lnltmp24, lnltmp25, lnltmp26
real*8 lnltmp27, lnltmp28, lnltmp29, lnltmp30, lnltmp31
real*8 lnltmp32, lnltmp33, lnltmp34, lnltmp35, lnltmp36
real*8 lnltmp37, lnltmp38, lnltmp39, lnltmp40, lnltmp41
real*8 lnltmp42, lnltmp43, lnltmp44, lnltmp45, lnltmp46
real*8 lnltmp47, lnltmp48, lnltmp49, lnltmp50, lnltmp51
real*8 lnltmp52, lnltmp53, lnltmp54, lnltmp55, lnltmp56
real*8 lnltmp57, lnltmp58, lnltmp59, lnltmp60, lnltmp61
real*8 lnltmp62, lnltmp63, lnltmp64, lnltmp65, lnltmp66
real*8 lnltmp67, lnltmp68, lnltmp69, lnltmp70, lnltmp71
real*8 lnltmp72, lnltmp73, lnltmp74, lnltmp75, lnltmp76
real*8 lnltmp77, lnltmp78, lnltmp79, lnltmp80, lnltmp81
real*8 lnltmp82, lnltmp83, lnltmp84, lnltmp85, lnltmp86
real*8 lnltmp87, lnltmp88, lnltmp89, lnltmp90, za, zb, zm
real*8 zp, zq, zr, zu, zv, zz, hpf$heap
integer*4 hash$nonlocals, send$buf$zp$814, send$buf$zq$815
integer*4 send$buf$zr$816, send$buf$zm$817, send$buf$zp$818
integer*4 send$buf$zq$819, send$buf$zr$833, send$buf$zm$821
integer*4 send$buf$zz$822, send$buf$zz$824, send$buf$zz$825
integer*4 send$buf$zz$827, send$buf$zr$828, send$buf$zr$830
integer*4 send$buf$zr$834, recv$buf$zp$814, recv$buf$zq$815
integer*4 recv$buf$zr$816, recv$buf$zm$817, recv$buf$zp$818
integer*4 recv$buf$zq$819, recv$buf$zr$833, recv$buf$zm$821
integer*4 recv$buf$zr$828, recv$buf$zr$830, recv$buf$zr$834
integer*4 send$buf$za$813, recv$buf$za$813, send$buf$za$835
integer*4 send$buf$zb$836, recv$buf$zz$822, recv$buf$zz$824
integer*4 recv$buf$zz$825, recv$buf$zz$827, recv$buf$za$835
integer*4 recv$buf$zb$836, za$align, za$dist, za$tmpl, za$proc
integer*4 za$align$new, za$dist$new, za$tmpl$new, za$proc$new
integer*4 za$desc, zb$align, zb$dist, zb$tmpl, zb$proc
integer*4 zb$align$new, zb$dist$new, zb$tmpl$new, zb$proc$new
integer*4 zb$desc, zm$align, zm$dist, zm$tmpl, zm$proc
integer*4 zm$align$new, zm$dist$new, zm$tmpl$new, zm$proc$new
integer*4 zm$desc, zp$align, zp$dist, zp$tmpl, zp$proc
integer*4 zp$align$new, zp$dist$new, zp$tmpl$new, zp$proc$new
integer*4 zp$desc, zq$align, zq$dist, zq$tmpl, zq$proc
integer*4 zq$align$new, zq$dist$new, zq$tmpl$new, zq$proc$new
integer*4 zq$desc, zr$align, zr$dist, zr$tmpl, zr$proc
integer*4 zr$align$new, zr$dist$new, zr$tmpl$new, zr$proc$new
integer*4 zr$desc, zu$align, zu$dist, zu$tmpl, zu$proc
integer*4 zu$align$new, zu$dist$new, zu$tmpl$new, zu$proc$new
integer*4 zu$desc, zv$align, zv$dist, zv$tmpl, zv$proc
integer*4 zv$align$new, zv$dist$new, zv$tmpl$new, zv$proc$new
integer*4 zv$desc, zz$align, zz$dist, zz$tmpl, zz$proc
integer*4 zz$align$new, zz$dist$new, zz$tmpl$new, zz$proc$new
integer*4 zz$desc, templ$template, templ$proc, templ$dist
integer*4 p$processors
dimension za(0:0), zb(0:0), zm(0:0), zp(0:0), zq(0:0), zr(0:0)
dimension zu(0:0), zv(0:0), zz(0:0), p$dims(1:2), p$wrap(1:2)
C
C
C -----------------------------
C runtime system initialization
C -----------------------------
call mpi_init(ierr)
call mpi_comm_rank(MPI_COMM_WORLD, myid, ierr)
C -----------------------------------------------
C initializations for run-time descriptor indices
C -----------------------------------------------
za$align$new = 0
za$align = 0
zr$align$new = 0
zr$align = 0
zb$align$new = 0
zb$align = 0
zu$align$new = 0
zu$align = 0
zz$align$new = 0
zz$align = 0
zv$align$new = 0
zv$align = 0
zq$align$new = 0
zq$align = 0
zm$align$new = 0
zm$align = 0
zp$align$new = 0
zp$align = 0
templ$dist = 0
za$dist$new = 0
za$dist = 0
zb$dist$new = 0
zb$dist = 0
zm$dist$new = 0
zm$dist = 0
zp$dist$new = 0
zp$dist = 0
zq$dist$new = 0
zq$dist = 0
zr$dist$new = 0
zr$dist = 0
zu$dist$new = 0
zu$dist = 0
zv$dist$new = 0
zv$dist = 0
zz$dist$new = 0
zz$dist = 0
za$desc = 0
zr$desc = 0
zb$desc = 0
zu$desc = 0
zz$desc = 0
zv$desc = 0
zq$desc = 0
zm$desc = 0
zp$desc = 0
C
C
C --------------------------------------
C building array descriptor for array za
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, za$desc)
call hpf_arrayrtd_setdim(za$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(za$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zr
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zr$desc)
call hpf_arrayrtd_setdim(zr$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zr$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zb
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zb$desc)
call hpf_arrayrtd_setdim(zb$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zb$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zu
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zu$desc)
call hpf_arrayrtd_setdim(zu$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zu$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zz
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zz$desc)
call hpf_arrayrtd_setdim(zz$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zz$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zv
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zv$desc)
call hpf_arrayrtd_setdim(zv$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zv$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zq
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zq$desc)
call hpf_arrayrtd_setdim(zq$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zq$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zm
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zm$desc)
call hpf_arrayrtd_setdim(zm$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zm$desc, 1, 1, 1024)
C
C --------------------------------------
C building array descriptor for array zp
C --------------------------------------
call hpf_arrayrtd_alloc(2, 2, zp$desc)
call hpf_arrayrtd_setdim(zp$desc, 0, 1, 1024)
call hpf_arrayrtd_setdim(zp$desc, 1, 1, 1024)
C
C ----------------------------------------
C building tmpl descriptor: template templ
C ----------------------------------------
call hpf_tmplrtd_alloc(2, templ$template)
call hpf_tmplrtd_setdim(templ$template, 0, 1, 1024)
call hpf_tmplrtd_setdim(templ$template, 1, 1, 1024)
C
C ---------------------------------------
C building procs descriptor: processors p
C ---------------------------------------
call hpf_procrtd_alloc(2, p$processors)
call hpf_procrtd_setdim(p$processors, 0, 1, 4)
call hpf_procrtd_setdim(p$processors, 1, 1, 8)
C
C ----------------------------------------------------
C initialize processor topology for processors array p
C ----------------------------------------------------
p$dims(1) = 4
p$wrap(1) = .false.
p$dims(2) = 8
p$wrap(2) = .false.
call mpi_cart_create(MPI_COMM_WORLD, 2, p$dims, p$wrap, .false.,
* p$cmap, ierr)
call hpf_procrtd_get_coords(hpf$heap, p$processors, p$coord)
call mpi_cart_coords(p$cmap, myid, 2, hpf$heap$integer(p$coord),
* ierr)
p$myid1 = hpf$heap$integer(p$coord + 0)
p$myid2 = hpf$heap$integer(p$coord + 1)
call hpf_procrtd_set_chandle(p$processors, p$cmap)
C
C ---------------------------------------------------
C building dist descriptor: distribute template templ
C ---------------------------------------------------
call hpf_distrtd_alloc(2, templ$dist)
call hpf_distrtd_setdim(templ$dist, 0, -1, 256, 0)
call hpf_distrtd_setdim(templ$dist, 1, -1, 128, 1)
templ$proc = p$processors
C
C ---------------------------------------------
C building dist descriptor: distribute array za
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, za$dist$new)
za$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zb
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zb$dist$new)
zb$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zm
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zm$dist$new)
zm$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zp
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zp$dist$new)
zp$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zq
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zq$dist$new)
zq$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zr
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zr$dist$new)
zr$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zu
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zu$dist$new)
zu$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zv
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zv$dist$new)
zv$proc$new = templ$proc
C
C ---------------------------------------------
C building dist descriptor: distribute array zz
C ---------------------------------------------
call hpf_distrtd_clone(templ$dist, zz$dist$new)
zz$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zp with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zp$align$new)
call hpf_alignrtd_setdim_src(zp$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zp$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zp$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zp$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zp with templ
C -----------------------------------------------------------------
zp$tmpl$new = templ$template
zp$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zm with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zm$align$new)
call hpf_alignrtd_setdim_src(zm$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zm$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zm$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zm$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zm with templ
C -----------------------------------------------------------------
zm$tmpl$new = templ$template
zm$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zq with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zq$align$new)
call hpf_alignrtd_setdim_src(zq$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zq$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zq$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zq$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zq with templ
C -----------------------------------------------------------------
zq$tmpl$new = templ$template
zq$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zv with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zv$align$new)
call hpf_alignrtd_setdim_src(zv$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zv$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zv$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zv$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zv with templ
C -----------------------------------------------------------------
zv$tmpl$new = templ$template
zv$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zz with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zz$align$new)
call hpf_alignrtd_setdim_src(zz$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zz$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zz$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zz$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zz with templ
C -----------------------------------------------------------------
zz$tmpl$new = templ$template
zz$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zu with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zu$align$new)
call hpf_alignrtd_setdim_src(zu$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zu$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zu$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zu$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zu with templ
C -----------------------------------------------------------------
zu$tmpl$new = templ$template
zu$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zb with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zb$align$new)
call hpf_alignrtd_setdim_src(zb$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zb$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zb$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zb$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zb with templ
C -----------------------------------------------------------------
zb$tmpl$new = templ$template
zb$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align zr with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, zr$align$new)
call hpf_alignrtd_setdim_src(zr$align$new, 0, 0)
call hpf_alignrtd_setdim_src(zr$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(zr$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(zr$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align zr with templ
C -----------------------------------------------------------------
zr$tmpl$new = templ$template
zr$proc$new = templ$proc
C
C ----------------------------------------------
C building align descriptor: align za with templ
C ----------------------------------------------
call hpf_alignrtd_alloc(2, 2, za$align$new)
call hpf_alignrtd_setdim_src(za$align$new, 0, 0)
call hpf_alignrtd_setdim_src(za$align$new, 1, 1)
call hpf_alignrtd_setdim_tmpl(za$align$new, 0, 0, 1, 0, 0)
call hpf_alignrtd_setdim_tmpl(za$align$new, 1, 1, 1, 0, 0)
C
C -----------------------------------------------------------------
C establish template and processor association: align za with templ
C -----------------------------------------------------------------
za$tmpl$new = templ$template
za$proc$new = templ$proc
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array za; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(za, za$align, za$dist, za$tmpl, za$proc, za
*$align$new, za$dist$new, za$tmpl$new, za$proc$new, za$desc, za$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, za$desc, za$coord)
za$coord$0 = hpf$heap$integer(za$coord + 0)
za$coord$1 = hpf$heap$integer(za$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array za
C ------------------------------------------------------------------
za$local$extent$0 = hpf_arrayrtd_get_lextent(za$desc, 0)
za$global$extent$0 = hpf_arrayrtd_get_gextent(za$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zb; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zb, zb$align, zb$dist, zb$tmpl, zb$proc, zb
*$align$new, zb$dist$new, zb$tmpl$new, zb$proc$new, zb$desc, zb$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zb$desc, zb$coord)
zb$coord$0 = hpf$heap$integer(zb$coord + 0)
zb$coord$1 = hpf$heap$integer(zb$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zb
C ------------------------------------------------------------------
zb$local$extent$0 = hpf_arrayrtd_get_lextent(zb$desc, 0)
zb$global$extent$0 = hpf_arrayrtd_get_gextent(zb$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zm; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zm, zm$align, zm$dist, zm$tmpl, zm$proc, zm
*$align$new, zm$dist$new, zm$tmpl$new, zm$proc$new, zm$desc, zm$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zm$desc, zm$coord)
zm$coord$0 = hpf$heap$integer(zm$coord + 0)
zm$coord$1 = hpf$heap$integer(zm$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zm
C ------------------------------------------------------------------
zm$local$extent$0 = hpf_arrayrtd_get_lextent(zm$desc, 0)
zm$global$extent$0 = hpf_arrayrtd_get_gextent(zm$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zp; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zp, zp$align, zp$dist, zp$tmpl, zp$proc, zp
*$align$new, zp$dist$new, zp$tmpl$new, zp$proc$new, zp$desc, zp$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zp$desc, zp$coord)
zp$coord$0 = hpf$heap$integer(zp$coord + 0)
zp$coord$1 = hpf$heap$integer(zp$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zp
C ------------------------------------------------------------------
zp$local$extent$0 = hpf_arrayrtd_get_lextent(zp$desc, 0)
zp$global$extent$0 = hpf_arrayrtd_get_gextent(zp$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zq; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zq, zq$align, zq$dist, zq$tmpl, zq$proc, zq
*$align$new, zq$dist$new, zq$tmpl$new, zq$proc$new, zq$desc, zq$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zq$desc, zq$coord)
zq$coord$0 = hpf$heap$integer(zq$coord + 0)
zq$coord$1 = hpf$heap$integer(zq$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zq
C ------------------------------------------------------------------
zq$local$extent$0 = hpf_arrayrtd_get_lextent(zq$desc, 0)
zq$global$extent$0 = hpf_arrayrtd_get_gextent(zq$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zr; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zr, zr$align, zr$dist, zr$tmpl, zr$proc, zr
*$align$new, zr$dist$new, zr$tmpl$new, zr$proc$new, zr$desc, zr$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zr$desc, zr$coord)
zr$coord$0 = hpf$heap$integer(zr$coord + 0)
zr$coord$1 = hpf$heap$integer(zr$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zr
C ------------------------------------------------------------------
zr$local$extent$0 = hpf_arrayrtd_get_lextent(zr$desc, 0)
zr$global$extent$0 = hpf_arrayrtd_get_gextent(zr$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zu; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zu, zu$align, zu$dist, zu$tmpl, zu$proc, zu
*$align$new, zu$dist$new, zu$tmpl$new, zu$proc$new, zu$desc, zu$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zu$desc, zu$coord)
zu$coord$0 = hpf$heap$integer(zu$coord + 0)
zu$coord$1 = hpf$heap$integer(zu$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zu
C ------------------------------------------------------------------
zu$local$extent$0 = hpf_arrayrtd_get_lextent(zu$desc, 0)
zu$global$extent$0 = hpf_arrayrtd_get_gextent(zu$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zv; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zv, zv$align, zv$dist, zv$tmpl, zv$proc, zv
*$align$new, zv$dist$new, zv$tmpl$new, zv$proc$new, zv$desc, zv$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zv$desc, zv$coord)
zv$coord$0 = hpf$heap$integer(zv$coord + 0)
zv$coord$1 = hpf$heap$integer(zv$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zv
C ------------------------------------------------------------------
zv$local$extent$0 = hpf_arrayrtd_get_lextent(zv$desc, 0)
zv$global$extent$0 = hpf_arrayrtd_get_gextent(zv$desc, 0)
C
C ------------------------------------------------------------------------
C-
C allocate or redistribute array zz; compute array-indexed processor coord
Cs
C ------------------------------------------------------------------------
C-
call hpf_array_remap(zz, zz$align, zz$dist, zz$tmpl, zz$proc, zz
*$align$new, zz$dist$new, zz$tmpl$new, zz$proc$new, zz$desc, zz$dat
*a)
C
C -----------------------------------------------------------------------
C map array-indexed processor coordinates to partitioned array dimensions
C -----------------------------------------------------------------------
call hpf_arrayrtd_get_coords(hpf$heap, zz$desc, zz$coord)
zz$coord$0 = hpf$heap$integer(zz$coord + 0)
zz$coord$1 = hpf$heap$integer(zz$coord + 1)
C
C ------------------------------------------------------------------
C initializing scalar extent vars used for linearization of array zz
C ------------------------------------------------------------------
zz$local$extent$0 = hpf_arrayrtd_get_lextent(zz$desc, 0)
zz$global$extent$0 = hpf_arrayrtd_get_gextent(zz$desc, 0)
C
call hpf_nonlocals_alloc(hash$nonlocals)
C
C --<< Iterations that access only local values >>--
C
C
C Loop section ---[ ((256 * p$myid1) + 1) <= j <= ((256 * p$myid1) + 256),
C ((128 * p$myid2) + 1) <= i <= ((128 * p$myid2) + 128) ]---
C
do i = 128 * p$myid2 + 1, 128 * p$myid2 + 128
do j = 256 * p$myid1 + 1, 256 * p$myid1 + 256
za(za$data + j - (za$coord$0 * 256 + 1) + (i - (za$coord$1 *
* 128 + 1)) * za$local$extent$0) = 1.0
zb(zb$data + j - (zb$coord$0 * 256 + 1) + (i - (zb$coord$1 *
* 128 + 1)) * zb$local$extent$0) = 2.0
zu(zu$data + j - (zu$coord$0 * 256 + 1) + (i - (zu$coord$1 *
* 128 + 1)) * zu$local$extent$0) = 3.0
zv(zv$data + j - (zv$coord$0 * 256 + 1) + (i - (zv$coord$1 *
* 128 + 1)) * zv$local$extent$0) = 4.0
zr(zr$data + j - (zr$coord$0 * 256 + 1) + (i - (zr$coord$1 *
* 128 + 1)) * zr$local$extent$0) = 5.0
zp(zp$data + j - (zp$coord$0 * 256 + 1) + (i - (zp$coord$1 *
* 128 + 1)) * zp$local$extent$0) = 6.0
zm(zm$data + j - (zm$coord$0 * 256 + 1) + (i - (zm$coord$1 *
* 128 + 1)) * zm$local$extent$0) = 7.0
zq(zq$data + j - (zq$coord$0 * 256 + 1) + (i - (zq$coord$1 *
* 128 + 1)) * zq$local$extent$0) = 8.0
zz(zz$data + j - (zz$coord$0 * 256 + 1) + (i - (zz$coord$1 *
* 128 + 1)) * zz$local$extent$0) = 9.0
enddo
enddo
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zp$814 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2 .and. 256 * p$myid1 + 1 .le. min(256 * p$myid1 + 2
*56, 1022) .and. max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3) .le. min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)) then
counter$zp$814 = counter$zp$814 + (min(256 * p$myid1 + 2
*56, 1022) - (256 * p$myid1 + 1) + 1) * (min(128 * p$q2 + 129, 128
** p$myid2 + 128) - max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3) + 1)
endif
call hpf_buffer_alloc(counter$zp$814 * 8, send$buf$zp$814)
call hpf_ptr_to_index(hpf$heap, send$buf$zp$814, 8, send$b
*uf$zp$814$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zp$814 = 0
C
C Loop section ---[ max(((128 * p$q2) + 2), ((128 * p$myid2) + 1), 3
C) <= i2 <= min(((128 * p$q2) + 129), ((128 * p$myid2) + 128)), ((256 * p$myid1)
C + 1) <= i1 <= min(((256 * p$myid1) + 256), 1022) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2) then
do i1 = 256 * p$myid1 + 1, min(256 * p$myid1 + 256, 1022
*)
do i2 = max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3), min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)
hpf$heap$double(send$buf$zp$814$index + counter$zp$8
*14) = zp(zp$data + i1 - (zp$coord$0 * 256 + 1) + (i2 - (zp$coord$1
* * 128 + 1)) * zp$local$extent$0)
counter$zp$814 = counter$zp$814 + 1
enddo
enddo
endif
if (counter$zp$814 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zp$814$index), co
*unter$zp$814, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 1, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zp$814)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zq$815 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2 .and. 256 * p$myid1 + 1 .le. min(256 * p$myid1 + 2
*56, 1022) .and. max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3) .le. min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)) then
counter$zq$815 = counter$zq$815 + (min(256 * p$myid1 + 2
*56, 1022) - (256 * p$myid1 + 1) + 1) * (min(128 * p$q2 + 129, 128
** p$myid2 + 128) - max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3) + 1)
endif
call hpf_buffer_alloc(counter$zq$815 * 8, send$buf$zq$815)
call hpf_ptr_to_index(hpf$heap, send$buf$zq$815, 8, send$b
*uf$zq$815$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zq$815 = 0
C
C Loop section ---[ max(((128 * p$q2) + 2), ((128 * p$myid2) + 1), 3
C) <= i2 <= min(((128 * p$q2) + 129), ((128 * p$myid2) + 128)), ((256 * p$myid1)
C + 1) <= i1 <= min(((256 * p$myid1) + 256), 1022) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2) then
do i1 = 256 * p$myid1 + 1, min(256 * p$myid1 + 256, 1022
*)
do i2 = max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3), min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)
hpf$heap$double(send$buf$zq$815$index + counter$zq$8
*15) = zq(zq$data + i1 - (zq$coord$0 * 256 + 1) + (i2 - (zq$coord$1
* * 128 + 1)) * zq$local$extent$0)
counter$zq$815 = counter$zq$815 + 1
enddo
enddo
endif
if (counter$zq$815 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zq$815$index), co
*unter$zq$815, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 2, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zq$815)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$816 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1 + 2) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 257, 1023) .an
*d. max(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023))
*then
counter$zr$816 = counter$zr$816 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 257, 1023) - max(256 * p$myid1 + 1, 256 * p$q1 +
*2) + 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1,
* 2) + 1)
endif
call hpf_buffer_alloc(counter$zr$816 * 8, send$buf$zr$816)
call hpf_ptr_to_index(hpf$heap, send$buf$zr$816, 8, send$b
*uf$zr$816$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zr$816 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$myid1) + 1), ((256 * p$q1) + 2)) <= i1
C <= min(((256 * p$myid1) + 256), ((256 * p$q1) + 257), 1023) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1 + 2), min(256
** p$myid1 + 256, 256 * p$q1 + 257, 1023)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zr$816$index + counter$zr$8
*16) = zr(zr$data + i1 - (zr$coord$0 * 256 + 1) + (i2 - (zr$coord$1
* * 128 + 1)) * zr$local$extent$0)
counter$zr$816 = counter$zr$816 + 1
enddo
enddo
endif
if (counter$zr$816 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zr$816$index), co
*unter$zr$816, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 3, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zr$816)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zm$817 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2 .and. 256 * p$myid1 + 1 .le. min(256 * p$myid1 + 2
*56, 1022) .and. max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3) .le. min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)) then
counter$zm$817 = counter$zm$817 + (min(256 * p$myid1 + 2
*56, 1022) - (256 * p$myid1 + 1) + 1) * (min(128 * p$q2 + 129, 128
** p$myid2 + 128) - max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3) + 1)
endif
call hpf_buffer_alloc(counter$zm$817 * 8, send$buf$zm$817)
call hpf_ptr_to_index(hpf$heap, send$buf$zm$817, 8, send$b
*uf$zm$817$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zm$817 = 0
C
C Loop section ---[ max(((128 * p$q2) + 2), ((128 * p$myid2) + 1), 3
C) <= i2 <= min(((128 * p$q2) + 129), ((128 * p$myid2) + 128)), ((256 * p$myid1)
C + 1) <= i1 <= min(((256 * p$myid1) + 256), 1022) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2) then
do i1 = 256 * p$myid1 + 1, min(256 * p$myid1 + 256, 1022
*)
do i2 = max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3), min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)
hpf$heap$double(send$buf$zm$817$index + counter$zm$8
*17) = zm(zm$data + i1 - (zm$coord$0 * 256 + 1) + (i2 - (zm$coord$1
* * 128 + 1)) * zm$local$extent$0)
counter$zm$817 = counter$zm$817 + 1
enddo
enddo
endif
if (counter$zm$817 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zm$817$index), co
*unter$zm$817, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 4, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zm$817)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zp$818 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 255, 1022) .and. m
*ax(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023)) then
counter$zp$818 = counter$zp$818 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 255, 1022) - max(256 * p$myid1 + 1, 256 * p$q1) +
* 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1, 2)
*+ 1)
endif
call hpf_buffer_alloc(counter$zp$818 * 8, send$buf$zp$818)
call hpf_ptr_to_index(hpf$heap, send$buf$zp$818, 8, send$b
*uf$zp$818$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zp$818 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$myid1) + 1), (256 * p$q1)) <= i1 <= mi
Cn(((256 * p$myid1) + 256), ((256 * p$q1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1), min(256 * p$
*myid1 + 256, 256 * p$q1 + 255, 1022)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zp$818$index + counter$zp$8
*18) = zp(zp$data + i1 - (zp$coord$0 * 256 + 1) + (i2 - (zp$coord$1
* * 128 + 1)) * zp$local$extent$0)
counter$zp$818 = counter$zp$818 + 1
enddo
enddo
endif
if (counter$zp$818 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zp$818$index), co
*unter$zp$818, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 5, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zp$818)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zq$819 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 255, 1022) .and. m
*ax(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023)) then
counter$zq$819 = counter$zq$819 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 255, 1022) - max(256 * p$myid1 + 1, 256 * p$q1) +
* 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1, 2)
*+ 1)
endif
call hpf_buffer_alloc(counter$zq$819 * 8, send$buf$zq$819)
call hpf_ptr_to_index(hpf$heap, send$buf$zq$819, 8, send$b
*uf$zq$819$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zq$819 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$myid1) + 1), (256 * p$q1)) <= i1 <= mi
Cn(((256 * p$myid1) + 256), ((256 * p$q1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1), min(256 * p$
*myid1 + 256, 256 * p$q1 + 255, 1022)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zq$819$index + counter$zq$8
*19) = zq(zq$data + i1 - (zq$coord$0 * 256 + 1) + (i2 - (zq$coord$1
* * 128 + 1)) * zq$local$extent$0)
counter$zq$819 = counter$zq$819 + 1
enddo
enddo
endif
if (counter$zq$819 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zq$819$index), co
*unter$zq$819, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 6, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zq$819)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$833 = 0
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. 1 + p$q2 .and. p$
*q2 .le. p$myid2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3)
*.le. min(128 * p$q2 + 129, 128 * p$myid2 + 128)) then
counter$zr$833 = counter$zr$833 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$q2 + 129
*, 128 * p$myid2 + 128) - max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3)
* + 1)
endif
call hpf_buffer_alloc(counter$zr$833 * 8, send$buf$zr$833)
call hpf_ptr_to_index(hpf$heap, send$buf$zr$833, 8, send$b
*uf$zr$833$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zr$833 = 0
C
C Loop section ---[ max(((128 * p$q2) + 2), ((128 * p$myid2) + 1), 3
C) <= i2 <= min(((128 * p$q2) + 129), ((128 * p$myid2) + 128)), max(((256 * p$my
Cid1) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. 1 + p$q2 .and. p$
*q2 .le. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3), min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)
hpf$heap$double(send$buf$zr$833$index + counter$zr$8
*33) = zr(zr$data + i1 - (zr$coord$0 * 256 + 1) + (i2 - (zr$coord$1
* * 128 + 1)) * zr$local$extent$0)
counter$zr$833 = counter$zr$833 + 1
enddo
enddo
endif
if (counter$zr$833 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zr$833$index), co
*unter$zr$833, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 7, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zr$833)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zm$821 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 255, 1022) .and. m
*ax(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023)) then
counter$zm$821 = counter$zm$821 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 255, 1022) - max(256 * p$myid1 + 1, 256 * p$q1) +
* 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1, 2)
*+ 1)
endif
call hpf_buffer_alloc(counter$zm$821 * 8, send$buf$zm$821)
call hpf_ptr_to_index(hpf$heap, send$buf$zm$821, 8, send$b
*uf$zm$821$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zm$821 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$myid1) + 1), (256 * p$q1)) <= i1 <= mi
Cn(((256 * p$myid1) + 256), ((256 * p$q1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1), min(256 * p$
*myid1 + 256, 256 * p$q1 + 255, 1022)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zm$821$index + counter$zm$8
*21) = zm(zm$data + i1 - (zm$coord$0 * 256 + 1) + (i2 - (zm$coord$1
* * 128 + 1)) * zm$local$extent$0)
counter$zm$821 = counter$zm$821 + 1
enddo
enddo
endif
if (counter$zm$821 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zm$821$index), co
*unter$zm$821, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 8, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zm$821)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$822 = 0
if (p$q2 .eq. p$myid2 .and. max(64 * p$q1 + 3, 256 * p$myi
*d1 + 1, 256 * p$q1 + 2) .le. min(256 * p$myid1 + 256, 256 * p$q1 +
* 257) .and. max(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128
*, 1023)) then
counter$zz$822 = counter$zz$822 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 257) - max(64 * p$q1 + 3, 256 * p$myid1 + 1, 256
** p$q1 + 2) + 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$m
*yid2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zz$822 * 8, send$buf$zz$822)
call hpf_ptr_to_index(hpf$heap, send$buf$zz$822, 8, send$b
*uf$zz$822$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zz$822 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((64 * p$q1) + 3), ((256 * p$myid1) + 1), ((256
C* p$q1) + 2)) <= i1 <= min(((256 * p$myid1) + 256), ((256 * p$q1) + 257)) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(64 * p$q1 + 3, 256 * p$myid1 + 1, 256 * p$q1
* + 2), min(256 * p$myid1 + 256, 256 * p$q1 + 257)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zz$822$index + counter$zz$8
*22) = zz(zz$data + i1 - (zz$coord$0 * 256 + 1) + (i2 - (zz$coord$1
* * 128 + 1)) * zz$local$extent$0)
counter$zz$822 = counter$zz$822 + 1
enddo
enddo
endif
if (counter$zz$822 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zz$822$index), co
*unter$zz$822, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 9, p$cmap, re
*quest, ierr)
endif
call hpf_buffer_free(send$buf$zz$822)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$824 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 255, 1022) .and. m
*ax(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023)) then
counter$zz$824 = counter$zz$824 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 255, 1022) - max(256 * p$myid1 + 1, 256 * p$q1) +
* 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1, 2)
*+ 1)
endif
call hpf_buffer_alloc(counter$zz$824 * 8, send$buf$zz$824)
call hpf_ptr_to_index(hpf$heap, send$buf$zz$824, 8, send$b
*uf$zz$824$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zz$824 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$myid1) + 1), (256 * p$q1)) <= i1 <= mi
Cn(((256 * p$myid1) + 256), ((256 * p$q1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1), min(256 * p$
*myid1 + 256, 256 * p$q1 + 255, 1022)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zz$824$index + counter$zz$8
*24) = zz(zz$data + i1 - (zz$coord$0 * 256 + 1) + (i2 - (zz$coord$1
* * 128 + 1)) * zz$local$extent$0)
counter$zz$824 = counter$zz$824 + 1
enddo
enddo
endif
if (counter$zz$824 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zz$824$index), co
*unter$zz$824, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 10, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$zz$824)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$825 = 0
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. p$q2 .and. p$q2 .
*le. 1 + p$myid2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$q2, 128 * p$myid2 + 1) .le. mi
*n(128 * p$q2 + 127, 128 * p$myid2 + 128, 1022)) then
counter$zz$825 = counter$zz$825 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$q2 + 127
*, 128 * p$myid2 + 128, 1022) - max(128 * p$q2, 128 * p$myid2 + 1)
*+ 1)
endif
call hpf_buffer_alloc(counter$zz$825 * 8, send$buf$zz$825)
call hpf_ptr_to_index(hpf$heap, send$buf$zz$825, 8, send$b
*uf$zz$825$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zz$825 = 0
C
C Loop section ---[ max((128 * p$q2), ((128 * p$myid2) + 1)) <= i2 <
C= min(((128 * p$q2) + 127), ((128 * p$myid2) + 128), 1022), max(((256 * p$myid1
C) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. p$q2 .and. p$q2 .
*le. 1 + p$myid2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$q2, 128 * p$myid2 + 1), min(128 *
*p$q2 + 127, 128 * p$myid2 + 128, 1022)
hpf$heap$double(send$buf$zz$825$index + counter$zz$8
*25) = zz(zz$data + i1 - (zz$coord$0 * 256 + 1) + (i2 - (zz$coord$1
* * 128 + 1)) * zz$local$extent$0)
counter$zz$825 = counter$zz$825 + 1
enddo
enddo
endif
if (counter$zz$825 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zz$825$index), co
*unter$zz$825, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 11, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$zz$825)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$827 = 0
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. 1 + p$q2 .and. p$
*q2 .le. p$myid2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3)
*.le. min(128 * p$q2 + 129, 128 * p$myid2 + 128)) then
counter$zz$827 = counter$zz$827 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$q2 + 129
*, 128 * p$myid2 + 128) - max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3)
* + 1)
endif
call hpf_buffer_alloc(counter$zz$827 * 8, send$buf$zz$827)
call hpf_ptr_to_index(hpf$heap, send$buf$zz$827, 8, send$b
*uf$zz$827$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zz$827 = 0
C
C Loop section ---[ max(((128 * p$q2) + 2), ((128 * p$myid2) + 1), 3
C) <= i2 <= min(((128 * p$q2) + 129), ((128 * p$myid2) + 128)), max(((256 * p$my
Cid1) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. 1 + p$q2 .and. p$
*q2 .le. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3), min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)
hpf$heap$double(send$buf$zz$827$index + counter$zz$8
*27) = zz(zz$data + i1 - (zz$coord$0 * 256 + 1) + (i2 - (zz$coord$1
* * 128 + 1)) * zz$local$extent$0)
counter$zz$827 = counter$zz$827 + 1
enddo
enddo
endif
if (counter$zz$827 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zz$827$index), co
*unter$zz$827, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 12, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$zz$827)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$828 = 0
if (p$q2 .eq. p$myid2 .and. max(64 * p$q1 + 3, 256 * p$myi
*d1 + 1, 256 * p$q1 + 2) .le. min(256 * p$myid1 + 256, 256 * p$q1 +
* 257) .and. max(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128
*, 1023)) then
counter$zr$828 = counter$zr$828 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 257) - max(64 * p$q1 + 3, 256 * p$myid1 + 1, 256
** p$q1 + 2) + 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$m
*yid2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zr$828 * 8, send$buf$zr$828)
call hpf_ptr_to_index(hpf$heap, send$buf$zr$828, 8, send$b
*uf$zr$828$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zr$828 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((64 * p$q1) + 3), ((256 * p$myid1) + 1), ((256
C* p$q1) + 2)) <= i1 <= min(((256 * p$myid1) + 256), ((256 * p$q1) + 257)) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(64 * p$q1 + 3, 256 * p$myid1 + 1, 256 * p$q1
* + 2), min(256 * p$myid1 + 256, 256 * p$q1 + 257)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zr$828$index + counter$zr$8
*28) = zr(zr$data + i1 - (zr$coord$0 * 256 + 1) + (i2 - (zr$coord$1
* * 128 + 1)) * zr$local$extent$0)
counter$zr$828 = counter$zr$828 + 1
enddo
enddo
endif
if (counter$zr$828 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zr$828$index), co
*unter$zr$828, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 13, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$zr$828)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$830 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 255, 1022) .and. m
*ax(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023)) then
counter$zr$830 = counter$zr$830 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 255, 1022) - max(256 * p$myid1 + 1, 256 * p$q1) +
* 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1, 2)
*+ 1)
endif
call hpf_buffer_alloc(counter$zr$830 * 8, send$buf$zr$830)
call hpf_ptr_to_index(hpf$heap, send$buf$zr$830, 8, send$b
*uf$zr$830$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zr$830 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$myid1) + 1), (256 * p$q1)) <= i1 <= mi
Cn(((256 * p$myid1) + 256), ((256 * p$q1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1), min(256 * p$
*myid1 + 256, 256 * p$q1 + 255, 1022)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
hpf$heap$double(send$buf$zr$830$index + counter$zr$8
*30) = zr(zr$data + i1 - (zr$coord$0 * 256 + 1) + (i2 - (zr$coord$1
* * 128 + 1)) * zr$local$extent$0)
counter$zr$830 = counter$zr$830 + 1
enddo
enddo
endif
if (counter$zr$830 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zr$830$index), co
*unter$zr$830, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 14, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$zr$830)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$834 = 0
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. p$q2 .and. p$q2 .
*le. 1 + p$myid2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$q2, 128 * p$myid2 + 1) .le. mi
*n(128 * p$q2 + 127, 128 * p$myid2 + 128, 1022)) then
counter$zr$834 = counter$zr$834 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$q2 + 127
*, 128 * p$myid2 + 128, 1022) - max(128 * p$q2, 128 * p$myid2 + 1)
*+ 1)
endif
call hpf_buffer_alloc(counter$zr$834 * 8, send$buf$zr$834)
call hpf_ptr_to_index(hpf$heap, send$buf$zr$834, 8, send$b
*uf$zr$834$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zr$834 = 0
C
C Loop section ---[ max((128 * p$q2), ((128 * p$myid2) + 1)) <= i2 <
C= min(((128 * p$q2) + 127), ((128 * p$myid2) + 128), 1022), max(((256 * p$myid1
C) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. p$q2 .and. p$q2 .
*le. 1 + p$myid2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$q2, 128 * p$myid2 + 1), min(128 *
*p$q2 + 127, 128 * p$myid2 + 128, 1022)
hpf$heap$double(send$buf$zr$834$index + counter$zr$8
*34) = zr(zr$data + i1 - (zr$coord$0 * 256 + 1) + (i2 - (zr$coord$1
* * 128 + 1)) * zr$local$extent$0)
counter$zr$834 = counter$zr$834 + 1
enddo
enddo
endif
if (counter$zr$834 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zr$834$index), co
*unter$zr$834, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 15, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$zr$834)
endif
enddo
enddo
continue
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zp$814 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2 .and. 256 * p$myid1 + 1 .le. min(256 * p$myid1 + 2
*56, 1022) .and. max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3) .le. min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)) then
counter$zp$814 = counter$zp$814 + (min(256 * p$myid1 + 2
*56, 1022) - (256 * p$myid1 + 1) + 1) * (min(128 * p$myid2 + 129, 1
*28 * p$q2 + 128) - max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3) + 1)
endif
call hpf_buffer_alloc(counter$zp$814 * 8, recv$buf$zp$814)
call hpf_ptr_to_index(hpf$heap, recv$buf$zp$814, 8, recv$b
*uf$zp$814$index)
if (counter$zp$814 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zp$814$index), co
*unter$zp$814, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 1, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zp$814 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 2), ((128 * p$q2) + 1), 3
C) <= i2 <= min(((128 * p$myid2) + 129), ((128 * p$q2) + 128)), ((256 * p$myid1)
C + 1) <= i1 <= min(((256 * p$myid1) + 256), 1022) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2) then
do i1 = 256 * p$myid1 + 1, min(256 * p$myid1 + 256, 1022
*)
do i2 = max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3), min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)
call hpf_nonlocal_insertd(hash$nonlocals, zp$data, i
*1 + i2 * zp$global$extent$0, hpf$heap$double(recv$buf$zp$814$index
* + counter$zp$814))
counter$zp$814 = counter$zp$814 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zp$814)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zq$815 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2 .and. 256 * p$myid1 + 1 .le. min(256 * p$myid1 + 2
*56, 1022) .and. max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3) .le. min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)) then
counter$zq$815 = counter$zq$815 + (min(256 * p$myid1 + 2
*56, 1022) - (256 * p$myid1 + 1) + 1) * (min(128 * p$myid2 + 129, 1
*28 * p$q2 + 128) - max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3) + 1)
endif
call hpf_buffer_alloc(counter$zq$815 * 8, recv$buf$zq$815)
call hpf_ptr_to_index(hpf$heap, recv$buf$zq$815, 8, recv$b
*uf$zq$815$index)
if (counter$zq$815 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zq$815$index), co
*unter$zq$815, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 2, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zq$815 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 2), ((128 * p$q2) + 1), 3
C) <= i2 <= min(((128 * p$myid2) + 129), ((128 * p$q2) + 128)), ((256 * p$myid1)
C + 1) <= i1 <= min(((256 * p$myid1) + 256), 1022) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2) then
do i1 = 256 * p$myid1 + 1, min(256 * p$myid1 + 256, 1022
*)
do i2 = max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3), min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)
call hpf_nonlocal_insertd(hash$nonlocals, zq$data, i
*1 + i2 * zq$global$extent$0, hpf$heap$double(recv$buf$zq$815$index
* + counter$zq$815))
counter$zq$815 = counter$zq$815 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zq$815)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$816 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1 + 2) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 257, 1023) .an
*d. max(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$zr$816 = counter$zr$816 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 257, 1023) - max(256 * p$q1 + 1, 256 * p$myid1 +
*2) + 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) +
*1)
endif
call hpf_buffer_alloc(counter$zr$816 * 8, recv$buf$zr$816)
call hpf_ptr_to_index(hpf$heap, recv$buf$zr$816, 8, recv$b
*uf$zr$816$index)
if (counter$zr$816 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zr$816$index), co
*unter$zr$816, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 3, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zr$816 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$q1) + 1), ((256 * p$myid1) + 2)) <= i1 <= mi
Cn(((256 * p$q1) + 256), ((256 * p$myid1) + 257), 1023) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1 + 2), min(256
** p$q1 + 256, 256 * p$myid1 + 257, 1023)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zr$data, i
*1 + i2 * zr$global$extent$0, hpf$heap$double(recv$buf$zr$816$index
* + counter$zr$816))
counter$zr$816 = counter$zr$816 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zr$816)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zm$817 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2 .and. 256 * p$myid1 + 1 .le. min(256 * p$myid1 + 2
*56, 1022) .and. max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3) .le. min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)) then
counter$zm$817 = counter$zm$817 + (min(256 * p$myid1 + 2
*56, 1022) - (256 * p$myid1 + 1) + 1) * (min(128 * p$myid2 + 129, 1
*28 * p$q2 + 128) - max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3) + 1)
endif
call hpf_buffer_alloc(counter$zm$817 * 8, recv$buf$zm$817)
call hpf_ptr_to_index(hpf$heap, recv$buf$zm$817, 8, recv$b
*uf$zm$817$index)
if (counter$zm$817 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zm$817$index), co
*unter$zm$817, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 4, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zm$817 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 2), ((128 * p$q2) + 1), 3
C) <= i2 <= min(((128 * p$myid2) + 129), ((128 * p$q2) + 128)), ((256 * p$myid1)
C + 1) <= i1 <= min(((256 * p$myid1) + 256), 1022) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2) then
do i1 = 256 * p$myid1 + 1, min(256 * p$myid1 + 256, 1022
*)
do i2 = max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3), min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)
call hpf_nonlocal_insertd(hash$nonlocals, zm$data, i
*1 + i2 * zm$global$extent$0, hpf$heap$double(recv$buf$zm$817$index
* + counter$zm$817))
counter$zm$817 = counter$zm$817 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zm$817)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zp$818 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 255, 1022) .and. m
*ax(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$zp$818 = counter$zp$818 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 255, 1022) - max(256 * p$q1 + 1, 256 * p$myid1) +
* 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zp$818 * 8, recv$buf$zp$818)
call hpf_ptr_to_index(hpf$heap, recv$buf$zp$818, 8, recv$b
*uf$zp$818$index)
if (counter$zp$818 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zp$818$index), co
*unter$zp$818, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 5, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zp$818 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$q1) + 1), (256 * p$myid1)) <= i1 <= min(((25
C6 * p$q1) + 256), ((256 * p$myid1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1), min(256 * p$
*q1 + 256, 256 * p$myid1 + 255, 1022)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zp$data, i
*1 + i2 * zp$global$extent$0, hpf$heap$double(recv$buf$zp$818$index
* + counter$zp$818))
counter$zp$818 = counter$zp$818 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zp$818)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zq$819 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 255, 1022) .and. m
*ax(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$zq$819 = counter$zq$819 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 255, 1022) - max(256 * p$q1 + 1, 256 * p$myid1) +
* 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zq$819 * 8, recv$buf$zq$819)
call hpf_ptr_to_index(hpf$heap, recv$buf$zq$819, 8, recv$b
*uf$zq$819$index)
if (counter$zq$819 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zq$819$index), co
*unter$zq$819, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 6, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zq$819 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$q1) + 1), (256 * p$myid1)) <= i1 <= min(((25
C6 * p$q1) + 256), ((256 * p$myid1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1), min(256 * p$
*q1 + 256, 256 * p$myid1 + 255, 1022)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zq$data, i
*1 + i2 * zq$global$extent$0, hpf$heap$double(recv$buf$zq$819$index
* + counter$zq$819))
counter$zq$819 = counter$zq$819 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zq$819)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$833 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3)
*.le. min(128 * p$myid2 + 129, 128 * p$q2 + 128)) then
counter$zr$833 = counter$zr$833 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$myid2 +
*129, 128 * p$q2 + 128) - max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3)
* + 1)
endif
call hpf_buffer_alloc(counter$zr$833 * 8, recv$buf$zr$833)
call hpf_ptr_to_index(hpf$heap, recv$buf$zr$833, 8, recv$b
*uf$zr$833$index)
if (counter$zr$833 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zr$833$index), co
*unter$zr$833, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 7, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zr$833 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 2), ((128 * p$q2) + 1), 3
C) <= i2 <= min(((128 * p$myid2) + 129), ((128 * p$q2) + 128)), max(((256 * p$my
Cid1) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3), min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)
call hpf_nonlocal_insertd(hash$nonlocals, zr$data, i
*1 + i2 * zr$global$extent$0, hpf$heap$double(recv$buf$zr$833$index
* + counter$zr$833))
counter$zr$833 = counter$zr$833 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zr$833)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zm$821 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 255, 1022) .and. m
*ax(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$zm$821 = counter$zm$821 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 255, 1022) - max(256 * p$q1 + 1, 256 * p$myid1) +
* 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zm$821 * 8, recv$buf$zm$821)
call hpf_ptr_to_index(hpf$heap, recv$buf$zm$821, 8, recv$b
*uf$zm$821$index)
if (counter$zm$821 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zm$821$index), co
*unter$zm$821, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 8, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zm$821 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$q1) + 1), (256 * p$myid1)) <= i1 <= min(((25
C6 * p$q1) + 256), ((256 * p$myid1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1), min(256 * p$
*q1 + 256, 256 * p$myid1 + 255, 1022)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zm$data, i
*1 + i2 * zm$global$extent$0, hpf$heap$double(recv$buf$zm$821$index
* + counter$zm$821))
counter$zm$821 = counter$zm$821 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zm$821)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$828 = 0
if (p$q2 .eq. p$myid2 .and. max(64 * p$q1 + 3, 256 * p$q1
*+ 1, 256 * p$myid1 + 2) .le. min(256 * p$q1 + 256, 256 * p$myid1 +
* 257) .and. max(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023
*)) then
counter$zr$828 = counter$zr$828 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 257) - max(64 * p$q1 + 3, 256 * p$q1 + 1, 256 * p
*$myid1 + 2) + 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 +
* 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zr$828 * 8, recv$buf$zr$828)
call hpf_ptr_to_index(hpf$heap, recv$buf$zr$828, 8, recv$b
*uf$zr$828$index)
if (counter$zr$828 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zr$828$index), co
*unter$zr$828, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 13, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zr$828 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((64 * p$q1) + 3), ((256 * p$q1) + 1), ((256 * p$myid1
C) + 2)) <= i1 <= min(((256 * p$q1) + 256), ((256 * p$myid1) + 257)) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(64 * p$q1 + 3, 256 * p$q1 + 1, 256 * p$myid1
* + 2), min(256 * p$q1 + 256, 256 * p$myid1 + 257)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zr$data, i
*1 + i2 * zr$global$extent$0, hpf$heap$double(recv$buf$zr$828$index
* + counter$zr$828))
counter$zr$828 = counter$zr$828 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zr$828)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$830 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 255, 1022) .and. m
*ax(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$zr$830 = counter$zr$830 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 255, 1022) - max(256 * p$q1 + 1, 256 * p$myid1) +
* 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zr$830 * 8, recv$buf$zr$830)
call hpf_ptr_to_index(hpf$heap, recv$buf$zr$830, 8, recv$b
*uf$zr$830$index)
if (counter$zr$830 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zr$830$index), co
*unter$zr$830, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 14, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zr$830 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$q1) + 1), (256 * p$myid1)) <= i1 <= min(((25
C6 * p$q1) + 256), ((256 * p$myid1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1), min(256 * p$
*q1 + 256, 256 * p$myid1 + 255, 1022)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zr$data, i
*1 + i2 * zr$global$extent$0, hpf$heap$double(recv$buf$zr$830$index
* + counter$zr$830))
counter$zr$830 = counter$zr$830 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zr$830)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zr$834 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$myid2, 128 * p$q2 + 1) .le. mi
*n(128 * p$myid2 + 127, 128 * p$q2 + 128, 1022)) then
counter$zr$834 = counter$zr$834 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$myid2 +
*127, 128 * p$q2 + 128, 1022) - max(128 * p$myid2, 128 * p$q2 + 1)
*+ 1)
endif
call hpf_buffer_alloc(counter$zr$834 * 8, recv$buf$zr$834)
call hpf_ptr_to_index(hpf$heap, recv$buf$zr$834, 8, recv$b
*uf$zr$834$index)
if (counter$zr$834 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zr$834$index), co
*unter$zr$834, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 15, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zr$834 = 0
C
C Loop section ---[ max((128 * p$myid2), ((128 * p$q2) + 1)) <= i2 <
C= min(((128 * p$myid2) + 127), ((128 * p$q2) + 128), 1022), max(((256 * p$myid1
C) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$myid2, 128 * p$q2 + 1), min(128 *
*p$myid2 + 127, 128 * p$q2 + 128, 1022)
call hpf_nonlocal_insertd(hash$nonlocals, zr$data, i
*1 + i2 * zr$global$extent$0, hpf$heap$double(recv$buf$zr$834$index
* + counter$zr$834))
counter$zr$834 = counter$zr$834 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zr$834)
endif
enddo
enddo
C
C --<< Iterations that access only local values >>--
C
C
C Loop section ---[ ((256 * p$myid1) + 2) <= j <= min(((256 * p$myid1) + 2
C56), 1023), max(((128 * p$myid2) + 1), 2) <= k <= ((128 * p$myid2) + 127) ]---
C
do k = max(128 * p$myid2 + 1, 2), 128 * p$myid2 + 127
do j = 256 * p$myid1 + 2, min(256 * p$myid1 + 256, 1023)
za(za$data + j - (za$coord$0 * 256 + 1) + (k - (za$coord$1 *
* 128 + 1)) * za$local$extent$0) = (zp(zp$data + j - 1 - (zp$coord$
*0 * 256 + 1) + (k + 1 - (zp$coord$1 * 128 + 1)) * zp$local$extent$
*0) + zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (k + 1 - (zq$co
*ord$1 * 128 + 1)) * zq$local$extent$0) - zp(zp$data + j - 1 - (zp$
*coord$0 * 256 + 1) + (k - (zp$coord$1 * 128 + 1)) * zp$local$exten
*t$0) - zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (k - (zq$coor
*d$1 * 128 + 1)) * zq$local$extent$0)) * (zr(zr$data + j - (zr$coor
*d$0 * 256 + 1) + (k - (zr$coord$1 * 128 + 1)) * zr$local$extent$0)
* + zr(zr$data + j - 1 - (zr$coord$0 * 256 + 1) + (k - (zr$coord$1
** 128 + 1)) * zr$local$extent$0)) / (zm(zm$data + j - 1 - (zm$coor
*d$0 * 256 + 1) + (k - (zm$coord$1 * 128 + 1)) * zm$local$extent$0)
* + zm(zm$data + j - 1 - (zm$coord$0 * 256 + 1) + (k + 1 - (zm$coor
*d$1 * 128 + 1)) * zm$local$extent$0))
enddo
enddo
C
C --<< Iterations that read *and* compute non-local values >>--
C
C
C Loop section ---[ j = ((256 * p$myid1) + 257), max(((128 * p$myid2) + 1)
C, 2) <= k <= min(((128 * p$myid2) + 128), 1023) ]---
C
if (p$myid1 .le. 2) then
do k = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 + 128, 102
*3)
j = 256 * p$myid1 + 257
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k + 1 .and. k + 1 .lt. p$my
*id2 * 128 + 129) then
lnltmp3 = zp(zp$data + j - 1 - (zp$coord$0 * 256 + 1) + (k
* + 1 - (zp$coord$1 * 128 + 1)) * zp$local$extent$0)
else
lnltmp3 = hpf_nonlocal_lookupd(hash$nonlocals, zp$data, j
*- 1 + (k + 1) * zp$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k + 1 .and. k + 1 .lt. p$my
*id2 * 128 + 129) then
lnltmp5 = zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (k
* + 1 - (zq$coord$1 * 128 + 1)) * zq$local$extent$0)
else
lnltmp5 = hpf_nonlocal_lookupd(hash$nonlocals, zq$data, j
*- 1 + (k + 1) * zq$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j .and. j .lt. p$myid1 * 256 + 25
*7 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 128 + 129)
* then
lnltmp7 = zr(zr$data + j - (zr$coord$0 * 256 + 1) + (k - (
*zr$coord$1 * 128 + 1)) * zr$local$extent$0)
else
lnltmp7 = hpf_nonlocal_lookupd(hash$nonlocals, zr$data, j
*+ k * zr$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k + 1 .and. k + 1 .lt. p$my
*id2 * 128 + 129) then
lnltmp9 = zm(zm$data + j - 1 - (zm$coord$0 * 256 + 1) + (k
* + 1 - (zm$coord$1 * 128 + 1)) * zm$local$extent$0)
else
lnltmp9 = hpf_nonlocal_lookupd(hash$nonlocals, zm$data, j
*- 1 + (k + 1) * zm$global$extent$0)
endif
lnltmp1 = (lnltmp3 + lnltmp5 - zp(zp$data + j - 1 - (zp$coor
*d$0 * 256 + 1) + (k - (zp$coord$1 * 128 + 1)) * zp$local$extent$0)
* - zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (k - (zq$coord$1
** 128 + 1)) * zq$local$extent$0)) * (lnltmp7 + zr(zr$data + j - 1
*- (zr$coord$0 * 256 + 1) + (k - (zr$coord$1 * 128 + 1)) * zr$local
*$extent$0)) / (zm(zm$data + j - 1 - (zm$coord$0 * 256 + 1) + (k -
*(zm$coord$1 * 128 + 1)) * zm$local$extent$0) + lnltmp9)
if (p$myid1 * 256 + 1 .le. j .and. j .lt. p$myid1 * 256 + 25
*7 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 128 + 129)
* then
za(za$data + j - (za$coord$0 * 256 + 1) + (k - (za$coord$1
* * 128 + 1)) * za$local$extent$0) = lnltmp1
else
call hpf_nonlocal_insertd(hash$nonlocals, za$data, j + k *
* za$global$extent$0, lnltmp1)
endif
enddo
endif
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$za$813 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1 + 2) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 257, 1023) .an
*d. max(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$za$813 = counter$za$813 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 257, 1023) - max(256 * p$q1 + 1, 256 * p$myid1 +
*2) + 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) +
*1)
endif
call hpf_buffer_alloc(counter$za$813 * 8, send$buf$za$813)
call hpf_ptr_to_index(hpf$heap, send$buf$za$813, 8, send$b
*uf$za$813$index)
C --< Pack Loop For Send For Nonlocal Write >--
counter$za$813 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$q1) + 1), ((256 * p$myid1) + 2)) <= i1 <= mi
Cn(((256 * p$q1) + 256), ((256 * p$myid1) + 257), 1023) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1 + 2), min(256
** p$q1 + 256, 256 * p$myid1 + 257, 1023)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
hpf$heap$double(send$buf$za$813$index + counter$za$8
*13) = hpf_nonlocal_lookupd(hash$nonlocals, za$data, i1 + i2 * za$g
*lobal$extent$0)
counter$za$813 = counter$za$813 + 1
enddo
enddo
endif
if (counter$za$813 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$za$813$index), co
*unter$za$813, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 16, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$za$813)
endif
enddo
enddo
C
C --<< Iterations that read (but do not compute) non-local values >>--
C
C
C Loop section ---[ ((256 * p$myid1) + 2) <= j <= min(((256 * p$myid1) + 2
C56), 1023), k = ((128 * p$myid2) + 128) ]---
C
if (p$myid2 .le. 6) then
do j = 256 * p$myid1 + 2, min(256 * p$myid1 + 256, 1023)
k = 128 * p$myid2 + 128
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k + 1 .and. k + 1 .lt. p$my
*id2 * 128 + 129) then
lnltmp4 = zp(zp$data + j - 1 - (zp$coord$0 * 256 + 1) + (k
* + 1 - (zp$coord$1 * 128 + 1)) * zp$local$extent$0)
else
lnltmp4 = hpf_nonlocal_lookupd(hash$nonlocals, zp$data, j
*- 1 + (k + 1) * zp$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k + 1 .and. k + 1 .lt. p$my
*id2 * 128 + 129) then
lnltmp6 = zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (k
* + 1 - (zq$coord$1 * 128 + 1)) * zq$local$extent$0)
else
lnltmp6 = hpf_nonlocal_lookupd(hash$nonlocals, zq$data, j
*- 1 + (k + 1) * zq$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j .and. j .lt. p$myid1 * 256 + 25
*7 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 128 + 129)
* then
lnltmp8 = zr(zr$data + j - (zr$coord$0 * 256 + 1) + (k - (
*zr$coord$1 * 128 + 1)) * zr$local$extent$0)
else
lnltmp8 = hpf_nonlocal_lookupd(hash$nonlocals, zr$data, j
*+ k * zr$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k + 1 .and. k + 1 .lt. p$my
*id2 * 128 + 129) then
lnltmp10 = zm(zm$data + j - 1 - (zm$coord$0 * 256 + 1) + (
*k + 1 - (zm$coord$1 * 128 + 1)) * zm$local$extent$0)
else
lnltmp10 = hpf_nonlocal_lookupd(hash$nonlocals, zm$data, j
* - 1 + (k + 1) * zm$global$extent$0)
endif
lnltmp2 = (lnltmp4 + lnltmp6 - zp(zp$data + j - 1 - (zp$coor
*d$0 * 256 + 1) + (k - (zp$coord$1 * 128 + 1)) * zp$local$extent$0)
* - zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (k - (zq$coord$1
** 128 + 1)) * zq$local$extent$0)) * (lnltmp8 + zr(zr$data + j - 1
*- (zr$coord$0 * 256 + 1) + (k - (zr$coord$1 * 128 + 1)) * zr$local
*$extent$0)) / (zm(zm$data + j - 1 - (zm$coord$0 * 256 + 1) + (k -
*(zm$coord$1 * 128 + 1)) * zm$local$extent$0) + lnltmp10)
if (p$myid1 * 256 + 1 .le. j .and. j .lt. p$myid1 * 256 + 25
*7 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 128 + 129)
* then
za(za$data + j - (za$coord$0 * 256 + 1) + (k - (za$coord$1
* * 128 + 1)) * za$local$extent$0) = lnltmp2
else
call hpf_nonlocal_insertd(hash$nonlocals, za$data, j + k *
* za$global$extent$0, lnltmp2)
endif
enddo
endif
continue
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$za$813 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1 + 2) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 257, 1023) .an
*d. max(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023))
*then
counter$za$813 = counter$za$813 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 257, 1023) - max(256 * p$myid1 + 1, 256 * p$q1 +
*2) + 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1,
* 2) + 1)
endif
call hpf_buffer_alloc(counter$za$813 * 8, recv$buf$za$813)
call hpf_ptr_to_index(hpf$heap, recv$buf$za$813, 8, recv$b
*uf$za$813$index)
if (counter$za$813 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$za$813$index), co
*unter$za$813, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 16, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Write >--
counter$za$813 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$myid1) + 1), ((256 * p$q1) + 2)) <= i1
C <= min(((256 * p$myid1) + 256), ((256 * p$q1) + 257), 1023) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1 + 2), min(256
** p$myid1 + 256, 256 * p$q1 + 257, 1023)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
za(za$data + i1 - (za$coord$0 * 256 + 1) + (i2 - (za
*$coord$1 * 128 + 1)) * za$local$extent$0) = hpf$heap$double(recv$b
*uf$za$813$index + counter$za$813)
counter$za$813 = counter$za$813 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$za$813)
endif
enddo
enddo
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$za$835 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$myid1 + 1, 256 * p
*$q1) .le. min(256 * p$myid1 + 256, 256 * p$q1 + 255, 1022) .and. m
*ax(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$za$835 = counter$za$835 + (min(256 * p$myid1 + 2
*56, 256 * p$q1 + 255, 1022) - max(256 * p$myid1 + 1, 256 * p$q1) +
* 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$za$835 * 8, send$buf$za$835)
call hpf_ptr_to_index(hpf$heap, send$buf$za$835, 8, send$b
*uf$za$835$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$za$835 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$myid1) + 1), (256 * p$q1)) <= i1 <= min(((25
C6 * p$myid1) + 256), ((256 * p$q1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 256 * p$q1), min(256 * p$
*myid1 + 256, 256 * p$q1 + 255, 1022)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
hpf$heap$double(send$buf$za$835$index + counter$za$8
*35) = za(za$data + i1 - (za$coord$0 * 256 + 1) + (i2 - (za$coord$1
* * 128 + 1)) * za$local$extent$0)
counter$za$835 = counter$za$835 + 1
enddo
enddo
endif
if (counter$za$835 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$za$835$index), co
*unter$za$835, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 17, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$za$835)
endif
enddo
enddo
continue
C
C --<< Iterations that access only local values >>--
C
C
C Loop section ---[ ((256 * p$myid1) + 2) <= j <= min(((256 * p$myid1) + 2
C56), 1023), ((128 * p$myid2) + 2) <= k <= min(((128 * p$myid2) + 128), 1023) ]-
C--
C
do k = 128 * p$myid2 + 2, min(128 * p$myid2 + 128, 1023)
do j = 256 * p$myid1 + 2, min(256 * p$myid1 + 256, 1023)
zb(zb$data + j - (zb$coord$0 * 256 + 1) + (k - (zb$coord$1 *
* 128 + 1)) * zb$local$extent$0) = (zp(zp$data + j - 1 - (zp$coord$
*0 * 256 + 1) + (k - (zp$coord$1 * 128 + 1)) * zp$local$extent$0) +
* zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (k - (zq$coord$1 *
*128 + 1)) * zq$local$extent$0) - zp(zp$data + j - (zp$coord$0 * 25
*6 + 1) + (k - (zp$coord$1 * 128 + 1)) * zp$local$extent$0) - zq(zq
*$data + j - (zq$coord$0 * 256 + 1) + (k - (zq$coord$1 * 128 + 1))
** zq$local$extent$0)) * (zr(zr$data + j - (zr$coord$0 * 256 + 1) +
* (k - (zr$coord$1 * 128 + 1)) * zr$local$extent$0) + zr(zr$data +
*j - (zr$coord$0 * 256 + 1) + (k - 1 - (zr$coord$1 * 128 + 1)) * zr
*$local$extent$0)) / (zm(zm$data + j - (zm$coord$0 * 256 + 1) + (k
*- (zm$coord$1 * 128 + 1)) * zm$local$extent$0) + zm(zm$data + j -
*1 - (zm$coord$0 * 256 + 1) + (k - (zm$coord$1 * 128 + 1)) * zm$loc
*al$extent$0))
enddo
enddo
C
C --<< Iterations that read (but do not compute) non-local values >>--
C
C
C Loop section ---[ max(((256 * p$myid1) + 1), 2) <= j <= min(((256 * p$my
Cid1) + 256), 1023), k = ((128 * p$myid2) + 1) ]---
C
if (1 .le. p$myid2) then
do j = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 256, 102
*3)
k = 128 * p$myid2 + 1
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 12
*8 + 129) then
lnltmp11 = zp(zp$data + j - 1 - (zp$coord$0 * 256 + 1) + (
*k - (zp$coord$1 * 128 + 1)) * zp$local$extent$0)
else
lnltmp11 = hpf_nonlocal_lookupd(hash$nonlocals, zp$data, j
* - 1 + k * zp$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 12
*8 + 129) then
lnltmp13 = zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (
*k - (zq$coord$1 * 128 + 1)) * zq$local$extent$0)
else
lnltmp13 = hpf_nonlocal_lookupd(hash$nonlocals, zq$data, j
* - 1 + k * zq$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 12
*8 + 129) then
lnltmp21 = zm(zm$data + j - 1 - (zm$coord$0 * 256 + 1) + (
*k - (zm$coord$1 * 128 + 1)) * zm$local$extent$0)
else
lnltmp21 = hpf_nonlocal_lookupd(hash$nonlocals, zm$data, j
* - 1 + k * zm$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j .and. j .lt. p$myid1 * 256 + 25
*7 .and. p$myid2 * 128 + 1 .le. k - 1 .and. k - 1 .lt. p$myid2 * 12
*8 + 129) then
lnltmp59 = zr(zr$data + j - (zr$coord$0 * 256 + 1) + (k -
*1 - (zr$coord$1 * 128 + 1)) * zr$local$extent$0)
else
lnltmp59 = hpf_nonlocal_lookupd(hash$nonlocals, zr$data, j
* + (k - 1) * zr$global$extent$0)
endif
zb(zb$data + j - (zb$coord$0 * 256 + 1) + (k - (zb$coord$1 *
* 128 + 1)) * zb$local$extent$0) = (lnltmp11 + lnltmp13 - zp(zp$dat
*a + j - (zp$coord$0 * 256 + 1) + (k - (zp$coord$1 * 128 + 1)) * zp
*$local$extent$0) - zq(zq$data + j - (zq$coord$0 * 256 + 1) + (k -
*(zq$coord$1 * 128 + 1)) * zq$local$extent$0)) * (zr(zr$data + j -
*(zr$coord$0 * 256 + 1) + (k - (zr$coord$1 * 128 + 1)) * zr$local$e
*xtent$0) + lnltmp59) / (zm(zm$data + j - (zm$coord$0 * 256 + 1) +
*(k - (zm$coord$1 * 128 + 1)) * zm$local$extent$0) + lnltmp21)
enddo
endif
C
C Loop section ---[ j = ((256 * p$myid1) + 1), ((128 * p$myid2) + 2) <= k
C<= min(((128 * p$myid2) + 128), 1023) ]---
C
if (1 .le. p$myid1) then
do k = 128 * p$myid2 + 2, min(128 * p$myid2 + 128, 1023)
j = 256 * p$myid1 + 1
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 12
*8 + 129) then
lnltmp12 = zp(zp$data + j - 1 - (zp$coord$0 * 256 + 1) + (
*k - (zp$coord$1 * 128 + 1)) * zp$local$extent$0)
else
lnltmp12 = hpf_nonlocal_lookupd(hash$nonlocals, zp$data, j
* - 1 + k * zp$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 12
*8 + 129) then
lnltmp14 = zq(zq$data + j - 1 - (zq$coord$0 * 256 + 1) + (
*k - (zq$coord$1 * 128 + 1)) * zq$local$extent$0)
else
lnltmp14 = hpf_nonlocal_lookupd(hash$nonlocals, zq$data, j
* - 1 + k * zq$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j - 1 .and. j - 1 .lt. p$myid1 *
*256 + 257 .and. p$myid2 * 128 + 1 .le. k .and. k .lt. p$myid2 * 12
*8 + 129) then
lnltmp22 = zm(zm$data + j - 1 - (zm$coord$0 * 256 + 1) + (
*k - (zm$coord$1 * 128 + 1)) * zm$local$extent$0)
else
lnltmp22 = hpf_nonlocal_lookupd(hash$nonlocals, zm$data, j
* - 1 + k * zm$global$extent$0)
endif
if (p$myid1 * 256 + 1 .le. j .and. j .lt. p$myid1 * 256 + 25
*7 .and. p$myid2 * 128 + 1 .le. k - 1 .and. k - 1 .lt. p$myid2 * 12
*8 + 129) then
lnltmp61 = zr(zr$data + j - (zr$coord$0 * 256 + 1) + (k -
*1 - (zr$coord$1 * 128 + 1)) * zr$local$extent$0)
else
lnltmp61 = hpf_nonlocal_lookupd(hash$nonlocals, zr$data, j
* + (k - 1) * zr$global$extent$0)
endif
zb(zb$data + j - (zb$coord$0 * 256 + 1) + (k - (zb$coord$1 *
* 128 + 1)) * zb$local$extent$0) = (lnltmp12 + lnltmp14 - zp(zp$dat
*a + j - (zp$coord$0 * 256 + 1) + (k - (zp$coord$1 * 128 + 1)) * zp
*$local$extent$0) - zq(zq$data + j - (zq$coord$0 * 256 + 1) + (k -
*(zq$coord$1 * 128 + 1)) * zq$local$extent$0)) * (zr(zr$data + j -
*(zr$coord$0 * 256 + 1) + (k - (zr$coord$1 * 128 + 1)) * zr$local$e
*xtent$0) + lnltmp61) / (zm(zm$data + j - (zm$coord$0 * 256 + 1) +
*(k - (zm$coord$1 * 128 + 1)) * zm$local$extent$0) + lnltmp22)
enddo
endif
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zb$836 = 0
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. 1 + p$q2 .and. p$
*q2 .le. p$myid2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3)
*.le. min(128 * p$q2 + 129, 128 * p$myid2 + 128)) then
counter$zb$836 = counter$zb$836 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$q2 + 129
*, 128 * p$myid2 + 128) - max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3)
* + 1)
endif
call hpf_buffer_alloc(counter$zb$836 * 8, send$buf$zb$836)
call hpf_ptr_to_index(hpf$heap, send$buf$zb$836, 8, send$b
*uf$zb$836$index)
C --< Pack Loop For Send For Nonlocal Read >--
counter$zb$836 = 0
C
C Loop section ---[ max(((128 * p$q2) + 2), ((128 * p$myid2) + 1), 3
C) <= i2 <= min(((128 * p$q2) + 129), ((128 * p$myid2) + 128)), max(((256 * p$my
Cid1) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$myid2 .le. 1 + p$q2 .and. p$
*q2 .le. p$myid2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$q2 + 2, 128 * p$myid2 + 1, 3), min
*(128 * p$q2 + 129, 128 * p$myid2 + 128)
hpf$heap$double(send$buf$zb$836$index + counter$zb$8
*36) = zb(zb$data + i1 - (zb$coord$0 * 256 + 1) + (i2 - (zb$coord$1
* * 128 + 1)) * zb$local$extent$0)
counter$zb$836 = counter$zb$836 + 1
enddo
enddo
endif
if (counter$zb$836 .gt. 0) then
call mpi_send(hpf$heap$double(send$buf$zb$836$index), co
*unter$zb$836, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 18, p$cmap, r
*equest, ierr)
endif
call hpf_buffer_free(send$buf$zb$836)
endif
enddo
enddo
continue
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$822 = 0
if (p$q2 .eq. p$myid2 .and. max(64 * p$q1 + 3, 256 * p$q1
*+ 1, 256 * p$myid1 + 2) .le. min(256 * p$q1 + 256, 256 * p$myid1 +
* 257) .and. max(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023
*)) then
counter$zz$822 = counter$zz$822 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 257) - max(64 * p$q1 + 3, 256 * p$q1 + 1, 256 * p
*$myid1 + 2) + 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 +
* 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zz$822 * 8, recv$buf$zz$822)
call hpf_ptr_to_index(hpf$heap, recv$buf$zz$822, 8, recv$b
*uf$zz$822$index)
if (counter$zz$822 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zz$822$index), co
*unter$zz$822, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 9, p$cmap, re
*quest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zz$822 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((64 * p$q1) + 3), ((256 * p$q1) + 1), ((256 * p$myid1
C) + 2)) <= i1 <= min(((256 * p$q1) + 256), ((256 * p$myid1) + 257)) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(64 * p$q1 + 3, 256 * p$q1 + 1, 256 * p$myid1
* + 2), min(256 * p$q1 + 256, 256 * p$myid1 + 257)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zz$data, i
*1 + i2 * zz$global$extent$0, hpf$heap$double(recv$buf$zz$822$index
* + counter$zz$822))
counter$zz$822 = counter$zz$822 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zz$822)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$824 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 255, 1022) .and. m
*ax(128 * p$q2 + 1, 2) .le. min(128 * p$q2 + 128, 1023)) then
counter$zz$824 = counter$zz$824 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 255, 1022) - max(256 * p$q1 + 1, 256 * p$myid1) +
* 1) * (min(128 * p$q2 + 128, 1023) - max(128 * p$q2 + 1, 2) + 1)
endif
call hpf_buffer_alloc(counter$zz$824 * 8, recv$buf$zz$824)
call hpf_ptr_to_index(hpf$heap, recv$buf$zz$824, 8, recv$b
*uf$zz$824$index)
if (counter$zz$824 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zz$824$index), co
*unter$zz$824, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 10, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zz$824 = 0
C
C Loop section ---[ max(((128 * p$q2) + 1), 2) <= i2 <= min(((128 *
Cp$q2) + 128), 1023), max(((256 * p$q1) + 1), (256 * p$myid1)) <= i1 <= min(((25
C6 * p$q1) + 256), ((256 * p$myid1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1), min(256 * p$
*q1 + 256, 256 * p$myid1 + 255, 1022)
do i2 = max(128 * p$q2 + 1, 2), min(128 * p$q2 + 128,
*1023)
call hpf_nonlocal_insertd(hash$nonlocals, zz$data, i
*1 + i2 * zz$global$extent$0, hpf$heap$double(recv$buf$zz$824$index
* + counter$zz$824))
counter$zz$824 = counter$zz$824 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zz$824)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$825 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$myid2, 128 * p$q2 + 1) .le. mi
*n(128 * p$myid2 + 127, 128 * p$q2 + 128, 1022)) then
counter$zz$825 = counter$zz$825 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$myid2 +
*127, 128 * p$q2 + 128, 1022) - max(128 * p$myid2, 128 * p$q2 + 1)
*+ 1)
endif
call hpf_buffer_alloc(counter$zz$825 * 8, recv$buf$zz$825)
call hpf_ptr_to_index(hpf$heap, recv$buf$zz$825, 8, recv$b
*uf$zz$825$index)
if (counter$zz$825 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zz$825$index), co
*unter$zz$825, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 11, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zz$825 = 0
C
C Loop section ---[ max((128 * p$myid2), ((128 * p$q2) + 1)) <= i2 <
C= min(((128 * p$myid2) + 127), ((128 * p$q2) + 128), 1022), max(((256 * p$myid1
C) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. p$myid2 .and. p$myid
*2 .le. 1 + p$q2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$myid2, 128 * p$q2 + 1), min(128 *
*p$myid2 + 127, 128 * p$q2 + 128, 1022)
call hpf_nonlocal_insertd(hash$nonlocals, zz$data, i
*1 + i2 * zz$global$extent$0, hpf$heap$double(recv$buf$zz$825$index
* + counter$zz$825))
counter$zz$825 = counter$zz$825 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zz$825)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zz$827 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3)
*.le. min(128 * p$myid2 + 129, 128 * p$q2 + 128)) then
counter$zz$827 = counter$zz$827 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$myid2 +
*129, 128 * p$q2 + 128) - max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3)
* + 1)
endif
call hpf_buffer_alloc(counter$zz$827 * 8, recv$buf$zz$827)
call hpf_ptr_to_index(hpf$heap, recv$buf$zz$827, 8, recv$b
*uf$zz$827$index)
if (counter$zz$827 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$zz$827$index), co
*unter$zz$827, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 12, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$zz$827 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 2), ((128 * p$q2) + 1), 3
C) <= i2 <= min(((128 * p$myid2) + 129), ((128 * p$q2) + 128)), max(((256 * p$my
Cid1) + 1), 2) <= i1 <= min(((256 * p$myid1) + 256), 1023) ]---
C
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2) then
do i1 = max(256 * p$myid1 + 1, 2), min(256 * p$myid1 + 2
*56, 1023)
do i2 = max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3), min
*(128 * p$myid2 + 129, 128 * p$q2 + 128)
call hpf_nonlocal_insertd(hash$nonlocals, zz$data, i
*1 + i2 * zz$global$extent$0, hpf$heap$double(recv$buf$zz$827$index
* + counter$zz$827))
counter$zz$827 = counter$zz$827 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$zz$827)
endif
enddo
enddo
continue
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$za$835 = 0
if (p$q2 .eq. p$myid2 .and. max(256 * p$q1 + 1, 256 * p$my
*id1) .le. min(256 * p$q1 + 256, 256 * p$myid1 + 255, 1022) .and. m
*ax(128 * p$myid2 + 1, 2) .le. min(128 * p$myid2 + 128, 1023)) then
counter$za$835 = counter$za$835 + (min(256 * p$q1 + 256,
* 256 * p$myid1 + 255, 1022) - max(256 * p$q1 + 1, 256 * p$myid1) +
* 1) * (min(128 * p$myid2 + 128, 1023) - max(128 * p$myid2 + 1, 2)
*+ 1)
endif
call hpf_buffer_alloc(counter$za$835 * 8, recv$buf$za$835)
call hpf_ptr_to_index(hpf$heap, recv$buf$za$835, 8, recv$b
*uf$za$835$index)
if (counter$za$835 .gt. 0) then
call mpi_recv(hpf$heap$double(recv$buf$za$835$index), co
*unter$za$835, MPI_DOUBLE_PRECISION, p$q2 + 8 * p$q1, 17, p$cmap, r
*equest, ierr)
endif
C --< Unpack Loop From Recv For Nonlocal Read >--
counter$za$835 = 0
C
C Loop section ---[ max(((128 * p$myid2) + 1), 2) <= i2 <= min(((128
C * p$myid2) + 128), 1023), max(((256 * p$q1) + 1), (256 * p$myid1)) <= i1 <= mi
Cn(((256 * p$q1) + 256), ((256 * p$myid1) + 255), 1022) ]---
C
if (p$q2 .eq. p$myid2) then
do i1 = max(256 * p$q1 + 1, 256 * p$myid1), min(256 * p$
*q1 + 256, 256 * p$myid1 + 255, 1022)
do i2 = max(128 * p$myid2 + 1, 2), min(128 * p$myid2 +
* 128, 1023)
call hpf_nonlocal_insertd(hash$nonlocals, za$data, i
*1 + i2 * za$global$extent$0, hpf$heap$double(recv$buf$za$835$index
* + counter$za$835))
counter$za$835 = counter$za$835 + 1
enddo
enddo
endif
call hpf_buffer_free(recv$buf$za$835)
endif
enddo
enddo
continue
C
C --<< Iterations that access only local values >>--
C
C
C Loop section ---[ ((256 * p$myid1) + 2) <= j <= ((256 * p$myid1) + 255),
C ((128 * p$myid2) + 2) <= k <= ((128 * p$myid2) + 127) ]---
C
do k = 128 * p$myid2 + 2, 128 * p$myid2 + 127
do j = 256 * p$myid1 + 2, 256 * p$myid1 + 255
zu(zu$data + j - (zu$coord$0 * 256 + 1) + (k - (zu$coord$1 *
* 128 + 1)) * zu$local$extent$0) = zu(zu$data + j - (zu$coord$0 * 2
*56 + 1) + (k - (zu$coord$1 * 128 + 1)) * zu$local$extent$0) + 0.00
*41 * (za(za$data + j - (za$coord$0 * 256 + 1) + (k - (za$coord$1 *
* 128 + 1)) * za$local$extent$0) * (zz(zz$data + j - (zz$coord$0 *
*256 + 1) + (k - (zz$coord$1 * 128 + 1)) * zz$local$extent$0) - zz(
*zz$data + j + 1 - (zz$coord$0 * 256 + 1) + (k - (zz$coord$1 * 128
*+ 1)) * zz$local$extent$0)) - za(za$data + j - 1 - (za$coord$0 * 2
*56 + 1) + (k - (za$coord$1 * 128 + 1)) * za$local$extent$0) * (zz(
*zz$data + j - (zz$coord$0 * 256 + 1) + (k - (zz$coord$1 * 128 + 1)
*) * zz$local$extent$0) - zz(zz$data + j - 1 - (zz$coord$0 * 256 +
*1) + (k - (zz$coord$1 * 128 + 1)) * zz$local$extent$0)) - zb(zb$da
*ta + j - (zb$coord$0 * 256 + 1) + (k - (zb$coord$1 * 128 + 1)) * z
*b$local$extent$0) * (zz(zz$data + j - (zz$coord$0 * 256 + 1) + (k
*- (zz$coord$1 * 128 + 1)) * zz$local$extent$0) - zz(zz$data + j -
*(zz$coord$0 * 256 + 1) + (k - 1 - (zz$coord$1 * 128 + 1)) * zz$loc
*al$extent$0)) + zb(zb$data + j - (zb$coord$0 * 256 + 1) + (k + 1 -
* (zb$coord$1 * 128 + 1)) * zb$local$extent$0) * (zz(zz$data + j -
*(zz$coord$0 * 256 + 1) + (k - (zz$coord$1 * 128 + 1)) * zz$local$e
*xtent$0) - zz(zz$data + j - (zz$coord$0 * 256 + 1) + (k + 1 - (zz$
*coord$1 * 128 + 1)) * zz$local$extent$0)))
zv(zv$data + j - (zv$coord$0 * 256 + 1) + (k - (zv$coord$1 *
* 128 + 1)) * zv$local$extent$0) = zv(zv$data + j - (zv$coord$0 * 2
*56 + 1) + (k - (zv$coord$1 * 128 + 1)) * zv$local$extent$0) + 0.00
*41 * (za(za$data + j - (za$coord$0 * 256 + 1) + (k - (za$coord$1 *
* 128 + 1)) * za$local$extent$0) * (zr(zr$data + j - (zr$coord$0 *
*256 + 1) + (k - (zr$coord$1 * 128 + 1)) * zr$local$extent$0) - zr(
*zr$data + j + 1 - (zr$coord$0 * 256 + 1) + (k - (zr$coord$1 * 128
*+ 1)) * zr$local$extent$0)) - za(za$data + j - 1 - (za$coord$0 * 2
*56 + 1) + (k - (za$coord$1 * 128 + 1)) * za$local$extent$0) * (zr(
*zr$data + j - (zr$coord$0 * 256 + 1) + (k - (zr$coord$1 * 128 + 1)
*) * zr$local$extent$0) - zr(zr$data + j - 1 - (zr$coord$0 * 256 +
*1) + (k - (zr$coord$1 * 128 + 1)) * zr$local$extent$0)) - zb(zb$da
*ta + j - (zb$coord$0 * 256 + 1) + (k - (zb$coord$1 * 128 + 1)) * z
*b$local$extent$0) * (zr(zr$data + j - (zr$coord$0 * 256 + 1) + (k
*- (zr$coord$1 * 128 + 1)) * zr$local$extent$0) - zr(zr$data + j -
*(zr$coord$0 * 256 + 1) + (k - 1 - (zr$coord$1 * 128 + 1)) * zr$loc
*al$extent$0)) + zb(zb$data + j - (zb$coord$0 * 256 + 1) + (k + 1 -
* (zb$coord$1 * 128 + 1)) * zb$local$extent$0) * (zr(zr$data + j -
*(zr$coord$0 * 256 + 1) + (k - (zr$coord$1 * 128 + 1)) * zr$local$e
*xtent$0) - zr(zr$data + j - (zr$coord$0 * 256 + 1) + (k + 1 - (zr$
*coord$1 * 128 + 1)) * zr$local$extent$0)))
enddo
enddo
C
C Loop section ---[ 0 <= p$q2 <= 7, 0 <= p$q1 <= 3 ]---
C
do p$q1 = 0, 3
do p$q2 = 0, 7
if (p$myid1 .ne. p$q1 .or. p$myid2 .ne. p$q2) then
C --< Loop Counters >--
counter$zb$836 = 0
if (p$q1 .eq. p$myid1 .and. p$q2 .le. 1 + p$myid2 .and. p$
*myid2 .le. p$q2 .and. max(256 * p$myid1 + 1, 2) .le. min(256 * p$m
*yid1 + 256, 1023) .and. max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3)
*.le. min(128 * p$myid2 + 129, 128 * p$q2 + 128)) then
counter$zb$836 = counter$zb$836 + (min(256 * p$myid1 + 2
*56, 1023) - max(256 * p$myid1 + 1, 2) + 1) * (min(128 * p$myid2 +
*129, 128 * p$q2 + 128) - max(128 * p$myid2 + 2, 128 * p$q2 + 1, 3)
* + 1)
endif
cal