HDLRuby 2.7.11 → 2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c66f2d8f552623dabccc43ea54a7246d49eb42a6aaf0f6b8a1977e7675221ca
-  data.tar.gz: 10f9b15022166b3fdb90a9a026653f3fec8b5a05f807e468dfed2d1c97d9adf7
+  metadata.gz: 90d139cd510b6600a32249a2e27969f6c415a49d9b26ba51ed84d20dcc82f2ba
+  data.tar.gz: b064d08cfbd46ae6fa4dffc7536a2dece4aed9c1c7588118502df79dd288c5bb
 SHA512:
-  metadata.gz: 3c56c51a83e75ddd03d34d0c305a17595c362077010213e299baf60e8a7e0b52e745c6b8f9ada7db3c4931b99809376ffdc54f3f4bbb122e002a82419f39e7fb
-  data.tar.gz: 3f056bd7523dea35b03188aa689a232afeadb7c24f7608f3207fc2479503081e1e1ce0a55c2ad3cc805721b60e7d559d464d9fa89a6f79f3f962388254eac6e7
+  metadata.gz: 40ced20f6723ff46f4c02a033c1d194e5ce267c75e7f2c22e6c70dd6f51ae9b530ebdc7dc7150970f3fefbf2ec4663c965a3a3fddf1c1b2369d6dac42317ba0c
+  data.tar.gz: 7782898ea6de9b5e42015f84dc56929ecd038baf42337c1f69f96bc644f0692ddd00ada0db0f9910b8ae7d93d2516ed4b3819c9f8735268d0a952f72b56bb37e

data/lib/HDLRuby/hdr_samples/adder_gen.rb

@@ -5,3 +5,25 @@ system :adder do |w|
 
     s <= x.as(bit[w+1]) + y
 end
+
+
+# Testing the generic adder.
+system :adder_bench do
+    width = 4
+    [width].inner :x,:y
+    [width+1].inner :z
+
+    adder(width).(:my_adder).(x,y,z)
+
+    timed do
+        x <= 0
+        y <= 0
+        !10.ns
+        x <= 1
+        !10.ns
+        y <= 1
+        !10.ns
+        x <= 15
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/adder_gen_gen.rb

@@ -0,0 +1,40 @@
+# A simple generic adder
+system :adder do |w|
+    [(w-1)..0].input :i,:j
+    [w..0].output :k
+
+    k <= i.as(bit[w+1]) + j
+end
+
+# A module embedding two generic adders.
+system :two_adders do |w|
+    [w*2].input :x, :y
+    [(w+1)*2].output :z
+
+    adder(w).(:adderI0).(x[(w-1)..0],y[(w-1)..0],z[w..0])
+    adder(w).(:adderI1).(x[(w*2-1)..w],y[(w*2-1)..w],z[(w*2+1)..(w+1)])
+end
+
+
+# Testing the generic adder.
+system :adder_bench do
+    width = 4
+    [width*2].inner :a,:b
+    [(width+1)*2].inner :c
+
+    two_adders(width).(:my_adders).(a,b,c)
+
+    timed do
+        a <= 0
+        b <= 0
+        !10.ns
+        a <= 1
+        !10.ns
+        b <= 1
+        !10.ns
+        a <= 255
+        !10.ns
+        b <= 128
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/dff_unit.rb

@@ -6,7 +6,7 @@
 3.times do |i|
 
     # A simple D-FF
-    system:"dff#{i}" do
+    system :"dff#{i}" do
         input :clk, :rst, :d
         output :q, :qb
 

data/lib/HDLRuby/hdr_samples/with_def.rb

@@ -0,0 +1,29 @@
+# A test of def.
+def lut84(content,addr)
+   bit[8][-4].inner tbl? => content.to_a
+   tbl![addr]
+end
+
+
+# A benchmark for testing the initialization of signals.
+system :def_bench do
+
+    [2].inner :addr
+    [8].inner :val0, :val1
+
+    par do
+        val0 <= lut84([0,1,4,9],addr)
+        val1 <= lut84([0,1,4,9],3-addr)
+    end
+
+    timed do
+        addr <= 0
+        !10.ns
+        addr <= 1
+        !10.ns
+        addr <= 2
+        !10.ns
+        addr <= 3
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_reconf.rb

