HDLRuby 3.1.0 → 3.3.0

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -121,6 +121,9 @@ Value calc_expression(Expression expr, Value res) {
                 free_value();
                 /* Performs the access. */
                 res = read_range(value,index,index,rexpr->type,res);
+                /* Set the type to the one of the reference since it is
+                 * an index access and not a range one. */
+                res->type = rexpr->type;
                 free_value();
                 break;
             }
@@ -174,6 +177,82 @@ Value calc_expression(Expression expr, Value res) {
 }
 
 
+/** Calculates a range access from a reference.
+ *  Recurse over the multiple references.
+ *  @param ref the reference to work on.
+ *  @param first the first index of the access.
+ *  @param last the last index of the access.
+ *  @param sig the target signal. */
+void calc_ref_rangeS(Reference ref, long long* first, long long *last, 
+        SignalI* sig) {
+    // printf("calc_ref_rangeS with kind=%d\n",ref->kind);
+    if (ref->kind == CAST) {
+        /* Create a new reference for the computation that changes the type. */
+        Cast refc = (Cast)ref;
+        /* Compute the range for the child. */
+        long long cfirst, clast;
+        calc_ref_rangeS(refc->child,&cfirst,&clast,sig);
+        /* Update first and last using the cast. */
+        /* Both first and last should be equal since the type of the cast sets
+         * the width */
+        // printf("cfirst=%d clast=%d\n",cfirst,clast);
+        *first = *last = cfirst;
+    }
+    else if (ref->kind == REF_INDEX) {
+        RefIndex refi = (RefIndex)ref;
+        /* Compute the index of refi. */
+        Value indexV = get_value();
+        indexV = calc_expression(refi->index,indexV);
+        long long index = value2integer(indexV);
+        // printf("index=%d\n",index);
+        free_value();
+        /* Is the reference a signal? */
+        if (refi->ref->kind == SIGNALI) {
+            /* Yes, end here. */
+            *first = index;
+            *last  = index;
+            *sig   = (SignalI)(refi->ref);
+        } else {
+            /* No, need to recurse. */
+            long long pfirst, plast;
+            calc_ref_rangeS(refi->ref,&pfirst,&plast,sig);
+            // printf("pfirst=%d plast=%d\n",pfirst,plast);
+            /* Calculate the final first and last. */
+            *first = *last = pfirst + index;
+        }
+    } else if (ref->kind == REF_RANGE) {
+        RefRangeE refr = (RefRangeE)ref;
+        /* Compute the range of refr */
+        Value firstV = get_value();
+        firstV = calc_expression(refr->first,firstV);
+        long long firstR = value2integer(firstV);
+        free_value();
+        Value lastV = get_value();
+        lastV = calc_expression(refr->last,lastV);
+        long long lastR = value2integer(lastV);
+        free_value();
+        // printf("firstR=%d lastR=%d\n",firstR,lastR);
+        /* Is the reference a signal? */
+        if (refr->ref->kind == SIGNALI) {
+            /* Yes, end here. */
+            *first = firstR;
+            *last  = lastR;
+            *sig   = (SignalI)(refr->ref);
+        } else {
+            /* No, need to recurse. */
+            long long pfirst, plast;
+            calc_ref_rangeS(refr->ref,&pfirst,&plast,sig);
+            /* Calculate the final first and last. */
+            *first = pfirst + firstR;
+            *last = plast + lastR;
+        }
+    } else {
+        perror("Invalid reference for converting to range access.");
+        exit(1);
+    }
+}
+
+
 
 /** Executes a statement.
  *  @param stmnt the statement to execute.
@@ -205,15 +284,22 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                         {
                             /* Transmission to sub element. */
                             RefIndex refi = (RefIndex)(trans->left);
-                            /* Compute the index. */
-                            Value indexV = get_value();
-                            indexV = calc_expression(refi->index,indexV);
-                            long long index = value2integer(indexV);
-                            free_value();
-                            /* Generate the reference inside the left value. */
+                            // /* Compute the index. */
+                            // Value indexV = get_value();
+                            // indexV = calc_expression(refi->index,indexV);
+                            // long long index = value2integer(indexV);
+                            // free_value();
+                            // /* Generate the reference inside the left value. */
+                            // RefRangeS ref = 
+                            //     make_ref_rangeS((SignalI)(refi->ref),refi->type,
+                            //         index,index);
+                            /* Compute the range. */
+                            long long first,last;
+                            SignalI sig;
+                            calc_ref_rangeS((Reference)refi,&first,&last,&sig);
+                            /* Now can create the range. */
                             RefRangeS ref = 
