HDLRuby 2.3.4 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9bca5842e518422f5e7b7edb864a8eae5955df19238cd9582a776d4ef6c7a1e
-  data.tar.gz: 6c094ebf5d69c8dbf57ddd800eca16aca88b4bc324db11eecac3f15569b633e3
+  metadata.gz: 65ef28718e6de9e9d1358073d2d7ae8bd914a3f942b48d6cd45c8f28f545a906
+  data.tar.gz: 0d469d886d79f65ebfc69a4c4f95d2d8f50c0ada6f4fdbf0349d3c9650fa4581
 SHA512:
-  metadata.gz: f01e2f703bcade0db355c42e78267205ca3662c8b30589c5676eab6acaf334fac2a86205b600122e50f11eef3e6a17182dacb59b9a7821c3fa9d7aed90ebd6b7
-  data.tar.gz: 5c3b80eddb70a3f25f2941bc26c8e95a8f3a30f5020cb17d6a4a199678aacaab4ce0c5c4ffcd347c23b53bd86fb15d58392818673e57ca3d108aec0c5b062ed0
+  metadata.gz: 4d458fe640fd29e1e31470b1f395333c3fd344703903c0c7d126e780d9e6f93c419f18a4e4cbaadc91461d19ed0087388a249fe3ccd87b2ed29d731733ecbc5b
+  data.tar.gz: 1ff098b2ca9bff7758bff7a5bb5e20df7272f53f103944037f9575b55444e6179781129e5d87e301a4e29b885bee5cc82794918ad85ac8236894603759d66212

data/README.md

@@ -50,6 +50,7 @@ Where:
 | `-s, --syntax`    | Output the Ruby syntax tree                          |
 | `-C, --clang`     | Output the C code of the simulator                   |
 | `-S, --sim`       | Output the executable simulator and execute it       |
+| `--vcd`           | Make the simulator generate a vcd file               |
 | `-d, --directory` | Specify the base directory for loading the HDLRuby files |
 | `-D, --debug`     | Set the HDLRuby debug mode |
 | `-t, --top system`| Specify the top system describing the circuit to compile |

data/lib/HDLRuby/hdr_samples/with_fixpoint.rb

@@ -9,6 +9,8 @@ system :fix_test do
 
     # Declare three 4-bit integer part 4-bit fractional part
     bit[3..0,3..0].inner :x,:y,:z
+    # Declare three 8-bit integer part 8-bit fractional part
+    signed[3..0,3..0].inner :a,:b,:c,:d
 
     # Performs calculation between then
     timed do
@@ -22,5 +24,12 @@ system :fix_test do
         !10.ns
         z <= z / x
         !10.ns
+        a <= _00010000
+        b <= _00001111
+        !10.ns
+        c <= a * b
+        d <= 0
+        !10.ns
+        d <= d + c 
     end
 end

data/lib/HDLRuby/hdr_samples/with_linear.rb

@@ -22,9 +22,6 @@ 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).input :readL0
     # memL1.branch(:rinc).input :readL1
     # memR.branch(:rinc).input :readR
@@ -35,9 +32,9 @@ system :testmat do
 
     # Accumulators memory.
     mem_file([8],2,clk,rst,rinc: :rst).(:memAcc)
-    # # memAcc.branch(:anum).inner :accs
-    memAcc.branch(:anum).inout :accs
-    accs_out = [accs.wrap(0), accs.wrap(1)]
+    # memAcc.branch(:anum).inout :accs
+    # accs_out = [accs.wrap(0), accs.wrap(1)]
+    accs_out = [memAcc.branch(:anum).wrap(0), memAcc.branch(:anum).wrap(1)]
 
     # Layer 0 ack.
     inner :ack0
@@ -52,8 +49,6 @@ 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).input :readT
     memF.branch(:anum).output :writeF
     regRs = [ readT.wrap(0), readT.wrap(1) ]
@@ -72,8 +67,6 @@ system :testmat do
     # Input memories.
     mem_dual([8],2,clk,rst, rinc: :rst,winc: :rst).(:mem2L0)
     # Access ports.
-    # # mem2L0.branch(:rinc).inner :read2L0
-    # # memF.branch(:rinc).inner :readF
     # mem2L0.branch(:rinc).input :read2L0
     # memF.branch(:rinc).input :readF
 