@@ -4,60 +4,16 @@ include HDLRuby::High::Std
 
 
 
-
-# Implementation of a vivado partial reconfiguration system.
-reconf(:vivado_reconf) do |clk,rst|
-
-    # Get access to the interface of the reconfigurable component.
-    inputs = each_input
-    outputs = each_output
-    inouts = each_inout
-
-    # Create the main system with the interface and a channel for
-    # handling the reconfiguration.
-    main = system do
-        # Declares the inputs.
-        inputs.each do |i|
-            i.type.input(i.name)
-        end
-        # Declares the outputs.
-        outputs.each do |o|
-            o.type.output(o.name)
-        end
-        # Declares the inouts.
-        inouts.each do |io|
-            io.type.inout(io.name)
-        end
-        # An that's all: in vivado the main system is to be a black-box.
-    end
-
-    # And set it as the main system.
-    set_main(main)
-
-    # The switching circuit.
-    # reconfer = vivado_reconfigurer :do_reconf # Will be that later
-    # reconfer.clk <= clk 
-    # reconfer.rst <= rst 
-    reconfer = proc do |idx|
-        puts "Instantiating reconfiguration circuits with #{idx}"
-    end
-
-    # Defines the reconfiguring procedure: switch to system idx.
-    switcher do |idx,ruby_block|
-        reconfer.call(idx)
-        ruby_block.call
-    end
-
-end
-
-
-# Some system that can be used for recponfiguration.
+# Some system that can be used for reconfiguration.
 system :sys0 do
     input :clk,:rst
     input :d
     output :q
 
-    q <= d
+    par(clk.posedge) do
+        hprint("sys0\n")
+        q <= d & ~rst
+    end
 end
 
 system :sys1 do
@@ -65,7 +21,10 @@ system :sys1 do
     input :d
     output :q
 
-    (q <= d).at(clk.posedge)
+    par(clk.posedge, rst.posedge) do
+        hprint("sys1\n")
+        q <= d & ~rst
+    end
 end
 
 system :sys2 do
@@ -73,7 +32,10 @@ system :sys2 do
     input :d
     output :q
 
-    (q <= d & ~rst).at(clk.posedge)
+    par(clk.posedge, rst.negedge) do
+        hprint("sys2\n")
+        q <= d & ~rst
+    end
 end
 
 # A system with a reconfifurable part.
@@ -81,23 +43,69 @@ system :with_reconf do
     input :clk,:rst
     input :d
     output :q
-    [2].input :conf # The configuration number
-
-    inner :wait_reconf
 
-    # Create a reconfigurable component.
-    vivado_reconf(clk,rst).(:my_reconf)
-    # It is to be reconfigured to sys0, sys1 or sys2
-    my_reconf.(sys0, sys1, sys2)
-
-    # Connect the reconfigurable instance.
-    my_reconf.instance.(clk,rst,d,q)
-
-    par(clk.posedge) do
-        hif(rst) { wait_reconf <= 0 }
-        helsif(conf != 0 && my_reconf.index != conf && wait_reconf == 0) do
-            wait_reconf <= 1
-            my_reconf.switch(conf) { wait_reconf <= 0 }
+    # Instantiate the default configuration.
+    sys0(:my_dff).(clk,rst,d,q)
+
+    # Adds the additional configuration.
+    my_dff.choice(conf1: sys1, conf2: sys2)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        d <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        3.times do |i|
+            clk <= 1
+            !10.ns
+            clk <= 0
+            d <= 1
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+            d <= 0
+            !10.ns
+            clk <= 1
+            my_dff.configure((i+1)%3)
+            !10.ns
+            clk <= 0
+            !10.ns
         end
+        clk <= 1
+        !10.ns
+        clk <= 0
+        d <= 1
+        !10.ns
+        clk <= 1
+        my_dff.configure(:conf1)
+        !10.ns
+        clk <= 0
+        d <= 0
+        !10.ns
+        clk <= 1
+        my_dff.configure(:conf2)
+        !10.ns
+        clk <= 0
+        d <= 1
+        !10.ns
+        clk <= 1
+        my_dff.configure(:my_dff)
+        !10.ns
+        clk <= 0
+        d <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/with_terminate.rb

