HDLRuby 2.11.11 → 3.0.0

data/lib/HDLRuby/hdr_samples/with_bram_frame_stack.rb

@@ -0,0 +1,105 @@
+require 'soft/stacks.rb'
+
+include HDLRuby::High::Soft
+
+
+# A system testing the bram-based stack.
+system :bram_stach_test do
+
+    widthD = 8
+    size = 1024
+    depth = 16
+
+
+    input :clk, :rst, :ce
+    [2].inner :cmd
+    { frame: bit[depth.width], offset: bit[size.width] }.inner :loc
+    [size.width].inner :frame_size
+    [widthD].inner  :din,:dout
+    inner :empty, :full
+
+    bram_frame_stack(widthD,size,depth).(:stack0).(clk,rst,ce,cmd,loc,din,dout,empty,full)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        ce <= 0
+        cmd <= READ
+        loc.frame  <= 0
+        loc.offset <= 0
+        frame_size <= 0
+        din <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        repeat(9) do
+            !10.ns
+            clk  <= 0
+            ce  <= 1
+            cmd <= PUSH
+            frame_size <= frame_size + 16
+            loc.offset <= frame_size
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+            cmd <= WRITE
+            din <= 5
+            loc.frame <= 0
+            loc.offset <= 1
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+            cmd <= READ
+            loc.frame <= 0
+            loc.offset <= 1
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+            cmd <= WRITE
+            din <= 55
+            loc.frame <= 1
+            loc.offset <= 14
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+            cmd <= READ
+            loc.frame <= 1
+            loc.offset <= 14
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        ce <= 0
+        !10.ns
+        clk <= 1
+        repeat(9) do
+            !10.ns
+            clk  <= 0
+            ce   <= 1
+            cmd  <= POP
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        ce  <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+    end
+
+end

data/lib/HDLRuby/hdr_samples/with_bram_stack.rb

@@ -0,0 +1,69 @@
+require 'soft/stacks.rb'
+
+include HDLRuby::High::Soft
+
+
+# A system testing the bram-based stack.
+system :bram_stach_test do
+
+    size = 8
+    widthD = 8
+
+
+    input :clk, :rst, :ce
+    inner :cmd
+    [widthD].inner  :din,:dout
+    inner :empty, :full
+
+    bram_stack(widthD,size).(:stack0).(clk,rst,ce,cmd,din,dout,empty,full)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        ce <= 0
+        cmd <= PUSH
+        din <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        din <= 0
+        !10.ns
+        clk <= 1
+        repeat(9) do
+            !10.ns
+            clk  <= 0
+            ce  <= 1
+            cmd <= PUSH
+            din <= din + 1
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        ce <= 0
+        !10.ns
+        clk <= 1
+        repeat(9) do
+            !10.ns
+            clk  <= 0
+            ce   <= 1
+            cmd  <= POP
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        ce  <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+    end
+
+end

data/lib/HDLRuby/hdr_samples/with_casts.rb

@@ -6,9 +6,9 @@ system :with_cast do
     [9].inner :val2,:val3
 
     timed do
-        val0 <= _11111111
-        val1 <= _00000010
-        val3 <= _000000000
+        val0 <= _b11111111
+        val1 <= _b00000010
+        val3 <= _b000000000
         count <= 0
         !10.ns
         count <= 1

data/lib/HDLRuby/hdr_samples/with_concat.rb

@@ -10,16 +10,16 @@ system :with_concat do
     val3 <= [val2,val0]
 
     timed do
-        val0 <= _1111
-        val1 <= _0000
+        val0 <= _b1111
+        val1 <= _b0000
         count <= 0
         !10.ns
-        val0 <= _1001
-        val1 <= _0110
+        val0 <= _b1001
+        val1 <= _b0110
         count <= 1
         !10.ns
-        val0 <= _1010
-        val1 <= _0101
+        val0 <= _b1010
+        val1 <= _b0101
         count <= 2
         !10.ns
     end

data/lib/HDLRuby/hdr_samples/with_connector_memory.rb

@@ -12,8 +12,8 @@ system :channel_connector do
     address_width = 4 # lutのアドレスのビット幅
     typ = signed[integer_width + decimal_width] # データ型
     
-    inputs_x = _00010011
-    inputs_h = _10100001
+    inputs_x = _b00010011
+    inputs_h = _b10100001
     columns = [2, 2, 1]
 
     inner :clk,   # clock

