HDLRuby 2.0.8

data/lib/HDLRuby/hdr_samples/neural/bw.rb

@@ -0,0 +1,23 @@
+##
+# Module generating a neuron bias or weight.
+# Params:
+# - +typ+: the data type of the neural signals.
+# - +init_bw+: initial value of the bias/weight.
+system :bw do |typ,init_bw|
+    # The control signals.
+    input :clk, :reset    # Clock and reset
+    input :select_initial # Initialization of the bias/weight
+    input :select_update  # Update of the bias/weight
+
+    # Update of the bias/weight
+    typ.input :dbw
+    # Output of the bias/weight
+    typ.output :bwo
+
+    # Behavior controlling the bias/weight
+    par(clk.posedge) do
+        hif(reset == 1) { bwo <= 0 }
+        helsif(select_initial == 1) { bwo <= init_bw }
+        helsif(select_update == 1)  { bwo <= bwo+dbw }
+    end
+end

data/lib/HDLRuby/hdr_samples/neural/counter.rb

@@ -0,0 +1,16 @@
+##
+# Module generating the sample counter.
+# Params:
+# - +num+: the number of samples.
+system :counter do |typ,num|
+    # The input control signals.
+    input :clk, :reset
+    # The output counter.
+    typ.output :out
+
+    par(clk.posedge) do
+        hif(reset == 1) { out <= 0 }
+        helsif(out == num-1) { out <= 0 }
+        helse { out <= out+1 }
+    end
+end

data/lib/HDLRuby/hdr_samples/neural/dadz.rb

@@ -0,0 +1,9 @@
+system :dadz do |width,derivate|
+    input :clk,:res
+    signed[width].input :a
+    signed[width].output :dadz
+
+    par(clk.posedge) do
+        dadz <= mux(res == 1, 0, derivate.(a))
+    end
+end

data/lib/HDLRuby/hdr_samples/neural/dadz_sub.rb

@@ -0,0 +1,4 @@
+require "./dadz.rb"
+
+system :dadz_sub, dadz(32, proc {|a| (_sh01000000-a)*a }) do
+end

data/lib/HDLRuby/hdr_samples/neural/forward.rb