@@ -0,0 +1,32 @@
+
+# A benchmark for testing the terminate statement.
+system :with_terminate do
+    [8].constant cst0: 127
+    constant cst1: _1
+    [8].inner sig0: _10000000
+    inner sig1: _1
+    [8].inner :sig2
+    [8].inner count: 0
+
+    timed do
+        !20.ns
+        100.times do
+            count <= count + 1
+            !20.ns
+        end
+    end
+
+    timed do
+        !10.ns
+        sig2  <= cst0 + cst1
+        sig0  <= sig0 + sig1
+        !10.ns
+        sig2 <= sig2 + sig1
+        !10.ns
+        terminate
+        sig0 <= sig0 + sig0
+        !10.ns
+        sig0 <= sig0 + sig0
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -647,12 +647,19 @@ elsif $options[:clang] then
         init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
                                            "init_default_visualizer"
 
+        # Gather the system to generate and sort them in the right order
+        # to ensure references are generated before being used.
+        # Base: reverse order of the tree.
+        # Then, multiple configuration of a system instance must be
+        # reverversed so that the base configuration is generated first.
+        c_systems = $top_system.each_systemT_deep_ref
         # Generate the code of the main function.
         # HDLRuby start code
         $main << HDLRuby::Low::Low2C.main("hruby_simulator",
                                          init_visualizer,
                                          $top_system,
-                                         $top_system.each_systemT_deep.to_a.reverse,$hnames)
+                                         c_systems,
+                                         $hnames)
         $main.close
 
         $top_system.each_systemT_deep do |systemT|

data/lib/HDLRuby/hruby_high.rb

@@ -2119,6 +2119,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 +2203,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 +2484,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
@@ -3369,6 +3432,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 +3886,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

@@ -165,6 +165,22 @@ module HDLRuby::Low
 
 
 
+        # 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+.
@@ -432,6 +448,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 +2537,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 +2601,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 +3821,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 +4116,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

data/lib/HDLRuby/hruby_low2c.rb

@@ -135,6 +135,8 @@ module HDLRuby::Low
             objs.each { |obj| res << "   " << Low2C.make_name(obj) << "();\n" }
             # Sets the top systemT.
             res << "   top_system = " << Low2C.obj_name(top) << ";\n"
+            # Enable it.
+            res << "   set_enable_system(top_system,1);\n"
             # Starts the simulation.
             res<< "   hruby_sim_core(\"#{name}\",#{init_visualizer},-1);\n"
             # Close the main.
@@ -170,6 +172,7 @@ module HDLRuby::Low
         # is the list of extra h files to include.
         # def to_c(level = 0, *hnames)
         def to_c(res, level = 0, *hnames)
+            # puts "SystemT.to_c with name=#{Low2C.obj_name(self)}#{@wrapper ? " and wrapper=#{Low2C.obj_name(@wrapper)}" : ""}"
             # The header
             # res = Low2C.includes(*hnames)
             res << Low2C.includes(*hnames)
@@ -179,7 +182,16 @@ module HDLRuby::Low
 
             # Generate the signals of the system.
             # self.each_signal { |signal| signal.to_c(level) }
-            self.each_signal { |signal| signal.to_c(res,level) }
+            if ((defined? @wrapper) && @wrapper) then
+                # It is a reconfiguring system, alias the signals.
+                wrap_signals = @wrapper.each_signal.to_a
+                self.each_signal.with_index do |signal,i|
+                    signal.to_c_alias(res,wrap_signals[i],level)
+                end
+            else
+                # It is a single system, default generation.
+                self.each_signal { |signal| signal.to_c(res,level) }
+            end
 
             # Generate the code for all the blocks included in the system.
             self.scope.each_scope_deep do |scope|
@@ -686,6 +698,10 @@ module HDLRuby::Low
                 res << "behavior->owner = NULL;\n"
             end
 
+            # Set the behavior as not enabled. */
+            res << " " * (level+1)*3
+            res << "behavior->enabled = 0;\n"
+
             # Set the behavior as inactive. */
             res << " " * (level+1)*3
             res << "behavior->activated = 0;\n"
