bics/actlib_dataflow_neuro
22
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: bics:encoder_wip
Branches Tags
bics:dev bics:main bics:encoder_wip
bics:TexelTapeout
..
compare: bics:8060051da09b0842ed2f6935063d9aac32a70c0b
Branches Tags
bics:main bics:dev bics:encoder_wip
bics:TexelTapeout

2 Commits
encoder_wi ... 8060051da0

Author SHA1 Message Date
alexmadison
8060051da0 Merge branch 'dev' of ssh://git.web.rug.nl:222/bics/actlib_dataflow_neuro into dev 2022-03-02 09:48:11 +01:00
alexmadison
b456ea40fd changed delayprog to outin vs ya naming scheme 2022-03-02 09:48:05 +01:00
1 changed files with 5 additions and 121 deletions
Expand all files Collapse all files

126
dataflow_neuro/primitives.act
View File

@@ -507,122 +507,6 @@ namespace tmpl {
BUF_X1 reset_buf(.a=reset_B, .y=_reset_BX,.vdd=supply.vdd,.vss=supply.vss);
}
// A tree composed by arbiters. The first layer takes N signals
export template<pint N>
defproc arbiter_tree(a1of1 in[N]; a1of1 out; power supply)
{
bool tout;
{ N > 0 : "Invalid N, should be greater than 0" };
/* We calculate here how many arbiters we need to create for the full tree */
pint inputs_in_layer, end, elements_in_layer;
pint odd_element_idx = 0;
pint odd_element_flag = 0;
inputs_in_layer = 0;
end = N-1;
pint element_counter = 0;
// Here we start a for loop to count the elements in the tree
// The loop iterates for every successive layer
// i is the variable used to iterate the inputs,
// j counts the elements in the layer
*[ inputs_in_layer != end ->
elements_in_layer = 0; // At every layer the counter of the elements is resetted
*[ inputs_in_layer < end ->
[ inputs_in_layer + 1 >= end ->
//In this case, the number of input is even: the layer finishes
inputs_in_layer = end;
odd_element_flag = 0;
[] inputs_in_layer + 2 >= end ->
//In this case, we arrived at the last input, this means the inputs are odd
//We need to save the odd input index and move it to the next layer,
//up to when the resulting number is even
odd_element_idx = end;
odd_element_flag = 1;
inputs_in_layer = end;
[] else ->
//If we are not close to the end, analyzes the next two inputs
inputs_in_layer = inputs_in_layer +2;
]
elements_in_layer = elements_in_layer + 1; //At every step the elements count is updated
]
//Move the inputs_in_layer to the next layer
//Increase the end to account for the next layer elements
//If there was an odd element, count it also in the end
inputs_in_layer = end + 1;
end = end + elements_in_layer + odd_element_flag;
element_counter = element_counter + elements_in_layer;
]
{ element_counter = 4 : "Michele you did wrong" };
// Creating the elements of the tree
arbiter_handshake arb_array[element_counter];
(i:element_counter:arb_array[i].supply = supply;)
// These are the wires that connect one element of the tree to the others
a1of1 channels[element_counter*2];
//Connecting the first channels to the inputs
(i:N:channels[i] = in[i];)
channels[element_counter*2-1] = out;
//Now we redo the for loop but here to assign the channels to the elements
odd_element_idx = 0;
odd_element_flag = 0;
inputs_in_layer = 0;
end = N-1;
{ end=4 : "Michele you did wrong" };
// Here we start a for loop to count the elements in the tree
// The loop iterates for every successive layer
// i is the variable used to iterate the inputs,
// j counts the elements in the layer
*[ inputs_in_layer != end ->
elements_in_layer = 0; // At every layer the counter of the elements is resetted
*[ inputs_in_layer < end ->
[ inputs_in_layer + 1 >= end ->
//In this case, the number of input is even: the layer finishes
[ odd_element_flag >= 1 ->
arb_array[elements_in_layer].in1 = channels[inputs_in_layer];
arb_array[elements_in_layer].in2 = channels[odd_element_idx];
[] else ->
arb_array[elements_in_layer].in1 = channels[inputs_in_layer];
arb_array[elements_in_layer].in2 = channels[inputs_in_layer+1];
]
inputs_in_layer = end;
odd_element_flag = 0;
[] inputs_in_layer + 2 >= end ->
//In this case, we arrived at the last input, this means the inputs are odd
//We need to save the odd input index and move it to the next layer,
//up to when the resulting number is even
odd_element_idx = end;
odd_element_flag = 1;
{ end<8 : "Michele you did wrong" };
{ odd_element_idx=4 : "Michele you did wrong" };
arb_array[elements_in_layer].in1 = channels[inputs_in_layer];
arb_array[elements_in_layer].in2 = channels[inputs_in_layer+1];
inputs_in_layer = end;
[] else ->
//If we are not close to the end, analyzes the next two inputs
arb_array[elements_in_layer].in1 = channels[inputs_in_layer];
arb_array[elements_in_layer].in2 = channels[inputs_in_layer+1];
inputs_in_layer = inputs_in_layer +2;
]
elements_in_layer = elements_in_layer + 1; //At every step the elements count is updated
]
//Move the inputs_in_layer to the next layer
//Increase the end to account for the next layer elements
//If there was an odd element, count it also in the end
inputs_in_layer = end + 1;
end = end + elements_in_layer + odd_element_flag;
element_counter = element_counter + elements_in_layer;
]
}
export template<pint N>
defproc merge (avMx1of2<N> in1; avMx1of2<N> in2; avMx1of2<N> out ; bool? reset_B; power supply) {
@@ -730,18 +614,18 @@ namespace tmpl {
// reset buffers
bool _reset_BX;
BUF_X1 reset_buf(.a=reset_B, .y=_reset_BX,.vdd=supply.vdd,.vss=supply.vss);
sigbuf<N> reset_bufarray(.in=_reset_BX, .out=_reset_BXX, .supply = supply);
sigbuf<N> reset_bufarray(.in=_reset_BX, .out=_reset_BXX; power supply);
}
// Programmable delay line.
// N is the number of layers,
// the longest layer having 2**N DLY elements
export template<pint N>
defproc delayprog (bool! y; bool? a, s[N]; power supply)
defproc delayprog (bool! out; bool? in, s[N]; power supply)
{
{ N >= 0 : "What?" };
{ N < 9 : "Delay prog size is given in 2**N. Given N is too big." };
{ N < 10 : "Delay prog size is given in 2**N. Given N is ridiculous." };
AND2_X1 and2[N];
@@ -750,7 +634,7 @@ namespace tmpl {
bool _a[N+1]; // Holds the input to each row
_a[0] = a;
_a[0] = in;
pint i_delay;
i_delay = 0; // Index of the last connected delay element
@@ -775,7 +659,7 @@ namespace tmpl {
_a[i+1] = mu2[i].y;
)
y = mu2[N-1].y;
out = mu2[N-1].y;
// Connect everything to vdd/gnd