HDLRuby 2.4.19 → 2.4.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98f251acca7748335f7f60586eddb75a2b8efb9773225d3776bdb585b6d05060
-  data.tar.gz: 689f2d3b0c2332e2877c3dcfd273b43c3b7deb44853f21aeffdd2e60d7e1d74c
+  metadata.gz: fd6292fe897c939784b2d10ae3e69e69eec7149be02fbc077b9ae789af840825
+  data.tar.gz: cd3ead86ae5b63976cab3d45db537f60a984ca65b0355dadaa755d1b6cbe0b89
 SHA512:
-  metadata.gz: 3732704b0a83a69ccf1796772c25d70a453adf5b0d4d795d2c9741fdb2e6e9ba5b086348983012a6ff68415de2327e22e7a7eed6bdff647da98e37406410869a
-  data.tar.gz: b01e94018fb612dfae8cbce2076a19829fe44f9301a5f4969d153323981b889c8b9d434ffc4b6f91e27830c312ef1108decc28c275be7a65997d74123488480d
+  metadata.gz: 7d33e055f706df8d06d6bd7578002a399c695f5a6705fce523a033a8d9954a74b44e1a337ac851a49a68a0c8d5a3fe42326a26b5d92003bb7d17dc90f5ed27a8
+  data.tar.gz: 8f49e18b9dbfd2ce0a5676e558c6054258809876f610ec3e35eda8ad4bf18ba9834aa11c6229ceb5e75b42649a353603da854a57b9f72432dc0b6459b1e35d61

data/lib/HDLRuby/hdr_samples/with_connector.rb

@@ -130,6 +130,7 @@ system :with_connectors do
     [4].inner :counter
     [4*4].inner :res
     inner :ack_in, :ack_out
+    inner :dup_req, :dup_ack
 
     # The input queue.
     queue(bit[4],4,clk,rst).(:in_qu)
@@ -143,7 +144,7 @@ system :with_connectors do
     queue(bit[4*4],4,clk,rst).(:out_qu)
 
     # Connect the input queue to the middle queues.
-    duplicator(bit[4],clk.negedge,in_qu,mid_qus)
+    duplicator(bit[4],clk.negedge,in_qu,mid_qus,dup_req,dup_ack)
 
     # Connect the middle queues to the output queue.
     merger([bit[4]]*4,clk.negedge,mid_qus,out_qu)
@@ -221,6 +222,7 @@ system :with_connectors do
     timed do
         clk <= 0
         rst <= 0
+        dup_req <= 0
         !10.ns
         clk <= 1
         !10.ns
@@ -235,6 +237,13 @@ system :with_connectors do
         !10.ns
         clk <= 0
         rst <= 0
+        4.times do
+            !10.ns
+            clk <= 1
+            !10.ns
+            clk <= 0
+        end
+        dup_req <= 1
         16.times do
             !10.ns
             clk <= 1

data/lib/HDLRuby/std/connector.rb

@@ -9,13 +9,28 @@ module HDLRuby::High::Std
     # channel +in_ch+ and connect it to channels +out_chs+ with data of
     # +typ+.
     # The duplication is done according to event +ev+.
-    function :duplicator do |typ, ev, in_ch, out_chs|
+    # The optional req and ack arguments are the signals for controlling the
+    # duplicator using a handshake protocol. If set to nil, the duplicator
+    # runs automatically.
+    function :duplicator do |typ, ev, in_ch, out_chs, req = nil, ack = nil|
         ev = ev.poswedge unless ev.is_a?(Event)
-        inner :in_ack, :in_req
+        inner :in_ack
+        inner :in_req
         out_acks = out_chs.size.times.map { |i| inner(:"out_ack#{i}") }
         typ.inner :data
         par(ev) do
-            in_req <= 1
+            if (ack) then
+                # Output ack mode.
+                ack <= 0
+            end
+            if (req) then
+                # Input request mode.
+                in_req <= 0
+                hif(req) { in_req <= 1 }
+            else
+                # Automatic mode.
+                in_req <= 1
+            end
             out_acks.each { |ack| ack <= 0 }
             out_acks.each do |ack| 
                 hif(ack == 1) { in_req <= 0 }
