HDLRuby 2.7.11 → 2.10.2

data/lib/HDLRuby/hruby_high.rb

@@ -344,6 +344,7 @@ module HDLRuby::High
         def initialize(name, *mixins, &ruby_block)
             # Initialize the system type structure.
             super(name,Scope.new(name,self))
+            # puts "new systemT=#{self}"
 
             # Initialize the set of extensions to transmit to the instances'
             # eigen class
@@ -373,6 +374,28 @@ module HDLRuby::High
             make_instantiater(name,SystemI,&ruby_block)
         end
 
+
+        # Tell if the current system is a descedent of +system+
+        def of?(system)
+            # Maybe self is system.
+            if (self == system) then
+                # Yes, consider it is adescendent of system.
+                return true
+            else
+                # Look into the generators.
+                @generators.each do |generator|
+                    return true if generator.of?(system)
+                end
+                # Look into the included systems.
+                @to_includes.each do |included|
+                    return true if included.of?(system)
+                end
+            end
+            # Not found.
+            return false
+        end
+
+
         # Converts to a namespace user.
         def to_user
             # Returns the scope.
@@ -418,9 +441,9 @@ module HDLRuby::High
                     res = self.add_output(SignalI.new(name,type,:output))
                 elsif name.is_a?(Hash) then
                     # Names associated with values.
-                    names.each do |name,value|
-                        res = self.add_inner(
-                            SignalI.new(name,type,:inner,value))
+                    name.each do |key,value|
+                        res = self.add_output(
+                            SignalI.new(key,type,:output,value))
                     end
                 else
                     raise AnyError, "Invalid class for a name: #{name.class}"
@@ -451,6 +474,21 @@ module HDLRuby::High
         end
 
 
+        # Gets an input signal by +name+ considering also the included
+        # systems
+        def get_input_with_included(name)
+            # Look in self.
+            found = self.get_input(name)
+            return found if found
+            # Not in self, look in the included systems.
+            self.scope.each_included do |included|
+                found = included.get_input_with_included(name)
+                return found if found
+            end
+            # Not found
+            return nil
+        end
+
         # Gets an output signal by +name+ considering also the included
         # systems
         def get_output_with_included(name)
@@ -466,6 +504,36 @@ module HDLRuby::High
             return nil
         end
 
+        # Gets an inout signal by +name+ considering also the included
+        # systems
+        def get_inout_with_included(name)
+            # Look in self.
+            found = self.get_inout(name)
+            return found if found
+            # Not in self, look in the included systems.
+            self.scope.each_included do |included|
+                found = included.get_inout_with_included(name)
+                return found if found
+            end
+            # Not found
+            return nil
+        end
+
+        # Iterates over the all signals (input, output, inout, inner, constant),
+        # i.e, also the ones of the included systems.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_signal_all_with_included(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_signal_all_with_included) unless ruby_block
+            # Iterate on all the signals of the current system.
+            self.each_signal_all(&ruby_block)
+            # Recurse on the included systems.
+            self.scope.each_included do |included|
+                included.each_signal_all_with_included(&ruby_block)
+            end
+        end
+
         # Iterates over the all interface signals, i.e, also the ones of
         # the included systems.
         #
@@ -473,7 +541,7 @@ module HDLRuby::High
         def each_signal_with_included(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each_signal_with_included) unless ruby_block
-            # Iterate on the signals of the current system.
+            # Iterate on all the signals of the current system.
             self.each_signal(&ruby_block)
             # Recurse on the included systems.
             self.scope.each_included do |included|
@@ -487,6 +555,14 @@ module HDLRuby::High
             return each_signal_with_included.to_a[i]
         end
 
+        # Gets a signal by +name+ considering also the included
+        # systems
+        def get_signal_with_included(name)
+            return get_input_with_included(name) ||
+                   get_output_with_included(name) ||
+                   get_inout_with_included(name)
+        end
+
         # Iterates over the exported constructs
         #
         # NOTE: look into the scope.
@@ -571,6 +647,7 @@ module HDLRuby::High
 
             # Sets the generators of the expanded result.
             expanded.add_generator(self)
