HDLRuby 2.11.12 → 3.1.0

data/ext/hruby_sim/hruby_sim_calc.c

@@ -1777,6 +1777,8 @@ Value write_range_bitstring_no_z(Value src,
     unsigned long long bw = type_width(base);
     first *= bw;
     last *=  bw;
+    last += bw-1;
+    // printf("bw=%lld, first=%lld, last=%lld\n",bw,first,last);
     /* Access the source and destination bitstring data. */
     char* dst_data = dst->data_str;
     char* src_data = src->data_str;

data/lib/HDLRuby/backend/hruby_allocator.rb

@@ -1,14 +1,14 @@
 require "HDLRuby/hruby_error"
 
+module HDLRuby::Low
 
 
 ##
 # Adds methods for allocating addresses to signals in Code objects.
 #
 ########################################################################
-module HDLRuby::Low
 
-    ## An allocator.
+    ## Describes an allocator.
     class Allocator
 
         # The space range for the allocation.

data/lib/HDLRuby/backend/hruby_c_allocator.rb

@@ -3,16 +3,16 @@ require "HDLRuby/hruby_low_resolve"
 require "HDLRuby/backend/hruby_allocator"
 
 
+module HDLRuby::Low
 
 ##
 # Adds methods for allocating addresses to signals in Code objects and
 # integrate the result into C code.
 #
 ########################################################################
-module HDLRuby::Low
 
-    ## Extends the SystemT class with support for C allocation of signals.
     class SystemT
+        ## Extends the SystemT class with support for C allocation of signals.
 
         ## Allocates signals within C code using +allocator+.
         def c_code_allocate(allocator)
@@ -21,8 +21,8 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the scope class with support for C allocation of signals.
     class Scope
+        ## Extends the scope class with support for C allocation of signals.
 
         ## Allocates signals within C code using +allocator+.
         def c_code_allocate(allocator)
@@ -34,10 +34,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the chunk class with support for self modification with
-    #  allocation.
-    #  NOTE: only work if the chunk is in C language.
     class Chunk
+        ## Extends the chunk class with support for self modification with
+        #  allocation.
+        #  NOTE: only works if the chunk is in C language.
 
         ## Allocates signal within C code using +allocator+ and self-modify
         #  the code correspondingly.
@@ -61,8 +61,8 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the code class with support for C allocation of signals.
     class Code
+        ## Extends the code class with support for C allocation of signals.
 
         ## Allocates signals within C code using +allocator+.
         def c_code_allocate(allocator)

data/lib/HDLRuby/hdr_samples/constant_in_function.rb

@@ -1,7 +1,8 @@
 # Sample for testing constant declaration in function.
 
 
-function :func do |addr|
+# function :func do |addr|
+hdef :func do |addr|
     bit[4][-4].constant tbl: [ _b1000, _b1001, _b1010, _b1011 ]
     
     tbl[addr]

data/lib/HDLRuby/hdr_samples/mei8_bench.rb

@@ -28,7 +28,7 @@ system :mei8 do |prog_file = "./prog.obj"|
         bit[7..0][-256].constant mem: # The content of the memory
             ( File.readlines(prog_file).map {|l| l.split[0] }.select do |l|
             ["0","1"].include?(l[2])
-        end.map {|l| l[2..9].to_i(2) } )
+        end.map {|l| l[2..9].to_i(2).to_expr.as(bit[8]) } )
         instr <= mem[addr]       # The access procedure
     end
 

data/lib/HDLRuby/hdr_samples/with_bram.rb

@@ -18,13 +18,13 @@ system :bram_test do
 
     timed do
         clk  <= 0
-        rwb  <= 1
+        rwb  <= 0
         addr <= 0
         din  <= 0
         !10.ns
         clk  <= 1
         !10.ns
-        rwb <= 1
+        rwb <= 0
         repeat(16) do
             clk <= 0
             !10.ns
@@ -33,7 +33,7 @@ system :bram_test do
             din <= din + 1
             !10.ns
         end
-        rwb <= 0
+        rwb <= 1
         repeat(16) do
             clk <= 0
             !10.ns

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_ref_expr.rb

