def __init__(s, dtype):
s.Data = canonicalize_type(dtype)
super(DropUnitInterface, s).__init__([
MethodSpec(
'drop',
args=None,
rets=None,
call=True,
rdy=True,
),
MethodSpec(
'drop_status',
args=None,
rets={'occurred': Bits(1)},
call=False,
rdy=False,
),
MethodSpec(
'output',
args=None,
rets={
'data': dtype,
},
call=True,
rdy=True,
),
],)
def __init__(s, Key, Value, num_read_ports, num_write_ports):
s.Key = Key
s.Value = Value
s.num_read_ports = num_read_ports
s.num_write_ports = num_write_ports
super(LookupRegisterFileInterface, s).__init__([
MethodSpec(
'read',
args={
'key': s.Key,
},
rets={
'value': s.Value,
'valid': Bits(1),
},
call=False,
rdy=False,
count=num_read_ports,
),
MethodSpec(
'write',
args={
'key': s.Key,
'value': s.Value,
},
rets={
'valid': Bits(1),
},
call=True,
rdy=False,
count=num_write_ports,
),
])
def __init__(s, data_len):
s.DataLen = data_len
super(DivideInterface, s).__init__([
MethodSpec(
'preempt',
args=None,
rets=None,
call=True,
rdy=False,
),
MethodSpec(
'result',
args=None,
rets={
'quotient': Bits(s.DataLen),
'rem': Bits(s.DataLen),
},
call=True,
rdy=True,
),
MethodSpec(
'div',
args={
'dividend': Bits(s.DataLen),
'divisor': Bits(s.DataLen),
'signed': Bits(1),
},
rets=None,
call=True,
rdy=True,
),
])
def __init__(s, xlen):
UseInterface(s, Interface([]))
s.require(
MethodSpec(
'check_redirect',
args={},
rets={
'redirect': Bits(1),
'target': Bits(xlen),
},
call=False,
rdy=False,
),
MethodSpec(
'kill_notify',
args={
'msg': Bits(1),
},
rets=None,
call=False,
rdy=False,
),
)
s.connect(s.kill_notify_msg, s.check_redirect_redirect)
def __init__(s, dtype, enable=False, bypass=False):
s.Data = canonicalize_type(dtype)
s.enable = enable
s.write_read_bypass = bypass
super(RegisterInterface, s).__init__(
[
MethodSpec(
'read',
args=None,
rets={
'data': s.Data,
},
call=False,
rdy=False,
),
MethodSpec(
'write',
args={
'data': s.Data,
},
rets=None,
call=enable,
rdy=False,
),
],
ordering_chains=[s.bypass_chain('write', 'read', bypass)],
)
def __init__(s, interface, clients):
UseInterface(s, interface)
reqs = []
for client in clients:
reqs.extend([
MethodSpec(
'{}_peek'.format(client),
args=None,
rets={
'msg': s.interface.MsgType,
},
call=False,
rdy=True,
),
MethodSpec(
'{}_take'.format(client),
args=None,
rets=None,
call=True,
rdy=False,
),
])
s.require(*reqs)
ninputs = len(clients)
s.index_peek_msg = [Wire(s.interface.MsgType) for _ in range(ninputs)]
s.index_peek_rdy = [Wire(1) for _ in range(ninputs)]
s.index_take_call = [Wire(1) for _ in range(ninputs)]
for i, client in enumerate(clients):
s.connect(s.index_peek_msg[i],
getattr(s, '{}_peek'.format(client)).msg)
s.connect(s.index_peek_rdy[i],
getattr(s, '{}_peek'.format(client)).rdy)
s.connect(
getattr(s, '{}_take'.format(client)).call,
s.index_take_call[i])
s.arb = PriorityArbiter(ArbiterInterface(ninputs))
s.mux = CaseMux(
CaseMuxInterface(s.interface.MsgType, Bits(ninputs), ninputs),
[1 << i for i in range(ninputs)])
@s.combinational
def compute_ready():
s.peek_rdy.v = (s.arb.grant_grant != 0)
for i in range(ninputs):
s.connect(s.arb.grant_reqs[i], s.index_peek_rdy[i])
# call an input if granted and we are being called
@s.combinational
def compute_call(i=i):
s.index_take_call[i].v = s.arb.grant_grant[i] & s.take_call
s.connect(s.mux.mux_in_[i], s.index_peek_msg[i])
s.connect(s.mux.mux_default, 0)
s.connect(s.mux.mux_select, s.arb.grant_grant)
s.connect(s.peek_msg, s.mux.mux_out)
def __init__(s, interface):
UseInterface(s, interface)
size = len(s.interface.clients)
Pipe = Bits(clog2nz(size))
s.require(
MethodSpec(
'in_peek',
args=None,
rets={
'msg': s.interface.Data,
},
call=False,
rdy=True,
),
MethodSpec(
'in_take',
args=None,
rets=None,
call=True,
rdy=False,
),
MethodSpec(
'sort',
args={'msg': s.interface.Data},
rets={'pipe': Pipe},
call=False,
rdy=False,
),
)
s.peek_array = [
getattr(s, '{}_peek'.format(client))
for client in s.interface.clients
]
s.take_array = [
getattr(s, '{}_take'.format(client))
for client in s.interface.clients
]
s.rdy_array = [Wire(1) for _ in range(size)]
for i in range(size):
s.connect(s.peek_array[i].rdy, s.rdy_array[i])
s.connect(s.sort_msg, s.in_peek_msg)
s.take_mux = Mux(Bits(1), size)
s.effective_call = Wire(1)
for i in range(size):
@s.combinational
def handle_rdy(i=i):
s.rdy_array[i].v = (s.sort_pipe == i) and s.in_peek_rdy
s.connect(s.peek_array[i].msg, s.in_peek_msg)
s.connect(s.take_mux.mux_in_[i], s.take_array[i].call)
s.connect(s.take_mux.mux_select, s.sort_pipe)
s.connect(s.in_take_call, s.take_mux.mux_out)
def __init__(s, entry_type, num_entries, KillOpaqueType, KillArgType):
s.EntryType = entry_type
s.EntryIdx = clog2(num_entries)
s.NumEntries = num_entries
s.KillOpaqueType = KillOpaqueType
s.KillArgType = KillArgType
super(ReorderBufferInterface, s).__init__([
MethodSpec(
'add',
args={
'idx': s.EntryIdx,
'value': s.EntryType,
'kill_opaque': s.KillOpaqueType,
},
rets=None,
call=True,
rdy=False,
),
MethodSpec(
'check_done',
args={
'idx': s.EntryIdx,
},
rets={
'is_rdy': Bits(1),
},
call=False,
rdy=False,
),
MethodSpec(
'peek',
args={
'idx': s.EntryIdx,
},
rets={
'value': s.EntryType,
},
call=False,
rdy=False,
),
MethodSpec(
'free',
args=None,
rets=None,
call=True,
rdy=False,
),
MethodSpec('kill_notify',
args={
'msg': s.KillArgType,
},
rets=None,
call=False,
rdy=False),
])
def __init__(s, dtype, nregs, num_read_ports, num_write_ports,
write_read_bypass, write_dump_bypass):
s.Addr = Bits(clog2nz(nregs))
s.Data = canonicalize_type(dtype)
ordering_chains = [
s.bypass_chain('write', 'read', write_read_bypass),
s.bypass_chain('write', 'dump', write_dump_bypass),
] + s.successor('set', ['read', 'write', 'dump'])
super(RegisterFileInterface, s).__init__(
[
MethodSpec('read',
args={
'addr': s.Addr,
},
rets={
'data': s.Data,
},
call=False,
rdy=False,
count=num_read_ports),
MethodSpec('write',
args={
'addr': s.Addr,
'data': s.Data,
},
rets=None,
call=True,
rdy=False,
count=num_write_ports),
MethodSpec(
'dump',
args=None,
rets={
'out': Array(s.Data, nregs),
},
call=False,
rdy=False,
),
MethodSpec(
'set',
args={
'in_': Array(s.Data, nregs),
},
rets=None,
call=True,
rdy=False,
),
],
ordering_chains=ordering_chains,
)
def __init__(s, stage_class, drop_controller_class=None):
def gen():
return ForwardingStage(stage_class)
gen.__name__ = stage_class.__name__
s.gen_stage = gen_stage(gen, drop_controller_class)()
UseInterface(s, s.gen_stage.interface)
s.wrap(s.gen_stage, ['forward'])
s.require(
MethodSpec(
'forward',
args={
'tag': PREG_IDX_NBITS,
'value': Bits(XLEN),
},
rets=None,
call=True,
rdy=False,
), )
s.forwarder = Forwarder()
s.connect_m(s.forwarder.in_forward, s.gen_stage.forward)
s.connect_m(s.forwarder.in_peek, s.gen_stage.peek)
s.connect_m(s.forwarder.in_take, s.gen_stage.take)
s.connect_m(s.forward, s.forwarder.forward)
s.connect_m(s.peek, s.forwarder.peek)
s.connect_m(s.take, s.forwarder.take)
if hasattr(s, 'kill_notify'):
s.connect_m(s.gen_stage.kill_notify, s.kill_notify)
def __init__(s, num_read_ports, num_write_ports):
s.num_read_ports = num_read_ports
s.num_write_ports = num_write_ports
super(CSRManagerInterface, s).__init__([
MethodSpec(
'read',
args={
'csr': Bits(CSR_SPEC_NBITS),
},
rets={
'value': Bits(XLEN),
'valid': Bits(1),
},
call=False,
rdy=False,
count=num_read_ports,
),
MethodSpec(
'write',
args={
'csr': Bits(CSR_SPEC_NBITS),
'value': Bits(XLEN),
},
rets={
'valid': Bits(1),
},
call=True,
rdy=False,
count=num_write_ports,
),
MethodSpec(
'op',
args={
'csr': Bits(CSR_SPEC_NBITS),
'op': Bits(CsrFunc.bits),
'rs1_is_x0': Bits(1),
'value': Bits(XLEN),
},
rets={
'old': Bits(XLEN),
'success': Bits(1),
},
call=True,
rdy=False,
),
])
def __init__(s, Addr, Size, Data):
s.Addr = Addr
s.Size = Size
s.Data = Data
super(MemoryArbiterInterface, s).__init__([
MethodSpec(
'recv_load',
args=None,
rets={
'data': s.Data,
},
call=True,
rdy=True,
),
MethodSpec(
'store_acks_outstanding',
args=None,
rets={
'ret': Bits(1),
},
call=False,
rdy=False,
),
MethodSpec(
'send_store',
args={
'addr': s.Addr,
'size': s.Size,
'data': s.Data,
},
rets=None,
call=True,
rdy=True,
),
MethodSpec(
'send_load',
args={
'addr': s.Addr,
'size': s.Size,
},
rets=None,
call=True,
rdy=True,
),
])
def __init__(s,
dtype,
nwords,
num_read_ports,
num_write_ports,
write_read_bypass=False):
s.Addr = Bits(clog2nz(nwords))
s.Data = canonicalize_type(dtype)
s.Bypass = write_read_bypass
s.NumWords = nwords
ordering_chains = [
s.bypass_chain('write', 'read', write_read_bypass),
]
super(SynchronousRAMInterface, s).__init__(
[
MethodSpec(
'read_next',
args={
'addr': s.Addr,
},
call=False,
rdy=False,
count=num_read_ports),
MethodSpec(
'read',
rets={
'data': s.Data,
},
call=False,
rdy=False,
count=num_read_ports),
MethodSpec(
'write',
args={
'addr': s.Addr,
'data': s.Data,
},
rets=None,
call=True,
rdy=False,
count=num_write_ports),
],
ordering_chains=ordering_chains,
)
def __init__(s, width):
s.width = width
super(ProcDebugBusInterface, s).__init__([
MethodSpec(
'recv',
args=None,
rets={'msg': Bits(width)},
call=True,
rdy=True,
),
MethodSpec(
'send',
args={'msg': Bits(width)},
rets=None,
call=True,
rdy=True,
),
])
def __init__(s):
UseInterface(s, ForwarderInterface())
s.require(
MethodSpec(
'in_peek',
args=None,
rets={
'msg': ExecuteMsg(),
},
call=False,
rdy=True,
),
MethodSpec(
'in_take',
args=None,
rets=None,
call=True,
rdy=False,
),
MethodSpec(
'forward',
args={
'tag': PREG_IDX_NBITS,
'value': Bits(XLEN),
},
rets=None,
call=True,
rdy=False,
),
)
s.connect_m(s.peek, s.in_peek)
s.connect_m(s.take, s.in_take)
@s.combinational
def handle_forward():
if s.in_forward_call:
s.forward_tag.v = s.in_forward_tag
s.forward_value.v = s.in_forward_value
s.forward_call.v = s.in_forward_call
else:
s.forward_tag.v = s.in_peek_msg.rd
s.forward_value.v = s.in_peek_msg.result
s.forward_call.v = s.in_peek_rdy and s.in_peek_msg.hdr_status == PipelineMsgStatus.PIPELINE_MSG_STATUS_VALID and s.in_peek_msg.rd_val
def __init__(s, dtype, nregs, num_read_ports, num_write_ports,
write_read_bypass, write_snapshot_bypass, nsnapshots):
# No dump port exposed, so write_dump_snapshot is False
base = RegisterFileInterface(dtype, nregs, num_read_ports,
num_write_ports, write_read_bypass, False)
s.SnapshotId = Bits(clog2nz(nsnapshots))
s.Addr = base.Addr
s.Data = base.Data
ordering_chains = [
s.bypass_chain('write', 'snapshot', write_snapshot_bypass),
] + s.successor('restore', ['read', 'write']) + [
['snapshot', 'restore', 'set'],
]
super(SnapshottingRegisterFileInterface, s).__init__(
[
MethodSpec(
'snapshot',
args={
'target_id': s.SnapshotId,
},
rets=None,
call=True,
rdy=False,
),
MethodSpec(
'restore',
args={
'source_id': s.SnapshotId,
},
rets=None,
call=True,
rdy=False,
),
],
bases=[
IncludeSome(base, {'read', 'write', 'set'}),
],
ordering_chains=ordering_chains,
)
def __init__(s, naregs, npregs, num_lookup_ports, num_update_ports,
nsnapshots):
s.Preg = Bits(clog2nz(npregs))
snapshot_interface = SnapshottingRegisterFileInterface(
s.Preg, naregs, 0, 0, False, True, nsnapshots)
s.Areg = snapshot_interface.Addr
s.SnapshotId = snapshot_interface.SnapshotId
super(RenameTableInterface, s).__init__(
[
MethodSpec(
'lookup',
args={
'areg': s.Areg,
},
rets={
'preg': s.Preg,
},
call=False,
rdy=False,
count=num_lookup_ports,
),
MethodSpec(
'update',
args={
'areg': s.Areg,
'preg': s.Preg,
},
rets=None,
call=True,
rdy=False,
count=num_update_ports,
),
],
bases=[
IncludeSome(snapshot_interface, {'snapshot', 'restore', 'set'}),
],
ordering_chains=[
['lookup', 'update', 'snapshot', 'restore', 'set'],
],
)
def __init__(s, slot_type, KillArgType, num_notify, ordered=True):
s.SlotType = slot_type
s.SrcTag = Bits(slot_type.src0.nbits)
s.Opaque = Bits(slot_type.opaque.nbits)
s.KillArgType = KillArgType
s.NumNotify = num_notify
s.Ordered = ordered
super(IssueQueueInterface, s).__init__([
MethodSpec(
'add', args={
'value': s.SlotType,
}, rets=None, call=True, rdy=True),
MethodSpec(
'remove',
args=None,
rets={
'value': s.SlotType,
},
call=True,
rdy=True),
MethodSpec(
'notify',
args={
'tag': s.SrcTag.nbits,
},
rets=None,
call=True,
rdy=False,
count=num_notify),
MethodSpec(
'kill_notify',
args={
'msg': s.KillArgType,
},
rets=None,
call=False,
rdy=False),
])
def __init__(s, nslots, num_alloc_ports, num_free_ports, nsnapshots):
base = FreeListInterface(nslots,
num_alloc_ports,
num_free_ports,
free_alloc_bypass=False,
release_alloc_bypass=False)
s.SnapshotId = Bits(clog2nz(nsnapshots))
super(SnapshottingFreeListInterface, s).__init__(
[
MethodSpec(
'reset_alloc_tracking',
args={
'target_id': s.SnapshotId,
},
rets=None,
call=True,
rdy=False,
),
MethodSpec(
'revert_allocs',
args={
'source_id': s.SnapshotId,
},
rets=None,
call=True,
rdy=False,
),
# calling reset_alloc_tracking and revert_allocs
# with the same target ID in the same cycle is not permitted
],
bases=[
IncludeSome(base, {'free', 'alloc', 'set', 'get_state'}),
],
ordering_chains=[
['alloc', 'reset_alloc_tracking', 'revert_allocs', 'set'],
],
)
def __init__(s):
super(PairTestInterface, s).__init__([
MethodSpec(
'make_pair',
args={
'a': MyType(10, 20),
'b': MyType(10, 20),
},
rets={'pair': PairType(MyType(10, 20), MyType(10, 20))},
call=False,
rdy=False,
),
])
def __init__(s, data_len, keep_upper=True):
s.DataLen = data_len
s.KeepUpper = keep_upper
super(MulPipelinedInterface, s).__init__([
MethodSpec(
'peek',
args=None,
rets={
'res': Bits(2 * s.DataLen if keep_upper else s.DataLen),
},
call=False,
rdy=True,
),
MethodSpec(
'take',
args=None,
call=True,
rdy=True,
),
MethodSpec(
'cl_helper_shift',
args=None,
rets=None,
call=False,
rdy=False,
),
MethodSpec(
'mult',
args={
'src1': Bits(s.DataLen),
'src2': Bits(s.DataLen),
'src1_signed': Bits(1),
'src2_signed': Bits(1),
},
rets=None,
call=True,
rdy=True,
),
])
def __init__(s):
super(FunctionalFormTestInterface, s).__init__([
MethodSpec(
'add_w4',
args={
'a': Bits(8),
'b': Bits(8),
},
rets={'sum': Bits(8)},
call=False,
rdy=False,
),
])
def __init__(s, dtype, nclients):
s.Data = canonicalize_type(dtype)
s.nclients = nclients
s.Spec = Bits(clog2nz(nclients))
super(PipelineSplitterControllerInterface, s).__init__([
MethodSpec(
'sort',
args={'msg': s.Data},
rets={'pipe': s.Spec},
call=False,
rdy=False,
),
])
def __init__(s):
super(IssueSetOrdered, s).__init__([
MethodSpec(
'ordered',
args={
'input': RenameMsg(),
},
rets={
'ret': Bits(1),
},
call=False,
rdy=False,
),
])
def __init__(s, width):
s.width = width
super(ThermometerMaskInterface, s).__init__([
MethodSpec(
'mask',
args={
'in_': Bits(width),
},
rets={
'out': Bits(width),
},
call=False,
rdy=False,
),
])
def __init__(s, In, Out):
super(PayloadGeneratorInterface, s).__init__([
MethodSpec(
'gen',
args={
'inst': InstMsg(),
'data': In,
},
rets={
'payload': Out,
'valid': Bits(1),
},
call=False,
rdy=False),
])
def __init__(s, inwidth, outwidth):
s.In = canonicalize_type(inwidth)
s.Out = canonicalize_type(outwidth)
super(SextInterface, s).__init__([
MethodSpec(
'sext',
args={'in_': s.In},
rets={
'out': s.Out,
},
call=False,
rdy=False,
),
])
def __init__(s, noutbits, enable=False):
s.Out = Bits(noutbits)
s.In = clog2nz(noutbits)
s.En = enable
super(OneHotEncoderInterface, s).__init__([
MethodSpec('encode',
args={
'number': s.In,
},
rets={
'onehot': s.Out,
},
call=enable,
rdy=False),
])
def __init__(s, nreqs):
s.nreqs = nreqs
super(ArbiterInterface, s).__init__([
MethodSpec(
'grant',
args={
'reqs': Bits(nreqs),
},
rets={
'grant': Bits(nreqs),
},
call=False,
rdy=False,
),
])
def __init__(s):
# the order above (0 for CSR 1 for ALU comes from this array
# This is bad
UseInterface(
s,
PipelineSplitterInterface(
DispatchMsg(), ['csr', 'alu', 'branch', 'm_pipe', 'mem_data']))
s.require(
MethodSpec(
'in_peek',
args=None,
rets={
'msg': DispatchMsg(),
},
call=False,
rdy=True,
),
MethodSpec(
'in_take',
args=None,
rets=None,
call=True,
rdy=False,
),
)
s.splitter = PipelineSplitter(s.interface)
s.controller = PipeSelectorController()
s.connect_m(s.splitter.sort, s.controller.sort)
s.connect_m(s.splitter.in_peek, s.in_peek)
s.connect_m(s.splitter.in_take, s.in_take)
for client in s.interface.clients:
s.connect_m(getattr(s.splitter, '{}_peek'.format(client)),
getattr(s, '{}_peek'.format(client)))
s.connect_m(getattr(s.splitter, '{}_take'.format(client)),
getattr(s, '{}_take'.format(client)))