data/lib/HDLRuby/hdr_samples/with_def.rb

@@ -9,11 +9,18 @@ end
 system :def_bench do
 
     [2].inner :addr
-    [8].inner :val0, :val1
+    [8].inner :val0, :val1, :val2, :val3
 
     par do
-        val0 <= lut84([0,1,4,9],addr)
-        val1 <= lut84([0,1,4,9],3-addr)
+        val0 <= lut84([_b8d0,_b8d1,_b8d4,_b8d9],addr)
+        val1 <= lut84([_b8d0,_b8d1,_b8d4,_b8d9],3-addr)
+    end
+
+    bit[8][-4].inner otbl: [_b8d0,_b8d1,_b8d4,_b8d9]
+
+    par do
+        val2 <= otbl[addr]
+        val3 <= otbl[3-addr]
     end
 
     timed do

data/lib/HDLRuby/hdr_samples/with_define_operator.rb

@@ -0,0 +1,44 @@
+# A sample for testing define operator.
+
+typedef :sat100 do |width|
+    signed[width]
+end
+
+sat100.define_operator(:+) do |width, x,y|
+    tmp = x.as(bit[width]) + y.as(bit[width])
+    mux(tmp > 100,tmp,100)
+end
+
+typedef :sat do |width, max|
+    signed[width]
+end
+
+sat.define_operator(:+) do |width,max, x,y|
+    tmp = x.as(bit[width]) + y.as(bit[width])
+    mux(tmp > max, tmp, max)
+end
+
+
+system :bench_sat do
+    sat100(8).inner :x,:y,:z
+    sat(8,55).inner :u,:v,:w
+
+    timed do
+        x <= 40
+        y <= 32
+        z <= x+y
+        !10.ns
+        u <= 20
+        v <= 24
+        w <= u+v
+        !10.ns
+        x <= 70
+        y <= 32
+        z <= x+y
+        !10.ns
+        u <= 50
+        v <= 24
+        w <= u+v
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_fixpoint.rb

@@ -14,9 +14,9 @@ system :fix_test do
 
     # Performs calculation between then
     timed do
-        # x <= _00110011 # 3.1875
+        # x <= _b00110011 # 3.1875
         x <= 3.1875.to_fix(4)
-        y <= _01000000 # 4
+        y <= _b01000000 # 4
         !10.ns
         z <= x + y
         !10.ns
@@ -24,8 +24,8 @@ system :fix_test do
         !10.ns
         z <= z / x
         !10.ns
-        a <= _00010000
-        b <= _00001111
+        a <= _b00010000
+        b <= _b00001111
         !10.ns
         c <= a * b
         d <= 0
@@ -49,15 +49,15 @@ system :fix_test do
         !10.ns
         c <= a * b
         !10.ns
-        # a <= _00010000
-        # b <= _00010101
-        a <= _0000111x
-        b <= _1110011x
+        # a <= _b00010000
+        # b <= _b00010101
+        a <= _sb0000111x
+        b <= _sb1110011x
         !10.ns
-        # a <= a & _11111110
-        # b <= b | _00000001
-        a <= a | _00000001
-        b <= b | _00000001
+        # a <= a & _b11111110
+        # b <= b | _b00000001
+        a <= a | _b00000001
+        b <= b | _b00000001
         !10.ns
         c <= a * b
         !10.ns

data/lib/HDLRuby/hdr_samples/with_init.rb

@@ -2,9 +2,9 @@
 # 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
+    constant cst1: _b1
+    [8].inner sig0: _b10000000
+    inner sig1: _b1
     [8].inner :sig2
 
     timed do

data/lib/HDLRuby/hdr_samples/with_leftright.rb

@@ -0,0 +1,21 @@
+# A benchmark for the cases where a left value is also a right value
+# in a block without sensitivity list.
+system :leftright_bench do
+    [8].inner :l,:r0,:r1,:lr
+
+    par do
+        lr <= r0*2
+        l <= [lr[7],lr[6..0]].to_expr + r1
+    end
+
+    timed do
+        !10.ns
+        r0 <= 1
+        !10.ns
+        r1 <= 2
+        !10.ns
+        r0 <= 3
+        r1 <= 4
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_reduce.rb

@@ -6,33 +6,33 @@ system :with_reduce_bench do
     [64].inner :val64
 
     timed do
