HDLRuby 2.7.1 → 2.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ca0e2aba73e7ceb55e145dd22286398ae7605d04d46212f870ba895d3f983d9
-  data.tar.gz: 434ae3eb4d974a00ea1510b0e23d66dc51d5f6ac5ef0e4b79af288b5d05f6985
+  metadata.gz: 4995e808d0aa2901a483011a4848bb9416d68850c95c74b9c2f2bf1fb3f648dc
+  data.tar.gz: 729643cd60228ab9ba4f3ab719e434b48963805ed6f4ac01dbcff2fdd6eb54b9
 SHA512:
-  metadata.gz: d097cbd7793ef60fd94c70f7a8acb2e49b13915fd799b7618523c1ba57300195a9ca8a7a61d6e50a8f89779ce6bf64a484bdf5267de93b3159f61186f40e6a82
-  data.tar.gz: 27db7c7e988abe14635a515572c2774e8a76d44e7f0e85bfb6ec8b1c9dfed85f61ef49e1f597c59fc9b725b6aacc53b976f73a3b49f816820c5ca9691e253559
+  metadata.gz: 82316dd87a532dbfa67d86fcdb13ade3f8329912bb6aa56ae0b5a4efe0a6110922912f52ae3558c4683147bb224ae2ed0b67e1d60e265d5d30624b3a2bee77be
+  data.tar.gz: 4df2cfb5c257838246fa2f953b3eeaa751902900ae4ea5319a69ca81f9e7eae49b75163fc621a81b2af1b399360c030ccf8717916c2abb7a5d2ffaad27d2b5df

data/lib/HDLRuby/hdr_samples/case_bench.rb

@@ -1,30 +1,35 @@
 # Test the comparison operators.
 
-# A benchmark for the case statement.
+# A benchmark for the if statement.
 system :if_bench do
-    [8].inner :x, :y
+    [8].inner :x, :z
 
     par do
         hcase(x)
-        hwhen(0) { y <= _10000000 }
-        hwhen(1) { y <= _10000001 }
-        hwhen(2) { y <= _10000010 }
-        hwhen(3) { y <= _10000011 }
-        helse    { y <= _00000000 }
+        hwhen(0)  { z <= 0 }
+        hwhen(1)  { z <= 1 }
+        hwhen(2)  { z <= 4 }
+        hwhen(3)  { z <= 9 }
+        hwhen(4)  { z <= 16 }
+        hwhen(5)  { z <= 25 }
+        hwhen(6)  { z <= 36 }
+        hwhen(7)  { z <= 49 }
+        hwhen(8)  { z <= 64 }
+        hwhen(9)  { z <= 81 }
+        hwhen(10) { z <= 100 }
+        hwhen(11) { z <= 121 }
+        hwhen(12) { z <= 144 }
+        hwhen(13) { z <= 169 }
+        hwhen(14) { z <= 196 }
+        hwhen(15) { z <= 225 }
+        helse    { z <= _zzzzzzzz }
     end
 
     timed do
-        x <= 0
-        !10.ns
-        x <= 1
-        !10.ns
-        x <= 2
-        !10.ns
-        x <= 3
-        !10.ns
-        x <= 4
-        !10.ns
-        x <= 5
         !10.ns
+        20.times do |i|
+            x <= i
+            !10.ns
+        end
     end
 end

data/lib/HDLRuby/hdr_samples/with_init.rb

@@ -0,0 +1,18 @@
+
+# A benchmark for testing the initialization of signals.
+system :with_init do
+    [8].constant cst0: 127
+    constant cst1: _1
+    [8].inner sig0: _10000000
+    inner sig1: _1
+    [8].inner :sig2
+
+    timed do
+        !10.ns
+        sig2  <= cst0 + cst1
+        sig0  <= sig0 + sig1
+        !10.ns
+        sig2 <= sig2 + sig1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_instance.rb

@@ -0,0 +1,42 @@
+
+
+
+# A benchmark for testing the instantiations.
+
+system :adder do |typ|
+    typ.input :x, :y
+    typ.output :z
+
+    z <= x + y
+end
+
+system :truc do
+    [8].input :u, :v
+    [8].output :q
+end
+
+
+
+system :with_instance do
+
+    [8].inner :x0, :y0, :z0, :x1, :y1, :z1
+
+    truc(:montruc).(x0,y0,z0)
+
+    adder(bit[8]).(:adderI0).(x0,y0,z0)
+    adder(bit[8]).(:adderI1).(x: x1, y: y1, z: z1)
+
+    timed do
+        !10.ns
+        x0 <= 0
+        y0 <= 0
+        x1 <= 1
+        y1 <= 1
+        !10.ns
+        x0 <= 1
+        y0 <= 1
+        x1 <= 2
+        y1 <= 2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_values.rb

@@ -27,6 +27,9 @@ system :with_values do
         v64 <= 1
         v96 <= 1
         !10.ns
+        v1  <= _1010[2]
+        v8  <= _uhFF00[12..4]
+        !10.ns
         v8  <= 128
         v16 <= 128
         v32 <= 128

data/lib/HDLRuby/hruby_high.rb

@@ -256,9 +256,9 @@ module HDLRuby::High
                                     SignalI.new(name,type,:inner))
                             elsif name.is_a?(Hash) then
                                 # Names associated with values.
