Beispiel #1
0
    def __init__(s,
                 MapperPRTL,
                 src_msgs,
                 sink_msgs,
                 src_delay,
                 sink_delay,
                 dump_vcd=False,
                 test_verilog=False):

        # Instantiate Models
        s.src = TestSource(MapperReqMsg(), src_msgs, src_delay)
        s.mapper = MapperPRTL()
        s.sink = TestSink(MapperRespMsg(), sink_msgs, sink_delay)

        # Dump VCD
        if dump_vcd:
            s.mapper.vcd_file = dump_vcd

        # Translation
        if test_verilog:
            s.mapper = TranslationTool(s.mapper)

        # Connect
        s.connect(s.src.out, s.mapper.req)
        s.connect(s.mapper.resp, s.sink.in_)
    def __init__(s, nbits=8, mbits=1):

        # Interface
        s.req = InValRdyBundle(MapperReqMsg())
        s.resp = OutValRdyBundle(MapperRespMsg())

        # Instantiate datapath and control
        s.dpath = MapperDpathRTL(nbits, mbits)
        s.ctrl = MapperCtrlRTL(mbits)

        # connect input interface to dpath/ctrl
        s.connect(s.req.msg.data, s.dpath.req_msg_data)

        s.connect(s.req.msg.type_, s.ctrl.req_msg_type)
        s.connect(s.req.val, s.ctrl.req_val)
        s.connect(s.resp.rdy, s.ctrl.resp_rdy)

        # connect dpath/ctrl to output interface
        s.connect(s.dpath.resp_msg_data, s.resp.msg.data)

        s.connect(s.ctrl.resp_msg_type, s.resp.msg.type_)
        s.connect(s.ctrl.req_rdy, s.req.rdy)
        s.connect(s.ctrl.resp_val, s.resp.val)

        # connect dpath/ctrl
        s.connect(s.ctrl.result_reg_en, s.dpath.result_reg_en)
        s.connect(s.ctrl.reference_reg_en, s.dpath.reference_reg_en)
    def __init__(s):

        s.req = InValRdyBundle(MapperReqMsg())
        s.resp = OutValRdyBundle(MapperRespMsg())

        s.dpath = MapperDpath()
        s.ctrl = MapperCtrl()

        s.connect(s.req.msg.data, s.dpath.req_msg_data)
        s.connect(s.req.msg.digit, s.dpath.req_msg_digit)
        s.connect(s.req.msg.type_, s.dpath.req_msg_type)
        s.connect(s.req.msg.type_, s.ctrl.req_msg_type)
        s.connect(s.req.val, s.ctrl.req_val)
        s.connect(s.req.rdy, s.ctrl.req_rdy)

        s.connect(s.dpath.resp_msg_data, s.resp.msg.data)
        s.connect(s.dpath.resp_msg_digit, s.resp.msg.digit)
        s.connect(s.dpath.resp_msg_type, s.resp.msg.type_)
        s.connect(s.ctrl.resp_val, s.resp.val)
        s.connect(s.ctrl.resp_rdy, s.resp.rdy)

        s.connect_auto(s.dpath, s.ctrl)
Beispiel #4
0
def mk_resp_msg(data, type, digit):
    msg = MapperRespMsg()
    msg.data = data
    msg.type_ = type
    msg.digit = digit
    return msg
