HDLRuby 2.7.1 → 2.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 4ca0e2aba73e7ceb55e145dd22286398ae7605d04d46212f870ba895d3f983d9
4
- data.tar.gz: 434ae3eb4d974a00ea1510b0e23d66dc51d5f6ac5ef0e4b79af288b5d05f6985
3
+ metadata.gz: 90d139cd510b6600a32249a2e27969f6c415a49d9b26ba51ed84d20dcc82f2ba
4
+ data.tar.gz: b064d08cfbd46ae6fa4dffc7536a2dece4aed9c1c7588118502df79dd288c5bb
5
5
  SHA512:
6
- metadata.gz: d097cbd7793ef60fd94c70f7a8acb2e49b13915fd799b7618523c1ba57300195a9ca8a7a61d6e50a8f89779ce6bf64a484bdf5267de93b3159f61186f40e6a82
7
- data.tar.gz: 27db7c7e988abe14635a515572c2774e8a76d44e7f0e85bfb6ec8b1c9dfed85f61ef49e1f597c59fc9b725b6aacc53b976f73a3b49f816820c5ca9691e253559
6
+ metadata.gz: 40ced20f6723ff46f4c02a033c1d194e5ce267c75e7f2c22e6c70dd6f51ae9b530ebdc7dc7150970f3fefbf2ec4663c965a3a3fddf1c1b2369d6dac42317ba0c
7
+ data.tar.gz: 7782898ea6de9b5e42015f84dc56929ecd038baf42337c1f69f96bc644f0692ddd00ada0db0f9910b8ae7d93d2516ed4b3819c9f8735268d0a952f72b56bb37e
@@ -5,3 +5,25 @@ system :adder do |w|
5
5
 
6
6
  s <= x.as(bit[w+1]) + y
7
7
  end
8
+
9
+
10
+ # Testing the generic adder.
11
+ system :adder_bench do
12
+ width = 4
13
+ [width].inner :x,:y
14
+ [width+1].inner :z
15
+
16
+ adder(width).(:my_adder).(x,y,z)
17
+
18
+ timed do
19
+ x <= 0
20
+ y <= 0
21
+ !10.ns
22
+ x <= 1
23
+ !10.ns
24
+ y <= 1
25
+ !10.ns
26
+ x <= 15
27
+ !10.ns
28
+ end
29
+ end
@@ -0,0 +1,40 @@
1
+ # A simple generic adder
2
+ system :adder do |w|
3
+ [(w-1)..0].input :i,:j
4
+ [w..0].output :k
5
+
6
+ k <= i.as(bit[w+1]) + j
7
+ end
8
+
9
+ # A module embedding two generic adders.
10
+ system :two_adders do |w|
11
+ [w*2].input :x, :y
12
+ [(w+1)*2].output :z
13
+
14
+ adder(w).(:adderI0).(x[(w-1)..0],y[(w-1)..0],z[w..0])
15
+ adder(w).(:adderI1).(x[(w*2-1)..w],y[(w*2-1)..w],z[(w*2+1)..(w+1)])
16
+ end
17
+
18
+
19
+ # Testing the generic adder.
20
+ system :adder_bench do
21
+ width = 4
22
+ [width*2].inner :a,:b
23
+ [(width+1)*2].inner :c
24
+
25
+ two_adders(width).(:my_adders).(a,b,c)
26
+
27
+ timed do
28
+ a <= 0
29
+ b <= 0
30
+ !10.ns
31
+ a <= 1
32
+ !10.ns
33
+ b <= 1
34
+ !10.ns
35
+ a <= 255
36
+ !10.ns
37
+ b <= 128
38
+ !10.ns
39
+ end
40
+ end
@@ -1,30 +1,35 @@
1
1
  # Test the comparison operators.
2
2
 
3
- # A benchmark for the case statement.
3
+ # A benchmark for the if statement.
4
4
  system :if_bench do
5
- [8].inner :x, :y
5
+ [8].inner :x, :z
6
6
 
7
7
  par do
8
8
  hcase(x)