+            # puts "expanded=#{expanded}"
             @to_includes.each { |system| expanded.add_generator(system) }
             # Also for the previously includeds. */
             self.scope.each_included.each { |system| expanded.add_generator(system) }
@@ -634,9 +711,8 @@ module HDLRuby::High
 
             # Create the instance and sets its eigen system to +eigen+.
             instance = @instance_class.new(i_name,eigen)
+            # puts "instance=#{instance}"
             eigen.eigenize(instance)
-            # puts "instance interface=#{instance.each_signal.to_a.size}"
-            # puts "eigen interface=#{eigen.each_signal.to_a.size}"
 
             # Extend the instance.
             instance.eigen_extend(@singleton_instanceO)
@@ -846,7 +922,8 @@ module HDLRuby::High
             # Initialize the set of exported inner signals and instances
             @exports = {}
             # Initialize the set of included systems.
-            @includes = {}
+            # @includes = {}
+            @includes = []
 
             # Builds the scope if a ruby block is provided.
             self.build(&ruby_block) if block_given?
@@ -933,7 +1010,8 @@ module HDLRuby::High
             # No ruby block? Return an enumerator.
             return to_enum(:each_included) unless ruby_block
             # A block? Apply it on each included system.
-            @includes.each_value(&ruby_block)
+            # @includes.each_value(&ruby_block)
+            @includes.each(&ruby_block)
             # And apply on the sub scopes if any.
             @scopes.each {|scope| scope.each_included(&ruby_block) }
         end
@@ -1226,13 +1304,16 @@ module HDLRuby::High
         # Include a +system+ type with possible +args+ instanciation
         # arguments.
         def include(system,*args)
-            if @includes.key?(system.name) then
-                raise AnyError, "Cannot include twice the same system."
+            # if @includes.key?(system.name) then
+            #     raise AnyError, "Cannot include twice the same system: #{system}"
+            # end
+            if @includes.include?(system) then
+                raise AnyError, "Cannot include twice the same system: #{system}"
             end
-            # puts "Include system=#{system.name}"
-            # Save the name of the included system, it will serve as key
-            # for looking for the included expanded version.
-            include_name = system.name
+            # # puts "Include system=#{system.name}"
+            # # Save the name of the included system, it will serve as key
+            # # for looking for the included expanded version.
+            # include_name = system.name
             # Expand the system to include
             system = system.expand(:"",*args)
             # Add the included system interface to the current one.
@@ -1240,7 +1321,8 @@ module HDLRuby::High
                 space = self.namespace
                 # Interface signals
                 # puts "i_name=#{i_name} @to_includes=#{@to_includes.size}"
-                system.each_signal_with_included do |signal|
+                # system.each_signal_with_included do |signal|
+                system.each_signal_all_with_included do |signal|
                     # puts "signal=#{signal.name}"
                     space.send(:define_singleton_method,signal.name) do
                         signal
@@ -1259,18 +1341,20 @@ module HDLRuby::High
                 end
             end
             # Adds it the list of includeds
-            @includes[include_name] = system
+            # @includes[include_name] = system
+            @includes << system
+
             # puts "@includes=#{@includes}"
             
         end
 
-        # Casts as an included +system+.
-        def as(system)
-            # puts "as with name: #{system.name}"
-            system = system.name if system.respond_to?(:name)
-            # puts "includes are: #{@includes.keys}"
-            return @includes[system].namespace
-        end
+        # Obsolete
+        # # Casts as an included +system+.
+        # def as(system)
+        #     # puts "as with name: #{system.name}"
+        #     system = system.name if system.respond_to?(:name)
+        #     return @includes[system].namespace
+        # end
 
 
         # Gets the current system.
@@ -1285,7 +1369,8 @@ module HDLRuby::High
         # NOTE: name conflicts are treated in the current NameStack state.
         def fill_low(scopeL)
             # Adds the content of its included systems.
-            @includes.each_value {|system| system.scope.fill_low(scopeL) }
+            # @includes.each_value {|system| system.scope.fill_low(scopeL) }
+            @includes.each {|system| system.scope.fill_low(scopeL) }
             # Adds the declared local system types.
             # NOTE: in the current version of HDLRuby::High, there should not
             # be any of them (only eigen systems are real system types).
