--- /dev/null
+package ofc.codegen
+
+trait Expression
--- /dev/null
+package ofc.codegen
+
+class IterationTemplate {
+}
--- /dev/null
+package ofc.codegen
+
+class Symbol(name: String)
call match {
case Some(FunctionCall(matType, params)) => (matType, params) match {
- case (Identifier("SPAM3"), ParameterList(StringParameter(name))) =>
- dictionary.matrices += (id -> new SPAM3(name))
+ //case (Identifier("SPAM3"), ParameterList(StringParameter(name))) =>
+ // dictionary.matrices += (id -> new SPAM3(name))
case _ => throw new InvalidInputException("Unknown usage of type: "+matType.name)
}
case _ => throw new InvalidInputException("Undefined concrete type for matrix: "+id.name)
call match {
case Some(FunctionCall(fSetType, params)) => (fSetType, params) match {
- case (Identifier("PPDFunctionSet"), ParameterList(StringParameter(basis), StringParameter(data))) =>
- dictionary.functionSets += id -> new PPDFunctionSet(basis, data)
+ //case (Identifier("PPDFunctionSet"), ParameterList(StringParameter(basis), StringParameter(data))) =>
+ // dictionary.functionSets += id -> new PPDFunctionSet(basis, data)
case _ => throw new InvalidInputException("Unknown usage of type: "+fSetType.name)
}
case _ => throw new InvalidInputException("Undefined concrete type for function set: "+id.name)
def buildDefinition(definition : parser.Definition) {
val builder = new TreeBuilder(dictionary)
val assignment = builder(definition.term, definition.expr)
- val codeGenerator = new CodeGenerator()
- codeGenerator(assignment)
+ //val codeGenerator = new CodeGenerator()
+ //codeGenerator(assignment)
}
def buildDefinitions(statements : List[parser.Statement]) {
package ofc.generators.onetep
-
+/*
class Assignment(indexBindings: IndexBindings, lhs: DataSpace, rhs: IterationSpace) extends IterationSpace {
def getIndexBindings = indexBindings
def getOperands = List(rhs)
def getTransformGenerator = None
def getProducerGenerator = None
}
+*/
package ofc.generators.onetep
import scala.collection.mutable.HashMap
-
+/*
class NameManager {
var nextIndexID = 0
val names = new HashMap[Index, String]()
// We now generate the actual loop for space. This may involve a composite iteration construction
}
}
+*/
package ofc.generators.onetep
-
+/*
class GeneralInnerProduct(operands: List[IterationSpace], removedIndices: Set[Index]) extends IterationSpace {
class DenseSpatialIndex(parent: GeneralInnerProduct, original: SpatialIndex) extends SpatialIndex{
def getTransformGenerator = None
def getProducerGenerator = None
}
-
-
+*/
package ofc.generators.onetep
+import ofc.codegen.Expression
+/*
object Index {
def sort(indices: Traversable[Index]) : List[Index] = {
def helper(input: Index, seen: collection.mutable.Set[Index]) : List[Index] =
indices.toList.flatMap(helper(_, seen))
}
}
+*/
trait Index {
def getName : String
- def getDependencies : Set[Index]
- def getDenseWidth(names: NameManager) : String
- def getDensePosition(names: NameManager) : String = names(this)
- def generateIterationHeader(names: NameManager) : String
- def generateIterationFooter(names: NameManager) : String
- def getDeclarations(names: NameManager) : List[String]
+ def getMappingFunction : Expression
+ def getMinimumValue : Expression
+ def getLength : Expression
+ def isRandomAccess : Boolean
}
trait SpatialIndex extends Index
package ofc.generators.onetep
+import ofc.codegen.IterationTemplate
+/*
object IterationSpace {
def sort(spaces : Traversable[IterationSpace]) : List[IterationSpace] = {
def helper(input: IterationSpace, seen: collection.mutable.Set[IterationSpace]) : List[IterationSpace] =
def flattenPostorder(term: IterationSpace) : Traversable[IterationSpace] =
term.getOperands.toTraversable.flatMap(flattenPostorder(_)) ++ List(term)
}
+*/
trait IterationSpace {
def getOperands : List[IterationSpace]
def getSpatialIndices : List[SpatialIndex]
def getDiscreteIndices : List[DiscreteIndex]
- def getExternalIndices : Set[Index]
- def getInternalIndices : Set[Index] = (getSpatialIndices ++ getDiscreteIndices).toSet
- def getIndices : Set[Index] = getInternalIndices ++ getExternalIndices
+ def getIndices : Set[Index] = (getSpatialIndices ++ getDiscreteIndices).toSet
def getDependencies : Set[IterationSpace] = {
val operands = getOperands
operands.toSet ++ operands.flatMap(_.getDependencies)
}
-
- // Code generation
- def getConsumerGenerator : Option[ConsumerGenerator]
- def getTransformGenerator : Option[TransformGenerator]
- def getProducerGenerator : Option[ProducerGenerator]
+ def getReader : IterationTemplate
}
trait DataSpace extends IterationSpace {
def getOperands = Nil
- def getConsumerGenerator = None
- def getTransformGenerator = None
}
trait Matrix extends DataSpace
package ofc.generators.onetep
-
+/*
class Laplacian(op: IterationSpace) extends IterationSpace {
def getOperands = List(op)
def getSpatialIndices = op.getSpatialIndices
def getTransformGenerator = None
def getProducerGenerator = None
}
-
-
+*/
Stores the configuration of indices we will use for code generation.
*/
+/*
object LoopNest {
def apply(root: IterationSpace) : LoopNest = {
val sortedSpaces = IterationSpace.flattenPostorder(root)
result.toList
}
}
-
-
+*/
package ofc.generators.onetep
class PPDFunctionSet(val basis : String, data : String) extends FunctionSet {
+/*
class SphereIndex(parent: PPDFunctionSet) extends DiscreteIndex {
def getName = "sphere_index"
def getDependencies = Set()
data+"("+getPPDIndex.getPPDPoint+")"
}
})
+*/
}
package ofc.generators.onetep
-
+/*
class Reciprocal(op: IterationSpace) extends IterationSpace {
class BlockIndex(parent: Reciprocal, dimension: Int, original: SpatialIndex) extends SpatialIndex {
def getName = "reciprocal_index_" + dimension
def getTransformGenerator = None
def getProducerGenerator = None
}
-
-
+*/
package ofc.generators.onetep
-
+/*
class SPAM3(name : String) extends Matrix {
override def toString = name
def getName = name
def getProducerGenerator = None
}
-
-
+*/
package ofc.generators.onetep
-
+/*
class Scalar(value: Double) extends DataSpace {
def getSpatialIndices = Nil
def getDiscreteIndices = Nil
def generate(names: NameManager) = value.toString
})
}
-
-
+*/
package ofc.generators.onetep
-
+/*
class SpatialRestriction(op: IterationSpace) extends IterationSpace {
class RestrictedIndex(parent: SpatialRestriction, dimension: Int) extends SpatialIndex {
def getName = "restriction_index_" + dimension
def getTransformGenerator = None
def getProducerGenerator = None
}
-
-
+*/
import ofc.parser.Identifier
import ofc.{InvalidInputException,UnimplementedException}
-trait ConsumerGenerator {
- def generate(names: NameManager, indices: Map[Index,String], values : Map[IterationSpace, String]) : String
-}
-
-trait ProducerGenerator {
- def generate(names: NameManager) : String
-}
-
-trait TransformGenerator {
- def generate(names: NameManager) : String
-}
-
class BindingIndex(name : String) {
override def toString() = name
}
val rhsTree = buildExpression(rhs)
lhsTree match {
- case (lhsTree: DataSpace) => new Assignment(indexBindings, lhsTree, rhsTree)
+ //case (lhsTree: DataSpace) => new Assignment(indexBindings, lhsTree, rhsTree)
case _ => throw new InvalidInputException("Non-assignable expression on LHS of assignment.")
}
}
term match {
case (t: IndexedTerm) => buildIndexedTerm(t)
+/*
case ScalarConstant(s) => new Scalar(s)
case Multiplication(a, b) =>
new GeneralInnerProduct(List(buildExpression(a), buildExpression(b)), Set())
case Operator(Identifier("laplacian"), List(op)) => new Laplacian(buildExpression(op))
case Operator(Identifier("fftbox"), List(op)) => new SpatialRestriction(buildExpression(op))
case Operator(Identifier(name), _) => throw new UnimplementedException("Unknown or incorrectly called operator: "+name)
+*/
}
}
}
projects / francis / ofc.git / commitdiff