-                                make_ref_rangeS((SignalI)(refi->ref),refi->type,
-                                    index,index);
+                                make_ref_rangeS(sig,refi->type,first,last);
                             /* Perform the transmit. */
                             if(mode)
                                 transmit_to_signal_range_seq(right,ref);
@@ -226,21 +312,24 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                             /* Transmission to range of sub elements. */
                             RefRangeE refr = (RefRangeE)(trans->left);
                             /* Compute the range. */
-                            // Value firstV = calc_expression(refr->first);
-                            Value firstV = get_value();
-                            firstV = calc_expression(refr->first,firstV);
-                            long long first = value2integer(firstV);
-                            free_value();
-                            // Value lastV = calc_expression(refr->last);
-                            Value lastV = get_value();
-                            lastV = calc_expression(refr->last,lastV);
-                            long long last = value2integer(lastV);
-                            free_value();
-                            // printf("firstV=%lld lastV=%lld right=%lld mode=%d\n",firstV->data_int,lastV->data_int,right->data_int,mode);
-                            /* Generate the reference inside the left value. */
+                            // Value firstV = get_value();
+                            // firstV = calc_expression(refr->first,firstV);
+                            // long long first = value2integer(firstV);
+                            // free_value();
+                            // Value lastV = get_value();
+                            // lastV = calc_expression(refr->last,lastV);
+                            // long long last = value2integer(lastV);
+                            // free_value();
+                            // /* Generate the reference inside the left value. */
+                            // RefRangeS ref = 
+                            //     make_ref_rangeS((SignalI)(refr->ref),refr->type,
+                            //         first,last);
+                            long long first,last;
+                            SignalI sig;
+                            calc_ref_rangeS((Reference)refr,&first,&last,&sig);
+                            /* Now can create the range. */
                             RefRangeS ref = 
-                                make_ref_rangeS((SignalI)(refr->ref),refr->type,
-                                    first,last);
+                                make_ref_rangeS(sig,refr->type,first,last);
                             /* Perform the transmit. */
                             if(mode)
                                 transmit_to_signal_range_seq(right,ref);
@@ -416,7 +505,7 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
             }
 
         default:
-            perror("Invalid kind for an expression."); 
+            perror("Invalid kind for a statement."); 
     }
 }
 

data/lib/HDLRuby/hdr_samples/c_program/echo.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include "cHDL.h"
+
+#if defined(_WIN32) || defined(_WIN64)
+__declspec(dllexport)
+#endif
+void echo(void* code) {
+    static void* inP = NULL;
+    static void* outP = NULL;
+    unsigned long long data;
+
+    /* Is the input port obtained? */
+    if (inP == NULL) {
+        /* No, get it. */
+        inP = c_get_port("inP");
+    }
+
+    /* Is the input port obtained? */
+    if (outP == NULL) {
+        /* No, get it. */
+        outP = c_get_port("outP");
+    }
+
+    /* Get data from the input port. */
+    data = c_read_port(inP);
+
+    /* Display it. */
+    printf("Echoing: %llu\n", data);
+
+    /* Echoing the data. */
+    c_write_port(outP,data);
+
+}

data/lib/HDLRuby/hdr_samples/comparison_bench.rb

@@ -1,7 +1,7 @@
 # Test the comparison operators.
 
-# A benchmark for the adder.
-system :adder_bench do
+# A benchmark for the comparators.
+system :comparison_bench do
     [8].inner :x, :y
     signed[8].inner :u,:v
     inner :ue, :ult, :ule, :ugt, :uge

data/lib/HDLRuby/hdr_samples/counter_bench.rb

@@ -19,8 +19,8 @@ system :counter do
     par do
         hif(rst) { [cc,qq] <= 0 }
         helse do
-            add.(q,1,[cc,qq])
             hif(ctrl == 1) { add.(q,-1,[cc,qq]) }
