HDLRuby 3.3.3 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fc400e683cbefc6a77e8e6c4394f67e88df74fccd3bcb4ba420f6babc2542c8
-  data.tar.gz: e4619579f4ef6703c38cb1ee5cc95197b37b929eb630f93497a4b7bde0a4955f
+  metadata.gz: a22563a2a4dc9d6d53ba33618efa1c18d0cfb51336bb1308545b77f6673c7719
+  data.tar.gz: 4e3d7d9cf4fc513a42cdae82f51ef8e2dcc732f79076e23f14b50b8c1614191e
 SHA512:
-  metadata.gz: 581b6f3029bc63108c0408495dcebaf6305f61697099985c7b2f043f3250d377e5640f0db7305f62ed2a4430f60f6dfc85495a382e84f89a1d595ac5519cebaa
-  data.tar.gz: 1821cb1ee95bb0abfdfd8d99318b1a5a103baabc3c3d3c58e50cd965f54059d0636b3cd352f1c9e726c7c04d3282f06820896cc9cf74e92b6e7a721bcd254560
+  metadata.gz: 9087fea3e3d94a9d136482b27d017151e2e9593c4244ca7777cbc6cf63587163c6cec6c6d43b8721c4f1935f06ef9a28bd41c0bf271080b312d7f904fc4ef9ce
+  data.tar.gz: 47672356dba32493e1e3a9d7e38b9199c1bf44ea85f9e82d5e157daf2f3f4465c9cdc6cc78a079a1276d92672a9e6a4b08931ea5dbba85b33f57544a71f01825

data/README.md

@@ -17,6 +17,19 @@ hdrcc --get-tuto
 
 __What's new__
 
