hwtLib.handshaked package

Submodules

hwtLib.handshaked.builder module

class hwtLib.handshaked.builder.HsBuilder(parent, srcInterface, name=None, master_to_slave=True)[source]

Bases: hwtLib.abstract.streamBuilder.AbstractStreamBuilder

Helper class which simplifies building of large stream paths

FifoAsyncCls

alias of hwtLib.handshaked.fifoAsync.HsFifoAsync

FifoCls

alias of hwtLib.handshaked.fifo.HandshakedFifo

JoinExplicitCls = NotImplemented
JoinFairCls

alias of hwtLib.handshaked.joinFair.HsJoinFairShare

JoinPrioritizedCls

alias of hwtLib.handshaked.joinPrioritized.HsJoinPrioritized

RegCls

alias of hwtLib.handshaked.reg.HandshakedReg

ResizerCls

alias of hwtLib.handshaked.resizer.HsResizer

SplitCopyCls

alias of hwtLib.handshaked.splitCopy.HsSplitCopy

SplitFairCls

alias of hwtLib.handshaked.splitFair.HsSplitFair

SplitPrioritizedCls

alias of hwtLib.handshaked.splitPrioritized.HsSplitPrioritized

SplitSelectCls

alias of hwtLib.handshaked.splitSelect.HsSplitSelect

hwtLib.handshaked.cdc module

class hwtLib.handshaked.cdc.HandshakeFSM[source]

Bases: hwt.synthesizer.unit.Unit

schematic
_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

static _serializeDecision(parentUnit, priv)

Decide to serialize only objs with uniq parameters and class

Parameters

priv – private data for this function ({frozen_params: obj})

Returns

tuple (do serialize this object, next priv, replacement unit)

