Generate something resembling PPD iteration code.

diff --git a/src/ofc/generators/onetep/LoopTree.scala b/src/ofc/generators/onetep/LoopTree.scala
index 6ce34cf88b5c2204faa849fa78963a6978984833..f6b71d042aabd79caa893b5433ede437bf5764cc 100644 (file)
--- a/src/ofc/generators/onetep/LoopTree.scala
+++ b/src/ofc/generators/onetep/LoopTree.scala
@@ -81,7 +81,7 @@ class LoopNest(sortedIndices: List[Index]) {
   def generateCode : String = {
     val code = new StringBuilder()
     declarations = base.collectDeclarations(nameManager)
-    code append declarations.mkString("\n")
+    code append declarations.mkString("\n") + "\n\n"
 
     val generationVisitor = new GenerationVisitor
     base.accept(generationVisitor)
@@ -108,6 +108,11 @@ class LoopNest(sortedIndices: List[Index]) {
     }
 
     def visitFragment(fragment: Fragment) {
+      fragment match {
+        case (c: ConsumerFragment) => 
+        case (p: ProducerFragment) => code append "!"+p.generate(nameManager)+"\n"
+        case (t: TransformFragment) =>
+      }
     }
 
     def getCode = code.mkString
@@ -124,7 +129,7 @@ trait Fragment {
 class ConsumerFragment(parent: IterationSpace, dependencies: Set[Fragment])  extends Fragment {
   def getAllFragments = Set(this)
   def getDependencies = dependencies
-  def collectDeclarations(nameManager: NameManager) = Set[String]()
+  def collectDeclarations(nameManager: NameManager) = parent.getIndices.flatMap(_.getDeclarations(nameManager))
   def accept(visitor: LoopTreeVisitor) = visitor.visitFragment(this)
   override def toString = "Consumer: " + parent.toString
 }
@@ -132,15 +137,16 @@ class ConsumerFragment(parent: IterationSpace, dependencies: Set[Fragment])  ext
 class ProducerFragment(parent: IterationSpace, dependencies: Set[Fragment])  extends Fragment {
   def getAllFragments = Set(this)
   def getDependencies = dependencies
-  def collectDeclarations(nameManager: NameManager) = Set[String]()
+  def collectDeclarations(nameManager: NameManager) = parent.getIndices.flatMap(_.getDeclarations(nameManager))
   def accept(visitor: LoopTreeVisitor) = visitor.visitFragment(this)
+  def generate(nameManager: NameManager) = parent.getProducerGenerator.get.generate(nameManager)
   override def toString = "Producer: " + parent.toString
 }
 
 class TransformFragment(parent: IterationSpace, dependencies: Set[Fragment])  extends Fragment {
   def getAllFragments = Set(this)
   def getDependencies = dependencies
-  def collectDeclarations(nameManager: NameManager) = Set[String]()
+  def collectDeclarations(nameManager: NameManager) = parent.getIndices.flatMap(_.getDeclarations(nameManager))
   def accept(visitor: LoopTreeVisitor) = visitor.visitFragment(this)
   override def toString = "Transform: " + parent.toString
 }

diff --git a/src/ofc/generators/onetep/Tree.scala b/src/ofc/generators/onetep/Tree.scala
index 5dff2b05fe89aa636f06a84c628d207e722a2435..78ac56b90ee0b6a0ccbde8464a356e896f6b97b1 100644 (file)
--- a/src/ofc/generators/onetep/Tree.scala
+++ b/src/ofc/generators/onetep/Tree.scala
@@ -269,43 +269,99 @@ class PPDFunctionSet(val basis : String, data : String) extends FunctionSet {
 
   class PPDIndex(parent: PPDFunctionSet) extends DiscreteIndex {
     var denseIndexNames : List[String] = Nil
+    var startNames : List[String] = Nil
+    var finishNames : List[String] = Nil
+    var offsetNames : List[String] = Nil
+    var ppdPoint : String = ""
 
     def getName = "ppd_index"
+    def getPPDPoint = ppdPoint
+    def getStartNames = startNames
+    def getFinishNames = finishNames
+    def getOffsetNames = offsetNames
     def getDependencies = Set[Index](parent.getSphereIndex)
     def getDensePPDIndices = denseIndexNames
 
-    //TODO: def getDenseWidth = parent.getSphereIndex.getSphere + "%n_ppds_sphere"
     def getDenseWidth(names: NameManager) = parent.basis+"%max_n_ppds_sphere"
 
     def generateIterationHeader(names: NameManager) = {
-      val initDense = "call basis_find_ppd_in_neighbour(" + denseIndexNames.mkString(",") + ", &\n" +
+      val findPPD = "call basis_find_ppd_in_neighbour(" + denseIndexNames.mkString(",") + ", &\n" +
         parent.getSphere(names) + "%ppd_list(1," + names(this) + "), &\n" +
         parent.getSphere(names) + "%ppd_list(2," + names(this) + "), &\n" +
         "pub_cell%n_ppds_a1, pub_cell%n_ppds_a2, pub_cell%n_ppds_a3)"
 
+      val computeRanges = for (dim <- 1 to 2) yield {
+        val tb = parent.getTightbox(names)
+
+        "call basis_lims_1d_in_ppd_in_tight("+startNames(dim)+", "+finishNames(dim)+", "+offsetNames(dim)+", &\n" +
+        denseIndexNames(dim)+", "+tb+"%start_ppds2, "+tb+"%finish_ppds2, &\n" +
+        tb+"%start_pts2, "+tb+"%finish_pts2, pub_cell%n_pt"+dim+")"
+      }
+
       val loopDeclaration = "do "+names(this)+"=1,"+parent.getSphere(names)+"%n_ppds_sphere"
 
-      initDense + "\n" + loopDeclaration
+      val ppdOffsetCalc = ppdPoint + " = " + parent.getSphere(names)+"%offset + ("+names(this)+"-1)*pub_cell%n_pts &\n"+
+      "+ ("+startNames(2)+"-1)*pub_cell%n_pt2*pub_cell%n_pt1 &\n"+
+      "+ ("+startNames(1)+"-1)*pub_cell%n_pt1 + ("+startNames(0)+"-1)"
+
+      (List(findPPD) ++ computeRanges ++ List(loopDeclaration) ++ List(ppdOffsetCalc)).mkString("\n")
     }
 
     def generateIterationFooter(names: NameManager) = "end do"
 
     def getDeclarations(names: NameManager) = {
       denseIndexNames = (for (dim <- 0 to 2) yield names.newIdentifier("derived_ppd_position_"+dim)).toList
-      denseIndexNames.map(x => "integer :: " + x) ++ List("integer :: "+names(this))
+      startNames = (for (dim <- 0 to 2) yield names.newIdentifier("tightbox_start_"+dim)).toList
+      finishNames = (for (dim <- 0 to 2) yield names.newIdentifier("tightbox_finish_"+dim)).toList
+      offsetNames = (for (dim <- 0 to 2) yield names.newIdentifier("tightbox_offset_"+dim)).toList
+      ppdPoint = names.newIdentifier("fa_point")
+      (denseIndexNames++finishNames++offsetNames++Some(ppdPoint)).map(x => "integer :: " + x) ++ List("integer :: "+names(this))
     }
   }
 
   class IntraPPDIndex(parent: PPDFunctionSet, dimension: Int) extends SpatialIndex {
+    var tbPoint : String = ""
+
     def getName = "intra_ppd_index_" + dimension
-    def getDependencies = Set[Index](parent.getPPDIndex)
+    private def getPPDIndex = parent.getPPDIndex
+    def getDependencies = {
+      val parentIndex = if (dimension < parent.getSpatialIndices.size-1) 
+        Some(parent.getSpatialIndices(dimension+1)) 
+      else 
+        None
+
+      Set[Index](getPPDIndex) ++ parentIndex
+    }
     def getDenseWidth(names: NameManager) = "pub_cell%total_pt"+(dimension+1)
-    def generateIterationHeader(names: NameManager) = "do "+names(this)+"=1,"+"pub_cell%n_pt"+(dimension+1)
-    def generateIterationFooter(names: NameManager) = "end do"
-    def getDeclarations(names: NameManager) = List("integer :: "+names(this))
+    def generateIterationHeader(names: NameManager) = {
+      val findPoint = tbPoint + " = " + 
+        names(this) + " - " + getPPDIndex.getStartNames(dimension) + " + " +
+        getPPDIndex.getOffsetNames(dimension) + " + 1"
+
+      val header = "do "+names(this)+"="+getPPDIndex.getStartNames(dimension)+","+getPPDIndex.getFinishNames(dimension)
+
+      List(findPoint, header).mkString("\n")
+    }
+
+    def generateIterationFooter(names: NameManager) = {
+      val incPoint = if (dimension == 0) Some(getPPDIndex.ppdPoint + " = " + getPPDIndex.ppdPoint + " + 1") else None
+      val jumpOffset = "pub_cell%n_pt"+(dimension+1)+"-" + 
+                       getPPDIndex.getFinishNames(dimension)+"+"+
+                       getPPDIndex.getStartNames(dimension)+"-1"
+      val jumpPoint = (List(getPPDIndex.ppdPoint + " = " + getPPDIndex.ppdPoint + " + (" + jumpOffset +")") ++
+                      (for (dim <- 0 until dimension) yield "pub_cell%n_pt"+(dim+1))).mkString("*")
+      val endLoop = "end do"
+
+      (incPoint ++ List(endLoop, jumpPoint)).mkString("\n")
+    }
+
+    def getDeclarations(names: NameManager) = {
+      tbPoint = names.newIdentifier("tb_pt"+(dimension+1))
+      List("integer :: "+names(this), "integer :: "+tbPoint)
+    }
 
     override def getDensePosition(names: NameManager) = 
-      parent.getPPDIndex.getDensePPDIndices(dimension) + "*pub_cell%n_pt"+(dimension+1) + " + " + names(this)
+      tbPoint
   }
 
   val ppdIndex = new PPDIndex(this)
@@ -315,6 +371,7 @@ class PPDFunctionSet(val basis : String, data : String) extends FunctionSet {
   def getPPDIndex = ppdIndex
   def getSphereIndex = sphereIndex
   def getSphere(names: NameManager) = basis + "%spheres("+names(getSphereIndex)+")"
+  def getTightbox(names: NameManager) = basis + "%tight_boxes("+names(getSphereIndex)+")"
 
   def getNumSpheres(names: NameManager) = {
     // TODO: This number is dependent on the parallel distribution
@@ -327,13 +384,7 @@ class PPDFunctionSet(val basis : String, data : String) extends FunctionSet {
 
   def getProducerGenerator = Some(new ProducerGenerator {
     def generate(names: NameManager) = {
-      val offset = getSphere(names)+"%offset + &\n" + 
-        "("+names(getPPDIndex)+"-1)*pub_cell%n_pts - 1 + &\n" +
-        "(" + names(spatialIndices(2)) + "-1)*pub_cell%n_pt2*pub_cell%n_pt1 + &\n" +
-        "(" + names(spatialIndices(1)) + "-1)*pub_cell%n_pt1 + &\n" +
-        names(spatialIndices(0))
-
-      data+"("+offset+")"
+      data+"("+getPPDIndex.getPPDPoint+")"
     }
   })
 }