HDLRuby 3.1.0 → 3.3.0

data/lib/HDLRuby/hdr_samples/with_program_ruby_threads.rb

@@ -0,0 +1,56 @@
+
+# A benchmark for testing the use of Ruby software code.
+system :with_ruby_thread do
+    inner :clk, :rst, :req, :ack
+    [8].inner :count
+
+    program(:ruby,:boot) do
+        actport rst.negedge
+        inport  din: count
+        outport ack: ack
+        code "ruby_program/sw_log.rb"
+    end
+
+    program(:ruby,:log) do
+        actport req.posedge
+        code "ruby_program/sw_log.rb"
+    end
+
+    par(ack.posedge) { count <= count + 1 }
+
+
+    timed do
+        clk <= 0
+        rst <= 0
+        count <= 0
+        req <= 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
+        !10.ns
+        clk <= 0
+        !10.ns
+        repeat(100) do
+            clk <= 1
+            req <= 1
+            !10.ns
+            clk <= 0
+            !10.ns
+            clk <= 1
+            req <= 0
+            !10.ns
+            clk <= 0
+            !10.ns
+        end
+
+    end
+end

data/lib/HDLRuby/hdr_samples/with_sequencer.rb

@@ -16,6 +16,7 @@ include HDLRuby::High::Std
 # - One sequencer puts the sum of two arrays in a third one.
 # - One sequencer iterates over two arrays.
 # - One sequencer iterates downward.
+# - One sequencer checks sub iterators (HDLRuby special).
 system :my_seqencer do
 
     inner :clk,:rst
@@ -161,6 +162,22 @@ system :my_seqencer do
         # hprint(")2 res6=",res6,"\n")
     end
 
+    [8].inner :res7,:res8
+
+    sequencer(clk.posedge,rst) do
+        res7 <= 0
+        res8 <= 0
+        ar0.seach_range(0..3) do |elem|
+            res7 <= elem
+        end
+        ar0.seach_range(4..9) do |elem|
+            res7 <= elem
+        end
+        (_h00.._h07).seach_range(1..4) do |elem|
+            res8 <= elem
+        end
+    end
+
 
     timed do
         clk <= 0

data/lib/HDLRuby/hdr_samples/with_sequencer_channel.rb

@@ -0,0 +1,58 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of sequencers' channels.
+system :my_seqencer do
+
+    inner :clk,:rst,filled: 0
+    bit[16][-16].inner :mem
+    [16].inner :res0, :res1, :res2, :res3
+
+    ch_read = schannel(bit[16],16) do |i|
+        mem[i]
+    end
+
+    ch_write = schannel(bit[16],16) do |i,val|
+        mem[i] <= val
+    end
+
+    sequencer(clk.posedge,rst) do
+        16.stimes { |i| ch_write.snext!(i) }
+        filled <= 1
+        16.stimes do |i| 
+            res0 <= ch_read.snext 
+            res1 <= ch_read[15-i]
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        swhile(~filled);
+        16.stimes do |i| 
+            res2 <= ch_read.snext 
+            res3 <= ch_read[15-i]
+        end
+    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_enumerable.rb

@@ -34,6 +34,7 @@ include HDLRuby::High::Std
 # - The twenty nineth sequencer checks stake and stake_while
 # - The thirtieth sequencer checks suniq
 # - The thirty first sequencer checks szip
+# - The thirty second sequnecer checks seach_nexts (HDLRuby special)
 #
 # __WARNING__: All the operations on enumerators generate their own result
 #              signal. Therefore, in a real circuit, there is no need to
@@ -414,6 +415,15 @@ system :my_seqencer do
         # hprint("}1 res52=",res52," res53=",res53,"\n")
     end
 
+    [8].inner :res54,:res55
+
+    sequencer(clk.posedge,rst) do
+        res54 <= 0
+        res55 <= 0
+        vals.seach_nexts(6) { |i| res54 <= i }
+        res55 <= vals.seach_nexts(4).ssum
+    end
+
 
 
     timed do

data/lib/HDLRuby/hdr_samples/with_sequencer_enumerator.rb

@@ -52,16 +52,30 @@ system :my_seqencer do
 
     data <= mem[addr]
 
-    mem_enum = senumerator(bit[8],8) do |i|
-        addr <= i
-        step
-        data
+    mem_enum = senumerator(bit[8],8) do |i,val|
+        if val then
+            # Write
+            mem[i] <= val
+            step
+            val
+        else 
+            # Read
+            addr <= i
+            step
+            data
+        end
     end
 
     sequencer(clk.posedge,rst) do
         # hprint("~0\n")
         res6 <= 0
         res6 <= mem_enum.ssum
+        mem_enum.srewind
+        mem_enum.snext!(_hAA)
+        mem_enum.snext!(_hBB)
+        mem_enum.srewind
+        res6 <= mem_enum.snext
+        res6 <= mem_enum.snext
         # hprint("~1 res6=",res6,"\n")
     end
 

