HDLRuby 2.3.7 → 2.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb0dfd0d3f5fd062cd7e31f46eab82f0090e58eb8690a50a74106cfa32b5b9c2
-  data.tar.gz: 46f437035c02b4c8de14fb5033361b2d65cb6a7916887ca16a1dea67adadc8b9
+  metadata.gz: cd62e24fab42fee5c7a9e3cefda920cab67ec3a739e7ec0e66e6e637e890b959
+  data.tar.gz: d294cb0479e6388dea6e318c458f26ddabf71fd9281fa25f6ee69d6039bd1526
 SHA512:
-  metadata.gz: f6db11e75542e9b1f3e9064c32b3d8979ff3815ff661bfe8defc80f9625b671851a341366ad021a120305071e5f2099f95193e8a2332366460b967c6755a041f
-  data.tar.gz: 44a91392735fa86edc102ae6d20aa54dd85628e2efac5f4112731d2733bf7b555e4dce9bc39a086efbb5c3a1f1f0d2a4bb0e420be1f6251d26a505599bff526d
+  metadata.gz: d2039cd7158a2e2296005639474f9076f4f72f667777c97a94d7581975e92242e2be31fe3b7fb1cadf722b4f9fa6d8f8287252ec9944077512ffcd7d036ad28f
+  data.tar.gz: 8107f68c9c15f2f5e33a6f1a94c3454d46b9d4493ed00868c660d084b0e94e64747da3b984f7812254c31f3595988833de1df6e71253648ed1f85042cd45b534

data/README.md

@@ -50,6 +50,7 @@ Where:
 | `-s, --syntax`    | Output the Ruby syntax tree                          |
 | `-C, --clang`     | Output the C code of the simulator                   |
 | `-S, --sim`       | Output the executable simulator and execute it       |
+| `--vcd`           | Make the simulator generate a vcd file               |
 | `-d, --directory` | Specify the base directory for loading the HDLRuby files |
 | `-D, --debug`     | Set the HDLRuby debug mode |
 | `-t, --top system`| Specify the top system describing the circuit to compile |

data/lib/HDLRuby/hdr_samples/bstr_bench.rb

@@ -0,0 +1,14 @@
+
+# A benchmark for the bit string generation in case of signed values.
+system :bstr_bench do
+    signed[7..0].inner :val
+
+    timed do
+        val <= 0
+        !10.ns
+        val <= 26
+        !10.ns
+        val <= -25
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/neg_arith_bench.rb

@@ -0,0 +1,49 @@
+
+# A benchmark for testing the arithmetic with signed values.
+system :neg_arith_bench do
+    signed[11..0].inner :x,:y,:z
+
+    timed do
+        x <= 10
+        y <= 10
+        z <= 0
+        !10.ns
+        z <= 10 * 10
+        !10.ns
+        z <= x * y
+        !10.ns
+        x <= 10
+        y <= -10
+        !10.ns
+        z <= 10 * (-10)
+        !10.ns
+        z <= x * y
+        !10.ns
+        x <= -10
+        y <= 10
+        !10.ns
+        z <= (-10) * 10
+        !10.ns
+        z <= x * y
+        !10.ns
+        x <= -10
+        y <= -10
+        !10.ns
+        z <= (-10) * (-10)
+        !10.ns
+        z <= x * y
+        !10.ns
+        x <= _000000011010
+        y <= _000011111010
+        z <= 0
+        !10.ns
+        z <= x * y
+        !10.ns
+        x <= _000000011010
+        y <= _111111111010
+        z <= 0
+        !10.ns
+        z <= x * y
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_fixpoint.rb

@@ -9,6 +9,8 @@ system :fix_test do
 
     # Declare three 4-bit integer part 4-bit fractional part
     bit[3..0,3..0].inner :x,:y,:z
+    # Declare three 8-bit integer part 8-bit fractional part
+    signed[3..0,3..0].inner :a,:b,:c,:d
 
     # Performs calculation between then
     timed do
@@ -22,5 +24,30 @@ system :fix_test do
         !10.ns
         z <= z / x
         !10.ns