@@ -30,6 +45,10 @@ module HDLRuby::High::Std
                 end
                 hif (out_acks.reduce(_1) { |sum,ack| ack & sum }) do
                     out_acks.each { |ack| ack <= 0 }
+                    if (ack) then
+                        # Output ack mode.
+                        ack <= 1
+                    end
                 end
             end
         end

data/lib/HDLRuby/std/memory.rb

@@ -1704,6 +1704,127 @@ HDLRuby::High::Std.channel(:mem_bank) do |typ,nbanks,size,clk,rst,br_rsts = {}|
 
 end
 
+
+# Queue memory of +size+ elements of +typ+ typ, syncrhonized on +clk+
+# (positive and negative edges) and reset on +rst+.
+# At each rising edge of +clk+ a read and a write is guaranteed to be
+# completed provided they are triggered.
+#
+# NOTE: this channel does not have any branch.
+HDLRuby::High::Std.channel(:mem_queue) do |typ,size,clk,rst|
+    # The inner buffer of the queue.
+    typ[-size].inner :buffer
+    # The read and write pointers.
+    [size.width].inner :rptr, :wptr
+    # The read and write command signals.
+    inner :rreq, :wreq
+    # The read and write ack signals.
+    inner :rack, :wack
+    # The read/write data registers.
+    typ.inner :rdata, :wdata
+
+    # The flags telling of the channel is synchronized
+    inner :rsync, :wsync
+
+    # The process handling the decoupled access to the buffer.
+    par(clk.posedge) do
+        hif(rst) { rptr <= 0; wptr <= 0 }
+        helse do
+            hif(~rsync) do
+                hif (~rreq) { rack <= 0 }
+                hif(rreq & (~rack) & (rptr != wptr)) do
+                    rdata <= buffer[rptr]
+                    rptr <= (rptr + 1) % depth
+                    rack <= 1
+                end
+            end
+
+            hif(~wsync) do
+                hif (~wreq) { wack <= 0 }
+                hif(wreq & (~wack) & (((wptr+1) % size) != rptr)) do
+                    buffer[wptr] <= wdata
+                    wptr <= (wptr + 1) % size
+                    wack <= 1
+                end
+            end
+        end
+    end
+
+    reader_output :rreq, :rptr, :rsync
+    reader_input :rdata, :rack, :wptr, :buffer
+
+    # 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
+                rsync <= 1
+                rreq <= 0
+            end
+            seq do
+                hif(rptr != wptr) do
+                    # target <= rdata
+                    target <= buffer[rptr]
+                    rptr <= (rptr + 1) % size
+                    blk.call if blk
+                end
+            end
+        else
+            # Different clk event, perform a decoupled access.
+            top_block.unshift do
+                rsync <= 0
+                rreq <= 0
+            end
+            par do
+                hif (~rack) { rreq <= 1 }
+                helsif(rreq) do
+                    rreq <= 0
+                    target <= rdata
+                    blk.call if blk
+                end
+            end
+        end
+    end
+
+    writer_output :wreq, :wdata, :wptr, :wsync, :buffer
+    writer_input :wack, :rptr
+
+    # 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
+                wsync <= 1
+                wreq <= 0
+            end
+            hif(((wptr+1) % size) != rptr) do
+                buffer[wptr] <= target
+                wptr <= (wptr + 1) % size
+                blk.call if blk
+            end
+        else
+            # Different clk event, asynchrone case: perform a decoupled access.
+            top_block.unshift do
+                wsync <= 0
+                wreq <= 0
+            end
+            seq do
+                hif (~wack) do
+                    wreq <= 1
+                    wdata <= target
+                end
+                helsif(wreq) do
+                    wreq <= 0
+                    blk.call if blk
+                end
+            end
+        end
+    end
+end
+
+
+
 # HDLRuby::High::Std.channel(:mem_bank) do |typ,nbanks,size,clk,rst,br_rsts = {}|
 #     # Ensure typ is a type.
 #     typ = typ.to_type

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.4.19"
+  VERSION = "2.4.20"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.4.19
+  version: 2.4.20
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-06 00:00:00.000000000 Z
+date: 2020-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler