continued handshaking tree, not finished

dataflow_neuro/primitives.act

@@ -507,6 +507,122 @@ 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) {
 
@@ -614,18 +730,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; power supply);
+          sigbuf<N> reset_bufarray(.in=_reset_BX, .out=_reset_BXX, .supply = 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! out; bool? in, s[N]; power supply)
+        defproc delayprog (bool! y; bool? a, s[N]; power supply)
         {
             
             { N >= 0 : "What?" };
-            { N < 10 : "Delay prog size is given in 2**N. Given N is ridiculous." };
+            { N < 9 : "Delay prog size is given in 2**N. Given N is too big." };
 
 
             AND2_X1 and2[N];
@@ -634,7 +750,7 @@ namespace tmpl {
 
             bool _a[N+1]; // Holds the input to each row
          
-            _a[0] = in;
+            _a[0] = a;
 
             pint i_delay;
             i_delay = 0; // Index of the last connected delay element
@@ -659,7 +775,7 @@ namespace tmpl {
                 _a[i+1] = mu2[i].y;
             )
 
-            out = mu2[N-1].y;
+            y = mu2[N-1].y;
 
 
             // Connect everything to vdd/gnd