HDLRuby 2.0.8

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "HDLRuby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/hdrcc

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+require 'HDLRuby/hdrcc.rb'

data/lib/HDLRuby/alcc.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/ruby
+
+require 'fileutils'
+
+
+##
+# Front-end to the Alliance tool chain for hdrcc vhdl results
+##############################################################
+
+if $*.include?("--clean") then
+    # Clean mode.
+    `rm *.vbe *.vst *.xsc *.ap`
+    exit
+end
+
+######################################################
+# Initialization phase
+#
+# Process the options.
+# For now there should only be the name of the main file.
+$input = $*[0]
+
+# Get the extension name, the base name and the path from the main file.
+$extname  = File.extname($input)
+$basename = File.basename($input,$extname)
+$path     = File.dirname($input)
+$fullname = $basename + $extname
+
+# Go the the target directory.
+Dir.chdir($path)
+
+# Gather the files other than the main to treat.
+$subfiles = Dir.foreach("./").select do |name|
+    File.extname(name) == $extname && name != $fullname
+end
+# And the all files to treat.
+$allfiles = [$fullname] + $subfiles
+
+# Generate the base names for the sub files.
+# $subbases = $subfiles.map {|file|  File.basename(file,$extname) }
+# $basename_model = $basename + "_model"
+# $subbases =[ $basename_model ] + $subbases
+$allbases = $allfiles.map {|file|  File.basename(file,$extname) }
+
+######################################################
+# Compiling steps
+
+# Conversion to alliance format.
+$allfiles.each do |file|
+    cmd = "vasy -Vaop -I vhd #{file}"
+    puts cmd
+    `#{cmd}`
+end
+
+# # Check if there is a model have been generated.
+# unless File.file?($basename_model + ".vbe") then
+#     # No model, single file case.
+#     $subbases = [ $basename ]
+# end
+
+# puts "$subbases=#{$subbases}"
+
+# Boolean minimisation.
+# $subbases.each do |base|
+$allbases.each do |base|
+    if File.file?("#{base}.vbe") then
+        cmd = "boom -l 3 -d 50 #{base}.vbe"
+        puts cmd
+        `#{cmd}`
+    end
+    if File.file?("#{base}_model.vbe") then
+        cmd = "boom -l 3 -d 50 #{base}_model.vbe"
+        puts cmd
+        `#{cmd}`
+    end
+end
+
+# Structureal description generation.
+# $subbases.each do |base|
+$allbases.each do |base|
+    if File.file?("#{base}.vbe") then
+        cmd = "boog #{base}_o #{base} -x 1 -m 2"
+        puts cmd
+        `#{cmd}`
+    end
+    if File.file?("#{base}_model.vbe") then
+        cmd = "boog #{base}_model_o #{base}_model -x 1 -m 2"
+        puts cmd
+        `#{cmd}`
+    end
+end
+
+# Flattening and global optimization.
+cmd = "loon #{$basename} #{$basename}_l -x 0 -m 0"
+puts cmd
+`#{cmd}`
+
+# Placement.
+cmd = "ocp #{$basename}_l #{$basename}_p"
+puts cmd
+`#{cmd}`
+
+# Route.
+cmd = "nero -V -G -6 -p #{$basename}_p #{$basename}_l #{$basename}_r"
+puts cmd
+`#{cmd}`
+
+# Technology mapping.
+cmd = "s2r -v #{$basename}_r #{$basename}_core"
+puts cmd
+`#{cmd}`
+
+
+## Other tools
+#  
+#  Simulation:
+#  `asimut #{$basename}_l #{$basename}_in #{$basename}_out`
+#
+#  View simulation result:
+#  `xpat -l #{basename}_out`
+#
+#  View P&R result:
+#  `graal`
+#
+#  Extract netlist:
+#  `cougar #{$basename}_r #{$basename}_c`
+#
+#  Check P&R result:
+#  `lvx vst al #{$basename} #{$basename}_c` or
+#  `lvx vst vst #{$basename} #{$basename}_c`
+#
+#  DRC check:
+#  `druc #{$basename}_r`
+#
+#  View techno mapping result:
+#  `dreal -l #{$basename}_core`
+#

