Subversion Repositories nocmodel

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
#
# Basic Channel model
#  * TBM 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 channel TBM model
"""
 
from nocmodel.noc_tbm_base import *
 
# ---------------------------
# Channel TBM model
 
class basic_channel_tbm(noc_tbm_base):
    """
    TBM model of a NoC channel. It models a simple FIFO channel with
    adjustable delay. This channel will move any kind of data as a whole, but
    ideally will move packet objects.
 
    Attributes:
    * Channel delay: delay in clock ticks.
 
    Notes:
    *This model is completely behavioral
    """
    def __init__(self, channel_ref, channel_delay=2):
        noc_tbm_base.__init__(self)
        if isinstance(channel_ref, channel):
            self.channel_ref = channel_ref
            self.graph_ref = channel_ref.graph_ref
            self.logname = "Channel '%s'" % channel_ref.name
        else:
            raise TypeError("This class needs a channel object as constructor argument.")
 
        self.debug("constructor")
 
        # channel parameters
        self.channel_delay = channel_delay
 
        # list of router endpoints
        self.endpoints = self.channel_ref.endpoints
 
        # generators
        self.generators = []
 
        self.has_delay = False
        if self.channel_delay > 0:
            self.has_delay = True
            self.delay_fifo = []
            self.delay_fifo_max = 4 # error-catch parameter, avoid fifo excessive growing
            self.delay_event = myhdl.Signal(False)
            # implement delay generator
            @myhdl.instance
            def delay_generator():
                while True:
                    while len(self.delay_fifo) > 0:
                        # extract packet and recorded time
                        timed_packet = self.delay_fifo.pop(0)
                        # calculate the exact delay value
                        next_delay = self.channel_delay - (myhdl.now() - timed_packet[0])
                        # time could be 0, when the packets arrive from both endpoints
                        # at the same time. In that case don't yield
                        if next_delay < 0:
                            self.debug("delay_generator CATCH next_delay is '%d'" % next_delay)
                        elif next_delay > 0:
                            yield myhdl.delay(next_delay)
                        self.debug("delay_generator sending delayed packet (by %d), timed_packet format %s" % (next_delay, repr(timed_packet)) )
                        # use send()
                        retval = self.send(*timed_packet[1:])
                        # what to do in error case? report and continue
                        if retval != noc_tbm_errcodes.no_error:
                            self.error("delay_generator send returns code '%d'?" % retval )
                    self.delay_event.next = False
                    yield self.delay_event.posedge
            self.generators.append(delay_generator)
 
        self.debugstate()
 
    # channel only relays transactions
    # Transaction - related methods
    def send(self, src, dest, packet, addattrs=None):
        """
        This method will be called by recv (no delay) or by delay_generator
        src always is self
        """
        # dest MUST be one of the channel endpoints
        self.debug("-> send( %s , %s , %s , %s )" % (repr(src), repr(dest), repr(packet), repr(addattrs)))
        if isinstance(dest, int):
            # assume router direction
            thedest = self.graph_ref.get_router_by_address(dest)
            if thedest == False:
                self.error("-> send: dest %s not found" % repr(dest) )
                return noc_tbm_errcodes.tbm_badcall_send
        elif isinstance(dest, (router, ipcore)):
            thedest = dest
        else:
            self.error("-> send: what is dest '%s'?" % repr(dest) )
            return noc_tbm_errcodes.tbm_badcall_send
 
        # check dest as one of the channel endpoints
        if thedest not in self.endpoints:
            self.error("-> send: object %s is NOT one of the channel endpoints [%s,%s]" % (repr(thedest), repr(self.endpoints[0]), repr(self.endpoints[1])) )
            return noc_tbm_errcodes.tbm_badcall_send
 
        # call trace functions
        traceargs = {"self": self, "src": src, "dest": dest, "packet": packet, "addattrs": addattrs}
        for f in self.tracesend:
            if callable(f):
                f(traceargs)
 
        # call recv on the dest object
        retval = thedest.tbm.recv(self.channel_ref, dest, packet, addattrs)
 
        # Something to do with the retval? Only report it.
        self.debug("-> send returns code '%s'" % repr(retval))
        return retval
 
    def recv(self, src, dest, packet, addattrs=None):
        """
        receive a packet from an object. src is the object source and
        it MUST be one of the objects in channel endpoints
        """
 
        self.debug("-> recv( %s , %s , %s , %s )" % (repr(src), repr(dest), repr(packet), repr(addattrs)))
        # src can be an address or a noc object.
        if isinstance(src, int):
            # assume router direction
            thesrc = self.graph_ref.get_router_by_address(src)
            if thesrc == False:
                self.error("-> recv: src %s not found" % repr(src) )
                return noc_tbm_errcodes.tbm_badcall_recv
        elif isinstance(src, (router, ipcore)):
            thesrc = src
        else:
            self.error("-> recv: what is src '%s'?" % repr(src) )
            return noc_tbm_errcodes.tbm_badcall_recv
 
        # check src as one of the channel endpoints
        if thesrc not in self.endpoints:
            self.error("-> recv: object %s is NOT one of the channel endpoints [%s,%s]" % (repr(thesrc), repr(self.endpoints[0]), repr(self.endpoints[1])) )
            return noc_tbm_errcodes.tbm_badcall_recv
 
        # call trace functions        
        for f in self.tracerecv:
            if callable(f):
                traceargs = {"self": self, "src": src, "dest": dest, "packet": packet, "addattrs": addattrs}
                f(traceargs)
 
        # calculate the other endpoint
        end_index = self.endpoints.index(thesrc) - 1
 
        if self.has_delay:
            # put in delay fifo: store time and call attributes
            self.delay_fifo.append([myhdl.now(), self.channel_ref, self.endpoints[end_index], packet, addattrs])
            self.debug("-> recv put in delay_fifo (delay %d)" % self.channel_delay)
            # catch growing fifo
            if len(self.delay_fifo) > self.delay_fifo_max:
                self.warning("-> recv: delay_fifo is getting bigger! current size is %d" % len(self.delay_fifo) )
            # trigger event
            self.delay_event.next = True
            retval = noc_tbm_errcodes.no_error
        else:
            # use send() call directly
            router_dest = self.endpoints[end_index]
            retval = self.send(self.channel_ref, router_dest, packet, addattrs)
 
        self.debug("-> recv returns code '%d'", retval)
        return retval