HDLRuby 2.11.12 → 3.0.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/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_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

data/lib/HDLRuby/hdr_samples/with_sequencer.rb

@@ -0,0 +1,190 @@
+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
+        uuu <= 0
+        vvv <= 1
+        swhile(vvv<10000) do
+            vvv <= uuu + vvv
+            uuu <= vvv - uuu
+            step
+            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")
+        # sfor(buf) do |elem,idx|
+        # buf.seach.with_index do |elem,idx|
+        #     res1 <= elem * elem
+        #     hprint("$1 res1=",res1," idx=",idx,"\n")
+        # end
+        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")
+        (0..7).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