HDLRuby 2.3.0 → 2.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08a1cfdc289eddf8a849b47ba65bf9fa0516ce40119a0ee2d498f535a5132af7'
-  data.tar.gz: 81f0f9897e053b894be99b5ab0c7df634c9b16919d6b0ee7cb272fac039ef44b
+  metadata.gz: 641fb6b2455f562967e1dd6d19ff944ed59e6f1e6a4e692c3dbd236af75ea3b6
+  data.tar.gz: 7238f3492e48352e20d4b1a321d9087d25c32b95900c6542e314d941a7a9ff42
 SHA512:
-  metadata.gz: 8083b7a99ce02118442cd4ed084ea391c9bafc34635810499edf51776ef73338335a9a85afa1a2eac3f8a4a7411bf1de8f27d871af0f025b008e25a0bf44d6d8
-  data.tar.gz: 28009e1a04aae15416c43e900a05a7dbb9cac0db946af08abfb7dfb5cfdc7cc2f9552cbea010ffb8db295e2bc6b329a339eb0d81da4ce1efc35b222a0b4b195e
+  metadata.gz: 15d0cfd9c1ad51076854eb39bce2b2dceee053b242350b7c1745d727e69bed0ced9d38f717252fb2a4bd971de5c6e3c804536212ccc6ac98936b716f574048e2
+  data.tar.gz: 10b6326d21c30106d922eb23f8c9da3849b56bf3cac0b186e21f1c427ebb664fab128aba7d961b53af6e558d861ed2a75ce7777c9fa54f778bd3d23e2ba697f4

data/README.md

@@ -2815,27 +2815,17 @@ This library provides a unified interface to complex communication protocols thr
 ### Using a channel
 
 A channel is used similarly to a pipe: it has an input where data can be written and an output where data can be read. The ordering of the data and the synchronization depend on the internals of the channel, e.g., a channel can be FIFO or LIFO. The interaction with the channel is done using the following methods:
- 
- * `input <name>`: generate ports in the system for reading from the channel amd associate them to `name`
- * `output <name>`: generate ports in the system for writing to the channel and associate them to `name`
- * `inout <name>`: generate ports in the system for reading and writing to the channel and associate them to `name`
- * `inner <name>`: generates inner signals for accessing directly the channel
-
-__Note__: `input`, `output`, `inout` and `inner` for channels work similarly to the ones of data types for declaring signals. In particular, `input`, `output` and `inout` are to be used in systems that do not include the channel and `inner` is to be used in the system that include the channel.
-
-When the channel ports are declared, they can be accessed using the following methods depending on whether they are writing or reading ports:
 
  * `write(<args>) <block>`: write to the channel and execute `block` when `write` completes. `args` is a list of arguments required for performing the write that depend on the channel.
  * `read(<args>) <block>`: read the channel and execute `block` when the read completes. `args` is a list of arguments required for performing the write that depend on the channel.
 
