HDLRuby 2.2.14 → 2.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6a6e334b6e55bdc8f7947f92f4dd8a9de83fc0f90725bad5bfafedc27a8ca2e
-  data.tar.gz: a6f43c383176d02af9e8491c6b2425b5e1e8ca3c339464842dbf288fbe91dc26
+  metadata.gz: cac7290729b07ecdbbd73528b0807e601c8ba0f04e6d2476bbd075d5c4dbb648
+  data.tar.gz: b2d244a59dcff8b363e6d1cdd66ff22cca81ffa24b666b97eb46b7b142047787
 SHA512:
-  metadata.gz: 50a46ad334407428425912ec7b1fbd745d1de686e8792548524f23d4ca10f6252368b589f5fc77b201b07f1becf86aa7c234c77443b1014caad341c1fa0fa966
-  data.tar.gz: c8defb6937e32d43ddd0c56f49a2a608a8444a8ca0eef10f387fb1fc89597dc13871ce086223e8d1892799d1518d9a5cf915142e500cf4c74937bdfbfff68514
+  metadata.gz: '093bfbd1c000b0d7a4e039d51a8a27da09483ac1b61f0d19d78a3999d9231abe6df0611b720e4d47409b8c9769a31e7f3770f8bd6fa0246b8854ea15f56d1648'
+  data.tar.gz: fb97205d4d7f542efb02e4951c696783c8d3f99b7f6def0f3a2cfbae27c7ff3d5e72459ba8aa899c6e93241d92302958177be0ee47472f329272f0c5fa2afd09

data/lib/HDLRuby/hdr_samples/linear_test.rb