-                                names.each do |name,value|
+                                name.each do |key,value|
                                     res = self.add_inner(
-                                        SignalI.new(name,type,:inner,value))
+                                        SignalI.new(key,type,:inner,value))
                                 end
                             else
                                 raise AnyError,
@@ -550,10 +550,14 @@ module HDLRuby::High
             expanded = self.class.new(name.to_s) {}
             # Include the mixin systems given when declaring the system.
             @to_includes.each { |system| expanded.scope.include(system) }
+            # Include the previously includeds. */
+            self.scope.each_included { |system| expanded.scope.include(system) }
 
             # Sets the generators of the expanded result.
             expanded.add_generator(self)
             @to_includes.each { |system| expanded.add_generator(system) }
+            # Also for the previously includeds. */
+            self.scope.each_included.each { |system| expanded.add_generator(system) }
 
             # Fills the scope of the expanded class.
             # puts "Build top with #{self.name} for #{name}"
@@ -1237,6 +1241,7 @@ module HDLRuby::High
             end
             # Adds it the list of includeds
             @includes[include_name] = system
+            # puts "@includes=#{@includes}"
             
         end
 
@@ -2033,10 +2038,25 @@ module HDLRuby::High
                 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
                     # 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
                     # Convert it to a reference.
                     ref = RefObject.new(self.to_ref,signal)
+                    # puts "key=#{key} value=#{value} signal=#{signal} ref=#{ref}"
                     # Make the connection.
                     if isout then
                         value <= ref
@@ -3081,7 +3101,8 @@ module HDLRuby::High
         # Converts to a new reference.
         def to_ref
             return RefIndex.new(self.type,
-                                self.ref.to_ref,self.index.to_expr)
+                                # self.ref.to_ref,self.index.to_expr)
+                                self.ref.to_expr,self.index.to_expr)
         end
 
         # Converts the index reference to HDLRuby::Low.
@@ -3496,7 +3517,8 @@ module HDLRuby::High
         # Converts the system to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
             # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
-            signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low)
+            valueL = self.value ? self.value.to_low : nil
+            signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low,valueL)
             # # For debugging: set the source high object 
             # signalIL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = signalIL

data/lib/HDLRuby/hruby_low.rb

@@ -5342,7 +5342,8 @@ module HDLRuby::Low
         def initialize(type,ref,index)
             super(type)
             # Check and set the accessed reference.
-            unless ref.is_a?(Ref) then
+            # unless ref.is_a?(Ref) then
+            unless ref.is_a?(Expression) then
                 raise AnyError, "Invalid class for a reference: #{ref.class}."
             end
             @ref = ref

data/lib/HDLRuby/hruby_low2c.rb

@@ -1610,26 +1610,18 @@ module HDLRuby::Low
             res << "{\n"
             self.value.to_c(res,level+1)
             res << " " * ((level+1)*3)
-            res << "Value v=d;\n"
+            res << "dup();\n"
             # Ensure the selection value is testable.
             res << " " * ((level+1)*3)
-            res << "if (is_defined_value(v)) {\n"
+            res << "if (is_defined()) {\n"
             # The condition is testable.
             # Generate the case as a succession of if statements.
-            first = true
             self.each_when do |w|
                 res << " " * ((level+2)*3)
-                if first then
-                    first = false
-                else
-                    res << "else "
-                end
-                res << "if (value2integer(v) == "
-                res << "value2integer(({\n"
+                res << "dup();\n"
                 res << " " * ((level+2)*3)
                 w.match.to_c(res,level+2)
-                res << "d;})"
-                res << ")) {\n"
+                res << "if (to_integer() == to_integer()) {\n"
                 w.statement.to_c(res,level+3)
                 res << " " * (level+2)*3
                 res << "}\n"
@@ -1643,6 +1635,8 @@ module HDLRuby::Low
             end
             # Close the case.
             res << " " * (level+1)*3
+            res << "pop();\n" # Remove the testing value.
+            res << " " * (level+1)*3
             res << "}\n"
             res << " " * (level)*3
             res << "}\n"

data/lib/HDLRuby/sim/hruby_sim.h

@@ -754,6 +754,9 @@ extern Value write_range_no_z(Value src, long long first, long long last,
  *  @param val the value to push. */
 extern void push(Value val);
 
+/** Duplicates a value in the stack. */
+extern void dup();
+
 /** Pops a value.
  *  @return the value. */
 extern Value pop();

data/lib/HDLRuby/sim/hruby_sim_stack_calc.c

@@ -27,6 +27,17 @@ void push(Value val) {
     }
 }
 
+/** Duplicates a value in the stack. */
+void dup() {
+    if (head > 0 && head < STACK_SIZE) {
+        Value val = stack[head];
+        stack[--head] = val;
+    } else {
+        perror("Cannot dup in computation stack.\n");
+        exit(1);
+    }
+}
+
 /** Pops a value.
  *  @return the value. */
 Value pop() {

data/lib/HDLRuby/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 2.7.5
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-18 00:00:00.000000000 Z
+date: 2022-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,6 +150,8 @@ files:
 - 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_init.rb
+- lib/HDLRuby/hdr_samples/with_instance.rb
 - lib/HDLRuby/hdr_samples/with_linear.rb
 - lib/HDLRuby/hdr_samples/with_loop.rb
 - lib/HDLRuby/hdr_samples/with_memory.rb