+For HDLRuby version 3.4.0:
+
+ * Improved synchronization of the browser-base graphical interface with the HDLRuby simulator.
+
+ * Added a Verilog HDL parsing library for Ruby. This library will be released separately once it is fully stabilized."
+
+ * Added a HDLRuby generating library from the a Verilog HDL AST provided by the above-mentioned library.
+
+ * Added a standalone tool for converting Verilog HDL files to HDLRuby called [v2hdr](#converting-verilog-hdl-to-hdlruby). This tool is still experimental though.
+
+ * Added a HDLRuby command for [loading a Verilog HDL file from a HDLRuby description](#loading-verilog-hdl-from-hdlruby).
+
+
 For HDLRuby version 3.3.0:
  
  * Remade the description of software components using the program construct.
@@ -3929,6 +3942,57 @@ The naming convention of the samples is the following:
 * `<name>_bench.rb`: sample including a simulation benchmark, these are the only samples that can be simulated using `hdrcc -S`. Please notice that such a sample cannot be converted to VHDL or Verilog HDL yet.
 * `with_<name>.rb`: sample illustrating a single aspect of HDLRuby or one of its libraries, usually includes a benchmark.
 
+# Converting Verilog HDL to HDLRuby
+
+While the HDLRuby framwork does not support Verilog HDL files as input yet, a standalone tool is provided for converting those files to HDLRuby. For that please use the following command:
+
+```bash
+v2hdr <input Verilog HDL file> <output HDLRuby file>
+```
+
+For example, assuming that you have a Verilog ddHDL named 'adder.v' describing and adder circuit, you can convert it to HDLRuby as follows:
+
+```bash
+v2hdr adder.v adder.v.rb
+```
+
+Another possibility is to directly load the Verilog HDL file from a HDLRuby description using the command `require_verilog`.
+For example, assuming `adder.v` contains the following code:
+
+```verilog
+module adder(x,y,z);
+  input[7:0] x,y;
+  output[7:0] z;
+  
+  assign z = x + y;
+endmodule
+```
+
+It can be loaded the be instantiated like any other module in HDLRuby as follows:
+
+```ruby
+require_verilog "adder.v"
+
+system :my_IC do
+   [8].inner :a, :b, :c
+
+   adder(:my_adder).(a,b,c)
+
+   ...
+end
+```
+
+
+__Notes__:
+
+* Verilog HDL accepts signal and module names in any letter case, while HDLRuby reserves identifiers starting with a capital letter for constants. To avoid conflicts, Verilog HDL names that begin with a capital letter are prefixed with an underscore (`_`) in HDLRuby. For example, if the Verilog HDL module name in the previous example were `ADDER`, it would be renamed to `_ADDER` in HDLRuby. Instantiating such a module would be done as follows:
+
+  ```ruby
+  _ADDER(:my_add).(a,b,c)
+  ```
+
+* With the current version of HDLRuby, the Verilog HDL files are first converted to HDLRuby before being loaded using the standalone `v2hdr` tool.
+
 
 # Contributing
 
@@ -3938,7 +4002,6 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/civol/
 # To do
 
  * Find and fix the (maybe) terrifying number of bugs.
- * Add a GUI (any volunteer to do it?).
 
 
 # License

data/exe/v2hdr

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+require 'HDLRuby/v2hdr.rb'

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -554,6 +554,7 @@ VALUE rcsim_make_timeWait(VALUE mod, VALUE unitV, VALUE delayV) {
     /* Adjust the delay depending on the unit. */
     const char* unit = rb_id2name(SYM2ID(unitV));
     switch(unit[0]) {
+        case 'f': delay /= 1000;          break;
         case 'p': /* Ok as is. */         break;
         case 'n': delay *= 1000;          break;
         case 'u': delay *= 1000000;       break;

data/lib/HDLRuby/hdr_samples/adder8.v

@@ -0,0 +1,6 @@
+module adder8(x,y,z);
+  input[7:0] x,y;
+  output[7:0] z;
+  
+  assign z = x + y;
+endmodule

data/lib/HDLRuby/hdr_samples/sw_encrypt_bench.rb

@@ -1,3 +1,5 @@
+raise "Deprecated code."
+
 # require "../hruby_low2c.rb"
 
 # An 8-bit register with C encrypting.

data/lib/HDLRuby/hdr_samples/sw_encrypt_cpu_bench.rb

@@ -1,3 +1,5 @@
+raise "Deprecated code."
+
 require 'HDLRuby/backend/allocator'
 require 'HDLRuby/hdr_samples/mei8'
 

data/lib/HDLRuby/hdr_samples/sw_encrypt_cpusim_bench.rb

@@ -1,3 +1,5 @@
+raise "Deprecated code."
+
 require 'HDLRuby/backend/allocator'
 
 ## A generic CPU description

data/lib/HDLRuby/hdr_samples/verilog_parser_bench.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH << "#{__dir__}/../../"
+
+require "HDLRuby/verilog_hruby.rb"
+
+parser = VerilogTools::Parser.new
+
+ast = nil
+
+begin
+  ast = parser.run(filename: ARGV[0], compress: ARGV[1] == "--compress" )
+rescue => error
+  puts error
+  exit
+end
+
+puts "#################################"
+puts "##             AST             ##"
+puts "#################################"
+puts "\n"
+
+puts ast
+
+hdlruby = ""
+begin
+  hdlruby = ast.to_HDLRuby
+rescue => error
+  puts error
+  exit
+end
+
+puts "\n"
+puts "#################################"
+puts "##           HDLRuby           ##"
+puts "#################################"
+
+puts hdlruby

data/lib/HDLRuby/hdr_samples/with_handshake.rb

@@ -1,3 +1,5 @@
+raise "Deprecated code."
+
 require 'std/handshakes.rb'
 
 include HDLRuby::High::Std

data/lib/HDLRuby/hdr_samples/with_memory.rb

@@ -1,3 +1,5 @@
+raise "Deprecated code."
+
 require 'std/memory.rb'
 
 include HDLRuby::High::Std

data/lib/HDLRuby/hdr_samples/with_nand_board.rb

@@ -11,7 +11,7 @@ system :nand_board do
     inner :clk
     # Description of the board.
     # It is updated at each rising edge of +clk+.
-    board(:nand,8080) do
+    board(:nand,http_port: 8080) do
         actport clk.posedge
         sw din0: din0
         sw din1: din1

data/lib/HDLRuby/hdr_samples/with_reconf.rb

@@ -1,3 +1,4 @@
+raise "Deprecated code."
 
 # Some system that can be used for reconfiguration.
 system :sys0 do

data/lib/HDLRuby/hdr_samples/with_verilog.rb

@@ -0,0 +1,24 @@
+# Sample HDLRuby instantiating a Verilog HDL-described adder (adder.v)
+
+require_verilog "adder8.v"
+
+system :verilog_bench do
+  [8].inner :a, :b, :c
+
+  # Instantiate the adder.
+  adder8(:my_adder8).(a,b,c)
+
+  # Testing it.
+  timed do
+    a <= 0
+    b <= 0
+    repeat(100) do
+      repeat(100) do
+        !10.ns
+        b <= b + 1
+      end
+      a <= a + 1
+    end
+    !10.ns
+  end
+end

data/lib/HDLRuby/hruby_high.rb

@@ -1235,8 +1235,10 @@ module HDLRuby::High
         end
 
         # Declares a high-level sequential behavior activated on a list of
-        # +events+, and built by executing +ruby_block+.
-        def seq(*events, &ruby_block)
+        # +events+, with possible name +name+ and built by executing
+        # +ruby_block+.
+        # def seq(*events, &ruby_block)
+        def seq(*events, name: nil, &ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # Preprocess the events.
@@ -1244,12 +1246,16 @@ module HDLRuby::High
                 event.respond_to?(:to_event) ? event.to_event : event
             end
             # Create and add the resulting behavior.
-            self.add_behavior(Behavior.new(:seq,*events,&ruby_block))
+            # self.add_behavior(Behavior.new(:seq,*events,&ruby_block))
+            self.add_behavior(Behavior.new(:seq,*events,name: name,
+                                           &ruby_block))
         end
 
         # Declares a high-level parallel behavior activated on a list of
-        # +events+, and built by executing +ruby_block+.
-        def par(*events, &ruby_block)
+        # +events+, with possible name +name+ and built by executing
+        # +ruby_block+.
+        # def par(*events, &ruby_block)
+        def par(*events, name: nil, &ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # Preprocess the events.
@@ -1257,7 +1263,8 @@ module HDLRuby::High
                 event.respond_to?(:to_event) ? event.to_event : event
             end
             # Create and add the resulting behavior.
-            self.add_behavior(Behavior.new(:par,*events,&ruby_block))
+            self.add_behavior(Behavior.new(:par,*events,name: name,
+                                           &ruby_block))
         end
 
         # Declares a high-level timed behavior built by executing +ruby_block+.
@@ -2271,6 +2278,22 @@ module HDLRuby::High
     end
 
 
+    ## Methods for loading external files.
+
+    # Require a verilog file.
+    def require_verilog(filename)
+      # Converts the file to HDLRuby.
+      if Kernel.system("v2hdr", "#{filename}", "#{filename}.rb") then
+        # Success, require the resulting file.
+        require "#{Dir.pwd}/#{filename}.rb"
+      else
+        # Failure.
+        raise AnyError, 
+          "Could not load Verilog HDL file: #{filename}."
+      end
+    end
+
+
 
     # Classes describing harware instances.
 
@@ -4558,20 +4581,19 @@ module HDLRuby::High
         High = HDLRuby::High
 
         # Creates a new behavior executing +block+ activated on a list of
-        # +events+, and built by executing +ruby_block+.
+        # +events+, possible name (of main block) +name+ and built by
+        # executing +ruby_block+.
         # +mode+ can be either :seq or :par for respectively sequential or
         # parallel.
-        def initialize(mode,*events,&ruby_block)
+        # def initialize(mode, *events, &ruby_block)
+        def initialize(mode, *events, name: nil, &ruby_block)
             # Initialize the behavior with it.
             super(nil)
-            # # Save the Location for debugging information
-            # @location = caller_locations
-            # # Sets the current behavior
-            # @@cur_behavior = self
             # Add the events (they may be hierarchical to flatten)
             events.flatten.each { |event| self.add_event(event) }
             # Create and add the block.
-            self.block = High.make_block(mode,&ruby_block)
+            # self.block = High.make_block(mode,&ruby_block)
+            self.block = High.make_block(mode,*name,&ruby_block)
             # # Unset the current behavior
             # @@cur_behavior = nil
         end
@@ -4866,6 +4888,11 @@ module HDLRuby::High
             to_expr
         end
 
+        # Converts to a new dealy in fentoseconds.
+        def fs
+          return Delay.new(self,:fs)
+        end
+
         # Converts to a new delay in picoseconds.
         def ps
             return Delay.new(self,:ps)

data/lib/HDLRuby/hruby_tools.rb

@@ -7,7 +7,6 @@ module HDLRuby
 # General tools for handling HDLRuby objects
 #######################################################
 
-
     # Method and attribute for generating an absolute uniq name.
     # Such names cannot be used in HDLRuby::High code, but can be used
     # to generate such code.

data/lib/HDLRuby/ui/hruby_board.rb

@@ -63,7 +63,8 @@ module HDLRuby::High::Std
     end
 
     ## Class describing a digit display.
-    DIGIT = Struct.new(:id, :size, :hread) do
+    #  Need to know the data type since signed is supported.
+    DIGIT = Struct.new(:id, :size, :type, :hread) do
       def to_html
         return '<div class="digitset" id=' + self.id.to_s +
               ' data-width="' + self.size.to_s + '" data-value="0" >' +
@@ -559,6 +560,9 @@ Content-Type: text/html
   const cartouche = document.getElementById("cartouche");
   const panel     = document.getElementById("panel");
 
+  // The current time stamp.
+  var time_stamp = 0;
+
   // The input and output elements' ids.
   const input_ids = [];
   const output_ids = [];
@@ -689,7 +693,7 @@ Content-Type: text/html
   function digitset_update(digitset,value) {
     // Update the digiset value.
     digitset.dataset.value = value;
-    // Unsigned case.
+    // Update its display.
     const num = digitset.dataset.width;
     digitset.lastElementChild.innerHTML = String(value).padStart(num,"\u00A0");
   }
@@ -704,7 +708,9 @@ Content-Type: text/html
   }
 
   // Update an oscilloscope.
-  function scope_update(scope,value) {
+  function scope_update(scope,value,new_time_stamp) {
+    // Compute the advance in time.
+    let diff_time_stamp = new_time_stamp - time_stamp;
     // Get the canvas.
     const canvas = scope.lastElementChild;
     // Shall we set up its size?
@@ -775,21 +781,21 @@ Content-Type: text/html
       // Draw a line to the new position.
       cxt.beginPath();
       cxt.moveTo(toPx(pos),   toPy(previous));
-      cxt.lineTo(toPx(pos+1), toPy(value)); 
+      cxt.lineTo(toPx(pos+diff_time_stamp), toPy(value)); 
       cxt.stroke();
       /* Update the values. */
       scope.dataset.previous = value;
-      scope.dataset.pos = pos + 1;
+      scope.dataset.pos = pos + diff_time_stamp;
     }
   }
 
   // Update a general display element.
-  function element_update(element,value) {
+  function element_update(element,value,new_time_stamp) {
     if(element.classList.contains('ledset'))  { ledset_update(element,value); }
     if(element.classList.contains('digitset')){ digitset_update(element,value); }
     if(element.classList.contains('signedset')){signedset_update(element,value);}
     if(element.classList.contains('hexaset')) { hexaset_update(element,value); }
-    if(element.classList.contains('scope'))   { scope_update(element,value); }
+    if(element.classList.contains('scope'))   { scope_update(element,value,new_time_stamp); }
   }
 
 
@@ -799,19 +805,25 @@ Content-Type: text/html
     xhttp.onreadystatechange = function() {
       // console.log("response=" + this.responseText);
       if (this.readyState == 4 && this.status == 200) {
-        if (/[0-9]+:[0-9]/.test(this.responseText)) {
+        if (/^[0-9]+;[0-9]+:-?[0-9]/.test(this.responseText)) {
           // There is a real response.
           // Update the interface with the answer.
           const commands = this.responseText.split(';');
+          // Get the new time stamp.
+          let new_time_stamp = commands.shift();
+          // console.log("new_time_stamp=" + new_time_stamp);
+          // Process the other commands.
           for(command of commands) {
              const toks = command.split(':');
-             element_update(document.getElementById(toks[0]),toks[1]);
+             element_update(document.getElementById(toks[0]),toks[1],new_time_stamp);
           }
+          // Update the time stamp
+          time_stamp = new_time_stamp
         }
       }
     };
     // Builds the action from the state of the input elements.
-    act = '';
+    let act = '';
     for(id of input_ids) {
       act += id + ':' + document.getElementById(id).dataset.value + ';';
     }
@@ -824,8 +836,9 @@ Content-Type: text/html
   // First call of synchronisation.
   hruby_sync();
 
-  // Then periodic synchronize.
-  setInterval(function() { hruby_sync(); }, 100);
+  // Moved to the Ruby constructor to allow setting the time intervals.
+  // // Then periodic synchronize.
+  // setInterval(function() { hruby_sync(); }, 100);
 
 </script>
 
@@ -850,9 +863,14 @@ HTMLRESPONSE
 
     # Create a new board named +name+ accessible on HTTP port +http_port+
     # and whose content is describe in +hdlruby_block+.
-    def initialize(name, http_port = 8000, &hdlruby_block)
+    def initialize(name, http_port: 8000, refresh_rate: 100,
+                   &hdlruby_block)
       # Set the name.
       @name = name.to_s
+      # Set the refresh rate.
+      @refresh_rate = refresh_rate.to_i
+      # Tell the interface is to be built.
+      @first = true
       # Check and set the port.
       http_port = http_port.to_i
       if (@@http_ports.include?(http_port)) then
@@ -869,13 +887,17 @@ HTMLRESPONSE
       # Initialize the list of board elements to empty.
       @elements = []
       @out_elements = []
+      # Initialize the time stamp.
+      @time_stamp = 0
       # And build the board.
       # Create the namespace for the program.
       @namespace = Namespace.new(self)
       # Build the program object.
       High.space_push(@namespace)
       pr = nil
-      High.top_user.instance_eval { pr = program(:ruby, @name.to_sym) {} }
+      High.top_user.instance_eval do
+        pr = program(:ruby, @name.to_sym) { }
+      end
       @program = pr
       # Fill it.
       High.top_user.instance_eval(&hdlruby_block)
@@ -936,6 +958,7 @@ HTMLRESPONSE
       # Createthe ui component.
       @elements << DIGIT.new(@elements.size, 
               Math.log10(2**hport[1].type.width - 1).to_i + (sign ? 2 : 1),
+              hport[1].type,
               hport[0])
       @out_elements << @elements[-1]
     end
@@ -1018,9 +1041,13 @@ HTMLRESPONSE
     # Generate a response to a request to the server.
     def make_response(request)
       # puts "request=#{request}"
-      if (request.empty?) then
+      if (@first) then
+        @first = false
         # First or re-connection, generate the UI.
-        return UI_header + "\n<script>\n" + 
+        return UI_header + 
+          "\n<script>\n" + 
+          "// Then periodic synchronize.\n" + 
+          "setInterval(function() { hruby_sync(); }, #{@refresh_rate});\n" + 
           "set_cartouche('#{@name}');\n" +
           @elements.map do |elem|
             "add_element('#{elem.to_html}');"
@@ -1030,11 +1057,13 @@ HTMLRESPONSE
         # This should be an AJAX request, process it.
         commands = request.split(";")
         commands.each do |command|
+          next unless command.include?(":")
           id, val = command.split(":").map {|t| t.to_i}
           self.update_port(id,val)
         end
         # And generate the response: an update of each board output element.
-        return UI_response + @out_elements.each.map do |e|
+        return UI_response + "#{@time_stamp};" + 
+          @out_elements.each.map do |e|
           # puts "resp=" + "#{e.id}:#{RubyHDL.send(e.hread)}"
           "#{e.id}:#{RubyHDL.send(e.hread)}"
         end.join(";")
@@ -1057,6 +1086,8 @@ HTMLRESPONSE
             session.print self.make_response(path[1..-1])
             # And tell the ui has been connected.
             @connected = true
+            # Then advance the time stamp.
+            @time_stamp += 1
           else
             session.print 'Connection Refuse'
           end
@@ -1072,8 +1103,11 @@ HTMLRESPONSE
 
   # Create a new board named +name+ accessible on HTTP port +http_port+
   # and whose content is describe in +block+.
-  def board(name, http_port = 8000, &block)
-    return Board.new(name,http_port,&block)
+  def board(name, http_port: 8000, refresh_rate: 100, &block)
+    # puts "name=#{name} http_port=#{http_port} refresh_rate=#{refresh_rate} block=#{block}"
+    return Board.new(name,
+                     http_port: http_port, refresh_rate: refresh_rate,
+                     &block)
   end
 
 end

data/lib/HDLRuby/v2hdr.rb

@@ -0,0 +1,39 @@
+require "HDLRuby/verilog_hruby.rb"
+
+parser = VerilogTools::Parser.new
+
+ast = nil
+
+HELP = "Usage: v2hdr <input verilog file name> <output HDLRuby file name>" 
+
+if  ARGV[0] == "--help" then
+  puts HELP
+  exit
+end
+
+unless ARGV.size == 2 then
+  puts HELP
+  exit(1)
+end
+
+if ARGV[0] == ARGV[1] then
+  puts "Error: input and output files are identical."
+  exit(1)
+end
+
+begin
+  ast = parser.run(filename: ARGV[0], compress: true)
+rescue => error
+  puts error
+  exit(1)
+end
+
+hdlruby = ""
+begin
+  hdlruby = ast.to_HDLRuby
+rescue => error
+  puts error
+  exit(1)
+end
+
+File.open(ARGV[1],"w") { |f| f.write(hdlruby) }