@@ -0,0 +1,207 @@
+require 'std/memory.rb'
+require 'std/linear.rb'
+
+include HDLRuby::High::Std
+
+# Tries for matrix-vector product.
+
+
+
+
+
+# Sample code for testing the linear library.
+
+system :linear_test do
+
+    # Clock and reset.
+    inner :clk,:rst
+
+    # Request and acknoledge signals.
+    inner :req
+    [8].inner :ack
+
+
+    # Circuit for testing the scaling.
+
+    # Input memory
+    mem_file([8],8,clk,rst, rinc: :rst, winc: :rst).(:mem_scale_in)
+    # Output memory
+    mem_file([8],8,clk,rst, winc: :rst).(:mem_scale_out)
+    # Access ports.
+    mem_scale_in.branch(:anum).inner :mem_scale_inP
+    mem_scale_inPs = 8.times.map { |i| mem_scale_inP.wrap(i) }
+    mem_scale_out.branch(:anum).inner :mem_scale_outP
+    mem_scale_outPs = 8.times.map { |i| mem_scale_outP.wrap(i) }
+
+    # Build the scaler.
+    scale([8],clk.posedge,req,ack[0],channel_port(3),
+          mem_scale_inPs,mem_scale_outPs)
+
+
+    # Circuit for testing the parallel addition.
+
+    # Input memories
+    mem_file([8],8,clk,rst, rinc: :rst, winc: :rst).(:mem_addn_left_in)
+    mem_file([8],8,clk,rst, rinc: :rst, winc: :rst).(:mem_addn_right_in)
+    # Output memory
+    mem_file([8],8,clk,rst, winc: :rst).(:mem_addn_out)
+    # Access ports.
+    mem_addn_left_in.branch(:anum).inner :mem_addn_left_inP
+    mem_addn_left_inPs = 8.times.map { |i| mem_addn_left_inP.wrap(i) }
+    mem_addn_right_in.branch(:anum).inner :mem_addn_right_inP
+    mem_addn_right_inPs = 8.times.map { |i| mem_addn_right_inP.wrap(i) }
+    mem_addn_out.branch(:anum).inner :mem_addn_outP
+    mem_addn_outPs = 8.times.map { |i| mem_addn_outP.wrap(i) }
+
+    # Build the adder.
+    add_n([8],clk.posedge,ack[0],ack[1],mem_addn_left_inPs,
+          mem_addn_right_inPs,mem_addn_outPs)
+
+
+    # Circuit for testing the parallel multiplication.
+
+    # Input memories
+    mem_file([8],8,clk,rst, rinc: :rst, winc: :rst).(:mem_muln_left_in)
+    mem_file([8],8,clk,rst, rinc: :rst, winc: :rst).(:mem_muln_right_in)
+    # Output memory
+    mem_file([8],8,clk,rst, winc: :rst).(:mem_muln_out)
+    # Access ports.
+    mem_muln_left_in.branch(:anum).inner :mem_muln_left_inP
+    mem_muln_left_inPs = 8.times.map { |i| mem_muln_left_inP.wrap(i) }
+    mem_muln_right_in.branch(:anum).inner :mem_muln_right_inP
+    mem_muln_right_inPs = 8.times.map { |i| mem_muln_right_inP.wrap(i) }
+    mem_muln_out.branch(:anum).inner :mem_muln_outP
+    mem_muln_outPs = 8.times.map { |i| mem_muln_outP.wrap(i) }
+
+    # Build the multer.
+    mul_n([8],clk.posedge,ack[1],ack[2],mem_muln_left_inPs,
+          mem_muln_right_inPs,mem_muln_outPs)
+
+
+    # Circuit for testing the mac
+    # Output signal.
+    [8].inner :acc
+
+    # Build the mac.
+    mac([8],clk.posedge,ack[2],ack[3],channel_port(5), channel_port(6), 
+        channel_port(acc))
+
+
+    # Circuit for testing the parallel mac.
+    # Input memory
+    mem_file([8],8,clk,rst, winc: :rst).(:mem_macn1_left_in)
+    # Output memory
+    mem_file([8],8,clk,rst, winc: :rst).(:mem_macn1_out)
+    # Access ports.
+    mem_macn1_left_in.branch(:anum).inner :mem_macn1_left_inP
+    mem_macn1_left_inPs = 8.times.map { |i| mem_macn1_left_inP.wrap(i) }
+    mem_macn1_out.branch(:anum).inner :mem_macn1_outP
+    mem_macn1_outPs = 8.times.map { |i| mem_macn1_outP.wrap(i) }
+
+    # Build the mac.
+    mac_n1([8],clk.posedge,ack[3],ack[4], mem_macn1_left_inPs,
+          channel_port(5), mem_macn1_outPs)
+
+
+    # The memory initializer.
+    # Writing ports
+    mem_scale_in.branch(:winc).inner :mem_scale_in_writeP
+    mem_addn_left_in.branch(:winc).inner :mem_addn_left_in_writeP
+    mem_addn_right_in.branch(:winc).inner :mem_addn_right_in_writeP
+    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
+    # Filling index
+    [8].inner :idx
+    # Filling counter
+    [3].inner :cnt
+    # Filling value
+    [8].inner :val
+
+    # Start flag
+    inner :start
+
+    # The execution process
+    par(clk.posedge) do
+        hif(rst) { cnt <= 0; val <= 0 }
+        helse do
+            # Step index processing.
+            hif(cnt == 7) do
+                hif(idx < 6) { idx <= idx + 1 }
+            end
+            # Memory filling steps.
+            hcase(idx)
+            hwhen(0) do
+                mem_scale_in_writeP.write(val) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
+            hwhen(1) do
+                mem_addn_left_in_writeP.write(val) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
+            hwhen(2) do
+                mem_addn_right_in_writeP.write(val) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
+            hwhen(3) do
+                mem_muln_left_in_writeP.write(val-24) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
+            hwhen(4) do
+                mem_muln_right_in_writeP.write(val-24) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
+            hwhen(5) do
+                mem_macn1_left_in_writeP.write(val-32) do
+                    cnt <= cnt + 1; val <= val + 1
+                end
+            end
+            # Computation steps.
+            helse do
+                hif(start) do
+                    req <= 1
+                    start <= 0
+                end
+                helse { req <= 0 }
+            end
+        end
+    end
+
+
+    # The test bench.
+    timed do
+        req <= 0
+        ack <= 0
+        clk <= 0
+        rst <= 0
+        cnt <= 0
+        idx <= 0
+        val <= 0
+        start <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        # Reset
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        start <= 1
+        !10.ns
+        # Run
+        64.times do
+            clk <= 1
+            !10.ns
+            clk <= 0
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_linear.rb

