Update

Author: Groupsun

.DS_Store

@@ -0,0 +1 @@
+from .dsl import *

Paper/.DS_Store

@@ -0,0 +1,80 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List
+
+from pyhcl.core._emit_context import EmitterContext
+from pyhcl.core._repr import Declare, Node
+from pyhcl.ir import low_ir
+
+
+@dataclass
+class CondBlock(Declare):
+    when: When = None
+    elsewhens: List[Elsewhen] = field(init=False, default_factory=list)
+    otherwise: Otherwise = field(init=False, default=None)
+
+    __canAcceptOtherwise: bool = field(init=False, default=True, repr=False)
+    __canAcceptElsewhen: bool = field(init=False, default=True, repr=False)
+
+    def withElsewhen(self, elifBlock):
+        self.elsewhens.append(elifBlock)
+        return self
+
+    def withOtherwise(self, elseBlock):
+        self.__canAcceptOtherwise = False
+        self.__canAcceptElsewhen = False
+        self.otherwise = elseBlock
+        return self
+
+    def canAcceptElsewhen(self):
+        return self.__canAcceptElsewhen
+
+    def canAcceptOtherwise(self):
+        return self.__canAcceptOtherwise
+
+    def mapToIR(self, ctx: EmitterContext):
+        def _mapToIRRec(cb: CondBlock):
+            cond = ctx.getRef(cb.when.cond)
+            [ctx.getRef(i) for i in cb.when.block]
+            conseq = low_ir.Block(ctx.getScopeStatements(cb.when.ownScope))
+            if len(cb.elsewhens) == 0:
+                if cb.otherwise is None:
+                    alt = low_ir.EmptyStmt()
+                else:
+                    [ctx.getRef(i) for i in cb.otherwise.block]
+                    alt = low_ir.Block(ctx.getScopeStatements(cb.otherwise.ownScope))
+                return low_ir.Conditionally(cond, conseq, alt)
+            else:
+                elif_ = cb.elsewhens[0]
+                a = When(elif_.cond, elif_.block)
+                a.ownScope = elif_.ownScope
+                ncb = CondBlock(a)
+                for i in cb.elsewhens[1:]:
+                    ncb.withElsewhen(i)
+                ncb.withOtherwise(cb.otherwise)
+                alt = _mapToIRRec(ncb)
+                return low_ir.Conditionally(cond, conseq, alt)
+
+        stmt = _mapToIRRec(self)
+        ctx.appendFinalStatement(stmt, self.scopeId)
+        return stmt
+
+
+@dataclass
+class When:
+    cond: Node
+    block: List[Node]
+    ownScope: int = field(init=False, repr=False, default=None)
+
+
+@dataclass
+class Elsewhen:
+    cond: Node
+    block: List[Node]
+    ownScope: int = field(init=False, repr=False, default=None)
+
+
+@dataclass
+class Otherwise:
+    block: List[Node]
+    ownScope: int = field(init=False, repr=False, default=None)

Paper/multi-level-execute-results/.DS_Store

@@ -0,0 +1,40 @@
+class DynamicContext:
+    _lst = []
+    _scopeId = [object()]
+    _delScope = []
+
+    @staticmethod
+    def push(stuff):
+        DynamicContext._lst.append(stuff)
+
+    @staticmethod
+    def pop():
+        res = DynamicContext._lst.pop()
+        return res
+
+    @staticmethod
+    def get():
+        res = DynamicContext._lst
+        DynamicContext._lst = []
+        return res
+
+    @staticmethod
+    def currentScope():
+        return id(DynamicContext._scopeId[-1])
+
+    @staticmethod
+    def createScope():
+        obj = object()
+        DynamicContext._scopeId.append(obj)
+        return id(obj)
+
+    @staticmethod
+    def deleteScope():
+        DynamicContext._delScope.append(DynamicContext._scopeId[-1])
+        DynamicContext._scopeId.pop()
+
+    @staticmethod
+    def clearScope():
+        DynamicContext._scopeId.clear()
+        DynamicContext._delScope.clear()
+        DynamicContext._scopeId.append(object())