@@ -2051,26 +2136,28 @@ module HDLRuby::High
                 # Performs the connections.
                 connects.each do |key,value|
                     # Gets the signal corresponding to connect.
-                    signal = self.get_signal(key)
-                    unless signal then
-                        # Look into the included systems.
-                        self.systemT.scope.each_included do |included|
-                            signal = included.get_signal(key)
-                            break if signal
-                        end
-                    end
+                    # signal = self.get_signal(key)
+                    # unless signal then
+                    #     # Look into the included systems.
+                    #     self.systemT.scope.each_included do |included|
+                    #         signal = included.get_signal(key)
+                    #         break if signal
+                    #     end
+                    # end
+                    signal = self.systemT.get_signal_with_included(key)
                     # Check if it is an output.
-                    isout = self.get_output(key)
-                    unless isout then
-                        # Look into the inlucded systems.
-                        self.systemT.scope.each_included do |included|
-                            isout = included.get_output(key)
-                            break if isout
-                        end
-                    end
+                    # isout = self.get_output(key)
+                    # unless isout then
+                    #     # Look into the inlucded systems.
+                    #     self.systemT.scope.each_included do |included|
+                    #         isout = included.get_output(key)
+                    #         break if isout
+                    #     end
+                    # end
+                    isout = self.systemT.get_output_with_included(key)
                     # Convert it to a reference.
+                    # puts "key=#{key} value=#{value} signal=#{signal}"
                     ref = RefObject.new(self.to_ref,signal)
-                    # puts "key=#{key} value=#{value} signal=#{signal} ref=#{ref}"
                     # Make the connection.
                     if isout then
                         value <= ref
@@ -2119,6 +2206,54 @@ module HDLRuby::High
             self.eigen_extend(@systemT.public_namespace)
         end
 
+        # Adds alternative system +systemT+
+        def choice(configuration = {})
+            # Process the argument.
+            configuration.each do |k,v|
+                k = k.to_sym
+                unless v.is_a?(SystemT) then
+                    raise "Invalid class for a system type: #{v.class}"
+                end
+                # Create an eigen system.
+                eigen = v.instantiate(HDLRuby.uniq_name(self.name)).systemT
+                # Ensure its interface corresponds.
+                my_signals = self.each_signal.to_a
+                if (eigen.each_signal.with_index.find { |sig,i|
+                    !sig.eql?(my_signals[i])
+                }) then
+                raise "Invalid system for configuration: #{systemT.name}." 
+                end
+                # Add it.
+                # At the HDLRuby::High level
+                @choices = { self.name => self.systemT } unless @choices
+                @choices[k] = eigen
+                # At the HDLRuby::Low level
+                self.add_systemT(eigen)
+            end
+        end
+
+        # (Re)Configuration of system instance to systemT designated by +sys+.
+        # +sys+ may be the index or the name of the configuration, the first
+        # configuration being named by the systemI name.
+        def configure(sys)
+            if sys.respond_to?(:to_i) then
+                # The argument is an index.
+                # Create the (re)configuration node.
+                High.top_user.add_statement(
+                    Configure.new(RefObject.new(RefThis.new,self),sys.to_i))
+            else
+                # The argument is a name (should be).
+                # Get the index corresponding to the name.
+                num = @choices.find_index { |k,_| k == sys.to_sym }
+                unless num then
+                    raise "Invalid name for configuration: #{sys.to_s}"
+                end
+                # Create the (re)configuration node.
+                High.top_user.add_statement(
+                    Configure.new(RefObject.new(RefThis.new,self),num))
+            end
+        end
+
         # include Hmissing
 
         # Missing methods are looked for in the public namespace of the
@@ -2155,8 +2290,11 @@ module HDLRuby::High
             # systemIL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = systemIL
             # Adds the other systemTs.
-            self.each_systemT do |systemT|
-                systemIL.add_systemT(systemT.to_low) unless systemT == self.systemT
+            self.each_systemT do |systemTc|
+                if systemTc != self.systemT
+                    systemTcL = systemTc.to_low
+                    systemIL.add_systemT(systemTcL)
+                end
             end
             return systemIL
         end
@@ -2433,6 +2571,18 @@ module HDLRuby::High
         end
     end
 