data/lib/HDLRuby/backend/hruby_allocator.rb

@@ -0,0 +1,69 @@
+require "HDLRuby/hruby_error"
+
+
+
+##
+# Adds methods for allocating addresses to signals in Code objects.
+#
+########################################################################
+module HDLRuby::Low
+
+    ## An allocator.
+    class Allocator
+
+        # The space range for the allocation.
+        attr_reader :range
+
+        # The word size.
+        attr_reader :word
+
+        ## Creates a new allocator within +range+ memory space whose word
+        #  size is +word+.
+        def initialize(range, word = 8)
+            # Check and set the range.
+            first = range.first.to_i
+            last = range.last.to_i
+            @range = first < last ? first..last : last..first
+            # Check and set the word size.
+            @word = word.to_i
+            # Initialize the allocation counter.
+            @head = first
+            # Initialize the allocation table.
+            @table = {}
+        end
+
+        ## Allocates space for +signal+.
+        #  NOTE: if the signal is already allocated, returns the previous
+        #        allocation result.
+        def allocate(signal)
+            # Has the signal been already allocated?
+            if @table.key?(signal) then
+                # Yes return the allocation result.
+                return @table[signal]
+            end
+            # Get the size to allocate in word.
+            size = signal.type.width / @word
+            size += 1 unless signal.type.width % word == 0
+            # Is there any room left?
+            if @head + size > @range.last then
+                raise AnyError, "Address range overflow."
+            end
+            # Ok, performs the allocation.
+            res = @head
+            @head += size
+            @table[signal] = res
+            return res
+        end
+
+        ## Get the address of +signal+ if allocated.
+        def get(signal)
+            return @table[signal]
+        end
+
+        ## Iterate over the allocated signals and their corresponding address.
+        def each
+            @table.each
+        end
+    end
+
+end

data/lib/HDLRuby/backend/hruby_c_allocator.rb

@@ -0,0 +1,76 @@
+require "HDLRuby/hruby_error"
+require "HDLRuby/hruby_low_resolve"
+require "HDLRuby/backend/hruby_allocator"
+
+
+
+##
+# Adds methods for allocating addresses to signals in Code objects and
+# integrate the result into C code.
+#
+########################################################################
+module HDLRuby::Low
+
+    ## Extends the SystemT class with support for C allocation of signals.
+    class SystemT
+
+        ## Allocates signals within C code using +allocator+.
+        def c_code_allocate(allocator)
+            self.scope.c_code_allocate(allocator)
+        end
+    end
+
+
+    ## Extends the scope class with support for C allocation of signals.
+    class Scope
+
+        ## Allocates signals within C code using +allocator+.
+        def c_code_allocate(allocator)
+            # Interrate on the sub scopes.
+            self.each_scope { |scope| scope.c_code_allocate(allocator) }
+            # Ally thr allocator on the codes.
+            self.each_code  { |code|  code.c_code_allocate(allocator) }
+        end
+    end
+
+
+    ## Extends the chunk class with support for self modification with
+    #  allocation.
+    #  NOTE: only work if the chunk is in C language.
+    class Chunk
+
+        ## Allocates signal within C code using +allocator+ and self-modify
+        #  the code correspondingly.
+        #  NOTE: non-C chunks are ignored.
+        def c_code_allocate!(allocator)
+            # Checks the chunk is actually C.
+            return self unless self.name == :c
+            # Process each lump.
+            @lumps.map! do |lump|
+                lump_r = lump.resolve if lump.respond_to?(:resolve)
+                if lump_r.is_a?(SignalI) then
+                    # The lump is a signal, performs the allocation and
+                    # change it to an address access.
+                    "*(0x#{allocator.allocate(lump_r).to_s(16)})"
+                else
+                    lump
+                end
+            end
+            self
+        end
+    end
+
+
+    ## Extends the code class with support for C allocation of signals.
+    class Code
+
+        ## Allocates signals within C code using +allocator+.
+        def c_code_allocate(allocator)
+            # Apply the allocator on each C chunk.
+            self.each_chunk do |chunk|
+                chunk.c_code_allocate!(allocator) if chunk.name == :c
+            end
+        end
+    end
+
+end

