Subversion Repositories nocmodel

#!/usr/bin/env python

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

#

# NoC TBM simulation support

#   This module declares classes for Transaction Based Model simulation

#

# Author:  Oscar Diaz

# Version: 0.2

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

#

"""

===============================

NoCmodel TBM simulation support

===============================

This module declares classes for Transaction Based Model simulation

* Class 'noc_tbm_base'

* Class 'noc_tbm_simulation'

* Class 'noc_tbm_errcodes'

"""

import networkx as nx

import myhdl

import logging

from noc_base import *

import inspect

class noc_tbm_base():

    """

    Base class for NoC TBM simulator.

    This class add methods to a NoC object, required for the TBM model. Each

    derived class must override the methods:

    * __init__() : its constructor contains the object TBM model (data

      structures, generators, etc).

    * send()

    * recv()

    Other methods are related to simulation configuration and logging support.

    """

    def __init__(self):

        self.log = logging.getLogger()

        self.logname = "BASECLASS"

        self.generators = []

        self.tracesend = []

        self.tracerecv = []

    def __repr__(self):

        if self.logname != "":

            return "<%s '%s'>" % (self.__class__.__name__, self.logname)

        else:

            return "<%s at '%d'>" % (self.__class__.__name__, id(self))

    def get_generators(self):

        return self.generators

    def _do_build_generators(self):

        self.generators.extend(self.build_generators())

    # TBM main: every object must define this functions

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

        """

        SEND method: this method MUST be called only by the local

        object who wants to start a transaction.

        This function will call the recv method in the right object.

        Arguments:

        * src: source object (or router address) that call this method, i.e. the

          object that starts the transaction.

        * dest: destination object (or router address) that receive the data in

          the transaction. This method will call dest' recv method.

        * data: data to be sent. Can be anything, but normally is an object of

          type packet.

        * addattrs: optional dictionary with additional arguments

        Return: Must return a number: 0 for everything OK, != 0 to show an error

            relevant to the caller, an exception in case of attribute error

        """

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

        return noc_tbm_errcodes.not_implemented

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

        """

        RECV method: this method MUST be called only by the send

        method of the object who started the transaction.

        Arguments:

        * src: source object (or router address) that call this method, i.e. the

          object that starts the transaction.

        * dest: destination object (or router address) that receive the data in

          the transaction. This method will call dest' recv method.

        * data: data to be sent. Can be anything, but normally is an object of

          type packet.

        * addattrs: optional dictionary with additional arguments

        @return Must return a number: 0 for everything OK, != 0 to show an error

            relevant to the caller, an exception in case of attribute error

        """

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

        return noc_tbm_errcodes.not_implemented

    # logging methods (only use 4 levels)

    def debug(self, msg, *args, **kwargs):

        self.log.debug(msg, extra={"objname": self.logname}, *args, **kwargs)

    def info(self, msg, *args, **kwargs):

        self.log.info(msg, extra={"objname": self.logname}, *args, **kwargs)

    def warning(self, msg, *args, **kwargs):

        self.log.warning(msg, extra={"objname": self.logname}, *args, **kwargs)

    def error(self, msg, *args, **kwargs):

        self.log.error(msg, extra={"objname": self.logname}, *args, **kwargs)

    # special log

    def debugstate(self):

        self.debug(" '%s' object state: " % repr(self))

        for i in dir(self):

            # exclude hidden attributes

            if i[0] == "_":

                continue

            self.debug("     ['%s'] = %s " % (i, repr(getattr(self, i))))

    def generators_info(self):

        self.debug(" Registered generators for '%s': " % repr(self))

        for g in self.generators:

            self.debug("     '%s': %s" % (getattr(g, "name", "-GEN-"), repr(g)))