+            helse          { add.(q,1,[cc,qq]) }
         end
     end
 

data/lib/HDLRuby/hdr_samples/counter_dff_bench.rb

@@ -1,34 +1,35 @@
 # A simple D-FF
 system :dff do
-    input  :clk, :d
+    input  :clk, :rst, :d
     output :q
 
-    (q <= d).at(clk.posedge)
+    (q <= d & ~rst).at(clk.posedge)
 end
 
 # A benchmark for the dff.
 system :dff_bench do
-    inner :clk
+    inner :clk, :rst
     inner :d0, :q0, :d1, :q1
 
-    dff(:my_dff0).(clk,d0,q0)
-    dff(:my_dff1).(d0,d1,q1)
+    dff(:my_dff0).(clk,rst,d0,q0)
+    dff(:my_dff1).(d0,rst,d1,q1)
 
     d0 <= ~q0
     d1 <= ~q1
 
     timed do
-        d0 <= 0
-        d1 <= 0
         clk <= 0
+        rst <= 0
         !10.ns
         clk <= 1
         !10.ns
         clk <= 0
+        rst <= 1
         !10.ns
         clk <= 1
         !10.ns
         clk <= 0
+        rst <= 0
         !10.ns
         clk <= 1
         !10.ns

data/lib/HDLRuby/hdr_samples/dff_properties.rb

@@ -1,3 +1,5 @@
+raise "Properties are deprecated in HDLRuby."
+
 # A simple D-FF
 system :dff do
     input :clk, :rst, :d

data/lib/HDLRuby/hdr_samples/enum_as_param.rb

@@ -0,0 +1,52 @@
+# Check if an enum can be passed as generic parameter.
+
+
+system :machin do |vals|
+    input :clk,:rst
+    [8].output :res
+    sequencer(clk,rst) do
+        vals.seach { |val| res <= val }
+    end
+end
+
+system :truc do |sig|
+    [8].output :res
+
+    res <= sig
+end
+
+system :machin_bench do
+    inner :clk,:rst
+
+    bit[8][-4].inner vals: [ _h01,_h02,_h03,_h05 ]
+    [8].inner :res0
+
+    machin(vals).(:my_machin).(clk,rst,res0)
+    
+    [8].inner :val, :res1
+    truc(val).(:my_truc).(res1)
+
+    timed do
+        val <= 10
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        repeat(15) do
+            clk <= 1
+            !10.ns
+            clk <= 0
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/linear_test.rb

@@ -1,6 +1,8 @@
 require 'std/memory.rb'
 require 'std/linear.rb'
 
+raise "std/memory.rb is deprecated."
+
 include HDLRuby::High::Std
 
 # Tries for matrix-vector product.

data/lib/HDLRuby/hdr_samples/logic_bench.rb

@@ -3,6 +3,8 @@
 system :logic_bench do
     [3].inner :x,:y
     [3].inner :s_not, :s_and, :s_or, :s_xor, :s_nxor
+    
+    signed[16].inner :a,:b,:shl,:shr
 
     timed do
         8.times do |i|
@@ -15,6 +17,10 @@ system :logic_bench do
                 s_xor  <= x ^ y
                 s_nxor <= (x == y)
                 !10.ns
+                a      <= i
+                b      <= j
+                shl    <= (a << b)
+                shr    <= (a >> b)
             end
         end
     end

data/lib/HDLRuby/hdr_samples/mei8.rb

@@ -54,7 +54,7 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
 
         # The control part for choosing between 0, add, sub and neg.
-        par do
+        par(opr,x,y) do
             # Default computations
             cf <= 0; vf <= 0; zf <= (z == 0); sf <= z[7]
             add.(0,0,0)
@@ -148,14 +148,14 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
     end
 
