OpenCores
URL https://opencores.org/ocsvn/soc_maker/soc_maker/trunk

Subversion Repositories soc_maker

[/] [soc_maker/] [trunk/] [lib/] [soc_maker/] [soc_def.rb] - Diff between revs 7 and 8

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 7 Rev 8
###############################################################
###############################################################
#
#
#  File:      soc_def.rb
#  File:      soc_def.rb
#
#
#  Author:    Christian Hättich
#  Author:    Christian Hättich
#
#
#  Project:   System-On-Chip Maker
#  Project:   System-On-Chip Maker
#
#
#  Target:    Linux / Windows / Mac
#  Target:    Linux / Windows / Mac
#
#
#  Language:  ruby
#  Language:  ruby
#
#
#
#
###############################################################
###############################################################
#
#
#
#
#   Copyright (C) 2014  Christian Hättich  - feddischson [ at ] opencores.org
#   Copyright (C) 2014  Christian Hättich  - feddischson [ at ] opencores.org
#
#
#   This program is free software: you can redistribute it and/or modify
#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License, or
#   the Free Software Foundation, either version 3 of the License, or
#   (at your option) any later version.
#   (at your option) any later version.
#
#
#   This program is distributed in the hope that it will be useful,
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#   GNU General Public License for more details.
#
#
#   You should have received a copy of the GNU General Public License
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see .
#   along with this program.  If not, see .
#
#
#
#
###############################################################
###############################################################
#
#
#   Description:
#   Description:
#     This class represents a System-on-chip and derives
#     This class represents a System-on-chip and derives
#     the functionallity from Component.
#     the functionallity from Component.
#     The two important fields are
#     The two important fields are
#       - @cores: holds all core-instances
#       - @cores: holds all core-instances
#       - cons:   holds all connections
#       - cons:   holds all connections
#     In addition, the field @static is used to store
#     In addition, the field @static is used to store
#     static parameters, which are set for cores used in this SOC.
#     static parameters, which are set for cores used in this SOC.
#
#
###############################################################
###############################################################
module SOCMaker
module SOCMaker
class SOCDef < Component
class SOCDef < Component
  include ERR
  include ERR
  include YAML_EXT
  include YAML_EXT
  attr_accessor :cores
  attr_accessor :cores
  attr_accessor :cons
  attr_accessor :cons
  attr_accessor :static
  attr_accessor :static
  def initialize( name, version, toplevel, options = {} )
  def initialize( name, version, toplevel, options = {} )
    init_with( { 'name'     => name,
    init_with( { 'name'     => name,
                 'version'  => version,
                 'version'  => version,
                 'toplevel' => toplevel }.merge( options ) )
                 'toplevel' => toplevel }.merge( options ) )
  end
  end
  def encode_with( coder )
  def encode_with( coder )
    super coder
    super coder
    %w[ cores cons static ].
    %w[ cores cons static ].
      each { |v| coder[ v ] = instance_variable_get "@#{v}" }
      each { |v| coder[ v ] = instance_variable_get "@#{v}" }
  end
  end
  def init_with( coder )
  def init_with( coder )
    super coder
    super coder
    @cores  = coder[ 'cores'  ] || {}
    @cores  = coder[ 'cores'  ] || {}
    @static = coder[ 'static' ] || {}
    @static = coder[ 'static' ] || {}
    @cons   = coder[ 'cons'   ] || {}
    @cons   = coder[ 'cons'   ] || {}
  end
  end
  def consistency_check
  def consistency_check
    super
    super
    @cores.values.each do |inst|
    @cores.values.each do |inst|
      inst.consistency_check
      inst.consistency_check
    end
    end
  end
  end
  # SOCMaker::logger.error( "instantiation #{inst_name} is already in use" )
  # SOCMaker::logger.error( "instantiation #{inst_name} is already in use" )
  def inst_in_use?( inst_name )
  def inst_in_use?( inst_name )
       @cores[ inst_name.to_sym ] != nil or
       @cores[ inst_name.to_sym ] != nil or
       @cons[ inst_name.to_sym ]  != nil
       @cons[ inst_name.to_sym ]  != nil
  end
  end
  def rm( inst_name )
  def rm( inst_name )
    if @cores[ inst_name.to_sym ] != nil
    if @cores[ inst_name.to_sym ] != nil
      # TODO: remove also all related connections
      # TODO: remove also all related connections
      @cores.delete( inst_name.to_sym )
      @cores.delete( inst_name.to_sym )
    elsif @cons[ inst_name.to_sym ]  != nil
    elsif @cons[ inst_name.to_sym ]  != nil
      @cons.delete( inst_name.to_sym )
      @cons.delete( inst_name.to_sym )
    else
    else
      return false
      return false
    end
    end
    return true
    return true
  end
  end
  def add_core( name, version, inst_name )
  def add_core( name, version, inst_name )
    return false if inst_in_use?( inst_name )
    return false if inst_in_use?( inst_name )
    # check, if the core exits in our library
    # check, if the core exits in our library
    #  if not: an error will be raised
    #  if not: an error will be raised
    SOCMaker::lib.get_core( name, version )
    SOCMaker::lib.get_core( name, version )
    @cores[ inst_name.to_sym ] = SOCMaker::CoreInst.new( name+version )
    @cores[ inst_name.to_sym ] = SOCMaker::CoreInst.new( name+version )
  end
  end
  def ifc_in_use?( inst_name, ifc_name )
  def ifc_in_use?( inst_name, ifc_name )
    # go through all connections and check,
    # go through all connections and check,
    # that non of the interfaces we want to connect is used
    # that non of the interfaces we want to connect is used
    @cons.each do |_con_name, con_def|
    @cons.each do |_con_name, con_def|
      return true if con_def[ :mapping ][ 0 ][ inst_name.to_sym] == ifc_name.to_sym
      return true if con_def[ :mapping ][ 0 ][ inst_name.to_sym] == ifc_name.to_sym
      return true if con_def[ :mapping ][ 1 ][ inst_name.to_sym] == ifc_name.to_sym
      return true if con_def[ :mapping ][ 1 ][ inst_name.to_sym] == ifc_name.to_sym
    end
    end
    return false
    return false
  end
  end
  def get_port_len( ifc_name, port_name, inst )
  def get_port_len( ifc_name, port_name, inst )
    if @cores[ inst.to_sym ] != nil
    if @cores[ inst.to_sym ] != nil
      return @cores[ inst ].get_port_len( ifc_name, port_name )
      return @cores[ inst ].get_port_len( ifc_name, port_name )
    else
    else
      return nil
      return nil
    end
    end
  end
  end
  def get_core_def( inst )
  def get_core_def( inst )
      if @cores[ inst.to_sym ] != nil
      if @cores[ inst.to_sym ] != nil
        return @cores[ inst.to_sym ].defn
        return @cores[ inst.to_sym ].defn
      elsif inst == @name
      elsif inst == @name
        return self
        return self
      else
      else
        return nil
        return nil
      end
      end
  end
  end
  def add_to_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
  def add_to_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
    perr_if( @cons[ con_name.to_sym ]  == nil, "Connection instance #{con_name} not found" )
    perr_if( @cons[ con_name.to_sym ]  == nil, "Connection instance #{con_name} not found" )
    @cons[ con_name.to_sym ][:mapping][0][ inst1.to_sym ] = ifc1_name.to_sym
    @cons[ con_name.to_sym ][:mapping][0][ inst1.to_sym ] = ifc1_name.to_sym
    @cons[ con_name.to_sym ][:mapping][1][ inst2.to_sym ] = ifc2_name.to_sym
    @cons[ con_name.to_sym ][:mapping][1][ inst2.to_sym ] = ifc2_name.to_sym
  end
  end
  def add_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
  def add_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
    if @cores[ con_name.to_sym ] != nil
    if @cores[ con_name.to_sym ] != nil
      return nil
      return nil
    elsif @cons[ con_name.to_sym ]  != nil
    elsif @cons[ con_name.to_sym ]  != nil
      return add_to_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
      return add_to_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
    end
    end
    [ [ inst1, ifc1_name ],
    [ [ inst1, ifc1_name ],
      [ inst2, ifc2_name ] ].each do |sub_arr|
      [ inst2, ifc2_name ] ].each do |sub_arr|
       perr_if( ifc_in_use?( sub_arr[ 0 ], sub_arr[ 1 ] ),
       perr_if( ifc_in_use?( sub_arr[ 0 ], sub_arr[ 1 ] ),
           "Interface #{sub_arr[ 1 ]} of instance '#{sub_arr[ 0 ]}' is already in use " )
           "Interface #{sub_arr[ 1 ]} of instance '#{sub_arr[ 0 ]}' is already in use " )
    end
    end
    core_def_1 = get_core_def( inst1 )
    core_def_1 = get_core_def( inst1 )
    core_def_2 = get_core_def( inst2 )
    core_def_2 = get_core_def( inst2 )
    perr_if( !core_def_1, "Can't find core #{inst1}" )
    perr_if( !core_def_1, "Can't find core #{inst1}" )
    perr_if( !core_def_2, "Can't find core #{inst2}" )
    perr_if( !core_def_2, "Can't find core #{inst2}" )
    [ [ core_def_1, ifc1_name ],
    [ [ core_def_1, ifc1_name ],
      [ core_def_2, ifc2_name ] ].each do |sub_arr|
      [ core_def_2, ifc2_name ] ].each do |sub_arr|
        perr_if( sub_arr[ 0 ].interfaces[ sub_arr[ 1 ].to_sym ] == nil,
        perr_if( sub_arr[ 0 ].interfaces[ sub_arr[ 1 ].to_sym ] == nil,
          "Interface '#{sub_arr[ 1 ]}' dosn't exist in core '#{sub_arr[0].name}' \n" +
          "Interface '#{sub_arr[ 1 ]}' dosn't exist in core '#{sub_arr[0].name}' \n" +
          "The following interfaces do exist:  '#{sub_arr[0].interfaces.keys}'"  )
          "The following interfaces do exist:  '#{sub_arr[0].interfaces.keys}'"  )
    end
    end
    # check name and version of the ifcs which will be connected
    # check name and version of the ifcs which will be connected
    perr_if( core_def_1.interfaces[ ifc1_name.to_sym ].name     !=
    perr_if( core_def_1.interfaces[ ifc1_name.to_sym ].name     !=
             core_def_2.interfaces[ ifc2_name.to_sym ].name     ||
             core_def_2.interfaces[ ifc2_name.to_sym ].name     ||
             core_def_1.interfaces[ ifc1_name.to_sym ].version  !=
             core_def_1.interfaces[ ifc1_name.to_sym ].version  !=
             core_def_2.interfaces[ ifc2_name.to_sym ].version,
             core_def_2.interfaces[ ifc2_name.to_sym ].version,
          "Can't connect #{
          "Can't connect #{
            core_def_1.interfaces[ ifc1_name.to_sym ].name } - #{
            core_def_1.interfaces[ ifc1_name.to_sym ].name } - #{
            core_def_2.interfaces[ ifc2_name.to_sym ].name } : #{
            core_def_2.interfaces[ ifc2_name.to_sym ].name } : #{
            core_def_1.interfaces[ ifc1_name.to_sym ].version } - #{
            core_def_1.interfaces[ ifc1_name.to_sym ].version } - #{
            core_def_2.interfaces[ ifc2_name.to_sym ].version }" )
            core_def_2.interfaces[ ifc2_name.to_sym ].version }" )
    @cons[ con_name.to_sym ] = {
    @cons[ con_name.to_sym ] = {
          :rule    => "or",
          :rule    => "or",
          :mapping => [ { inst1.to_sym => ifc1_name.to_sym },
          :mapping => [ { inst1.to_sym => ifc1_name.to_sym },
                        { inst2.to_sym => ifc2_name.to_sym } ] }
                        { inst2.to_sym => ifc2_name.to_sym } ] }
    return false
    return false
  end
  end
  def set_param( instance, param, value )
  def set_param( instance, param, value )
    # get instance
    # get instance
    core_inst = @cores[ instance.to_sym ]
    core_inst = @cores[ instance.to_sym ]
    perr_if( core_inst == nil,
    perr_if( core_inst == nil,
      "Can't find '#{instance}' in SOC" )
      "Can't find '#{instance}' in SOC" )
    # get the core-definition
    # get the core-definition
    core_def = SOCMaker::lib.get_core( core_inst.type  )
    core_def = SOCMaker::lib.get_core( core_inst.type  )
    # check if parameter exist
    # check if parameter exist
    if core_def.inst_parameters[ param.to_sym ] != nil
    if core_def.inst_parameters[ param.to_sym ] != nil
      core_inst.params[ param.to_sym ] = value
      core_inst.params[ param.to_sym ] = value
    else
    else
      perr_if( true,
      perr_if( true,
        "Parameter '#{param}' not found in '#{core_def.name}'" )
        "Parameter '#{param}' not found in '#{core_def.name}'" )
    end
    end
  end
  end
  def get_param( instance, param )
  def get_param( instance, param )
    # get instance
    # get instance
    core_inst = @cores[ instance.to_sym ]
    core_inst = @cores[ instance.to_sym ]
    perr_if( core_inst == nil,
    perr_if( core_inst == nil,
      "Can't find '#{instance}' in SOC" )
      "Can't find '#{instance}' in SOC" )
    param_val = core_inst.params[ param.to_sym ]
    param_val = core_inst.params[ param.to_sym ]
    perr_if( param_val == nil,
    perr_if( param_val == nil,
      "Can't find parameter '#{param}' in '#{instance}'" )
      "Can't find parameter '#{param}' in '#{instance}'" )
    return param_val
    return param_val
  end
  end
  def set_sparam( core, param, value )
  def set_sparam( core, param, value )
    #get instance
    #get instance
    # check, if we are instantiating this core
    # check, if we are instantiating this core
    perr_if( @cores.select{ |name,inst| inst.type == core }.size == 0,
    perr_if( @cores.select{ |name,inst| inst.type == core }.size == 0,
      "Core '#{core}' is not instantiated in this SOC" )
      "Core '#{core}' is not instantiated in this SOC" )
    # get the core-definition
    # get the core-definition
    core_def = SOCMaker::lib.get_core( core )
    core_def = SOCMaker::lib.get_core( core )
    # check if parameter exist
    # check if parameter exist
    perr_if( core_def.static_parameters.select{ |f,p| p.parameters[ param.to_sym ] != nil }.size == 0,
    perr_if( core_def.static_parameters.select{ |f,p| p.parameters[ param.to_sym ] != nil }.size == 0,
        "Parameter '#{param}' not found in '#{core_def.name}'" )
        "Parameter '#{param}' not found in '#{core_def.name}'" )
    @static[ core.to_sym ] ||= {}
    @static[ core.to_sym ] ||= {}
    @static[ core.to_sym ][ param.to_sym ] = value
    @static[ core.to_sym ][ param.to_sym ] = value
  end
  end
  def get_sparam( core, param )
  def get_sparam( core, param )
    perr_if( @static[ core.to_sym ] == nil,
    perr_if( @static[ core.to_sym ] == nil,
      "Core '#{core}' does not exist in this SOC" )
      "Core '#{core}' does not exist in this SOC" )
    perr_if( @static[ core.to_sym ][ param.to_sym ] == nil,
    perr_if( @static[ core.to_sym ][ param.to_sym ] == nil,
      "Parameter '#{param}' does not exist for core '#{core}'" )
      "Parameter '#{param}' does not exist for core '#{core}'" )
    return @static[ core.to_sym ][ param.to_sym ]
    return @static[ core.to_sym ][ param.to_sym ]
  end
  end
  def copy_files
  def copy_files
    SOCMaker::logger.proc( "START of copying all HDL files" )
    SOCMaker::logger.proc( "START of copying all HDL files" )
 
 
 
 
    #
    #
    # Create a unique list of cores and
    # Create a unique list of cores and
    # for every core, create a directory and copy files
    # for every core, create a directory and copy files
    #
    #
    @cores.values.uniq{|x| x.type }.each do |core_inst; core_def, dst_dir|
    @cores.values.uniq{|x| x.type }.each do |core_inst; core_def, dst_dir|
      core_def = SOCMaker::lib.get_core( core_inst.type )
      core_def = SOCMaker::lib.get_core( core_inst.type )
      # create destination directory name and ensure, that it is exist
      # create destination directory name and ensure, that it is exist
      dst_dir  = get_and_ensure_dst_dir!( core_def.name )
      dst_dir  = get_and_ensure_dst_dir!( core_def.name )
      # copy each file into destination dir
      # copy each file into destination dir
      core_def.hdlfiles.each do |file, val|
      core_def.hdlfiles.each do |file, val|
        file_path = File.join( core_def.dir, val.path )
        file_path = File.join( core_def.dir, val.path )
        dst_path = File.join( dst_dir, val.path )
        dst_path = File.join( dst_dir, val.path )
        SOCMaker::logger.proc( "copy #{file_path} to #{ dst_path} " )
        SOCMaker::logger.proc( "copy #{file_path} to #{ dst_path} " )
        FileUtils.mkdir_p(File.dirname(dst_path))
        FileUtils.mkdir_p(File.dirname(dst_path))
        FileUtils.cp( file_path, dst_path )
        FileUtils.cp( file_path, dst_path )
      end
      end
 
 
 
 
      #
      #
      # handle the static parameters
      # handle the static parameters
      #   (search and replace in pakckage/include files)
      #   (search and replace in pakckage/include files)
      core_def.static_parameters.each do |file, param|
      core_def.static_parameters.each do |file, sparam|
 
 
        token_val_map = {}
        token_val_map = {}
        param.parameters.each do |n,p|
        sparam.parameters.each do |n,sparam_entry|
 
 
          if  @static[ core_inst.type.to_sym ]      != nil and
          if  @static[ core_inst.type.to_sym ]      != nil and
              @static[ core_inst.type.to_sym ][ n ] != nil
              @static[ core_inst.type.to_sym ][ n ] != nil
 
 
            # use value defined in soc-spec
            # use value defined in soc-spec
            token_val_map[ p.token ] = @static[ core_inst.type.to_sym ][ n ]
            tmp = @static[ core_inst.type.to_sym ][ n ]
          else
          else
            # use default value from core-spec
            # use default value from core-spec
            token_val_map[ p.token ] =  p.default
            tmp =  sparam_entry.default
          end
          end
 
 
 
          if sparam_entry.type == "enum"
 
            token_val_map[ sparam_entry.token ] = sparam_entry.choice[ tmp ]
 
          elsif sparam_entry.type == "bool"
 
            if tmp == true
 
              token_val_map[ sparam_entry.token ] = sparam_entry.choice
 
            else
 
              token_val_map[ sparam_entry.token ] = ""
 
            end
 
          else
 
            token_val_map[ sparam_entry.token ] = tmp
 
          end
 
 
 
 
        end
        end
        # create file paths
        # create file paths
        src_path = File.join( core_def.dir, param.path )
        src_path = File.join( core_def.dir, sparam.path )
        dst_dir  = get_and_ensure_dst_dir!( core_def.name )
        dst_dir  = get_and_ensure_dst_dir!( core_def.name )
        dst_path = File.join( dst_dir, param.file_dst )
        dst_path = File.join( dst_dir, sparam.file_dst )
 
 
        # process each line of input file
        # process each line of input file
        # and replace tokens by value via
        # and replace tokens by value via
        # regular expression
        # regular expression
        File.open( dst_path, 'w' ) do |dst_f|
        File.open( dst_path, 'w' ) do |dst_f|
          File.open( src_path ) do |src_f|
          File.open( src_path ) do |src_f|
            SOCMaker::logger.proc( "create #{dst_path} from #{ src_path} " )
            SOCMaker::logger.proc( "create #{dst_path} from #{ src_path} " )
            while line = src_f.gets
            while line = src_f.gets
              token_val_map.each { |token, val| line = line.sub( Regexp.new( token.to_s ), val.to_s ) }
              token_val_map.each { |token, val| line = line.sub( Regexp.new( '\b' + token.to_s + '\b' ), val.to_s ) }
              dst_f.puts line
              dst_f.puts line
            end
            end
          end
          end
        end
        end
      end
      end
    end
    end
    SOCMaker::logger.proc( "END of copying all HDL files" )
    SOCMaker::logger.proc( "END of copying all HDL files" )
  end
  end
  def ==(o)
  def ==(o)
    o.class   == self.class   &&
    o.class   == self.class   &&
    o.cores   == self.cores   &&
    o.cores   == self.cores   &&
    o.cons    == self.cons    &&
    o.cons    == self.cons    &&
    o.static  == self.static  &&
    o.static  == self.static  &&
    super( o )
    super( o )
  end
  end
  def to_s
  def to_s
    tmp = "_________ SOC #{@name}: _______\n"     +
    tmp = "_________ SOC #{@name}: _______\n"     +
          super                                   +
          super                                   +
          "\n__connections__\n"
          "\n__connections__\n"
    @cons.each do |_con_name, con_def|
    @cons.each do |_con_name, con_def|
      tmp += "#{_con_name}: #{con_def}\n"
      tmp += "#{_con_name}: #{con_def}\n"
    end
    end
    tmp += "\n__cores__\n"
    tmp += "\n__cores__\n"
    @cores.each do |inst_name, inst|
    @cores.each do |inst_name, inst|
      tmp += "#{inst_name}:\n#{inst}\n"
      tmp += "#{inst_name}:\n#{inst}\n"
    end
    end
    tmp += "'''''''''''''''''''''''''''''''''''\n"
    tmp += "'''''''''''''''''''''''''''''''''''\n"
    return tmp
    return tmp
  end
  end
end # class SOCSpec
end # class SOCSpec
end # module SOCMaker
end # module SOCMaker
# vim: noai:ts=2:sw=2
# vim: noai:ts=2:sw=2
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.