+        a <= _00010000
+        b <= _00001111
+        !10.ns
+        c <= a * b
+        d <= 0
+        !10.ns
+        d <= d + c 
+        !10.ns
+        a <= -0.375.to_fix(4)
+        b <= 1.625.to_fix(4)
+        !10.ns
+        c <= a * b
+        !10.ns
+        # a <= _00010000
+        # b <= _00010101
+        a <= _0000111x
+        b <= _1110011x
+        !10.ns
+        # a <= a & _11111110
+        # b <= b | _00000001
+        a <= a | _00000001
+        b <= b | _00000001
+        !10.ns
+        c <= a * b
+        !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/with_multi_channels.rb

@@ -0,0 +1,300 @@
+require "std/channel.rb"
+
+include HDLRuby::High::Std
+
+# Channel describing a buffered queue storing data of +typ+ type of +depth+,
+# synchronized through clk and reset on +rst+.
+channel(:queue) do |typ,depth,clk,rst|
+    # The inner buffer of the queue.
+    typ[-depth].inner :buffer
+    # The read and write pointers.
+    [depth.width].inner :rptr, :wptr
+    # The read and write command signals.
+    inner :rcmd, :wcmd
+    # The read and write ack signals.
+    inner :rack, :wack
+    # The ack check deactivator (for synchron accesses).
+    inner :hrack, :hwack
+    # The read/write data registers.
+    typ.inner :rdata, :wdata
+
+    # The process handling the decoupled access to the buffer.
+    par(clk.posedge) do
+        # rack <= 0
+        # wack <= 0
+        hif (~rcmd) { rack <= 0 }
+        hif (~wcmd) { wack <= 0 }
+        hif(rst) { rptr <= 0; wptr <= 0 }
+        hif(rcmd & (hrack|~rack) & (rptr != wptr)) do
+            rptr <= (rptr + 1) % depth
+            rack <= 1
+        end
+        hif(wcmd & (hwack|~wack) & (((wptr+1) % depth) != rptr)) do
+            buffer[wptr] <= wdata
+            # buffer[1] <= wdata
+            wptr <= (wptr + 1) % depth
+            wack <= 1
+        end
+    end
+    par { rdata <= buffer[rptr] }
+
+    reader_output :rcmd, :rptr, :hrack
+    reader_input :rdata, :rack
+
+    # 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
+                rcmd <= 0
+                hrack <= 1
+            end
+            seq do
+                rptr <= (rptr + 1) % depth
+                target <= rdata
+                blk.call if blk
+            end
+        else
+            # Different clk event, perform a decoupled access.
+            top_block.unshift do
+                rcmd <= 0
+                hrack <= 0
+            end
+            seq do
+                hif(rack) do
+                    blk.call if blk
+                end
+                helse do
+                    rcmd <= 1 
+                    target <= rdata
+                end
+            end
+        end
+    end
+
+    writer_output :wcmd, :wdata, :hwack
+    writer_input :wack
+
+    # 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
+                wcmd <= 0
+                hwack <= 1
+            end
+            wcmd <= 1
+            wdata <= target
+            blk.call if blk
+        else
+            # Different clk event, asynchrone case: perform a decoupled access.
+            top_block.unshift do
+                wcmd <= 0
+                hwack <= 0
+            end
+            seq do
+                hif(wack) do
+                    blk.call if blk
+                end
+                helse { wcmd <= 1 }
+                wdata <= target
+            end
+        end
+    end
+end
+
+
+# Channel describing a register of +typ+ type.
+channel(:register) do |typ|
+    # The register.
+    typ.inner :buffer
+
+    reader_input :buffer
+
+    # The read primitive.
+    reader do |blk,target|
+        target <= buffer
+        blk.call if blk
+    end
+
+    writer_output :buffer
+
+    # The read primitive.
+    writer do |blk,target|
+        buffer <= target
+        blk.call if blk
+    end
+end
+
+
+
+# Channel describing a handshake for transmitting data of +typ+ type, reset
+# by +rst+
+channel(:handshake) do |typ|
+    # The data signal.
+    typ.inner :data
+    # The request and acknowledge.
+    typ.inner :req, :ack
+
+    reader_input :ack, :data
+    reader_output :req
+
+    # The read primitive.
+    reader do |blk,target|
+        top_block.unshift do
+            req <= 0
+        end
+        hif(ack == 0) do
+            req <= 1
+        end
+        helsif(req) do
+            target <= data
+            req <= 0
+            blk.call if blk
+        end
+    end
+
+    writer_input :req
+    writer_output :ack, :data
+
+    # The read primitive.
+    writer do |blk,target|
+        top_block.unshift do
+            ack <= 0
+        end
+        hif(req) do
+            hif(~ack) do
+                data <= target
+                blk.call if blk
+            end
+            ack <= 1
+        end
+    end
+end
+
+
+# $mode = :sync
+# $mode = :nsync
+# $mode = :async
+# $mode = :proco  # Producter / Consummer
+# $channel = :register
+# $channel = :handshake
+# $channel = :queue
+
+# The configuration scenarii
+$scenarii = [ [:sync,  :register], [:sync,  :handshake], [:sync,  :queue],
+              [:nsync, :register], [:nsync, :handshake], [:nsync, :queue],
+              [:async, :register], [:async, :handshake], [:async, :queue],
+              [:proco, :register], [:proco, :handshake], [:proco, :queue] ]
+
+# The configuration
+$mode, $channel = $scenarii[11]
+
+# Testing the queue channel.
+system :test_queue do
+    inner :clk, :rst, :clk2, :clk3
+    [8].inner :idata, :odata
+    [4].inner :counter
+
+    if $channel == :register then
+        register(bit[8]).(:my_ch)
+    elsif $channel == :handshake then
+        handshake(bit[8],rst).(:my_ch)
+    elsif $channel == :queue then
+        queue(bit[8],5,clk,rst).(:my_ch)
+    end
+
+    ev = $mode == :sync ? clk.posedge : 
+         $mode == :nsync ? clk.negedge : clk2.posedge
+
+    if $mode != :proco then
+        # Sync/Neg sync and async tests mode
+        par(ev) do
+            hif(rst) do
+                counter <= 0
+                idata <= 0
+                odata <= 0
+            end
+            helse do
+                hif (counter < 4) do
+                    my_ch.write(idata) do
+                        idata <= idata + 1
+                        counter <= counter + 1
+                    end
+                end
+                helsif ((counter > 10) & (counter < 15)) do
+                    my_ch.read(odata) do
+                        idata <= idata - odata
+                        counter <= counter + 1
+                    end
+                end
+                helse do
+                    counter <= counter + 1
+                end
+            end
+        end
+    else
+        # Producter/consumer mode
+        # Producer
+        par(clk2.posedge) do
+            hif(rst) do
+                idata <= 0
+            end
+            helse do
+                my_ch.write(idata) do
+                    idata <= idata + 1
+                end
+            end
+        end
+        # Consumer
+        par(clk3.posedge) do
+            hif(rst) do
+                counter <= 0
+            end
+            helse do
+                my_ch.read(odata) do
+                    counter <= counter + 1
+                end
+            end
+        end
+    end
+
+    timed do
+        clk <= 0
+        clk2 <= 0
+        clk3 <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !3.ns
+        clk2 <= 1
+        !3.ns
+        clk3 <= 0
+        !4.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !3.ns
+        clk2 <= 0
+        !3.ns
+        clk3 <= 1
+        !2.ns
+        rst <= 0
+        !2.ns
+        64.times do
+            clk <= 1
+            !10.ns
+            clk <= 0
+            !3.ns
+            clk2 <= ~clk2
+            !3.ns
+            hif (clk2 == 0) { clk3 <= ~ clk3 }
+            !4.ns
+        end
+    end
+end
+

data/lib/HDLRuby/hdrcc.rb

@@ -269,6 +269,9 @@ $optparse = OptionParser.new do |opts|
         $options[:multiple] = v
         $options[:sim] = v
     end
+    opts.on("--vcd", "The simulator will generate a vcd file") do |v|
+        $options[:vcd] = v
+    end
     opts.on("-v", "--verilog","Output in Verlog HDL format") do |v|
         $options[:verilog] = v
         $options[:multiple] = v
@@ -515,9 +518,15 @@ elsif $options[:clang] then
         # Generate the code for it.
         $main = File.open($name,"w")
 
+        # Select the vizualizer depending on the options.
+        init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
+                                           "init_default_visualizer"
+
         # Generate the code of the main function.
         # HDLRuby start code
-        $main << HDLRuby::Low::Low2C.main($top_system,
+        $main << HDLRuby::Low::Low2C.main("hruby_simulator",
+                                         init_visualizer,
+                                         $top_system,
                                          $top_system.each_systemT_deep.to_a.reverse,$hnames)
         $main.close