Paper/multi-level-execute-results/PyHCL-Tester/PT-cocotb/.DS_Store

@@ -0,0 +1,114 @@
+from collections import deque
+from typing import Optional, Dict, Counter
+
+from pyhcl.core._dynamic_ctx import DynamicContext
+from pyhcl.ir import low_ir
+
+
+class EmitterContext:
+    def __init__(self, module: "Module",
+                 emittedModules: Dict[int, low_ir.DefModule],
+                 moduleNameCounter: Counter):
+
+        # generate the name
+        modClass = module.__class__
+        self._modClass = modClass
+        modName = modClass.__name__
+        c = moduleNameCounter[modName]
+        moduleNameCounter[modName] += 1
+        self.name = modName + (("_" + str(c)) if c > 0 else "")
+
+        # bunch of records
+        self._module = module
+        self._rawStatements = deque(modClass._statements)
+        self._rawNameTable = modClass._rawTable
+        self._emittedModules: Dict[int, low_ir.DefModule] = emittedModules
+        self._moduleNameCounter = moduleNameCounter
+
+        self._innerRef = {}
+
+        self._finalStatements = {}
+        self._finalPorts = []
+        self._nameIndex = -1
+
+    def prependRawStatement(self, statement):
+        self._rawStatements.appendleft(statement)
+
+    def appendFinalStatement(self, statement, scopeId):
+        if self._finalStatements.get(scopeId) is None:
+            self._finalStatements[scopeId] = []
+
+        self._finalStatements[scopeId].append(statement)
+
+    def getScopeStatements(self, scopeId):
+        res = self._finalStatements[scopeId]
+        return res
+
+    def appendFinalPort(self, port):
+        self._finalPorts.append(port)
+
+    def updateRef(self, obj, ref):
+        self._innerRef[id(obj)] = ref
+
+    def getRef(self, obj) -> Optional:
+        from pyhcl.core._meta_pub import Pub
+        if isinstance(obj, Pub):
+            obj = obj.value
+        r = self._innerRef.get(id(obj))
+        if r is not None:
+            return r
+        else:
+            ref = obj.mapToIR(self)
+            return ref
+
+    def emit(self) -> Dict[int, low_ir.DefModule]:
+        self._dealWithClockAndReset()
+        scopeId = DynamicContext.currentScope()
+
+        while len(self._rawStatements) > 0:
+            lf = self._rawStatements.popleft()
+            lf.mapToIR(self)
+
+        modBundle = self._mapToBundle(self._finalPorts)
+        finalMod = low_ir.Module(self.name,
+                                 self._finalPorts,
+                                 low_ir.Block(self.getScopeStatements(scopeId)),
+                                 modBundle)
+
+        self._emittedModules[id(self._modClass)] = finalMod
+
+        return self._emittedModules
+
+    def _dealWithClockAndReset(self):
+        c = self._modClass.clock.public()
+        r = self._modClass.reset.public()
+        c.mapToIR(self)
+        r.mapToIR(self)
+        self._finalStatements[c.scopeId] = []
+
+    def getName(self, obj):
+        res = self._rawNameTable.get(id(obj))
+        if res is not None:
+            return res
+        else:
+            self._nameIndex += 1
+            return "_T" + (("_" + str(self._nameIndex)) if self._nameIndex > 0 else "")
+
+    def extendNewEnv(self, module):
+        return EmitterContext(module, self._emittedModules, self._moduleNameCounter)
+
+    def _mapToBundle(self, finalPorts):
+        fs = []
+        for i in finalPorts:
+            if i.direction == low_ir.Input():
+                fs.append(low_ir.Field(i.name, low_ir.Flip(), i.typ))
+            else:
+                fs.append(low_ir.Field(i.name, low_ir.Default(), i.typ))
+
+        return low_ir.BundleType(fs)
+
+    def getClock(self):
+        return low_ir.Reference("clock", low_ir.ClockType())
+
+    def getReset(self):
+        return low_ir.Reference("reset", low_ir.UIntType(low_ir.IntWidth(1)))

