HDLRuby 2.9.0 → 2.10.2

data/lib/HDLRuby/hruby_high.rb

@@ -441,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}"
@@ -474,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)
@@ -489,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.
         #
@@ -496,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|
@@ -510,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.
@@ -869,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?
@@ -956,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
@@ -1249,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.
@@ -1263,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
@@ -1282,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.
@@ -1308,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).
@@ -2074,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
@@ -3158,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 

data/lib/HDLRuby/hruby_low.rb

@@ -184,7 +184,7 @@ module HDLRuby::Low
 
         # 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,
@@ -289,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.
@@ -297,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)

data/lib/HDLRuby/hruby_low2c.rb

@@ -2082,11 +2082,11 @@ module HDLRuby::Low
             if str =~ /^[01]+$/ && str.length <= 64 then
                 # Yes, generate a numeral value.
                 res << " " * (level+1)*3
-                # res << "static unsigned long long data[] = { "
                 res << "static unsigned int data[] = { "
                 res << str.scan(/.{1,#{Low2C.int_width}}/m).reverse.map do |sub|
                     sub.to_i(2).to_s # + "ULL"
                 end.join(",")
+                res << ", 0" if (str.length <= 32)
                 res << " };\n"
                 # Create the value.
                 res << " " * (level+1)*3

data/lib/HDLRuby/hruby_low_without_connection.rb

@@ -92,6 +92,7 @@ module HDLRuby::Low
                             inputs_blk.add_statement(
                                 Transmit.new(right.clone,left.clone))
                         elsif (left_is_o) then
+                            # puts "left=#{left} right=#{right}"
                             outputs_blk.add_statement(
                                 Transmit.new(right.clone,left.clone))
                         elsif (right_is_o) then

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -1871,10 +1871,11 @@ static Value equal_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    // /* Perform the !XOR. */
-    // dst->data_int = ~(src0->data_int ^ src1->data_int);
     /* Perform the comparison. */
     dst->data_int = (src0->data_int == src1->data_int) ? 1 : 0;
+    printf("scr0->data_int=%lld\n",src0->data_int);
+    printf("scr1->data_int=%lld\n",src1->data_int);
+    printf("dst->data_int=%lld\n",dst->data_int);
     return dst;
 }
 

data/lib/HDLRuby/std/delays.rb

@@ -0,0 +1,92 @@
+module HDLRuby::High::Std
+
+##
+# Standard HDLRuby::High library: delays
+#
+########################################################################
+
+
+    ## Module describing a simple delay using handshake for working.
+    #  @param num the number of clock cycles to delay.
+    system :delay do |num|
+        # Checks and process the number of clock to wait.
+        num = num.to_i
+        raise "The delay generic argument must be positive: #{num}" if (num < 0)
+
+        input  :clk     # The clock to make the delay on.
+        input  :req     # The handshake request.
+        output :ack     # The handshake acknoledgment.
+
+        # The process of the delay.
+        if (num == 0) then
+            # No delay case.
+            ack <= req
+        else
+            # The is a delay.
+            inner run: 0               # Tell if the deayl is running.
+            [num.width+1].inner :count # The counter for computing the delay.
+            par(clk.posedge) do
+                # Is there a request to treat?
+                hif(req & ~run) do
+                    # Yes, intialize the delay.
+                    run <= 1
+                    count <= 0
+                    ack <= 0
+                end
+                # No, maybe there is a request in processing.
+                helsif(run) do
+                    # Yes, increase the counter.
+                    count <= count + 1
+                    # Check if the delay is reached.
+                    hif(count == num-1) do
+                        # Yes, tells it and stop the count.
+                        ack <= 1
+                        run <= 0
+                    end
+                end
+            end
+        end
+    end
+
+
+
+    ## Module describing a pipeline delay (supporting multiple successive delays)
+    #  using handshake for working.
+    #  @param num the number of clock cycles to delay.
+    system :delayp do |num|
+        # Checks and process the number of clock to wait.
+        num = num.to_i
+        raise "The delay generic argument must be positive: #{num}" if (num < 0)
+
+        input  :clk          # The clock to make the delay on.
+        input  :req          # The handshake request.
+        output :ack          # The handshake acknoledgment.
+
+        if (num==0) then
+            # No delay.
+            ack <= req
+        else
+            # There is a delay.
+
+            [num].inner state: 0 # The shift register containing the progression
+                                 # of each requested delay.
+
+            # The acknoledgment is directly the last bit of the state register.
+            ack <= state[-1]
+
+
+            # The process controlling the delay.
+            seq(clk.posedge) do
+                # Update the state.
+                if (num > 1) then
+                    state <= state << 1
+                else
+                    state <= 0
+                end
+                # Handle the input.
+                ( state[0] <= 1 ).hif(req)
+            end
+        end
+    end
+
+end

data/lib/HDLRuby/std/handshakes.rb

@@ -0,0 +1,60 @@
+module HDLRuby::High::Std
+
+##
+# Standard HDLRuby::High library: handshake protocols.
+#
+########################################################################
+
+
+    ## Module describing a simple client handshake for working.
+    #  @param event the event to synchronize the handshake.
+    #  @param req   the signal telling a request is there.
+    #  @param cond  the condition allowing the protocol.
+    system :hs_client do |event, req, cond=_1|
+        input :reqI
+        output ackI: 0
+
+        # A each synchronization event.
+        par(event) do
+            # Is the protocol is allowed and a request is present.
+            hif(cond & reqI) do
+                # Yes perform the action and tell the request has been treated.
+                req  <= 1 if req
+                ackI <= 1
+            end
+            helse do
+                # No, do not perform the action, and do not acknowledge.
+                req  <= 0 if req
+                ackI <= 0
+            end
+        end
+    end
+
+
+    ## Module describing a simple server handshake for working.
+    #  @param event the event to synchronize the handshake.
+    #  @param req   the signal for asking a new request.
+    system :hs_server do |event, req|
+        output reqO: 0
+        input  :ackO
+
+        # A each synchronization event.
+        par(event) do
+            # Shall we start the output?
+            hif(ackO)  { reqO <= 0 }
+            hif(req)   { reqO <= 1 }
+        end
+    end
+
+
+    ## Module describing a pipeline with handshakes.
+    #  @param event the event to synchronize the handshakes.
+    #  @param read  the signal telling there is a request from the client side
+    #  @param write the signal used for asking the server to issue a request
+    system :hs_pipe do |event,read,write|
+        inner :cond
+        include(hs_client(event,read,cond))
+        include(hs_server(event,write))
+        cond <= ~reqO
+    end
+end

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.9.0"
+  VERSION = "2.10.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.2
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-15 00:00:00.000000000 Z
+date: 2022-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -152,9 +152,11 @@ files:
 - 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_delay.rb
 - lib/HDLRuby/hdr_samples/with_fixpoint.rb
 - lib/HDLRuby/hdr_samples/with_fsm.rb
 - lib/HDLRuby/hdr_samples/with_function_generator.rb
+- lib/HDLRuby/hdr_samples/with_handshake.rb
 - lib/HDLRuby/hdr_samples/with_init.rb
 - lib/HDLRuby/hdr_samples/with_instance.rb
 - lib/HDLRuby/hdr_samples/with_linear.rb
@@ -173,6 +175,7 @@ files:
 - lib/HDLRuby/hdr_samples/with_to_array.rb
 - lib/HDLRuby/hdr_samples/with_values.rb
 - lib/HDLRuby/hdrcc.rb
+- lib/HDLRuby/hdrlib.rb
 - lib/HDLRuby/high_samples/_adder_fault.rb
 - lib/HDLRuby/high_samples/_generic_transmission2.rb
 - lib/HDLRuby/high_samples/adder.rb
@@ -324,9 +327,11 @@ files:
 - lib/HDLRuby/std/connector.rb
 - lib/HDLRuby/std/counters.rb
 - lib/HDLRuby/std/decoder.rb
+- lib/HDLRuby/std/delays.rb
 - lib/HDLRuby/std/fixpoint.rb
 - lib/HDLRuby/std/fsm.rb
 - lib/HDLRuby/std/function_generator.rb
+- lib/HDLRuby/std/handshakes.rb
 - lib/HDLRuby/std/hruby_unit.rb
 - lib/HDLRuby/std/linear.rb
 - lib/HDLRuby/std/loop.rb