@@ -0,0 +1,30 @@
+
+# A benchmark for testing range reference and index reference on expressions.
+system :with_concat do
+    [8].inner :val0,:val1
+    inner :val2
+    [4].inner :val3, :count
+    inner :val4
+    [4].inner :val5
+
+    val2 <= (val0+val1)[4]
+    val3 <= (val0+val1)[3..0]
+
+    val4 <= val0[4]
+    val5 <= val0[3..0]
+
+    timed do
+        val0 <= _b00001111
+        val1 <= _b11000011
+        count <= 0
+        !10.ns
+        val0 <= _b11110000
+        val1 <= _b00111100
+        count <= 1
+        !10.ns
+        val0 <= _b10101010
+        val1 <= _b01010101
+        count <= 2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_sequencer.rb

@@ -0,0 +1,185 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of sequencers:
+# - One sequencer computes a fibbnacci series until 100
+# - One sequencer computes a fibbnacci series until 1000 with early termination
+#   for testing sterminate.
+# - One sequencer computes a fibbnacci series until 1000 with ealry break
+#   for testing sbreak.
+# - One sequence that increase a first counter and the other one every four
+#   increases of the first one for testing scontinue.
+# - One sequencer computes the square value of each elements of a buffer.
+# - One sequencer computes the square value of each elements of a range.
+# - One sequencer concatenates the value of a counter with its index.
+# - One sequencer puts the sum of two arrays in a third one.
+# - One sequencer iterates over two arrays.
+# - One sequencer iterates downward.
+system :my_seqencer do
+
+    inner :clk,:rst
+    [16].inner :u, :v,:res0
+
+    sequencer(clk.posedge,rst) do
+        # hprint("#0\n")
+        u <= 0
+        v <= 1
+        step
+        res0 <= 0
+        # hprint("#1 res0=",res0,"\n")
+        swhile(v < 100) do
+            v <= u + v
+            u <= v - u
+            # hprint("#2 v=",v,"\n")
+        end
+        res0 <= v
+        # hprint("#3 res0=",res0,"\n")
+    end
+
+    [16].inner :uu, :vv
+    sequencer(clk.posedge,rst) do
+        # hprint("##0\n")
+        uu <= 0
+        vv <= 1
+        swhile(vv<10000) do
+            vv <= uu + vv
+            uu <= vv - uu
+            step
+            # hprint("##1 vv=",vv,"\n")
+            sif(vv >= 100) { sterminate }
+        end
+        # hprint("##2 vv=",vv,"... But should not be here!\n")
+    end
+
+    [16].inner :uuu, :vvv, :res00
+
+    sequencer(clk.posedge,rst) do
+        # hprint("###0\n")
+        res00 <= 0
+        steps(3) # Checks 3 steps
+        uuu <= 0
+        vvv <= 1
+        swhile(vvv<10000) do
+            vvv <= uuu + vvv
+            uuu <= vvv - uuu
+            # hprint("##1 vvv=",vvv,"\n")
+            sif(vvv >= 100) { sbreak }
+            selse { res00 <= res00 + 1 }
+        end
+        # hprint("##2 res00=",res00,"... and should be here!\n")
+    end
+
+    [8].inner :a,:b
+
+    sequencer(clk.posedge,rst) do
+        # hprint("=0\n")
+        a <= 0
+        b <= 0
+        sfor(0..19) do
+            a <= a + 1
+            # hprint("=1 a=",a,"\n")
+            sif(a % 4) { scontinue }
+            b <= b + 1
+            # hprint("=2 b=",b,"\n")
+        end
+        # hprint("=3 a=",a," b=",b,"\n")
+    end
+
+
+    bit[16][-8].inner buf: 8.times.map {|i| i.to_expr.as(bit[16]) }
+    [16].inner :res1
+    # [8].inner :idx
+
+    sequencer(clk.posedge,rst) do
+        res1 <= 0
+        # hprint("$0 res1=",res1,"\n")
+        buf.seach do |elem|
+            res1 <= elem * elem
+            # hprint("$1 elem=",elem," res1=",res1,"\n")
+        end
+        # hprint("$2 res1=",res1,"\n")
+    end
+
+    [32].inner :res2
+
+    sequencer(clk.posedge,rst) do
+        res2 <= 0
+        # hprint("%0 res2=",res2,"\n")
+        (_h00000000.._h00000007).seach do |elem|
+            res2 <= elem * elem
+            # hprint("%1 elem=",elem," res2=",res2,"\n")
+        end
+        # hprint("%2 res2=",res2,"\n")
+    end
+
+    [32].inner :res3
+
+    sequencer(clk.posedge,rst) do
+        res3 <= 0
+        # hprint("&0 res3=",res3,"\n")
+        5.supto(10).with_index do |elem,idx|
+            res3 <= [elem[15..0],idx[15..0]]
+            # hprint("&1 elem=",elem," idx=",idx," res3=",res3,"\n")
+        end
+        # hprint("&2 res3=",res3,"\n")
+    end
+
+    bit[8][-8].inner ar0: [_h01,_h02,_h04,_h08, _h10,_h20,_h40,_h80]
+    bit[8][-8].inner ar1: [_h01,_h02,_h03,_h04, _h05,_h06,_h07,_h08]
+    bit[8][-8].inner :res4
+
+    sequencer(clk.posedge,rst) do
+        sfor(ar0) do |elem,idx|
+            res4[idx] <= elem + ar1[idx]
+        end
+        # hprint("res4=",res4,"\n")
+    end
+
+    [8].inner :res5
+
+    sequencer(clk.posedge,rst) do
+        res5 <= 0
+        # hprint("(0 res5=",res5,"\n")
+        (ar0.seach + ar1).seach do |elem|
+            res5 <= elem
+            # hprint("(1 res5=",res5,"\n")
+        end
+        # hprint("(2 res5=",res5,"\n")
+    end
+
+
+    [32].inner :res6
+
+    sequencer(clk.posedge,rst) do
+        res6 <= 0
+        # hprint(")0 res6=",res6,"\n")
+        10.sdownto(1) do |elem|
+            res6 <= elem
+            # hprint(")1 res6=",res6,"\n")
+        end
+        # hprint(")2 res6=",res6,"\n")
+    end
+
+
+    timed do
+        clk <= 0
+        rst <= 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(100) do
+            !10.ns
+            clk <= ~clk
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_sequencer_deep.rb