@@ -0,0 +1,153 @@
+require "./counter.rb"
+require "./selector.rb"
+require "./bw.rb"
+require "./z.rb"
+require "./a.rb"
+require "./mem.rb"
+
+
+##
+# Module Generating a foward propagation structure of a NN.
+# Params:
+# - +typ+:   the data type for standard computations.
+# - +arch+:  the architecture of the NN as a array of columns sizes
+# - +samps+: the NN input and expected outputs samples as a 3D array
+# - +b_init+:the bias initial values as a 2D array
+# - +w_init+:the weights initial values as a 3D array
+# - +actP+:  the activation proc, default: ReLU
+# - +sopP+:  the sum of production function, default: basic operators
+system :forward do |typ,arch,samps,b_init,w_init,
+                    actP = proc { |z| mux(z < 0, 0, z) },
+                    sopP = proc do |xs,ws| 
+                        xs.zip(ws).map{ |x,w| x*w }.reduce(:+)
+                    end |
+    ###
+    # The interface signals
+
+    # The control signals
+    input :clk, :reset
+    input :din, :select_initial
+    # The input signals for updating of the weights and biases,
+    # and the output signals giving the corresponding current values.
+    cap_bs = []
+    bs = []
+    cap_ws = []
+    ws = []
+    arch[1..-1].each.with_index do |col,i|
+        cap_bs << []
+        bs << []
+        # The biase update inputs and value outputs
+        col.times do |j| 
+            cap_bs[-1] << ( typ.input  :"cap_b#{i+1}_#{j+1}" )
+            bs[-1] <<     ( typ.output :"b#{i+1}_#{j+1}"     )
+        end
+        # The weigh update inputs and value outputs
+        cap_ws << []
+        ws << []
+        col.times do |j0|
+            cap_ws[-1] << []
+            ws[-1] << []
+            arch[i].times do |j1|
+                cap_ws[-1][-1] << ( typ.input  :"cap_w#{i+1}_#{j0+1}#{j1+1}" )
+                ws[-1][-1] <<     ( typ.output :"w#{i+1}_#{j0+1}#{j1+1}"     )
+            end
+        end
+    end
+    # The output signals giving each neuron output.
+    as = []
+    arch[1..-1].each.with_index do |col,i|
+        as << []
+        col.times do |j|
+            as[-1] << ( typ.output :"a#{i+1}_#{j+1}" )
+        end
+    end
+    # The output signals indicating the current NN input and expected
+    # answer (they are provided by an inner memory).
+    ks = []
+    arch[0].times do |i|
+        # NN input
+        ks << ( typ.output :"k#{i+1}" )
+    end
+    ts = []
+    arch[-1].times do |i|
+        # NN expected answer
+        ts << ( typ.output :"t#{i+1}" )
+    end
+
+    ###
+    # The inner signals
+
+    # The control signals
+    inner :select_update
+    typedef(:outT) { [Math::log2(samps[0][0].size).ceil] } # Sample counter type
+    outT.inner :out
+
+    # The neurons sum results.
+    zs = []
+    arch[1..-1].each.with_index do |col,i|
+        zs << []
+        col.times do |j|
+            zs[-1] << ( typ.inner :"z#{i+1}_#{j+1}" )
+        end
+    end
+
+    ###
+    # The structural description (instantiation of thre neuron computation
+    # systems)
+
+    # Sample counter
+    counter(outT,samps[0][0].size).(:counterI).(clk, reset, out)
+
+    # Neuron update selector, the skip size is (NN depth)*4+1
+    # (4-cycle neurons and one addition sync cycle).
+    selector(arch.size*4+1).(:selectorI).(clk, reset, select_update)
+
+    # Input and expected output memories
+    arch[0].times do |i|
+        # Samples for input i
+        mem(typ,outT,samps[0][i]).(:"k#{i+1}I").(clk, din, out, ks[i])
+    end
+    arch[-1].times do |i|
+        # Expected values for output i
+        mem(typ,outT,samps[1][i]).(:"t#{i+1}I").(clk, din, out, ts[i])
+    end
+
+    # Biases and weights
+    arch[1..-1].each.with_index do |col,i|
+        # Biases
+        col.times do |j|
+            bw(typ,b_init[i][j]).
+                (:"b#{i+1}_#{j+1}I").(clk, reset, cap_bs[i][j],
+                    select_initial, select_update, bs[i][j])
+        end
+        # Weights
+        col.times do |j0|
+            arch[i].times do |j1|
+                bw(typ,w_init[i][j0][j1]).
+                    (:"w#{i+1}_#{j0+1}#{j1+1}I").(clk,reset,cap_ws[i][j0][j1],
+                    select_initial, select_update, ws[i][j0][j1])
+            end
+        end
+    end
+
+    # Weighted Sums
+    # First column
+    arch[1].times do |j|
+        z(typ,ks.size,sopP).(:"z2_#{j+1}I").
+            (clk, reset, *ks, *ws[0][j], bs[0][j], zs[0][j])
+    end
+    # Other columns
+    arch[2..-1].each.with_index do |col,i|
+        col.times do |j|
+            z(typ,as[i].size,sopP).(:"z#{i+3}_#{j+1}I").
+                (clk, reset, *as[i], *ws[i+1][j], bs[i+1][j], zs[i+1][j])
+        end
+    end
+
+    # Activations
+    arch[1..-1].each.with_index do |col,i|
+        col.times do |j|
+            a(typ,actP).(:"a#{i+1}_#{j+1}I").(clk, reset, zs[i][j], as[i][j])
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/neural/forward_sub.rb

@@ -0,0 +1,62 @@
+require "./forward.rb"
+require "./sigmoid.rb"
+
+##
+# A fully specified forward module with 8.24-bit fixed point computation
+# and 4.4bit table-based sigmoid activation function.
+# Structure: 2 inputs, one 3-column hidden layer and 2 outputs.
+
+system :forward_sub, forward(
+    signed[31..0],   # Data type
+    [2,3,2], # NN structure
+    [
+        # Input samples.
+          # First input.
+        [[_sh08000000, _sh08000000, _sh05000000, _sh05000000, 
+          *([_sh00000000]*28)],
+          # Second input.
+         [_sh08000000, _sh05000000, _sh08000000, _sh05000000,
+          *([_sh00000000]*28)]],
+        # Expected outputs
+          # First output
+        [[_sh01000000, _sh00000000, _sh00000000, _sh00000000, 
+          *([_sh00000000]*28)],
+          # Second output
+         [_sh00000000, _sh01000000, _sh01000000, _sh01000000,
+          *([_sh00000000]*28)]]
+    ],
+    # Biases initial values
+    [
+        # Second column
+        [_shFF000000, _shFF000000, _shFF000000],
+        # Third column
+        [_shFF000000, _shFF000000]
+    ],
+    # Weights initial values
+    [
+        # Second column
+        [
+            # First neuron
+            [ _sh00199999, _sh00666666 ],
+            # Second neuron
+            [ _sh004CCCCC, _sh00800000 ],
+            # Third neuron
+            [ _sh00999999, _sh00199999 ]
+        ],
+        # Third column
+        [
+            # First neuron
+            [ _sh00B33333, _sh00333333, _sh0014CCCC ],
+            # Second neuron
+            [ _sh00333333, _sh00800000, _sh01199999 ]
+        ]
+    ],
+    # The activation function.
+    proc{|addr| sigmoid(8,4,32,24,addr)},
+    # The sum of production function.
+    proc do |xs,ws|
+        (xs.zip(ws).map { |x,w| x*w }.reduce(:+))[27..20]
+    end
+) do
+end
+