@@ -0,0 +1,163 @@
+require 'std/memory.rb'
+require 'std/linear.rb'
+
+include HDLRuby::High::Std
+
+# Tries for matrix-vector product.
+
+
+
+
+
+# Testing.
+system :testmat do
+
+    inner :clk,:rst, :req
+
+    # Input memories
+    mem_dual([8],256,clk,rst, rinc: :rst,winc: :rst).(:memL0)
+    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
+
+    # Prepares the left and acc arrays.
+    lefts = [readL0, readL1]
+
+    # Accumulators memory.
+    mem_file([8],2,clk,rst,rinc: :rst).(:memAcc)
+    memAcc.branch(:anum).inner :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)
+
+    # Translation.
+    # Translation memory.
+    mem_file([8],2,clk,rst,winc: :rst).(:memT)
+    # Tarnslation result
+    mem_file([8],2,clk,rst,rinc: :rst).(:memF)
+    # Access ports.
+    memT.branch(:anum).inner :readT
+    memF.branch(:anum).inner :writeF
+    regRs = [ readT.wrap(0), readT.wrap(1) ]
+    regLs = [ accs.wrap(0), accs.wrap(1) ]
+    regs =  [ writeF.wrap(0), writeF.wrap(1) ]
+
+    # Translater ack.
+    inner :ackT
+
+    # Instantiate the translater.
+    add_n([8],clk,ack0,ackT,regLs,regRs,regs)
+
+
+
+    # Second layer.
+    # 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
+
+    # Second layer ack.
+    inner :ack1
+
+    # Result.
+    [8].inner :res
+
+    sub do
+        # Instantiate the second matrix product.
+        # mac([8],clk,req,read2L0,accsR,res)
+        mac([8],clk,ackT,ack1,read2L0,readF,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
+    inner :fill, :fill2
+    [8].inner :val
+    par(clk.posedge) do
+        hif(fill) do
+            writeL0.write(val)
+            writeL1.write(val+1)
+            writeR.write(val+1)
+        end
+        hif(fill2) do
+            write2L0.write(val+2)
+            writeT.write(val+2)
+        end
+    end
+
+    timed do
+        req <= 0
+        clk <= 0
+        rst <= 0
+        fill <= 0
+        fill2 <= 0
+        val  <= 0
+        !10.ns
+        # Reset the memories.
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        # Fill the memories.
+        # First layer
+        clk <= 0
+        rst <= 0
+        fill <= 1
+        !10.ns
+        256.times do |i|
+            clk <= 1
+            !10.ns
+            clk <= 0
+            val <= val + 1
+            !10.ns
+        end
+        fill <= 0
+        clk <= 1
+        !10.ns
+        # Second layer
+        clk <= 0
+        rst <= 0
+        fill2 <= 1
+        !10.ns
+        2.times do |i|
+            clk <= 1
+            !10.ns
+            clk <= 0
+            val <= val + 1
+            !10.ns
+        end
+        fill2 <= 0
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        # Launch the computation
+        clk <= 0
+        req <= 1
+        !10.ns
+        300.times do
+            clk <= 1
+            !10.ns
+            clk <= 0
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hruby_low.rb

@@ -3059,24 +3059,6 @@ module HDLRuby::Low
             return [@value,@whens,@default].hash
         end
 
-        # # Adds a possible +match+ for the case's value that lead to the 
-        # # execution of +statement+.
-        # def add_when(match,statement)
-        #     # Checks the match.
-        #     unless match.is_a?(Expression)
-        #         raise AnyError, "Invalid class for a case match: #{match.class}"
-        #     end
-        #     # Checks statement.
-        #     unless statement.is_a?(Statement)
-        #         raise AnyError, "Invalid class for a statement: #{statement.class}"
-        #     end
-        #     # Add the case.
-        #     @whens << [match,statement]
-        #     # And set their parents.
-        #     match.parent = statement.parent = self
-        #     [match,statement]
-        # end
-
         # Adds possible when case +w+.
         def add_when(w)
             # Check +w+.
@@ -3178,7 +3160,7 @@ module HDLRuby::Low
         # Clones the Case (deeply)
         def clone
             # Clone the default if any.
-            defaut = @default ? @default.clone : nil
+            default = @default ? @default.clone : nil
             # Clone the case.
             return Case.new(@value.clone,default,(@whens.map do |w|
                 w.clone

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -1069,7 +1069,8 @@ module HDLRuby::Low
             node2rep = node2reassign.map {|n,r| [n,r[0]] }.to_h
 
             # First recurse on the sub blocks.
-            self.each_block { |block| block.reassign_expressions!(node2rep) }
+            # self.each_block { |block| block.reassign_expressions!(node2rep) }
+            self.each_block { |block| block.reassign_expressions!(node2reassign) }
 
             # Now work on the block.
             # Replace on the statements.

data/lib/HDLRuby/sim/hruby_sim.h

@@ -205,6 +205,20 @@ Value shift_right_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value equal_value(Value src0, Value src1, Value dst);
 
+/** Computes the lesser comparision of two values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+extern Value lesser_value(Value src0, Value src1, Value dst);
+
+/** Computes the greater comparision of two values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+extern Value greater_value(Value src0, Value src1, Value dst);
+
 /** Selects a value depending on a condition.
  *  @param cond   the condition to use for selecting a value
  *  @param dst    the destination value

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -284,6 +284,11 @@ Value make_set_value(Type type, int numeric, void* data) {
 //     }
 // }
 
+/* Defined after.*/
+static unsigned long long
+fix_numeric_type(Type type, unsigned long long val);
+
+
 /** Copies a value to another, the type of the destination is preserved.
  *  @param src the source value
  *  @param dst the destination value
@@ -296,7 +301,7 @@ Value copy_value(Value src, Value dst) {
     /* Copy the data. */
     if (src->numeric) {
         /* Numeric copy. */
-        dst->data_int = src->data_int;
+        dst->data_int = fix_numeric_type(dst->type,src->data_int);
     } else {
         /* Resize the destination if required. */
         resize_value(dst,type_width(dst->type));
@@ -617,6 +622,38 @@ static Value div_value_defined_bitstring(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the lesser comparision of two defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the comparison. */
+    dst->data_int = (value2integer(src0) < value2integer(src1));
+    return dst;
+}
+
+
+/** Computes the greater comparision of two defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the comparison. */
+    dst->data_int = (value2integer(src0) > value2integer(src1));
+    return dst;
+}
+
+
 /** Computes the NOT of a bitstring value.
  *  @param src the source value of the not
  *  @param dst the destination value
@@ -1364,6 +1401,37 @@ Value write_range_bitstring_no_z(Value src, long long first, long long last,
 
 /* ############# Start of the computation of numeric values. ############## */
 
+/** Fix the content of a numeric value according to its type so that
+ *  it can be used for C numeric computation. 
+ *  @param type the type to fix the value to
+ *  @param val the value to fix 
+ *  @return the rsulting value */
+static unsigned long long
+fix_numeric_type(Type type, unsigned long long val) {
+    /* Get the width of the type. */
+    int width = type_width(type);
+    /* Compute the base mask. */
+    unsigned long long mask = ((unsigned long long)(-1)) << width;
+    // printf("width=%i val=%llu mask=%llx\n",width,val,mask);
+
+    /* Is the type signed? */
+    if (type->flags.sign) {
+        /* Yes, perform sign extension. */
+        int is_neg = (val >> (width-1)) & 1;
+        // printf("is_neg=%i\n",is_neg);
+        if (is_neg) {
+            /* Negative sign extension. */
+            return val | mask;
+        } else {
+            /* Positive sign extension. */
+            return val & ~mask;
+        }
+    } else {
+        /* No, perform a zero extension. */
+        return val & ~mask;
+    }
+}
+
 
 /** Computes the neg of a numeric value.
  *  @param src the source value of the not
@@ -1375,7 +1443,7 @@ static Value neg_value_numeric(Value src, Value dst) {
     dst->numeric = 1;
 
     /* Perform the negation. */
-    dst->data_int = -src->data_int;
+    dst->data_int = fix_numeric_type(dst->type,-src->data_int);
     return dst;
 }
 
@@ -1391,7 +1459,7 @@ static Value add_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the addition. */
-    dst->data_int = src0->data_int + src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int + src1->data_int);
     return dst;
 }
 