@@ -842,11 +858,8 @@ module HDLRuby::Low
         #  +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
-            # The resulting string.
-            # res = ""
-
+            # puts "Signal.to_c with name: #{Low2C.obj_name(self)}"
             # Declare the global variable holding the signal.
-            # res << "SignalI #{self.to_c_signal(level+1)};\n\n"
             res << "SignalI "
             self.to_c_signal(res,level+1)
             res << ";\n\n"
@@ -854,6 +867,7 @@ module HDLRuby::Low
             # The header of the signal generation.
             res << " " * level*3
             res << "SignalI " << Low2C.make_name(self) << "() {\n"
+
             # res << " " * level*3
             # res << "Value l,r,d;\n"
             # res << " " * (level+1)*3
@@ -866,7 +880,6 @@ module HDLRuby::Low
             # Sets the global variable of the signal.
             res << "\n"
             res << " " * (level+1)*3
-            # res << "#{self.to_c_signal(level+1)} = signalI;\n"
             self.to_c_signal(res,level+1)
             res << " = signalI;\n"
 
@@ -958,6 +971,43 @@ module HDLRuby::Low
 
             return res;
         end
+
+        ## Generates the C text of the equivalent HDLRuby code in case
+        #  the signals is actually an alias to another signal.
+        #  +other+ is the target signal of the alias.
+        #  +level+ is the hierachical level of the object.
+        def to_c_alias(res,target,level = 0)
+            # puts "Signal.to_c_alias with name: #{Low2C.obj_name(self)}"
+            # The resulting string.
+            # res = ""
+
+            # Declare the global variable holding the signal.
+            res << "SignalI "
+            self.to_c_signal(res,level+1)
+            res << ";\n\n"
+
+            # The header of the signal generation.
+            res << " " * level*3
+            res << "SignalI " << Low2C.make_name(self) << "() {\n"
+
+            res << "SignalI signalI = #{Low2C.obj_name(target)};\n"
+
+            # Sets the global variable of the signal.
+            res << "\n"
+            res << " " * (level+1)*3
+            self.to_c_signal(res,level+1)
+            res << " = signalI;\n"
+
+            # Generate the return of the signal.
+            res << "\n"
+            res << " " * (level+1)*3
+            res << "return signalI;\n"
+
+            # Close the signal.
+            res << " " * level*3
+            res << "};\n\n"
+            return res
+        end
     end
 
 
@@ -999,9 +1049,22 @@ module HDLRuby::Low
             # Set the name
             res << " " * (level+1)*3
             res << "systemI->name = \"#{self.name}\";\n"
-            # Set the type.
+            # # Set the type.
+            # res << " " * (level+1)*3
+            # res << "systemI->system = " << Low2C.obj_name(self.systemT) << ";\n"
+            # Set the systems.
+            num_sys = self.each_systemT.to_a.size
             res << " " * (level+1)*3
-            res << "systemI->system = " << Low2C.obj_name(self.systemT) << ";\n"
+            res << "systemI->num_systems = #{num_sys};\n"
+            res << " " * (level+1)*3
+            res << "systemI->systems = calloc(sizeof(SystemT), #{num_sys});\n"
+            self.each_systemT.with_index do |sysT,i|
+                res << " " * (level+1)*3
+                res << "systemI->systems[#{i}] = #{Low2C.obj_name(sysT)};\n"
+            end
+
+            # Configure the instance to current systemT.
+            res << (" " * (level*3)) << "configure(systemI,0);\n"
 
             # Generate the return of the signal.
             res << "\n"
@@ -1100,6 +1163,10 @@ module HDLRuby::Low
                 res << "code->owner = NULL;\n"
             end
 
+            # Set the code as enabled (for now, may change in a near future). */
+            res << " " * (level+1)*3
+            res << "code->enabled = 1;\n"
+
             # Set the code as inactive. */
             res << " " * (level+1)*3
             res << "code->activated = 0;\n"
@@ -1392,6 +1459,28 @@ module HDLRuby::Low
         end
     end
 