data/lib/HDLRuby/hdr_samples/neural/forward_sub_rand.rb

@@ -0,0 +1,41 @@
+require "./forward.rb"
+require "./sigmoid.rb"
+require "./random.rb"
+
+##
+# A fully specified forward module with 8.24-bit fixed point computation
+# and 4.4bit table-based sigmoid activation function.
+# Structure: 2 inputs, one 3-column hidden layer and 2 outputs.
+
+system :forward_sub, forward(
+    signed[31..0],   # Data type
+    [2,4,3,2], # NN structure
+    [
+        # Input samples.
+          # First input.
+        [[_sh08000000, _sh08000000, _sh05000000, _sh05000000, 
+          *([_sh00000000]*28)],
+          # Second input.
+         [_sh08000000, _sh05000000, _sh08000000, _sh05000000,
+          *([_sh00000000]*28)]],
+        # Expected outputs
+          # First output
+        [[_sh01000000, _sh00000000, _sh00000000, _sh00000000, 
+          *([_sh00000000]*28)],
+          # Second output
+         [_sh00000000, _sh01000000, _sh01000000, _sh01000000,
+          *([_sh00000000]*28)]]
+    ],
+    # Biases initial values
+    rand_array([4,3,2],32),
+    # Weights initial values
+    rand_array([[2,2,2,2],[4,4,4],[3,3]],32),
+    # The activation function.
+    proc{|addr| sigmoid(8,4,32,24,addr)},
+    # The sum of production function.
+    proc do |xs,ws|
+        (xs.zip(ws).map { |x,w| x*w }.reduce(:+))[27..20]
+    end
+) do
+end
+

data/lib/HDLRuby/hdr_samples/neural/forward_sub_rand_typedef.rb

@@ -0,0 +1,47 @@
+require "./forward.rb"
+require "./sigmoid.rb"
+require "./random.rb"
+
+# proc do |xs,ws|
+#     (xs.zip(ws).map { |x,w| x*w }.reduce(:+))[27..20]
+# end
+
+# 16:16 Fixed-point type.
+[31..0].signed.typedef(:fix32)
+# Multiply must adjust point.
+fix32.define_operator(:*) do |left,right|
+   ( left.as([31..0]) * right ) >> 32
+end
+
+
+##
+# A fully specified forward module with 8.24-bit fixed point computation
+# and 4.4bit table-based sigmoid activation function.
+# Structure: 2 inputs, one 3-column hidden layer and 2 outputs.
+
+system :forward_sub, forward(
+    fix32,   # Data type
+    [2,4,3,2], # NN structure
+    [
+        # Input samples.
+          # First input.
+        [[_sh08000000, _sh08000000, _sh05000000, _sh05000000, 
+          *([_sh00000000]*28)],
+          # Second input.
+         [_sh08000000, _sh05000000, _sh08000000, _sh05000000,
+          *([_sh00000000]*28)]],
+        # Expected outputs
+          # First output
+        [[_sh01000000, _sh00000000, _sh00000000, _sh00000000, 
+          *([_sh00000000]*28)],
+          # Second output
+         [_sh00000000, _sh01000000, _sh01000000, _sh01000000,
+          *([_sh00000000]*28)]]
+    ],
+    # Biases initial values
+    rand_array([4,3,2],32),
+    # Weights initial values
+    rand_array([[2,2,2,2],[4,4,4],[3,3]],32)
+) do
+end
+

data/lib/HDLRuby/hdr_samples/neural/mem.rb

