HDLRuby 2.7.5 → 2.7.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4995e808d0aa2901a483011a4848bb9416d68850c95c74b9c2f2bf1fb3f648dc
-  data.tar.gz: 729643cd60228ab9ba4f3ab719e434b48963805ed6f4ac01dbcff2fdd6eb54b9
+  metadata.gz: 2c66f2d8f552623dabccc43ea54a7246d49eb42a6aaf0f6b8a1977e7675221ca
+  data.tar.gz: 10f9b15022166b3fdb90a9a026653f3fec8b5a05f807e468dfed2d1c97d9adf7
 SHA512:
-  metadata.gz: 82316dd87a532dbfa67d86fcdb13ade3f8329912bb6aa56ae0b5a4efe0a6110922912f52ae3558c4683147bb224ae2ed0b67e1d60e265d5d30624b3a2bee77be
-  data.tar.gz: 4df2cfb5c257838246fa2f953b3eeaa751902900ae4ea5319a69ca81f9e7eae49b75163fc621a81b2af1b399360c030ccf8717916c2abb7a5d2ffaad27d2b5df
+  metadata.gz: 3c56c51a83e75ddd03d34d0c305a17595c362077010213e299baf60e8a7e0b52e745c6b8f9ada7db3c4931b99809376ffdc54f3f4bbb122e002a82419f39e7fb
+  data.tar.gz: 3f056bd7523dea35b03188aa689a232afeadb7c24f7608f3207fc2479503081e1e1ce0a55c2ad3cc805721b60e7d559d464d9fa89a6f79f3f962388254eac6e7

data/lib/HDLRuby/hdr_samples/parseq_bench.rb

@@ -0,0 +1,61 @@
+# Check of various par and seq.
+
+# A benchmark for the dff.
+system :parseq_bench do
+    [4].inner :x0, :x1, :x2, :x3
+    [4].inner :y0, :y1, :y2, :y3
+    [4].inner :z00, :z01
+    [4].inner :z10, :z11
+    [4].inner :z20, :z21
+    [4].inner :z30, :z31
+    [4].inner :u0, :u1, :u2, :u3
+    bit[4][-16].constant mem: 16.times.to_a
+
+    par(x0) do
+        z00 <= x0 + y0
+        z01 <= z00 + 1
+        u0 <= mem[z00]
+    end
+
+    seq(y1) do
+        z10 <= x1 + y1
+        z11 <= z10 + 1
+        u1 <= mem[z10]
+    end
+
+    seq(x2,y2) do
+        z20 <= x2 + y2
+        z21 <= z20 + 1
+        u2 <= mem[z20]
+    end
+
+    par do
+        bit[4].constant inc: 1
+        z30 <= x3 + y3
+        z31 <= z30 + inc
+        u3 <= mem[z30]
+    end
+
+
+    timed do
+        x0 <= 1
+        x1 <= 1
+        x2 <= 1
+        x3 <= 1
+        !10.ns
+        y0 <= 2
+        y1 <= 2
+        y2 <= 2
+        y3 <= 2
+        !10.ns
+        x0 <= 3
+        x1 <= 3
+        x2 <= 3
+        x3 <= 3
+        y0 <= 4
+        y1 <= 4
+        y2 <= 4
+        y3 <= 4
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/range_bench.rb

@@ -3,13 +3,16 @@
 # A benchmark for the index access..
 system :if_bench do
     [8].inner :x
-    [2].inner :r0,:r1,:r2,:r3
+    [2].inner :r0,:r1,:r2,:r3, :r4
+    inner :r5
 
     par do
         r0 <= x[1..0]
         r1 <= x[3..2]
         r2 <= x[5..4]
         r3 <= x[7..6]
+        r4 <= x[-1..-2]
+        r5 <= x[-1]
     end
 
     timed do

data/lib/HDLRuby/hdr_samples/rom_nest.rb

@@ -0,0 +1,27 @@
+# Rom access generator, def case.
+def rom_gen(addr,&func)
+    bit[8][-8].constant tbl? => 8.times.map {|i| func.(i).to_i }
+    tbl![addr]
+end
+
+
+
+system :test_rom do
+    [2..0].inner :addr
+    [7..0].inner :data0, :data1, :data2, :data3
+
+    data0 <= rom_gen(addr) { |i| i*i }
+    data1 <= rom_gen(addr) { |i| i*i }
+
+    par do
+        data2 <= rom_gen(addr) { |i| i*i }
+        data3 <= rom_gen(addr) { |i| i*i }
+    end
+
+    timed do
+        8.times do |i|
+            addr <= i
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_channel_other.rb