+    ## Extends the TimeTerminate class with generation of C text.
+    class TimeTerminate
+
+        # Generates the C text of the equivalent HDLRuby code.
+        # +level+ is the hierachical level of the object.
+        def to_c(res,level = 0)
+            # Save the value pool state.
+            res << (" " * (level*3)) << "terminate();\n"
+        end
+    end
+
+    ## Extends the Configure class with generation of C text.
+    class Configure
+
+        # Generates the C text of the equivalent HDLRuby code.
+        # +level+ is the hierachical level of the object.
+        def to_c(res,level = 0)
+            # Save the value pool state.
+            res << (" " * (level*3)) << "configure(#{Low2C.obj_name(self.ref.resolve)},#{self.index});\n"
+        end
+    end
+
     
     ## Extends the If class with generation of C text.
     class If

data/lib/HDLRuby/hruby_low2vhd.rb

@@ -925,6 +925,18 @@ module HDLRuby::Low
             end.join(" & ") + ";\n"
         end
     end
+
+    ## Extends the TimeTerminate class with generation of HDLRuby::High text.
+    class TimeTerminate
+
+        # Generates the text of the equivalent HDLRuby::High code.
+        # +vars+ is the list of the variables and
+        # +level+ is the hierachical level of the object.
+        def to_vhdl(vars,level = 0)
+            # Generate a report statement.
+            return " " * (level*3) + "finish;\n"
+        end
+    end
     
     ## Extends the If class with generation of HDLRuby::High text.
     class If

data/lib/HDLRuby/hruby_low_bool2select.rb

@@ -75,6 +75,18 @@ module HDLRuby::Low
         end
     end
 
+
+    ## Extends the TimeTerminate class with functionality for converting booleans
+    #  in assignments to select operators.
+    class TimeTerminate
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # Nothing to do.
+            return self
+        end
+    end
+
     
     ## Extends the If class with functionality for converting booleans
     #  in assignments to select operators.

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -71,7 +71,7 @@ module HDLRuby::Low
     class Statement
         # Explicit the types conversions in the statement.
         def explicit_types!
-            raise "Should implement explicit_types for class #{self.class}."
+            raise "Should implement explicit_types! for class #{self.class}."
         end
     end
 
@@ -98,7 +98,26 @@ module HDLRuby::Low
             self.map_args!(&:explicit_types)
             return self
         end
+    end
+
+
+    ## Extends the Configure class with fixing of types and constants.
+    class Configure
+        # Explicit the types conversions in the statement.
+        def explicit_types!
+            # Nothing to do.
+            return self
+        end
+    end
 
+
+    ## Extends the TimeTerminate class with fixing of types and constants.
+    class TimeTerminate
+        # Explicit the types conversions in the statement.
+        def explicit_types!
+            # Nothing to do.
+            return self
+        end
     end
 
 

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -242,7 +242,7 @@ module HDLRuby::Low
                     parent = parent.parent
                 end
                 # Not found.
-                # puts "Not found!"
+                puts "Not found!"
                 return nil
             end
         end

data/lib/HDLRuby/hruby_low_without_select.rb

@@ -163,7 +163,7 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the String class with functionality for converting select
+    ## Extends the Print class with functionality for converting select
     #  expressions to case statements.
     class Print
         # Extract the Select expressions.
@@ -175,6 +175,16 @@ module HDLRuby::Low
             return selects
         end
     end
+
+    ## Extends the TimeTerminate class with functionality for converting select
+    #  expressions to case statements.
+    class TimeTerminate
+        # Extract the Select expressions.
+        def extract_selects!
+            # Nothing to extract.
+            return []
+        end
+    end
     
     ## Extends the If class with functionality for converting select
     #  expressions to case statements.

data/lib/HDLRuby/hruby_verilog.rb

@@ -171,7 +171,7 @@ module HDLRuby::Low
 
     # Enhance Print with generation of verilog code.
     class Print
-        # Converts the system to Verilog code.
+        # Converts the print to Verilog code.
         def to_verilog(spc = 3)
             code = "#{" " * spc}$write(#{self.each_arg.map do |arg|
             arg.to_verilog
@@ -180,6 +180,14 @@ module HDLRuby::Low
         end
     end
 