Paper/multi-level-execute-results/Treadle/.DS_Store

@@ -0,0 +1,81 @@
+from pyhcl.core._utils import get_attr
+
+
+class BundleAccessor:
+    def provideBundle(self):
+        from pyhcl.dsl.bundle import Bundle
+        typ = get_attr(self, "typ")
+        if isinstance(typ, Bundle):
+            return True, typ
+        else:
+            return False, None
+
+    def getAttr(self, item):
+        return get_attr(self, item)
+
+    def __getattribute__(self, item):
+        res = get_attr(self, "getAttr")(item)
+        if res is not None:
+            return res
+
+        pred, bd = get_attr(self, "provideBundle")()
+
+        if pred:
+            from pyhcl.core._repr import SubField
+            sf: SubField = getattr(bd, item)
+            sf.ref = self
+            return sf
+        else:
+            return None
+
+
+class VecOps:
+    def provideVector(self):
+        from pyhcl.dsl.vector import Vec
+        if isinstance(self.typ, Vec):
+            return True, self.typ
+        else:
+            return False, None
+
+    def size(self):
+        isVec, typ = get_attr(self, "provideVector")()
+        if isVec:
+            return typ.size
+        else:
+            raise Exception(f"${self} is not vector type")
+
+    def length(self):
+        return self.size()
+
+    def reverse(self):
+        from pyhcl.core._repr import ReverseView
+        isVec, typ = get_attr(self, "provideVector")()
+        if isVec:
+            return ReverseView(self, typ)
+        else:
+            raise Exception(f"${self} is not vector type")
+
+    def flatten(self):
+        from pyhcl.dsl.vector import Vec
+        from pyhcl.core._repr import FlattenView
+        isVec, typ = get_attr(self, "provideVector")()
+        if isVec:
+            l0v = typ
+            l1v = typ.typ
+            vt = Vec(l0v.size * l1v.size, l1v.typ)
+            return FlattenView(self, vt, l0v.size, l1v.size)
+        else:
+            raise Exception(f"${self} is not vector type")
+
+    def __iter__(self):
+        isVec, typ = get_attr(self, "provideVector")()
+        if isVec:
+            return iter([self[i] for i in range(typ.size)])
+
+        raise Exception(f"${self} is not vector type")
+
+    def __len__(self):
+        return self.size()
+
+    def __reversed__(self):
+        return self.reverse()

Paper/multi-level-execute-results/Treadle/PT-Treadle/.DS_Store

@@ -0,0 +1,44 @@
+from pyhcl.core._repr import Node
+from pyhcl.core._utils import get_attr, has_attr
+
+
+class Pub(Node):
+    """
+    A Tag Class For Showing The Visibility Of Module's Fields
+    """
+
+    def __init__(self, value):
+        self.value = value
+        self.typ = value.typ
+
+    def __repr__(self):
+        value = get_attr(self, "value")
+        return "Pub(" + str(value) + ")"
+
+    def __getattribute__(self, item):
+        if has_attr(self, item):
+            return get_attr(self, item)
+        else:
+            return getattr(self.public(), item)
+
+    def extractForName(self):
+        return get_attr(self, "value")
+
+    def public(self):
+        return get_attr(self, "value")
+
+    def mapToIR(self, ctx):
+        return self.value.mapToIR(ctx)
+
+
+class MetaPub(type):
+    def __call__(cls, *args, **kwargs):
+        # unwrap
+        func = lambda x: get_attr(x, 'value') if isinstance(x, Pub) else x
+
+        nArgs = [func(i) for i in args]
+        nKwargs = {k: func(v) for k, v in kwargs.items()}
+        obj = type.__call__(cls, *nArgs, **nKwargs)
+
+        # rewrap
+        return Pub(obj)