@@ -0,0 +1,128 @@
+require 'std/channel.rb'
+require 'std/hruby_unit.rb'
+
+include HDLRuby::High::Std
+
+# A clocked handshake channel for testing purpuse.
+channel(:handshake) do |typ,clk|
+    inner has_data: 0
+    inner :set_data
+    inner :get_data
+    typ.inner :data, :data_val
+
+    writer_input :has_data
+    writer_output :set_data, :data_val
+    reader_input :has_data, :data
+    reader_output :get_data
+
+    par(clk.negedge) do
+        hif(set_data) do
+            data <= data_val
+            has_data <= 1
+        end
+        helsif(get_data) do
+            has_data <= 0
+        end
+    end
+
+    # The writer.
+    writer do |blk,target|
+        hif(~has_data) do
+            set_data <= 1
+            data_val <= target
+            blk.call if blk
+        end
+        helse { set_data <= 0 }
+    end
+
+    # The reader
+    reader do |blk,target|
+        hif(has_data) do
+            target <= data
+            get_data <= 1
+            blk.call if blk
+        end
+        helse { get_data <= 0 }
+    end
+end
+
+
+
+# A system writing indefinitely to a channel.
+# Checking usage of channel without declaring a port.
+system :producer8 do |channel|
+    # Inputs of the producer: clock and reset.
+    input :clk, :rst
+    # Inner 8-bit counter for generating values.
+    [8].inner :counter
+
+    # The value production process
+    par(clk.posedge) do
+        hif(rst) { counter <= 0 }
+        helse do
+            channel.write(counter) { counter <= counter + 1 }
+        end
+    end
+end
+
+# A system reading indefinitely from a channel.
+system :consummer8 do |channel|
+    # Input of the consummer: a clock is enough.
+    input :clk
+    # # Instantiate the channel ports
+    # channel.input :ch
+    # Inner buffer for storing the cunsummed value.
+    [8].inner :buf
+
+    # The value consumption process
+    par(clk.posedge) do
+        channel.read(buf)
+    end
+end
+
+
+# A system testing the handshaker.
+Unit.system :hs_test do
+    inner :clk,:rst
+
+    # Declares two handshakers
+    handshake(bit[8],clk).(:hs)
+
+    # For the first handshake
+
+    # Instantiate the producer.
+    producer8(hs).(:producerI).(clk,rst)
+
+    # Instantiate the consummer.
+    consummer8(hs).(:consummerI).(clk)
+
+    test do
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        10.times do
+            clk <= 0
+            !10.ns
+            clk <= 1
+            !10.ns
+        end
+    end
+
+end

data/lib/HDLRuby/hruby_high.rb

@@ -133,6 +133,8 @@ module HDLRuby::High
     module Hmissing
         High = HDLRuby::High
 
+        NAMES = { }
+
         # Missing methods may be immediate values, if not, they are looked up
         # in the upper level of the namespace if any.
         def method_missing(m, *args, &ruby_block)
@@ -140,6 +142,20 @@ module HDLRuby::High
             # Is the missing method an immediate value?
             value = m.to_value
             return value if value and args.empty?
+            # Or is it a uniq name generator?
+            if (m[-1] == '?') then
+                # Yes
+                m = m[0..-2]
+                return NAMES[m] = HDLRuby.uniq_name(m)
+            end
+            # Is in a previous uniq name?
+            if (m[-1] == '!') then
+                pm = m[0..-2]
+                if NAMES.key?(pm) then
+                    # Yes, returns the current corresponding uniq name.
+                    return self.send(NAMES[pm],*args,&ruby_block)
+                end
+            end
             # No, is there an upper namespace, i.e. is the current object
             # present in the space?
             if High.space_index(self) then
@@ -832,8 +848,7 @@ module HDLRuby::High
             # Initialize the set of included systems.
             @includes = {}
 
-            # Builds the scope if a ruby block is provided
-            # (which means the scope is not the top of a system).
+            # Builds the scope if a ruby block is provided.
             self.build(&ruby_block) if block_given?
         end
 