data/lib/HDLRuby/hdr_samples/with_sequencer_func.rb

@@ -1,7 +1,3 @@
-require 'std/sequencer_func.rb'
-
-include HDLRuby::High::Std
-
 
 # A factorial with default stack depth.
 sdef(:fact) do |n|
@@ -31,11 +27,13 @@ system :my_seqencer do
         5.stimes do |i|
             val <= i
             res <= fact(val)
+            hprint("res=",res,"\n")
         end
         hprint("Going to overflow...\n")
         4.stimes do |i|
             val <= i
             res <= fact_over(val)
+            hprint("res=",res,"\n")
         end
         hprint("stack_overflow_error=",stack_overflow_error,"\n")
     end

data/lib/HDLRuby/hdr_samples/with_sequencer_sync.rb

@@ -13,7 +13,8 @@ system :my_seqencer do
     arbiter(:arbiter0).(x1)
 
     par(clk.posedge) do
-        x0.select <= x0.select + 1
+        hif(rst) { x0.select(0) }
+        helse { x0.select(x0.select + 1) }
     end
 
     sequencer(clk.posedge,rst) do

data/lib/HDLRuby/hdrcc.rb

@@ -37,19 +37,19 @@ if ARGV.include?("-I") || ARGV.include?("--interactive") then
 end
 
 
-begin
-    # We can check the memory.
-    require 'get_process_mem'
-    $memory_check = GetProcessMem.new
-    def show_mem
-        " | "+$memory_check.bytes.to_s+"B"
-    end
-rescue LoadError
-    # We cannot check the memory.
+# begin
+#     # We can check the memory.
+#     require 'get_process_mem'
+#     $memory_check = GetProcessMem.new
+#     def show_mem
+#         " | "+$memory_check.bytes.to_s+"B"
+#     end
+# rescue LoadError
+#     # We cannot check the memory.
     def show_mem
         ""
     end
-end
+# end
 
 
 require 'fileutils'
@@ -84,6 +84,10 @@ require 'HDLRuby/backend/hruby_c_allocator'
 
 require 'HDLRuby/version.rb'
 
+# Global flags
+$sim = false     # Tells if hdrcc is in simulation mode
+$gen = false     # Tells if hdrcc is in hardware generation mode
+
 
 ##
 # HDLRuby compiler interface program
@@ -363,29 +367,33 @@ $optparse = OptionParser.new do |opts|
     opts.on("-r", "--hdr","Output in HDLRuby format") do |v|
         $options[:hdr] = v
     end
-    opts.on("-C", "--clang","Output in C format (simulator)") do |v|
-        $options[:clang] = v
-        $options[:multiple] = v
-    end
-    opts.on("--allocate=LOW,HIGH,WORD","Allocate signals to addresses") do |v|
-        $options[:allocate] = v
-    end
+    # opts.on("-C", "--clang","Output in C format (simulator, deprecated)") do |v|
+    #     $options[:clang] = v
+    #     $options[:multiple] = v
+    # end
+    # opts.on("--allocate=LOW,HIGH,WORD","Allocate signals to addresses") do |v|
+    #     $options[:allocate] = v
+    # end
     opts.on("-S","--sim","Default simulator (hybrid C-Ruby)") do |v|
         $options[:rcsim] = v
         $options[:multiple] = v
+        $sim = true
     end
-    opts.on("--csim","Standalone C-based simulator") do |v|
+    opts.on("--csim","Standalone C-based simulator (deprecated)") do |v|
         $options[:clang] = v
         $options[:multiple] = v
         $options[:csim] = v
+        $sim = true
     end
-    opts.on("--rsim","Ruby-based simulator") do |v|
+    opts.on("--rsim","Ruby-based simulator (deprecated)") do |v|
         $options[:rsim] = v
         $options[:multiple] = v
+        $sim = true
     end
     opts.on("--rcsim","Hybrid C-Ruby-based simulator") do |v|
         $options[:rcsim] = v
         $options[:multiple] = v
+        $sim = true
     end
     opts.on("--mute", "The simulator will not generate any output") do |v|
         $options[:mute] = v
@@ -393,15 +401,44 @@ $optparse = OptionParser.new do |opts|
     opts.on("--vcd", "The simulator will generate a vcd file") do |v|
         $options[:vcd] = v
     end
