[PATCH] kill POOMA_REORDER_ITERATES

[Richard Guenther <rguenth@xxxxxxxxxxxxxxxxxxxxxxxxxxx>]

This patch kills POOMA_REORDER_ITERATES, i.e. assumes it is always set.
It was used inconsistently before anyways and the stub scheduler doesn't
reorder iterates anyway and the SerialAsync does so anyway.  So this
reduces source code complexity.

Not tested, but looks obvious.  Ok?

Richard.


2004Aug16  Richard Guenther <richard.guenther@xxxxxxxxxxxxxxxx>

	* configure: remove traces of POOMA_REORDER_ITERATES.
	src/Evaluator/Evaluator.h: likewise.
	src/Evaluator/MultiArgEvaluator.h: likewise.
	src/Evaluator/Reduction.h: likewise.
	src/Pooma/Pooma.cmpl.cpp: likewise.
	src/Tulip/SendReceive.h: likewise.

===== r2/configure 1.17 vs edited =====
--- 1.17/r2/configure	2004-07-15 16:22:32 +02:00
+++ edited/r2/configure	2004-08-16 16:47:58 +02:00
@@ -1498,10 +1498,6 @@
 	}
     }
 
-  $pooma_reorder_iterates = $threads || ($scheduler eq "serialAsync");
-
-  add_yesno_define("POOMA_REORDER_ITERATES", $pooma_reorder_iterates);
-
   # OpenMP support
   if (scalar @{$arghash{$openmpnm}} > 1)
     {
===== r2/src/Evaluator/Evaluator.h 1.3 vs edited =====
--- 1.3/r2/src/Evaluator/Evaluator.h	2003-10-23 14:41:01 +02:00
+++ edited/r2/src/Evaluator/Evaluator.h	2004-08-16 16:44:43 +02:00
@@ -153,12 +153,8 @@
   void evaluate(const LHS& lhs, const Op& op, const RHS& rhs) const
   {
     typedef typename KernelTag<LHS,RHS>::Kernel_t Kernel_t;
-#if POOMA_REORDER_ITERATES
     Pooma::Iterate_t *iterate = ::generateKernel(lhs, op, rhs, Kernel_t());
     Pooma::scheduler().handOff(iterate);
-#else
-    KernelEvaluator<Kernel_t>::evaluate(lhs, op, rhs);
-#endif
   }
 };
 
===== r2/src/Evaluator/MultiArgEvaluator.h 1.15 vs edited =====
--- 1.15/r2/src/Evaluator/MultiArgEvaluator.h	2004-07-15 16:47:32 +02:00
+++ edited/r2/src/Evaluator/MultiArgEvaluator.h	2004-08-16 16:45:01 +02:00
@@ -220,14 +220,10 @@
 		const Kernel &)
   {
     Kernel kernelf(function, domain);
-#if 1 || POOMA_REORDER_ITERATES
     Pooma::Iterate_t *iterate =
       new MultiArgKernel<A1, Kernel>(a1, kernelf,
 				     info.writers(), info.readers());
     Pooma::scheduler().handOff(iterate);
-#else
-    kernelf(a1);
-#endif
   }
 
 };
===== r2/src/Evaluator/Reduction.h 1.10 vs edited =====
--- 1.10/r2/src/Evaluator/Reduction.h	2004-01-29 10:28:58 +01:00
+++ edited/r2/src/Evaluator/Reduction.h	2004-08-16 16:45:20 +02:00
@@ -168,14 +168,9 @@
   {
     typedef typename KernelTag1<Expr>::Kernel_t Kernel_t;
 
-#if POOMA_REORDER_ITERATES
     Pooma::Iterate_t *iterate = 
       new ReductionKernel<T, Op, Expr, Kernel_t>(ret, op, e, csem);
     Pooma::scheduler().handOff(iterate);
-#else
-    ReductionEvaluator<Kernel_t>::evaluate(ret, op, e);
-    csem.incr();
-#endif
   }
   
   template<class T, class Op, class Expr>
===== r2/src/Pooma/Pooma.cmpl.cpp 1.3 vs edited =====
--- 1.3/r2/src/Pooma/Pooma.cmpl.cpp	2004-01-17 16:20:23 +01:00
+++ edited/r2/src/Pooma/Pooma.cmpl.cpp	2004-08-16 16:47:24 +02:00
@@ -803,10 +803,6 @@
     SystemContext_t::runSomething();
   }
 
-# elif POOMA_REORDER_ITERATES
-
-  CTAssert(NO_SUPPORT_FOR_THREADS_WITH_MESSAGING);
-
 # else // we're using the serial scheduler, so we only need to get messages
 
   while (Pooma::incomingMessages())
===== r2/src/Tulip/SendReceive.h 1.4 vs edited =====
--- 1.4/r2/src/Tulip/SendReceive.h	2004-01-07 09:54:09 +01:00
+++ edited/r2/src/Tulip/SendReceive.h	2004-08-16 16:47:00 +02:00
@@ -93,11 +93,9 @@
     hintAffinity(engineFunctor(view_m,
 			       DataObjectRequest<BlockAffinity>()));
 
-#if POOMA_REORDER_ITERATES
     // Priority interface was added to r2 version of serial async so that
     // message iterates would run before any other iterates.
     priority(-1);
-#endif
 
     DataObjectRequest<WriteRequest> writeReq(*this);
     DataObjectRequest<ReadRequest> readReq(writeReq);
@@ -158,11 +156,9 @@
     hintAffinity(engineFunctor(view,
 			       DataObjectRequest<BlockAffinity>()));
 
-#if POOMA_REORDER_ITERATES
     // Priority interface was added to r2 version of serial async so that
     // message iterates would run before any other iterates.
     priority(-1);
-#endif
 
     DataObjectRequest<WriteRequest> writeReq(*this);
     engineFunctor(view, writeReq);
@@ -181,38 +177,12 @@
   // registers a method that gets handled by cheetah when the appropriate
   // message arrives.
 
-#if !POOMA_REORDER_ITERATES
-
-  bool ready_m;
-
-  static void handle(This_t *me, IncomingView &viewMessage)
-  {
-    apply(me->view_m, viewMessage);
-    me->ready_m = true;
-  }
-
-  virtual void run()
-  {
-    ready_m = false;
-    Pooma::remoteEngineHandler()->request(fromContext_m, tag_m,
-					  This_t::handle, this);
-
-    while (!ready_m)
-    {
-      Pooma::poll();
-    }
-  }
-
-#else
-
   virtual void run()
   {
     Pooma::remoteEngineHandler()->request(fromContext_m, tag_m,
 					  This_t::apply, view_m);
   }
 
-#endif
-
 private:
 
   static void apply(const View &viewLocal, IncomingView &viewMessage)
@@ -302,11 +272,9 @@
     hintAffinity(engineFunctor(view_m,
 			       DataObjectRequest<BlockAffinity>()));
 
-#if POOMA_REORDER_ITERATES
     // Priority interface was added to r2 version of serial async so that
     // message send iterates would run before any other iterates.
     priority(-1);
-#endif
 
     DataObjectRequest<WriteRequest> writeReq(*this);
     DataObjectRequest<ReadRequest> readReq(writeReq);
@@ -384,11 +352,9 @@
     hintAffinity(engineFunctor(view,
 			       DataObjectRequest<BlockAffinity>()));
 
-#if POOMA_REORDER_ITERATES
     // Priority interface was added to r2 version of serial async so that
     // message receive iterates would run after any other iterates.
     priority(-1);
-#endif
 
     DataObjectRequest<WriteRequest> writeReq(*this);
     engineFunctor(view, writeReq);