9
- hwhen(0) { y <= _10000000 }
10
- hwhen(1) { y <= _10000001 }
11
- hwhen(2) { y <= _10000010 }
12
- hwhen(3) { y <= _10000011 }
13
- helse { y <= _00000000 }
9
+ hwhen(0) { z <= 0 }
10
+ hwhen(1) { z <= 1 }
11
+ hwhen(2) { z <= 4 }
12
+ hwhen(3) { z <= 9 }
13
+ hwhen(4) { z <= 16 }
14
+ hwhen(5) { z <= 25 }
15
+ hwhen(6) { z <= 36 }
16
+ hwhen(7) { z <= 49 }
17
+ hwhen(8) { z <= 64 }
18
+ hwhen(9) { z <= 81 }
19
+ hwhen(10) { z <= 100 }
20
+ hwhen(11) { z <= 121 }
21
+ hwhen(12) { z <= 144 }
22
+ hwhen(13) { z <= 169 }
23
+ hwhen(14) { z <= 196 }
24
+ hwhen(15) { z <= 225 }
25
+ helse { z <= _zzzzzzzz }
14
26
  end
15
27
 
16
28
  timed do
17
- x <= 0
18
- !10.ns
19
- x <= 1
20
- !10.ns
21
- x <= 2
22
- !10.ns
23
- x <= 3
24
- !10.ns
25
- x <= 4
26
- !10.ns
27
- x <= 5
28
29
  !10.ns
30
+ 20.times do |i|
31
+ x <= i
32
+ !10.ns
33
+ end
29
34
  end
30
35
  end
@@ -6,7 +6,7 @@
6
6
  3.times do |i|
7
7
 
8
8
  # A simple D-FF
9
- system:"dff#{i}" do
9
+ system :"dff#{i}" do
10
10
  input :clk, :rst, :d
11
11
  output :q, :qb
12
12
 
@@ -0,0 +1,61 @@
1
+ # Check of various par and seq.
2
+
3
+ # A benchmark for the dff.
4
+ system :parseq_bench do
5
+ [4].inner :x0, :x1, :x2, :x3
6
+ [4].inner :y0, :y1, :y2, :y3
7
+ [4].inner :z00, :z01
8
+ [4].inner :z10, :z11
9
+ [4].inner :z20, :z21
10
+ [4].inner :z30, :z31
11
+ [4].inner :u0, :u1, :u2, :u3
12
+ bit[4][-16].constant mem: 16.times.to_a
13
+
14
+ par(x0) do
15
+ z00 <= x0 + y0
16
+ z01 <= z00 + 1
17
+ u0 <= mem[z00]
18
+ end
19
+
20
+ seq(y1) do
21
+ z10 <= x1 + y1
22
+ z11 <= z10 + 1
23
+ u1 <= mem[z10]
24
+ end
25
+
26
+ seq(x2,y2) do
27
+ z20 <= x2 + y2
28
+ z21 <= z20 + 1
29
+ u2 <= mem[z20]
30
+ end
31
+
32
+ par do
33
+ bit[4].constant inc: 1
34
+ z30 <= x3 + y3
35
+ z31 <= z30 + inc
36
+ u3 <= mem[z30]
37
+ end
38
+
39
+
40
+ timed do
41
+ x0 <= 1
42
+ x1 <= 1
43
+ x2 <= 1
44
+ x3 <= 1
45
+ !10.ns
46
+ y0 <= 2
47
+ y1 <= 2
48
+ y2 <= 2
49
+ y3 <= 2
50
+ !10.ns
51
+ x0 <= 3
52
+ x1 <= 3
53
+ x2 <= 3
54
+ x3 <= 3
55
+ y0 <= 4
56
+ y1 <= 4
57
+ y2 <= 4
58
+ y3 <= 4
59
+ !10.ns
60
+ end
61
+ end
@@ -3,13 +3,16 @@
3
3
  # A benchmark for the index access..
4
4
  system :if_bench do
5
5
  [8].inner :x
6
- [2].inner :r0,:r1,:r2,:r3
6
+ [2].inner :r0,:r1,:r2,:r3, :r4
7
+ inner :r5
7
8
 
8
9
  par do
9
10
  r0 <= x[1..0]
10
11
  r1 <= x[3..2]
11
12
  r2 <= x[5..4]
12
13
  r3 <= x[7..6]
14
+ r4 <= x[-1..-2]
15
+ r5 <= x[-1]
13
16
  end
14
17
 
15
18
  timed do