+    opts.on("--ch dir", "Generates the files for compiling a software extension") do |dir|
+        # Check the target directory.
+        if !dir or dir.empty? then
+            raise "Need a program name for generating the compiling files."
+        end
+        # Create the source path.
+        src_path = File.dirname(__FILE__) + "/../c/"
+        # Create the target directory.
+        Dir.mkdir(dir) unless File.exist?(dir)
+        # Copy the header files.
+        ## FileUtils.copy(src_path + "cHDL.h",dir)
+        # And update it with any empty initialization function
+        # (not used but required for compiling for windows).
+        lines = nil
+        File.open(src_path + "cHDL.h","r") {|f| lines = f.readlines }
+        lines = ["void Init_#{dir}() {}\n\n"] + lines
+        File.open(dir + "/" + "cHDL.h", "w") {|f| lines.each {|l| f.write(l) } }
+        # Copy and modify the files for rake.
+        ["extconf.rb", "Rakefile"].each do |fname|
+            lines = nil
+            File.open(src_path + fname,"r") {|f| lines = f.readlines }
+            # puts "Checking dir: #{File.dirname(__FILE__)+"/../hruby_sim/"}"
+            lines = ["C_PROGRAM = '#{dir}'\nRCSIM_DIR = '#{File.dirname(__FILE__)+"/../hruby_sim/"}'\n"] + lines
+            File.open(dir + "/" + fname, "w") {|f| lines.each {|l| f.write(l) } }
+        end
+        exit
+    end
     opts.on("-v", "--verilog","Output in Verlog HDL format") do |v|
         $options[:verilog] = v
         $options[:multiple] = v
+        $gen = true
     end
     opts.on("-V", "--vhdl","Output in VHDL format") do |v|
         HDLRuby::Low::Low2VHDL.vhdl08 = false
         $options[:vhdl] = v
         $options[:multiple] = v
         $options[:vhdl08] = false
+        $gen = true
     end
     opts.on("-A", "--alliance","Output in Alliance-compatible VHDL format") do |v|
         HDLRuby::Low::Low2VHDL.vhdl08 = false
@@ -410,12 +447,14 @@ $optparse = OptionParser.new do |opts|
         $options[:alliance] = v
         $options[:multiple] = v
         $options[:vhdl08] = false
+        $gen = true
     end
     opts.on("-U", "--vhdl08","Output in VHDL'08 format") do |v|
         HDLRuby::Low::Low2VHDL.vhdl08 = true
         $options[:vhdl] = v
         $options[:multiple] = v
         $options[:vhdl08] = true
+        $gen = true
     end
     opts.on("-s", "--syntax","Output the Ruby syntax tree") do |s|
         $options[:syntax] = s
@@ -454,14 +493,26 @@ $optparse = OptionParser.new do |opts|
         $options[:dump] = v
         $options[:multiple] = v
     end
-    opts.on("--get-samples", "Copy the sample directory (hdr_samples) to current one, the exit") do
+    opts.on("--get-samples", "Copy the sample directory (hdr_samples) to current one, then exit") do
         FileUtils.copy_entry(File.dirname(__FILE__) + "/hdr_samples","./hdr_samples")
+        FileUtils.copy_entry(File.dirname(__FILE__) + "/hdr_samples/c_program","./hdr_samples/c_program")
+        FileUtils.copy_entry(File.dirname(__FILE__) + "/hdr_samples/ruby_program","./hdr_samples/ruby_program")
+        exit
+    end
+    opts.on("--get-tuto", "Copy the tutorial directory (tuto) to current one, then exit") do
+      FileUtils.copy_entry(File.dirname(__FILE__) + "../../tuto","./tuto")
         exit
     end
     opts.on("--version", "Show the version of HDLRuby, then exit") do |v|
         puts VERSION
         exit
     end
+    opts.on("--path","Shows the path where HDLRuby is install.") do |v|
+        require 'pathname'
+        path = Pathname.new(__FILE__ + "../../../../").cleanpath
+        puts path.to_s
+        exit
+    end
     # opts.on_tail("-h", "--help", "Show this message") do
     opts.on("-h", "--help", "Show this message") do
         puts opts
@@ -571,7 +622,7 @@ if $options[:syntax] then
     $output << $loader.show_all
     exit
 end
-HDLRuby.show "#{Time.now}#{show_mem}"
+# HDLRuby.show "#{Time.now}#{show_mem}"
 HDLRuby.show "##### Starting parser #####"
 
 if $options[:debug] then

data/lib/HDLRuby/hruby_error.rb

@@ -5,6 +5,10 @@ module HDLRuby
     class AnyError < ::StandardError
     end
 
+    ## The HDLRuby UI error class.
+    class UIError < ::StandardError
+    end
+
     module High
         ## The HDLRuby::High error class.
         class AnyError < HDLRuby::AnyError
@@ -13,12 +17,21 @@ module HDLRuby
         ## The HDLRuby error class replacing the standard Ruby NoMethodError
         class NotDefinedError < AnyError
         end
+
+        ## The HDLRuby::High UI error class.
+        class UIError < HDLRuby::UIError
+        end
     end
 
+
     module Low
         ## The HDLRuby::Low error class.
         class AnyError < HDLRuby::AnyError
         end
+
+        ## The HDLRuby::Low UI error class.
+        class UIError < HDLRuby::UIError
+        end
     end
 
     ## Execution context for processing error messages in +code+.