HDLRuby 2.2.15 → 2.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cac7290729b07ecdbbd73528b0807e601c8ba0f04e6d2476bbd075d5c4dbb648
-  data.tar.gz: b2d244a59dcff8b363e6d1cdd66ff22cca81ffa24b666b97eb46b7b142047787
+  metadata.gz: f752aaab90bc0318eadca1d00745607d477bf742a568de5e0c17a64e399327f1
+  data.tar.gz: 0d3dc8821a51afa9cbae15a60611beb3b3b3671add3728a5843ad51f42013534
 SHA512:
-  metadata.gz: '093bfbd1c000b0d7a4e039d51a8a27da09483ac1b61f0d19d78a3999d9231abe6df0611b720e4d47409b8c9769a31e7f3770f8bd6fa0246b8854ea15f56d1648'
-  data.tar.gz: fb97205d4d7f542efb02e4951c696783c8d3f99b7f6def0f3a2cfbae27c7ff3d5e72459ba8aa899c6e93241d92302958177be0ee47472f329272f0c5fa2afd09
+  metadata.gz: 0116cacdf784719837ede586042b07903ad54540b797549e7731c0a35e7fb9be9ffad241d237c454d6d47dcf94346004a73913610e2dfecb1e3b58b4984ea75c
+  data.tar.gz: 233ff279a0c056998ae3b88017d08f2a69986919b4b148058c30e3da8573d96792e103b938a50654b96b75ce17a46ec1d45ec1069e27f56847538e095d4fb00b

data/lib/HDLRuby/hdr_samples/linear_test.rb

@@ -102,6 +102,22 @@ system :linear_test do
     mac_n1([8],clk.posedge,ack[3],ack[4], mem_macn1_left_inPs,
           channel_port(5), mem_macn1_outPs)
 
+    # Circuit for testing the linearun with mac.
+    # Input memories
+    mem_dual([8],8,clk,rst, rinc: :rst, winc: :rst).(:mem_macrn_left_in)
+    mem_dual([8],8,clk,rst, rinc: :rst, winc: :rst).(:mem_macrn_right_in)
+    # Access ports.
+    mem_macrn_left_in.branch(:rinc).inner :mem_macrn_left_in_readP
+    mem_macrn_right_in.branch(:rinc).inner :mem_macrn_right_in_readP
+    # Output signal.
+    [8].inner :accr
+
+    # Build the linearun mac.
+    linearun(8,clk.posedge,ack[4],ack[5]) do |ev,req,ack|
+        mac([8],ev,req,ack,mem_macrn_left_in_readP,mem_macrn_right_in_readP, 
+            channel_port(accr))
+    end
+
 
     # The memory initializer.
     # Writing ports
@@ -111,6 +127,8 @@ system :linear_test do
     mem_muln_left_in.branch(:winc).inner :mem_muln_left_in_writeP
     mem_muln_right_in.branch(:winc).inner :mem_muln_right_in_writeP
     mem_macn1_left_in.branch(:winc).inner :mem_macn1_left_in_writeP
+    mem_macrn_left_in.branch(:winc).inner :mem_macrn_left_in_writeP
+    mem_macrn_right_in.branch(:winc).inner :mem_macrn_right_in_writeP
     # Filling index
     [8].inner :idx
     # Filling counter
@@ -127,7 +145,7 @@ system :linear_test do
         helse do
             # Step index processing.
             hif(cnt == 7) do
-                hif(idx < 6) { idx <= idx + 1 }
+                hif(idx < 8) { idx <= idx + 1 }
             end
             # Memory filling steps.
             hcase(idx)
@@ -161,6 +179,16 @@ system :linear_test do
                     cnt <= cnt + 1; val <= val + 1
                 end
             end
+            hwhen(6) do
+                mem_macrn_left_in_writeP.write(val-48) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
+            hwhen(7) do
+                mem_macrn_right_in_writeP.write(val-48) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
             # Computation steps.
             helse do
                 hif(start) do
@@ -197,7 +225,7 @@ system :linear_test do
         start <= 1
         !10.ns
         # Run
-        64.times do
+        128.times do
             clk <= 1
             !10.ns
             clk <= 0

data/lib/HDLRuby/hruby_high.rb

@@ -1851,16 +1851,18 @@ module HDLRuby::High
     # NOTE: a function is a short-cut for a method that creates a scope.
     def function(name, &ruby_block)
         if HDLRuby::High.in_system? then
-            define_singleton_method(name.to_sym) do |*args|
+            define_singleton_method(name.to_sym) do |*args,&other_block|
                 sub do
-                    HDLRuby::High.top_user.instance_exec(*args,&ruby_block)
+                    HDLRuby::High.top_user.instance_exec(*args,*other_block,
+                                                         &ruby_block)
                     # ruby_block.call(*args)
                 end
             end
         else
-            define_method(name.to_sym) do |*args|
+            define_method(name.to_sym) do |*args,&other_block|
                 sub do
-                    HDLRuby::High.top_user.instance_exec(*args,&ruby_block)
+                    HDLRuby::High.top_user.instance_exec(*args,*other_block,
+                                                         &ruby_block)
                 end
             end
         end

data/lib/HDLRuby/hruby_low2c.rb

@@ -1961,6 +1961,7 @@ module HDLRuby::Low
         # Generates the C text for reference as left value to a signal.
         # +level+ is the hierarchical level of the object.
         def to_c_signal(level = 0)
