INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
: return: True if two Value instances are same: note: not just equal | def isSameHVal(a: Value, b: Value) -> bool:
"""
:return: True if two Value instances are same
:note: not just equal
"""
return a is b or (isinstance(a, Value)
and isinstance(b, Value)
and a.val == b.val
and a.vldMask == b.vldMask) |
: return: True if two vectors of Value instances are same: note: not just equal | def areSameHVals(a: Union[None, List[Value]],
b: Union[None, List[Value]]) -> bool:
"""
:return: True if two vectors of Value instances are same
:note: not just equal
"""
if a is b:
return True
if a is None or b is None:
return False
if len(a) == len(b):
... |
: return: True if two lists of HdlStatement instances are same | def isSameStatementList(stmListA: List[HdlStatement],
stmListB: List[HdlStatement]) -> bool:
"""
:return: True if two lists of HdlStatement instances are same
"""
if stmListA is stmListB:
return True
if stmListA is None or stmListB is None:
return False
f... |
: return: True if all statements are same | def statementsAreSame(statements: List[HdlStatement]) -> bool:
"""
:return: True if all statements are same
"""
iterator = iter(statements)
try:
first = next(iterator)
except StopIteration:
return True
return all(first.isSame(rest) for rest in iterator) |
: return: first statement with rank > 0 or None if iterator empty | def _get_stm_with_branches(stm_it):
"""
:return: first statement with rank > 0 or None if iterator empty
"""
last = None
while last is None or last.rank == 0:
try:
last = next(stm_it)
except StopIteration:
last = None
break
return last |
Clean informations about enclosure for outputs and sensitivity of this statement | def _clean_signal_meta(self):
"""
Clean informations about enclosure for outputs and sensitivity
of this statement
"""
self._enclosed_for = None
self._sensitivity = None
for stm in self._iter_stms():
stm._clean_signal_meta() |
Collect inputs/ outputs from all child statements to: py: attr: ~_input/: py: attr: _output attribure on this object | def _collect_io(self) -> None:
"""
Collect inputs/outputs from all child statements
to :py:attr:`~_input` / :py:attr:`_output` attribure on this object
"""
in_add = self._inputs.extend
out_add = self._outputs.extend
for stm in self._iter_stms():
in_ad... |
Discover enclosure for list of statements | def _discover_enclosure_for_statements(statements: List['HdlStatement'],
outputs: List['HdlStatement']):
"""
Discover enclosure for list of statements
:param statements: list of statements in one code branch
:param outputs: list of outputs whic... |
Discover sensitivity for list of signals | def _discover_sensitivity_seq(self,
signals: List[RtlSignalBase],
seen: set, ctx: SensitivityCtx)\
-> None:
"""
Discover sensitivity for list of signals
"""
casualSensitivity = set()
for s in signals... |
get RtlNetlist context from signals | def _get_rtl_context(self):
"""
get RtlNetlist context from signals
"""
for sig in chain(self._inputs, self._outputs):
if sig.ctx:
return sig.ctx
else:
# Param instances does not have context
continue
raise H... |
Update signal IO after reuce atempt | def _on_reduce(self, self_reduced: bool, io_changed: bool,
result_statements: List["HdlStatement"]) -> None:
"""
Update signal IO after reuce atempt
:param self_reduced: if True this object was reduced
:param io_changed: if True IO of this object may changed
... |
After merging statements update IO sensitivity and context | def _on_merge(self, other):
"""
After merging statements update IO, sensitivity and context
:attention: rank is not updated
"""
self._inputs.extend(other._inputs)
self._outputs.extend(other._outputs)
if self._sensitivity is not None:
self._sensitivit... |
Walk statements and compare if they can be merged into one statement list | def _is_mergable_statement_list(cls, stmsA, stmsB):
"""
Walk statements and compare if they can be merged into one statement list
"""
if stmsA is None and stmsB is None:
return True
elif stmsA is None or stmsB is None:
return False
a_it = iter(st... |
Merge statements in list to remove duplicated if - then - else trees | def _merge_statements(statements: List["HdlStatement"])\
-> Tuple[List["HdlStatement"], int]:
"""
Merge statements in list to remove duplicated if-then-else trees
:return: tuple (list of merged statements, rank decrease due merging)
:note: rank decrease is sum of ranks of re... |
Merge two lists of statements into one | def _merge_statement_lists(stmsA: List["HdlStatement"], stmsB: List["HdlStatement"])\
-> List["HdlStatement"]:
"""
Merge two lists of statements into one
:return: list of merged statements
"""
if stmsA is None and stmsB is None:
return None
tmp =... |
Simplify statements in the list | def _try_reduce_list(statements: List["HdlStatement"]):
"""
Simplify statements in the list
"""
io_change = False
new_statements = []
for stm in statements:
reduced, _io_change = stm._try_reduce()
new_statements.extend(reduced)
io_chan... |
After parrent statement become event dependent propagate event dependency flag to child statements | def _on_parent_event_dependent(self):
"""
After parrent statement become event dependent
propagate event dependency flag to child statements
"""
if not self._is_completly_event_dependent:
self._is_completly_event_dependent = True
for stm in self._iter_stms... |
Assign parent statement and propagate dependency flags if necessary | def _set_parent_stm(self, parentStm: "HdlStatement"):
"""
Assign parent statement and propagate dependency flags if necessary
"""
was_top = self.parentStm is None
self.parentStm = parentStm
if not self._now_is_event_dependent\
and parentStm._now_is_event_d... |
Append statements to this container under conditions specified by condSet | def _register_stements(self, statements: List["HdlStatement"],
target: List["HdlStatement"]):
"""
Append statements to this container under conditions specified
by condSet
"""
for stm in flatten(statements):
assert stm.parentStm is None, stm... |
Disconnect this statement from signals and delete it from RtlNetlist context | def _destroy(self):
"""
Disconnect this statement from signals and delete it from RtlNetlist context
:attention: signal endpoints/drivers will be altered
that means they can not be used for iteration
"""
ctx = self._get_rtl_context()
for i in self._inputs:
... |
: param val: python string or None: param typeObj: instance of String HdlType: param vldMask: if is None validity is resolved from val if is 0 value is invalidated if is 1 value has to be valid | def fromPy(cls, val, typeObj, vldMask=None):
"""
:param val: python string or None
:param typeObj: instance of String HdlType
:param vldMask: if is None validity is resolved from val
if is 0 value is invalidated
if is 1 value has to be valid
"""
as... |
Create register in this unit | def _reg(self, name, dtype=BIT, defVal=None, clk=None, rst=None):
"""
Create register in this unit
:param defVal: default value of this register,
if this value is specified reset of this component is used
(unit has to have single interface of class Rst or Rst_n)
... |
Create signal in this unit | def _sig(self, name, dtype=BIT, defVal=None):
"""
Create signal in this unit
"""
if isinstance(dtype, HStruct):
if defVal is not None:
raise NotImplementedError()
container = dtype.fromPy(None)
for f in dtype.fields:
if ... |
Disconnect internal signals so unit can be reused by parent unit | def _cleanAsSubunit(self):
"""Disconnect internal signals so unit can be reused by parent unit"""
for pi in self._entity.ports:
pi.connectInternSig()
for i in chain(self._interfaces, self._private_interfaces):
i._clean() |
Select fields from structure ( rest will become spacing ) | def HStruct_selectFields(structT, fieldsToUse):
"""
Select fields from structure (rest will become spacing)
:param structT: HStruct type instance
:param fieldsToUse: dict {name:{...}} or set of names to select,
dictionary is used to select nested fields
in HStruct or HUnion fields
... |
Walk all simple values in HStruct or HArray | def walkFlattenFields(sigOrVal, skipPadding=True):
"""
Walk all simple values in HStruct or HArray
"""
t = sigOrVal._dtype
if isinstance(t, Bits):
yield sigOrVal
elif isinstance(t, HUnion):
yield from walkFlattenFields(sigOrVal._val, skipPadding=skipPadding)
elif isinstance(t... |
opposite of packAxiSFrame | def HStruct_unpack(structT, data, getDataFn=None, dataWidth=None):
"""
opposite of packAxiSFrame
"""
if getDataFn is None:
assert dataWidth is not None
def _getDataFn(x):
return toHVal(x)._auto_cast(Bits(dataWidth))
getDataFn = _getDataFn
val = structT.fromPy(N... |
Convert signum no bit manipulation just data are represented differently | def _convSign(self, signed):
"""
Convert signum, no bit manipulation just data are represented
differently
:param signed: if True value will be signed,
if False value will be unsigned,
if None value will be vector without any sign specification
"""
... |
Construct value from pythonic value ( int bytes enum. Enum member ) | def fromPy(cls, val, typeObj, vldMask=None):
"""
Construct value from pythonic value (int, bytes, enum.Enum member)
"""
assert not isinstance(val, Value)
if val is None:
vld = 0
val = 0
assert vldMask is None or vldMask == 0
else:
... |
Concatenate this with other to one wider value/ signal | def _concat(self, other):
"""
Concatenate this with other to one wider value/signal
"""
w = self._dtype.bit_length()
try:
other_bit_length = other._dtype.bit_length
except AttributeError:
raise TypeError("Can not concat bits and", other._dtype)
... |
register sensitivity for process | def sensitivity(proc: HWProcess, *sensitiveTo):
"""
register sensitivity for process
"""
for s in sensitiveTo:
if isinstance(s, tuple):
sen, s = s
if sen == SENSITIVITY.ANY:
s.simSensProcs.add(proc)
elif sen == SENSITIVITY.RISING:
... |
Evaluate list of values as condition | def simEvalCond(simulator, *conds):
"""
Evaluate list of values as condition
"""
_cond = True
_vld = True
for v in conds:
val = bool(v.val)
fullVld = v.vldMask == 1
if fullVld:
if not val:
return False, True
else:
return Fal... |
Connect ports of simulation models by name | def connectSimPort(simUnit, subSimUnit, srcName, dstName, direction):
"""
Connect ports of simulation models by name
"""
if direction == DIRECTION.OUT:
origPort = getattr(subSimUnit, srcName)
newPort = getattr(simUnit, dstName)
setattr(subSimUnit, srcName, newPort)
else:
... |
Create value updater for simulation | def mkUpdater(nextVal: Value, invalidate: bool):
"""
Create value updater for simulation
:param nextVal: instance of Value which will be asssiggned to signal
:param invalidate: flag which tells if value has been compromised
and if it should be invaidated
:return: function(value) -> tuple(va... |
Create value updater for simulation for value of array type | def mkArrayUpdater(nextItemVal: Value, indexes: Tuple[Value],
invalidate: bool):
"""
Create value updater for simulation for value of array type
:param nextVal: instance of Value which will be asssiggned to signal
:param indexes: tuple on indexes where value should be updated
... |
: param val: None or dictionary { index: value } or iterrable of values: param vldMask: if is None validity is resolved from val if is 0 value is invalidated if is 1 value has to be valid | def fromPy(cls, val, typeObj, vldMask=None):
"""
:param val: None or dictionary {index:value} or iterrable of values
:param vldMask: if is None validity is resolved from val
if is 0 value is invalidated
if is 1 value has to be valid
"""
size = evalParam(ty... |
: atention: this will clone item from array iterate over. val if you need to modify items | def _getitem__val(self, key):
"""
:atention: this will clone item from array, iterate over .val
if you need to modify items
"""
try:
kv = key.val
if not key._isFullVld():
raise KeyError()
else:
if kv >= self.... |
create hdl vector value | def vec(val, width, signed=None):
"""create hdl vector value"""
return Bits(width, signed, forceVector=True).fromPy(val) |
Collect data from interface | def monitor(self, sim):
"""
Collect data from interface
"""
r = sim.read
if self.notReset(sim):
# update rd signal only if required
if self._lastRd is not 1:
self.wrRd(sim.write, 1)
self._lastRd = 1
# try to... |
Push data to interface | def driver(self, sim):
"""
Push data to interface
set vld high and wait on rd in high then pass new data
"""
r = sim.read
# pop new data if there are not any pending
if self.actualData is NOP and self.data:
self.actualData = self.data.popleft()
... |
Gues resource usage by HWProcess | def HWProcess(cls, proc: HWProcess, ctx: ResourceContext) -> None:
"""
Gues resource usage by HWProcess
"""
seen = ctx.seen
for stm in proc.statements:
encl = stm._enclosed_for
full_ev_dep = stm._is_completly_event_dependent
now_ev_dep = stm._n... |
: return: bit width for this type | def bit_length(self):
"""
:return: bit width for this type
"""
try:
itemSize = self.elmType.bit_length
except AttributeError:
itemSize = None
if itemSize is None:
raise TypeError(
"Can not determine size of array because... |
Get value of parameter | def evalParam(p):
"""
Get value of parameter
"""
while isinstance(p, Param):
p = p.get()
if isinstance(p, RtlSignalBase):
return p.staticEval()
# use rather param inheritance instead of param as param value
return toHVal(p) |
set value of this param | def set(self, val):
"""
set value of this param
"""
assert not self.__isReadOnly, \
("This parameter(%s) was locked"
" and now it can not be changed" % self.name)
assert self.replacedWith is None, \
("This param was replaced with new one and t... |
Generate flattened register map for HStruct | def HTypeFromIntfMap(interfaceMap):
"""
Generate flattened register map for HStruct
:param interfaceMap: sequence of
tuple (type, name) or (will create standard struct field member)
interface or (will create a struct field from interface)
instance of hdl type (is used as padding)
... |
mux record is in format ( self. MUX n m ) where n is number of bits of this mux and m is number of possible inputs | def registerMUX(self, stm: Union[HdlStatement, Operator], sig: RtlSignal,
inputs_cnt: int):
"""
mux record is in format (self.MUX, n, m)
where n is number of bits of this mux
and m is number of possible inputs
"""
assert inputs_cnt > 1
res = se... |
Resolve ports of discovered memories | def finalize(self):
"""
Resolve ports of discovered memories
"""
ff_to_remove = 0
res = self.resources
for m, addrDict in self.memories.items():
rwSyncPorts, rSyncPorts, wSyncPorts = 0, 0, 0
rwAsyncPorts, rAsyncPorts, wAsyncPorts = 0, 0, 0
... |
Try lookup operator with this parameters in _usedOps if not found create new one and soter it in _usedOps | def naryOp(self, operator, opCreateDelegate, *otherOps) -> RtlSignalBase:
"""
Try lookup operator with this parameters in _usedOps
if not found create new one and soter it in _usedOps
:param operator: instance of OpDefinition
:param opCreateDelegate: function (*ops) to create op... |
__eq__ is not overloaded because it will destroy hashability of object | def _eq(self, other):
"""
__eq__ is not overloaded because it will destroy hashability of object
"""
return self.naryOp(AllOps.EQ, tv(self)._eq, other) |
Find out if this signal is something indexed | def _getIndexCascade(self):
"""
Find out if this signal is something indexed
"""
try:
# now I am result of the index xxx[xx] <= source
# get index op
d = self.singleDriver()
try:
op = d.operator
except Attribute... |
Construct value of this type. Delegated on value class for this type | def fromPy(self, v, vldMask=None):
"""
Construct value of this type.
Delegated on value class for this type
"""
return self.getValueCls().fromPy(v, self, vldMask=vldMask) |
Cast value or signal of this type to another compatible type. | def auto_cast(self, sigOrVal, toType):
"""
Cast value or signal of this type to another compatible type.
:param sigOrVal: instance of signal or value to cast
:param toType: instance of HdlType to cast into
"""
if sigOrVal._dtype == toType:
return sigOrVal
... |
Cast value or signal of this type to another type of same size. | def reinterpret_cast(self, sigOrVal, toType):
"""
Cast value or signal of this type to another type of same size.
:param sigOrVal: instance of signal or value to cast
:param toType: instance of HdlType to cast into
"""
try:
return self.auto_cast(sigOrVal, toT... |
walk parameter instances on this interface | def walkParams(intf, discovered):
"""
walk parameter instances on this interface
"""
for si in intf._interfaces:
yield from walkParams(si, discovered)
for p in intf._params:
if p not in discovered:
discovered.add(p)
yield p |
Connect 1D vector signal to this structuralized interface | def connectPacked(srcPacked, dstInterface, exclude=None):
"""
Connect 1D vector signal to this structuralized interface
:param packedSrc: vector which should be connected
:param dstInterface: structuralized interface where should
packedSrc be connected to
:param exclude: sub interfaces of s... |
: param shouldEnterIntfFn: function ( actual interface ) returns tuple ( shouldEnter shouldYield ) | def walkFlatten(interface, shouldEnterIntfFn):
"""
:param shouldEnterIntfFn: function (actual interface)
returns tuple (shouldEnter, shouldYield)
"""
_shouldEnter, _shouldYield = shouldEnterIntfFn(interface)
if _shouldYield:
yield interface
if shouldEnterIntfFn:
for intf... |
Concatenate all signals to one big signal recursively | def packIntf(intf, masterDirEqTo=DIRECTION.OUT, exclude=None):
"""
Concatenate all signals to one big signal, recursively
:param masterDirEqTo: only signals with this direction are packed
:param exclude: sequence of signals/interfaces to exclude
"""
if not intf._interfaces:
if intf._mas... |
Due to verilog restrictions it is not posible to use array constants and rom memories has to be hardcoded as process | def hardcodeRomIntoProcess(cls, rom):
"""
Due to verilog restrictions it is not posible to use array constants
and rom memories has to be hardcoded as process
"""
processes = []
signals = []
for e in rom.endpoints:
assert isinstance(e, Operator) and e.... |
: return: list of extra discovered processes | def Architecture_var(cls, v, serializerVars, extraTypes,
extraTypes_serialized, ctx, childCtx):
"""
:return: list of extra discovered processes
"""
t = v._dtype
# if type requires extra definition
if isinstance(t, HArray) and v.defVal.vldMask:
... |
synthesize all subunits make connections between them build entity and component for this unit | def _toRtl(self, targetPlatform: DummyPlatform):
"""
synthesize all subunits, make connections between them,
build entity and component for this unit
"""
assert not self._wasSynthetised()
self._targetPlatform = targetPlatform
if not hasattr(self, "_name"):
... |
Load all declarations from _decl () method recursively for all interfaces/ units. | def _loadDeclarations(self):
"""
Load all declarations from _decl() method, recursively
for all interfaces/units.
"""
if not hasattr(self, "_interfaces"):
self._interfaces = []
if not hasattr(self, "_private_interfaces"):
self._private_interfaces =... |
Register interface in implementation phase | def _registerIntfInImpl(self, iName, intf):
"""
Register interface in implementation phase
"""
self._registerInterface(iName, intf, isPrivate=True)
self._loadInterface(intf, False)
intf._signalsForInterface(self._ctx) |
Reverse byteorder ( littleendian/ bigendian ) of signal or value | def reverseByteOrder(signalOrVal):
"""
Reverse byteorder (littleendian/bigendian) of signal or value
"""
w = signalOrVal._dtype.bit_length()
i = w
items = []
while i > 0:
# take last 8 bytes or rest
lower = max(i - 8, 0)
items.append(signalOrVal[i:lower])
i -... |
Return sig and val reduced by & operator or None if it is not possible to statically reduce expression | def tryReduceAnd(sig, val):
"""
Return sig and val reduced by & operator or None
if it is not possible to statically reduce expression
"""
m = sig._dtype.all_mask()
if val._isFullVld():
v = val.val
if v == m:
return sig
elif v == 0:
return val |
Return sig and val reduced by ^ operator or None if it is not possible to statically reduce expression | def tryReduceXor(sig, val):
"""
Return sig and val reduced by ^ operator or None
if it is not possible to statically reduce expression
"""
m = sig._dtype.all_mask()
if not val.vldMask:
return val
if val._isFullVld():
v = val.val
if v == m:
return ~sig
... |
Get root of name space | def getBaseNameScope(cls):
"""
Get root of name space
"""
s = NameScope(False)
s.setLevel(1)
s[0].update(cls._keywords_dict)
return s |
Convert object to HDL string | def asHdl(cls, obj, ctx: SerializerCtx):
"""
Convert object to HDL string
:param obj: object to serialize
:param ctx: SerializerCtx instance
"""
if isinstance(obj, RtlSignalBase):
return cls.SignalItem(obj, ctx)
elif isinstance(obj, Value):
... |
Entity is just forward declaration of Architecture it is not used in most HDL languages as there is no recursion in hierarchy | def Entity(cls, ent: Entity, ctx: SerializerCtx):
"""
Entity is just forward declaration of Architecture, it is not used
in most HDL languages as there is no recursion in hierarchy
"""
ent.name = ctx.scope.checkedName(ent.name, ent, isGlobal=True)
return "" |
Decide if this unit should be serialized or not eventually fix name to fit same already serialized unit | def serializationDecision(cls, obj, serializedClasses,
serializedConfiguredUnits):
"""
Decide if this unit should be serialized or not eventually fix name
to fit same already serialized unit
:param obj: object to serialize
:param serializedClasses: ... |
Serialize HdlType instance | def HdlType(cls, typ: HdlType, ctx: SerializerCtx, declaration=False):
"""
Serialize HdlType instance
"""
if isinstance(typ, Bits):
sFn = cls.HdlType_bits
elif isinstance(typ, HEnum):
sFn = cls.HdlType_enum
elif isinstance(typ, HArray):
... |
Srialize IfContainer instance | def IfContainer(cls, ifc: IfContainer, ctx: SerializerCtx):
"""
Srialize IfContainer instance
"""
childCtx = ctx.withIndent()
def asHdl(statements):
return [cls.asHdl(s, childCtx) for s in statements]
try:
cond = cls.condAsHdl(ifc.cond, True, ctx... |
: return: simulation driver which keeps signal value high for initDelay then it sets value to 0 | def pullDownAfter(sig, initDelay=6 * Time.ns):
"""
:return: simulation driver which keeps signal value high for initDelay
then it sets value to 0
"""
def _pullDownAfter(s):
s.write(True, sig)
yield s.wait(initDelay)
s.write(False, sig)
return _pullDownAfter |
if is negated return original cond and negated flag | def getBaseCond(c):
"""
if is negated return original cond and negated flag
"""
isNegated = False
try:
drivers = c.drivers
except AttributeError:
return (c, isNegated)
if len(drivers) == 1:
d = list(c.drivers)[0]
if isinstance(d, Operator) and d.operator == A... |
Construct SimBitsT with cache | def simBitsT(width: int, signed: Union[bool, None]):
"""
Construct SimBitsT with cache
"""
k = (width, signed)
try:
return __simBitsTCache[k]
except KeyError:
t = SimBitsT(width, signed)
__simBitsTCache[k] = t
return t |
: param val: None or dict { field name: field value }: param typeObj: instance of String HdlType: param vldMask: if is None validity is resolved from val if is 0 value is invalidated if is 1 value has to be valid | def fromPy(cls, val, typeObj, vldMask=None):
"""
:param val: None or dict {field name: field value}
:param typeObj: instance of String HdlType
:param vldMask: if is None validity is resolved from val
if is 0 value is invalidated
if is 1 value has to be valid
... |
Create basic: class:. Signal interface where type is vector | def VectSignal(width,
signed=None,
masterDir=D.OUT,
loadConfig=True):
"""
Create basic :class:`.Signal` interface where type is vector
"""
return Signal(masterDir,
Bits(width, signed, forceVector=True),
loadConfig) |
Get constant name for value name of constant is reused if same value was used before | def getConstName(self, val):
"""
Get constant name for value
name of constant is reused if same value was used before
"""
try:
return self._cache[val]
except KeyError:
if isinstance(val.val, int):
name = "const_%d_" % val.val
... |
Cut off statements which are driver of specified signal | def _cut_off_drivers_of(self, sig: RtlSignalBase):
"""
Cut off statements which are driver of specified signal
"""
if self.dst is sig:
self.parentStm = None
return self
else:
return None |
Parse HArray type to this transaction template instance | def _loadFromArray(self, dtype: HdlType, bitAddr: int) -> int:
"""
Parse HArray type to this transaction template instance
:return: address of it's end
"""
self.itemCnt = evalParam(dtype.size).val
self.children = TransTmpl(
dtype.elmType, 0, parent=self, orig... |
Parse HStruct type to this transaction template instance | def _loadFromHStruct(self, dtype: HdlType, bitAddr: int):
"""
Parse HStruct type to this transaction template instance
:return: address of it's end
"""
for f in dtype.fields:
t = f.dtype
origin = f
isPadding = f.name is None
if is... |
Parse HUnion type to this transaction template instance | def _loadFromUnion(self, dtype: HdlType, bitAddr: int) -> int:
"""
Parse HUnion type to this transaction template instance
:return: address of it's end
"""
for field in dtype.fields.values():
ch = TransTmpl(field.dtype, 0, parent=self, origin=field)
self.... |
Parse HUnion type to this transaction template instance | def _loadFromHStream(self, dtype: HStream, bitAddr: int) -> int:
"""
Parse HUnion type to this transaction template instance
:return: address of it's end
"""
ch = TransTmpl(dtype.elmType, 0, parent=self, origin=self.origin)
self.children.append(ch)
return bitAddr... |
Parse any HDL type to this transaction template instance | def _loadFromHType(self, dtype: HdlType, bitAddr: int) -> None:
"""
Parse any HDL type to this transaction template instance
"""
self.bitAddr = bitAddr
childrenAreChoice = False
if isinstance(dtype, Bits):
ld = self._loadFromBits
elif isinstance(dtype,... |
Only for transactions derived from HArray | def getItemWidth(self) -> int:
"""
Only for transactions derived from HArray
:return: width of item in original array
"""
if not isinstance(self.dtype, HArray):
raise TypeError()
return (self.bitAddrEnd - self.bitAddr) // self.itemCnt |
Walk fields in instance of TransTmpl | def walkFlatten(self, offset: int=0,
shouldEnterFn=_default_shouldEnterFn,
otherObjItCtx: ObjIteratorCtx =_DummyIteratorCtx()
) -> Generator[
Union[Tuple[Tuple[int, int], 'TransTmpl'], 'OneOfTransaction'],
None, None]:
"""
... |
: return: generator of generators of tuples (( startBitAddress endBitAddress ) TransTmpl instance ) for each possiblility in this transaction | def walkFlattenChilds(self) -> Generator[
Union[Tuple[Tuple[int, int], TransTmpl], 'OneOfTransaction'],
None, None]:
"""
:return: generator of generators of tuples
((startBitAddress, endBitAddress), TransTmpl instance)
for each possiblility in this transac... |
Convert negative int to positive int which has same bits set | def signFix(val, width):
"""
Convert negative int to positive int which has same bits set
"""
if val > 0:
msb = 1 << (width - 1)
if val & msb:
val -= mask(width) + 1
return val |
: attention: If other is Bool signal convert this to bool ( not ideal due VHDL event operator ) | def bitsCmp(self, other, op, evalFn=None):
"""
:attention: If other is Bool signal convert this to bool (not ideal,
due VHDL event operator)
"""
other = toHVal(other)
t = self._dtype
ot = other._dtype
iamVal = isinstance(self, Value)
otherIsVal = isinstance(other, Value)
if... |
: attention: If other is Bool signal convert this to bool ( not ideal due VHDL event operator ) | def bitsBitOp(self, other, op, getVldFn, reduceCheckFn):
"""
:attention: If other is Bool signal, convert this to bool
(not ideal, due VHDL event operator)
"""
other = toHVal(other)
iamVal = isinstance(self, Value)
otherIsVal = isinstance(other, Value)
if iamVal and otherIsVal:
... |
: param val: value of python type bool or None: param typeObj: instance of HEnum: param vldMask: if is None validity is resolved from val if is 0 value is invalidated if is 1 value has to be valid | def fromPy(cls, val, typeObj, vldMask=None):
"""
:param val: value of python type bool or None
:param typeObj: instance of HEnum
:param vldMask: if is None validity is resolved from val
if is 0 value is invalidated
if is 1 value has to be valid
"""
... |
Doc on parent class: meth: HdlStatement. _discover_sensitivity | def _discover_sensitivity(self, seen) -> None:
"""
Doc on parent class :meth:`HdlStatement._discover_sensitivity`
"""
assert self._sensitivity is None, self
ctx = self._sensitivity = SensitivityCtx()
casual_sensitivity = set()
self.switchOn._walk_sensitivity(casu... |
: attention: enclosure has to be discoverd first use _discover_enclosure () method | def _fill_enclosure(self, enclosure: Dict[RtlSignalBase, HdlStatement]) -> None:
"""
:attention: enclosure has to be discoverd first use _discover_enclosure() method
"""
select = []
outputs = self._outputs
for e in enclosure.keys():
if e in outputs:
... |
Doc on parent class: meth: HdlStatement. _iter_stms | def _iter_stms(self):
"""
Doc on parent class :meth:`HdlStatement._iter_stms`
"""
for _, stms in self.cases:
yield from stms
if self.default is not None:
yield from self.default |
: return: True if other can be merged into this statement else False | def _is_mergable(self, other) -> bool:
"""
:return: True if other can be merged into this statement else False
"""
if not isinstance(other, SwitchContainer):
return False
if not (self.switchOn is other.switchOn and
len(self.cases) == len(other.cases) ... |
Merge other statement to this statement | def _merge_with_other_stm(self, other: "IfContainer") -> None:
"""
Merge other statement to this statement
"""
merge = self._merge_statement_lists
newCases = []
for (c, caseA), (_, caseB) in zip(self.cases, other.cases):
newCases.append((c, merge(caseA, caseB)... |
Doc on parent class: meth: HdlStatement. _try_reduce | def _try_reduce(self) -> Tuple[List["HdlStatement"], bool]:
"""
Doc on parent class :meth:`HdlStatement._try_reduce`
"""
io_change = False
new_cases = []
for val, statements in self.cases:
_statements, rank_decrease, _io_change = self._try_reduce_list(
... |
: return: True if statements in branches has different effect | def _condHasEffect(self) -> bool:
"""
:return: True if statements in branches has different effect
"""
if not self.cases:
return False
# [TODO]
type_domain_covered = bool(self.default) or len(
self.cases) == self.switchOn._dtype.domain_size()
... |
Doc on parent class: meth: HdlStatement. isSame | def isSame(self, other: HdlStatement) -> bool:
"""
Doc on parent class :meth:`HdlStatement.isSame`
"""
if self is other:
return True
if self.rank != other.rank:
return False
if isinstance(other, SwitchContainer) \
and isSameHVal(s... |
: return: generator of tuples ( event operator signal ) | def discoverEventDependency(sig):
"""
:return: generator of tuples (event operator, signal)
"""
try:
drivers = sig.drivers
except AttributeError:
return
if len(drivers) == 1:
d = drivers[0]
if isinstance(d, Operator):
if isEventDependentOp(d.operator... |
Cached indent getter function | def getIndent(indentNum):
"""
Cached indent getter function
"""
try:
return _indentCache[indentNum]
except KeyError:
i = "".join([_indent for _ in range(indentNum)])
_indentCache[indentNum] = i
return i |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.