data/lib/HDLRuby/hdr_samples/adder.rb

@@ -0,0 +1,7 @@
+# A simple 16-bit adder
+system :adder do
+    [15..0].input :x,:y
+    [16..0].output :s
+
+    s <= x + y
+end

data/lib/HDLRuby/hdr_samples/adder_assign_error.rb

@@ -0,0 +1,11 @@
+# A simple 16-bit adder
+system :adder do
+    [15..0].input :x,:y
+    [16..0].output :s
+
+    s <= x + y
+
+    s = "tot"
+
+    S = "TT"
+end

data/lib/HDLRuby/hdr_samples/adder_bench.rb

@@ -0,0 +1,27 @@
+# A simple 16-bit adder
+system :adder do
+    [15..0].input :x,:y
+    [16..0].output :s
+
+    s <= x + y
+end
+
+# A benchmark for the adder.
+system :adder_bench do
+    [15..0].inner :x,:y
+    [16..0].inner :s
+
+    adder(:my_adder).(x,y,s)
+
+    timed do
+        x <= 0
+        y <= 0
+        !10.ns
+        x <= 1
+        y <= _zzzzzzzzzzzzzzzz
+        !10.ns
+        x <= 2
+        y <= 1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/adder_gen.rb

@@ -0,0 +1,7 @@
+# A simple generic adder
+system :adder do |w|
+    [(w-1)..0].input :x,:y
+    [w..0].output :s
+
+    s <= x + y
+end

data/lib/HDLRuby/hdr_samples/adder_nodef_error.rb

@@ -0,0 +1,7 @@
+# A simple 16-bit adder
+system :adder do
+    [15..0].input :x,:y
+    [16..0].output :u
+
+    s <= x + y
+end

data/lib/HDLRuby/hdr_samples/addsub.rb

@@ -0,0 +1,19 @@
+# An adder-suber
+system :addsub do
+    input  :opr
+    [15..0].input :x,:y
+    [16..0].output :s
+
+    # The only adder instance.
+    instance :add do
+        [15..0].input :x,:y
+        input :cin
+        [16..0].output :s
+
+        s <= x+y+cin
+    end
+
+    # Control part for choosing between add and sub.
+    hif(opr) { add.(x,~y,1,s) }
+    helse    { add.(x,y,0,s) }
+end

data/lib/HDLRuby/hdr_samples/addsubz.rb

@@ -0,0 +1,22 @@
+# An extended adder-suber
+system :addsubz do
+    [1..0].input  :opr
+    [15..0].input :x,:y
+    [16..0].output :s
+
+    # The only adder instance.
+    instance :add do
+        [15..0].input :x,:y
+        input :cin
+        [16..0].output :s
+        
+        s <= x+y+cin
+    end
+
+    # The control part for choosing between 0, add, sub and neg.
+    hcase(opr)
+    hwhen(0) { add.(0,0,0,s) }
+    hwhen(1) { add.(x,y,0,s) }
+    hwhen(2) { add.(x,~y,1,s) }
+    helse    { add.(0,~y,1,s) }
+end

data/lib/HDLRuby/hdr_samples/alu.rb

@@ -0,0 +1,47 @@
+# A simple ALU
+system :alu do
+    [4].input  :opr
+    [16].input :x,:y
+    [16].output :s
+    output :zf, :cf, :sf, :vf
+
+    # The only adder instance.
+    instance :add do
+        [16].input :x,:y
+        input :cin
+        [17].output :s
+        
+        s <= x+y+cin
+    end
+
+    # The control part for choosing between 0, add, sub and neg.
+    par do
+        # The main computation: s and cf
+        # Default connections
+        cf <= 0
+        vf <= 0
+        add.(0,0,0)
+        # Depending on the operator
+        hcase(opr)
+        hwhen(1) { s <= x }
+        hwhen(2) { s <= y }
+        hwhen(3) { add.(x ,y ,0,[cf,s])
+                   vf <= (~x[15] & ~y[15] & s[15]) | (x[15] & y[15] & ~s[15]) }
+        hwhen(4) { add.(x ,~y,1,[cf,s])
+                   vf <= (~x[15] & y[15] & s[15]) | (x[15] & ~y[15] & ~s[15]) }
+        hwhen(5) { add.(0 ,~y,1,[cf,s])
+                   vf <= (~y[15] & s[15]) }
+        hwhen(6) { add.(~x,0 ,1,[cf,s])
+                   vf <= (x[15] & ~s[15]) }
+        hwhen(7) { s <= x & y }
+        hwhen(8) { s <= x | y }
+        hwhen(9) { s <= x ^ y }
+        hwhen(10){ s <= ~x }
+        hwhen(11){ s <= ~y }
+        helse    { s <= 0 }
+
+        # The remaining flags.
+        zf <= (s == 0)
+        sf <= s[15]
+    end
+end

