HDLRuby 2.6.23 → 2.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d8c97794e72e7b03ad7d6db03c24ff4fb77748c3340bc9b9857a64537118e8f
-  data.tar.gz: 8077bcb0c9ce65c3372943ffcdeb2fd756fcd6969e94e135bb32a53b3de1e650
+  metadata.gz: 4995e808d0aa2901a483011a4848bb9416d68850c95c74b9c2f2bf1fb3f648dc
+  data.tar.gz: 729643cd60228ab9ba4f3ab719e434b48963805ed6f4ac01dbcff2fdd6eb54b9
 SHA512:
-  metadata.gz: 104fae34f93944ecc476026b0e8c97b548220e92b7e14727f66af0dc8e6e3655b9dee20b1057f177263ad8947fd2a289333b7aa4378e9baaf16dac57cb41b988
-  data.tar.gz: 47c8c77471d8aff9cc4e601f403d3f32f254658f81884075cdc25e9c4ea422cbd3ef645664fcc3524f2cfb632c2a7c3f11d1cff20451a81e17422e3fab0f4130
+  metadata.gz: 82316dd87a532dbfa67d86fcdb13ade3f8329912bb6aa56ae0b5a4efe0a6110922912f52ae3558c4683147bb224ae2ed0b67e1d60e265d5d30624b3a2bee77be
+  data.tar.gz: 4df2cfb5c257838246fa2f953b3eeaa751902900ae4ea5319a69ca81f9e7eae49b75163fc621a81b2af1b399360c030ccf8717916c2abb7a5d2ffaad27d2b5df

data/lib/HDLRuby/hdr_samples/case_bench.rb

@@ -0,0 +1,35 @@
+# Test the comparison operators.
+
+# A benchmark for the if statement.
+system :if_bench do
+    [8].inner :x, :z
+
+    par do
+        hcase(x)
+        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
+        !10.ns
+        20.times do |i|
+            x <= i
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/constant_in_function.rb

@@ -2,7 +2,7 @@
 
 
 function :func do |addr|
-    bit[4][-4].constant tbl: [ _0000, _0001, _0010, _0011 ]
+    bit[4][-4].constant tbl: [ _1000, _1001, _1010, _1011 ]
     
     tbl[addr]
 end

data/lib/HDLRuby/hdr_samples/if_bench.rb

@@ -0,0 +1,24 @@
+# Test the comparison operators.
+
+# A benchmark for the if statement.
+system :if_bench do
+    [8].inner :x, :y, :z
+
+    par do
+        hif(x == y)   { z <= 1 }
+        helsif(x < y) { z <= 2 }
+        helse         { z <= 3 }
+    end
+
+    timed do
+        x <= 0
+        y <= 0
+        !10.ns
+        x <= 1
+        !10.ns
+        y <= 2
+        !10.ns
+        x <= 2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/index_bench.rb

@@ -0,0 +1,37 @@
+# Test the comparison operators.
+
+# A benchmark for the index access..
+system :if_bench do
+    [8].inner :x
+    inner :b0,:b1,:b2,:b3,:b4,:b5,:b6,:b7
+
+    par do
+        b0 <= x[0]
+        b1 <= x[1]
+        b2 <= x[2]
+        b3 <= x[3]
+        b4 <= x[4]
+        b5 <= x[5]
+        b6 <= x[6]
+        b7 <= x[7]
+    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
+        x[7] <= 1
+        !10.ns
+        x[6] <= 1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/range_bench.rb

@@ -0,0 +1,47 @@
+# Test the comparison operators.
+
+# A benchmark for the index access..
+system :if_bench do
+    [8].inner :x
+    [2].inner :r0,:r1,:r2,:r3
+
+    par do
+        r0 <= x[1..0]
+        r1 <= x[3..2]
+        r2 <= x[5..4]
+        r3 <= x[7..6]
+    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
+        x <= 6
+        !10.ns
+        x <= 7
+        !10.ns
+        x <= 8
+        !10.ns
+        x <= 81
+        !10.ns
+        x <= 123
+        !10.ns
+        x <= 0
+        !10.ns
+        x[7..6] <= 3
+        !10.ns
+        x[5..4] <= 2
+        !10.ns
+        x[3..2] <= 1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_casts.rb

@@ -0,0 +1,30 @@
+
+# A benchmark for testing the casts.
+system :with_cast do
+    [8].inner :count
+    [8].inner :val0,:val1
+    [9].inner :val2,:val3
+
+    timed do
+        val0 <= _11111111
+        val1 <= _00000010
+        val3 <= _000000000
+        count <= 0
+        !10.ns
+        count <= 1
+        val2 <= val0 + val1
+        val3 <= val3 + 1
+        !10.ns
+        count <= 2
+        val2 <= val0.as(bit[9]) + val1
+        val3 <= val3.as(bit[10]) + 1
+        !10.ns
+        count <= 3
+        val2 <= (val0 + val1).as(bit[9])
+        val3 <= (val3 + 1).as(bit[10])
+        !10.ns
+        count <= 4
+        val2 <= (val0 + val1).as(bit[8])
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_concat.rb