@@ -1407,7 +1475,7 @@ static Value sub_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the subtraction. */
-    dst->data_int = src0->data_int - src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int - src1->data_int);
     return dst;
 }
 
@@ -1422,8 +1490,8 @@ static Value mul_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
-    dst->data_int = src0->data_int * src1->data_int;
+    /* Perform the multiplication. */
+    dst->data_int = fix_numeric_type(dst->type, src0->data_int * src1->data_int);
     return dst;
 }
 
@@ -1438,8 +1506,8 @@ static Value div_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
-    dst->data_int = src0->data_int / src1->data_int;
+    /* Perform the division. */
+    dst->data_int = fix_numeric_type(dst->type, src0->data_int / src1->data_int);
     return dst;
 }
 
@@ -1454,7 +1522,7 @@ static Value not_value_numeric(Value src, Value dst) {
     dst->numeric = 1;
 
     /* Perform the not. */
-    dst->data_int = !src->data_int;
+    dst->data_int = fix_numeric_type(dst->type,!src->data_int);
     return dst;
 }
 
@@ -1518,7 +1586,7 @@ static Value shift_left_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the left shift. */
-    dst->data_int = src0->data_int << src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int << src1->data_int);
     return dst;
 }
 
@@ -1534,7 +1602,7 @@ static Value shift_right_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the right shift. */
-    dst->data_int = src0->data_int >> src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int >> src1->data_int);
     return dst;
 }
 