+    # Enhance TimeTerminate with generation of verilog code.
+    class TimeTerminate
+        # Converts the terminate to Verilog code.
+        def to_verilog(spc = 3)
+            return "#{" " * spc}$finish;"
+        end
+    end
+
     # To scheduling to the Block.
     # Enhance Block with generation of verilog code.
     class Block

data/lib/HDLRuby/sim/hruby_sim.h

@@ -467,7 +467,10 @@ typedef struct SystemIS_ {
     Object owner;       /* The owner if any. */
 
     char* name;         /* The name of the signal. */
-    SystemT system;     /* The instantiated system. */
+    SystemT system;     /* The currently instantiated system. */
+
+    int num_systems;    /* The number of systems possibly instantiated here. */
+    SystemT* systems;   /* The systems possibly instantiated here. */
 } SystemIS;
 
 
@@ -499,6 +502,8 @@ typedef struct BehaviorS_ {
     Event* events;      /* The events of the behavior. */
     Block block;        /* The block of the behavior. */
 
+    int enabled;        /* Tells if the behavior is enabled or not. */
+
     int activated;      /* Tells if the behavior is activated or not. */
 
     int timed;          /* Tell if the behavior is timed or not:
@@ -519,6 +524,8 @@ typedef struct CodeS_ {
     Event* events;      /* The events of the behavior. */
     void (*function)(); /* The function to execute for the code. */
 
+    int enabled;        /* Tells if the behavior is enabled or not. */
+
     int activated;      /* Tells if the code is activated or not. */
 } CodeS;
 
@@ -623,6 +630,16 @@ extern unsigned long long make_delay(int value, Unit unit);
  * @param func function to applie on each signal. */
 extern void each_all_signal(void (*func)(SignalI));
 
