[PATCH] Extend ScalarCode to allow writing to guards
Richard Guenther
rguenth at tat.physik.uni-tuebingen.de
Fri Feb 14 22:07:46 UTC 2003
Hi!
The following patch adds write-to-(external)-guards capability to
ScalarCode. This allows one to use the same functor for ScalarCode
and the external guards filler. Ideally this would allow for n-stage
computation without internal guards update for n*m sized internal guards,
too, but this needs prevention of internal guards fill (working on it).
The problem remains, that ScalarCodeInfo::lower_m/upper_m are not per
argument, and such prevent from storing into full 1-guard-layer field
with reading from 2-guard-layer field (cannot take the neccesarry view
of the 1-guard-layer field).
The extension comes with a new test.
Ok?
Richard.
===== MultiArgEvaluator.h 1.5 vs edited =====
--- 1.5/r2/src/Evaluator/MultiArgEvaluator.h Fri Feb 14 21:39:39 2003
+++ edited/MultiArgEvaluator.h Fri Feb 14 23:05:22 2003
@@ -173,6 +173,8 @@
Pooma::beginExpression();
+ // Should use info.readers() here - but readers/writers are mutually
+ // exclusive so this (or the latter) seems not to be a great idea.
applyMultiArg(multiArg, UpdateNotifier());
MultiArgEvaluator<Evaluator_t>::evaluate(multiArg, function,
===== ScalarCodeInfo.h 1.1 vs edited =====
--- 1.1/r2/src/Evaluator/ScalarCodeInfo.h Mon May 13 17:47:34 2002
+++ edited/ScalarCodeInfo.h Fri Feb 14 22:56:48 2003
@@ -105,12 +105,16 @@
dimensions_m = n;
lower_m.resize(n);
upper_m.resize(n);
+ wlower_m.resize(n);
+ wupper_m.resize(n);
int i;
for (i = 0; i < n; ++i)
{
lower_m[i] = 0;
upper_m[i] = 0;
+ wlower_m[i] = 0;
+ wupper_m[i] = 0;
}
}
@@ -123,6 +127,21 @@
{
return upper_m[i];
}
+
+ // Extend the evaluation domain into the guard layers by the amount
+ // specified with g. Needs to be less or equal the guard layer specification
+ // with lowerExtent() and upperExtent().
+
+ template <int Dim>
+ void evaluationExtent(const GuardLayers<Dim> &g)
+ {
+ PAssert(dimensions_m == Dim);
+ for (int i = 0; i < Dim; ++i)
+ {
+ wlower_m[i] = g.lower(i);
+ wupper_m[i] = g.upper(i);
+ }
+ }
void write(int i, bool f)
{
@@ -175,8 +194,8 @@
{
ret[d] =
Interval<1>(
- lower_m[d],
- domain[d].last() - domain[d].first() + lower_m[d]
+ lower_m[d]-wlower_m[d],
+ domain[d].last() - domain[d].first() + lower_m[d] + wupper_m[d]
);
}
return ret;
@@ -194,6 +213,8 @@
int dimensions_m;
Extents_t upper_m;
Extents_t lower_m;
+ Extents_t wupper_m;
+ Extents_t wlower_m;
BoolVector_t useGuards_m;
BoolVector_t writers_m;
BoolVector_t readers_m;
===== tests/makefile 1.7 vs edited =====
--- 1.7/r2/src/Evaluator/tests/makefile Fri Feb 14 21:39:39 2003
+++ edited/tests/makefile Fri Feb 14 21:57:09 2003
@@ -36,7 +36,7 @@
TESTS = compressibleTest1 \
evaluatorTest1 evaluatorTest2 evaluatorTest3 evaluatorTest4 \
- evaluatorTest5 \
+ evaluatorTest5 evaluatorTest6 \
ReductionTest1 ReductionTest2 ReductionTest3 ReductionTest4
default:: build
// -*- C++ -*-
// ACL:license
// ----------------------------------------------------------------------
// This software and ancillary information (herein called "SOFTWARE")
// called POOMA (Parallel Object-Oriented Methods and Applications) is
// made available under the terms described here. The SOFTWARE has been
// approved for release with associated LA-CC Number LA-CC-98-65.
//
// Unless otherwise indicated, this SOFTWARE has been authored by an
// employee or employees of the University of California, operator of the
// Los Alamos National Laboratory under Contract No. W-7405-ENG-36 with
// the U.S. Department of Energy. The U.S. Government has rights to use,
// reproduce, and distribute this SOFTWARE. The public may copy, distribute,
// prepare derivative works and publicly display this SOFTWARE without
// charge, provided that this Notice and any statement of authorship are
// reproduced on all copies. Neither the Government nor the University
// makes any warranty, express or implied, or assumes any liability or
// responsibility for the use of this SOFTWARE.
//
// If SOFTWARE is modified to produce derivative works, such modified
// SOFTWARE should be clearly marked, so as not to confuse it with the
// version available from LANL.
//
// For more information about POOMA, send e-mail to pooma at acl.lanl.gov,
// or visit the POOMA web page at http://www.acl.lanl.gov/pooma/.
// ----------------------------------------------------------------------
// ACL:license
//-----------------------------------------------------------------------------
// evaluatorTest5 - testing ScalarCode and direct external bounds computation
//-----------------------------------------------------------------------------
#include "Pooma/Pooma.h"
#include "Pooma/Arrays.h"
#include "Pooma/Fields.h" // for PerformUpdateTag() only!
#include "Evaluator/ScalarCode.h"
#include "Utilities/Tester.h"
#include <iostream>
// dummy operation
template <int extent>
struct Store
{
Store(int val) : val_m(val) {}
template<class A>
inline void operator()(const A &a, const Loc<1> &i) const
{
a(i) = val_m;
}
void scalarCodeInfo(ScalarCodeInfo& i) const
{
i.arguments(1);
i.dimensions(1);
i.lowerExtent(0) = 2;
i.upperExtent(0) = 2;
i.evaluationExtent(GuardLayers<1>(extent));
i.write(0, true);
i.useGuards(0, true);
}
const int val_m;
};
int main(int argc, char *argv[])
{
// Initialize POOMA and output stream, using Tester class
Pooma::initialize(argc, argv);
Pooma::Tester tester(argc, argv);
Pooma::blockingExpressions(true);
Interval<1> domain(0, 7);
DomainLayout<1> layout(domain, GuardLayers<1>(2));
UniformRectilinearMesh<1> mesh(layout);
Centering<1> cell = canonicalCentering<1>(VertexType, Continuous);
Field<UniformRectilinearMesh<1>, int, Brick>
a(cell, layout, mesh);
// init all of a
a.all() = 0;
tester.out() << a.all() << std::endl;
tester.check("guard init", a(-2) == 0 && a(-1) == 0
&& a(8) == 0 && a(9) == 0);
// zero-extent Store into a
(ScalarCode<Store<0> >(1))(a);
tester.out() << a.all() << std::endl;
tester.check("guard init", a(-2) == 0 && a(-1) == 0
&& a(8) == 0 && a(9) == 0);
// one-extent Store into a
(ScalarCode<Store<1> >(2))(a);
tester.out() << a.all() << std::endl;
tester.check("guard init", a(-2) == 0 && a(-1) == 2
&& a(8) == 2 && a(9) == 0);
// two-extent Store into a
(ScalarCode<Store<2> >(3))(a);
tester.out() << a.all() << std::endl;
tester.check("guard init", a(-2) == 3 && a(-1) == 3
&& a(8) == 3 && a(9) == 3);
int retval = tester.results("evaluatorTest6 (ScalarCode)");
Pooma::finalize();
return retval;
}
// ACL:rcsinfo
// ----------------------------------------------------------------------
// $RCSfile: evaluatorTest2.cpp,v $ $Author: pooma $
// $Revision: 1.7 $ $Date: 2003/01/29 19:32:07 $
// ----------------------------------------------------------------------
// ACL:rcsinfo
More information about the pooma-dev
mailing list