@@ -0,0 +1,27 @@
1
+ # Rom access generator, def case.
2
+ def rom_gen(addr,&func)
3
+ bit[8][-8].constant tbl? => 8.times.map {|i| func.(i).to_i }
4
+ tbl![addr]
5
+ end
6
+
7
+
8
+
9
+ system :test_rom do
10
+ [2..0].inner :addr
11
+ [7..0].inner :data0, :data1, :data2, :data3
12
+
13
+ data0 <= rom_gen(addr) { |i| i*i }
14
+ data1 <= rom_gen(addr) { |i| i*i }
15
+
16
+ par do
17
+ data2 <= rom_gen(addr) { |i| i*i }
18
+ data3 <= rom_gen(addr) { |i| i*i }
19
+ end
20
+
21
+ timed do
22
+ 8.times do |i|
23
+ addr <= i
24
+ !10.ns
25
+ end
26
+ end
27
+ end
@@ -0,0 +1,128 @@
1
+ require 'std/channel.rb'
2
+ require 'std/hruby_unit.rb'
3
+
4
+ include HDLRuby::High::Std
5
+
6
+ # A clocked handshake channel for testing purpuse.
7
+ channel(:handshake) do |typ,clk|
8
+ inner has_data: 0
9
+ inner :set_data
10
+ inner :get_data
11
+ typ.inner :data, :data_val
12
+
13
+ writer_input :has_data
14
+ writer_output :set_data, :data_val
15
+ reader_input :has_data, :data
16
+ reader_output :get_data
17
+
18
+ par(clk.negedge) do
19
+ hif(set_data) do
20
+ data <= data_val
21
+ has_data <= 1
22
+ end
23
+ helsif(get_data) do
24
+ has_data <= 0
25
+ end
26
+ end
27
+
28
+ # The writer.
29
+ writer do |blk,target|
30
+ hif(~has_data) do
31
+ set_data <= 1
32
+ data_val <= target
33
+ blk.call if blk
34
+ end
35
+ helse { set_data <= 0 }
36
+ end
37
+
38
+ # The reader
39
+ reader do |blk,target|
40
+ hif(has_data) do
41
+ target <= data
42
+ get_data <= 1
43
+ blk.call if blk
44
+ end
45
+ helse { get_data <= 0 }
46
+ end
47
+ end
48
+
49
+
50
+
51
+ # A system writing indefinitely to a channel.
52
+ # Checking usage of channel without declaring a port.
53
+ system :producer8 do |channel|
54
+ # Inputs of the producer: clock and reset.
55
+ input :clk, :rst
56
+ # Inner 8-bit counter for generating values.
57
+ [8].inner :counter
58
+
59
+ # The value production process
60
+ par(clk.posedge) do
61
+ hif(rst) { counter <= 0 }
62
+ helse do
63
+ channel.write(counter) { counter <= counter + 1 }
64
+ end
65
+ end
66
+ end
67
+
68
+ # A system reading indefinitely from a channel.
69
+ system :consummer8 do |channel|
70
+ # Input of the consummer: a clock is enough.
71
+ input :clk
72
+ # # Instantiate the channel ports
73
+ # channel.input :ch
74
+ # Inner buffer for storing the cunsummed value.
75
+ [8].inner :buf
76
+
77
+ # The value consumption process
78
+ par(clk.posedge) do
79
+ channel.read(buf)
80
+ end
81
+ end
82
+
83
+
84
+ # A system testing the handshaker.
85
+ Unit.system :hs_test do
86
+ inner :clk,:rst
87
+
88
+ # Declares two handshakers
89
+ handshake(bit[8],clk).(:hs)
90
+
91
+ # For the first handshake
92
+
93
+ # Instantiate the producer.
94
+ producer8(hs).(:producerI).(clk,rst)
95
+
96
+ # Instantiate the consummer.
97
+ consummer8(hs).(:consummerI).(clk)
98
+
99
+ test do
100
+ clk <= 0
101
+ rst <= 0
102
+ !10.ns
103
+ clk <= 1
104
+ !10.ns
105
+ clk <= 0
106
+ rst <= 1
107
+ !10.ns
108
+ clk <= 1
109
+ !10.ns
110
+ clk <= 0
111
+ !10.ns
112
+ !10.ns
113
+ clk <= 1
114
+ !10.ns
115
+ clk <= 0
116
+ rst <= 0
117
+ !10.ns
118
+ clk <= 1
119
+ !10.ns
120
+ 10.times do
121
+ clk <= 0
122
+ !10.ns
123
+ clk <= 1
124
+ !10.ns
125
+ end
126
+ end
127
+
128
+ end
@@ -0,0 +1,29 @@
1
+ # A test of def.
2
+ def lut84(content,addr)
3
+ bit[8][-4].inner tbl? => content.to_a
4
+ tbl![addr]
5
+ end
6
+
7
+
8
+ # A benchmark for testing the initialization of signals.
9
+ system :def_bench do
10
+
11
+ [2].inner :addr
12
+ [8].inner :val0, :val1
13
+
14
+ par do
15
+ val0 <= lut84([0,1,4,9],addr)
16
+ val1 <= lut84([0,1,4,9],3-addr)
17
+ end
18
+
19
+ timed do
20
+ addr <= 0
21
+ !10.ns
22
+ addr <= 1
23
+ !10.ns
24
+ addr <= 2
25
+ !10.ns
26
+ addr <= 3
27
+ !10.ns
28
+ end
29
+ end
@@ -0,0 +1,18 @@
1
+
2
+ # A benchmark for testing the initialization of signals.
3
+ system :with_init do
4
+ [8].constant cst0: 127
5
+ constant cst1: _1
6
+ [8].inner sig0: _10000000
7
+ inner sig1: _1
8
+ [8].inner :sig2
9
+
10
+ timed do
11
+ !10.ns
12
+ sig2 <= cst0 + cst1
13
+ sig0 <= sig0 + sig1
14
+ !10.ns
15
+ sig2 <= sig2 + sig1
16
+ !10.ns
17
+ end
18
+ end
@@ -0,0 +1,42 @@
1
+
2
+
3
+
4
+ # A benchmark for testing the instantiations.
5
+
6
+ system :adder do |typ|
7
+ typ.input :x, :y
8
+ typ.output :z
9
+
10
+ z <= x + y
11
+ end
12
+
13
+ system :truc do
14
+ [8].input :u, :v
15
+ [8].output :q
16
+ end
17
+
18
+
19
+
20
+ system :with_instance do
21
+
22
+ [8].inner :x0, :y0, :z0, :x1, :y1, :z1
23
+
24
+ truc(:montruc).(x0,y0,z0)
25
+
26
+ adder(bit[8]).(:adderI0).(x0,y0,z0)
27
+ adder(bit[8]).(:adderI1).(x: x1, y: y1, z: z1)
28
+
29
+ timed do
30
+ !10.ns
31
+ x0 <= 0
32
+ y0 <= 0
33
+ x1 <= 1
34
+ y1 <= 1
35
+ !10.ns
36
+ x0 <= 1
37
+ y0 <= 1
38
+ x1 <= 2
39
+ y1 <= 2
40
+ !10.ns
41
+ end
42
+ end
@@ -4,60 +4,16 @@ include HDLRuby::High::Std
4
4
 