@@ -0,0 +1,91 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of sequencers with multiple and deep loops.
+# Also checks empty loops and loops controlled from the outside.
+system :my_seqencer do
+
+    inner :clk,:rst,:req
+
+    [16].inner :u, :v
+
+    sequencer(clk,rst) do
+        hprint("#0\n")
+        u <= 0
+        v <= 1
+        swhile(v<10) { v <= v + 1 }
+        hprint("#1\n")
+        swhile(u<10) { u <= u + 1 }
+        hprint("#2\n")
+    end
+
+    [16].inner :x, :y
+
+    sequencer(clk,rst) do
+        hprint("!0\n")
+        x <= 1
+        y <= 0
+        swhile(x<20) do
+            hprint("!1\n")
+            x <= x + 4
+            swhile(y<x) { y <= y + 1 }
+        end
+        hprint("!2\n")
+    end
+
+    [16].inner :z
+
+    sequencer(clk,rst) do
+        hprint("$0\n")
+        z <= 10
+        swhile(x==0)
+        z <= 0
+        hprint("$1\n")
+        swhile(x<10)
+        z <= 1
+        hprint("$2\n")
+    end
+
+    [16].inner :w
+
+    sequencer(clk,rst) do
+        hprint(":0\n")
+        w <= 0
+        sloop do
+            swhile(req == 1) { w <= 1 }
+            w <= w + 1
+        end
+    end
+
+
+    timed do
+        clk <= 0
+        rst <= 0
+        req <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        req <= 1
+        !10.ns
+        clk <= 1
+        repeat(10) do
+            !10.ns
+            clk <= ~clk
+        end
+        !10.ns
+        req <= 0
+        clk <= ~clk
+        repeat(60) do
+            !10.ns
+            clk <= ~clk
+        end
+    end
+end