Subversion Repositories nocmodel

#!/usr/bin/env python

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

#

# Basic Router model

#  * TBM model

#  * Code generation model

#

# Author:  Oscar Diaz

# Version: 0.2

# Date:    14-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

# 14-03-2011 : (OD) adding code generation model

#

"""

* Basic router TBM model

* Router code generation model

"""

from nocmodel.noc_tbm_base import *

from nocmodel.noc_codegen_base import *

from intercon_model import *

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

# Router TBM model

class basic_router_tbm(noc_tbm_base):

    """

    TBM 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=5):

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

        self.idlesignal = myhdl.Signal(True)

        # 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:

                        self.idlesignal.next = False

                        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)

                        self.idlesignal.next = False

                        # try to send it

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

                        if retval == noc_tbm_errcodes.no_error:

                            # clean trigger

                            data["fifo_out_event"].next = False

                            self.debug("flush_fifo_out clean trigger. list %s" % repr(self.list_fifo_out_events))

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

                    else:

                        if data["fifo_out_event"].val:

                            self.debug("flush_fifo_out CATCH fifo_out empty and trigger ON! Cleaning trigger")

                            data["fifo_out_event"].next = False

                self.idlesignal.next = True

                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:

                        self.idlesignal.next = False

                        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.idlesignal.next = False

                        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

                    # assuming empty fifo_in

                    if data["fifo_in_event"].val:

                        self.debug("routing_loop CATCH fifo_in empty and trigger ON! Cleaning trigger")

                        data["fifo_in_event"].next = False

                self.idlesignal.next = True

                self.debug("routing_loop idle. fifo_in_events list %s" % repr(self.list_fifo_in_events))

                if not any(self.list_fifo_in_events):

                    yield self.list_fifo_in_events

                else:

                    self.debug("routing_loop pending fifo_in_events list %s" % repr(self.list_fifo_in_events))

                self.debug("routing_loop fifo_in 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_tbm_errcodes.tbm_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_tbm_errcodes.tbm_badcall_send

        # call recv on the dest channel object

        retval = thedest.tbm.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_tbm_errcodes.tbm_badcall_recv

        else:

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

            return noc_tbm_errcodes.tbm_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.")

            self.debug("-> recv: port %s fifo_in contents: %s" % (thesrc, repr(self.ports_info[thesrc]["fifo_in"])))

            return noc_tbm_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.debug("-> recv: CATCH fifo_in_event list %s" % repr(self.list_fifo_in_events))

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

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

        return noc_tbm_errcodes.no_error

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

# Router code generation model

class basic_router_codegen(noc_codegen_ext):

    """

    Code generation extension for Router objects.

    """

    def __init__(self, codegen_ref):

        noc_codegen_ext.__init__(self, codegen_ref)

        self.router_ref = codegen_ref.nocobject_ref

        if not isinstance(self.router_ref, router):

            raise TypeError("Argument must be a 'noc_codegen_base' instance defined for a router object.")

        # router model: This basic router has some parameters put in the 

        # generics list, and a fixed number of NoC ports: 4. 

        # assumptions: use 4 ports 'dualwb_intercon' plus 1 port 'slavewb_intercon'

        codegen_ref.modulename = "basic_4P_router"

        # 1. convert basic attributes to generics

        codegen_ref.add_generic("name", self.router_ref.name, "Router Name")

        codegen_ref.add_generic("address", self.router_ref.address, "Router Address")

        # assuming rectangular layout

        codegen_ref.add_generic("coord_x", self.router_ref.coord_x, "Router X-axis Coord")

        codegen_ref.add_generic("coord_y", self.router_ref.coord_y, "Router Y-axis Coord")

        # 2. Calculate which of 4 ports is used by who

        portinfo = {"N": None, "E": None, "S": None, "W": None}

        for pname, pvalues in self.router_ref.ports.iteritems():

            if pname != self.router_ref.address:

                # check correct intercon

                if not isinstance(pvalues["channel"].ports[self.router_ref.address]["intercon"], dualwb_intercon):

                    raise UserWarning("Port '%d' on router '%s' does not use intercon 'dualwb_intercon'." % (pname, self.router_ref.name))

                # calculate which port

                dx = self.router_ref.coord_x - pvalues["peer"].coord_x

                dy = self.router_ref.coord_y - pvalues["peer"].coord_y

                if dx == 0:

                    if dy > 0:

                        portinfo["S"] = pname

                    else:

                        portinfo["N"] = pname

                if dy == 0:

                    if dx > 0:

                        portinfo["W"] = pname

                    else:

                        portinfo["E"] = pname

            else:

                # check correct intercon

                if not isinstance(pvalues["channel"].ports[self.router_ref.address]["intercon"], slavewb_intercon):

                    raise UserWarning("Port 'Local' on router '%s' does not use intercon 'slavewb_intercon'." % self.router_ref.name)

        icon_ref = dualwb_intercon()

        # 3. Add ports and info through generics

        for pname, pvalue in portinfo.iteritems():

            # add new port

            pstr = "Port%s" % pname

            codegen_ref.add_port(pstr, None, "Port %s" % pname, type=icon_ref.intercon_type, nocport=pvalue)

            for signame, sigval in icon_ref.signals.iteritems():

                stmp = get_new_signal(

                    name=signame,

                    direction=sigval["direction"],

                    default_value=intbv(0)[sigval["width"]:],

                    description=sigval["description"])

                codegen_ref.add_port(pstr, stmp)

            # determine if the port is used

            if pvalue is None:

                penable = 0

                paddr = 0

            else:

                penable = 1

                paddr = pvalue

            codegen_ref.add_generic("Use_Port%s" % pname, penable, "Is Port%s being used?" % pname)

            codegen_ref.add_generic("Dest_Port%s" % pname, paddr, "Dest address in Port%s" % pname)

        # 4. Local port

        icon_ref = slavewb_intercon()

        codegen_ref.add_port("PortLocal", None, "Port Local", type=icon_ref.intercon_type)

        for signame, sigval in icon_ref.signals.iteritems():

            stmp = get_new_signal(

                name=signame,

                direction=sigval["direction"],

                default_value=intbv(0)[sigval["width"]:],

                description=sigval["description"])

            codegen_ref.add_port("PortLocal", stmp)

        # 5. Calculate a hash with generics and ports info. This hash will help 

        # codegen to establish equivalent router implementations.

        codegen_ref.model_hash()

        # 6. Implementation comment

        codegen_ref.implementation += "-- Add here implementation code for Router %s" % self.router_ref.name