@@ -0,0 +1,30 @@
+##
+# Module generating a lookup table memory.
+# Params:
+# - +inT+:  the data type of the input (address).
+# - +outT+: the data type of the output (data).
+# - +ar+:   the contents of the memory as an array.
+system :mem do |inT,outT,ar|
+    # The control signals.
+    input :clk # Clock
+    input :din # Read enable
+
+    # The interface signals.
+    inT.input   :addr  # Address
+    outT.output :data  # Data
+
+    # The memory.
+    outT[ar.size].inner :contents
+
+    # Fills the memory (static)
+    # ar.each.with_index do |val,i|
+    #     contents[i] <= val
+    # end
+    contents <= ar
+
+    # Handle the access to the memory.
+    par(clk.posedge) do
+        hif(din == 1) { data <= contents[addr] }
+        helse         { data <= :"_#{"z"*outT.width}" }
+    end
+end

data/lib/HDLRuby/hdr_samples/neural/random.rb

@@ -0,0 +1,23 @@
+# Generate a +width+ bit (signed) random value.
+def rand_signed(width)
+    :"_s#{width.times.map { Random.rand(0..1).to_s }.join }".to_expr
+end
+
+# Generates a N-dimension array described by +geometry+ filled
+# with +width+ bit values.
+def rand_array(geometry,width)
+    if geometry.is_a?(Array) then
+        # Geometry is hierarchical, recurse on it.
+        return geometry.map {|elem| rand_array(elem,width) }
+    else
+        # Geometry is a size of a 1-D array, generate it.
+        return geometry.times.map { |i| rand_signed(width) }
+    end
+end
+
+# rand_array(4,6).each do |v|
+#     puts v.content
+# end
+# 
+# system :test do
+# end

data/lib/HDLRuby/hdr_samples/neural/selector.rb

@@ -0,0 +1,29 @@
+##
+# Module generating the selector that decides if a neuron is to update or not.
+# Params:
+# - +skip+: the number of clocks to skip.
+system :selector do |skip|
+    input :clk, :reset
+    output :enable_update
+
+    # The clock counter.
+    [Math::log2(skip).ceil].inner :counter
+
+    # The behavior handling the skip counter
+    par(clk.posedge) do
+        hif(reset == 1) { counter <= 0 }
+        helse do
+            hif(counter == skip-1) { counter <=0 }
+            helse        {counter <= counter + 1 }
+        end
+    end
+
+    # The behavior handling the update signal
+    par(clk.posedge) do
+        hif(reset == 1) { enable_update <= 0 }
+        helse do
+            hif(counter == skip-1) { enable_update <= 1 }
+            helse                  { enable_update <= 0 }
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/neural/sigmoid.rb

@@ -0,0 +1,20 @@
+def sigmoid(a_width, a_point, d_width, d_point, addr)
+   # Initialize the result to force it as a ruby variable.
+    High.cur_system.open do
+      sub do
+         # Generates the rom
+         [d_width][2**a_width].inner :contents
+         contents <= (2**a_width).times.map do |i|
+            # Converts i to a float
+            i = i.to_f * 2**(-a_point)
+            # Compute the sigmoid
+            sigm = (1.0 / (1+Math.exp(i)))
+            # Convert it to fixed point
+            (sigm * 2**d_point).to_i
+         end
+
+         # Use it for the access
+         contents[addr[(a_point+d_width-1-d_point)..a_point-d_point]]
+      end
+   end
+end

data/lib/HDLRuby/hdr_samples/neural/z.rb

@@ -0,0 +1,33 @@
+##
+# Module generating a neuron sum.
+# Params:
+# - +typ+:  the data type of the neural signals.
+# - +ary+:  the arity of the neuron.
+# - +sopP+: the sum of product function.
+system :z do |typ,ary,sopP|
+    # The control signals.
+    input :clk, :reset    # Clock and reset
+
+    # The inputs of the neuron.
+    ins = []
+    wgs = []
+    ary.times do |i|
+        # The input values
+        ins << typ.input(:"x#{i}")
+    end
+    ary.times do |i|
+        # The weights
+        wgs << typ.input(:"w#{i}")
+    end
+    # The bias
+    typ.input :bias
+
+    # The sum output
+    typ.output :z
+
+    # Behavior controlling the bias/weight
+    par(clk.posedge) do
+        hif(reset == 1) { z <= 0 }
+        helse           { z <= sopP.(ins + [1],wgs + [bias]) }
+    end
+end