+
+/** Configure a system instance.
+ *  @param systemI the system instance to configure.
+ *  @param idx the index of the target system. */
+extern void configure(SystemI systemI, int idx);
+
+
+/** Terminates the simulation. */
+extern void terminate();
+
 /* Interface to the visualization engine. */
 
 typedef struct {
@@ -701,6 +718,11 @@ extern void init_vcd_visualizer(char* name);
 
 /* The interface to the simulator core. */
 
+/** Sets the enable status of the behaviors of a system type. 
+ *  @param systemT the system type to process.
+ *  @param status the enable status. */
+extern void set_enable_system(SystemT systemT, int status);
+
 /** The simulation core function.
  *  @param name the name of the simulation.
  *  @param init_vizualizer the vizualizer engine initializer.

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -253,8 +253,8 @@ void hruby_sim_update_signals() {
             if (obj->kind == BEHAVIOR) {
                 /* Behavior case. */
                 Behavior beh = (Behavior)obj;
-                /* Is the code really activated? */
-                if (beh->activated) {
+                /* Is the code really enabled and activated? */
+                if (beh->enabled && beh->activated) {
                     /* Yes, execute it. */
                     beh->block->function();
                     /* And deactivate it. */
@@ -264,7 +264,7 @@ void hruby_sim_update_signals() {
                 /* Other code case. */
                 Code cod = (Code)obj;
                 /* Is the code really activated? */
-                if (cod->activated) {
+                if (cod->enabled && cod->activated) {
                     /* Yes, execute it. */
                     cod->function();
                     /* And deactivate it. */
@@ -294,6 +294,35 @@ void hruby_sim_advance_time() {
 }
 
 
+/** Sets the enamble status of the behaviors of a scope.
+ *  @param scope the scope to process.
+ *  @param status the enable status. */
+static void set_enable_scope(Scope scope, int status) {
+    int i;
+    int num_beh = scope->num_behaviors;
+    Behavior*  behs = scope->behaviors;
+    int num_scp = scope->num_scopes;
+    Scope* scps = scope->scopes;
+
+    /* Enable the behaviors. */
+    for(i=0; i<num_beh; ++i) {
+        behs[i]->enabled = status;
+    }
+
+    /* Recurse on the sub scopes. */
+    for(i=0; i<num_scp; ++i) {
+        set_enable_scope(scps[i],status);
+    }
+}
+
+/** Sets the enable status of the behaviors of a system type. 
+ *  @param systemT the system type to process.
+ *  @param status the enable status. */
+void set_enable_system(SystemT systemT, int status) {
+    set_enable_scope(systemT->scope,status);
+}
+
+
 /** Activates a behavior.
  *  @param behavior the behavior to activate. */
 void activate_behavior(Behavior behavior) {
@@ -359,7 +388,8 @@ void* behavior_run(void* arg) {
     pthread_mutex_unlock(&hruby_sim_mutex);
     // printf("#2\n");
     /* Now can start the execution of the behavior. */
-    behavior->block->function();
+    if (behavior->enabled)
+        behavior->block->function();
     // printf("#3\n");
     /* Now can start the execution of the behavior. */
     /* Stops the behavior. */
@@ -635,11 +665,35 @@ unsigned long long make_delay(int value, Unit unit) {
 
 
 
-/* Iterate over all the signals.
- * @param func function to applie on each signal. */
+/** Iterates over all the signals.
+ *  @param func function to applie on each signal. */
 void each_all_signal(void (*func)(SignalI)) {
     int i;
     for(i = 0; i<num_all_signals; ++i) {
         func(all_signals[i]);
     }
 }
+
+
+/** Configure a system instance.
+ *  @param systemI the system instance to configure.
+ *  @param idx the index of the target system. */
+void configure(SystemI systemI, int idx) {
+    int i;
+    // printf("Configure to: %i\n",idx);
+    /* Sets the current system type. */
+    systemI->system = systemI->systems[idx];
+    /* Disable all the behaviors of the system instance. */
+    for(i=0; i<systemI->num_systems; ++i) {
+        if (i != idx)
+            set_enable_system(systemI->systems[i],0);
+    }
+    /* Enable the current system. */
+    set_enable_system(systemI->systems[idx],1);
+}
+
+
+/** Terminates the simulation. */
+void terminate() {
+    exit(0);
+}

data/lib/HDLRuby/sim/hruby_sim_vcd.c

@@ -85,7 +85,7 @@ static void vcd_print_name(Object object) {
                 vcd_print("%s",name);
             } else {
                 /* No name, use the address of the object as name generator.*/
-                vcd_print("$%p",(void*)object);
+                vcd_print("x$%p",(void*)object);
             }
             break;
         default: /* Nothing to do */

data/lib/HDLRuby/std/reconf.rb

@@ -8,6 +8,9 @@ module HDLRuby::High::Std
     ## Describes a high-level reconfigurable component type.
     class ReconfT
 
+        extend Gem::Deprecate
+        deprecate :initialize, Configure, 2022, 3
+
         # The name of the reconfigurable component type.
         attr_reader :name
 

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.7.11"
+  VERSION = "2.8.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.7.11
+  version: 2.8.1
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - lib/HDLRuby/hdr_samples/adder_assign_error.rb
 - lib/HDLRuby/hdr_samples/adder_bench.rb
 - lib/HDLRuby/hdr_samples/adder_gen.rb
+- lib/HDLRuby/hdr_samples/adder_gen_gen.rb
 - lib/HDLRuby/hdr_samples/adder_kadai.rb
 - lib/HDLRuby/hdr_samples/adder_nodef_error.rb
 - lib/HDLRuby/hdr_samples/addsub.rb
@@ -150,6 +151,7 @@ files:
 - lib/HDLRuby/hdr_samples/with_connector.rb
 - lib/HDLRuby/hdr_samples/with_connector_memory.rb
 - lib/HDLRuby/hdr_samples/with_decoder.rb
+- lib/HDLRuby/hdr_samples/with_def.rb
 - lib/HDLRuby/hdr_samples/with_fixpoint.rb
 - lib/HDLRuby/hdr_samples/with_fsm.rb
 - lib/HDLRuby/hdr_samples/with_function_generator.rb
@@ -165,6 +167,7 @@ files:
 - lib/HDLRuby/hdr_samples/with_ref_array.rb
 - lib/HDLRuby/hdr_samples/with_str2value.rb
 - lib/HDLRuby/hdr_samples/with_subsums.rb
+- lib/HDLRuby/hdr_samples/with_terminate.rb
 - lib/HDLRuby/hdr_samples/with_to_a.rb
 - lib/HDLRuby/hdr_samples/with_to_array.rb
 - lib/HDLRuby/hdr_samples/with_values.rb