@@ -93,11 +86,6 @@ system :testmat do
 
 
     # 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).output :writeL0
     # memL1.branch(:winc).output :writeL1
     # memR.branch(:winc).output :writeR

data/lib/HDLRuby/hdr_samples/with_multi_channels.rb

@@ -0,0 +1,290 @@
+require "std/channel.rb"
+
+include HDLRuby::High::Std
+
+# Channel describing a buffered queue storing data of +typ+ type of +depth+,
+# synchronized through clk and reset on +rst+.
+channel(:queue) do |typ,depth,clk,rst|
+    # The inner buffer of the queue.
+    typ[-depth].inner :buffer
+    # The read and write pointers.
+    [depth.width].inner :rptr, :wptr
+    # The read and write command signals.
+    inner :rcmd, :wcmd
+    # The read and write ack signals.
+    inner :rack, :wack
+    # The ack check deactivator (for synchron accesses).
+    inner :hrack, :hwack
+    # The read/write data registers.
+    typ.inner :rdata, :wdata
+
+    # The process handling the decoupled access to the buffer.
+    par(clk.posedge) do
+        # rack <= 0
+        # wack <= 0
+        hif (~rcmd) { rack <= 0 }
+        hif (~wcmd) { wack <= 0 }
+        hif(rst) { rptr <= 0; wptr <= 0 }
+        hif(rcmd & (hrack|~rack) & (rptr != wptr)) do
+            rptr <= (rptr + 1) % depth
+            rack <= 1
+        end
+        hif(wcmd & (hwack|~wack) & (((wptr+1) % depth) != rptr)) do
+            buffer[wptr] <= wdata
+            # buffer[1] <= wdata
+            wptr <= (wptr + 1) % depth
+            wack <= 1
+        end
+    end
+    par { rdata <= buffer[rptr] }
+
+    reader_output :rcmd, :rptr, :hrack
+    reader_input :rdata, :rack
+
+    # The read primitive.
+    reader do |blk,target|
+        if (cur_behavior.on_event?(clk.posedge,clk.negedge)) then
+            # Same clk event, synchrone case: perform a direct access.
+            # Now perform the access.
+            top_block.unshift do
+                rcmd <= 0
+                hrack <= 1
+            end
+            seq do
+                rptr <= (rptr + 1) % depth
+                target <= rdata
+                blk.call if blk
+            end
+        else
+            # Different clk event, perform a decoupled access.
+            top_block.unshift do
+                rcmd <= 0
+                hrack <= 0
+            end
+            seq do
+                hif(rack) do
+                    blk.call if blk
+                end
+                helse do
+                    rcmd <= 1 
+                    target <= rdata
+                end
+            end
+        end
+    end
+
+    writer_output :wcmd, :wdata, :hwack
+    writer_input :wack
+
+    # The write primitive.
+    writer do |blk,target|
+        if (cur_behavior.on_event?(clk.negedge,clk.posedge)) then
+            # Same clk event, synchrone case: perform a direct access.
+            top_block.unshift do
+                wcmd <= 0
+                hwack <= 1
+            end
+            wcmd <= 1
+            wdata <= target
+            blk.call if blk
+        else
+            # Different clk event, asynchrone case: perform a decoupled access.
+            top_block.unshift do
+                wcmd <= 0
+                hwack <= 0
+            end
+            seq do
+                hif(wack) do
+                    blk.call if blk
+                end
+                helse { wcmd <= 1 }
+                wdata <= target
+            end
+        end
+    end
+end
+
+
+# Channel describing a register of +typ+ type.
+channel(:register) do |typ|
+    # The register.
+    typ.inner :buffer
+
+    reader_input :buffer
+
+    # The read primitive.
+    reader do |blk,target|
+        target <= buffer
+        blk.call if blk
+    end
+
+    writer_output :buffer
+
+    # The read primitive.
+    writer do |blk,target|
+        buffer <= target
+        blk.call if blk
+    end
+end
+
+
+
+# Channel describing a handshake for transmitting data of +typ+ type, reset
+# by +rst+
+channel(:handshake) do |typ|
+    # The data signal.
+    typ.inner :data
+    # The request and acknowledge.
+    typ.inner :req, :ack
+
+    reader_input :ack, :data
+    reader_output :req
+
+    # The read primitive.
+    reader do |blk,target|
+        top_block.unshift do
+            req <= 0
+        end
+        hif(ack == 0) do
+            req <= 1
+        end
+        helsif(req) do
+            target <= data
+            req <= 0
+            blk.call if blk
+        end
+    end
+
+    writer_input :req
+    writer_output :ack, :data
+
+    # The read primitive.
+    writer do |blk,target|
+        top_block.unshift do
+            ack <= 0
+        end
+        hif(req) do
+            hif(~ack) do
+                data <= target
+                blk.call if blk
+            end
+            ack <= 1
+        end
+    end
+end
+
+
+$mode = :prodcons
+# $mode = :sync
+# $mode = :nsync
+# $mode = :async
+# $channel = :register
+# $channel = :handshake
+$channel = :queue
+
+# Testing the queue channel.
+system :test_queue do
+    inner :clk, :rst, :clk2, :clk3
+    [8].inner :idata, :odata
+    [4].inner :counter
+
+    if $channel == :register then
+        register(bit[8]).(:my_ch)
+    elsif $channel == :handshake then
+        handshake(bit[8],rst).(:my_ch)
+    elsif $channel == :queue then
+        queue(bit[8],5,clk,rst).(:my_ch)
+    end
+
+    ev = $mode == :sync ? clk.posedge : 
+         $mode == :nsync ? clk.negedge : clk2.posedge
+
+    if $mode != :prodcons then
+        # Sync/Neg sync and async tests mode
+        par(ev) do
+            hif(rst) do
+                counter <= 0
+                idata <= 0
+                odata <= 0
+            end
+            helse do
+                hif (counter < 4) do
+                    my_ch.write(idata) do
+                        idata <= idata + 1
+                        counter <= counter + 1
+                    end
+                end
+                helsif ((counter > 10) & (counter < 15)) do
+                    my_ch.read(odata) do
+                        idata <= idata - odata
+                        counter <= counter + 1
+                    end
+                end
+                helse do
+                    counter <= counter + 1
+                end
+            end
+        end
+    else
+        # Producter/consumer mode
+        # Producer
+        par(clk2.posedge) do
+            hif(rst) do
+                idata <= 0
+            end
+            helse do
+                my_ch.write(idata) do
+                    idata <= idata + 1
+                end
+            end
+        end
+        # Consumer
+        par(clk3.posedge) do
+            hif(rst) do
+                counter <= 0
+            end
+            helse do
+                my_ch.read(odata) do
+                    counter <= counter + 1
+                end
+            end
+        end
+    end
+
+    timed do
+        clk <= 0
+        clk2 <= 0
+        clk3 <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !3.ns
+        clk2 <= 1
+        !1.ns
+        clk3 <= 1
+        !6.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !3.ns
+        clk2 <= 0
+        !1.ns
+        clk3 <= 1
+        !6.ns
+        64.times do
+            clk <= 1
+            !10.ns
+            clk <= 0
+            !3.ns
+            clk2 <= ~clk2
+            !1.ns
+            hif (clk2 == 0) { clk3 <= ~ clk3 }
+            !6.ns
+        end
+    end
+end
+