Beispiel #5
0
    def __init__(s, mapper_num=2, reducer_num=1):

        # Top Level Interface
        s.in_ = InValRdyBundle(WordcountReqMsg())
        s.out = OutValRdyBundle(WordcountRespMsg())
        s.reference = InPort(32)
        s.base = InPort(32)
        s.size = InPort(32)

        # Global Memory Interface
        s.gmem_req = OutValRdyBundle(MemReqMsg(8, 32, 32))
        s.gmem_resp = InValRdyBundle(MemRespMsg(8, 32))

        # Local Memory Interface
        s.lmem_req = OutValRdyBundle(MemReqMsg(8, 32, 32))
        s.lmem_resp = InValRdyBundle(MemRespMsg(8, 32))

        # Mapper Interface
        s.map_req = OutValRdyBundle[mapper_num](MapperReqMsg())
        s.map_resp = InValRdyBundle[mapper_num](MapperRespMsg())

        # Reducer Interface
        s.red_req = OutValRdyBundle[reducer_num](ReducerReqMsg())
        s.red_resp = InValRdyBundle[reducer_num](ReducerRespMsg())

        # Task Queue
        s.task_queue = NormalQueue(2, Bits(32))

        # Idle Queue storing mapper ID
        s.idle_queue = NormalQueue(2, Bits(2))

        # States
        s.STATE_IDLE = 0  # Idle state, scheduler waiting for top level to start
        s.STATE_SOURCE = 1  # Source state, handling with Test Source, getting base, size, ref info
        s.STATE_INIT = 2  # Init state, scheduler assigns input info to each Mapper
        s.STATE_START = 3  # Start state, scheduler starts scheduling
        s.STATE_END = 4  # End state, shceduler loads all task from global memory and it is done

        s.state = RegRst(4, reset_value=s.STATE_IDLE)

        # Counters
        s.init_count = Wire(2)
        s.input_count = Wire(32)

        @s.tick
        def counter():
            if (s.idle_queue.enq.val and s.init):
                s.init_count.next = s.init_count + 1
            if (s.gmem_req.val):
                s.input_count.next = s.input_count + 1

        # Signals
        s.go = Wire(1)  # go signal tells scheduler to start scheduling
        s.mapper_done = Wire(1)  # if one or more mapper is done and send resp
        s.init = Wire(1)  # init signal indicates scheduler at initial state
        s.end = Wire(1)  # end signal indicates all task are loaded
        s.done = Wire(1)  # done signal indicates everything is done
        s.num_task_queue = Wire(2)

        s.connect(s.task_queue.num_free_entries, s.num_task_queue)

        @s.combinational
        def logic():
            s.mapper_done.value = s.map_resp[0].val | s.map_resp[1].val

        #---------------------------------------------------------------------
        # Assign Task to Mapper Combinational Logic
        #---------------------------------------------------------------------

        @s.combinational
        def mapper():

            # initialize mapper req and resp handshake signals
            for i in xrange(mapper_num):
                s.map_req[i].val.value = 0
            s.task_queue.deq.rdy.value = 0
            s.idle_queue.deq.rdy.value = 0

            if s.init:
                s.map_req[s.init_count].msg.data.value = s.reference
                s.map_req[s.init_count].msg.type_.value = 1
                s.map_req[s.init_count].val.value = 1
                s.idle_queue.enq.msg.value = s.init_count
                s.idle_queue.enq.val.value = 1
            else:
                # assign task to mapper if task queue is ready to dequeue
                # idle queue is ready to dequeue and mapper is ready to take request
                if (s.task_queue.deq.val and s.idle_queue.deq.val
                        and s.map_req[s.idle_queue.deq.msg].rdy):
                    s.map_req[s.idle_queue.deq.
                              msg].msg.data.value = s.task_queue.deq.msg[0:8]
                    s.map_req[s.idle_queue.deq.msg].msg.type_.value = 0
                    s.map_req[s.idle_queue.deq.msg].val.value = 1
                    s.task_queue.deq.rdy.value = 1
                    s.idle_queue.deq.rdy.value = 1

        #---------------------------------------------------------------------
        # Send Mapper Resp to Reducer Combinational Logic
        #---------------------------------------------------------------------

        @s.combinational
        def reducer():

            # initialize mapper and reducer handshake signals
            for i in xrange(mapper_num):
                s.map_resp[i].rdy.value = 0
            for i in xrange(reducer_num):
                s.red_req[i].val.value = 0
            #s.idle_queue.enq.val.value = 0

            # get the mapper response, assign the response to reducer
            if (s.mapper_done):

                # Check each mapper response, add it to idle queue, send its response
                # to Reducer, mark its response ready
                for i in xrange(mapper_num):
                    if (s.map_resp[i].val):
                        if ~s.init:
                            if s.idle_queue.enq.rdy:
                                s.idle_queue.enq.msg.value = i
                                s.idle_queue.enq.val.value = 1
                            if s.red_req[0].rdy:
                                if s.end and s.num_task_queue == 2:
                                    s.red_req[0].msg.data.value = s.map_resp[
                                        i].msg.data
                                    s.red_req[0].msg.type_.value = 1
                                    s.red_req[0].val.value = 1
                                    s.done.value = 1
                                else:
                                    s.red_req[0].msg.data.value = s.map_resp[
                                        i].msg.data
                                    s.red_req[0].msg.type_.value = 0
                                    s.red_req[0].val.value = 1
                        s.map_resp[i].rdy.value = 1
                        break

        #---------------------------------------------------------------------
        # Task State Transition Logic
        #---------------------------------------------------------------------

        @s.combinational
        def state_transitions():

            curr_state = s.state.out
            next_state = s.state.out

            if (curr_state == s.STATE_IDLE):
                if (s.in_.val):
                    next_state = s.STATE_SOURCE

            if (curr_state == s.STATE_SOURCE):
                if (s.go):
                    next_state = s.STATE_INIT
                elif (s.done and s.red_resp[0].val):
                    next_state = s.STATE_IDLE

            if (curr_state == s.STATE_INIT):
                if (s.init_count == mapper_num - 1):
                    next_state = s.STATE_START

            if (curr_state == s.STATE_START):
                if (s.input_count == s.size - 1):
                    next_state = s.STATE_END

            if (curr_state == s.STATE_END):
                if (s.done):
                    next_state = s.STATE_SOURCE

            s.state.in_.value = next_state

        #---------------------------------------------------------------------
        # Task State Output Logic
        #---------------------------------------------------------------------

        @s.combinational
        def state_outputs():

            current_state = s.state.out
            s.gmem_req.val.value = 0
            s.gmem_resp.rdy.value = 0
            s.in_.rdy.value = 0
            s.out.val.value = 0
            s.task_queue.enq.val.value = 0

            # In IDLE state
            if (current_state == s.STATE_IDLE):
                s.init_count.value = 0
                s.input_count.value = 0
                s.end.value = 0
                s.go.value = 0
                s.init.value = 0
                s.done.value = 0
                if s.in_.val:
                    if (s.in_.msg.addr == 1):
                        s.base.value = s.in_.msg.data
                    s.in_.rdy.value = 1
                    s.out.msg.type_.value = WordcountReqMsg.TYPE_WRITE
                    s.out.msg.data.value = 0
                    s.out.val.value = 1

            #In SOURCE state
            if (current_state == s.STATE_SOURCE):
                if (s.in_.val and s.out.rdy):
                    if (s.in_.msg.type_ == WordcountReqMsg.TYPE_WRITE):
                        if (s.in_.msg.addr == 0):
                            s.go.value = 1
                        elif (s.in_.msg.addr == 2):
                            s.size.value = s.in_.msg.data
                        elif (s.in_.msg.addr == 3):
                            s.reference.value = s.in_.msg.data
                        # Send xcel response message
                        s.in_.rdy.value = 1
                        s.out.msg.type_.value = WordcountReqMsg.TYPE_WRITE
                        s.out.msg.data.value = 0
                        s.out.val.value = 1

                    elif (s.in_.msg.type_ == WordcountReqMsg.TYPE_READ):
                        if (s.done and s.red_resp[0].val):

                            s.out.msg.type_.value = WordcountReqMsg.TYPE_READ
                            s.out.msg.data.value = s.red_resp[0].msg.data
                            s.red_resp[0].rdy.value = 1
                            s.in_.rdy.value = 1
                            s.out.val.value = 1

            # In INIT state
            if (current_state == s.STATE_INIT):

                s.init.value = 1
                s.go.value = 0

                # at the last 2 cycle of init, send read req to global memory
                if s.init_count == mapper_num - 2:
                    if s.gmem_req.rdy:
                        s.gmem_req.msg.addr.value = s.base + (4 *
                                                              s.input_count)
                        s.gmem_req.msg.type_.value = TYPE_READ
                        s.gmem_req.val.value = 1

                # at the last cycle of init, receive read resp to global memory, put it in task queue
                # send another read req to global memory
                if s.init_count == mapper_num - 1:
                    if s.gmem_resp.val and s.gmem_req.rdy:
                        s.task_queue.enq.msg.value = s.gmem_resp.msg
                        s.task_queue.enq.val.value = 1
                        s.gmem_resp.rdy.value = 1
                        s.gmem_req.msg.addr.value = s.base + (4 *
                                                              s.input_count)
                        s.gmem_req.msg.type_.value = TYPE_READ
                        s.gmem_req.val.value = 1

            # In START state
            if (current_state == s.STATE_START):

                s.init.value = 0

                if s.gmem_resp.val and s.gmem_req.rdy:
                    s.task_queue.enq.msg.value = s.gmem_resp.msg
                    s.task_queue.enq.val.value = 1
                    s.gmem_resp.rdy.value = 1
                    s.gmem_req.msg.addr.value = s.base + (4 * s.input_count)
                    s.gmem_req.msg.type_.value = TYPE_READ
                    s.gmem_req.val.value = 1

            # In END state
            if (current_state == s.STATE_END):
                if s.gmem_resp.val:
                    s.task_queue.enq.msg.value = s.gmem_resp.msg
                    s.task_queue.enq.val.value = 1
                    s.gmem_resp.rdy.value = 1
                    s.end.value = 1
Beispiel #6
0
def mk_resp_msg(data, type):
    msg = MapperRespMsg()
    msg.data = data
    msg.type_ = type
    return msg
def mk_resp_msg(data, type):
    msg = MapperRespMsg()
    msg.data = data
    msg.type_ = type
    return msg
def mk_resp_msg( data, type, digit ):
  msg       = MapperRespMsg()
  msg.data  = data
  msg.type_ = type
  msg.digit = digit
  return msg