Subversion Repositories nocmodel

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

# Basic Router model

#  * TLM model

#

# Author:  Oscar Diaz

# Version: 0.1

# Date:    03-03-2011

#

# This code is free software; you can redistribute it and/or

# modify it under the terms of the GNU Lesser General Public

# License as published by the Free Software Foundation; either

# version 2.1 of the License, or (at your option) any later version.

#

# This code is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# Lesser General Public License for more details.

#

# You should have received a copy of the GNU Lesser General Public

# License along with this library; if not, write to the

# Free Software  Foundation, Inc., 59 Temple Place, Suite 330,

# Boston, MA  02111-1307  USA

#

#

# Changelog:

#

# 03-03-2011 : (OD) initial release

#

"""

Basic router TLM model

"""

from nocmodel.noc_tlm_base import *

# ---------------------------

# Router TLM model

class basic_router_tlm(noc_tlm_base):

    """

    TLM model of a NoC router. This router uses store-and-forward technique,

    using the routing information from the router object. This model just

    forward the packet, and if the packet is in its router destination, send it

    to its ipcore. Each package that the ipcore generates is delivered

    automátically.

    Attributes:

    * router_ref : base reference

    * fifo_len: max number of packets to hold in each port

    Notes:

    * This model is completely behavioral.

    * See code comments to better understanding.

    """

    def __init__(self, router_ref, fifo_len=4):

        noc_tlm_base.__init__(self)

        if isinstance(router_ref, router):

            self.router_ref = router_ref

            self.graph_ref = router_ref.graph_ref

            self.logname = "Router '%s'" % router_ref.name

            if router_ref.name == "":

                self.logname = "Router addr '%s'" % router_ref.address

        else:

            raise TypeError("This class needs a router object as constructor argument.")

        self.debug("constructor")

        # generic parameters

        self.fifo_len = fifo_len

        # delay parameters

        self.delay_route = 5        # delay for each routing decisition

        self.delay_outfromfifo = 2  # delay for extract packet from fifo to output port

        self.delay_ipcorebus = 1    # delay for ipcore local bus operations

        # router parameters (Assume rectangular coords)

        self.myaddress = router_ref.address

        self.mynodecoord = (router_ref.coord_x, router_ref.coord_y)

        # port additions: use a copy of the ports list, and add

        # fifo storage and signal events

        router_ref.update_ports_info()

        self.ports_info = router_ref.ports.copy()

        for p in self.ports_info.itervalues():

            p["fifo_in"] = []

            p["fifo_out"] = []

            p["fifo_in_event"] = myhdl.Signal(False)

            p["fifo_out_event"] = myhdl.Signal(False)

        # extract a list of all fifo event signals

        self.list_fifo_in_events = [i["fifo_in_event"] for i in self.ports_info.itervalues()]

        self.list_fifo_out_events = [i["fifo_out_event"] for i in self.ports_info.itervalues()]

        # the routing table is generated from the routes_info dict

        # key: its destination address

        # values: a list of ports where the package should send it. First element

        #    is the default option, next elements are alternate routes

        router_ref.update_routes_info()

        self.detailed_routingtable = self.router_ref.routes_info.copy()

        self.routingtable = {}

        for dest, data in self.detailed_routingtable.iteritems():

            self.routingtable[dest] = [x["next"] for x in data]

        # add route to myself

        self.routingtable[self.myaddress] = [self.myaddress]

        # log interesting info

        self.info(" router params: fifo_len=%d" % self.fifo_len)

        self.info(" router info: addr=%d coord=%s" % (self.myaddress, repr(self.mynodecoord)))

        self.info(" router ports: %s" % repr(self.ports_info))

        self.info(" router routing table: %s" % repr(self.routingtable))

        # myhdl generators (concurrent processes)

        self.generators = []

        # fifo out process

        @myhdl.instance

        def flush_fifo_out():

            while True:

                for port, data in self.ports_info.iteritems():

                    if len(data["fifo_out"]) > 0:

                        if not data["fifo_out_event"].val:

                            self.debug("flush_fifo_out CATCH fifo not empty and NO trigger! fifo has %s" % repr(data["fifo_out"]))

                        self.info("flush_fifo_out event in port %d" % port)

                        packet = data["fifo_out"].pop(0)

                        self.debug("flush_fifo_out port %d packet is %s (delay %d)" % (port, repr(packet), self.delay_outfromfifo))

                        # DELAY model: time to move from fifo to external port in destination object

                        yield myhdl.delay(self.delay_outfromfifo)

                        # try to send it

                        retval = self.send(self.router_ref, data["channel"], packet)

                        if retval == noc_tlm_errcodes.no_error:

                            # clean trigger

                            data["fifo_out_event"].next = False

                            #continue

                        else:

                            self.error("flush_fifo_out FAILED in port %d (code %d)" % (port, retval))

                            # error management: 

                            #TODO: temporally put back to fifo

                            self.info("flush_fifo_out packet went back to fifo.")

                            data["fifo_out"].append(packet)

                yield self.list_fifo_out_events

                self.debug("flush_fifo_out event hit. list %s" % repr(self.list_fifo_out_events))

        # routing loop

        @myhdl.instance

        def routing_loop():

            while True:

                # routing update: check all fifos

                for port, data in self.ports_info.iteritems():

                    while len(data["fifo_in"]) > 0:

                        if not data["fifo_in_event"].val:

                            self.debug("routing_loop CATCH fifo not empty and NO trigger! fifo has %s" % repr(data["fifo_in"]))

                        self.info("routing_loop fifo_in event in port %d" % port)

                        # data in fifo

                        packet = data["fifo_in"].pop(0)

                        data["fifo_in_event"].next = False

                        self.debug("routing_loop port %d packet %s to ipcore (delay %d)" % (port, repr(packet), self.delay_route))

                        # destination needed. extract from routing table

                        destaddr = packet["dst"]

                        self.debug("routing_loop port %d routingtable %s (dest %d)" % (port, repr(self.routingtable), destaddr))

                        nextaddr = self.routingtable[destaddr][0]

                        self.debug("routing_loop port %d to port %s (dest %d)" % (port, nextaddr, destaddr))

                        # DELAY model: time spent to make a route decisition

                        yield myhdl.delay(self.delay_route)

                        self.ports_info[nextaddr]["fifo_out"].append(packet)

                        # fifo trigger

                        if self.ports_info[nextaddr]["fifo_out_event"]:

                            self.debug("routing_loop CATCH possible miss event because port %d fifo_out_event=True", self.myaddress)

                        self.ports_info[nextaddr]["fifo_out_event"].next = True

                yield self.list_fifo_in_events

                self.debug("routing_loop event hit. list %s" % repr(self.list_fifo_in_events))

        # list of all generators

        self.generators.extend([flush_fifo_out, routing_loop])

        self.debugstate()

    # Transaction - related methods

    def send(self, src, dest, packet, addattrs=None):

        """

        This method will be called on a fifo available data event

        Notes:

        * Ignore src object.

        * dest should be a channel object, but also can be a router address or

          a router object.

        """

        self.debug("-> send( %s , %s , %s , %s )" % (repr(src), repr(dest), repr(packet), repr(addattrs)))

        if isinstance(dest, int):

            # it means dest is a router address

            therouter = self.graph_ref.get_router_by_address(dest)

            if therouter == False:

                self.error("-> send: dest %s not found" % repr(dest) )

                return noc_tlm_errcodes.tlm_badcall_send

            # extract channel ref from ports_info

            thedest = self.ports_info[therouter.address]["channel"]

        elif isinstance(dest, router):

            # extract channel ref from ports_info

            thedest = self.ports_info[dest.address]["channel"]

        elif isinstance(dest, channel):

            # use it directly

            thedest = dest

        else:

            self.error("-> send: what is dest '%s'?" % repr(dest) )

            return noc_tlm_errcodes.tlm_badcall_send

        # call recv on the dest channel object

        retval = thedest.tlm.recv(self.router_ref, thedest, packet, addattrs)

        # TODO: something to do with the retval?

        self.debug("-> send returns code '%s'" % repr(retval))

        return retval

    def recv(self, src, dest, packet, addattrs=None):

        """

        This method will be called by channel objects connected to this router.

        Notes:

        * The recv method only affect the receiver FIFO sets

        * Ignore dest object.

        """

        self.debug("-> recv( %s , %s , %s , %s )" % (repr(src), repr(dest), repr(packet), repr(addattrs)))

        # src can be an address or a noc object.

        # convert to addresses

        if isinstance(src, int):

            thesrc = src

        elif isinstance(src, router):

            thesrc = src.address

        elif isinstance(src, channel):

            # get address from the other end. Use the endpoints to calculate

            # source router

            src_index = src.endpoints.index(self.router_ref) - 1

            theend = src.endpoints[src_index]

            if isinstance(theend, router):

                thesrc = theend.address

            elif isinstance(theend, ipcore):

                thesrc = theend.router_ref.address

            else:

                self.error("-> recv: what is endpoint '%s' in channel '%s'?" % (repr(theend), repr(src)) )

                return noc_tlm_errcodes.tlm_badcall_recv

        else:

            self.error("-> recv: what is src '%s'?" % repr(src) )

            return noc_tlm_errcodes.tlm_badcall_recv

        # thesrc becomes the port number

        # check if there is enough space on the FIFO

        if len(self.ports_info[thesrc]["fifo_in"]) == self.fifo_len:

            # full FIFO

            self.error("-> recv: full fifo. Try later.")

            return noc_tlm_errcodes.full_fifo

        # get into fifo

        self.ports_info[thesrc]["fifo_in"].append(packet)

        # trigger a new routing event

        if self.ports_info[thesrc]["fifo_in_event"].val:

            self.debug("-> recv: CATCH possible miss event because in port %d fifo_in_event=True", thesrc)

        self.ports_info[thesrc]["fifo_in_event"].next = True

        self.debug("-> recv returns 'noc_tlm_errcodes.no_error'")

        return noc_tlm_errcodes.no_error