HDLRuby 2.7.11 → 2.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c66f2d8f552623dabccc43ea54a7246d49eb42a6aaf0f6b8a1977e7675221ca
-  data.tar.gz: 10f9b15022166b3fdb90a9a026653f3fec8b5a05f807e468dfed2d1c97d9adf7
+  metadata.gz: 960102912fa0b766d6d17de3d6f4c727e022b459813c47ce5156d4f695a97231
+  data.tar.gz: d79ea380f00deed3419e8565ee82c59d9568fd8844e2422c2d00e163548225c4
 SHA512:
-  metadata.gz: 3c56c51a83e75ddd03d34d0c305a17595c362077010213e299baf60e8a7e0b52e745c6b8f9ada7db3c4931b99809376ffdc54f3f4bbb122e002a82419f39e7fb
-  data.tar.gz: 3f056bd7523dea35b03188aa689a232afeadb7c24f7608f3207fc2479503081e1e1ce0a55c2ad3cc805721b60e7d559d464d9fa89a6f79f3f962388254eac6e7
+  metadata.gz: 45f8c0e72f6ebfee3fbf7cbd0172ccb24995d175134ff8d456c1d7aef22466bd1a0bf8b1fac4fef9f2e912d6e51bd16426b6fd376a7e07796f03114ae8a2bc38
+  data.tar.gz: 1fe88f2ce84c4e48eacc20119804062cb50ccf1a36acec6c0bbb82e6e0e9b1414af93af8daff4760c722159fa319d3af19082a2533b34ba9d6bac33ac3cd0f5a

data/README.md

@@ -44,6 +44,7 @@ Where:
 
 |  Options         |          |
 |:------------------|:-----------------------------------------------------|
+| `-I, --interactive` | Run in interactive mode                            |
 | `-y, --yaml`      | Output in YAML format                                |
 | `-v, --verilog`   | Output in Verilog HDL format                         |
 | `-V, --vhdl`      | Output in VHDL format                                |
@@ -97,6 +98,18 @@ hdrcc -y -t multer -p 16,16,32 multer_gen.rb multer
 hdrcc -S counter_bench.rb counter
 ```
 
+* Run in interactive mode.
+
+```
+hdrcc -I
+```
+
+* Run in interactive mode using pry as UI.
+
+```
+hdrcc -I pry
+```
+
 
 ## Using HDLRuby within Ruby
 
@@ -439,7 +452,7 @@ The description above is straight forward, but it would be necessary to rewrite
 
 ```ruby
 system :sumprod do |typ,coefs|
-   typ[coefs.size].input ins
+   typ[coefs.size].input :ins
    typ.output :o
    
    o <= coefs.each_with_index.reduce(_0) do |sum,(coef,i)|

data/lib/HDLRuby/hdr_samples/adder_gen.rb

@@ -5,3 +5,25 @@ system :adder do |w|
 
     s <= x.as(bit[w+1]) + y
 end
+
+
+# Testing the generic adder.
+system :adder_bench do
+    width = 4
+    [width].inner :x,:y
+    [width+1].inner :z
+
+    adder(width).(:my_adder).(x,y,z)
+
+    timed do
+        x <= 0
+        y <= 0
+        !10.ns
+        x <= 1
+        !10.ns
+        y <= 1
+        !10.ns
+        x <= 15
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/adder_gen_gen.rb

@@ -0,0 +1,40 @@
+# A simple generic adder
+system :adder do |w|
+    [(w-1)..0].input :i,:j
+    [w..0].output :k
+
+    k <= i.as(bit[w+1]) + j
+end
+
+# A module embedding two generic adders.
+system :two_adders do |w|
+    [w*2].input :x, :y
+    [(w+1)*2].output :z
+
+    adder(w).(:adderI0).(x[(w-1)..0],y[(w-1)..0],z[w..0])
+    adder(w).(:adderI1).(x[(w*2-1)..w],y[(w*2-1)..w],z[(w*2+1)..(w+1)])
+end
+
+
+# Testing the generic adder.
+system :adder_bench do
+    width = 4
+    [width*2].inner :a,:b
+    [(width+1)*2].inner :c
+
+    two_adders(width).(:my_adders).(a,b,c)
+
+    timed do
+        a <= 0
+        b <= 0
+        !10.ns
+        a <= 1
+        !10.ns
+        b <= 1
+        !10.ns
+        a <= 255
+        !10.ns
+        b <= 128
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/dff_unit.rb

@@ -6,7 +6,7 @@
 3.times do |i|
 
     # A simple D-FF