data/lib/HDLRuby/hdrcc.rb

@@ -269,6 +269,9 @@ $optparse = OptionParser.new do |opts|
         $options[:multiple] = v
         $options[:sim] = v
     end
+    opts.on("--vcd", "The simulator will generate a vcd file") do |v|
+        $options[:vcd] = v
+    end
     opts.on("-v", "--verilog","Output in Verlog HDL format") do |v|
         $options[:verilog] = v
         $options[:multiple] = v
@@ -515,9 +518,15 @@ elsif $options[:clang] then
         # Generate the code for it.
         $main = File.open($name,"w")
 
+        # Select the vizualizer depending on the options.
+        init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
+                                           "init_default_visualizer"
+
         # Generate the code of the main function.
         # HDLRuby start code
-        $main << HDLRuby::Low::Low2C.main($top_system,
+        $main << HDLRuby::Low::Low2C.main("hruby_simulator",
+                                         init_visualizer,
+                                         $top_system,
                                          $top_system.each_systemT_deep.to_a.reverse,$hnames)
         $main.close
 

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
@@ -2788,6 +2791,14 @@ module HDLRuby::High
             return RefObject.new(@base,@object)
         end
 
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(RefObject)
+            return false unless @base.eql?(obj.base)
+            return false unless @object.eql?(obj.object)
+            return true
+        end
+
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
             # return HDLRuby::Low::RefName.new(@base.to_ref.to_low,@object.name)