HDLRuby 2.9.0 → 2.10.5

data/lib/HDLRuby/hdr_samples/dff_bench.rb

@@ -11,7 +11,10 @@ system :dff_bench do
     inner :d, :clk, :rst
     inner :q
 
-    dff(:my_dff).(d,clk,rst,q)
+    # dff(:my_dff).(d,clk,rst,q)
+    dff(:my_dff).(d,clk)
+    q <= my_dff.q
+    my_dff.clk <= clk
 
     timed do
         clk <= 0

data/lib/HDLRuby/hdr_samples/dff_override.rb

@@ -0,0 +1,76 @@
+# A simple D-FF with overridable part.
+system :dff do
+    input  :d, :clk, :rst
+    output :q
+
+    sub(:process) do
+        (q <= d & ~rst).at(clk.posedge)
+    end
+end
+
+# A new dff overriding process.
+system :dff_neg, dff do
+    sub(:process) do
+        (q <= d & ~rst).at(clk.negedge)
+    end
+end
+
+# A benchmark for the dff.
+system :dff_bench do
+    inner :d, :clk, :rst
+    inner :q
+
+    dff_neg(:my_dff).(d,clk,rst,q)
+    # dff(:my_dff).(d,clk,rst,q)
+
+    timed do
+        clk <= 1
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 0
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 0
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 0
+        !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_values.rb

@@ -37,6 +37,20 @@ system :with_values do
         v64 <= 128
         v96 <= 128
         !10.ns
+        v8  <= -1
+        v16 <= -1
+        v32 <= -1
+        v56 <= -1
+        v64 <= -1
+        v96 <= -1
+        !10.ns
+        v8  <= -2
+        v16 <= -2
+        v32 <= -2
+        v56 <= -2
+        v64 <= -2
+        v96 <= -2
+        !10.ns
         v16 <= 0x1000
         v32 <= 0x1000
         v56 <= 0x1000

data/lib/HDLRuby/hdrcc.rb

@@ -1,5 +1,57 @@
 #!/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
+
+
+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
+
+
 require 'fileutils'
 require 'tempfile'
 require 'HDLRuby'
@@ -31,6 +83,7 @@ require 'HDLRuby/backend/hruby_c_allocator'
 
 require 'HDLRuby/version.rb'
 
+
 ##
 # HDLRuby compiler interface program
 #####################################
@@ -267,6 +320,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 +334,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 +346,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
@@ -486,7 +542,7 @@ if $options[:syntax] then
     $output << $loader.show_all
     exit
 end
-HDLRuby.show Time.now
+HDLRuby.show "#{Time.now}#{show_mem}"
 HDLRuby.show "##### Starting parser #####"
 
 if $options[:debug] then
@@ -499,11 +555,11 @@ end
 
 # Generate the result.
 # Get the top systemT.
-HDLRuby.show Time.now
+HDLRuby.show "#{Time.now}#{show_mem}"
 $top_system = $top_instance.to_low.systemT
 $top_intance = nil # Free as much memory as possible.
 HDLRuby.show "##### Top system built #####"
-HDLRuby.show Time.now
+HDLRuby.show "#{Time.now}#{show_mem}"
 
 
 # # Apply the pre drivers if any.
@@ -574,19 +630,19 @@ elsif $options[:clang] then
         # Coverts the par blocks in seq blocks to seq blocks to match
         # the simulation engine.
         systemT.par_in_seq2seq!
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
         HDLRuby.show "connections_to_behaviors step..."
         # Converts the connections to behaviors.
         systemT.connections_to_behaviors!
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
         # Break the RefConcat.
         HDLRuby.show "concat_assigns step..."
         systemT.break_concat_assigns! 
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
         # Explicits the types.
         HDLRuby.show "explicit_types step..."
         systemT.explicit_types!
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
     end
     # Generate the C.
     if $options[:multiple] then
@@ -729,23 +785,23 @@ elsif $options[:verilog] then
         # HDLRuby.show Time.now
         HDLRuby.show "to_upper_space! step..."
         systemT.to_upper_space!
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
     end
     HDLRuby.show "to_global_space! step (global)..."
     $top_system.to_global_systemTs!
-    HDLRuby.show Time.now
+    HDLRuby.show "#{Time.now}#{show_mem}"
     $top_system.each_systemT_deep do |systemT|
         ## systemT.break_types!
         ## systemT.expand_types!
         HDLRuby.show "par_in_seq2seq! step..."
         systemT.par_in_seq2seq!
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
         HDLRuby.show "initial_concat_to_timed! step..."
         systemT.initial_concat_to_timed!
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
         HDLRuby.show "with_port! step..."
         systemT.with_port!
-        HDLRuby.show Time.now
+        HDLRuby.show "#{Time.now}#{show_mem}"
     end
     # # Verilog generation
     # $output << top_system.to_verilog
@@ -836,7 +892,7 @@ elsif $options[:vhdl] then
 end
 
 HDLRuby.show "##### Code generated #####"
-HDLRuby.show Time.now
+HDLRuby.show "#{Time.now}#{show_mem}"
 
 # # Apply the post drivers if any.
 # Hdecorator.each_with_property(:post_driver) do |obj, value|