@@ -1555,6 +1623,37 @@ static Value equal_value_numeric(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the lesser comparision of two numeric values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return the destination value */
+static Value lesser_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the lesser. */
+    dst->data_int = (src0->data_int < src1->data_int);
+    return dst;
+}
+
+/** Computes the greater comparision of two numeric values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return the destination value */
+static Value greater_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the lesser. */
+    dst->data_int = (src0->data_int > src1->data_int);
+    return dst;
+}
+
+
 /** Selects a value depending on a numeric condition.
  *  @param cond   the condition to use for selecting a value
  *  @param dst    the destination value (used only if new value is created).
@@ -1719,6 +1818,7 @@ Value read_range_numeric(Value value, long long first, long long last,
  *  @return dst */
 Value write_range_numeric(Value src, long long first, long long last,
         Value dst) {
+    // printf("write_range_numeric\n");
     /* Ensure first is the smaller. */
     if (first > last) {
         long long tmp = last;
@@ -1730,6 +1830,7 @@ Value write_range_numeric(Value src, long long first, long long last,
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type of the destination. */
     unsigned long long bw = dst->type->base;
+    // printf("src_width=%llu dst_wdith=%llu bw=%llu\n",src_width,dst_width,bw);
     first *= bw;
     last *= bw;
     /* If first is too large, end here. */
@@ -1737,11 +1838,13 @@ Value write_range_numeric(Value src, long long first, long long last,
     /* Adjust the last to fit the source and destination range. */
     if (last >= dst_width) last = dst_width-1;
     if (last-first >= src_width) last = src_width + first - 1;
+    // printf("first=%lld last=%lld\n",first,last);
     /* Copy from the source. */
-    unsigned long long src_data = src->data_int & ~((-1LL) << (last-first));
+    unsigned long long src_data = src->data_int & ~((-1LL) << (last-first+1));
     /* Cleans the destination where to place the data. */
-    unsigned long long mask = ((-1LL) << first) & ~((-1LL) << last);
+    unsigned long long mask = ~(((-1LL) << first) & ~((-1LL) << (last+1)));
     unsigned long long dst_data = dst->data_int & mask;
+    // printf("src_data=%llx  mask=%llx dst_data=%llx\n",src_data,mask,dst_data);
     /* Write the data. */
     dst_data |= src_data << first;
     dst->data_int = dst_data;
@@ -2111,6 +2214,60 @@ Value equal_value(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the lesser comparision of two general values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+Value lesser_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        return lesser_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return lesser_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
+/** Computes the greater comparision of two general values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+Value greater_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        return greater_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return greater_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
 /** Selects a value depending on a general condition.
  *  @param cond   the condition to use for selecting a value
  *  @param dst    the destination value (used only if new value is created).
@@ -2460,6 +2617,7 @@ Value read_range(Value value, long long first, long long last, Type base,
  *  @param dst the destination value
  *  @return dst */
 Value write_range(Value src, long long first, long long last, Value dst) {
+    // printf("write_range\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */
@@ -2485,6 +2643,7 @@ Value write_range(Value src, long long first, long long last, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 Value write_range_no_z(Value src, long long first, long long last, Value dst) {
+    // printf("write_range_no_z\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */

data/lib/HDLRuby/std/channel.rb

@@ -901,29 +901,77 @@ module HDLRuby::High::Std
     end
 
 
-end
-
+    # Wrapper to make an object run like a channel port.
+    class ChannelPortObject
+        # Create a new object wrapper for +obj+.
+        def initialize(obj)
+            @obj = obj
+        end
 
-module HDLRuby::High
+        # Port read with arguments +args+ executing +ruby_block+ in
+        # case of success.
+        def read(*args,&ruby_block)
+            # Get the target from the arguments.
+            target = args.pop
+            # Is there any argument left?
+            unless (args.empty?) then
+                # There are arguments left, perform an array access.
+                target <= @obj[*args]
+            else
+                # There are no argument left, perform a direct access.
+                target <= @obj
+            end
+            # Execute the ruby_block if any.
+            ruby_block.call if ruby_block 
+        end
 
-    ## Enhance expressions with possibility to act like a reading branch.
-    module HExpression
-        ## Transmits the expression to +target+ and execute +ruby_block+ if
-        #  any.
-        def read(target,&ruby_block)
-            target <= self
-            ruby_block.call if ruby_block
+        # Port write with argumnet +Args+ executing +ruby_block+ in
+        # case of success.
+        def write(*args,&ruby_block)
+            # Get the value to write from the arguments.
+            value = args.pop
+            # Is there any argument left?
+            unless (args.empty?) then
+                # There are arguments left, perform an array access.
+                @obj[*args] <= value
+            else
+                # There are no argument left, perform a direct access.
+                @obj <= value
+            end
+            # Execute the ruby_block if any.
+            ruby_block.call if ruby_block 
         end
+
     end
 
 
-    ## Enhance references with possibility to act like a writing branch.
-    module HRef
-        ## Transmits +target+ to the reference and execute +ruby_block+ if
-        #  any.
-        def write(target,&ruby_block)
-            self <= target
-            ruby_block.call if ruby_block
-        end
+    # Wrap object +obj+ to act like a channel port.
+    def channel_port(obj)
+        return ChannelPortObject.new(obj)
     end
 end
+
+
+# module HDLRuby::High
+# 
+#     ## Enhance expressions with possibility to act like a reading branch.
+#     module HExpression
+#         ## Transmits the expression to +target+ and execute +ruby_block+ if
+#         #  any.
+#         def read(target,&ruby_block)
+#             target <= self
+#             ruby_block.call if ruby_block
+#         end
+#     end
+# 
+# 
+#     ## Enhance references with possibility to act like a writing branch.
+#     module HRef
+#         ## Transmits +target+ to the reference and execute +ruby_block+ if
+#         #  any.
+#         def write(target,&ruby_block)
+#             self <= target
+#             ruby_block.call if ruby_block
+#         end
+#     end
+# end

data/lib/HDLRuby/std/linear.rb

@@ -0,0 +1,197 @@
+module HDLRuby::High::Std
+
+
+    ##
+    # Standard HDLRuby::High library: linear algebra functions.
+    #
+    # NOTE: require channel-like interface.
+    #
+    ########################################################################
+
+
+    # Delcares a vector product by a scalar value.
+    #
+    # Can be used for scaling a vector.
+    function :scale do |typ,ev,req,ack,left,rights,prods,
+                        mul = proc { |x,y| x*y }|
+        # Ensure ev is really an event.
+        ev = ev.posedge unless ev.is_a?(Event)
+        # Ensures rights and prods are arrays.
+        rights = rights.to_a
+        prods = prods.to_a
+        # Left value (the scale) and right value.
+        typ.inner :lv
+        rvs = rights.each_with_index.map { |left,i| typ.inner :"rv#{i}" }
+        # lv and rv are valid.
+        inner :lvok
+        rvoks = rights.each_with_index.map { |left,i| inner :"rvok#{i}" }
+        # Run flag
+        inner :run
+        par(ev) do
+            ack <= 0
+            run <= 0
+            hif(req | run) do
+                run <= 1
+                # Computation request.
+                left.read(lv) { lvok <= 1 }
+                rights.each_with_index do |right,i|
+                    right.read(rvs[i]) { rvoks[i] <= 1 }
+                    hif(lvok & rvoks[i]) do
+                        ack <= 1
+                        run <= 0
+                        prods[i].write(mul.(lv,rvs[i]))
+                    end
+                end
+            end
+            helse do
+                lvok <= 0
+                rights.each_with_index do |right,i|
+                    rvoks[i] <= 0
+                end
+            end
+        end
+    end
+
+
+    # Declares a 1-dimension vector adder.
+    #
+    # Can be used for the sum of two vectors.
+    function :add_n do |typ,ev,req,ack,lefts, rights, sums,
+                        add = proc { |x,y| x+y }|
+        # Ensure ev is really an event.
+        ev = ev.posedge unless ev.is_a?(Event)
+        # Ensures lefts and rights and sums are arrays.
+        lefts = lefts.to_a
+        rights = rights.to_a
+        sums = sums.to_a
+        # Left value and right value.
+        lvs = lefts.each_with_index.map { |left,i| typ.inner :"lv#{i}" }
+        rvs = lefts.each_with_index.map { |left,i| typ.inner :"rv#{i}" }
+        # lv and rv are valid.
+        lvoks = lefts.each_with_index.map { |left,i| inner :"lvok#{i}" }
+        rvoks = lefts.each_with_index.map { |left,i| inner :"rvok#{i}" }
+        # Run flag.
+        inner :run
+        par(ev) do
+            ack <= 0
+            run <= 0
+            hif(req | run) do
+                run <= 1
+                # Computation request.
+                lefts.zip(rights).each_with_index do |(left,right),i|
+                    left.read(lvs[i])  { lvoks[i] <= 1 }
+                    right.read(rvs[i]) { rvoks[i] <= 1 }
+                    hif(lvoks[i] & rvoks[i]) do
+                        run <= 0
+                        ack <= 1
+                        sums[i].write(add.(lvs[i],rvs[i]))
+                    end
+                end
+            end
+            helse do
+                lefts.each_with_index do |left,i|
+                    lvoks[i] <= 0
+                    rvoks[i] <= 0
+                end
+            end
+        end
+    end
+
+    # Declares a 1-dimension vector element-wise multiplier.
+    function :mul_n do |typ,ev,req,ack,lefts, rights, prods,
+                        mul = proc { |x,y| x*y }|
+        add_n(typ,ev,req,ack,lefts,rights,prods,mul)
+    end
+
+
+    # Declares a simple multiplier accumulator.
+    #
+    # Can be used for the scalar product of two vectors.
+    function :mac do |typ,ev,req,ack,left, right, acc,
+        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.
+        typ.inner :lv, :rv, :av
+        # lv and rv are valid.
+        inner :lvok, :rvok
+        # Run flag
+        inner :run
+        par(ev) do
+            ack <= 0
+            run <= 0
+            hif(req | run) do
+                run <= 1
+                # 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)))
+                end
+            end
+            helse do
+                lvok <= 0
+                rvok <= 0
+                acc.write(0)
+            end
+        end
+    end
+
+
+    # Declares a simple multiple mac with single right data.
+    #
+    # Can be used for the product of a martix-vector product.
+    function :mac_n1 do |typ,ev,req,ack,lefts, right, accs,
+        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)
+        # Ensures lefts is an array.
+        lefts = lefts.to_a
+        # Ensures accs is an array.
+        accs = accs.to_a
+        # Left value and right value.
+        lvs = lefts.each_with_index.map { |left,i| typ.inner :"lv#{i}" }
+        # Accumutated values.
+        avs = lefts.each_with_index.map { |left,i| typ.inner :"av#{i}" }
+        typ.inner :rv
+        # lv and rv are valid.
+        lvoks = lefts.each_with_index.map { |left,i| inner :"lvok#{i}" }
+        inner :rvok
+        # Run flag
+        inner :run
+        par(ev) do
+            ack <= 0
+            run <= 0
+            hif(req | run) do
+                run <= 1
+                # Computation request.
+                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])
+                    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)))
+                    end
+                end
+            end
+            helse do
+                rvok <= 0
+                lefts.each_with_index do |left,i|
+                    lvoks[i] <= 0
+                    # accs.write(i,0)
+                    accs[i].write(0)
+                end
+            end
+        end
+    end
+
+
+end

data/lib/HDLRuby/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.2.14
+  version: 2.2.15
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-26 00:00:00.000000000 Z
+date: 2020-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,6 +82,7 @@ files:
 - lib/HDLRuby/hdr_samples/dff_counter.rb
 - lib/HDLRuby/hdr_samples/include.rb
 - lib/HDLRuby/hdr_samples/instance_open.rb
+- lib/HDLRuby/hdr_samples/linear_test.rb
 - lib/HDLRuby/hdr_samples/mei8.rb
 - lib/HDLRuby/hdr_samples/mei8_bench.rb
 - lib/HDLRuby/hdr_samples/memory_test.rb
@@ -118,6 +119,7 @@ files:
 - lib/HDLRuby/hdr_samples/with_decoder.rb
 - lib/HDLRuby/hdr_samples/with_fixpoint.rb
 - lib/HDLRuby/hdr_samples/with_fsm.rb
+- lib/HDLRuby/hdr_samples/with_linear.rb
 - lib/HDLRuby/hdr_samples/with_memory.rb
 - lib/HDLRuby/hdr_samples/with_reconf.rb
 - lib/HDLRuby/hdrcc.rb
@@ -266,6 +268,7 @@ files:
 - lib/HDLRuby/std/decoder.rb
 - lib/HDLRuby/std/fixpoint.rb
 - lib/HDLRuby/std/fsm.rb
+- lib/HDLRuby/std/linear.rb
 - lib/HDLRuby/std/memory.rb
 - lib/HDLRuby/std/pipeline.rb
 - lib/HDLRuby/std/reconf.rb