-    system:"dff#{i}" do
+    system :"dff#{i}" do
         input :clk, :rst, :d
         output :q, :qb
 

data/lib/HDLRuby/hdr_samples/with_def.rb

@@ -0,0 +1,29 @@
+# A test of def.
+def lut84(content,addr)
+   bit[8][-4].inner tbl? => content.to_a
+   tbl![addr]
+end
+
+
+# A benchmark for testing the initialization of signals.
+system :def_bench do
+
+    [2].inner :addr
+    [8].inner :val0, :val1
+
+    par do
+        val0 <= lut84([0,1,4,9],addr)
+        val1 <= lut84([0,1,4,9],3-addr)
+    end
+
+    timed do
+        addr <= 0
+        !10.ns
+        addr <= 1
+        !10.ns
+        addr <= 2
+        !10.ns
+        addr <= 3
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_delay.rb

@@ -0,0 +1,72 @@
+require 'std/delays.rb'
+
+include HDLRuby::High::Std
+
+# System descending for delayp for adding a reset.
+system :delayp_rst do |num|
+    include(delayp(num))
+
+    input :rst
+
+    par(clk.posedge) do
+        hif(rst) { state <= 0 }
+    end
+end
+
+
+# System testing delay, delayp and the new delayp_rst.
+system :with_delays do
+    num = 10
+
+    # The clock and reset signals
+    inner :clk,:rst
+    # The request signals.
+    inner :req, :reqp, :reqp_rst
+    # The ack signals.
+    inner :ack, :ackp, :ackp_rst
+
+    # Instantiate the delays.
+    delay(num).(:delayI).(clk,req,ack)
+    delayp(num).(:delaypI).(clk,reqp,ackp)
+    delayp_rst(num).(:delaypI_rst).(rst,clk,reqp_rst,ackp_rst)
+
+    # Test the delays.
+    timed do
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        req <= 1
+        reqp <= 1
+        reqp_rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        req <= 0
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        reqp <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        reqp_rst <= 0
+        10.times do
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_handshake.rb

@@ -0,0 +1,110 @@
+require 'std/handshakes.rb'
+
+include HDLRuby::High::Std
+
+
+# System using a handshake for summing inputs.
+system :hs_adder do
+    input :clk
+    [8].input :x,:y
+    [8].output :z
+
+    inner :read, :write
+
+    include(hs_pipe(clk.posedge,read,write))
+
+    par(clk.posedge) do
+        hif(read) do
+            z <= x + y
+            write <= 1
+        end
+        hif(ackO) do
+            z <= _zzzzzzzz
+            write <= 0
+        end
+    end
+end
+
+
+# System testing handshakes.
+system :with_handshake do
+
+    # The clock signal.
+    inner :clk
+    # The request and acknoledge signals.
+    inner :reqI,:ackI,:reqO,:ackO
+
+    # The input and output values.
+    [8].inner :x, :y, :z
+
+    # Instantiate the handshake adder.
+    hs_adder.(:adderI).(clk: clk, x: x, y: y, z: z,
+                        reqI: reqI, ackI: ackI, reqO: reqO, ackO: ackO)
+
+    # Test the handshake adder.
+    timed do
+        clk  <= 0
+        x    <= 0
+        y    <= 0
+        reqI <= 0
+        ackO <= 0
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        x    <= 1
+        y    <= 2
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        reqI <= 1
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        reqI <= 0
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        ackO <= 1
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        ackO <= 0
+        !10.ns
+        clk  <= 0
+        x    <= 3
+        y    <= 4
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        reqI <= 1
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        reqI <= 0
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        ackO <= 1
+        !10.ns
+        clk  <= 1
+        !10.ns
+        clk  <= 0
+        ackO <= 0
+    end
+end

data/lib/HDLRuby/hdr_samples/with_of.rb