@@ -944,18 +959,20 @@ module HDLRuby::High
             # Set the namespace for buidling the scope.
             High.space_push(@namespace)
             # Build the scope.
-            # @return_value = High.top_user.instance_eval(&ruby_block)
-            res = High.top_user.instance_eval(&ruby_block)
+            @return_value = High.top_user.instance_eval(&ruby_block)
+            # res = High.top_user.instance_eval(&ruby_block)
             High.space_pop
-            # Now gain access to the result within the sub scope.
-            if (res.is_a?(HRef)) then
-                @return_value = res.type.inner(HDLRuby.uniq_name)
-                High.space_push(@namespace)
-                @return_value <= res
-                High.space_pop
-            else
-                @return_value = res
-            end
+            # # Now gain access to the result within the sub scope.
+            # # if (res.is_a?(HRef)) then
+            # if (res.is_a?(HExpression)) then
+            #     High.space_push(@namespace)
+            #     @return_value = res.type.inner(HDLRuby.uniq_name)
+            #     @return_value <= res
+            #     High.space_pop
+            #     @return_value = RefObject.new(self,@return_value)
+            # else
+            #     @return_value = res
+            # end
             # This will be the return value.
             @return_value
         end
@@ -1087,10 +1104,12 @@ module HDLRuby::High
         # Declares a sub scope with possible +name+ and built from +ruby_block+.
         def sub(name = :"", &ruby_block)
             # Creates the new scope.
-            scope = Scope.new(name,&ruby_block)
-            # puts "new scope=#{scope}"
+            # scope = Scope.new(name,&ruby_block)
+            scope = Scope.new(name)
             # Add it
             self.add_scope(scope)
+            # Build it.
+            scope.build(&ruby_block)
             # puts "self=#{self}"
             # puts "self scopes=#{self.each_scope.to_a.join(",")}"
             # Use its return value
@@ -1965,9 +1984,6 @@ module HDLRuby::High
                                                          &ruby_block)
                     # ruby_block.call(*args)
                 end
-                # sub do
-                #     ruby_block.call(*args,*other_block)
-                # end
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
@@ -1975,10 +1991,8 @@ module HDLRuby::High
                 sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
+                    # ruby_block.call(*args,*other_block)
                 end
-                # sub do
-                #     ruby_block.call(*args,*other_block)
-                # end
             end
         end
     end
@@ -2671,6 +2685,20 @@ module HDLRuby::High
         #
         # NOTE: +rng+ can be a single expression in which case it is an index.
         def [](rng)
+            if rng.is_a?(::Range) then
+                first = rng.first
+                if (first.is_a?(::Integer)) then
+                    first = self.type.size+first if first < 0
+                end
+                last = rng.last
+                if (last.is_a?(::Integer)) then
+                    last = self.type.size+last if last < 0
+                end
+                rng = first..last
+            end
+            if rng.is_a?(::Integer) && rng < 0 then
+                rng = self.type.size+rng
+            end
             if rng.respond_to?(:to_expr) then
                 # Number range: convert it to an expression.
                 rng = rng.to_expr
@@ -3007,6 +3035,7 @@ module HDLRuby::High
 
         # Creates a new reference from a +base+ reference and named +object+.
         def initialize(base,object)
+            # puts "New RefObjet with base=#{base}, object=#{object.name}"
             if object.respond_to?(:type) then
                 # Typed object, so typed reference.
                 super(object.type)
@@ -3043,7 +3072,7 @@ module HDLRuby::High
 
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
-            # puts "to_low with base=#{@base} @object=#{@object}"
+            # puts "to_low with base=#{@base} @object=#{@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 
@@ -3608,6 +3637,15 @@ module HDLRuby::High
             High.space_push(@namespace)
             @return_value = High.top_user.instance_eval(&ruby_block)
             High.space_pop
+            # if @return_value.is_a?(HExpression) then
+            #     res = @return_value
+            #     High.space_push(@namespace)
+            #     @return_value = res.type.inner(HDLRuby.uniq_name)
+            #     puts "@return_value name=#{@return_value.name}"
+            #     @return_value <= res
+            #     High.space_pop
+            #     @return_value = RefObject.new(self,@return_value)
+            # end
             @return_value
         end
 
