From 14f03187eee407ce8562d31bd3c7d5802fadc7b6 Mon Sep 17 00:00:00 2001 From: Francis Russell Date: Fri, 21 Sep 2012 00:35:58 +0100 Subject: [PATCH] Remove previous Scala implementation. --- old/ofc/OFC.scala | 95 ----- old/ofc/codegen/AllocateStatement.scala | 16 - old/ofc/codegen/AssignStatement.scala | 11 - old/ofc/codegen/Comment.scala | 6 - old/ofc/codegen/ConditionalValue.scala | 15 - old/ofc/codegen/DeallocateStatement.scala | 12 - old/ofc/codegen/Expression.scala | 131 ------ old/ofc/codegen/ForLoop.scala | 8 - old/ofc/codegen/FortranGenerator.scala | 402 ------------------ old/ofc/codegen/FortranProperty.scala | 17 - old/ofc/codegen/Function.scala | 19 - old/ofc/codegen/FunctionCall.scala | 16 - old/ofc/codegen/FunctionCallStatement.scala | 6 - old/ofc/codegen/FunctionSignature.scala | 25 -- old/ofc/codegen/IfStatement.scala | 6 - old/ofc/codegen/Intrinsic.scala | 24 -- old/ofc/codegen/IterationContext.scala | 179 -------- old/ofc/codegen/NumericOperator.scala | 40 -- old/ofc/codegen/ScopeStatement.scala | 22 - old/ofc/codegen/Statement.scala | 9 - old/ofc/codegen/Symbol.scala | 38 -- old/ofc/codegen/Type.scala | 77 ---- old/ofc/expression/Assignment.scala | 5 - old/ofc/expression/Dictionary.scala | 32 -- old/ofc/expression/Expression.scala | 78 ---- old/ofc/expression/TreeBuilder.scala | 71 ---- old/ofc/generators/Generator.scala | 7 - old/ofc/generators/Onetep.scala | 156 ------- old/ofc/generators/onetep/Assignment.scala | 3 - old/ofc/generators/onetep/CodeGenerator.scala | 37 -- .../onetep/DensePsincToReciprocal.scala | 36 -- old/ofc/generators/onetep/Dictionary.scala | 40 -- old/ofc/generators/onetep/Field.scala | 6 - old/ofc/generators/onetep/FieldFragment.scala | 26 -- old/ofc/generators/onetep/Fragment.scala | 6 - .../generators/onetep/GenerationContext.scala | 7 - old/ofc/generators/onetep/InnerProduct.scala | 65 --- old/ofc/generators/onetep/Laplacian.scala | 93 ---- old/ofc/generators/onetep/NamedIndex.scala | 5 - .../generators/onetep/OnetepFunctions.scala | 71 ---- old/ofc/generators/onetep/OnetepTypes.scala | 89 ---- .../generators/onetep/OnetepVariables.scala | 15 - old/ofc/generators/onetep/Operand.scala | 13 - .../generators/onetep/PPDFunctionSet.scala | 185 -------- .../generators/onetep/ReciprocalToPsinc.scala | 38 -- old/ofc/generators/onetep/SPAM3.scala | 82 ---- old/ofc/generators/onetep/Scalar.scala | 6 - .../generators/onetep/ScalarFragment.scala | 13 - old/ofc/generators/onetep/ScalarLiteral.scala | 21 - old/ofc/generators/onetep/ScaledField.scala | 69 --- old/ofc/parser/Parser.scala | 67 --- old/ofc/parser/Statement.scala | 69 --- old/ofc/util/DirectedGraph.scala | 64 --- old/ofc/util/Graph.scala | 41 -- old/ofc/util/GraphBase.scala | 73 ---- old/ofc/util/Ordering.scala | 14 - old/ofc/util/Queue.scala | 61 --- old/ofc/util/UndirectedGraph.scala | 16 - 58 files changed, 2854 deletions(-) delete mode 100644 old/ofc/OFC.scala delete mode 100644 old/ofc/codegen/AllocateStatement.scala delete mode 100644 old/ofc/codegen/AssignStatement.scala delete mode 100644 old/ofc/codegen/Comment.scala delete mode 100644 old/ofc/codegen/ConditionalValue.scala delete mode 100644 old/ofc/codegen/DeallocateStatement.scala delete mode 100644 old/ofc/codegen/Expression.scala delete mode 100644 old/ofc/codegen/ForLoop.scala delete mode 100644 old/ofc/codegen/FortranGenerator.scala delete mode 100644 old/ofc/codegen/FortranProperty.scala delete mode 100644 old/ofc/codegen/Function.scala delete mode 100644 old/ofc/codegen/FunctionCall.scala delete mode 100644 old/ofc/codegen/FunctionCallStatement.scala delete mode 100644 old/ofc/codegen/FunctionSignature.scala delete mode 100644 old/ofc/codegen/IfStatement.scala delete mode 100644 old/ofc/codegen/Intrinsic.scala delete mode 100644 old/ofc/codegen/IterationContext.scala delete mode 100644 old/ofc/codegen/NumericOperator.scala delete mode 100644 old/ofc/codegen/ScopeStatement.scala delete mode 100644 old/ofc/codegen/Statement.scala delete mode 100644 old/ofc/codegen/Symbol.scala delete mode 100644 old/ofc/codegen/Type.scala delete mode 100644 old/ofc/expression/Assignment.scala delete mode 100644 old/ofc/expression/Dictionary.scala delete mode 100644 old/ofc/expression/Expression.scala delete mode 100644 old/ofc/expression/TreeBuilder.scala delete mode 100644 old/ofc/generators/Generator.scala delete mode 100644 old/ofc/generators/Onetep.scala delete mode 100644 old/ofc/generators/onetep/Assignment.scala delete mode 100644 old/ofc/generators/onetep/CodeGenerator.scala delete mode 100644 old/ofc/generators/onetep/DensePsincToReciprocal.scala delete mode 100644 old/ofc/generators/onetep/Dictionary.scala delete mode 100644 old/ofc/generators/onetep/Field.scala delete mode 100644 old/ofc/generators/onetep/FieldFragment.scala delete mode 100644 old/ofc/generators/onetep/Fragment.scala delete mode 100644 old/ofc/generators/onetep/GenerationContext.scala delete mode 100644 old/ofc/generators/onetep/InnerProduct.scala delete mode 100644 old/ofc/generators/onetep/Laplacian.scala delete mode 100644 old/ofc/generators/onetep/NamedIndex.scala delete mode 100644 old/ofc/generators/onetep/OnetepFunctions.scala delete mode 100644 old/ofc/generators/onetep/OnetepTypes.scala delete mode 100644 old/ofc/generators/onetep/OnetepVariables.scala delete mode 100644 old/ofc/generators/onetep/Operand.scala delete mode 100644 old/ofc/generators/onetep/PPDFunctionSet.scala delete mode 100644 old/ofc/generators/onetep/ReciprocalToPsinc.scala delete mode 100644 old/ofc/generators/onetep/SPAM3.scala delete mode 100644 old/ofc/generators/onetep/Scalar.scala delete mode 100644 old/ofc/generators/onetep/ScalarFragment.scala delete mode 100644 old/ofc/generators/onetep/ScalarLiteral.scala delete mode 100644 old/ofc/generators/onetep/ScaledField.scala delete mode 100644 old/ofc/parser/Parser.scala delete mode 100644 old/ofc/parser/Statement.scala delete mode 100644 old/ofc/util/DirectedGraph.scala delete mode 100644 old/ofc/util/Graph.scala delete mode 100644 old/ofc/util/GraphBase.scala delete mode 100644 old/ofc/util/Ordering.scala delete mode 100644 old/ofc/util/Queue.scala delete mode 100644 old/ofc/util/UndirectedGraph.scala diff --git a/old/ofc/OFC.scala b/old/ofc/OFC.scala deleted file mode 100644 index 688c069..0000000 --- a/old/ofc/OFC.scala +++ /dev/null @@ -1,95 +0,0 @@ -package ofc - -import scala.reflect.Manifest -import scala.reflect.Manifest.singleType -import java.io.FileReader -import parser.{Parser,Statement,Target,TargetAssignment,Identifier,ParseException,Definition} -import expression.{Dictionary,TreeBuilder} -import generators.Generator - -class InvalidInputException(s: String) extends Exception(s) -class UnimplementedException(s: String) extends Exception(s) -class LogicError(s: String) extends Exception(s) - -object OFC extends Parser { - - def main(args: Array[String]) { - if (args.isEmpty) { - Console.err.println("Specify input file.") - System.exit(1) - } - - val reader = new FileReader(args(0)) - - try { - val program = parseProgram(reader) - processAST(program) - } catch { - case e: ParseException => { - Console.err.println("Parse failure: "+e) - System.exit(1) - } - case e: InvalidInputException => { - Console.err.println("Semantic Error: "+e) - System.exit(1) - } - } finally { - reader.close - } - } - - private def filterStatements[T <: parser.Statement](statements : Seq[parser.Statement])(implicit m: Manifest[T]) = - statements.foldLeft(List[T]())((list, item) => item match { - case s if (singleType(s) <:< m) => s.asInstanceOf[T] :: list - case _ => list - }) - - private def getDeclarations(statements : Seq[parser.Statement]) : Map[parser.Identifier, parser.OFLType] = { - def getMappings(dl : parser.DeclarationList) = - for (name <- dl.names) yield - (name, dl.oflType) - - filterStatements[parser.DeclarationList](statements).flatMap(getMappings(_)).toMap - } - - private def buildDictionary(declarations : Map[parser.Identifier, parser.OFLType]) : Dictionary = { - import expression.{Matrix,FunctionSet,Index} - val dictionary = new Dictionary - - for(d <- declarations) { - // Find corresponding target-specific declaration if it exists. - d match { - case (id, parser.Matrix()) => dictionary.add(new Matrix(id)) - case (id, parser.FunctionSet()) => dictionary.add(new FunctionSet(id)) - case (id, parser.Index()) => dictionary.add(new Index(id)) - } - } - - dictionary - } - - private def processAST(statements : Seq[Statement]) = { - val declarations = getDeclarations(statements) - val dictionary = buildDictionary(declarations) - val treeBuilder = new TreeBuilder(dictionary) - - val definitions = filterStatements[Definition](statements) - - val definition = definitions match { - case Seq(singleDef) => singleDef - case _ => throw new InvalidInputException("OFL file should only have one definition.") - } - - val expressionTree = treeBuilder(definition) - val targetStatements = filterStatements[Target](statements) - - val generator : Generator = targetStatements match { - case Seq(Target(Identifier("ONETEP"))) => new generators.Onetep - case Seq(Target(Identifier(x))) => throw new InvalidInputException("Unknown target: " + x) - case _ => throw new InvalidInputException("OFL file should have single target statement.") - } - - val targetAssignments = filterStatements[TargetAssignment](statements) - generator.acceptInput(dictionary, expressionTree, targetAssignments) - } -} diff --git a/old/ofc/codegen/AllocateStatement.scala b/old/ofc/codegen/AllocateStatement.scala deleted file mode 100644 index 3782f7a..0000000 --- a/old/ofc/codegen/AllocateStatement.scala +++ /dev/null @@ -1,16 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -class AllocateStatement(array: Expression[_], size: Seq[Expression[IntType]]) extends Statement { - val arrayType = array.getType match { - case (at: ArrayType[_]) => at - case _ => throw new LogicError("Can only allocate an array expression.") - } - - if (size.length != arrayType.getRank) - throw new LogicError("Incorrect rank for array allocation.") - - def getArray : Expression[_] = array - def getSize : Seq[Expression[IntType]] = size - def getExpressions = array +: size -} diff --git a/old/ofc/codegen/AssignStatement.scala b/old/ofc/codegen/AssignStatement.scala deleted file mode 100644 index 791b24a..0000000 --- a/old/ofc/codegen/AssignStatement.scala +++ /dev/null @@ -1,11 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -class AssignStatement(lhs: Expression[_ <: Type], rhs: Expression[_ <: Type]) extends Statement { - if (lhs.getType != rhs.getType) - throw new LogicError("Assignment from incompatible type.") - - def getLHS : Expression[_] = lhs - def getRHS : Expression[_] = rhs - def getExpressions = List(lhs, rhs) -} diff --git a/old/ofc/codegen/Comment.scala b/old/ofc/codegen/Comment.scala deleted file mode 100644 index 01be110..0000000 --- a/old/ofc/codegen/Comment.scala +++ /dev/null @@ -1,6 +0,0 @@ -package ofc.codegen - -class Comment(value: String) extends Statement { - def getValue = value - def getExpressions = Nil -} diff --git a/old/ofc/codegen/ConditionalValue.scala b/old/ofc/codegen/ConditionalValue.scala deleted file mode 100644 index 84f4de5..0000000 --- a/old/ofc/codegen/ConditionalValue.scala +++ /dev/null @@ -1,15 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -class ConditionalValue[T <: Type](predicate: Expression[BoolType], ifTrue: Expression[T], ifFalse: Expression[T]) extends Expression[T] { - def foreach[U](f: Expression[_] => U) = List(predicate, ifTrue, ifFalse).foreach(f) - def getPredicate = predicate - def getIfTrue = ifTrue - def getIfFalse = ifFalse - def getType = { - if (ifTrue.getType != ifFalse.getType) - throw new LogicError("Parameters to ternary operator have different types") - else - ifTrue.getType - } -} diff --git a/old/ofc/codegen/DeallocateStatement.scala b/old/ofc/codegen/DeallocateStatement.scala deleted file mode 100644 index 39ddc21..0000000 --- a/old/ofc/codegen/DeallocateStatement.scala +++ /dev/null @@ -1,12 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -class DeallocateStatement(array: Expression[_ <: Type]) extends Statement { - array.getType match { - case (_: ArrayType[_]) => () - case _ => throw new LogicError("Can only deallocate an array expression.") - } - - def getArray : Expression[_] = array - def getExpressions = List(array) -} diff --git a/old/ofc/codegen/Expression.scala b/old/ofc/codegen/Expression.scala deleted file mode 100644 index b1433f1..0000000 --- a/old/ofc/codegen/Expression.scala +++ /dev/null @@ -1,131 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -object Expression { - implicit def fromInt(i: Int) : Expression[IntType] = new IntegerLiteral(i) - - def findReferencedVariables(expression: Expression[_]) : Set[VarSymbol[_]] = - findReferencedVariables(Some[Expression[_]](expression)) - - def findReferencedVariables(expressions: Traversable[Expression[_]]) : Set[VarSymbol[_]] = { - val vars = scala.collection.mutable.Set[VarSymbol[_]]() - expressions.foreach(_ match { - case (ref: VarRef[_]) => vars += ref.getSymbol - case x => vars ++= findReferencedVariables(x.toTraversable) - }) - - vars.toSet - } -} - -abstract class Expression[T <: Type] extends Traversable[Expression[_]] { - def getType : T - - // Field Operations - def +(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[T] = - new NumericOperator[T](NumericOperations.Add, this, rhs) - - def -(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[T] = - new NumericOperator[T](NumericOperations.Sub, this, rhs) - - def *(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[T] = - new NumericOperator[T](NumericOperations.Mul, this, rhs) - - def /(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[T] = - new NumericOperator[T](NumericOperations.Div, this, rhs) - - def %(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[T] = - new NumericOperator[T](NumericOperations.Mod, this, rhs) - - // Comparison Operations - def |<|(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[BoolType] = - new NumericComparison[T](NumericOperations.LT, this, rhs) - - def |<=|(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[BoolType] = - new NumericComparison[T](NumericOperations.LE, this, rhs) - - def |==|(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[BoolType] = - new NumericComparison[T](NumericOperations.EQ, this, rhs) - - def |!=|(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[BoolType] = - new NumericComparison[T](NumericOperations.NE, this, rhs) - - def |>|(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[BoolType] = - new NumericComparison[T](NumericOperations.GT, this, rhs) - - def |>=|(rhs: Expression[T])(implicit arg: HasProperty[T, Numeric]) : Expression[BoolType] = - new NumericComparison[T](NumericOperations.GE, this, rhs) - - def %[FieldType <: Type](field: FieldSymbol[FieldType])(implicit witness: <:<[this.type, Expression[StructType]]) : Expression[FieldType] = - new FieldAccess[FieldType](witness(this), field) - - def at[T <: Type](index: Expression[IntType]*)(implicit witness: <:<[this.type, Expression[ArrayType[T]]]) : Expression[T] = - new ArrayAccess(witness(this), index.toList) - - def unary_~[T <: Type]()(implicit witness: <:<[this.type, Expression[PointerType[T]]]) : Expression[T] = - new PointerDereference(witness(this)) -} - -trait LeafExpression { - def foreach[U](f: Expression[_] => U): Unit = () -} - -// Variable references -class VarRef[T <: Type](symbol: VarSymbol[T]) extends Expression[T] with LeafExpression { - def getSymbol = symbol - def getType = symbol.getType -} - -class FieldRef[T <: Type](symbol: FieldSymbol[T]) extends Expression[T] with LeafExpression { - def getSymbol = symbol - def getType = symbol.getType -} - -// Struct and array accesses -class FieldAccess[T <: Type](expression: Expression[StructType], field: FieldSymbol[T]) extends Expression[T] { - def foreach[U](f: Expression[_] => U) = f(expression) - def getStructExpression = expression - def getField = field - def getType = field.getType -} - -class ArrayAccess[E <: Type](expression: Expression[ArrayType[E]], index: Seq[Expression[IntType]]) extends Expression[E] { - if (index.size != expression.getType.getRank) - throw new LogicError("Array of rank "+expression.getType.getRank+" indexed with rank "+index.size+" index.") - - def foreach[U](f: Expression[_] => U) = (index :+ expression).foreach(f) - def getArrayExpression = expression - def getIndexExpressions = index - def getType = expression.getType.getElementType -} -class PointerDereference[E <: Type](expression: Expression[PointerType[E]]) extends Expression[E] { - def foreach[U](f: Expression[_] => U) = f(expression) - def getExpression = expression - def getType = expression.getType.getTargetType -} - -// Conversation -class Conversion[F <: Type, T <: Type](expression: Expression[F], toType: T)(implicit convertible: IsConvertible[F,T]) extends Expression[T] { - def this(expression: Expression[F])(implicit builder: TypeBuilder[T], convertible: IsConvertible[F,T]) - = this(expression, builder())(convertible) - - def getType = toType - def getExpression = expression - def foreach[U](f: Expression[_] => U) = expression.foreach(f) -} - -// Literals -class IntegerLiteral(value: Int) extends Expression[IntType] with LeafExpression { - def getValue = value - def getType = new IntType -} - -class FloatLiteral(value: Double) extends Expression[FloatType] with LeafExpression { - def getValue = value - def getType = new FloatType -} - -class CharLiteral(value: Char) extends Expression[CharType] with LeafExpression { - def getValue = value - def getType = new CharType -} diff --git a/old/ofc/codegen/ForLoop.scala b/old/ofc/codegen/ForLoop.scala deleted file mode 100644 index 0e91e6c..0000000 --- a/old/ofc/codegen/ForLoop.scala +++ /dev/null @@ -1,8 +0,0 @@ -package ofc.codegen - -class ForLoop(index: VarSymbol[IntType], begin: Expression[IntType], end: Expression[IntType]) extends ScopeStatement { - def getIndex = index - def getBegin = begin - def getEnd = end - def getExpressions = List(begin, end) -} diff --git a/old/ofc/codegen/FortranGenerator.scala b/old/ofc/codegen/FortranGenerator.scala deleted file mode 100644 index dbf02cc..0000000 --- a/old/ofc/codegen/FortranGenerator.scala +++ /dev/null @@ -1,402 +0,0 @@ -package ofc.codegen -import scala.annotation.tailrec -import ofc.{UnimplementedException,LogicError} - -class SymbolManager { - import scala.collection.mutable - - class SymbolInfo(name: String) { - def getName = name - } - - private val symbols = mutable.Set[Symbol]() - private val declaredSymbols = mutable.Map[VarSymbol[_ <: Type], SymbolInfo]() - private val names = mutable.Set[String]() - - private def createNewName(sym: VarSymbol[_]) : String = { - @tailrec - def helper(sym: VarSymbol[_], suffix: Int) : String = { - val candidate = sym.getName + "_" + suffix - if (names.contains(candidate)) - helper(sym, suffix + 1) - else - candidate - } - - helper(sym, 1) - } - - def addSymbol(sym: Symbol) { - symbols += sym - } - - def addDeclaration(sym: VarSymbol[_ <: Type]) { - addSymbol(sym) - - sym match { - case (s: DeclaredVarSymbol[_]) => if (!declaredSymbols.contains(s)) { - val name = createNewName(s) - names += name - declaredSymbols += s -> new SymbolInfo(name) - - //FIXME: This is a hacky way to detect structures we need to import - s.getType match { - case (structType: StructType) => addSymbol(structType) - case _ => () - } - } else { - throw new LogicError("Attempted to add symbol more than once (multiple declarations?): "+sym.getName) - } - - case _ => throw new LogicError("Attempted to add declaration not of type DeclaredVarSymbol.") - } - } - - def getName(sym: VarSymbol[_ <: Type]) = - declaredSymbols.get(sym) match { - case None => throw new LogicError("Unknown symbol (missing declaration?): "+sym.getName) - case Some(info) => info.getName - } - - def getDeclarations : Seq[String] = { - for ((sym, info) <- declaredSymbols) yield { - var attributeStrings : Seq[String] = Nil - - // It seems these properties need to go after the type-related attributes - for(property <- sym.getProperties) property match { - case (p: FortranAttribute) => attributeStrings +:= p.getName - case _ => () - } - - attributeStrings ++:= sym.getType.getFortranAttributes - attributeStrings.mkString(", ") + " :: " + info.getName - } - }.toSeq.sorted - - def getUses : Seq[String] = { - var uses : Map[String, mutable.Set[String]] = Map.empty - - for (sym <- symbols) { - for(property <- sym.getProperties) property match { - case FortranModule(name) => { - val imported = uses.getOrElse(name, mutable.Set.empty) - uses += name -> imported - imported += sym.getName - } - case _ => () - } - } - - for((moduleName, symbolNames) <- uses) yield - "use "+moduleName+", only: " + symbolNames.mkString(", ") - }.toSeq.sorted -} - -object FortranGenerator { - private val maxPrec = 30 - - case class BinaryOpInfo(template: String, precedence: Int, assoc: BinaryOpInfo.Associativity) - - object BinaryOpInfo { - sealed abstract class Associativity - object LEFT extends Associativity - object RIGHT extends Associativity - object FUNCTION extends Associativity - } - - private def getBinaryOpInfo(op: NumericOperations.CompareOp) : BinaryOpInfo = { - import NumericOperations._ - import BinaryOpInfo._ - op match { - case LT => BinaryOpInfo("%s .lt. %s", 16, LEFT) - case LE => BinaryOpInfo("%s .le. %s", 16, LEFT) - case EQ => BinaryOpInfo("%s .eq. %s", 16, LEFT) - case NE => BinaryOpInfo("%s .ne. %s", 16, LEFT) - case GT => BinaryOpInfo("%s .gt. %s", 16, LEFT) - case GE => BinaryOpInfo("%s .ge. %s", 16, LEFT) - case x => throw new UnimplementedException("Unknown comparison type in FORTRAN generator: "+x.toString) - } - } - - private def getBinaryOpInfo(op: NumericOperations.FieldOp) : BinaryOpInfo = { - import NumericOperations._ - import BinaryOpInfo._ - op match { - case Add => BinaryOpInfo("%s + %s", 22, LEFT) - case Sub => BinaryOpInfo("%s - %s", 22, LEFT) - case Mul => BinaryOpInfo("%s * %s", 26, LEFT) - case Div => BinaryOpInfo("%s / %s", 26, LEFT) - case Mod => BinaryOpInfo("mod(%s, %s)", maxPrec, FUNCTION) - case x => throw new UnimplementedException("Unknown numeric operator in FORTRAN generator: "+x.toString) - } - } - - private def wrapLine(line: String) : Seq[String] = { - // Fortran95 maximum line length is 132 characters, but let's assume people - // might want to indent further. - val maxLineLength = 120 - val buffer = scala.collection.mutable.Buffer[String]() - val marginMatch = "^\\s*".r - val margin = marginMatch.findFirstIn(line) match { - case Some(string) => string - case _ => "" - } - - var remaining = line.drop(margin.length) - while (remaining.length + margin.length > maxLineLength) { - val takeLength = maxLineLength - margin.length + 1 - val nextSubLine = margin + remaining.take(takeLength) + "&" - remaining = "&"+remaining.drop(takeLength) - buffer.append(nextSubLine) - } - buffer.append(margin + remaining) - buffer.toSeq - } - - private def wrapLines(lines: Seq[String]) : Seq[String] = lines.flatMap(wrapLine(_)) -} - -class FortranGenerator { - import FortranGenerator.{maxPrec, BinaryOpInfo, getBinaryOpInfo} - - private val symbolManager = new SymbolManager - private val buffer = scala.collection.mutable.Buffer[String]() - private var indentLevel = 0 - - case class ExpHolder(prec: Int, exp: String) { - override def toString = exp - } - - def apply(stat: Statement) : String = { - processStatement(stat) - - prependLine("\n") - prependLines(symbolManager.getDeclarations) - FortranGenerator.wrapLines(buffer).mkString("\n") - } - - def apply(func: Function[_ <: Type]) : String = { - in - processStatement(func.getBlock) - prependLine("") - prependLines(symbolManager.getDeclarations) - prependLine("implicit none") - prependLine("") - prependLines(symbolManager.getUses) - out - - // parameters are only named *after* processing the body - val paramNames = func.getParameters.map(symbolManager.getName(_)) - val (header, footer) = func.getReturnType match { - case (_: VoidType) => { - val header = "subroutine " + func.getName + paramNames.mkString("(", ", ", ")") - val footer = "end subroutine" - (header, footer) - } - case _ => throw new UnimplementedException("Fortran function code generation not implemented.") - } - - prependLine(header) - addLine(footer) - FortranGenerator.wrapLines(buffer).mkString("\n") - } - - - private def processStatement(stat: Statement) { - stat match { - case (x : NullStatement) => () - case (x : Comment) => addLine("!" + x.getValue) - case (x : BlockStatement) => processScope(x) - case (x : IterationContext) => processStatement(x.toConcrete) - case (x : ForLoop) => processForLoop(x) - case (a : AssignStatement) => processAssignment(a) - case (i : IfStatement) => processIf(i) - case (a : AllocateStatement) => processAllocate(a) - case (d : DeallocateStatement) => processDeallocate(d) - case (f : FunctionCallStatement) => { - symbolManager.addSymbol(f.getCall.getSignature) - processFunctionCallStatement(f) - } - case x => throw new UnimplementedException("Unknown statement type in FORTRAN generator: " + x.toString) - } - } - - private def in() { - indentLevel += 1 - } - - private def out() { - indentLevel -=1 - if (indentLevel < 0) throw new LogicError("Indentation level dropped below 0 in FORTRAN generator.") - } - - private def buildExpression(expression: Expression[_]) : ExpHolder = { - expression match { - case (i : IntegerLiteral) => ExpHolder(maxPrec, i.getValue.toString) - case (i : FloatLiteral) => ExpHolder(maxPrec, i.getValue.toString) - case (i : CharLiteral) => ExpHolder(maxPrec, "'%s'".format(i.getValue.toString)) - case (a : FieldAccess[_]) => ExpHolder(maxPrec, "%s%%%s".format(buildExpression(a.getStructExpression), a.getField.getName)) - case (r : VarRef[_]) => r.getSymbol match { - case (s: DeclaredVarSymbol[_]) => ExpHolder(maxPrec, symbolManager.getName(s)) - case (s: Symbol) => { - symbolManager.addSymbol(s) - ExpHolder(maxPrec, s.getName) - } - } - case (r: ArrayAccess[_]) => - ExpHolder(maxPrec, buildExpression(r.getArrayExpression) + r.getIndexExpressions.map(buildExpression(_)).mkString("(",", ",")")) - case (d: PointerDereference[_]) => buildExpression(d.getExpression) - case (c: ConditionalValue[_]) => buildConditionalValue(c) - case (c: NumericComparison[_]) => buildNumericComparison(c) - case (c: NumericOperator[_]) => buildNumericOperator(c) - case (c: Conversion[_,_]) => buildConversion(c) - case (i: Intrinsic[_]) => buildIntrinsic(i) - case (f: FunctionCall[_]) => { - symbolManager.addSymbol(f.getSignature) - buildFunctionCall(f) - } - case x => throw new UnimplementedException("Unknown expression type in FORTRAN generator: " + x.toString) - } - } - - private def buildConditionalValue(conditional: ConditionalValue[_ <: Type]) : ExpHolder = { - var symbol = new DeclaredVarSymbol[Type]("ternary", conditional.getType) - symbolManager.addDeclaration(symbol) - val name = symbolManager.getName(symbol) - addLine("if (%s) then".format(buildExpression(conditional.getPredicate))) - in - addLine("%s = %s".format(name, buildExpression(conditional.getIfTrue))) - out - addLine("else") - in - addLine("%s = %s".format(name, buildExpression(conditional.getIfFalse))) - out - addLine("endif") - - ExpHolder(maxPrec, name) - } - - private def buildBinaryOperation(opInfo: BinaryOpInfo, left: ExpHolder, right: ExpHolder) : ExpHolder = { - import BinaryOpInfo._ - - def bracket(opInfo: BinaryOpInfo, exp: ExpHolder, assoc: Associativity) = - opInfo.assoc != FUNCTION && - (opInfo.precedence > exp.prec || (opInfo.precedence == exp.prec && opInfo.assoc != assoc)) - - val lhs = if (bracket(opInfo, left, LEFT)) - "(" + left.exp + ")" - else - left.exp - - val rhs = if (bracket(opInfo, right, RIGHT)) - "(" + right.exp + ")" - else - right.exp - - ExpHolder(opInfo.precedence, opInfo.template.format(lhs, rhs)) - } - - private def buildConversion(c: Conversion[_,_]) : ExpHolder = c.getType match { - case (_: FloatType) => ExpHolder(maxPrec, "real(%s)".format(buildExpression(c.getExpression))) - case (_: ComplexType) => ExpHolder(maxPrec, "cmplx(%s)".format(buildExpression(c.getExpression))) - case _ => throw new UnimplementedException("Fortran generator cannot handle conversion.") - } - - private def buildIntrinsic(i: Intrinsic[_]) : ExpHolder = i match { - case (m: Min[_]) => ExpHolder(maxPrec, "min(%s, %s)".format(buildExpression(m.getLeft), buildExpression(m.getRight))) - case (m: Max[_]) => ExpHolder(maxPrec, "max(%s, %s)".format(buildExpression(m.getLeft), buildExpression(m.getRight))) - case _ => throw new UnimplementedException("Unknown intrinsic in Fortran generator: "+i) - } - - private def buildNumericComparison(c: NumericComparison[_]) : ExpHolder = - buildBinaryOperation(getBinaryOpInfo(c.getOperation), buildExpression(c.getLeft), buildExpression(c.getRight)) - - private def buildNumericOperator(o: NumericOperator[_]) : ExpHolder = { - val left = buildExpression(o.getLeft) - var right = buildExpression(o.getRight) - - // Fortran has stupid rules about unary negation on the right hand side of an arithmetic operator. - def isUnaryNegate(expression: Expression[_]) = expression match { - case (l: FloatLiteral) if l.getValue < 0 => true - case (l: IntegerLiteral) if l.getValue < 0 => true - case _ => false - } - - if (isUnaryNegate(o.getRight)) - right = ExpHolder(maxPrec, "(%s)".format(right.exp)) - - buildBinaryOperation(getBinaryOpInfo(o.getOperation), left, right) - } - - private def processForLoop(stat: ForLoop) { - val index = stat.getIndex - val name = symbolManager.getName(index) - val begin = buildExpression(stat.getBegin) - val end = buildExpression(stat.getEnd) - - val header = "do %s = %s, %s".format(name, begin, end) - val footer = "end do" - addLine(header) - in - processScope(stat) - out - addLine(footer) - } - - private def processFunctionCallStatement(stat: FunctionCallStatement) { - val call = stat.getCall - call.getSignature match { - case (fortSub: FortranSubroutineSignature) => - addLine("call %s(%s)".format(fortSub.getName, call.getParams.map(buildExpression(_)).mkString(", "))) - case _ => throw new LogicError("Fortran generator only knows how to call Fortran sub-routines.") - } - } - - private def buildFunctionCall(call: FunctionCall[_]) : ExpHolder = call.getSignature match { - case (fortFunc: FortranFunctionSignature[_]) => - new ExpHolder(maxPrec, "%s(%s)".format(fortFunc.getName, call.getParams.map(buildExpression(_)).mkString(", "))) - case _ => throw new LogicError("Fortran generator only knows how to call Fortran functions.") - } - - private def processScope(scope: ScopeStatement) { - for (sym <- scope.getDeclarations) { - symbolManager.addDeclaration(sym) - } - for(stat <- scope.getStatements) { - processStatement(stat) - } - } - - private def processAssignment(assignment: AssignStatement) { - addLine("%s = %s".format(buildExpression(assignment.getLHS), buildExpression(assignment.getRHS))) - } - - private def processIf(ifStatement: IfStatement) { - addLine("if (%s) then".format(buildExpression(ifStatement.getPredicate))) - in - processScope(ifStatement) - out - addLine("endif") - } - - private def processAllocate(allocate: AllocateStatement) { - addLine("allocate(%s(%s))".format(buildExpression(allocate.getArray), allocate.getSize.map(buildExpression(_)).mkString(","))) - } - - private def processDeallocate(deallocate: DeallocateStatement) { - addLine("deallocate(%s)".format(buildExpression(deallocate.getArray))) - } - - private def addLine(line: String) { - buffer += " "*indentLevel + line - } - - private def prependLine(line: String) { - buffer.prepend(" "*indentLevel + line) - } - - private def prependLines(lines: Seq[String]) { - for(line <- lines.reverse) - prependLine(line) - } -} diff --git a/old/ofc/codegen/FortranProperty.scala b/old/ofc/codegen/FortranProperty.scala deleted file mode 100644 index de4db58..0000000 --- a/old/ofc/codegen/FortranProperty.scala +++ /dev/null @@ -1,17 +0,0 @@ -package ofc.codegen - -trait FortranProperty extends SymbolProperty { -} - -trait FortranAttribute extends FortranProperty { - def getName : String -} - -case class AllocatableProperty() extends FortranAttribute { - def getName = "allocatable" -} - -case class FortranModule(module: String) extends FortranProperty { - def getName = module - def getModuleName : String = module -} diff --git a/old/ofc/codegen/Function.scala b/old/ofc/codegen/Function.scala deleted file mode 100644 index fa8e517..0000000 --- a/old/ofc/codegen/Function.scala +++ /dev/null @@ -1,19 +0,0 @@ -package ofc.codegen - -class Function[R <: Type](name: String, retType: R) { - val block = new BlockStatement - var params : Seq[VarSymbol[_ <: Type]] = Nil - - def addParameter(param: VarSymbol[_ <: Type]) { - params :+= param - block.addDeclaration(param) - } - - def getName = name - - def getBlock = block - - def getParameters : Seq[VarSymbol[_ <: Type]] = params - - def getReturnType : Type = retType -} diff --git a/old/ofc/codegen/FunctionCall.scala b/old/ofc/codegen/FunctionCall.scala deleted file mode 100644 index f5925f9..0000000 --- a/old/ofc/codegen/FunctionCall.scala +++ /dev/null @@ -1,16 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -class FunctionCall[R <: Type](signature: FunctionSignature[R], params: Seq[Expression[_]]) extends Expression[R] { - if (params.size != signature.getParams.size) - throw new LogicError("Function "+signature.getName+" called with incorrect number of parameters.") - - for((param, (name, paramType)) <- params.zip(signature.getParams)) - if (param.getType != paramType) - throw new LogicError("Type mismatch on parameter "+name+" when calling function "+signature.getName) - - def getType = signature.getReturnType - def foreach[U](f: Expression[_] => U) = params.foreach(f) - def getSignature = signature - def getParams = params -} diff --git a/old/ofc/codegen/FunctionCallStatement.scala b/old/ofc/codegen/FunctionCallStatement.scala deleted file mode 100644 index 8447ce3..0000000 --- a/old/ofc/codegen/FunctionCallStatement.scala +++ /dev/null @@ -1,6 +0,0 @@ -package ofc.codegen - -class FunctionCallStatement(call: FunctionCall[VoidType]) extends Statement { - def getCall : FunctionCall[VoidType] = call - def getExpressions = call.getParams -} diff --git a/old/ofc/codegen/FunctionSignature.scala b/old/ofc/codegen/FunctionSignature.scala deleted file mode 100644 index e87cfe7..0000000 --- a/old/ofc/codegen/FunctionSignature.scala +++ /dev/null @@ -1,25 +0,0 @@ -package ofc.codegen - -trait FunctionSignature[R <: Type] extends Symbol { - def getReturnType: R - def getParams: Seq[(String, Type)] -} - -class FortranSubroutineSignature(name: String, - params: Seq[(String, Type)]) extends FunctionSignature[VoidType] { - - def getName = name - def getReturnType = new VoidType - def getParams = params -} - -class FortranFunctionSignature[R <: Type](name: String, - params: Seq[(String, Type)], retType: R) extends FunctionSignature[R] { - - def this(name: String, params: Seq[(String, Type)])(implicit builder: TypeBuilder[R]) = - this(name, params, builder()) - - def getName = name - def getReturnType = retType - def getParams = params -} diff --git a/old/ofc/codegen/IfStatement.scala b/old/ofc/codegen/IfStatement.scala deleted file mode 100644 index b23ae16..0000000 --- a/old/ofc/codegen/IfStatement.scala +++ /dev/null @@ -1,6 +0,0 @@ -package ofc.codegen - -class IfStatement(predicate: Expression[BoolType]) extends ScopeStatement { - def getPredicate : Expression[BoolType] = predicate - def getExpressions = predicate -} diff --git a/old/ofc/codegen/Intrinsic.scala b/old/ofc/codegen/Intrinsic.scala deleted file mode 100644 index a73c7ea..0000000 --- a/old/ofc/codegen/Intrinsic.scala +++ /dev/null @@ -1,24 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -abstract class Intrinsic[T <: Type] extends Expression[T] - -class Min[T <: Type](a: Expression[T], b: Expression[T])(implicit isNumeric: HasProperty[T, Numeric]) extends Intrinsic[T] { - if (a.getType != b.getType) - throw new LogicError("Parameters to min must have matching types.") - - def getType = a.getType - def foreach[U](f: Expression[_] => U) = List(a, b).foreach(f) - def getLeft = a - def getRight = b -} - -class Max[T <: Type](a: Expression[T], b: Expression[T])(implicit isNumeric: HasProperty[T, Numeric]) extends Intrinsic[T] { - if (a.getType != b.getType) - throw new LogicError("Parameters to max must have matching types.") - - def getType = a.getType - def foreach[U](f: Expression[_] => U) = List(a, b).foreach(f) - def getLeft = a - def getRight = b -} diff --git a/old/ofc/codegen/IterationContext.scala b/old/ofc/codegen/IterationContext.scala deleted file mode 100644 index 9654090..0000000 --- a/old/ofc/codegen/IterationContext.scala +++ /dev/null @@ -1,179 +0,0 @@ -package ofc.codegen -import ofc.LogicError -import ofc.util.DirectedGraph - -object IterationContext { - object Context { - private def priority(context: Context) : Int = { - // This ensures that the nesting ordering is Predicate, DerivedExpression, VariableRange - // when no other dependencies exist. - context match { - case (_: Predicate) => 1 - case (_: DerivedExpression) => 2 - case (_: VariableRange) => 3 - case _ => throw new LogicError("Unknown context type.") - } - } - - def sort(contexts: Seq[Context]) : Seq[Context] = { - def pathFunction(c1: Context, c2: Context) = c1.tryCompare(c2) match { - case Some(x) if x<0 => true - case _ => false - } - - val graph = new DirectedGraph - val contextMapping = scala.collection.mutable.Map[Context, DirectedGraph#Vertex]() - - for(context <- contexts) { - val vertex = graph.addVertex - contextMapping += (context -> vertex) - } - - for(c1 <- contexts; c2 <- contexts; if pathFunction(c1, c2)) { - graph.addEdge(contextMapping.get(c1).get, contextMapping.get(c2).get) - } - - val flippedMapping = contextMapping.map(_.swap).toMap - val vertexPriorityFunction = (v: DirectedGraph#Vertex) => priority(flippedMapping.get(v).get) - val sortedVertices = DirectedGraph.topoSort(graph, vertexPriorityFunction) - val sortedContexts = { for (v <- sortedVertices) yield flippedMapping.get(v).get } - - sortedContexts.toSeq - } - } - - sealed trait Context { - def defines : Set[VarSymbol[_]] - def depends : Set[VarSymbol[_]] - def tryCompare(other: Context) : Option[Int] = { - val isChild = other.defines & depends - val isParent = defines & other.depends - assert(isChild.isEmpty || isParent.isEmpty) - - if (this == other) - Some(0) - else if (isParent.nonEmpty) - Some(-1) - else if (isChild.nonEmpty) - Some(1) - else - None - } - } - - case class VariableRange(symbol: VarSymbol[IntType], first: Expression[IntType], last: Expression[IntType]) extends Context { - override def toString = "VariableRange("+symbol.toString+", "+first.toString+", "+last.toString+")" - def defines = Set(symbol) - def depends = Expression.findReferencedVariables(List(first, last)) - } - - case class Predicate(expression: Expression[BoolType]) extends Context { - override def toString = "Predicate("+expression.toString+")" - def defines = Set.empty - def depends = Expression.findReferencedVariables(expression) - } - - case class DerivedExpression(symbol: VarSymbol[_ <: Type], expression: Expression[_ <: Type]) extends Context { - override def toString = "DerivedExpression("+symbol.toString + " <- " + expression.toString+")" - def defines = Set(symbol) - def depends = Expression.findReferencedVariables(expression) - } -} - -class IterationContext extends Statement { - import IterationContext._ - - var declarations : Seq[VarSymbol[_ <: Type]] = Nil - var headers : Seq[Statement] = Nil - var footers : Seq[Statement] = Nil - var ranges : Seq[VariableRange] = Nil - var predicates : Seq[Predicate] = Nil - var expressions : Seq[DerivedExpression] = Nil - - def addDeclaration(declaration: VarSymbol[_ <: Type]) { - declarations +:= declaration - } - - def addExpression[T <: Type](name: String, expression: Expression[T]) : VarSymbol[T] = { - val symbol = new DeclaredVarSymbol[T](name, expression.getType) - expressions +:= new DerivedExpression(symbol, expression) - symbol - } - - def addIteration(name: String, first: Expression[IntType], last: Expression[IntType]) : VarSymbol[IntType] = { - val symbol = new DeclaredVarSymbol[IntType](name) - ranges +:= new VariableRange(symbol, first, last) - symbol - } - - def addPredicate(condition: Expression[BoolType]) { - predicates +:= new Predicate(condition) - } - - def addHeader(stat: Statement) { - headers +:= stat - } - - def addFooter(stat: Statement) { - footers +:= stat - } - - def merge(statement: IterationContext) : IterationContext = { - val result = new IterationContext - result.declarations = declarations ++ statement.declarations - result.ranges = ranges ++ statement.ranges - result.predicates = predicates ++ statement.predicates - result.expressions = expressions ++ statement.expressions - result.headers = headers ++ statement.headers - result.footers = footers ++ statement.footers - result - } - - def toConcrete(statement: Statement) : Statement = { - val contexts = ranges ++ predicates ++ expressions - val sortedContexts = Context.sort(contexts) - - val block = new BlockStatement - var scope : ScopeStatement = block - - for(declaration <- declarations) - block.addDeclaration(declaration) - - for(header <- headers) - block += header - - for (context <- sortedContexts) { - context match { - case VariableRange(sym, first, last) => { - val loop = new ForLoop(sym, first, last) - scope.addDeclaration(sym) - scope += loop - scope = loop - } - case Predicate(expression) => { - val ifStat = new IfStatement(expression) - scope += ifStat - scope = ifStat - } - case DerivedExpression(sym, expression) => { - val assignment = new AssignStatement(sym, expression) - scope.addDeclaration(sym) - scope += assignment - } - } - } - - scope += statement - - for(footer <- footers) - block += footer - - block - } - - def toConcrete : Statement = - toConcrete(new Comment("Placeholder statement for consumer.")) - - def getExpressions = - throw new LogicError("Call IterationContext::toConcrete() before trying to access expressions.") -} diff --git a/old/ofc/codegen/NumericOperator.scala b/old/ofc/codegen/NumericOperator.scala deleted file mode 100644 index 58213a4..0000000 --- a/old/ofc/codegen/NumericOperator.scala +++ /dev/null @@ -1,40 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -object NumericOperations { - sealed abstract class FieldOp - case object Add extends FieldOp - case object Sub extends FieldOp - case object Mul extends FieldOp - case object Div extends FieldOp - case object Mod extends FieldOp - - sealed abstract class CompareOp - object LT extends CompareOp - object LE extends CompareOp - object EQ extends CompareOp - object NE extends CompareOp - object GT extends CompareOp - object GE extends CompareOp -} - -class NumericOperator[T <: Type](op: NumericOperations.FieldOp, left: Expression[T], right: Expression[T]) extends Expression[T] { - def foreach[U](f: Expression[_] => U) = List(left, right).foreach(f) - def getOperation = op - def getLeft = left - def getRight = right - def getType = { - if (left.getType != right.getType) - throw new LogicError("Non-matching types for parameters to numeric comparison") - else - left.getType - } -} - -class NumericComparison[T <: Type](op: NumericOperations.CompareOp, left: Expression[T], right: Expression[T]) extends Expression[BoolType] { - def foreach[U](f: Expression[_] => U) = List(left, right).foreach(f) - def getOperation = op - def getLeft = left - def getRight = right - def getType = new BoolType -} diff --git a/old/ofc/codegen/ScopeStatement.scala b/old/ofc/codegen/ScopeStatement.scala deleted file mode 100644 index f83eac7..0000000 --- a/old/ofc/codegen/ScopeStatement.scala +++ /dev/null @@ -1,22 +0,0 @@ -package ofc.codegen - -abstract class ScopeStatement(initialStatements: Seq[Statement] = Nil) extends Statement { - val declarations = scala.collection.mutable.Set[VarSymbol[_ <: Type]]() - val statements = initialStatements.toBuffer - - def +=(stat: Statement) { - statements += stat - } - - def getStatements : Seq[Statement] = statements.toSeq - - def addDeclaration(sym: VarSymbol[_ <: Type]) { - declarations += sym - } - - def getDeclarations : Seq[VarSymbol[_ <: Type]] = declarations.toSeq -} - -class BlockStatement(initialStatements: Seq[Statement] = Nil) extends ScopeStatement(initialStatements) { - def getExpressions = Nil -} diff --git a/old/ofc/codegen/Statement.scala b/old/ofc/codegen/Statement.scala deleted file mode 100644 index 24e0f03..0000000 --- a/old/ofc/codegen/Statement.scala +++ /dev/null @@ -1,9 +0,0 @@ -package ofc.codegen - -trait Statement { - def getExpressions: Traversable[Expression[_]] -} - -class NullStatement extends Statement { - def getExpressions = Nil -} diff --git a/old/ofc/codegen/Symbol.scala b/old/ofc/codegen/Symbol.scala deleted file mode 100644 index 508ec6b..0000000 --- a/old/ofc/codegen/Symbol.scala +++ /dev/null @@ -1,38 +0,0 @@ -package ofc.codegen - -trait Symbol { - private var properties : Seq[SymbolProperty] = Nil - - def getName : String - def addProperty(property: SymbolProperty) { - properties +:= property - } - def getProperties : Seq[SymbolProperty] = properties -} - -trait SymbolProperty { - def getName : String -} - -class FieldSymbol[T <: Type](name: String, fieldType: T) extends Symbol { - def this(name: String)(implicit builder: TypeBuilder[T]) = this(name, builder()) - def getName = name - def getType = fieldType -} - -sealed abstract class VarSymbol[T <: Type](name: String, varType: T) extends Symbol { - def getName = name - def getType : T = varType -} - -object VarSymbol { - implicit def toRef[T <: Type](symbol: VarSymbol[T]) = new VarRef[T](symbol) -} - -class DeclaredVarSymbol[T <: Type](name: String, varType: T) extends VarSymbol[T](name, varType) { - def this(name: String)(implicit builder: TypeBuilder[T]) = this(name, builder()) -} - -class NamedUnboundVarSymbol[T <: Type](name: String, varType: T) extends VarSymbol[T](name, varType) { - def this(name: String)(implicit builder: TypeBuilder[T]) = this(name, builder()) -} diff --git a/old/ofc/codegen/Type.scala b/old/ofc/codegen/Type.scala deleted file mode 100644 index 2c6cbc4..0000000 --- a/old/ofc/codegen/Type.scala +++ /dev/null @@ -1,77 +0,0 @@ -package ofc.codegen -import ofc.LogicError - -sealed abstract class Type { - def getFortranAttributes : Set[String] -} -sealed abstract class PrimitiveType extends Type - -// These are case classes solely for the comparison operators -final case class IntType() extends PrimitiveType { - def getFortranAttributes = Set("integer") -} - -final case class FloatType() extends PrimitiveType { - def getFortranAttributes = Set("real(kind=DP)") -} - -final case class BoolType() extends PrimitiveType { - def getFortranAttributes = Set("logical") -} - -final case class VoidType() extends PrimitiveType { - def getFortranAttributes = throw new LogicError("void type does not exist in Fortran.") -} - -final case class CharType() extends PrimitiveType { - def getFortranAttributes = Set("character") -} - -final case class ComplexType() extends PrimitiveType { - def getFortranAttributes = Set("complex(kind=DP)") -} - -final case class ArrayType[ElementType <: Type](rank: Int, eType: ElementType) extends Type { - def this(rank: Int)(implicit builder: TypeBuilder[ElementType]) = this(rank, builder()) - def getElementType = eType - def getFortranAttributes = eType.getFortranAttributes ++ Set((":"*rank).mkString("dimension(",",",")")) - def getRank = rank -} - -final case class PointerType[TargetType <: Type](tType: TargetType) extends Type { - def this()(implicit builder: TypeBuilder[TargetType]) = this(builder()) - def getTargetType = tType - def getFortranAttributes = tType.getFortranAttributes + "pointer" -} - -abstract class StructType extends Type with Symbol { - def getFortranAttributes = Set("type(" + getName + ")") -} - -trait TypeBuilder[T <: Type] { - def apply() : T -} - -object TypeBuilder { - implicit val charBuilder = new TypeBuilder[CharType] { def apply() = new CharType } - implicit val intBuilder = new TypeBuilder[IntType] { def apply() = new IntType } - implicit val floatBuilder = new TypeBuilder[FloatType] { def apply() = new FloatType } - implicit val complexBuilder = new TypeBuilder[ComplexType] { def apply() = new ComplexType } - implicit val boolBuilder = new TypeBuilder[BoolType] { def apply() = new BoolType } -} - -trait TypeProperty -trait Numeric extends TypeProperty - -class HasProperty[T <: Type, P <: TypeProperty] -object HasProperty { - implicit val intNumeric = new HasProperty[IntType, Numeric]() - implicit val floatNumeric = new HasProperty[FloatType, Numeric]() - implicit val complexNumeric = new HasProperty[ComplexType, Numeric]() -} - -class IsConvertible[From <: Type, To <: Type] -object IsConvertible { - implicit val intToFloat = new IsConvertible[IntType, FloatType]() - implicit val floatToFloat = new IsConvertible[FloatType, ComplexType]() -} diff --git a/old/ofc/expression/Assignment.scala b/old/ofc/expression/Assignment.scala deleted file mode 100644 index 0a2ea2c..0000000 --- a/old/ofc/expression/Assignment.scala +++ /dev/null @@ -1,5 +0,0 @@ -package ofc.expression - -case class Assignment(lhs: Scalar, rhs: Scalar) { - override def toString = lhs.toString + " = " + rhs.toString -} diff --git a/old/ofc/expression/Dictionary.scala b/old/ofc/expression/Dictionary.scala deleted file mode 100644 index 0b95012..0000000 --- a/old/ofc/expression/Dictionary.scala +++ /dev/null @@ -1,32 +0,0 @@ -package ofc.expression -import ofc.parser.Identifier - -class Dictionary { - import scala.collection.mutable.HashMap - - var matrices = new HashMap[Identifier, Matrix] - var functionSets = new HashMap[Identifier, FunctionSet] - var indices = new HashMap[Identifier, Index] - - def add(matrix: Matrix) { - matrices += matrix.getIdentifier -> matrix - } - - def add(functionSet: FunctionSet) { - functionSets += functionSet.getIdentifier -> functionSet - } - - def add(index: Index) { - indices += index.getIdentifier -> index - } - - def getMatrix(id: Identifier) : Option[Matrix] = matrices.get(id) - - def getFunctionSet(id: Identifier) : Option[FunctionSet] = functionSets.get(id) - - def getIndex(id: Identifier) : Option[Index] = indices.get(id) - - def getOperands = matrices.values ++ functionSets.values - - def getIndices = indices.values -} diff --git a/old/ofc/expression/Expression.scala b/old/ofc/expression/Expression.scala deleted file mode 100644 index 9fa2d48..0000000 --- a/old/ofc/expression/Expression.scala +++ /dev/null @@ -1,78 +0,0 @@ -package ofc.expression -import ofc.parser.Identifier - -case class Index(id: Identifier) { - def getIdentifier = id - def getName = id.getName - override def toString() = id.getName -} - -sealed trait Expression { - def isAssignable : Boolean - def numIndices : Int - def getDependentIndices : Set[Index] -} - -sealed trait NamedOperand { - val id: Identifier - def getIdentifier = id - def isAssignable = true - def getDependentIndices : Set[Index] = Set.empty - override def toString = id.getName -} - -sealed trait Scalar extends Expression -sealed trait Field extends Expression - -trait IndexingOperation { - val op: Expression - def getIndices : List[Index] - def isAssignable = op.isAssignable - def numIndices = 0 - def getDependentIndices = op.getDependentIndices ++ getIndices - override def toString = op.toString + getIndices.map(_.getName).mkString("[",",","]") -} - -case class ScalarIndexingOperation(val op: Scalar, indices: List[Index]) extends IndexingOperation with Scalar { - def getIndices = indices -} - -case class FieldIndexingOperation(val op: Field, indices: List[Index]) extends IndexingOperation with Field { - def getIndices = indices -} - -case class InnerProduct(left: Field, right: Field) extends Scalar { - override def toString = "inner(" + left.toString + ", " + right.toString+")" - def isAssignable = false - def numIndices = 0 - def getDependentIndices = left.getDependentIndices ++ right.getDependentIndices -} - -case class Laplacian(op: Field) extends Field { - override def toString = "laplacian("+op.toString+")" - def isAssignable = false - def numIndices = 0 - def getDependentIndices = op.getDependentIndices -} - -case class FieldScaling(op: Field, scale: Scalar) extends Field { - override def toString = "(" + op.toString + "*" + scale.toString + ")" - def isAssignable = false - def numIndices = 0 - def getDependentIndices = op.getDependentIndices ++ scale.getDependentIndices -} - -case class ScalarLiteral(literal: Double) extends Scalar { - override def toString = literal.toString - def isAssignable = false - def numIndices = 0 - def getDependentIndices = Set.empty -} - -class FunctionSet(val id: Identifier) extends Field with NamedOperand { - def numIndices = 1 -} - -class Matrix(val id: Identifier) extends Scalar with NamedOperand { - def numIndices = 2 -} diff --git a/old/ofc/expression/TreeBuilder.scala b/old/ofc/expression/TreeBuilder.scala deleted file mode 100644 index 3d656d2..0000000 --- a/old/ofc/expression/TreeBuilder.scala +++ /dev/null @@ -1,71 +0,0 @@ -package ofc.expression - -import ofc.parser -import ofc.parser.Identifier -import ofc.{InvalidInputException,UnimplementedException} - -class TreeBuilder(dictionary : Dictionary) { - def apply(definition: parser.Definition) : Assignment = { - val lhsTree = buildExpression(definition.term) - val rhsTree = buildExpression(definition.expr) - - if (!lhsTree.isAssignable) - throw new InvalidInputException("Non-assignable expression on LHS of assignment.") - else (lhsTree, rhsTree) match { - case (lhs: Scalar, rhs: Scalar) => new Assignment(lhs, rhs) - case _ => throw new InvalidInputException("Assignment must be of scalar type.") - } - } - - private def buildIndexedOperand(term: parser.IndexedIdentifier) : Expression = { - val indices = for(id <- term.indices) yield buildIndex(id) - - dictionary.getMatrix(term.id) match { - case Some(matrix) => new ScalarIndexingOperation(matrix, indices) - case None => dictionary.getFunctionSet(term.id) match { - case Some(functionSet) => new FieldIndexingOperation(functionSet, indices) - case None => throw new UnimplementedException("No idea how to index "+term.id) - } - } - } - - private def buildIndex(id: parser.Identifier) : Index = dictionary.getIndex(id) match { - case Some(index) => index - case None => throw new InvalidInputException("Unknown index "+id) - } - - private def buildIndex(term: parser.Expression) : Index = term match { - case (indexedID: parser.IndexedIdentifier) => { - if (indexedID.indices.nonEmpty) - throw new InvalidInputException("Tried to parse expression "+term+" as index but it is indexed.") - else - buildIndex(indexedID.id) - } - case other => throw new InvalidInputException("Cannot parse expression "+other+" as index.") - } - - private def buildExpression(term: parser.Expression) : Expression = { - import parser._ - - term match { - case (t: IndexedIdentifier) => buildIndexedOperand(t) - case ScalarConstant(s) => new ScalarLiteral(s) - case Division(a, b) => - throw new UnimplementedException("Semantics of division not yet defined, or implemented.") - case Multiplication(left, right) => (buildExpression(left), buildExpression(right)) match { - case (field: Field, factor: Scalar) => new FieldScaling(field, factor) - case (factor: Scalar, field: Field) => new FieldScaling(field, factor) - case _ => throw new InvalidInputException("Cannot multiply "+left+" and "+right+".") - } - case Operator(Identifier("inner"), List(a,b)) => (buildExpression(a), buildExpression(b)) match { - case (left: Field, right: Field) => new InnerProduct(left, right) - case _ => throw new InvalidInputException("inner requires both operands to be fields.") - } - case Operator(Identifier("laplacian"), List(op)) => buildExpression(op) match { - case (field: Field) => new Laplacian(field) - case _ => throw new InvalidInputException("laplacian can only be applied to a field.") - } - case Operator(Identifier(name), _) => throw new UnimplementedException("Unknown or incorrectly called operator: "+name) - } - } -} diff --git a/old/ofc/generators/Generator.scala b/old/ofc/generators/Generator.scala deleted file mode 100644 index e4b5639..0000000 --- a/old/ofc/generators/Generator.scala +++ /dev/null @@ -1,7 +0,0 @@ -package ofc.generators -import ofc.parser.TargetAssignment -import ofc.expression.{Dictionary,Assignment} - -trait Generator { - def acceptInput(dictionary: Dictionary, expression: Assignment, targetSpecific : Seq[TargetAssignment]) -} diff --git a/old/ofc/generators/Onetep.scala b/old/ofc/generators/Onetep.scala deleted file mode 100644 index 38d8e60..0000000 --- a/old/ofc/generators/Onetep.scala +++ /dev/null @@ -1,156 +0,0 @@ -package ofc.generators - -import ofc.InvalidInputException -import ofc.parser -import ofc.codegen -import ofc.expression -import ofc.generators.onetep._ - -class Onetep extends Generator { - val dictionary = new Dictionary - var parameters : Map[String, codegen.VarSymbol[_ <: codegen.Type]] = Map.empty - var functionIdentifiers : Option[(String, Seq[String])] = None - - def acceptInput(exprDictionary: expression.Dictionary, exprAssignment: - expression.Assignment, targetSpecific : Seq[parser.TargetAssignment]) { - - buildDictionary(exprDictionary, targetSpecific) - val function = buildFunction(targetSpecific) - val assignment = new Assignment(buildScalarExpression(exprAssignment.lhs), buildScalarExpression(exprAssignment.rhs)) - val codeGenerator = new CodeGenerator(dictionary, function.getBlock) - codeGenerator(assignment) - - val generator = new codegen.FortranGenerator - val code = generator(function) - println(code) - } - - private def buildDictionary(exprDictionary: expression.Dictionary, targetSpecific : Seq[parser.TargetAssignment]) { - for(operand <- exprDictionary.getOperands) { - // Find corresponding target-specific declaration if it exists. - val targetDeclarationCall = targetSpecific.filter(_.id == operand.getIdentifier) match { - case Seq(x) => Some(x.value) - case Seq(_,_,_*) => throw new InvalidInputException("Invalid multiple target declarations for symbol " + operand.getIdentifier + ".") - case Nil => None - } - - operand match { - case (m: expression.Matrix) => buildMatrix(operand.getIdentifier, targetDeclarationCall) - case (f: expression.FunctionSet) => buildFunctionSet(operand.getIdentifier, targetDeclarationCall) - } - } - - for(index <- exprDictionary.getIndices) { - dictionary.addIndex(index.getIdentifier, new NamedIndex(index.getName)) - } - } - - private def buildFunction(targetSpecific : Seq[parser.TargetAssignment]) = { - import parser._ - import codegen._ - - val outputCall = targetSpecific.filter(_.id == Identifier("output")) match { - case Seq(x) => x.value - case Seq(_,_,_*) => throw new InvalidInputException("Too many output function specifications.") - case Nil => throw new InvalidInputException("No output function specification found.") - } - - outputCall match { - case FunctionCall(Identifier("FortranFunction"), callInfo) => callInfo match { - case ParameterList(StringParameter(funcName), funcParams: ParameterList) => { - val function = new Function(funcName, new VoidType) - - for(funcParam <- funcParams.toSeq) funcParam match { - case StringParameter(paramName) => parameters.get(paramName) match { - case Some(symbol) => function.addParameter(symbol) - case None => throw new InvalidInputException("Unable to find definition of parameter "+paramName) - } - case _ => throw new InvalidInputException("FortranFunction only takes string parameters") - } - - function - } - case _ => throw new InvalidInputException("FortranFunction takes a name and a parameter list.") - } - case _ => throw new InvalidInputException("Unknown output type "+outputCall.name) - } - } - - private def getIndex(exprIndex: Seq[expression.Index]) : Seq[NamedIndex] = { - for(index <- exprIndex) yield - dictionary.getIndex(index.getIdentifier) - } - - private def matchLHS(lhs: expression.Scalar) : Boolean = { - lhs match { - case expression.ScalarIndexingOperation(_: expression.Matrix, List(bra, ket)) => true - case _ => false - } - } - - private def buildScalarExpression(scalar: expression.Scalar) : Scalar = { - scalar match { - case expression.ScalarLiteral(s) => new ScalarLiteral(s) - case expression.InnerProduct(l, r) => new InnerProduct(buildFieldExpression(l), buildFieldExpression(r)) - case expression.ScalarIndexingOperation(op, indices) => buildScalarAccess(op, indices) - case (_: expression.Matrix) => throw new InvalidInputException("Cannot handle un-indexed matrices.") - } - } - - private def buildScalarAccess(op: expression.Scalar, indices: Seq[expression.Index]) : Scalar = - op match { - case (matrix: expression.Matrix) => dictionary.getScalar(matrix.getIdentifier)(getIndex(indices)) - case _ => throw new InvalidInputException("Can only index leaf-matrices.") - } - - private def buildFieldAccess(op: expression.Field, indices: Seq[expression.Index]) : Field = - op match { - case (functionSet: expression.FunctionSet) => dictionary.getField(functionSet.getIdentifier)(getIndex(indices)) - case _ => throw new InvalidInputException("Can only index function-sets.") - } - - private def buildFieldExpression(field: expression.Field) : Field = { - field match { - case expression.Laplacian(op) => new Laplacian(buildFieldExpression(op)) - case expression.FieldScaling(op, scale) => new ScaledField(buildFieldExpression(op), buildScalarExpression(scale)) - case expression.FieldIndexingOperation(op, indices) => buildFieldAccess(op, indices) - case (_: expression.FunctionSet) => throw new InvalidInputException("Cannot handle un-indexed function sets.") - } - } - - private def buildMatrix(id: parser.Identifier, call : Option[parser.FunctionCall]) { - import parser._ - import codegen._ - - call match { - case Some(FunctionCall(matType, params)) => (matType, params) match { - case (Identifier("SPAM3"), ParameterList(StringParameter(name))) => { - val mat = new DeclaredVarSymbol[StructType](name, OnetepTypes.SPAM3) - parameters += (name -> mat) - dictionary.addScalar(id, new SPAM3(mat, _: Seq[NamedIndex])) - } - case _ => throw new InvalidInputException("Unknown usage of type: "+matType.name) - } - case _ => throw new InvalidInputException("Undefined concrete type for matrix: "+id.name) - } - } - - private def buildFunctionSet(id: parser.Identifier, call : Option[parser.FunctionCall]) { - import parser._ - import codegen._ - - call match { - case Some(FunctionCall(fSetType, params)) => (fSetType, params) match { - case (Identifier("PPDFunctionSet"), ParameterList(StringParameter(basisName), StringParameter(dataName))) => { - val basis = new DeclaredVarSymbol[StructType](basisName, OnetepTypes.FunctionBasis) - val data = new DeclaredVarSymbol[ArrayType[FloatType]](dataName, new ArrayType[FloatType](1)) - parameters += (basisName -> basis) - parameters += (dataName -> data) - dictionary.addField(id, new PPDFunctionSet(basis, data, _: Seq[NamedIndex])) - } - case _ => throw new InvalidInputException("Unknown usage of type: "+fSetType.name) - } - case _ => throw new InvalidInputException("Undefined concrete type for function set: "+id.name) - } - } -} diff --git a/old/ofc/generators/onetep/Assignment.scala b/old/ofc/generators/onetep/Assignment.scala deleted file mode 100644 index f5972c3..0000000 --- a/old/ofc/generators/onetep/Assignment.scala +++ /dev/null @@ -1,3 +0,0 @@ -package ofc.generators.onetep - -class Assignment(val lhs: Scalar, val rhs: Scalar) diff --git a/old/ofc/generators/onetep/CodeGenerator.scala b/old/ofc/generators/onetep/CodeGenerator.scala deleted file mode 100644 index 1d47395..0000000 --- a/old/ofc/generators/onetep/CodeGenerator.scala +++ /dev/null @@ -1,37 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class CodeGenerator(dictionary: Dictionary, scope: ScopeStatement) { - class Context extends GenerationContext { - val block = new BlockStatement - - def addDeclaration(sym: VarSymbol[_ <: Type]) { - block.addDeclaration(sym) - } - - def +=(stat: Statement) { - block += stat - } - - def getStatement: Statement = block - } - - def apply(assignment: Assignment) { - val lhs = assignment.lhs - val rhs = assignment.rhs - - val iterationInfo = lhs.getIterationInfo - val context = new Context - - val indexMap = iterationInfo.getIndexMappings - val lhsFragment = lhs.getFragment(indexMap) - val rhsFragment = rhs.getFragment(indexMap) - - rhsFragment.setup(context) - lhsFragment.setValue(context, rhsFragment.getValue) - rhsFragment.teardown(context) - - val iterated = iterationInfo.getContext.toConcrete(context.getStatement) - scope += iterated; - } -} diff --git a/old/ofc/generators/onetep/DensePsincToReciprocal.scala b/old/ofc/generators/onetep/DensePsincToReciprocal.scala deleted file mode 100644 index 5464f44..0000000 --- a/old/ofc/generators/onetep/DensePsincToReciprocal.scala +++ /dev/null @@ -1,36 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class DensePsincToReciprocal(op: DensePsincFragment, indices: Map[NamedIndex, Expression[IntType]]) extends ReciprocalFragment { - import OnetepTypes.FunctionBasis - val reciprocalBox = new DeclaredVarSymbol[ArrayType[ComplexType]]("reciprocal_box", new ArrayType[ComplexType](3)) - reciprocalBox.addProperty(new AllocatableProperty) - - def setup(context: GenerationContext) { - import OnetepTypes.FFTBoxInfo - - op.setup(context) - context.addDeclaration(reciprocalBox) - - val fftboxSize : Seq[Expression[IntType]] = op.getSize - context += new AllocateStatement(reciprocalBox, fftboxSize) - - val fourierParams : Seq[Expression[_]] = Seq(new CharLiteral('C'), new CharLiteral('F'), op.getBuffer, op.getBuffer, reciprocalBox) - context += new FunctionCallStatement(new FunctionCall(OnetepFunctions.fourier_apply_box_pair, fourierParams)) - op.teardown(context) - } - - def teardown(context: GenerationContext) { - context += new DeallocateStatement(reciprocalBox) - } - - def getSize = for (dim <- 0 to 2) yield OnetepTypes.FFTBoxInfo.public % OnetepTypes.FFTBoxInfo.totalPts(dim) - - def getOrigin = op.getOrigin - - def getBuffer = reciprocalBox - - def toPsinc = new ReciprocalToPsinc(this) - - def toDensePsinc = new ReciprocalToPsinc(this) -} diff --git a/old/ofc/generators/onetep/Dictionary.scala b/old/ofc/generators/onetep/Dictionary.scala deleted file mode 100644 index 4466e58..0000000 --- a/old/ofc/generators/onetep/Dictionary.scala +++ /dev/null @@ -1,40 +0,0 @@ -package ofc.generators.onetep -import ofc.parser.Identifier -import ofc.InvalidInputException - -class Dictionary { - import scala.collection.mutable.HashMap - - var scalars = new HashMap[Identifier, Seq[NamedIndex] => Scalar] - var fields = new HashMap[Identifier, Seq[NamedIndex] => Field] - var indices = new HashMap[Identifier, NamedIndex] - - def addScalar(id: Identifier, scalarGenerator: Seq[NamedIndex] => Scalar) { - scalars += id -> scalarGenerator - } - - def addField(id: Identifier, fieldGenerator: Seq[NamedIndex] => Field) { - fields += id -> fieldGenerator - } - - def addIndex(id: Identifier, index: NamedIndex) { - indices += id -> index - } - - def getScalar(id: Identifier) = scalars.get(id) match { - case Some(s) => s - case None => throw new InvalidInputException("Unknown scalar operand "+id.getName) - } - - def getField(id: Identifier) = fields.get(id) match { - case Some(f) => f - case None => throw new InvalidInputException("Unknown field operand "+id.getName) - } - - def getIndex(id: Identifier) : NamedIndex = indices.get(id) match { - case Some(i) => i - case None => throw new InvalidInputException("Unknown index operand "+id.getName) - } - - def getIndices = indices.values -} diff --git a/old/ofc/generators/onetep/Field.scala b/old/ofc/generators/onetep/Field.scala deleted file mode 100644 index 86d16c7..0000000 --- a/old/ofc/generators/onetep/Field.scala +++ /dev/null @@ -1,6 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -trait Field extends Operand { - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) : FieldFragment -} diff --git a/old/ofc/generators/onetep/FieldFragment.scala b/old/ofc/generators/onetep/FieldFragment.scala deleted file mode 100644 index 9dabd65..0000000 --- a/old/ofc/generators/onetep/FieldFragment.scala +++ /dev/null @@ -1,26 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -trait FieldFragment extends Fragment { - def toReciprocal : ReciprocalFragment - def toPsinc : PsincFragment - def toDensePsinc : DensePsincFragment -} - -trait PsincFragment extends FieldFragment { - def toPsinc = this -} - -trait DensePsincFragment extends PsincFragment { - def getBuffer : Expression[ArrayType[FloatType]] - def toDensePsinc = this - def getSize : Seq[Expression[IntType]] - def getOrigin : Seq[Expression[IntType]] -} - -trait ReciprocalFragment extends FieldFragment { - def toReciprocal = this - def getSize : Seq[Expression[IntType]] - def getOrigin : Seq[Expression[IntType]] - def getBuffer : Expression[ArrayType[ComplexType]] -} diff --git a/old/ofc/generators/onetep/Fragment.scala b/old/ofc/generators/onetep/Fragment.scala deleted file mode 100644 index 8ed8c8a..0000000 --- a/old/ofc/generators/onetep/Fragment.scala +++ /dev/null @@ -1,6 +0,0 @@ -package ofc.generators.onetep - -trait Fragment { - def setup(context: GenerationContext) - def teardown(context: GenerationContext) -} diff --git a/old/ofc/generators/onetep/GenerationContext.scala b/old/ofc/generators/onetep/GenerationContext.scala deleted file mode 100644 index f12700e..0000000 --- a/old/ofc/generators/onetep/GenerationContext.scala +++ /dev/null @@ -1,7 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -trait GenerationContext { - def addDeclaration(sym: VarSymbol[_ <: Type]) - def +=(stat: Statement) -} diff --git a/old/ofc/generators/onetep/InnerProduct.scala b/old/ofc/generators/onetep/InnerProduct.scala deleted file mode 100644 index 92c6dab..0000000 --- a/old/ofc/generators/onetep/InnerProduct.scala +++ /dev/null @@ -1,65 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class InnerProduct(left: Field, right: Field) extends Scalar { - class LocalFragment(left: FieldFragment, right: FieldFragment) extends ScalarFragment with NonAssignableScalarFragment { - val result = new DeclaredVarSymbol[FloatType]("inner_product_result") - val leftDense = left.toDensePsinc - val rightDense = right.toDensePsinc - - def setup(context: GenerationContext) { - context.addDeclaration(result) - leftDense.setup(context) - rightDense.setup(context) - - val leftOrigin = leftDense.getOrigin - val leftSize = leftDense.getSize - - val rightOrigin = rightDense.getOrigin - val rightSize = rightDense.getSize - - val topLeft : Seq[Expression[IntType]] = - for (dim <- 0 to 2) yield new Max[IntType](leftOrigin(dim), rightOrigin(dim)) - - val bottomRight : Seq[Expression[IntType]] = - for (dim <- 0 to 2) yield new Min[IntType](leftOrigin(dim) + leftSize(dim), rightOrigin(dim) + rightSize(dim)) - 1 - - val indices = for(dim <- 0 to 2) yield { - val index = new DeclaredVarSymbol[IntType]("i"+(dim+1)) - context.addDeclaration(index) - index - } - - val loops = for(dim <- 0 to 2) yield new ForLoop(indices(dim), topLeft(dim), bottomRight(dim)) - for(dim <- 1 to 2) loops(dim) += loops(dim-1) - - context += new AssignStatement(result, new FloatLiteral(0.0)) - context += loops(2) - - val leftIndex = for (dim <- 0 to 2) yield indices(dim) - leftOrigin(dim) + 1 - val rightIndex = for (dim <- 0 to 2) yield indices(dim) - rightOrigin(dim) + 1 - - loops(0) += new AssignStatement(result, (result : Expression[FloatType]) + - leftDense.getBuffer.at(leftIndex: _*) * - rightDense.getBuffer.at(rightIndex: _*) * - (OnetepTypes.CellInfo.public % OnetepTypes.CellInfo.weight)) - - leftDense.teardown(context) - rightDense.teardown(context) - } - - def getValue = result - - def teardown(context: GenerationContext) { - } - } - - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) : ScalarFragment = - new LocalFragment(left.getFragment(indices), right.getFragment(indices)) - - def getIterationInfo : IterationInfo = { - var leftInfo = left.getIterationInfo - var rightInfo = right.getIterationInfo - leftInfo merge rightInfo - } -} diff --git a/old/ofc/generators/onetep/Laplacian.scala b/old/ofc/generators/onetep/Laplacian.scala deleted file mode 100644 index ee2c88a..0000000 --- a/old/ofc/generators/onetep/Laplacian.scala +++ /dev/null @@ -1,93 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class Laplacian(op: Field) extends Field { - class LocalFragment(parent: Laplacian, indices: Map[NamedIndex, Expression[IntType]]) extends ReciprocalFragment { - val transformed = new DeclaredVarSymbol[ArrayType[ComplexType]]("transformed", new ArrayType[ComplexType](3)) - transformed.addProperty(new AllocatableProperty) - - val opFragment = parent.getOperand.getFragment(indices).toReciprocal - - def setup(context: GenerationContext) { - context.addDeclaration(transformed) - opFragment.setup(context) - - context += new AllocateStatement(transformed, opFragment.getSize) - - val indices = for(dim <- 0 to 2) yield { - val index = new DeclaredVarSymbol[IntType]("i"+(dim+1)) - context.addDeclaration(index) - index - } - - // Construct loops - val loops = for(dim <- 0 to 2) yield new ForLoop(indices(dim), 1, getSize(dim)) - - val frequencies = for(dim <- 0 to 2) yield { - val index = indices(dim) - val frequency = new DeclaredVarSymbol[IntType]("freq_"+(dim+1)) - val halfWidth = getSize(dim)/2 + 1; - context.addDeclaration(frequency) - loops(dim) += new AssignStatement(frequency, - new ConditionalValue[IntType](index |>| halfWidth, index - getSize(dim) - 1, index - 1)) - frequency - } - - // Nest loops and add outer to context - for(dim <- 1 to 2) loops(dim) += loops(dim-1) - context += loops(2) - - val reciprocalVector = for(dim <- 0 to 2) yield { - val component = new DeclaredVarSymbol[FloatType]("reciprocal_vector"+(dim+1)) - context.addDeclaration(component) - (component : Expression[FloatType]) - } - - for(dim <- 0 to 2) { - var component : Expression[FloatType] = new FloatLiteral(0.0) - for(vec <- 0 to 2) { - val vector = OnetepTypes.FFTBoxInfo.public % OnetepTypes.FFTBoxInfo.latticeReciprocal(vec) - component = component + vector % OnetepTypes.Point.coord(dim) * new Conversion[IntType, FloatType](frequencies(vec)) - } - loops(0) += new AssignStatement(reciprocalVector(dim), component) - } - - val reciprocalIndex = indices.map(new VarRef[IntType](_)) - - //TODO: Use a unary negation instead of multiplication by -1.0. - loops(0) += new AssignStatement(transformed.at(reciprocalIndex: _*), - opFragment.getBuffer.at(reciprocalIndex: _*) * - new Conversion[FloatType, ComplexType](magnitude(reciprocalVector) * new FloatLiteral(-1.0))) - - opFragment.teardown(context) - } - - private def magnitude(vector: Seq[Expression[FloatType]]) = { - var result : Expression[FloatType] = new FloatLiteral(0.0) - for(element <- vector) result += element * element - result - } - - def teardown(context: GenerationContext) { - context += new DeallocateStatement(transformed) - } - - def getSize = opFragment.getSize - - def getOrigin = opFragment.getOrigin - - def getBuffer = transformed - - def toPsinc = new ReciprocalToPsinc(this) - - def toDensePsinc = new ReciprocalToPsinc(this) - } - - private def getOperand = op - - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) = - new LocalFragment(this, indices) - - def getIterationInfo : IterationInfo = - op.getIterationInfo -} diff --git a/old/ofc/generators/onetep/NamedIndex.scala b/old/ofc/generators/onetep/NamedIndex.scala deleted file mode 100644 index bc50ca1..0000000 --- a/old/ofc/generators/onetep/NamedIndex.scala +++ /dev/null @@ -1,5 +0,0 @@ -package ofc.generators.onetep - -class NamedIndex(name: String) { - def getName = name -} diff --git a/old/ofc/generators/onetep/OnetepFunctions.scala b/old/ofc/generators/onetep/OnetepFunctions.scala deleted file mode 100644 index dd5424e..0000000 --- a/old/ofc/generators/onetep/OnetepFunctions.scala +++ /dev/null @@ -1,71 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -object OnetepFunctions { - - // module basis - - val basis_copy_function_to_box = new FortranSubroutineSignature("basis_copy_function_to_box", - Seq(("fa_box", new ArrayType[FloatType](3)), - ("box_n1", new IntType), - ("box_n2", new IntType), - ("box_n3", new IntType), - ("offset1", new IntType), - ("offset2", new IntType), - ("offset3", new IntType), - ("fa_tightbox", OnetepTypes.TightBox), - ("fa_on_grid", new ArrayType[FloatType](1)), - ("fa_sphere", OnetepTypes.Sphere))) - - val basis_ket_start_wrt_fftbox = new FortranSubroutineSignature("basis_ket_start_wrt_fftbox", - Seq(("row_start1", new IntType), - ("row_start1", new IntType), - ("row_start3", new IntType), - ("n1", new IntType), - ("n2", new IntType), - ("n3", new IntType))) - - List(basis_copy_function_to_box, basis_ket_start_wrt_fftbox).map(_.addProperty(new FortranModule("basis"))) - - // module fourier - - val fourier_apply_box_pair = new FortranSubroutineSignature("fourier_apply_box_pair", - Seq(("grid", new CharType), - ("dir", new CharType), - ("rspc1", new ArrayType[FloatType](3)), - ("rspc2", new ArrayType[FloatType](3)), - ("gspc", new ArrayType[ComplexType](3)))) - - List(fourier_apply_box_pair).map(_.addProperty(new FortranModule("fourier"))) - - // module sparse - - val sparse_first_elem_on_node = new FortranFunctionSignature[IntType]("sparse_first_elem_on_node", - Seq(("node", new IntType), - ("mat", OnetepTypes.SPAM3), - ("rowcol", new CharType))) - - val sparse_index_length = new FortranFunctionSignature[IntType]("sparse_index_length", - Seq(("mat", OnetepTypes.SPAM3))) - - val sparse_generate_index = new FortranSubroutineSignature("sparse_generate_index", - Seq(("idx", new ArrayType[IntType](1)), - ("mat", OnetepTypes.SPAM3))) - - val sparse_atom_of_elem = new FortranFunctionSignature[IntType]("sparse_atom_of_elem", - Seq(("elem", new IntType), - ("mat", OnetepTypes.SPAM3), - ("rowcol", new CharType))) - - val sparse_put_element_real = new FortranSubroutineSignature("sparse_put_element", - Seq(("el", new FloatType), - ("mat", OnetepTypes.SPAM3), - ("jrow", new IntType), - ("jcol", new IntType))) - - List(sparse_first_elem_on_node, - sparse_index_length, - sparse_generate_index, - sparse_atom_of_elem, - sparse_put_element_real).map(_.addProperty(new FortranModule("sparse"))) -} diff --git a/old/ofc/generators/onetep/OnetepTypes.scala b/old/ofc/generators/onetep/OnetepTypes.scala deleted file mode 100644 index 75ff483..0000000 --- a/old/ofc/generators/onetep/OnetepTypes.scala +++ /dev/null @@ -1,89 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -object OnetepTypes { - object FunctionBasis extends StructType { - addProperty(new FortranModule("function_basis")) - def getName = "FUNC_BASIS" - - val numPPDsInSphere = { - val fieldType = new PointerType[ArrayType[IntType]](new ArrayType[IntType](1)) - new FieldSymbol[PointerType[ArrayType[IntType]]]("n_ppds_sphere", fieldType) - } - - val num = new FieldSymbol[IntType]("num") - - val tightBoxes = { - val fieldType = new PointerType[ArrayType[StructType]](new ArrayType(1, TightBox)) - new FieldSymbol[PointerType[ArrayType[StructType]]]("tight_boxes", fieldType) - } - - val spheres = { - val fieldType = new PointerType[ArrayType[StructType]](new ArrayType[StructType](1, Sphere)) - new FieldSymbol[PointerType[ArrayType[StructType]]]("spheres", fieldType) - } - } - - object Sphere extends StructType { - addProperty(new FortranModule("basis")) - def getName = "SPHERE" - - val ppdList = { - val fieldType = new PointerType[ArrayType[IntType]](new ArrayType[IntType](2)) - new FieldSymbol[PointerType[ArrayType[IntType]]]("ppd_list", fieldType) - } - - val offset = new FieldSymbol[IntType]("offset") - } - - object Point extends StructType { - addProperty(new FortranModule("geometry")) - def getName = "POINT" - - val x = new FieldSymbol[FloatType]("X") - val y = new FieldSymbol[FloatType]("Y") - val z = new FieldSymbol[FloatType]("Z") - val coord = List(x,y,z) - } - - object CellInfo extends StructType { - private val module = new FortranModule("simulation_cell") - addProperty(module) - def getName = "CELL_INFO" - - val public = new NamedUnboundVarSymbol[StructType]("pub_cell", OnetepTypes.CellInfo) - public.addProperty(module) - - val ppdWidth = {for (dim <- 1 to 3) yield new FieldSymbol[IntType]("n_pt"+dim)}.toSeq - val numPPDs = {for (dim <- 1 to 3) yield new FieldSymbol[IntType]("n_ppds_a"+dim)}.toSeq - val pointsInPPD = new FieldSymbol[IntType]("n_pts") - val latticeReciprocal = for(dim <- 1 to 3) yield new FieldSymbol[StructType]("b"+dim, Point) - val weight = new FieldSymbol[FloatType]("weight") - } - - object TightBox extends StructType { - addProperty(new FortranModule("basis")) - def getName = "FUNCTION_TIGHT_BOX" - - val startPts = {for (dim <- 1 to 3) yield new FieldSymbol[IntType]("start_pts"+dim)}.toSeq - val finishPts = {for (dim <- 1 to 3) yield new FieldSymbol[IntType]("finish_pts"+dim)}.toSeq - val startPPD = {for (dim <- 1 to 3) yield new FieldSymbol[IntType]("start_ppds"+dim)}.toSeq - val finishPPD = {for (dim <- 1 to 3) yield new FieldSymbol[IntType]("finish_ppds"+dim)}.toSeq - } - - object FFTBoxInfo extends StructType { - addProperty(new FortranModule("fourier")) - def getName = "FFTBOX_INFO" - - val public = new NamedUnboundVarSymbol[StructType]("pub_fftbox", FFTBoxInfo) - public.addProperty(new FortranModule("simulation_cell")) - - val latticeReciprocal = for(dim <- 1 to 3) yield new FieldSymbol[StructType]("b"+dim, Point) - val totalPts = {for (dim <- 1 to 3) yield new FieldSymbol[IntType]("total_pt"+dim)}.toSeq - } - - object SPAM3 extends StructType { - addProperty(new FortranModule("sparse")) - def getName = "SPAM3" - } -} diff --git a/old/ofc/generators/onetep/OnetepVariables.scala b/old/ofc/generators/onetep/OnetepVariables.scala deleted file mode 100644 index 277ad7b..0000000 --- a/old/ofc/generators/onetep/OnetepVariables.scala +++ /dev/null @@ -1,15 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -object OnetepVariables { - // comms - val pub_my_node_id = new NamedUnboundVarSymbol[IntType]("pub_my_node_id") - pub_my_node_id.addProperty(new FortranModule("comms")) - - // parallel_strategy - val pub_first_atom_on_node = new NamedUnboundVarSymbol[ArrayType[IntType]]("pub_first_atom_on_node", new ArrayType[IntType](1)) - val pub_num_atoms_on_node = new NamedUnboundVarSymbol[ArrayType[IntType]]("pub_num_atoms_on_node", new ArrayType[IntType](1)) - - List(pub_first_atom_on_node, - pub_num_atoms_on_node).map(_.addProperty(new FortranModule("parallel_strategy"))) -} diff --git a/old/ofc/generators/onetep/Operand.scala b/old/ofc/generators/onetep/Operand.scala deleted file mode 100644 index d31822f..0000000 --- a/old/ofc/generators/onetep/Operand.scala +++ /dev/null @@ -1,13 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class IterationInfo(val context: IterationContext, val indexMappings: Map[NamedIndex, Expression[IntType]]) { - def merge(other: IterationInfo) : IterationInfo = - new IterationInfo(context merge other.context, indexMappings ++ other.indexMappings) - def getContext = context - def getIndexMappings = indexMappings -} - -trait Operand { - def getIterationInfo : IterationInfo -} diff --git a/old/ofc/generators/onetep/PPDFunctionSet.scala b/old/ofc/generators/onetep/PPDFunctionSet.scala deleted file mode 100644 index 61fe3a9..0000000 --- a/old/ofc/generators/onetep/PPDFunctionSet.scala +++ /dev/null @@ -1,185 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ -import ofc.{LogicError,UnimplementedException} -/* -object PPDFunctionSet { - private class SphereIndex(name: String, value: Expression[IntType]) extends DiscreteIndex { - def getName = name - def getValue = value - } - - private class PositionIndex(name: String, value: Expression[IntType], centre: Expression[IntType]) extends FunctionSpatialIndex { - def getName = name - def getValue = value - def getFunctionCentre = centre - } - - def apply(basisName: String, dataName: String) : PPDFunctionSet = { - import OnetepTypes._ - - val basis = new NamedUnboundVarSymbol[StructType](basisName, FunctionBasis) - val data = new NamedUnboundVarSymbol[ArrayType[FloatType]](dataName, new ArrayType[FloatType](1)) - - val numSpheres = basis % FunctionBasis.num - val ppdWidths = for(dim <- 0 to 2) yield CellInfo.public % CellInfo.ppdWidth(dim) - val cellWidthPPDs = for(dim <- 0 to 2) yield CellInfo.public % CellInfo.numPPDs(dim) - val cellWidthPts = for(dim <- 0 to 2) yield cellWidthPPDs(dim) * ppdWidths(dim) - - val producer = new ProducerStatement - val sphereIndex = producer.addIteration("sphere_index", 1, numSpheres) - val numPPDs = (~(basis % FunctionBasis.numPPDsInSphere)).at(sphereIndex) - val ppdIndex = producer.addIteration("ppd_index", 1, numPPDs) - val sphere = (~(basis % FunctionBasis.spheres)).at(sphereIndex) - val ppdGlobalCount = (~(sphere % Sphere.ppdList)).at(ppdIndex, 1) - 1 - - // The integer co-ordinates of the PPD (0-based) - val a3pos = producer.addExpression("ppd_pos1", ppdGlobalCount / (cellWidthPPDs(0)*cellWidthPPDs(1))) - val a2pos = producer.addExpression("ppd_pos2", (ppdGlobalCount % (cellWidthPPDs(0)*cellWidthPPDs(1)))/cellWidthPPDs(0)) - val a1pos = producer.addExpression("ppd_pos3", ppdGlobalCount % cellWidthPPDs(0)) - val ppdPos = List(a1pos, a2pos, a3pos) - - val tightbox = (~(basis % FunctionBasis.tightBoxes)).at(sphereIndex) - - // The offsets into the PPDs for the edges of the tightbox - val ppdStartOffsets = for(dim <- 0 to 2) yield tightbox % TightBox.startPts(dim) - 1 - val ppdFinishOffsets = for(dim <- 0 to 2) yield tightbox % TightBox.finishPts(dim) - 1 - - // The first and last PPDs in PPD co-ordinates (0-based, inside simulation cell) - val startPPDs = for(dim <- 0 to 2) yield - producer.addExpression("start_ppd"+(dim+1), (tightbox % TightBox.startPPD(dim) + cellWidthPPDs(dim)-1) % cellWidthPPDs(dim)) - val finishPPDs = for(dim <- 0 to 2) yield - producer.addExpression("finish_ppd"+(dim+1),(tightbox % TightBox.finishPPD(dim) + cellWidthPPDs(dim)-1) % cellWidthPPDs(dim)) - - // The dimensions of the tightbox - val tightboxStartPts = for(dim <- 0 to 2) yield - producer.addExpression("tightbox_start_pt"+(dim+1), startPPDs(dim)*(CellInfo.public % CellInfo.ppdWidth(dim)) + ppdStartOffsets(dim)) - - val tightboxFinishPts = for(dim <- 0 to 2) yield - producer.addExpression("tightbox_finsh_pt"+(dim+1), finishPPDs(dim)*(CellInfo.public % CellInfo.ppdWidth(dim)) + ppdFinishOffsets(dim)) - - val tightboxWidth = for(dim <- 0 to 2) yield - producer.addExpression("tightbox_width_pt"+(dim+1), (tightboxFinishPts(dim) - tightboxStartPts(dim) + cellWidthPts(dim)) % cellWidthPts(dim)) - - val tightboxCentre = for(dim <- 0 to 2) yield - producer.addExpression("tightbox_centre_pt"+(dim+1), ((tightboxStartPts(dim) : Expression[IntType]) + tightboxWidth(dim) / 2) % cellWidthPts(dim)) - - // Offsets for the current PPD being iterated over - val loopStarts = for(dim <- 0 to 2) yield - producer.addExpression("start_pt"+(dim+1), new ConditionalValue[IntType](startPPDs(dim) |==| ppdPos(dim), ppdStartOffsets(dim), 0)) - - val loopEnds = for(dim <- 0 to 2) yield - producer.addExpression("end_pt"+(dim+1), new ConditionalValue[IntType](finishPPDs(dim) |==| ppdPos(dim), ppdFinishOffsets(dim), ppdWidths(dim) - 1)) - - // Loops for iterating over the PPD itself - val ppdIndices = for(dim <- 0 to 2) yield producer.addIteration("point"+(dim+1), loopStarts(dim), loopEnds(dim)) - - // Values exposed as indices and data - val positions = for(dim <- 0 to 2) yield - producer.addExpression("pos"+(dim+1), ppdPos(dim)*ppdWidths(dim) + ppdIndices(dim)) - - val ppdDataStart = - producer.addExpression("ppd_data_start", (sphere % Sphere.offset) + (ppdIndex-1) * (CellInfo.public % CellInfo.pointsInPPD)) - - val ppdDataIndex = producer.addExpression("ppd_data_index", (ppdDataStart: Expression[IntType]) - + ppdIndices(2) * (CellInfo.public % CellInfo.ppdWidth(1)) * (CellInfo.public % CellInfo.ppdWidth(0)) - + ppdIndices(1) * (CellInfo.public % CellInfo.ppdWidth(0)) - + ppdIndices(0)) - - val dataValue = producer.addExpression("data", data.at(ppdDataIndex)) - - val discreteIndices = List[DiscreteIndex](new SphereIndex("sphere", sphereIndex)) - val spatialIndices = { - val indexNames = List("x", "y", "z") - for (dim <- 0 to 2) yield new PositionIndex(indexNames(dim), positions(dim), tightboxCentre(dim)) - } - - new PPDFunctionSet(discreteIndices, spatialIndices, dataValue, producer) - } -} -*/ - -class PPDFunctionSet(val basis: Expression[StructType], val data: Expression[ArrayType[FloatType]], indices: Seq[NamedIndex]) extends Field { - - class LocalFragment(parent: PPDFunctionSet, indices: Map[NamedIndex, Expression[IntType]]) extends PsincFragment { - def setup(context: GenerationContext) {} - def teardown(context: GenerationContext) {} - def toReciprocal : ReciprocalFragment = toDensePsinc.toReciprocal - def toDensePsinc = new LocalDense(parent, indices) - } - - class LocalDense(parent: PPDFunctionSet, indices: Map[NamedIndex, Expression[IntType]]) extends DensePsincFragment { - import OnetepTypes.FunctionBasis - - val sphereIndex = indices.get(parent.getSphereIndex) match { - case Some(expression) => expression - case None => throw new LogicError("Cannot find expression for index "+parent.getSphereIndex) - } - - val fftbox = new DeclaredVarSymbol[ArrayType[FloatType]]("fftbox", new ArrayType[FloatType](3)) - fftbox.addProperty(new AllocatableProperty) - - val tightbox = (~(basis % FunctionBasis.tightBoxes)).at(sphereIndex) - val sphere = (~(basis % FunctionBasis.spheres)).at(sphereIndex) - val fftboxOffset = for(dim <- 0 to 2) yield new DeclaredVarSymbol[IntType]("fftbox_offset"+(dim+1)) - val tightboxOrigin = for(dim <- 0 to 2) yield new DeclaredVarSymbol[IntType]("tightbox_origin"+(dim+1)) - - def setup(context: GenerationContext) { - import OnetepTypes.FFTBoxInfo - - context.addDeclaration(fftbox) - fftboxOffset.map(context.addDeclaration(_)) - - val fftboxSize : Seq[Expression[IntType]] = getSize - context += new AllocateStatement(fftbox, fftboxSize) - context += new FunctionCallStatement(new FunctionCall(OnetepFunctions.basis_ket_start_wrt_fftbox, - fftboxOffset.map(new VarRef[IntType](_)) ++ fftboxSize)) - - var basisCopyParams : Seq[Expression[_]] = Nil - basisCopyParams :+= (fftbox: Expression[ArrayType[FloatType]]) - basisCopyParams ++= fftboxSize - basisCopyParams ++= fftboxOffset.map(new VarRef[IntType](_)) - basisCopyParams :+= tightbox - basisCopyParams :+= (parent.data: Expression[ArrayType[FloatType]]) - basisCopyParams :+= sphere - - context += new FunctionCallStatement(new FunctionCall(OnetepFunctions.basis_copy_function_to_box, basisCopyParams)) - - for (dim <- 0 to 2) yield { - import OnetepTypes._ - val startPPD = tightbox % TightBox.startPPD(dim) - 1 - val startPPDPoint = startPPD * (CellInfo.public % CellInfo.ppdWidth(dim)) - val startPoint = startPPDPoint + tightbox % TightBox.startPts(dim) - - context.addDeclaration(tightboxOrigin(dim)) - context += new AssignStatement(tightboxOrigin(dim), startPoint) - } - } - - def teardown(context: GenerationContext) { - context += new DeallocateStatement(fftbox) - } - - def getSize = for (dim <- 0 to 2) yield OnetepTypes.FFTBoxInfo.public % OnetepTypes.FFTBoxInfo.totalPts(dim) - - def getOrigin = { - for (dim <- 0 to 2) yield - tightboxOrigin(dim) - fftboxOffset(dim) - } - - def getBuffer = fftbox - - def toReciprocal = new DensePsincToReciprocal(this, indices) - } - - private def getSphereIndex = indices.head - - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) : FieldFragment = - new LocalFragment(this, indices) - - def getIterationInfo : IterationInfo = { - val context = new IterationContext - val numSpheres = basis % OnetepTypes.FunctionBasis.num - val sphereIndexExpr = context.addIteration("sphere_index", 1, numSpheres) - new IterationInfo(context, Map(getSphereIndex -> sphereIndexExpr)) - } -} diff --git a/old/ofc/generators/onetep/ReciprocalToPsinc.scala b/old/ofc/generators/onetep/ReciprocalToPsinc.scala deleted file mode 100644 index 0e17431..0000000 --- a/old/ofc/generators/onetep/ReciprocalToPsinc.scala +++ /dev/null @@ -1,38 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class ReciprocalToPsinc(op: ReciprocalFragment) extends DensePsincFragment { - val fftbox = new DeclaredVarSymbol[ArrayType[FloatType]]("fftbox", new ArrayType[FloatType](3)) - fftbox.addProperty(new AllocatableProperty) - - val dummybox = new DeclaredVarSymbol[ArrayType[FloatType]]("dummybox", new ArrayType[FloatType](3)) - dummybox.addProperty(new AllocatableProperty) - - def toReciprocal = op - - def setup(context: GenerationContext) { - op.setup(context) - context.addDeclaration(fftbox) - context.addDeclaration(dummybox) - - val fftboxSize : Seq[Expression[IntType]] = getSize - context += new AllocateStatement(fftbox, fftboxSize) - context += new AllocateStatement(dummybox, fftboxSize) - - val fourierParams : Seq[Expression[_]] = Seq(new CharLiteral('C'), new CharLiteral('B'), fftbox, dummybox, op.getBuffer) - context += new FunctionCallStatement(new FunctionCall(OnetepFunctions.fourier_apply_box_pair, fourierParams)) - - op.teardown(context) - } - - def teardown(context: GenerationContext) { - context += new DeallocateStatement(fftbox) - context += new DeallocateStatement(dummybox) - } - - def getSize = for (dim <- 0 to 2) yield OnetepTypes.FFTBoxInfo.public % OnetepTypes.FFTBoxInfo.totalPts(dim) - - def getOrigin = op.getOrigin - - def getBuffer = fftbox -} diff --git a/old/ofc/generators/onetep/SPAM3.scala b/old/ofc/generators/onetep/SPAM3.scala deleted file mode 100644 index f9cee0b..0000000 --- a/old/ofc/generators/onetep/SPAM3.scala +++ /dev/null @@ -1,82 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class SPAM3(mat: Expression[StructType], position: Seq[NamedIndex]) extends Scalar { - - class LocalFragment(row: Expression[IntType], col: Expression[IntType]) extends ScalarFragment { - def setup(context: GenerationContext) { - } - - def getValue = throw new ofc.UnimplementedException("get unimplemented for SPAM3") - - def setValue(context: GenerationContext, value: Expression[FloatType]) { - val functionCall = new FunctionCall(OnetepFunctions.sparse_put_element_real, - Seq(value, mat, row, col)) - context += new FunctionCallStatement(functionCall) - } - - def teardown(context: GenerationContext) { - } - } - - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) : ScalarFragment = - new LocalFragment(indices.get(position(0)).get, indices.get(position(1)).get) - - def getIterationInfo : IterationInfo = { - val context = new IterationContext - - // Create sparse index - val header = new BlockStatement - val indexLength = new FunctionCall(OnetepFunctions.sparse_index_length, Seq(mat)) - val index = new DeclaredVarSymbol[ArrayType[IntType]]("sparse_idx", new ArrayType[IntType](1)) - index.addProperty(new AllocatableProperty) - - header += new AllocateStatement(index, Seq(indexLength)) - header += new FunctionCallStatement(new FunctionCall(OnetepFunctions.sparse_generate_index, Seq(index, mat))) - context.addHeader(header) - context.addDeclaration(index) - - val footer = new DeallocateStatement(index) - context.addFooter(footer) - - val firstCol = new FunctionCall(OnetepFunctions.sparse_first_elem_on_node, - Seq(OnetepVariables.pub_my_node_id, - mat, - new CharLiteral('C'))) - - val lastCol = new FunctionCall(OnetepFunctions.sparse_first_elem_on_node, - Seq((OnetepVariables.pub_my_node_id: Expression[IntType])+1, - mat, - new CharLiteral('C'))) - 1 - - val firstRow = new FunctionCall(OnetepFunctions.sparse_first_elem_on_node, - Seq(OnetepVariables.pub_my_node_id, - mat, - new CharLiteral('R'))) - - val lastRow = new FunctionCall(OnetepFunctions.sparse_first_elem_on_node, - Seq((OnetepVariables.pub_my_node_id: Expression[IntType])+1, - mat, - new CharLiteral('R'))) - 1 - - val col = context.addIteration("col", firstCol, lastCol) - val colAtom = context.addExpression("col_atom", new FunctionCall(OnetepFunctions.sparse_atom_of_elem, - Seq(col, mat, new CharLiteral('C')))) - val localColAtom = context.addExpression("local_col_atom", - colAtom - OnetepVariables.pub_first_atom_on_node.at(OnetepVariables.pub_my_node_id) + 1) - - val row = context.addIteration("row", firstRow, lastRow) - val rowAtom = context.addExpression("row_atom", new FunctionCall(OnetepFunctions.sparse_atom_of_elem, - Seq(row, mat, new CharLiteral('R')))) - - val rowIdx = context.addIteration("row_idx", index.at(localColAtom), - index.at((localColAtom: Expression[IntType])+1)-1) - context.addPredicate(index.at(rowIdx) |==| rowAtom) - - var indexMappings : Map[NamedIndex, Expression[IntType]] = Map.empty - indexMappings += position(0) -> row - indexMappings += position(1) -> col - - new IterationInfo(context, indexMappings) - } -} diff --git a/old/ofc/generators/onetep/Scalar.scala b/old/ofc/generators/onetep/Scalar.scala deleted file mode 100644 index e151dad..0000000 --- a/old/ofc/generators/onetep/Scalar.scala +++ /dev/null @@ -1,6 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -trait Scalar extends Operand { - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) : ScalarFragment -} diff --git a/old/ofc/generators/onetep/ScalarFragment.scala b/old/ofc/generators/onetep/ScalarFragment.scala deleted file mode 100644 index 936bbc9..0000000 --- a/old/ofc/generators/onetep/ScalarFragment.scala +++ /dev/null @@ -1,13 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -trait ScalarFragment extends Fragment { - def getValue : Expression[FloatType] - def setValue(context: GenerationContext, value: Expression[FloatType]) -} - -trait NonAssignableScalarFragment { - def setValue(context: GenerationContext, value: Expression[FloatType]) { - throw new ofc.LogicError("Expression: "+this+" is not assignable.") - } -} diff --git a/old/ofc/generators/onetep/ScalarLiteral.scala b/old/ofc/generators/onetep/ScalarLiteral.scala deleted file mode 100644 index 277613e..0000000 --- a/old/ofc/generators/onetep/ScalarLiteral.scala +++ /dev/null @@ -1,21 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class ScalarLiteral(s: Double) extends Scalar { - class LocalFragment(s: Double) extends ScalarFragment with NonAssignableScalarFragment { - def setup(context: GenerationContext) { - } - - def getValue = - new FloatLiteral(s) - - def teardown(context: GenerationContext) { - } - } - - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) : ScalarFragment = - new LocalFragment(s) - - def getIterationInfo : IterationInfo = - new IterationInfo(new IterationContext, Map.empty) -} diff --git a/old/ofc/generators/onetep/ScaledField.scala b/old/ofc/generators/onetep/ScaledField.scala deleted file mode 100644 index be401f3..0000000 --- a/old/ofc/generators/onetep/ScaledField.scala +++ /dev/null @@ -1,69 +0,0 @@ -package ofc.generators.onetep -import ofc.codegen._ - -class ScaledField(op: Field, factor: Scalar) extends Field { - class LocalFragment(parent: ScaledField, indices: Map[NamedIndex, Expression[IntType]]) extends DensePsincFragment { - val transformed = new DeclaredVarSymbol[ArrayType[FloatType]]("scaled", new ArrayType[FloatType](3)) - transformed.addProperty(new AllocatableProperty) - - val scaleFragment = parent.getScalingFactor.getFragment(indices) - val opFragment = parent.getOperand.getFragment(indices).toDensePsinc - - def setup(context: GenerationContext) { - context.addDeclaration(transformed) - opFragment.setup(context) - scaleFragment.setup(context) - - context += new AllocateStatement(transformed, opFragment.getSize) - - val indices = for(dim <- 0 to 2) yield { - val index = new DeclaredVarSymbol[IntType]("i"+(dim+1)) - context.addDeclaration(index) - index - } - - // Construct loops - val loops = for(dim <- 0 to 2) yield new ForLoop(indices(dim), 1, getSize(dim)) - - // Nest loops and add outer to context - for(dim <- 1 to 2) loops(dim) += loops(dim-1) - context += loops(2) - - val index = indices.map(new VarRef[IntType](_)) - - loops(0) += new AssignStatement(transformed.at(index: _*), - opFragment.getBuffer.at(index: _*) * scaleFragment.getValue) - - opFragment.teardown(context) - scaleFragment.teardown(context) - } - - private def magnitude(vector: Seq[Expression[FloatType]]) = { - var result : Expression[FloatType] = new FloatLiteral(0.0) - for(element <- vector) result += element * element - result - } - - def teardown(context: GenerationContext) { - context += new DeallocateStatement(transformed) - } - - def getSize = opFragment.getSize - - def getOrigin = opFragment.getOrigin - - def getBuffer = transformed - - def toReciprocal = new DensePsincToReciprocal(this, indices) - } - - private def getOperand = op - - private def getScalingFactor = factor - - def getFragment(indices: Map[NamedIndex, Expression[IntType]]) = - new LocalFragment(this, indices) - - def getIterationInfo : IterationInfo = - op.getIterationInfo merge factor.getIterationInfo -} diff --git a/old/ofc/parser/Parser.scala b/old/ofc/parser/Parser.scala deleted file mode 100644 index 5bd373f..0000000 --- a/old/ofc/parser/Parser.scala +++ /dev/null @@ -1,67 +0,0 @@ -package ofc.parser -import scala.util.parsing.combinator._ -import scala.util.parsing.input.Position -import java.io.Reader - -sealed abstract class ScalarOperationTag -case class MultiplicationTag() extends ScalarOperationTag -case class DivisionTag() extends ScalarOperationTag - -class ParseException(message: String, pos: Position) extends Exception { - override def toString : String = - message + " at line " + pos.line + ", column " + pos.column + "." -} - -class Parser extends JavaTokenParsers { - def program : Parser[List[Statement]] = rep(comment | declarations | definition | target | comment | specifics) - def comment : Parser[Comment] = "#"~!".*".r ^^ (v => new Comment(v._2)) - def identifier : Parser[Identifier] = ident ^^ (v => new Identifier(v)) - - def oflType : Parser[OFLType] = arrayType | functionSetType | indexType - def arrayType : Parser[Matrix] = "Array["~>repsep(indexType, ",")<~"]" ^^ (x => new Matrix(x)) - def functionSetType : Parser[FunctionSet] = "FunctionSet" ^^ (_ => new FunctionSet) - def indexType : Parser[Index] = "FunctionIndex" ^^ (_ => new Index) - - def declarations: Parser[DeclarationList] = oflType~!repsep(identifier, ",") ^^ - (d => new DeclarationList(d._1, d._2)) - - def definition: Parser[Definition] = indexedIdentifier~("="~>expr) ^^ (x => new Definition(x._1, x._2)) - def expr : Parser[Expression] = term~opt(scalarOperator~!expr) ^^ - (x => x._2 match { - case None => x._1 - case Some(y) => y._1 match { - case MultiplicationTag() => new Multiplication(x._1, y._2) - case DivisionTag() => new Division(x._1, y._2) - } - }) - - def scalarOperator : Parser[ScalarOperationTag] = mulOp | divOp - def mulOp : Parser[ScalarOperationTag] = "*" ^^ (_ => MultiplicationTag()) - def divOp : Parser[ScalarOperationTag] = "/" ^^ (_ => DivisionTag()) - - def term: Parser[Expression] = scalarConstant ||| indexedIdentifier ||| operator - def scalarConstant : Parser[ScalarConstant] = floatingPointNumber ^^ (x => new ScalarConstant(x.toDouble)) - def indexedIdentifier: Parser[IndexedIdentifier] = identifier~opt("["~>repsep(identifier, ",")<~"]") ^^ - (x => new IndexedIdentifier(x._1, x._2 match { - case Some(list) => list - case None => Nil - })) - def operator : Parser[Operator] = identifier~("("~>repsep(expr, ",")<~")") ^^ (x => new Operator(x._1, x._2)) - - def target : Parser[Target] = "target"~!identifier ^^ (x => new Target(x._2)) - def specifics : Parser[TargetAssignment] = "Variable"~>identifier~("="~>functionCall) ^^ (x => new TargetAssignment(x._1, x._2)) - def functionCall : Parser[FunctionCall] = identifier~("("~>repsep(functionParameter, ",")<~")") ^^ - (x => new FunctionCall(x._1, new ParameterList(x._2 : _*))) - - def functionParameter : Parser[Parameter] = stringParameter | numericParameter | identifier | parameterList - def stringParameter : Parser[StringParameter] = stringLiteral ^^ (x => new StringParameter(x.slice(1, x.length-1))) - def numericParameter : Parser[NumericParameter] = floatingPointNumber ^^ (x => new NumericParameter(x.toDouble)) - def parameterList : Parser[ParameterList] = "["~>repsep(functionParameter, ",")<~"]" ^^ (x => new ParameterList(x : _*)) - - def parseProgram(in: Reader) : List[Statement] = - parseAll(program, in) match { - case Success(result, _) => result - case r : NoSuccess => - throw new ParseException(r.msg, r.next.pos) - } -} diff --git a/old/ofc/parser/Statement.scala b/old/ofc/parser/Statement.scala deleted file mode 100644 index 3c6ddce..0000000 --- a/old/ofc/parser/Statement.scala +++ /dev/null @@ -1,69 +0,0 @@ -package ofc.parser - -case class Identifier(name: String) extends Parameter { - override def toString : String = "id(\""+name+"\")" - def getName = name -} - -sealed abstract class Statement -class Comment(value: String) extends Statement { - override def toString : String = "comment(\""+value+"\")" -} -case class DeclarationList(oflType: OFLType, names: List[Identifier]) extends Statement { - override def toString : String = "decl("+oflType+", "+names+")" -} -case class Definition(term: IndexedIdentifier, expr: Expression) extends Statement { - override def toString : String = "define("+term+", "+expr+")" -} -case class Target(name: Identifier) extends Statement { - override def toString : String = "target("+name+")" -} -case class TargetAssignment(id: Identifier, value: FunctionCall) extends Statement { - override def toString : String = "target_assignment("+id+", "+value+")" -} - -sealed abstract class OFLType -case class Matrix(indices: List[Index]) extends OFLType { - override def toString : String = "Matrix" -} -case class FunctionSet() extends OFLType { - override def toString : String = "FunctionSet" -} -case class Index() extends OFLType { - override def toString : String = "Index" -} - -sealed abstract class Expression -case class ScalarConstant(s: Double) extends Expression { - override def toString : String = s.toString -} -case class IndexedIdentifier(id: Identifier, indices : List[Identifier]) extends Expression { - override def toString : String = id+indices.mkString("[", ", ", "]") -} -case class Operator(id: Identifier, operands : List[Expression]) extends Expression { - override def toString : String = "operator("+id+ ", " + operands.mkString("[", ", ", "]")+")" -} - -sealed abstract class ScalarOperation extends Expression -case class Multiplication(a: Expression, b: Expression) extends ScalarOperation { - override def toString : String = "mul("+a.toString+","+b.toString+")" -} -case class Division(a: Expression, b: Expression) extends ScalarOperation { - override def toString : String = "div("+a.toString+","+b.toString+")" -} - -case class FunctionCall(name: Identifier, params: ParameterList) { - override def toString : String = "call("+name+", "+params+")" -} - -sealed abstract class Parameter -case class ParameterList(params: Parameter*) extends Parameter { - override def toString : String = params.mkString("[", ", ", "]") - def toSeq : Seq[Parameter] = params.toSeq -} -case class StringParameter(value: String) extends Parameter { - override def toString : String = "\""+value+"\"" -} -case class NumericParameter(value: Double) extends Parameter { - override def toString : String = value.toString -} diff --git a/old/ofc/util/DirectedGraph.scala b/old/ofc/util/DirectedGraph.scala deleted file mode 100644 index 6c060d0..0000000 --- a/old/ofc/util/DirectedGraph.scala +++ /dev/null @@ -1,64 +0,0 @@ -package ofc.util -import ofc.LogicError - -object DirectedGraph { - private def topoSort(graph: DirectedGraph, queue: Queue[DirectedGraph#Vertex]) = { - type Vertex = DirectedGraph#Vertex - val degrees = scala.collection.mutable.Map[Vertex, Int]() - val result = scala.collection.mutable.ArrayBuffer[Vertex]() - - degrees ++= { for (v <- graph.vertices) yield (v, graph.inDegree(v)) } - queue ++= { for (v <- graph.vertices; if graph.inDegree(v) == 0) yield v } - - while(queue.nonEmpty) { - val top = queue.pop() - result += top - - for(outEdge <- graph.outEdges(top)) { - val target = graph.target(outEdge) - degrees.get(target) match { - case None => throw new LogicError("Unknown vertex in topological sort") - case Some(degree) => { - val newDegree = degree-1 - degrees += (target -> newDegree) - if (newDegree == 0) queue += target - if (newDegree < 0) throw new LogicError("Degree of vertex dropped below zero in topological sort.") - } - } - } - } - - if (degrees.values.filter(x => x>0).nonEmpty) throw new LogicError("Cycle in graph.") - result.toSeq - } - - def topoSort(graph: DirectedGraph) : Seq[DirectedGraph#Vertex] = - topoSort(graph, new StackQueue[DirectedGraph#Vertex]()) - - def topoSort(graph: DirectedGraph, priority: DirectedGraph#Vertex => Int) : Seq[DirectedGraph#Vertex] = - topoSort(graph, new PriorityQueue[DirectedGraph#Vertex](priority)) -} - -class DirectedGraph extends GraphBase { - protected def canonicalEdge(e: Edge) = e - - def inEdges(v: Vertex) = { - val info = getInfo(v) - info.in.map(x => (x, v)) - } - - def outEdges(v: Vertex) = { - val info = getInfo(v) - info.out.map(x => (v, x)) - } - - def inDegree(v: Vertex) = { - val info = getInfo(v) - info.in.size - } - - def outDegree(v: Vertex) = { - val info = getInfo(v) - info.out.size - } -} diff --git a/old/ofc/util/Graph.scala b/old/ofc/util/Graph.scala deleted file mode 100644 index 7347dab..0000000 --- a/old/ofc/util/Graph.scala +++ /dev/null @@ -1,41 +0,0 @@ -package ofc.util - -trait Graph { - type Vertex - type Edge - def nullVertex : Vertex -} - -trait IncidenceGraph extends Graph { - def source(e: Edge) : Vertex - def target(e: Edge) : Vertex - def outEdges(v: Vertex) : Traversable[Edge] - def outDegree(v: Vertex) : Int -} - -trait BidirectionalGraph extends IncidenceGraph { - def inEdges(v: Vertex) : Traversable[Edge] - def inDegree(v: Vertex) : Int - def degree(v: Vertex) : Int -} - -trait VertexListGraph extends Graph { - def vertices : Traversable[Vertex] - def numVertices: Int -} - -trait EdgeListGraph extends Graph { - def edges : Traversable[Edge] - def numEdges : Int -} - -trait AdjacencyMatrix extends Graph { - def hasEdge(u: Vertex, v: Vertex) : Boolean -} - -trait MutableGraph extends Graph { - def addVertex() : Vertex - def removeVertex(v: Vertex) : Unit - def addEdge(u: Vertex, v: Vertex) : Edge - def removeEdge(e: Edge) : Unit -} diff --git a/old/ofc/util/GraphBase.scala b/old/ofc/util/GraphBase.scala deleted file mode 100644 index b17fd73..0000000 --- a/old/ofc/util/GraphBase.scala +++ /dev/null @@ -1,73 +0,0 @@ -package ofc.util -import ofc.LogicError - -abstract class GraphBase extends BidirectionalGraph with VertexListGraph with EdgeListGraph with AdjacencyMatrix with MutableGraph { - import scala.collection.mutable - - type Vertex = Int - type Edge = (Vertex, Vertex) - - case class VertexInfo(var in: Set[Vertex], var out: Set[Vertex]) { - def this() = this(Set.empty, Set.empty) - } - - val nullVertex = 0 - private var lastVertex = nullVertex - private val vertexMap = collection.mutable.Map[Vertex, VertexInfo]() - - protected def getInfo(v: Vertex) : VertexInfo = { - vertexMap.get(v) match { - case Some(vertexInfo) => vertexInfo - case _ => throw new LogicError("Cannot find vertex "+v+" in graph.") - } - } - - protected def canonicalEdge(e: Edge) : Edge - - def source(e: Edge) = e._1 - def target(e: Edge) = e._2 - - def vertices = vertexMap.keys - def numVertices = vertexMap.size - - def degree(v: Vertex) = { - val info = getInfo(v) - info.in.size + info.out.size - } - - def addVertex = { - lastVertex += 1 - vertexMap += (lastVertex -> new VertexInfo) - lastVertex - } - - def addEdge(u: Vertex, v: Vertex) = { - val canonical = canonicalEdge(u -> v) - getInfo(source(canonical)).out += target(canonical) - getInfo(target(canonical)).in += source(canonical) - u -> v - } - - def removeEdge(e: Edge) { - val canonical = canonicalEdge(e) - getInfo(source(e)).out -= target(e) - getInfo(target(e)).in -= source(e) - } - - def hasEdge(u: Vertex, v: Vertex) = { - val canonical = canonicalEdge(u -> v) - val info = getInfo(source(canonical)) - info.out.contains(target(canonical)) - } - - def removeVertex(v: Vertex) = { - val info = getInfo(v) - for (in <- info.in) getInfo(in).out -= v - for (out <- info.out) getInfo(out).in -= v - vertexMap -= v - } - - def edges = for(fromInfo <- vertexMap; to <- fromInfo._2.out) yield (fromInfo._1, to) - - def numEdges = vertexMap.values.map(info => info.out.size).sum -} diff --git a/old/ofc/util/Ordering.scala b/old/ofc/util/Ordering.scala deleted file mode 100644 index 3bc1c09..0000000 --- a/old/ofc/util/Ordering.scala +++ /dev/null @@ -1,14 +0,0 @@ -package ofc.util - -object Ordering { - def transitiveClosure[T](nodes: Seq[T], hasPath: (T,T) => Boolean) : Set[(T,T)] = { - val ordering = scala.collection.mutable.Set[(T, T)]() - ordering ++= { for(n1 <- nodes; n2 <- nodes; if hasPath(n1, n2)) yield (n1 -> n2) } - - for(via <- nodes; start <- nodes; end <- nodes) - if (!ordering.contains(start -> end) && ordering.contains(start -> via) && ordering.contains(via -> end)) - ordering += (start -> end) - - ordering.toSet - } -} diff --git a/old/ofc/util/Queue.scala b/old/ofc/util/Queue.scala deleted file mode 100644 index e93a608..0000000 --- a/old/ofc/util/Queue.scala +++ /dev/null @@ -1,61 +0,0 @@ -package ofc.util -import scala.collection.generic.Growable - -trait Queue[A] extends Growable[A] { - def pop() : A - def nonEmpty : Boolean -} - -class StackQueue[A] extends Queue[A] { - private var stack = List[A]() - - def nonEmpty = stack.nonEmpty - - def +=(e: A) = { - stack = (e :: stack) - this - } - - def pop() = { - val (head, tail) = (stack.head, stack.tail) - stack = tail - head - } - - def clear() { - stack = Nil - } -} - -// Nodes with smaller priorities are popped first -class PriorityQueue[A](priority: A => Int) extends Queue[A] { - // This class helps create an artificial total ordering by comparing - // unique integers if the compare function is non-total. This is - // probably unnecessary since priority queues permit duplicates. - private class UniqueOrdering(priority: A => Int) extends scala.math.Ordering[(A, Int)] { - def compare(x: (A, Int), y: (A, Int)) = { - val xPri = priority(x._1) - val yPri = priority(y._1) - val comparison = -xPri.compareTo(yPri) - - if (comparison != 0) - comparison - else - x._2.compareTo(y._2) - } - } - - var uniqueID = 0 - val queue = new scala.collection.mutable.PriorityQueue[(A, Int)]()(new UniqueOrdering(priority)) - - def nonEmpty = queue.nonEmpty - def pop() = queue.dequeue()._1 - def clear() = queue.clear() - - def +=(e: A) = { - queue += (e -> uniqueID) - uniqueID += 1 - this - } -} - diff --git a/old/ofc/util/UndirectedGraph.scala b/old/ofc/util/UndirectedGraph.scala deleted file mode 100644 index 80bd746..0000000 --- a/old/ofc/util/UndirectedGraph.scala +++ /dev/null @@ -1,16 +0,0 @@ -package ofc.util - -class UndirectedGraph extends GraphBase { - protected def canonicalEdge(e: Edge) = if (e._1 < e._2) e else (e._2, e._1) - - def inEdges(v: Vertex) = outEdges(v).map(_.swap) - - def outEdges(v: Vertex) = { - val info = getInfo(v) - (info.in.toSeq ++ info.out.toSeq).map(x => (v, x)) - } - - def inDegree(v: Vertex) = degree(v) - - def outDegree(v: Vertex) = degree(v) -} -- 2.47.3