data/lib/HDLRuby/hdr_samples/calculator.rb

@@ -0,0 +1,48 @@
+require '../std/fsm.rb'
+
+include HDLRuby::High::Std
+
+# Implementation of an 8-bit calculator.
+system :calculator do
+    input :clk,:rst
+    [1..0].input :opr
+    [7..0].input :x, :y
+    [7..0].output :s
+    output :zf, :sf, :cf, :vf
+
+    [8..0].inner :tmp
+
+    def common
+        s   <= tmp[7..0]
+        zf  <= (s == 0)
+        sf  <= tmp[7]
+        cf  <= tmp[8]
+        vf  <= tmp[8] ^ tmp[7]
+        goto(:choice)
+    end
+
+    fsm(clk.posedge,rst) do
+        state(:zero) do
+            s <= 0;
+            zf <= 0;
+            sf <= 0;
+            cf <= 0;
+            vf <= 0;
+        end
+        state(:choice) do
+            goto(opr, :add,:sub,:neg, :zero)
+        end
+        state(:add) do
+            tmp <= x + y
+            common
+        end
+        state(:sub) do
+            tmp <= x - y
+            common
+        end
+        state(:neg) do
+            tmp <= -x
+            common
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/counter_bench.rb

@@ -0,0 +1,83 @@
+# A simple counter
+system :counter do
+    input  :clk, :rst
+    input :ctrl
+    [8].output :q
+    output :c
+
+    [8].inner :qq
+    inner :cc
+
+    instance :add do
+        [8].input :x,:y
+        [9].output :z
+
+        z <= x.as([9]) + y
+    end
+
+
+    par do
+        add.(q,0)
+        hif(rst) { [cc,qq] <= 0 }
+        helse do
+            add.(q,1,[cc,qq])
+            hif(ctrl == 1) { add.(q,-1,[cc,qq]) }
+        end
+    end
+
+    par(clk.posedge) do
+        q <= qq
+        c <= cc
+    end
+
+end
+
+
+# A benchmark for the counter.
+system :counter_bench do
+    inner :clk, :rst
+    inner :ctrl
+    [8].inner :q
+    inner :c
+
+    counter(:my_counter).(clk,rst,ctrl,q,c)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        ctrl <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        rst <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        10.times do
+            clk <= 0
+            rst <= 0
+            !10.ns
+            clk <= 1
+            rst <= 0
+            !10.ns
+        end
+        ctrl <= 1
+        20.times do
+            clk <= 0
+            rst <= 0
+            !10.ns
+            clk <= 1
+            rst <= 0
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/dff.rb

@@ -0,0 +1,9 @@
+# A simple D-FF
+system :dff do
+    input :clk, :rst, :d
+    output :q, :qb
+
+    qb <= ~q
+
+    par(clk.posedge) { q <= d & ~rst }
+end

data/lib/HDLRuby/hdr_samples/dff_bench.rb

@@ -0,0 +1,66 @@
+# A simple D-FF
+system :dff do
+    input  :d, :clk, :rst
+    output :q
+
+    (q <= d & ~rst).at(clk.posedge)
+end
+
+# A benchmark for the dff.
+system :dff_bench do
+    inner :d, :clk, :rst
+    inner :q
+
+    dff(:my_dff).(d,clk,rst,q)
+
+    timed do
+        clk <= 0
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 1
+        rst <= 1
+        d   <= _z
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 0
+        !10.ns
+        clk <= 0
+        rst <= 0
+        d   <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        d   <= 0
+        !10.ns
+    end
+end