@@ -3797,7 +3835,7 @@ module HDLRuby::High
         # Converts the block to HDLRuby::Low.
         def to_low
             # Create the resulting block
-            blockL = HDLRuby::Low::Block.new(self.mode)
+            blockL = HDLRuby::Low::Block.new(self.mode,self.name)
             # # For debugging: set the source high object 
             # blockL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = blockL

data/lib/HDLRuby/hruby_low.rb

@@ -4058,6 +4058,7 @@ module HDLRuby::Low
 
         # Adds inner signal +signal+.
         def add_inner(signal)
+            # puts "add inner=#{signal.name} in block=#{self}"
             # Check and add the signal.
             unless signal.is_a?(SignalI)
                 raise AnyError,
@@ -4087,6 +4088,7 @@ module HDLRuby::Low
 
         ## Gets an inner signal by +name+.
         def get_inner(name)
+            # puts "name=#{name}, inners=#{@inners.each_key.to_a}"
             return @inners[name.to_sym]
         end
         alias_method :get_signal, :get_inner

data/lib/HDLRuby/hruby_low2c.rb

@@ -356,8 +356,13 @@ module HDLRuby::Low
             end
             self.scope.each_block_deep do |block|
                 block.each_inner do |signal|
-                    # res << signal.value.to_ch if signal.value
-                    signal.value.to_ch(res) if signal.value
+                    # signal.value.to_ch(res) if signal.value
+                    if signal.value then
+                        signal.value.each_node_deep do |node|
+                            # res << node.to_ch if node.is_a?(Value)
+                            node.to_ch(res) if node.is_a?(Value)
+                        end
+                    end
                 end
                 block.each_node_deep do |node|
                     # res << node.to_ch if node.is_a?(Value)
@@ -702,6 +707,10 @@ module HDLRuby::Low
                 end.to_a
                 # Keep only one ref per signal.
                 refs.uniq! { |node| node.full_name }
+                # Remove the inner signals from the list.
+                self.block.each_inner do |inner|
+                    refs.delete_if {|r| r.name == inner.name }
+                end
                 # Generate the event.
                 events = refs.map {|ref| Event.new(:anyedge,ref.clone) }
                 # Add them to the behavior for further processing.
@@ -891,11 +900,12 @@ module HDLRuby::Low
             if self.value then
                 # There is an initial value.
                 res << " " * (level+1)*3
-                # res << "copy_value(#{self.value.to_c(level+2)}," +
-                #        "signalI->c_value);\n"
+                # res << "copy_value("
+                # self.value.to_c_expr(res,level+2)
+                # res << ",signalI->c_value);\n"
                 res << "copy_value("
                 self.value.to_c_expr(res,level+2)
-                res << ",signalI->c_value);\n"
+                res << ",signalI->f_value);\n"
             end
 
             # Initially the signal can be overwritten by anything.
@@ -1893,6 +1903,16 @@ module HDLRuby::Low
             # Should never be here.
             raise AnyError, "Internal error: to_c should be implemented in class :#{self.class}"
         end
+
+        ## Generates the C text for an expression access to the expression,
+        #  default case.
+        #  +level+ is the hierachical level of the object.
+        def to_c_expr(res,level = 0)
+            res << "({"
+            self.to_c(res,level+1)
+            res << (" " * ((level+1)*3))
+            res << "pop();})"
+        end
     end
 
 
@@ -2455,46 +2475,64 @@ module HDLRuby::Low
             return res
         end
 