@@ -0,0 +1,26 @@
+
+# A benchmark for testing the concat.
+system :with_concat do
+    [8].inner :count
+    [4].inner :val0,:val1
+    [8].inner :val2
+    [12].inner :val3
+
+    val2 <= [val0,val1]
+    val3 <= [val2,val0]
+
+    timed do
+        val0 <= _1111
+        val1 <= _0000
+        count <= 0
+        !10.ns
+        val0 <= _1001
+        val1 <= _0110
+        count <= 1
+        !10.ns
+        val0 <= _1010
+        val1 <= _0101
+        count <= 2
+        !10.ns
+    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_ref_array.rb

@@ -0,0 +1,26 @@
+
+# A benchmark for testing array references.
+system :with_concat do
+    [8].inner :count
+    [8].inner :val0,:val1
+    [3].inner :val2
+    [8].inner :val3
+
+    val2 <= val0[4..2]
+    val3[6..3] <= val1[7..4]
+
+    timed do
+        val0 <= _00001111
+        val1 <= _11000011
+        count <= 0
+        !10.ns
+        val0 <= _11110000
+        val1 <= _00111100
+        count <= 1
+        !10.ns
+        val0 <= _10101010
+        val1 <= _01010101
+        count <= 2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_subsums.rb

@@ -0,0 +1,33 @@
+
+# A benchmark for sum of sub parts of a vector.
+system :with_concat do
+    [8].inner :count
+    [16].inner :val0, :val1, :val2, :val3, :val4, :val5, :val6
+    bs = []
+    10.times do |i|
+        bs << [16].inner(:"b#{i}")
+    end
+
+    vals = [val1,val2,val3,val4]
+    par do
+        vals.each.with_index { |val,i| val <= val0[(i*4+3)..i*4] }
+    end
+    val5 <= vals.reduce(:+)
+
+    par do
+        bs.each.with_index { |b,i| b <= val0[i..i] }
+    end
+    val6 <= bs.reduce(:+)
+
+    timed do
+        val0 <= _1111000011110000
+        count <= 0
+        !10.ns
+        val0 <= _0000111100001111
+        count <= 1
+        !10.ns
+        val0 <= _1010101010101010
+        count <= 2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_values.rb

@@ -0,0 +1,61 @@
+
+# A benchmark for testing the literal values.
+system :with_values do
+    inner :v1
+    [8].inner :v8
+    [16].inner :v16
+    [32].inner :v32
+    [56].inner :v56
+    [64].inner :v64
+    [96].inner :v96
+
+
+    timed do
+        v1  <= 0
+        v8  <= 0
+        v16 <= 0
+        v32 <= 0
+        v56 <= 0
+        v64 <= 0
+        v96 <= 0
+        !10.ns
+        v1  <= 1
+        v8  <= 1
+        v16 <= 1
+        v32 <= 1
+        v56 <= 1
+        v64 <= 1
+        v96 <= 1
+        !10.ns
+        v1  <= _1010[2]
+        v8  <= _uhFF00[12..4]
+        !10.ns
+        v8  <= 128
+        v16 <= 128
+        v32 <= 128
+        v56 <= 128
+        v64 <= 128
+        v96 <= 128
+        !10.ns
+        v16 <= 0x1000
+        v32 <= 0x1000
+        v56 <= 0x1000
+        v64 <= 0x1000
+        v96 <= 0x1000
+        !10.ns
+        v32 <= 0x10000000
+        v56 <= 0x10000000
+        v64 <= 0x10000000
+        v96 <= 0x10000000
+        !10.ns
+        v56 <= 0x10000000000000
+        v64 <= 0x10000000000000
+        v96 <= 0x10000000000000
+        !10.ns
+        v64 <= 0x1000000000000000
+        v96 <= 0x1000000000000000
+        !10.ns
+        v96 <= 0x1000000000000000000
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -486,6 +486,8 @@ if $options[:syntax] then
     $output << $loader.show_all
     exit
 end
+HDLRuby.show Time.now
+HDLRuby.show "##### Starting parser #####"
 
 if $options[:debug] then
     # Debug mode, no error management.
@@ -608,26 +610,29 @@ elsif $options[:clang] then
         $outfile = File.open($hname,"w")
         # Adds the generated globals
         $top_system.each_systemT_deep do |systemT|
-            # For the h file.
-            # hname = $output + "/" +
-            #     HDLRuby::Low::Low2C.c_name(systemT.name) +
-            #     ".h"
-            # hnames << File.basename(hname)
-            # # Open the file for current systemT
-            # output = File.open(hname,"w")
+            # # For the h file.
+            # # hname = $output + "/" +
+            # #     HDLRuby::Low::Low2C.c_name(systemT.name) +
+            # #     ".h"
+            # # hnames << File.basename(hname)
+            # # # Open the file for current systemT
+            # # output = File.open(hname,"w")
             # Generate the H code in to.
-            $outfile << systemT.to_ch
-            # # Close the file.
-            # output.close
-            # # Clears the name.
-            # hname = nil
+            # $outfile << systemT.to_ch
+            systemT.to_ch($outfile)
+            # # # Close the file.
+            # # output.close
+            # # # Clears the name.
+            # # hname = nil
         end
         # Adds the globals from the non-HDLRuby code
         $non_hdlruby.each do |code|
             code.each_chunk do |chunk|
                 if chunk.name == :sim then
-                    $outfile << "extern " + 
-                        HDLRuby::Low::Low2C.prototype(chunk.to_c)
+                    # $outfile << "extern " + 
+                    #     HDLRuby::Low::Low2C.prototype(chunk.to_c)
+                    $outfile << "extern "
+                    $outfile << HDLRuby::Low::Low2C.prototype(chunk.to_c(""))
                 end
             end
         end
@@ -659,7 +664,8 @@ elsif $options[:clang] then
             # Open the file for current systemT
             outfile = File.open(name,"w")
             # Generate the C code in to.
-            outfile << systemT.to_c(0,*$hnames)
+            # outfile << systemT.to_c(0,*$hnames)
+            systemT.to_c(outfile,0,*$hnames)
             # Close the file.
             outfile.close
             # Clears the name.
@@ -668,8 +674,10 @@ elsif $options[:clang] then
     else
         # Single file generation mode.
         $top_system.each_systemT_deep.reverse_each do |systemT|
-            $output << systemT.to_ch
-            $output << systemT.to_c
+            # $output << systemT.to_ch
+            systemT.to_ch($output)
+            # $output << systemT.to_c
+            systemT.to_c($output)
         end
         # Adds the main code.
         $output << HDLRuby::Low::Low2C.main(top_system,
@@ -709,17 +717,19 @@ elsif $options[:verilog] then
     # top_system = $top_system
     # Make description compatible with verilog generation.
     $top_system.each_systemT_deep do |systemT|
-        HDLRuby.show "casts_without_expression! step..."
-        systemT.casts_without_expression!
-        HDLRuby.show Time.now
+        # HDLRuby.show "casts_without_expression! step..."
+        # systemT.casts_without_expression!
+        # HDLRuby.show Time.now
         HDLRuby.show "to_upper_space! step..."
         systemT.to_upper_space!
         HDLRuby.show Time.now
-        HDLRuby.show "to_global_space! step..."
-        systemT.to_global_systemTs!
-        HDLRuby.show Time.now
-        # systemT.break_types!
-        # systemT.expand_types!
+    end
+    HDLRuby.show "to_global_space! step (global)..."
+    $top_system.to_global_systemTs!
+    HDLRuby.show Time.now
+    $top_system.each_systemT_deep do |systemT|
+        ## systemT.break_types!
+        ## systemT.expand_types!
         HDLRuby.show "par_in_seq2seq! step..."
         systemT.par_in_seq2seq!
         HDLRuby.show Time.now
@@ -818,6 +828,9 @@ elsif $options[:vhdl] then
     end
 end
 
+HDLRuby.show "##### Code generated #####"
+HDLRuby.show Time.now
+
 # # Apply the post drivers if any.
 # Hdecorator.each_with_property(:post_driver) do |obj, value|
 #     # Load the driver.

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
 
@@ -1960,6 +1965,9 @@ 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|
@@ -1968,6 +1976,9 @@ module HDLRuby::High
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
                 end
+                # sub do
+                #     ruby_block.call(*args,*other_block)
+                # end
             end
         end
     end
@@ -2027,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
@@ -2499,7 +2525,11 @@ module HDLRuby::High
 
         # Casts as +type+.
         def as(type)
-            return Cast.new(type.to_type,self.to_expr)
+            if (self.parent)
+                return Cast.new(type.to_type,self.to_expr)
+            else
+                return Cast.new(type.to_type,self)
+            end
         end
 
         # Casts to a bit vector type.
@@ -3071,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.
@@ -3486,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

@@ -63,6 +63,17 @@ module HDLRuby::Low
             cur = cur.parent until cur.is_a?(Scope)
             return cur
         end
+
+        # Get the full parents hierachy.
+        def hierarchy
+            res = []
+            cur = self
+            while(cur) do
+                res << cur
+                cur = cur.parent
+            end
+            return res
+        end
     end
 
 
@@ -5331,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