+    ## 
+    # Describes a timed terminate statement: not synthesizable!
+    class TimeTerminate < Low::TimeTerminate
+        include HStatement
+
+        # Converts the repeat statement to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::TimeTerminate.new
+        end
+    end
+
+
 
     ##
     # Module giving high-level expression properties
@@ -3072,7 +3222,8 @@ module HDLRuby::High
 
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
-            # puts "to_low with base=#{@base} @object=#{@object.name}"
+            # puts "to_low with base=#{@base} @object=#{@object}"
+            # puts "@object.name=#{@object.name}"
             refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              @base.to_ref.to_low,@object.name)
             # # For debugging: set the source high object 
@@ -3369,6 +3520,27 @@ module HDLRuby::High
     end
 
 
+    ## 
+    # Describes a systemI (re)configure statement: not synthesizable!
+    class Configure < Low::Configure
+        High = HDLRuby::High
+
+        include HStatement
+
+        # Creates a new (re)configure statement for system instance refered
+        # by +ref+ with system number +num+.
+        def initialize(ref,num)
+            super(ref,num)
+        end
+
+        # Converts the connection to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::Configure.new(self.ref.to_low, self.index)
+        end
+
+    end
+
+
     ## 
     # Describes a connection.
     class Connection < Low::Connection
@@ -3802,6 +3974,11 @@ module HDLRuby::High
         def hprint(*args)
             self.add_statement(Print.new(*args))
         end
+
+        # Terminate the simulation.
+        def terminate
+            self.add_statement(TimeTerminate.new)
+        end
     end
 
 

data/lib/HDLRuby/hruby_low.rb

@@ -164,12 +164,27 @@ module HDLRuby::Low
         end
 
 
+        # Handling the (re)configuration.
+
+        # Gets the configuration wrapper if any.
+        def wrapper
+            return defined? @wrapper ? @wrapper : nil
+        end
+
+        # Sets the configuration wrapper to +systemT+.
+        def wrapper=(systemT)
+            unless systemT.is_a?(SystemT) then
+                raise "Invalid class for a wrapper system type: #{systemT}."
+            end
+            @wrapper = systemT
+        end
+
 
         # Handling the signals.
 
         # Adds input +signal+.
         def add_input(signal)
-            # print "add_input with signal: #{signal.name}\n"
+            # print "In #{self} add_input with signal: #{signal.name}\n"
             # Check and add the signal.
             unless signal.is_a?(SignalI)
                 raise AnyError,
@@ -274,6 +289,8 @@ module HDLRuby::Low
             @inputs.each(&ruby_block)
             @outputs.each(&ruby_block)
             @inouts.each(&ruby_block)
+            # And each signal of the direct scope.
+            @scope.each_signal(&ruby_block)
         end
 
         # Iterates over all the signals of the system type and its scope.
@@ -282,7 +299,8 @@ module HDLRuby::Low
             return to_enum(:each_signal_deep) unless ruby_block
             # A ruby block?
             # First iterate over the current system type's signals.
-            self.each_signal_all(&ruby_block)
+            # self.each_signal_all(&ruby_block)
+            self.each_signal(&ruby_block)
             # Then apply on the behaviors (since in HDLRuby:High, blocks can
             # include signals).
             @scope.each_signal_deep(&ruby_block)
@@ -432,6 +450,27 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Iterates over the systemT deeply if any in order of reference
+        # to ensure the refered elements are processed first.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_systemT_deep_ref(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_systemT_deep_ref) unless ruby_block
+            # A ruby block? 
+            # Recurse on the systemT accessible through the instances.
+            self.scope.each_scope_deep do |scope|
+                scope.each_systemI do |systemI|
+                    # systemI.systemT.each_systemT_deep(&ruby_block)
+                    systemI.each_systemT do |systemT|
+                        systemT.each_systemT_deep_ref(&ruby_block)
+                    end
+                end
+            end
+            # Finally apply it to current.
+            ruby_block.call(self)
+        end
     end
 
 
@@ -2500,8 +2539,8 @@ module HDLRuby::Low
     # NOTE: an instance can actually represented muliple layers
     #       of systems, the first one being the one actually instantiated
     #       in the final RTL code.
