HDLRuby 2.6.25 → 2.7.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a207f3222cab832d2b846f9658ea0cf9426e77afd14196c2db8cb6832bd4ebda
-  data.tar.gz: 490c8a6400d6faac77cec5ab1e49caa3abd94d4d0961521ec14d485cad640b72
+  metadata.gz: 2c66f2d8f552623dabccc43ea54a7246d49eb42a6aaf0f6b8a1977e7675221ca
+  data.tar.gz: 10f9b15022166b3fdb90a9a026653f3fec8b5a05f807e468dfed2d1c97d9adf7
 SHA512:
-  metadata.gz: '08196d385fb34444cc7387f6b4982063c38e98e10e51e3b58551b0a6b62dac6921fcbb9c7a89aaccabea055ecab0d2da0543667f688d52bd7ea6b875d9db5ebd'
-  data.tar.gz: c22296c840a2a7a52b8f4bd8bc34dc38c53f571feba0a01f1bb17a2f548c2965947916fcf47b95b33f2293f1481d8b91653d855c21708a746245cebffebc72f4
+  metadata.gz: 3c56c51a83e75ddd03d34d0c305a17595c362077010213e299baf60e8a7e0b52e745c6b8f9ada7db3c4931b99809376ffdc54f3f4bbb122e002a82419f39e7fb
+  data.tar.gz: 3f056bd7523dea35b03188aa689a232afeadb7c24f7608f3207fc2479503081e1e1ce0a55c2ad3cc805721b60e7d559d464d9fa89a6f79f3f962388254eac6e7

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/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/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