+            # puts "to_c_signal with self=#{self.name}, resolve=#{self.resolve}"
             return "#{self.resolve.to_c_signal(level+1)}"
         end
     end

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -39,6 +39,7 @@ module HDLRuby::Low
         ## Find an inner object by +name+.
         #  NOTE: return nil if not found.
         def get_by_name(name)
+            # puts "getbyname for name=#{name} with self=#{self}"
             # Ensure the name is a symbol.
             name = name.to_sym
             # Look in the signals.
@@ -114,7 +115,6 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            # puts "from_systemI? for #{self.name}"
             # Look for the owner from the name hierarchy.
             if self.ref.is_a?(RefName) then
                 # Look in the parent hierachy for the sub reference name.
@@ -151,6 +151,7 @@ module HDLRuby::Low
                 parent = self.parent
                 # puts "parent=#{parent}"
                 while parent
+                    # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
                         found = parent.get_by_name(self.name)
                         return found if found

data/lib/HDLRuby/std/linear.rb

@@ -8,6 +8,51 @@ module HDLRuby::High::Std
     #
     ########################################################################
 
+    # Controller of the linear operator.
+    # - +num+: the number of computation cycles.
+    # - +ev+: event to synchronize the controller on.
+    # - +req+: the request to start the linear computation.
+    # - +ack+: the ack signal that is set to 1 when the computation completes.
+    # - +ruby_block+: the code of the linear computation kernel, it takes
+    #                 as argument +ev+, and its own req and ack signals
+    #                 (resp. +req_ker+ +ack_ker+).
+    function :linearun do |num,ev,req,ack,ruby_block|
+        # Ensure ev is really an event.
+        ev = ev.posedge unless ev.is_a?(Event)
+
+        # Creates the kernel.
+        inner :req_ker, :ack_ker
+
+        HDLRuby::High.top_user.instance_exec(ev,req_ker,ack_ker,&ruby_block)
+
+        # The computation counter.
+        [num.width].inner :count
+        # Run flag
+        inner :run
+        par(ev) do
+            req_ker <= 0
+            ack <= 0
+            count <= 1
+            run <= 0
+            hif(req | run) do
+                run <= 1
+                req_ker <= 1
+                # Is one linear computation completed?
+                hif(ack_ker) do
+                    # Yes.
+                    count <= count + 1
+                end
+                # Is the full computation completed?
+                hif(count == num) do
+                    # Yes.
+                    ack <= 1
+                    run <= 0
+                    req_ker <= 0
+                end
+            end
+        end
+    end
+
 
     # Delcares a vector product by a scalar value.
     #
@@ -111,7 +156,7 @@ module HDLRuby::High::Std
         mul = proc { |x,y| x*y }, add = proc { |x,y| x+y }|
         # Ensure ev is really an event.
         ev = ev.posedge unless ev.is_a?(Event)
-        # Left value and right value.
+        # Left value, right value and computation temp value.
         typ.inner :lv, :rv, :av
         # lv and rv are valid.
         inner :lvok, :rvok
@@ -125,18 +170,21 @@ module HDLRuby::High::Std
                 # Computation request.
                 left.read(lv)  { lvok <= 1 }
                 right.read(rv) { rvok <= 1 }
-                # ( acc <= add.(acc,mul.(lv,rv)) ).hif(lvok & rvok)
-                acc.read(av)
                 hif(lvok & rvok) do
                     ack <= 1
                     run <= 0
-                    acc.write(add.(av,mul.(lv,rv)))
+                    # acc.write(add.(av,mul.(lv,rv)))
+                    seq do
+                        av <= add.(av,mul.(lv,rv))
+                        acc.write(av)
+                    end
                 end
             end
             helse do
                 lvok <= 0
                 rvok <= 0
-                acc.write(0)
+                # acc.write(0)
+                av <= 0
             end
         end
     end
@@ -172,13 +220,15 @@ module HDLRuby::High::Std
                 right.read(rv) { rvok <= 1 }
                 lefts.each_with_index do |left,i|
                     left.read(lvs[i])  { lvoks[i] <= 1 }
-                    # accs.read(i,avs[i])
-                    accs[i].read(avs[i])
+                    # accs[i].read(avs[i])
                     hif(lvoks[i] & rvok) do
                         ack <= 1
                         run <= 0
-                        # accs.write(i,add.(avs[i],mul.(lvs[i],rv)))
-                        accs[i].write(add.(avs[i],mul.(lvs[i],rv)))
+                        # accs[i].write(add.(avs[i],mul.(lvs[i],rv)))
+                        seq do
+                            avs[i] <= add.(avs[i],mul.(lvs[i],rv))
+                            accs[i].write(avs[i])
+                        end
                     end
                 end
             end
@@ -186,12 +236,14 @@ module HDLRuby::High::Std
                 rvok <= 0
                 lefts.each_with_index do |left,i|
                     lvoks[i] <= 0
-                    # accs.write(i,0)
-                    accs[i].write(0)
+                    # accs[i].write(0)
+                    avs[i] <= 0
                 end
             end
         end
     end
 
 
+
+
 end

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.2.15"
+  VERSION = "2.2.16"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.2.15
+  version: 2.2.16
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-29 00:00:00.000000000 Z
+date: 2020-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler