Merge branch 'dev' of ssh://git.web.rug.nl:222/bics/actlib_dataflow_neuro into dev

dataflow_neuro/primitives.act

@@ -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