-    #       This layring can be used for describing software or partial
-    #       reconfiguration.
+    #       This layering can be used for describing software or partial
+    #       (re)configuration.
     class SystemI
 
         include Hparent
@@ -2564,13 +2603,16 @@ module HDLRuby::Low
             @name = name.to_sym
         end
 
-        ## Adds a system layer.
+        ## Adds a system configuration.
         def add_systemT(systemT)
             # puts "add_systemT #{systemT.name} to systemI #{self.name}"
             # Check and add the systemT.
             if !systemT.is_a?(SystemT) then
                 raise AnyError, "Invalid class for a system type: #{systemT.class}"
             end
+            # Set the base configuration of the added system.
+            systemT.wrapper = self.systemT
+            # Add it.
             @systemTs << systemT
         end
 
@@ -3781,6 +3823,93 @@ module HDLRuby::Low
                 end
             end
         end
+    end
+
+
+    ## 
+    # Describes a system instance (re)configuration statement: not synthesizable!
+    class Configure < Statement
+
+        # attr_reader :systemI, :systemT, :index
+        attr_reader :ref, :index
+
+        # Creates a new (re)configure statement of system instance refered by
+        # +ref+ with system number +index+
+        def initialize(ref,index)
+            super()
+            # Process the arguments.
+            index = index.to_i
+            unless ref.is_a?(Ref) then
+                raise "Invalid class for a reference: #{ref.class}."
+            end
+            # Sets the arguments.
+            @ref = ref
+            ref.parent = self
+            @index = index
+            # @systemT = systemI.each_systemT.to_a[index]
+            # # Check the systemT is valid.
+            # unless @systemT then
+            #     raise "Invalid configuration index: #{index}."
+            # end
+        end
+
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(Configure)
+            return false unless @ref.eql?(obj.ref)
+            return false unless @index.eql?(obj.index)
+            return true
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the reference.
+            @ref.each_deep(&ruby_block)
+        end
+
+        # Hash function.
+        def hash
+            return (@ref.hash + @index.hash).hash
+        end
+
+        # Clones (deeply)
+        def clone
+            return Configure.new(@ref.clone,@index)
+        end
+
+        # Iterates over the nodes deeply if any.
+        def each_node_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # And recurse on the reference.
+            @ref.each_node_deep(&ruby_block)
+        end
+
+        # Iterates over all the blocks contained in the current block.
+        def each_block_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block_deep) unless ruby_block
+            # A ruby block?
+            # Nothing more to do anyway.
+        end
+
+        # Iterates over all the statements contained in the current block.
+        def each_statement_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement_deep) unless ruby_block
+            # A ruby block?
+            # Apply it on self.
+            ruby_block.call(self)
+            # And that's all.
+        end
 
     end
 
@@ -3989,6 +4118,82 @@ module HDLRuby::Low
     end
 
 
+    ## 
+    # Describes a timed terminate statement: not synthesizable!
+    class TimeTerminate < Statement
+
+        # Creates a new timed terminate statement that terminate execution.
+        def initialize
+            super()
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # And that's all.
+        end
+
+        # Iterates over all the nodes.
+        def each_node(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node) unless ruby_block
+            # A ruby block?
+            # Nothing to do anyway.
+        end
+
+        # Iterates over all the nodes deeply.
+        def each_node_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node_deep) unless ruby_block
+            # A ruby block?
+            # Apply of current node.
+            ruby_block.call(self)
+            # And that's all.
+        end
+
+        # Iterates over all the statements deeply.
+        def each_statement_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement_deep) unless ruby_block
+            # A ruby block?
+            # Apply of current node.
+            ruby_block.call(self)
+            # And that's all.
+        end
+
+        # Iterates over all the blocks contained in the current block.
+        def each_block_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block_deep) unless ruby_block
+            # A ruby block?
+            # Nothing to do anyway.
+        end
+
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(TimeTerminate)
+            return true
+        end
+
+        # Hash function.
+        def hash
+            return TimeTerminate.hash
+        end
+
+        # Clones the TimeRepeat (deeply)
+        def clone
+            return TimeTerminate.new
+        end
+    end
+
+
+
+
     ## 
     # Describes a block.
     class Block < Statement