5
5
 
6
6
 
7
-
8
- # Implementation of a vivado partial reconfiguration system.
9
- reconf(:vivado_reconf) do |clk,rst|
10
-
11
- # Get access to the interface of the reconfigurable component.
12
- inputs = each_input
13
- outputs = each_output
14
- inouts = each_inout
15
-
16
- # Create the main system with the interface and a channel for
17
- # handling the reconfiguration.
18
- main = system do
19
- # Declares the inputs.
20
- inputs.each do |i|
21
- i.type.input(i.name)
22
- end
23
- # Declares the outputs.
24
- outputs.each do |o|
25
- o.type.output(o.name)
26
- end
27
- # Declares the inouts.
28
- inouts.each do |io|
29
- io.type.inout(io.name)
30
- end
31
- # An that's all: in vivado the main system is to be a black-box.
32
- end
33
-
34
- # And set it as the main system.
35
- set_main(main)
36
-
37
- # The switching circuit.
38
- # reconfer = vivado_reconfigurer :do_reconf # Will be that later
39
- # reconfer.clk <= clk
40
- # reconfer.rst <= rst
41
- reconfer = proc do |idx|
42
- puts "Instantiating reconfiguration circuits with #{idx}"
43
- end
44
-
45
- # Defines the reconfiguring procedure: switch to system idx.
46
- switcher do |idx,ruby_block|
47
- reconfer.call(idx)
48
- ruby_block.call
49
- end
50
-
51
- end
52
-
53
-
54
- # Some system that can be used for recponfiguration.
7
+ # Some system that can be used for reconfiguration.
55
8
  system :sys0 do
56
9
  input :clk,:rst
57
10
  input :d
58
11
  output :q
59
12
 
60
- q <= d
13
+ par(clk.posedge) do
14
+ hprint("sys0\n")
15
+ q <= d & ~rst
16
+ end
61
17
  end
62
18
 
63
19
  system :sys1 do
@@ -65,7 +21,10 @@ system :sys1 do
65
21
  input :d
66
22
  output :q
67
23
 
68
- (q <= d).at(clk.posedge)
24
+ par(clk.posedge, rst.posedge) do
25
+ hprint("sys1\n")
26
+ q <= d & ~rst
27
+ end
69
28
  end
70
29
 