@@ -0,0 +1,51 @@
+# Some abstract system.
+system :sysA do
+    input :clk,:rst
+    input :d
+    output :q
+end
+
+# Some inheriting system.
+system :sysH, sysA do
+    par(clk.posedge, rst.posedge) do
+        hprint("sys1\n")
+        q <= d & ~rst
+    end
+end
+
+# Another system that have nothing to see with the others.
+# Some abstract system.
+system :sysO do
+    input :clk,:rst
+    input :d
+    output :q
+
+    par(clk.posedge, rst.posedge) do
+        hprint("sys1\n")
+        q <= d & ~rst
+    end
+end
+
+
+# A system for testing inheritance and of?
+system :with_reconf do
+    input :clk,:rst
+    input :d
+    output :q
+
+    # Instantiate the abstract system.
+    sysA(:my_dffA).(clk,rst,d,q)
+
+    # Test the of?
+    puts "my_dffA.systemT.of?(sysA)=#{my_dffA.systemT.of?(sysA)}"
+    puts "my_dffA.systemT.of?(sysH)=#{my_dffA.systemT.of?(sysH)}"
+    puts "my_dffA.systemT.of?(sysO)=#{my_dffA.systemT.of?(sysO)}"
+
+    # Instantiate the inheriting system.
+    sysH(:my_dffH).(clk,rst,d,q)
+
+    # Test the of?
+    puts "my_dffH.systemT.of?(sysH)=#{my_dffH.systemT.of?(sysH)}"
+    puts "my_dffH.systemT.of?(sysA)=#{my_dffH.systemT.of?(sysA)}"
+    puts "my_dffH.systemT.of?(sysO)=#{my_dffH.systemT.of?(sysO)}"
+end

data/lib/HDLRuby/hdr_samples/with_reconf.rb

@@ -1,63 +1,14 @@
-require 'std/reconf.rb'
 
-include HDLRuby::High::Std
-
-
-
-
-# Implementation of a vivado partial reconfiguration system.
-reconf(:vivado_reconf) do |clk,rst|
-
-    # Get access to the interface of the reconfigurable component.
-    inputs = each_input
-    outputs = each_output
-    inouts = each_inout
-
-    # Create the main system with the interface and a channel for
-    # handling the reconfiguration.
-    main = system do
-        # Declares the inputs.
-        inputs.each do |i|
-            i.type.input(i.name)
-        end
-        # Declares the outputs.
-        outputs.each do |o|
-            o.type.output(o.name)
-        end
-        # Declares the inouts.
-        inouts.each do |io|
-            io.type.inout(io.name)
-        end
-        # An that's all: in vivado the main system is to be a black-box.
-    end
-
-    # And set it as the main system.
-    set_main(main)
-
-    # The switching circuit.
-    # reconfer = vivado_reconfigurer :do_reconf # Will be that later
-    # reconfer.clk <= clk 
-    # reconfer.rst <= rst 
-    reconfer = proc do |idx|
-        puts "Instantiating reconfiguration circuits with #{idx}"
-    end
-
-    # Defines the reconfiguring procedure: switch to system idx.
-    switcher do |idx,ruby_block|
-        reconfer.call(idx)
-        ruby_block.call
-    end
-
-end
-
-
-# Some system that can be used for recponfiguration.
+# Some system that can be used for reconfiguration.
 system :sys0 do
     input :clk,:rst
     input :d
     output :q
 
-    q <= d
+    par(clk.posedge) do
+        hprint("sys0\n")
+        q <= d & ~rst
+    end
 end
 
 system :sys1 do
@@ -65,7 +16,10 @@ system :sys1 do
     input :d
     output :q
 
-    (q <= d).at(clk.posedge)
+    par(clk.posedge, rst.posedge) do
+        hprint("sys1\n")
+        q <= d & ~rst
+    end
 end
 
 system :sys2 do
@@ -73,7 +27,10 @@ system :sys2 do
     input :d
     output :q
 
-    (q <= d & ~rst).at(clk.posedge)
+    par(clk.posedge, rst.negedge) do
+        hprint("sys2\n")
+        q <= d & ~rst
+    end
 end
 
 # A system with a reconfifurable part.
@@ -81,23 +38,69 @@ system :with_reconf do
     input :clk,:rst
     input :d
     output :q
-    [2].input :conf # The configuration number
-
-    inner :wait_reconf
 
-    # Create a reconfigurable component.
-    vivado_reconf(clk,rst).(:my_reconf)
-    # It is to be reconfigured to sys0, sys1 or sys2
-    my_reconf.(sys0, sys1, sys2)
-
-    # Connect the reconfigurable instance.
-    my_reconf.instance.(clk,rst,d,q)
-
-    par(clk.posedge) do
-        hif(rst) { wait_reconf <= 0 }
-        helsif(conf != 0 && my_reconf.index != conf && wait_reconf == 0) do
-            wait_reconf <= 1
-            my_reconf.switch(conf) { wait_reconf <= 0 }
+    # Instantiate the default configuration.
+    sys0(:my_dff).(clk,rst,d,q)
+
+    # Adds the additional configuration.
+    my_dff.choice(conf1: sys1, conf2: sys2)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        d <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        3.times do |i|
+            clk <= 1
+            !10.ns
+            clk <= 0
+            d <= 1
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+            d <= 0
+            !10.ns
+            clk <= 1
+            my_dff.configure((i+1)%3)
+            !10.ns
+            clk <= 0
+            !10.ns
         end