-        # Generates the C text of expression for the equivalent HDLRuby code.
-        # +level+ is the hierachical level of the object.
-        def to_c_expr(res,level = 0)
-            # Gather the content to concat.
-            expressions = self.each_expression.to_a
-            # Create the resulting string.
-            res << "({\n"
-            # Overrides the upper src0, src1, ..., and dst...
-            # And allocates a new value for dst.
-            res << (" " * ((level+1)*3))
-            res << "Value "
-            res << expressions.size.times.map do |i| 
-                "src#{i}"
-            end.join(",")
-            res << ";\n"
-            res << (" " * ((level+1)*3))
-            res << "Value dst = get_value();\n"
-            # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
-            # Compute each sub expression.
-            expressions.each_with_index do |expr,i|
-                res << (" " * ((level+1)*3))
-                res << "src#{i} = "
-                expr.to_c_expr(res,level+2)
-                res << ";\n"
-            end
-            # Compute the direction.
-            # Compute the resulting concatenation.
-            res << (" " * ((level+1)*3))
-            res << "concat_value(#{expressions.size},"
-            res << "#{self.type.direction == :little ? 1 : 0},dst,"
-            res << expressions.size.times.map { |i| "src#{i}" }.join(",")
-            res << ");\n"
-            # Save the value pool state.
-            res << (" " * (level*3)) << "SV;\n"
-            # Close the computation.
-            res << (" " * (level*3))
-            res << "dst; })"
-            return res
-        end
+        # # # Generates the C text of expression for the equivalent HDLRuby code.
+        # # # +level+ is the hierachical level of the object.
+        # # def to_c_expr(res,level = 0)
+        # #     # Gather the content to concat.
+        # #     expressions = self.each_expression.to_a
+        # #     # Create the resulting string.
+        # #     res << "({\n"
+        # #     # Overrides the upper src0, src1, ..., and dst...
+        # #     # And allocates a new value for dst.
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "Value "
+        # #     res << expressions.size.times.map do |i| 
+        # #         "src#{i}"
+        # #     end.join(",")
+        # #     res << ";\n"
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "Value dst = get_value();\n"
+        # #     # Save the value pool state.
+        # #     res << (" " * (level*3)) << "SV;\n"
+        # #     # Compute each sub expression.
+        # #     expressions.each_with_index do |expr,i|
+        # #         res << (" " * ((level+1)*3))
+        # #         res << "src#{i} = "
+        # #         expr.to_c_expr(res,level+2)
+        # #         res << ";\n"
+        # #     end
+        # #     # Compute the direction.
+        # #     # Compute the resulting concatenation.
+        # #     res << (" " * ((level+1)*3))
+        # #     res << "concat_value(#{expressions.size},"
+        # #     res << "#{self.type.direction == :little ? 1 : 0},dst,"
+        # #     res << expressions.size.times.map { |i| "src#{i}" }.join(",")
+        # #     res << ");\n"
+        # #     # Save the value pool state.
+        # #     res << (" " * (level*3)) << "SV;\n"
+        # #     # Close the computation.
+        # #     res << (" " * (level*3))
+        # #     res << "dst; })"
+        # #     return res
+        # # end
+        # def to_c_expr(res,level = 0)
+        #     # Save the value pool state.
+        #     res << "({ PV;"
+        #     # Gather the content to concat.
+        #     expressions = self.each_expression.to_a
+        #     # Compute each sub expression.
+        #     expressions.each_with_index do |expr,i|
+        #         expr.to_c(res,level+2)
+        #     end
+        #     # Compute the resulting concatenation.
+        #     res << (" " * ((level+1)*3))
+        #     res << "sconcat(#{expressions.size},"
+        #     res << (self.type.direction == :little ? "1" : "0")
+        #     res << ");\n"
+        #     # Restore the value pool state.
+        #     res << "RV; pop();})"
+        #     return res
+        # end
     end
 
 
@@ -2778,17 +2816,11 @@ module HDLRuby::Low
         # +left+ tells if it is a left value or not.
         # def to_c(level = 0, left = false)
         def to_c(res,level = 0, left = false)
-            # # puts "RefName to_c for #{self.name}"
-            # self.resolve.to_c_signal(res,level+1)
-            # res << "->" << (left ? "f_value" : "c_value")
-            # return res
             # puts "RefName to_c for #{self.name}"
             res << (" " * (level*3))
-            # res << "d="
             res << "push("
             self.resolve.to_c_signal(res,level+1)
             res << "->" << (left ? "f_value" : "c_value")
-            # res << ";\n"
             res << ");\n"
             return res
         end

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -50,9 +50,25 @@ module HDLRuby::Low
             return found if found
             # Maybe it is a sub scope.
             return self.each_scope.find { |scope| scope.name == name }
+            # Maybe it in the behavior.
+            return self.behavior.get_by_name
         end
     end
 
+    ##
+    #  Extends Behavior with the capability of finding one of its inner object
+    #  by name.
+    class Behavior
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            if (self.block.name == name.to_sym) then
+                return self.block
+            end
+            return self.block.get_by_name(name)
+        end
+    end
 
     ##
     #  Extends SystemI with the capability of finding one of its inner object