-        val <= _01101010
-        res <= val.reduce(_00000000,:+)
+        val <= _b01101010
+        res <= val.reduce(_b00000000,:+)
         !10.ns
         val <= _01010010
-        res <= val.reduce(_00000000,:+)
+        res <= val.reduce(_b00000000,:+)
         !10.ns
         val <= _01101111
-        res <= val.reduce(_00000000,:+)
+        res <= val.reduce(_b00000000,:+)
         !10.ns
-        val64 <= _0110101001101010011010100110101001101010011010100110101001101010
-        res <= val64.reduce(_00000000,:+)
+        val64 <= _b0110101001101010011010100110101001101010011010100110101001101010
+        res <= val64.reduce(_b00000000,:+)
         !10.ns
         res <= val64[7..0]
         !10.ns
-        res <= res.reduce(_00000000,:+)
+        res <= res.reduce(_b00000000,:+)
         !10.ns
         res <= val64[63..60]
         !10.ns
-        res <= res.reduce(_00000000,:+)
+        res <= res.reduce(_b00000000,:+)
         !10.ns
         val64 <= ~(val64 ^ val64)
-        res <= val64.reduce(_00000000,:+)
+        res <= val64.reduce(_b00000000,:+)
         !10.ns
-        val64[0] <= _0
-        val64[3] <= _0
-        val64[63] <= _0
-        res <= val64.reduce(_00000000,:+)
+        val64[0] <= _b0
+        val64[3] <= _b0
+        val64[63] <= _b0
+        res <= val64.reduce(_b00000000,:+)
         !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/with_ref_array.rb

@@ -10,16 +10,16 @@ system :with_concat do
     val3[6..3] <= val1[7..4]
 
     timed do
-        val0 <= _00001111
-        val1 <= _11000011
+        val0 <= _b00001111
+        val1 <= _b11000011
         count <= 0
         !10.ns
-        val0 <= _11110000
-        val1 <= _00111100
+        val0 <= _b11110000
+        val1 <= _b00111100
         count <= 1
         !10.ns
-        val0 <= _10101010
-        val1 <= _01010101
+        val0 <= _b10101010
+        val1 <= _b01010101
         count <= 2
         !10.ns
     end

data/lib/HDLRuby/hdr_samples/with_register_stack.rb

@@ -0,0 +1,150 @@
+require 'soft/stacks.rb'
+
+include HDLRuby::High::Soft
+
+
+# A system testing the bram-based stack.
+system :register_stack_test do
+
+    widthA = 3
+    size   = 2**widthA
+    widthD = 8
+
+
+    input :clk,:rst,:ce
+    [2].inner :cmd
+    [widthD].inner  :din,:dout
+    inner :empty, :full
+    douts = size.times.map { |i| [widthD].inner :"dout#{i}" }
+
+    register_stack(widthA,widthD,size).(:stackI).(clk,rst,ce,cmd,din,dout,empty,full,*douts)
+
+    [widthD].inner :count # Additional counter for the test.
+
+    timed do
+        clk <= 0
+        ce  <= 0
+        rst <= 0
+        cmd <= READ
+        din <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        ce  <= 1
+        din <= 1
+        !10.ns
+        clk <= 1
+        repeat(9) do
+            !10.ns
+            clk <= 0
+            cmd <= PUSH
+            din <= din + 1
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        din <= -1
+        repeat(8) do
+            !10.ns
+            clk <= 0
+            cmd <= READ
+            din <= din + 1
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        count <= 0
+        repeat(4) do
+            !10.ns
+            clk <= 0
+            din <= 1
+            cmd <= POP
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+            count <= count + 1
+            din <= count
+            cmd <= PUSH
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        repeat(9) do
+            !10.ns
+            clk <= 0
+            din <= 1
+            cmd <= POP
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        din <= _b8hAA
+        cmd <= PUSH
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        din <= 7
+        cmd <= WRITE
+        !10.ns
+        clk <= 1
+        din <= -1
+        repeat(8) do
+            !10.ns
+            clk <= 0
+            cmd <= WRITE
+            din <= din + 1
+            !10.ns
+            clk <= 1
+        end
+        !10.ns
+        clk <= 0
+        din <= size-1
+        cmd <= READ
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        din <= -3
+        cmd <= POP
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        din <= 31
+        cmd <= PUSH
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        din <= 3
+        cmd <= POP
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        din <= size-1
+        cmd <= READ
+        !10.ns
+        clk <= 1
+    end
+
+end