Subversion Repositories nocmodel

#!/usr/bin/env python

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

#

# Basic IPcore 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 ipcore TBM model

* Ipcore code generation model

"""

from nocmodel.noc_tbm_base import *

from nocmodel.noc_codegen_base import *

from intercon_model import *

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

# Basic IPCore TBM model

class basic_ipcore_tbm(noc_tbm_base):

    """

    TBM model of a NoC ipcore. Its based on sending and receiving packets

    to a custom-based MyHDL generators. This class does not define any

    functionality.

    Attributes:

    * ipcore_ref: reference to ipcore base object

    Notes:

    * This model is completely behavioral.

    * See code comments to better understanding.

    """

    def __init__(self, ipcore_ref):

        noc_tbm_base.__init__(self)

        if isinstance(ipcore_ref, ipcore):

            self.ipcore_ref = ipcore_ref

            self.graph_ref = ipcore_ref.graph_ref

            self.logname = "IPCore '%s'" % ipcore_ref.name

            if ipcore_ref.name == "":

                self.logname = "IPCore '%s'" % ipcore_ref.router_ref.name

        else:

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

        self.debug("constructor")

        # generic parameters

        self.retrytimes = 3

        self.retrydelay = 2

        # one-port support: get a reference to the related channel

        self.localch = self.ipcore_ref.channel_ref

        # get protocol reference

        self.protocol_ref = self.ipcore_ref.get_protocol_ref()

        # bidirectional port: the sender part will write data to the signal 

        # outgoing_packet. This class provides a generator thar call send() 

        # method when there is new data. 

        # for receiving data, recv() method will write

        # to the signal incoming_packet, and the ipcore must provide a generator 

        # sensible to that signal. Use the method register_generator()

        self.incoming_packet = myhdl.Signal(packet())

        self.outgoing_packet = myhdl.Signal(packet())

        @myhdl.instance

        def outgoing_process():

            while True:

                yield self.outgoing_packet

                # multiple tries

                for i in range(self.retrytimes):

                    retval = self.send(self.ipcore_ref, self.localch, self.outgoing_packet.val)

                    if retval == noc_tbm_errcodes.no_error:

                        break;

                    yield myhdl.delay(self.retrydelay)

        self.generators = [outgoing_process]

        self.debugstate()

    def register_generator(self, genfunction, **kwargs):

        """

        Register a new generator for this ipcore.

        Arguments:

        * genfunction: function that returns a MyHDL generator

        * kwargs: optional keyed arguments to pass to genfunction call

        Notes:

        * This method requires that genfunction has the following prototype:

            * my_function(din, dout, tbm_ref, <other_arguments>)

                * din is a MyHDL Signal of type packet, and is the input signal

                  to the ipcore. Use this signal to react to input events and

                  receive input packets.

                * dout is a MyHDL Signal of type packet, and is the output

                  signal to the ipcore. Use this signal to send out packets to

                  local channel (and then insert into the NoC).

                * tbm_ref is a reference to an object with logging methods.

                  (e.g. tbm_ref.info("message") ).

                * <other_arguments> may be defined, this method use kwargs

                  argument to pass them.

        """

        makegen = genfunction(din=self.incoming_packet, dout=self.outgoing_packet, tbm_ref=self, **kwargs)

        self.debug("register_generator( %s ) generator is %s args %s" % (repr(genfunction), repr(makegen), repr(kwargs)))

        self.generators.append(makegen)

    # Transaction - related methods

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

        """

        Assumptions:

        * Safely ignore src and dest arguments, because this method

          is called only by this object generators, therefore it always send

          packets to the ipcore related channel.

        * In theory src should be self.ipcore_ref, and dest should be

          self.localch . This may be checked for errors.

        """

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

        # call recv on the local channel object

        retval = self.localch.tbm.recv(self.ipcore_ref, self.localch, 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):

        """

        Assumptions:

        * Safely ignore src and dest arguments, because this method

          is called only by local channel object.

        * In theory src should be self.localch, and dest should be

          self.ipcore_ref . This may be checked for errors.

        """

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

        # update signal

        self.incoming_packet.next = packet

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

        return noc_tbm_errcodes.no_error

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

# Ipcore code generation model

class basic_ipcore_codegen(noc_codegen_ext):

    """

    Code generation extension for Ipcore objects.

    """

    def __init__(self, codegen_ref):

        noc_codegen_ext.__init__(self, codegen_ref)

        #self.codegen_ref = codegen_ref

        self.ipcore_ref = codegen_ref.nocobject_ref

        if not isinstance(self.ipcore_ref, ipcore):

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

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

        # generics list, and only one port of type masterwb.

        codegen_ref.modulename = "basic_ipcore"

        # 1. convert some attributes to generics

        codegen_ref.add_generic("name", self.ipcore_ref.name, "Ipcore Name")

        codegen_ref.add_generic("address", self.ipcore_ref.router_ref.address, "Ipcore router Address")

        # 2. check intercon on ipcore port

        ch = self.ipcore_ref.channel_ref

        icon = ch.ports[None]["intercon"]

        if not isinstance(icon, masterwb_intercon):

            raise UserWarning("Port Local on ipcore '%s' does not use intercon 'masterwb_intercon'." % self.ipcore_ref.name)

        # 2. convert ipcore port to codegen port

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

        for signame, sigval in icon.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)

        # 3. Calculate a Hash with generics and ports info. 

        # WARNING: You must recalculate the hash when you change the model!

        codegen_ref.model_hash()

        # 4. Implementation comment

        codegen_ref.implementation += "-- Add here implementation code for Ipcore %s" % self.ipcore_ref.name

    def add_external_signal(self, name, direction, value, description="", **kwargs):

        """

        Wrapper to noc_codegen_base.add_external_signal method, to support hash

        updating.

        """

        retval = self.codegen_ref.add_external_signal(name, direction, value, description, **kwargs)

        self.codegen_ref.model_hash()

        return retval