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)))