class noc_tbm_simulation():

    """

    NoC TBM simulator object

    This class manages the MyHDL simulation on a NoC object and its logging

    support.

    Attributes:

    * noc_ref: reference to NoC model to simulate

    * log_file: optional file to save the simulation log

    * log_level: optional logging level for the previous file

    * kwargs: optional attributes to add to this object

    """

    def __init__(self, noc_ref, log_file=None, log_level=logging.INFO, **kwargs):

        if isinstance(noc_ref, noc):

            self.noc_ref = noc_ref

        else:

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

        # configure logging system

        # log errors to console, custom log to log_file if specified

        addmsg = ""

        self.log = logging.getLogger()

        self.log.setLevel(log_level)

        console_hdl = logging.StreamHandler()

        console_hdl.setLevel(logging.WARNING)

        class SimTimeFilter(logging.Filter):

            def filter(self, record):

                record.myhdltime = myhdl.now()

                return True

        self.log.addFilter(SimTimeFilter())

        self.noc_formatter = logging.Formatter("%(myhdltime)4d:%(levelname)-5s:%(objname)-16s - %(message)s")

        console_hdl.setFormatter(self.noc_formatter)

        self.log.addHandler(console_hdl)

        if log_file != None:

            file_hdl = logging.FileHandler(log_file, 'w')

            file_hdl.setLevel(log_level)

            file_hdl.setFormatter(self.noc_formatter)

            self.log.addHandler(file_hdl)

            addmsg = "and on file (%s) level %s" % (log_file, logging._levelNames[log_level])

        # ready to roll

        self.debug("Logging enabled! Running log on console level WARNING %s" % addmsg)

    def configure_simulation(self, max_time=None, add_generators=[]):

        """

        Configure MyHDL simulation.

        Arguments:

        * max_time: optional max time to simulate. None means simulation

          without time limit.

        * add_generators: external MyHDL generators to add to the simulation

        """

        # myhdl simulation: extract all generators and prepare 

        # arguments

        for obj in self.noc_ref.all_list():

            prevcount = len(add_generators)

            add_generators.extend(obj.tbm.get_generators())

            #self.debug("configure_simulation: adding %d generators from object %s" % (len(add_generators)-prevcount, repr(obj)))

            if isinstance(obj, ipcore):

                add_generators.extend(obj.channel_ref.tbm.get_generators())

                #self.debug("configure_simulation: plus ipcore channel: adding %d generators from object %s" % (len(add_generators)-prevcount, repr(obj.channel_ref)))

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

        # debug info

        # TODO: try to get info about generators, particularly obtain origin 

        # info about @always and @always_comb generators

        #self.debug("configure_simulation: list of generators: (count = %d)" % len(add_generators))

        #for genl in add_generators:

            #if not isinstance(genl, list):

                #gen2 = [genl]

            #else:

                #gen2 = genl

                #self.debug("configure_simulation:   generator list '%s'" % repr(genl))

            #for gen in gen2:

                #self.debug("configure_simulation:   generator '%s'" % repr(gen))

                #try:

                    #self.debug("configure_simulation:   inspect info name '%s'" % gen.gen.__name__)

                    #self.debug("configure_simulation:   inspect info locals '%s'" % repr(gen.gen.gi_frame.f_locals.keys()))

                    #for k, v in gen.gen.gi_frame.f_locals.iteritems():

                        #self.debug("configure_simulation:   inspect info locals[%s] '%s'" % (k, repr(v)))

                    #if gen.gen.__name__ == "genfunc":

                        #self.debug("configure_simulation:   inspect info deep name '%s'" % gen.func.__name__)

                #except:

                    #pass

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

        self.sim_object = myhdl.Simulation(*add_generators)

        self.sim_duration = max_time

        self.debug("configure_simulation: will run until simulation time '%d'" % max_time)

    def run(self):

        """

        Run MyHDL simulation

        """

        self.debug("Start simulation")

        self.sim_object.run(self.sim_duration)

        self.debug("End simulation")

    # custom logging methods (only use 4 levels)

    def debug(self, msg, *args, **kwargs):

        self.log.debug(msg, extra={"objname": "TopNoC"}, *args, **kwargs)

    def info(self, msg, *args, **kwargs):

        self.log.info(msg, extra={"objname": "TopNoC"}, *args, **kwargs)

    def warning(self, msg, *args, **kwargs):

        self.log.warning(msg, extra={"objname": "TopNoC"}, *args, **kwargs)

    def error(self, msg, *args, **kwargs):

        self.log.error(msg, extra={"objname": "TopNoC"}, *args, **kwargs)

    # special log filter: log individually by object name

    def configure_byobject_logging(self, basefilename="", log_level=logging.INFO):

        """

        Special log filter: log individually by object name

        Arguments:

        * basefilename: generated filenames will start with this string

        * log_level: optional logging level for previous files

        """

        # base filter

        class ObjFilter(logging.Filter):

            def __init__(self, basename):

                self.basename = basename

            def filter(self, record):

                if record.objname == self.basename:

                    return True

                return False

        # need a handler for each object

        for obj in self.noc_ref.all_list():

            newfilter = ObjFilter(obj.tbm.logname)

            newhandler = logging.FileHandler("%s_%s.log" % (basefilename, obj.tbm.logname), "w")

            newhandler.setLevel(log_level)

            newhandler.addFilter(newfilter)

            newhandler.setFormatter(self.noc_formatter)

            self.log.addHandler(newhandler)

        # Transactions logger

        class TransFilter(logging.Filter):

            def filter(self, record):

                if record.message.find("->") == 0:

                    return True

                return False

        newhandler = logging.FileHandler("%s_transactions.log" % basefilename, "w")

        newhandler.setLevel(log_level)

        newhandler.addFilter(TransFilter())

        newhandler.setFormatter(self.noc_formatter)

        self.log.addHandler(newhandler)

        # TopNoC will not be added to this set

        self.debug("Special logging enabled. basefilename=%s level %s" % (basefilename, logging._levelNames[log_level]))

class noc_tbm_errcodes():

    """

    Common error codes definition

    """

    no_error = 0

    full_fifo = -1

    packet_bad_data = -2

    tbm_badcall_recv = -3

    tbm_badcall_send = -4

    tbm_busy_channel = -5

    not_implemented = -15