abstract class Base extends AnyRef
The Base trait houses common AST nodes. It also manages a list of encountered definitions which allows for common sub-expression elimination (CSE).
- Self Type
- Scalan
- Alphabetic
- By Inheritance
- Base
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new Base()
Type Members
- abstract class BaseDef[+T] extends Scalan.Node with Scalan.Def[T]
Base class for most predefined operations.
- abstract class CompanionDef[T] extends Scalan.Node with Scalan.Def[T]
Base class for virtualized instances of type companions.
Base class for virtualized instances of type companions. Each virtualized entity type (trait or class) may have virtualized companion class.
- case class Const[T](x: T)(implicit eT: Scalan.Elem[T]) extends Scalan.BaseDef[T] with Product with Serializable
Default node type for embedding of literal values to graph IR.
Default node type for embedding of literal values to graph IR. This can be used or those types
T
whenElem[T]
is defined, butLiftable[_,T]
is not, i.e. for non-liftable types.- x
literal value
- eT
type descriptor of IR type T
- trait Def[+T] extends Scalan.Node
Base type for all graph nodes (aka computable value definitions).
Base type for all graph nodes (aka computable value definitions). Each graph node or definition represent one operation node of the data flow graph.
- class EntityObject extends AnyRef
Base class for all objects generated for virtualized types to support staged evaluation machinery.
Base class for all objects generated for virtualized types to support staged evaluation machinery. Each object contains definitions which can be imported when necessary. All that objects are registered in
entityObjects
hash map, which is done while IR cake is constructed. - case class EntityObjectOwner(obj: Scalan.EntityObject) extends Scalan.OwnerKind with Product with Serializable
- abstract class Node extends Product
Base class for all IR nodes/operations/definitions.
- class NotImplementedStagingException extends Scalan.StagingException
- sealed abstract class OwnerKind extends AnyRef
Variants of
owner
parameter of constructors of nested classes: 1) predefined node classes are owned by IR cake (ScalanOwner) 2) entity classes are owned by enclosing EntityObject - case class Placeholder[T](eT: Scalan.LElem[T]) extends Scalan.Node with Scalan.Def[T] with Product with Serializable
Symbols may temporary refer to this node until their target node is updated.
- type RFunc[-A, +B] = Scalan.Ref[(A) => B]
- type RPair[+A, +B] = Scalan.Ref[(A, B)]
- abstract class Ref[+T] extends AnyRef
Abstract representation of a computable value.
Abstract representation of a computable value. Default implementation is a simple lightweight reference to the corresponding definition. Every Ref have direct access to its Def via
node
property. Every Ref is typed, and the type is avaliable viaelem
property.- See also
SingleRep
- final class SingleRef[+T] extends Scalan.Ref[T]
A Ref is a symbolic reference used internally to refer to graph nodes.
A Ref is a symbolic reference used internally to refer to graph nodes. Light weight stateless immutable reference to a graph node (Def[T]). Two symbols are equal if they refer to the nodes with the same id, which is due to Def unification means equal symbols refer to the same instance of Def.
- class StagingException extends RuntimeException
- type Sym = Scalan.Ref[_]
Untyped shortcut sinonim of Ref, which is used as untyped reference to graph nodes (definitions).
Untyped shortcut sinonim of Ref, which is used as untyped reference to graph nodes (definitions). Following a tradition in compiler engineering we call references to definitions as symbols.
- abstract class Transformer extends AnyRef
Base class for Ref to Ref transformations.
Base class for Ref to Ref transformations. Each transformer keeps a mapping data between references to original nodes and references to the corresponding transformed nodes.
- case class Variable[T](varId: Int)(implicit eT: Scalan.LElem[T]) extends Scalan.Node with Scalan.Def[T] with Product with Serializable
Node class for typed variables.
Node class for typed variables. In particular for lambda-bound variables.
- varId
is independent from nodeId, shouldn't be used as node id.
- eT
type descriptor of the variable type
- type |[+A, +B] = Either[A, B]
Value Members
- def !!!(msg: String, e: Throwable, syms: Scalan.Ref[_]*): Nothing
- def !!!(msg: String, syms: Scalan.Ref[_]*): Nothing
- def !!!: Nothing
Helper methods to throw errors
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def ???(value: Any, syms: Scalan.Ref[_]*): Nothing
- def ???: Nothing
- val EmptyArrayOfSym: Array[Scalan.Sym]
Immutable empty array of symbols, can be used to avoid unnecessary allocations.
- val EmptyDSetOfInt: Set[Int]
Used internally in IR and should be used with care since it is mutable.
Used internally in IR and should be used with care since it is mutable. At the same time, it is used in the hotspot and allows to avoid roughly tens of thousands of allocations per second. WARNING: Mutations of this instance can lead to undefined behavior.
- Attributes
- protected
- val EmptySeqOfSym: Seq[Scalan.Sym]
Immutable empty Seq, can be used to avoid unnecessary allocations.
- final def IntZero: Scalan.Ref[Int]
Zero literal node, which is lazily created and can be efficiently reused.
Zero literal node, which is lazily created and can be efficiently reused. Much faster alternative to
(0: Rep[Int])
ortoRep(0)
.- Annotations
- @inline()
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- final def asRep[T](x: Scalan.Ref[_]): Scalan.Ref[T]
Helper to type cast node references.
Helper to type cast node references.
- Annotations
- @inline()
- val cacheElems: Boolean
Whether IR type descriptors should be cached.
- val cachePairs: Boolean
Whether Tup instances should be cached.
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def createDefinition[T](optScope: Nullable[Scalan.ThunkScope], s: Scalan.Ref[T], d: Scalan.Def[T]): Scalan.Ref[T]
Create new definition entry in either given Thunk or in the global hash table.
Create new definition entry in either given Thunk or in the global hash table.
- optScope
optional thunk scope to put given definition
- s
symbol refering to
d
- d
definition node to add to the scope of globally
- returns
reference to
d
(which iss
)
- Attributes
- protected
- val debugModeSanityChecks: Boolean
Whether to perform extended checks of correctness, expected invariants and data consistency.
Whether to perform extended checks of correctness, expected invariants and data consistency. NOTE: Since it may add substantial overhead, set it to
false
before using in production. - def defCount: Int
Returns a number of definitions added to this IR context.
- def def_unapply[T](e: Scalan.Ref[T]): Nullable[Scalan.Def[T]]
- final def emptyDBufferOfSym: Buffer[Scalan.Sym]
Create a new empty buffer around pre-allocated empty array.
Create a new empty buffer around pre-allocated empty array. This method is preferred, rather that creating empty debox.Buffer directly because it allows to avoid allocation of the empty array.
- Annotations
- @inline()
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def findGlobalDefinition[T](d: Scalan.Def[T]): Scalan.Ref[T]
Lookup definition in this IR context's hash table of definitions.
Lookup definition in this IR context's hash table of definitions.
- returns
node reference to an instance stored in hash table, which is equal to
d
and null if there is no definition which is equal tod
- def findOrCreateDefinition[T](d: Scalan.Def[T], newSym: => Scalan.Ref[T]): Scalan.Ref[T]
Lookup
d
in the heap of nodes.Lookup
d
in the heap of nodes. If the lookup is successfull, then its reference is returned. If the node is not found in the heap, then it is added andd.self
reference is returned.- d
node to be added to the head of nodes
- newSym
producer of the reference to be used as the reference to
d
node.- returns
return a reference to
d
node in the heap HOTSPOT:
- final def freshId: Int
Get next fresh node id
Get next fresh node id
- Annotations
- @inline()
- final def freshSym[T](d: Scalan.Def[T]): Scalan.Ref[T]
Lookup of create reference to the given definition.
Lookup of create reference to the given definition. To lookup
d.nodeId
is used as the index in the_symbolTable
. If Ref is not found in_symbolTable
, then new Ref instance is created and stored in_symbolTable
atd.nodeId
index.- Annotations
- @inline()
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getEntityObject(name: String): Nullable[Scalan.EntityObject]
- Annotations
- @inline()
- def getOwnerKind(constructor: RConstructor[_]): Scalan.OwnerKind
Returns OwnerKind for the given constructor, using its first parameter.
Returns OwnerKind for the given constructor, using its first parameter.
- Attributes
- protected
- final def getSym(id: Int): Scalan.Sym
Lookup node reference by its id.
Lookup node reference by its id. This is simple array access by index O(1) operation.
- Annotations
- @inline()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- implicit def liftToRep[A](x: A)(implicit arg0: Scalan.Elem[A]): Scalan.Ref[A]
- Annotations
- @inline()
- def logWarn(msg: => String): Unit
Log warning message to the log.
Log warning message to the log. This is default and simple implementation, which can be overriden.
- val nInitialDefs: Int
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def onReset(): Unit
Called during resetContext() operation after the core context state has been reset.
Called during resetContext() operation after the core context state has been reset. Derived classes can override to define application specific initialization. Don't forget to call super method in the beginning of your overriding method.
- Attributes
- protected
- def placeholder[T](implicit eT: Scalan.LElem[T]): Scalan.Ref[T]
- Annotations
- @inline()
- def registerEntityObject(name: String, obj: Scalan.EntityObject): Unit
- Attributes
- protected
- implicit def reifyObject[A](obj: Scalan.Def[A]): Scalan.Ref[A]
Implicit injection of new definition (graph node) into universum of nodes with collapsing semantics.
Implicit injection of new definition (graph node) into universum of nodes with collapsing semantics. If there exists node
n
in this IR such thatobj equals n
, then the value ofn.self
is returned, i.e. the new nodeobj
is collapsed with already existing one. This has an effect of Common Subexpression Elimination (CSE) when an expression tree is transformed to the graph and identical subtrees are collapsed. After a reference to the node is obtained, global rewriting rules are examined and the reference may be replaced with a new one. - def resetContext(): Unit
- def stagingExceptionMessage(message: String, syms: Seq[Scalan.Ref[_]]): String
Prettyprint exception message
Prettyprint exception message
- Attributes
- protected
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toExp[T](d: Scalan.Def[T], newSym: => Scalan.Ref[T]): Scalan.Ref[T]
Updates the universe of symbols and definitions, then rewrites until fix-point
Updates the universe of symbols and definitions, then rewrites until fix-point
- d
A new graph node to add to the universe
- newSym
A symbol that will be used if d doesn't exist in the universe
- returns
The symbol of the graph which is semantically(up to rewrites) equivalent to d
- Attributes
- protected[scalan]
- def toRep[A](x: A)(implicit eA: Scalan.Elem[A]): Scalan.Ref[A]
Lifting of data values to IR nodes.
- def toString(): String
- Definition Classes
- AnyRef → Any
- def transformProductParam(x: Any, t: Scalan.Transformer): Any
Transforms this object into new one by applying
t
to every Ref inside its structure.Transforms this object into new one by applying
t
to every Ref inside its structure. The structure is build out of Seq, Array, Option and Def values. Other structure items remain unchanged and copied to the new instance. HOTSPOT: don't beautify the code- Attributes
- protected
- final def updateSymbolTable[T](s: Scalan.Ref[T], d: Scalan.Def[T]): Scalan.Ref[T]
Create or find symbol (node Ref) which refers to the given node in the table of all created symbols.
Create or find symbol (node Ref) which refers to the given node in the table of all created symbols. The d.nodeId is the index in the _symbolTable which is DBuffer (backed by Array)
- returns
new of existing symbol HOTSPOT: the method should be allocation-free (make it sure by examining the generated Java code)
- final def valueFromRep[A](x: Scalan.Ref[A]): A
Extract data value from Const node or throw an exception.
Extract data value from Const node or throw an exception.
- Annotations
- @inline()
- def variable[T](implicit eT: Scalan.LElem[T]): Scalan.Ref[T]
- Annotations
- @inline()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- object &&
Logical AND between two pattern matches of the save value
x
.Logical AND between two pattern matches of the save value
x
. Can be used to construct patterns likecase P1 && P2 => ...
- object Def
- object ExpWithElem
- object Liftables
Data type
ST
is liftable is there is Liftable[ST, T] instance for some typeT
.Data type
ST
is liftable is there is Liftable[ST, T] instance for some typeT
. Liftable typeclass allows to define which types can have values embedded as literals into graph IR. - case object NoOwner extends Scalan.OwnerKind with Product with Serializable
- case object ScalanOwner extends Scalan.OwnerKind with Product with Serializable