+
 For example, a system sending successive 8-bit values through a channel can be described as follows:
 
 ```ruby
 system :producer8 do |channel|
     # Inputs of the producer: clock and reset.
     input :clk, :rst
-    # Instantiate the channel ports
-    channel.output :chi
     # Inner 8-bit counter for generating values.
     [8].inner :counter
 
@@ -2843,7 +2833,7 @@ system :producer8 do |channel|
     par(clk.posedge) do
         hif(rst) { counter <= 0 }
         helse do
-            chi.write(counter) { counter <= counter + 1 }
+            channel.write(counter) { counter <= counter + 1 }
         end
     end
 end
@@ -2851,6 +2841,22 @@ end
 
 __Note__: In the code above, the channel is passed as generic argument of the system.
 
+The access points to a channel can also be handled individually by declaring ports using the following methods:
+ 
+ * `input <name>`: declares a port for reading from the channel and associate them to `name` if any
+ * `output <name>`: declares a port for writing to the channel and associate them to `name` if any
+ * `inout <name>`: declares a port for reading and writing to the channel and associate them to `name` if any
+
+Such port can then be accessed using the same `read` and `write` method of a channel, the difference being that they can also be configured for new access procedure using the `wrap` method:
+
+ * `wrap(<args>) <code>`: creates a new port whose read or write procedure has the elements of `<args>` and the ones produced by `<code>` assign to the arguments of the read or write procedure.
+
+For example, assuming `mem` is a channel whose read and write access have as argument the target address and data signals, the following code creates a port for always accessing at address 0:
+
+```ruby
+  addr0 = channel.input.wrap(0) 
+```
+
 ### Channel branches
 
 Some channel may include several branches, they are accessed by name using the following method:
@@ -2894,7 +2900,7 @@ Where `name` is the name of the channel and `block` is a procedure block describ
  The first argument of the block must be the following:
    - `blk`: the block to execute when the write completes.
  Other arguments can be freely defined, and will be required by the `write` command.
- * `brancher(name) <block>`: defines branch named +name+ described in `block`. The content of block can be any content valid for a channel, with the additional possiblity to access the internals of the upper channel.
+ * `brancher(name) <block>`: defines branch named +name+ described in `block`. The content of block can be any content valid for a channel, with the additional possibility to access the internals of the upper channel.
 
 For example, a channel implemented by a simple register of generic type `typ`, that can be set to 0 using the `reset` command can be described as follows:
 

data/lib/HDLRuby/hdr_samples/with_channel.rb

@@ -63,12 +63,13 @@ end
 
 
 # A system writing indefinitely to a channel.
+# Checking usage of channel without declaring a port.
 system :producer8 do |channel|
-    # puts "channel=#{channel}"
+    # puts "channel=#{channel}, channel methods=#{channel.methods}"
     # Inputs of the producer: clock and reset.
     input :clk, :rst
-    # Instantiate the channel ports
-    channel.output :ch
+    # # Instantiate the channel ports
+    # channel.output :ch
     # Inner 8-bit counter for generating values.
     [8].inner :counter
 
@@ -76,7 +77,8 @@ system :producer8 do |channel|
     par(clk.posedge) do
         hif(rst) { counter <= 0 }
         helse do
-            ch.write(counter) { counter <= counter + 1 }
+            # ch.write(counter) { counter <= counter + 1 }
+            channel.write(counter) { counter <= counter + 1 }
         end
     end
 end
@@ -96,20 +98,59 @@ system :consummer8 do |channel|
     end
 end
 
+# A system reading indefinitely from a channel.
+# Version without port declaration.
+system :consummer16 do |channel|
+    # Input of the consummer: a clock is enough.
+    input :clk
+    # # Instantiate the channel ports
+    # channel.input :ch
+    # Inner buffer for storing the cunsummed value.
+    [16].inner :buf
+
+    # The value consumption process
+    par(clk.posedge) do
+        # ch.read(buf)
+        channel.read(buf)
+    end
+end
+
 
 # A system testing the handshaker.
 system :hs_test do
     input :clk,:rst
 
-    # Declares the handshaker
-    handshaker([8]).(:hs)
+    # Declares two handshakers
+    handshaker([8]).(:hs0)
+    handshaker([16]).(:hs1)
 
     # # Sets the reset.
     # par(rst.posedge) { hs.reset }
+    
+    # For the first handshake
 
     # Instantiate the producer.
-    producer8(hs).(:producerI).(clk,rst)
+    producer8(hs0).(:producerI).(clk,rst)
 
     # Instantiate the consummer.
-    consummer8(hs).(:consummerI).(clk)
+    consummer8(hs0).(:consummerI).(clk)
+
+    # For the second handshaker
+    
+    # Instantiatethe consummer.
+    consummer16(hs1).(:consummer2I).(clk)
+
+    # Produce from within.
+    [16].inner :counter
+
+    # hs1.output :port
+
+    par(clk.posedge) do
+       hif(rst) { counter <= 0 }
+        helse do
+            # port.write(counter) { counter <= counter + 1 }
+            hs1.write(counter) { counter <= counter + 1 }
+        end
+    end
+
 end

data/lib/HDLRuby/hdr_samples/with_linear.rb

@@ -22,23 +22,29 @@ system :testmat do
     mem_dual([8],256,clk,rst, rinc: :rst,winc: :rst).(:memL1)
     mem_dual([8],256,clk,rst, rinc: :rst,winc: :rst).(:memR)
     # Access ports.
-    memL0.branch(:rinc).inner :readL0
-    memL1.branch(:rinc).inner :readL1
-    memR.branch(:rinc).inner :readR
+    # # memL0.branch(:rinc).inner :readL0
+    # # memL1.branch(:rinc).inner :readL1
+    # # memR.branch(:rinc).inner :readR
+    # memL0.branch(:rinc).input :readL0
+    # memL1.branch(:rinc).input :readL1
+    # memR.branch(:rinc).input :readR
 
     # Prepares the left and acc arrays.
-    lefts = [readL0, readL1]
+    # lefts = [readL0, readL1]
+    lefts = [memL0.branch(:rinc), memL1.branch(:rinc)]
 
     # Accumulators memory.
     mem_file([8],2,clk,rst,rinc: :rst).(:memAcc)
-    memAcc.branch(:anum).inner :accs
+    # # memAcc.branch(:anum).inner :accs
+    memAcc.branch(:anum).inout :accs
     accs_out = [accs.wrap(0), accs.wrap(1)]
 
     # Layer 0 ack.
     inner :ack0
     
     # Instantiate the matrix product.
-    mac_n1([8],clk,req,ack0,lefts,readR,accs_out)
+    # mac_n1([8],clk,req,ack0,lefts,readR,accs_out)
+    mac_n1([8],clk,req,ack0,lefts,memR.branch(:rinc),accs_out)
 
     # Translation.
     # Translation memory.
@@ -46,10 +52,12 @@ system :testmat do
     # Tarnslation result
     mem_file([8],2,clk,rst,rinc: :rst).(:memF)
     # Access ports.
-    memT.branch(:anum).inner :readT
-    memF.branch(:anum).inner :writeF
+    # # memT.branch(:anum).inner :readT
+    # # memF.branch(:anum).inner :writeF
+    memT.branch(:anum).input :readT
+    memF.branch(:anum).output :writeF
     regRs = [ readT.wrap(0), readT.wrap(1) ]
-    regLs = [ accs.wrap(0), accs.wrap(1) ]
+    regLs = accs_out
     regs =  [ writeF.wrap(0), writeF.wrap(1) ]
 
     # Translater ack.
@@ -64,9 +72,10 @@ system :testmat do
     # Input memories.
     mem_dual([8],2,clk,rst, rinc: :rst,winc: :rst).(:mem2L0)
     # Access ports.
-    mem2L0.branch(:rinc).inner :read2L0
-    # memAcc.branch(:rinc).inner :accsR
-    memF.branch(:rinc).inner :readF
+    # # mem2L0.branch(:rinc).inner :read2L0
+    # # memF.branch(:rinc).inner :readF
+    # mem2L0.branch(:rinc).input :read2L0
+    # memF.branch(:rinc).input :readF
 
     # Second layer ack.
     inner :ack1
@@ -76,29 +85,40 @@ system :testmat do
 
     sub do
         # Instantiate the second matrix product.
-        # mac([8],clk,req,read2L0,accsR,res)
-        mac([8],clk,ackT,ack1,read2L0,readF,channel_port(res))
+        # mac([8],clk,ackT,ack1,read2L0,readF,channel_port(res))
+        mac([8],clk,ackT,ack1,mem2L0.branch(:rinc),memF.branch(:rinc),
+            channel_port(res))
     end
 
 
 
     # The memory initializer.
-    memL0.branch(:winc).inner :writeL0
-    memL1.branch(:winc).inner :writeL1
-    memR.branch(:winc).inner :writeR
-    memT.branch(:winc).inner :writeT
-    mem2L0.branch(:winc).inner :write2L0
+    # # memL0.branch(:winc).inner :writeL0
+    # # memL1.branch(:winc).inner :writeL1
+    # # memR.branch(:winc).inner :writeR
+    # # memT.branch(:winc).inner :writeT
+    # # mem2L0.branch(:winc).inner :write2L0
+    # memL0.branch(:winc).output :writeL0
+    # memL1.branch(:winc).output :writeL1
+    # memR.branch(:winc).output :writeR
+    # mem2L0.branch(:winc).output :write2L0
+    # memT.branch(:winc).output :writeT
     inner :fill, :fill2
     [8].inner :val
     par(clk.posedge) do
         hif(fill) do
-            writeL0.write(val)
-            writeL1.write(val+1)
-            writeR.write(val+1)
+            # writeL0.write(val)
+            # writeL1.write(val+1)
+            # writeR.write(val+1)
+            memL0.branch(:winc).write(val)
+            memL1.branch(:winc).write(val+1)
+            memR.branch(:winc).write(val+1)
         end
         hif(fill2) do
-            write2L0.write(val+2)
-            writeT.write(val+2)
+            # write2L0.write(val+2)
+            # writeT.write(val+2)
+            mem2L0.branch(:winc).write(val+2)
+            memT.branch(:winc).write(val+2)
         end
     end
 

data/lib/HDLRuby/hdrcc.rb

@@ -113,12 +113,9 @@ module HDLRuby
                 return
             end
             # Get its required files.
-            requires = @checks[-1].get_all_requires
+            requires = @checks[-1].get_all_requires +
+                       @checks[-1].get_all_require_relatives
             requires.each do |file|
-                # if file != "HDLRuby" &&
-                #         !@std_files.find { |std| std.include?(file) } then
-                #     read_all(file)
-                # end
                 read_all(file)
             end
             @requires += requires
@@ -244,7 +241,7 @@ include HDLRuby
 # Process the command line options
 $options = {}
 $optparse = OptionParser.new do |opts|
-    opts.banner = "Usage: hdrcc.rb [options] <input file> [<output file>]"
+    opts.banner = "Usage: hdrcc.rb [options] <input file> [<output directory or file>]"
 
     opts.separator ""
     opts.separator "Where:"
@@ -326,18 +323,17 @@ $optparse = OptionParser.new do |opts|
     opts.separator ""
     opts.separator "Notice:"
     opts.separator "* If no output option is given, simply checks the input file"
-    opts.separator "* If no output file is given, the result is given through the standard output."
     opts.separator "* If no top system is given, it will be automatically searched in the input file."
     opts.separator ""
     opts.separator "Examples:"
     opts.separator "* Compile system named `adder` from `adder.rb` input file and generate `adder.yaml` low-level YAML description:"
     opts.separator "   hdrcc.rb --yaml --top adder adder.rb adder.yaml"
-    opts.separator "* Compile `adder.rb` input file and generate `adder.vhd` low-level VHDL description:"
-    opts.separator "   hdrcc.rb --vhdl adder.rb adder.vhd"
+    opts.separator "* Compile `adder.rb` input file and generate low-level VHDL description files in `adder_vhd` directory:"
+    opts.separator "   hdrcc.rb --vhdl adder.rb adder_vhd"
     opts.separator "* Check the validity of `adder.rb` input file:"
     opts.separator "   hdrcc.rb adder.rb"
-    opts.separator "* Compile system `adder` whose bit width is generic from `adder_gen.rb` input file to a 16-bit circuit whose low-level Verilog HDL description is dumped to the standard output:"
-    opts.separator "   hdrcc -v -t adder --param 16 adder_gen.rb"
+    opts.separator "* Compile system `adder` whose bit width is generic from `adder_gen.rb` input file to a 16-bit circuit whose low-level Verilog HDL description files are put in `adder_gen_v` directory:"
+    opts.separator "   hdrcc -v -t adder --param 16 adder_gen.rb adder_gen_v"
     opts.separator "* Compile system `multer` with inputs and output bit width is generic from `multer_gen.rb` input file to a 16x16->32 bit cicruit whose low-level YAML description is saved to output file `multer_gen.yaml`"
     opts.separator "hdrcc -y -t multer -p 16,16,32 multer_gen.rb multer_gen.yaml"
 

data/lib/HDLRuby/hruby_check.rb

@@ -45,11 +45,20 @@ module HDLRuby
                    (code[1][1] == "require")
         end
 
+        # Tells if +code+ is require_relative description.
+        def is_require_relative?(code)
+            # return code[0] && (code[0][0] == :command) &&
+            #        (code[0][1][1] == "require_relative")
+            return code && (code[0] == :command) &&
+                   (code[1][1] == "require_relative")
+        end
+
         # Gets the required file from +code+.
         def get_require(code)
             # return (code[0][2][1][0][1][1][1])
             return (code[2][1][0][1][1][1])
         end
+        alias_method :get_require_relative, :get_require
 
         # Gets all the required files of  +code+.
         def get_all_requires(code = @code)
@@ -66,6 +75,21 @@ module HDLRuby
             end
         end
 
+        # Gets all the require_relative files of  +code+.
+        def get_all_require_relatives(code = @code)
+            if code.is_a?(Array) then
+                require_relatives = (code.select { |sub| is_require_relative?(sub) }).map! do |sub|
+                    get_require_relative(sub)
+                end
+                code.each do |sub|
+                    require_relatives += get_all_require_relatives(sub)
+                end
+                return require_relatives
+            else
+                return []
+            end
+        end
+
         # Tells if +code+ is a system description.
         def is_system?(code)
             return code.is_a?(Array) && (code[0] == :command) &&
@@ -77,7 +101,7 @@ module HDLRuby
             return code[2][1][0][1][1][1]
         end
 
-        # Gets all the required files of  +code+.
+        # Gets all the systems of  +code+.
         def get_all_systems(code = @code)
             return [] unless code.is_a?(Array)
             return code.reduce([]) {|ar,sub| ar + get_all_systems(sub) } +

data/lib/HDLRuby/hruby_high.rb

@@ -1263,7 +1263,8 @@ module HDLRuby::High
         # Converts the scope to HDLRuby::Low.
         def to_low()
             # Create the resulting low scope.
-            scopeLow = HDLRuby::Low::Scope.new()
+            # scopeLow = HDLRuby::Low::Scope.new()
+            scopeLow = HDLRuby::Low::Scope.new(self.name)
             # Push the private namespace for the low generation.
             High.space_push(@namespace)
             # Pushes on the name stack for converting the internals of
@@ -1858,7 +1859,8 @@ module HDLRuby::High
     def function(name, &ruby_block)
         if HDLRuby::High.in_system? then
             define_singleton_method(name.to_sym) do |*args,&other_block|
-                sub do
+                # sub do
+                sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
                     # ruby_block.call(*args)
@@ -1866,7 +1868,8 @@ module HDLRuby::High
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
-                sub do
+                # sub do
+                sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
                 end

data/lib/HDLRuby/hruby_low.rb

@@ -1123,6 +1123,10 @@ module HDLRuby::Low
             return self.parent.is_a?(SystemT) ? self : self.parent.top_scope
         end
 
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
 
     end
 
@@ -2132,6 +2136,11 @@ module HDLRuby::Low
         def top_scope
             return parent.top_scope
         end
+
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
     end
 
 
@@ -2619,6 +2628,11 @@ module HDLRuby::Low
         def top_scope
             return self.scope.top_scope
         end
+
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
     end
 
 
@@ -3717,6 +3731,11 @@ module HDLRuby::Low
         def top_scope
             return self.parent.is_a?(Scope) ? self.parent : self.parent.top_scope
         end
+
+        # Gets the parent system, i.e., the parent of the top scope.
+        def parent_system
+            return self.top_scope.parent
+        end
     end