@@ -79,7 +95,16 @@ module HDLRuby::Low
             # Ensure the name is a symbol.
             name = name.to_sym
             # Look in the signals.
-            return self.get_inner(name)
+            found = self.get_inner(name)
+            return found if found
+            # Check the sub blocks names.
+            self.each_block do |block|
+                # puts "block=#{block.name}"
+                if (block.name == name) then
+                    return block
+                end
+            end
+            return nil
         end
     end
 
@@ -199,6 +224,7 @@ module HDLRuby::Low
             if self.ref.is_a?(RefName) then
                 # puts "ref name=#{self.ref.name}"
                 obj = self.ref.resolve
+                # puts "obj=#{obj}"
                 # Look into the object for the name.
                 return obj.get_by_name(self.name)
             else
@@ -208,12 +234,15 @@ module HDLRuby::Low
                 while parent
                     # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
+                        # puts "get_by_name"
                         found = parent.get_by_name(self.name)
+                        # puts "found" if found
                         return found if found
                     end
                     parent = parent.parent
                 end
                 # Not found.
+                # puts "Not found!"
                 return nil
             end
         end

data/lib/HDLRuby/hruby_tools.rb

@@ -1,5 +1,6 @@
 require 'set'
 
+
 module HDLRuby
 
 ##

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -108,7 +108,7 @@ void register_signal(SignalI signal) {
 /** Recursively update the signals until no (untimed) behavior are
  *  activated. */
 void hruby_sim_update_signals() {
-    // printf("hruby_sim_update_signals...\n");
+     // printf("hruby_sim_update_signals...\n");
     /* As long as the list of touched signals is not empty go on computing. */
     while(!empty_list(touched_signals) || !empty_list(touched_signals_seq)) {
         // printf("## Checking touched signals.\n");
@@ -121,7 +121,6 @@ void hruby_sim_update_signals() {
             /* Is there a change? */
             if (same_content_value(sig->c_value,sig->f_value)) continue;
             /* Yes, process the signal. */
-            // println_signal(sig);
             printer.print_signal(sig);
             // printf("c_value="); printer.print_value(sig->c_value);
             // printf("\nf_value="); printer.print_value(sig->f_value); printf("\n");
@@ -441,6 +440,10 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
         /* Update the signal values (recursively executing blocks locked
          * on the signals). */
         hruby_sim_update_signals(); 
+        if (hruby_sim_time == 0) {
+            /* Initially touch all the signals. */
+            each_all_signal(&touch_signal);
+        }
         if (num_run_behaviors <= 0) break;
         /* Advance time to next timestep. */
         hruby_sim_advance_time();

data/lib/HDLRuby/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.7.5
+  version: 2.7.11
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-11 00:00:00.000000000 Z
+date: 2022-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -125,11 +125,13 @@ files:
 - lib/HDLRuby/hdr_samples/neural/selector.rb
 - lib/HDLRuby/hdr_samples/neural/sigmoid.rb
 - lib/HDLRuby/hdr_samples/neural/z.rb
+- lib/HDLRuby/hdr_samples/parseq_bench.rb
 - lib/HDLRuby/hdr_samples/prog.obj
 - lib/HDLRuby/hdr_samples/ram.rb
 - lib/HDLRuby/hdr_samples/range_bench.rb
 - lib/HDLRuby/hdr_samples/register_with_code_bench.rb
 - lib/HDLRuby/hdr_samples/rom.rb
+- lib/HDLRuby/hdr_samples/rom_nest.rb
 - lib/HDLRuby/hdr_samples/ruby_fir_hw.rb
 - lib/HDLRuby/hdr_samples/seqpar_bench.rb
 - lib/HDLRuby/hdr_samples/struct.rb
@@ -142,6 +144,7 @@ files:
 - lib/HDLRuby/hdr_samples/type_minmax_bench.rb
 - lib/HDLRuby/hdr_samples/with_casts.rb
 - lib/HDLRuby/hdr_samples/with_channel.rb
+- lib/HDLRuby/hdr_samples/with_channel_other.rb
 - lib/HDLRuby/hdr_samples/with_class.rb
 - lib/HDLRuby/hdr_samples/with_concat.rb
 - lib/HDLRuby/hdr_samples/with_connector.rb