class hwtLib.handshaked.cdc.HandshakedCdc(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.compBase.HandshakedCompBase

CDC (Clock Domain Crossing) for handshaked interface

Note

This component uses syncrhorization by pulse CDCs which means it’s throughput is significantly limited (eta slowest clk / 3)

schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

static _serializeDecision(parentUnit, priv)

Decide to serialize only objs with uniq parameters and class

Parameters

priv – private data for this function ({frozen_params: obj})

Returns

tuple (do serialize this object, next priv, replacement unit)

create_data_reg(name_prefix, clk=None, rst=None)[source]

Create a registers for data signals with default values from Unit parameters and with specified clk/rst

propagate_clk(u, reverse=False)[source]
propagate_in_clk(u)[source]
propagate_out_clk(u)[source]
hwtLib.handshaked.cdc.example_HandshakedCdc()[source]

hwtLib.handshaked.compBase module

class hwtLib.handshaked.compBase.HandshakedCompBase(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwt.synthesizer.unit.Unit

Abstract class for components which has Handshaked interface as main

__init__(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]
Parameters

hsIntfCls – class of interface which should be used as interface of this unit

_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

get_data(intf)[source]
classmethod get_ready_signal(intf)[source]
classmethod get_valid_signal(intf)[source]

hwtLib.handshaked.fifo module

class hwtLib.handshaked.fifo.HandshakedFifo(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.compBase.HandshakedCompBase

Synchronous FIFO for handshaked interfaces

_images/aafig-2b8462ad6636d27e12d56420615971cbcc07ab68.gif schematic
FIFO_CLS

alias of hwtLib.mem.fifo.Fifo

_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_connect_fifo_in()[source]
_connect_fifo_out(out_clk, out_rst)[source]
_connect_size_and_space(out_vld, fifo)[source]
_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl(clk_rst: Optional[Tuple[Tuple[hwt.interfaces.std.Clk, Union[hwt.interfaces.std.Rst, hwt.interfaces.std.Rst_n]], Tuple[hwt.interfaces.std.Clk, Union[hwt.interfaces.std.Rst, hwt.interfaces.std.Rst_n]]]] = None)[source]
Parameters

clk_rst – optional tuple ((inClk, inRst), (outClk, outRst))

static _serializeDecision(parentUnit, priv)

Decide to serialize only objs with uniq parameters and class

Parameters

priv – private data for this function ({frozen_params: obj})

Returns

tuple (do serialize this object, next priv, replacement unit)

hwtLib.handshaked.fifo._example_HandshakedFifo()[source]

hwtLib.handshaked.fifoAsync module

class hwtLib.handshaked.fifoAsync.HsFifoAsync(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.fifo.HandshakedFifo

Asynchronous FIFO using BRAM/LUT memory, based on:

Note

same functionality as hwtLib.handshaked.fifo.HandshakedFifo except it has separated clock for input/output

schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]
Parameters

clk_rst – optional tuple ((inClk, inRst), (outClk, outRst))

static _serializeDecision(parentUnit, priv)

Decide to serialize only objs with uniq parameters and class

Parameters

priv – private data for this function ({frozen_params: obj})

Returns

tuple (do serialize this object, next priv, replacement unit)

hwtLib.handshaked.fifoAsync._example_HsFifoAsync()[source]

hwtLib.handshaked.fifo_drop module

class hwtLib.handshaked.fifo_drop.HandshakedFifoDrop(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.fifo.HandshakedFifo

Fifo for handsahaked interface which allows to discard/commit written data

See

hwtLib.handshaked.fifo.HandshakedFifo and hwtLib.mem.fifo_drop.FifoDrop

schematic
FIFO_CLS

alias of hwtLib.mem.fifo_drop.FifoDrop

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl(clk_rst: Optional[Tuple[Tuple[hwt.interfaces.std.Clk, Union[hwt.interfaces.std.Rst, hwt.interfaces.std.Rst_n]], Tuple[hwt.interfaces.std.Clk, Union[hwt.interfaces.std.Rst, hwt.interfaces.std.Rst_n]]]] = None)[source]
Parameters

clk_rst – optional tuple ((inClk, inRst), (outClk, outRst))

hwtLib.handshaked.fifo_drop._example_HandshakedFifoDrop()[source]

hwtLib.handshaked.intfBiDirectional module

class hwtLib.handshaked.intfBiDirectional.HandshakedBiDirectional(masterDir=<DIRECTION.OUT: 1>, loadConfig=True)[source]

Bases: hwt.interfaces.std.Handshaked

hwt.interfaces.std.Handshaked interface with data

channels in bout direction

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_initSimAgent(sim: pycocotb.hdlSimulator.HdlSimulator)[source]
class hwtLib.handshaked.intfBiDirectional.HandshakedBiDirectionalAgent(sim, intf)[source]

Bases: hwt.interfaces.agents.handshaked.HandshakedAgent

Simulation agent for HandshakedBiDirectional interface

Attention

for monitor number of items in dinData has to match with number of received items

__init__(sim, intf)[source]
Parameters

rst – tuple (rst signal, rst_negated flag)

getMonitors()[source]

Called before simulation to collect all monitors of interfaces from this agent

get_data()[source]

extract data from interface

notReset()[source]
onDriverWriteAck()[source]

read din

onMonitorReady()[source]

write din

set_data(data)[source]

write data to interface

hwtLib.handshaked.joinFair module

class hwtLib.handshaked.joinFair.HsJoinFairShare(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.joinPrioritized.HsJoinPrioritized

Join multiple input streams into single output stream. Priority is changing every clock period. If prioritized input is not sending valid data, input with lowest index and valid is used.

Note

combinational

_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

inputMuxLogic(isSelectedFlags)[source]
isSelectedLogic(din_vlds, dout_rd, selectedOneHot)[source]

Resolve isSelected signal flags for each input, when isSelected flag signal is 1 it means input has clearance to make transaction

static priorityAck(priorityReg, vldSignals, index)[source]

Generate ack logic for selected input

Parameters
  • priorityReg – priority register with one hot encoding, 1 means input of this index should have be prioritized.

  • vldSignals – list of vld signals of input

  • index – index of input for which you wont get ack logic

Returns

ack signal for this input

hwtLib.handshaked.joinFair._example_HsJoinFairShare()[source]

hwtLib.handshaked.joinPrioritized module

class hwtLib.handshaked.joinPrioritized.HsJoinPrioritized(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.compBase.HandshakedCompBase

Join input stream to single output stream inputs with lower number has higher priority

Note

combinational

schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

dataConnectionExpr(dIn, dOut)[source]

Create connection between input and output interface

hwtLib.handshaked.joinPrioritized._example_HsJoinPrioritized()[source]

hwtLib.handshaked.ramAsHs module

class hwtLib.handshaked.ramAsHs.RamAsHs[source]

Bases: hwt.synthesizer.unit.Unit

Converter from ram port to handshaked interfaces

schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

static _serializeDecision(parentUnit, priv)

Decide to serialize only objs with uniq parameters and class

Parameters

priv – private data for this function ({frozen_params: obj})

Returns

tuple (do serialize this object, next priv, replacement unit)

class hwtLib.handshaked.ramAsHs.RamHsR(masterDir=<DIRECTION.OUT: 1>, loadConfig=True)[source]

Bases: hwt.synthesizer.interface.Interface

Handshaked RAM port

_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_initSimAgent(sim: pycocotb.hdlSimulator.HdlSimulator)[source]
class hwtLib.handshaked.ramAsHs.RamHsRAgent(sim: pycocotb.hdlSimulator.HdlSimulator, intf)[source]

Bases: pycocotb.agents.base.AgentBase

Composite agent with agent for addr and data channel enable is shared

__init__(sim: pycocotb.hdlSimulator.HdlSimulator, intf)[source]

Initialize self. See help(type(self)) for accurate signature.

getDrivers()[source]

Called before simulation to collect all drivers of interfaces from this agent

getEnable()[source]
getMonitors()[source]

Called before simulation to collect all monitors of interfaces from this agent

setEnable(v)[source]

Distribute change of enable on child agents

hwtLib.handshaked.reg module

class hwtLib.handshaked.reg.HandshakedReg(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.compBase.HandshakedCompBase

Register for Handshaked interfaces

Note

latency and delay can be specified as well as interface class

schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

_implLatencyAndDelay(inVld: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, inRd: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, inData: List[hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal], outVld: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, outRd: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, prefix: str)[source]

Create a register pipe

_implReadyChainBreak(in_vld: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, in_rd: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, in_data: List[hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal], out_vld: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, out_rd: hwt.synthesizer.rtlLevel.rtlSignal.RtlSignal, prefix: str)[source]

Two sets of registers 0. is prioritized 1. is used as a backup The in_rd is not combinationally connected to out_rd The out_vld is not combinationally connected to in_vld

_impl_latency(inVld, inRd, inData, outVld, outRd, prefix)[source]

Create a normal handshaked register

static _serializeDecision(parentUnit, priv)

Decide to serialize only objs with uniq parameters and class

Parameters

priv – private data for this function ({frozen_params: obj})

Returns

tuple (do serialize this object, next priv, replacement unit)

hwtLib.handshaked.reg._example_HandshakedReg()[source]

hwtLib.handshaked.resizer module

class hwtLib.handshaked.resizer.HsResizer(hsIntfCls, scale, inIntfConfigFn, outIntfConfigFn)[source]

Bases: hwtLib.handshaked.compBase.HandshakedCompBase

Resize width of handshaked interface

schematic
__init__(hsIntfCls, scale, inIntfConfigFn, outIntfConfigFn)[source]
Parameters
  • hsIntfCls – class of interface which should be used as interface of this unit

  • scale – tuple (in scale, out scale) one of scales has to be 1, f. e. (1,2) means output will be 2x wider

  • inIntfConfigFn – function inIntfConfigFn(input interface) which will be applied on dataIn

  • outIntfConfigFn – function outIntfConfigFn(input interface) which will be applied on dataOut

_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_downscale(factor)[source]
_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

_upscale(factor)[source]
_upscaleDataPassLogic(inputRegs_cntr, ITEMS)[source]
hwtLib.handshaked.resizer._example_HsResizer()[source]

hwtLib.handshaked.splitCopy module

class hwtLib.handshaked.splitCopy.HsSplitCopy(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.compBase.HandshakedCompBase

Clone input stream to n identical output streams transaction is made in all interfaces or none of them

Note

combinational

_images/aafig-974cbc4cabd23d90a21b7cc9815a419c9c989770.gif schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

hwtLib.handshaked.splitCopy._example_HsSplitCopy()[source]

hwtLib.handshaked.splitFair module

class hwtLib.handshaked.splitFair.HsSplitFair(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.splitCopy.HsSplitCopy

Split input stream to outputs, select single output for every input data based on priority.

Priority is changing every clock If prioritized output is not ready, input with lowest index and ready is used

Note

combinational

_images/aafig-8d5df5cd3e28bd7d989ef9d372e25aed77fa17b7.gif
Variables

selectedOneHot – handshaked interface with one hot encoded index of selected output

schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

isSelectedLogic(din)[source]

Resolve isSelected signal flags for each input, when isSelected flag signal is 1 it means input has clearance to make transaction

hwtLib.handshaked.splitFair._example_HsSplitFair()[source]

hwtLib.handshaked.splitPrioritized module

class hwtLib.handshaked.splitPrioritized.HsSplitPrioritized(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.splitCopy.HsSplitCopy

Split input stream to N output streams. Data is send to output interface which is ready and has lowest index.

Note

combinational

_images/aafig-8d5df5cd3e28bd7d989ef9d372e25aed77fa17b7.gif schematic
_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

hwtLib.handshaked.splitPrioritized._example_HsSplitPrioritized()[source]

hwtLib.handshaked.splitSelect module

class hwtLib.handshaked.splitSelect.HsSplitSelect(hsIntfCls: Type[Union[hwt.interfaces.std.Handshaked, hwt.interfaces.std.HandshakeSync]])[source]

Bases: hwtLib.handshaked.compBase.HandshakedCompBase

Split data from input interface to N output interfaces based on explicit output index provided by select interface.

_images/aafig-b9eef9583623a6ff729becb02432e0765ac9c26b.gif schematic
_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

_select_consume_en()[source]
hwtLib.handshaked.splitSelect._example_HsSplitSelect()[source]

hwtLib.handshaked.storedBurst module

class hwtLib.handshaked.storedBurst.HandshakedStoredBurst(intfCls=<class 'hwt.interfaces.std.Handshaked'>)[source]

Bases: hwt.synthesizer.unit.Unit

This units send data stored in property DATA over axi-stream interface

schematic
__init__(intfCls=<class 'hwt.interfaces.std.Handshaked'>)[source]

Initialize self. See help(type(self)) for accurate signature.

_config()[source]

Configure object parameters

  • setup all parameters on this object, use Param class instances to allow use of parameter inheritance

  • called in __init__ of class

_declr()[source]

declarations

  • do all declarations of externally accessible objects there (Interfaces)

  • _declr method is called after _config

  • if this object is Unit all interfaces are threated as externally accessible interfaces if this object is Interface instance all subinterfaces are loaded as well

_impl()[source]

implementations

  • implement functionality of componnent there

  • called after _declr

dataRd()[source]
nextWordIndexLogic(wordIndex)[source]
set_data(intf, d)[source]

hwtLib.handshaked.streamNode module

class hwtLib.handshaked.streamNode.ExclusiveStreamGroups(iterable=(), /)[source]

Bases: list

list of tuples (cond, StreamNode instance) Only one stream from this group can be activated at the time

ack()[source]
Returns

expression which’s value is high when transaction can be made over at least on child streaming node

sync(enSig=None)[source]

Create synchronization logic between streams (generate valid/ready synchronization logic for interfaces)

Parameters

enSig – optional signal to enable this group of nodes

Returns

list of assignments which are responsible for synchronization of streams

class hwtLib.handshaked.streamNode.StreamNode(masters=None, slaves=None, extraConds=None, skipWhen=None)[source]

Bases: object

Group of stream master and slave interfaces to synchronize them to each other

Variables
  • masters – interfaces which are inputs into this node

  • slaves – interfaces which are outputs of this node

  • extraConds – {dict interface : extraConditionSignal} where extra conditions will be added to expression for channel enable. For master it means it will obtain ready=1 only if extraConditionSignal is 1. For slave it means it will obtain valid=1 only if extraConditionSignal is 1. All interfaces have to wait on each other so if an extraCond!=1 it causes blocking on all interfaces if not overridden by skipWhen.

  • skipWhen – dict interface : skipSignal where if skipSignal is high interface is disconnected from stream sync node and others does not have to wait on it (master does not need to have valid and slave ready)

Attention

skipWhen has higher priority

__init__(masters=None, slaves=None, extraConds=None, skipWhen=None)[source]

Initialize self. See help(type(self)) for accurate signature.

ack()[source]
Returns

expression which’s value is high when transaction can be made over interfaces

ackForMaster(master)[source]
Returns

driver of ready signal for master

ackForSlave(slave)[source]
Returns

driver of valid signal for slave

getExtraAndSkip(intf)[source]
Returns

optional extraCond and skip flags for interface

rd(intf)[source]
Returns

ready signal of slave interface for synchronization of othres

sync(enSig=None)[source]

Create synchronization logic between streams (generate valid/ready synchronization logic for interfaces)

Parameters

enSig – optional signal to enable this node

Returns

list of assignements which are responsible for synchronization of streams

vld(intf)[source]
Returns

valid signal of master interface for synchronization of othres

hwtLib.handshaked.streamNode._exStreamMemberAck(m)[source]
hwtLib.handshaked.streamNode._get_ready_signal(intf)[source]
hwtLib.handshaked.streamNode._get_valid_signal(intf)[source]