+    # Handling of the 3-state data bus
+    dbus <= mux(io_rwb,io_out,_bzzzzzzzz)
+    io_in <= dbus
+
     # The io unit.
     fsm(clk.posedge,rst,:async) do
         default       { io_done <= 0; req <= 0; rwb <= 0; addr <= 0
-                        io_r_done <= 0
-                        # Default handling of the 3-state data bus
-                        hif(io_rwb) { dbus <= _zzzzzzzz }
-                        helse       { dbus <= io_out }
-                        io_in <= dbus }
+                        io_r_done <= 0 }
         reset(:sync)  { data <= 0; }
         state(:wait)  { goto(io_req,:start,:wait) }        # Waiting for an IO
         state(:start) { req <= 1; rwb <= io_rwb; addr <= g # Start an IO

data/lib/HDLRuby/hdr_samples/mei8_bench.rb

@@ -56,7 +56,7 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
 
         # The control part for choosing between 0, add, sub and neg.
-        par do
+        par(opr,x,y) do
             # Default computations
             cf <= 0; vf <= 0; zf <= (z == 0); sf <= z[7]
             add.(0,0,0)
@@ -150,14 +150,14 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
     end
 
+    # Handling of the 3-state data bus
+    dbus <= mux(io_rwb,io_out,_bzzzzzzzz)
+    io_in <= dbus
+
     # The io unit.
     fsm(clk.posedge,rst,:async) do
         default       { io_done <= 0; req <= 0; rwb <= 0; addr <= 0
-                        io_r_done <= 0
-                        # Default handling of the 3-state data bus
-                        hif(io_rwb) { dbus <= _zzzzzzzz }
-                        helse       { dbus <= io_out }
-                        io_in <= dbus }
+                        io_r_done <= 0 }
         reset(:sync)  { data <= 0; }
         state(:wait)  { goto(io_req,:start,:wait) }        # Waiting for an IO
         state(:start) { req <= 1; rwb <= io_rwb; addr <= g # Start an IO

data/lib/HDLRuby/hdr_samples/memory_test.rb

@@ -1,5 +1,7 @@
 require 'std/memory.rb'
 
+raise "std/memory.rb is deprecated."
+
 include HDLRuby::High::Std
 
 

data/lib/HDLRuby/hdr_samples/named_sub.rb

@@ -4,9 +4,9 @@
 
 
 # A simple circuit with named sub
-system :named_sub do
-    input  :x, :y
-    output :s
+system :named_sub do |x|
+    input  :y
+    output :s, :z
 
     sub :somesub do
         inner :sig
@@ -17,13 +17,17 @@ system :named_sub do
         s <= ~somesub.sig
     end
 
+    z <= s
+
 end
 
 # A benchmark for the circuit.
 system :named_sub_bench do
-    inner :x, :y, :s
+    inner :x, :y, :s, :z
+
+    named_sub(x).(:my_named_sub).(y,s)
 
-    named_sub(:my_named_sub).(x,y,s)
+    z <= my_named_sub.z
 
     timed do
         x <= 0

data/lib/HDLRuby/hdr_samples/ram.rb

@@ -4,15 +4,16 @@ system :ram8_16 do
     [7..0].input :addr
     [7..0].inout :data
 
+    [7..0].inner :data_in
+
     bit[7..0][2**8].inner :content
 
-    # Memory enabled?
+    data <= mux(en & rwb, _bzzzzzzzz, content[addr])
+    data_in <= data
+
     par(clk.posedge) do
-        hif(en) do
-            # Read case
-            hif(rwb)   { data <= content[addr] }
-            helse      { content[addr] <= data }
+        hif(en & ~rwb) do
+            content[addr] <= data_in
         end
-        helse { data <= _bZZZZZZZZ }
     end
 end

data/lib/HDLRuby/hdr_samples/ruby_fir_hw.rb

@@ -2,6 +2,8 @@ require 'std/memory.rb'
 require 'std/linear.rb'
 # require 'std/timing.rb'
 
+raise "std/memory.rb is deprecated."
+
 include HDLRuby::High::Std
 
 

data/lib/HDLRuby/hdr_samples/ruby_program/echo.rb

@@ -0,0 +1,9 @@
+require 'rubyHDL'
+
+# Ruby program ment to eb executed within HDLRuby hardware.
+
+def echo
+    val = RubyHDL.inP
+    puts "Echoing: #{val}"
+    RubyHDL.outP = val    
+end

data/lib/HDLRuby/hdr_samples/ruby_program/stdrw.rb

@@ -0,0 +1,6 @@
+require 'RubyHDL'
+
+def stdrw
+  RubyHDL.sigI = $stdin.read.to_i
+  $stdout.puts(RubyHDL.sigO)
+end