71
30
  system :sys2 do
@@ -73,7 +32,10 @@ system :sys2 do
73
32
  input :d
74
33
  output :q
75
34
 
76
- (q <= d & ~rst).at(clk.posedge)
35
+ par(clk.posedge, rst.negedge) do
36
+ hprint("sys2\n")
37
+ q <= d & ~rst
38
+ end
77
39
  end
78
40
 
79
41
  # A system with a reconfifurable part.
@@ -81,23 +43,69 @@ system :with_reconf do
81
43
  input :clk,:rst
82
44
  input :d
83
45
  output :q
84
- [2].input :conf # The configuration number
85
-
86
- inner :wait_reconf
87
46
 
88
- # Create a reconfigurable component.
89
- vivado_reconf(clk,rst).(:my_reconf)
90
- # It is to be reconfigured to sys0, sys1 or sys2
91
- my_reconf.(sys0, sys1, sys2)
92
-
93
- # Connect the reconfigurable instance.
94
- my_reconf.instance.(clk,rst,d,q)
95
-
96
- par(clk.posedge) do
97
- hif(rst) { wait_reconf <= 0 }
98
- helsif(conf != 0 && my_reconf.index != conf && wait_reconf == 0) do
99
- wait_reconf <= 1
100
- my_reconf.switch(conf) { wait_reconf <= 0 }
47
+ # Instantiate the default configuration.
48
+ sys0(:my_dff).(clk,rst,d,q)
49
+
50
+ # Adds the additional configuration.
51
+ my_dff.choice(conf1: sys1, conf2: sys2)
52
+
53
+ timed do
54
+ clk <= 0
55
+ rst <= 0
56
+ d <= 0
57
+ !10.ns
58
+ clk <= 1
59
+ !10.ns
60
+ clk <= 0
61
+ rst <= 1
62
+ !10.ns
63
+ clk <= 1
64
+ !10.ns
65
+ clk <= 0
66
+ rst <= 0
67
+ !10.ns
68
+ 3.times do |i|
69
+ clk <= 1
70
+ !10.ns
71
+ clk <= 0
72
+ d <= 1
73
+ !10.ns
74
+ clk <= 1
75
+ !10.ns
76
+ clk <= 0
77
+ d <= 0
78
+ !10.ns
79
+ clk <= 1
80
+ my_dff.configure((i+1)%3)
81
+ !10.ns
82
+ clk <= 0
83
+ !10.ns
101
84
  end
85
+ clk <= 1
86
+ !10.ns
87
+ clk <= 0
88
+ d <= 1
89
+ !10.ns
90
+ clk <= 1
91
+ my_dff.configure(:conf1)
92
+ !10.ns
93
+ clk <= 0
94
+ d <= 0
95
+ !10.ns
96
+ clk <= 1
97
+ my_dff.configure(:conf2)
98
+ !10.ns
99
+ clk <= 0
100
+ d <= 1
101
+ !10.ns
102
+ clk <= 1
103
+ my_dff.configure(:my_dff)
104
+ !10.ns
105
+ clk <= 0
106
+ d <= 0
107
+ !10.ns
108
+ clk <= 1
109
+ !10.ns
102
110
  end
103
111
  end
@@ -0,0 +1,32 @@
1
+
2
+ # A benchmark for testing the terminate statement.
3
+ system :with_terminate do
4
+ [8].constant cst0: 127
5
+ constant cst1: _1
6
+ [8].inner sig0: _10000000
7
+ inner sig1: _1
8
+ [8].inner :sig2
9
+ [8].inner count: 0
10
+
11
+ timed do
12
+ !20.ns
13
+ 100.times do
14
+ count <= count + 1
15
+ !20.ns
16
+ end
17
+ end
18
+
19
+ timed do
20
+ !10.ns
21
+ sig2 <= cst0 + cst1
22
+ sig0 <= sig0 + sig1
23
+ !10.ns
24
+ sig2 <= sig2 + sig1
25
+ !10.ns
26
+ terminate
27
+ sig0 <= sig0 + sig0
28
+ !10.ns
29
+ sig0 <= sig0 + sig0
30
+ !10.ns
31
+ end
32
+ end
@@ -27,6 +27,9 @@ system :with_values do
27
27
  v64 <= 1
28
28
  v96 <= 1
29
29
  !10.ns
30
+ v1 <= _1010[2]
31
+ v8 <= _uhFF00[12..4]
32
+ !10.ns
30
33
  v8 <= 128
31
34
  v16 <= 128
32
35
  v32 <= 128