+        clk <= 1
+        !10.ns
+        clk <= 0
+        d <= 1
+        !10.ns
+        clk <= 1
+        my_dff.configure(:conf1)
+        !10.ns
+        clk <= 0
+        d <= 0
+        !10.ns
+        clk <= 1
+        my_dff.configure(:conf2)
+        !10.ns
+        clk <= 0
+        d <= 1
+        !10.ns
+        clk <= 1
+        my_dff.configure(:my_dff)
+        !10.ns
+        clk <= 0
+        d <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/with_terminate.rb

@@ -0,0 +1,32 @@
+
+# A benchmark for testing the terminate statement.
+system :with_terminate do
+    [8].constant cst0: 127
+    constant cst1: _1
+    [8].inner sig0: _10000000
+    inner sig1: _1
+    [8].inner :sig2
+    [8].inner count: 0
+
+    timed do
+        !20.ns
+        100.times do
+            count <= count + 1
+            !20.ns
+        end
+    end
+
+    timed do
+        !10.ns
+        sig2  <= cst0 + cst1
+        sig0  <= sig0 + sig1
+        !10.ns
+        sig2 <= sig2 + sig1
+        !10.ns
+        terminate
+        sig0 <= sig0 + sig0
+        !10.ns
+        sig0 <= sig0 + sig0
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -1,5 +1,41 @@
 #!/usr/bin/ruby
 
+
+# Check if run in interactive mode.
+if ARGV.include?("-I") || ARGV.include?("--interactive") then
+    # Yes, first check which repl to use.
+    idx = ARGV.index("-I")
+    idx = ARGV.index("--interactive") unless idx
+    if ARGV[idx+1] == "irb" || ARGV[idx+1] == nil then
+        repl = :irb
+    elsif ARGV[idx+1] == "pry" then
+        repl = :pry
+    else 
+        raise "Unknown repl: #{ARGV[idx+1]}"
+    end
+    # Look for the interactive Ruby library.
+    libpath = ""
+    $:.each do |dir|
+        if File.exist?(dir + "/hdrlib.rb") then
+            libpath = dir + "/hdrlib.rb"
+            break
+        end
+    end
+    ARGV.clear
+    ARGV.concat(['-r', libpath])
+    case repl
+    when :irb
+        require 'irb'
+        IRB.start
+    when :pry
+        require 'pry'
+        require libpath
+        # Pry.start(binding)
+        Pry.start()
+    end
+    abort
+end
+
 require 'fileutils'
 require 'tempfile'
 require 'HDLRuby'
@@ -267,6 +303,9 @@ def which(cmd)
 end
 
 
+# Used standalone, check the files given in the standard input.
+include HDLRuby
+
 
 if __FILE__ == $0 then
     # From hdrcc.rb
@@ -278,9 +317,6 @@ else
 end
 
 require 'optparse'
-# Used standalone, check the files given in the standard input.
-include HDLRuby
-
 # Process the command line options
 $options = {}
 $optparse = OptionParser.new do |opts|
@@ -293,7 +329,10 @@ $optparse = OptionParser.new do |opts|
     opts.separator "* `<output file>` is the output file"
     opts.separator ""
     opts.separator "Options:"
-    
+
+    opts.on("-I", "--interactive") do |repl|
+        raise "Internal error: the --interactive option should have been processed earlier."
+    end
     opts.on("-y", "--yaml", "Output in YAML format") do |y|
         $options[:yaml] = y
     end
@@ -647,12 +686,19 @@ elsif $options[:clang] then
         init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
                                            "init_default_visualizer"
 
+        # Gather the system to generate and sort them in the right order
+        # to ensure references are generated before being used.
+        # Base: reverse order of the tree.
+        # Then, multiple configuration of a system instance must be
+        # reverversed so that the base configuration is generated first.
+        c_systems = $top_system.each_systemT_deep_ref
         # Generate the code of the main function.
         # HDLRuby start code
         $main << HDLRuby::Low::Low2C.main("hruby_simulator",
                                          init_visualizer,
                                          $top_system,
-                                         $top_system.each_systemT_deep.to_a.reverse,$hnames)
+                                         c_systems,
+                                         $hnames)
         $main.close
 
         $top_system.each_systemT_deep do |systemT|