Subversion Repositories nocmodel

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
#
# NoC RTL support in MyHDL
#   This module adds support for mixed model and RTL descriptions in MyHDL
#
# Author:  Oscar Diaz
# Version: 0.2
# Date:    01-06-2012
 
#
# 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
# 01-06-2012 : (OD) big refactorization
#
 
"""
===============================
NoCmodel RTL MyHDL support
===============================
 
This module extends 'noc_tbm_base' class for RTL descriptions in MyHDL
 
* Class 'noc_rtl_myhdl_base'
"""
 
import myhdl
 
from nocmodel import *
from noc_tbm_base import *
 
class noc_rtl_myhdl_base(noc_tbm_base):
    """
    Extended class for a MyHDL description of a NoC router.
 
    This class adds support for behavioral - RTL mixed modeling and
    full RTL modeling. It is meant to add in NoC objects through
    multiple inheritance mechanism
 
    Features:
    * Keep a list of (Intercon type) interface objects, each object is 
        indexed by a port index and each object stores a list of signals
        dict: "interface_objects"
    * Keep a list of external interface objects. Each object is a set of 
        signals (use "signalset" class), and are accessed by any python
        object (a string is recommended).
        dict: "external_objects"
    * Keep a list of internal MyHDL signals, and provides correct references
        dict: "internal_signals"
    """
    # Interface objects methods
    def add_interface(self, port_idx, object_ref=None):
        """
        Add a new interface
        Arguments:
        """
        if not hasattr(self, "interface_objects"):
            self._new_interface_objects()
 
        self.interface_objects[port_idx] = object_ref
        return object_ref
 
    def get_interface_signal(self, port_idx, signalname):
        """
        Try to get a signal reference from the interface object indexed by
        "port_idx". Raise an Exception if not found.
        Arguments:
        * port_idx: 
        * signalname:
        Returns:
          the MyHDL signal reference
        """
        if not hasattr(self, "interface_objects"):
            self._new_interface_objects()
 
        if port_idx not in self.interface_objects:
            raise ValueError("%s : Interface '%s' not found." % (repr(self), repr(port_idx)))
 
        # check if object is list-dict type or a class with signal attributes
        if isinstance(self.interface_objects[port_idx], (tuple, list, dict)):
            # indexing lookup
            if signalname not in self.interface_objects[port_idx]:
                raise AttributeError("%s : Signal '%s' from Interface %s not found." % (repr(self), signalname, repr(port_idx)))
 
            return self.interface_objects[port_idx][signalname]
        else:
            # attribute lookup
            try:
                return getattr(self.interface_objects[port_idx], signalname)
            except:
                 raise AttributeError("%s : Signal '%s' from Interface %s not found." % (repr(self), signalname, repr(port_idx)))
 
    def get_interface_all_signals(self, port_idx):
        """
        Return a dict with all signals references from interface
        Arguments:
        * port_idx: 
        Returns:
          dict with references to all signals in interface
        """
        if not hasattr(self, "interface_objects"):
            self._new_interface_objects()
            return {}
 
        if port_idx not in self.interface_objects:
            raise ValueError("%s : Interface '%s' not found." % (repr(self), repr(port_idx)))
 
        if isinstance(self.interface_objects[port_idx], dict):
            return self.interface_objects[port_idx]
        elif isinstance(self.interface_objects[port_idx], (tuple, list)):
            return dict([(k, v) for k, v in enumerate(self.interface_objects[port_idx])])
        else:
            # search through all attributes
            retval = {}
            for attrname in dir(self.interface_objects[port_idx]):
                attr = getattr(self.interface_objects[port_idx], attrname)
                if isinstance(attr, myhdl.SignalType):
                    retval[attrname] = attr
            return retval
 
    # External interface objects methods
    def add_external_interface(self, index, object_ref=None):
        if not hasattr(self, "external_objects"):
            self._new_external_objects()
 
        if index is None:
            raise ValueError("Index cannot be None.")
 
        # Use an intercon object to model the external 
        # interface objects.
        if object_ref is not None:
            if not isinstance(object_ref, signalset):
                raise ValueError("Object_ref must be of signalset type (not %s, type %s)" % (repr(object_ref), type(object_ref)))
        else:
            object_ref = signalset(index)
 
        self.external_objects[index] = object_ref
        return object_ref
 
    def get_external_signal(self, index, signalname):
        """
        Try to get a signal reference from the external interface object 
        indexed by "index". Raise an Exception if not found.
        Arguments:
        * index: 
        * signalname:
        Returns:
          the MyHDL signal reference
        """
        if not hasattr(self, "external_objects"):
            self._new_external_objects()
 
        if index is None:
            # special case: search through all external interfaces
            siglist = []
            for sigset in self.external_objects.itervalues():
                try:
                    siglist.append(sigset.get_signal_ref(signalname))
                except:
                    pass
            if len(siglist) == 0:
                raise ValueError("%s : signal '%s' not found in any of the external objects." % (repr(self), repr(signalname)))
            elif len(siglist) > 1:
                raise ValueError("%s : signal '%s' found on multiple external objects." % (repr(self), repr(signalname)))
            else:
                return siglist[0]
 
        if index not in self.external_objects:
            raise ValueError("%s : External interface '%s' not found." % (repr(self), repr(index)))
 
        return self.external_objects[index].get_signal_ref(signalname)
 
    def get_external_all_signals(self, index):
        """
        Return a dict with all signals references from interface
        Arguments:
        * index: 
        Returns:
          dict with references to all signals in interface
        """
        if not hasattr(self, "external_objects"):
            self._new_external_objects()
 
        if index not in self.external_objects:
            raise ValueError("%s : External interface '%s' not found." % (repr(self), repr(index)))
 
        retval = {}
        for signalname in self.external_objects[index].get_signal_allnames():
            retval[signalname] = self.external_objects[index].get_signal_ref(signalname)
        return retval
 
    # Internal signals methods
    def getset_internal_signal(self, signalname, newsignal_ref=None):
        """
        Try to get a reference to a internal signal with name "signalname".
        If not found, optionally add a new signal with its reference
        in "newsignal_ref".
        Arguments:
        * signalname: 
        * newsignal_ref:
        Returns:
          the MyHDL signal reference, or the contents of "newsignal_ref"
        """
        if not hasattr(self, "internal_signals"):
            self._new_internal_signals()
 
        if signalname not in self.internal_signals:
            if newsignal_ref is not None:
                if isinstance(newsignal_ref, myhdl.SignalType):
                    self.internal_signals[signalname] = newsignal_ref
                else:
                    # build a new signal based on newsignal_ref
                    self.internal_signals[signalname] = myhdl.Signal(newsignal_ref)
            else:
                raise ValueError("%s : Signal '%s' not found." % (repr(self), signalname))
        return self.internal_signals[signalname]
 
    def internal_signal_iter(self):
        """
        Return an iterator object over all the internal signals.
        This iterator works with tuples (signame, sigref).
        """
        return self.internal_signals.iteritems()
 
    # Methods to override
    def build_generators_codegen(self, withbaseclass=True):
        """
        Separate generator builder, for hw generators only
        NOTES:
        * Generators in this method must be convertible
        * Use overridden functions
        """
        raise NotImplementedError
 
    def _new_internal_signals(self):
        self.internal_signals = {}
    def _new_external_objects(self):
        self.external_objects = {}
    def _new_interface_objects(self):
        self.interface_objects = {}