continued handshaking tree, not finished

dataflow_neuro/primitives.act

@@ -170,7 +170,7 @@ namespace tmpl {
           // reset buffers
           bool _reset_BX;
           BUF_X1 reset_buf(.a=reset_B, .y=_reset_BX,.vdd=supply.vdd,.vss=supply.vss);
-          sigbuf<M> reset_bufarray(.in=_reset_BX, .out=_reset_BXX);
+          sigbuf<M> reset_bufarray(.in=_reset_BX, .out=_reset_BXX,.supply = supply);
         }
 
         /**
@@ -190,7 +190,7 @@ namespace tmpl {
 
 
             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);
+            sigbuf<N> reset_bufarray(.in=_reset_BX, .out=_reset_BXX, .supply=supply);
         
             //validity
             bool _in_v, _in_vX[N];
@@ -205,8 +205,8 @@ namespace tmpl {
             sigbuf<N> en_buf_t(.in=_en, .out=_en_X_t, .supply=supply);
             sigbuf<N> en_buf_f(.in=_en, .out=_en_X_f, .supply=supply);
             INV_X1 out_a_inv(.a=out.a,.y=_out_a_B);
-            sigbuf<N> out_a_B_buf_f(.in=_out_a_B,.out=_out_a_BX_t);
+            sigbuf<N> out_a_B_buf_f(.in=_out_a_B,.out=_out_a_BX_t, .supply=supply);
-            sigbuf<N> out_a_B_buf_t(.in=_out_a_B,.out=_out_a_BX_f);
+            sigbuf<N> out_a_B_buf_t(.in=_out_a_B,.out=_out_a_BX_f, .supply=supply);
             // check if you can also do single var to array connect a=b[N]
             // and remove them from the loop
             (i:N: 
@@ -244,8 +244,8 @@ namespace tmpl {
             //validity
             bool _in_v, _c_f_buf[N], _c_t_buf[N], _c_v;
             
-            sigbuf<N> c_buf_t(.in=cond.d.d[0].t, .out=_c_t_buf);
+            sigbuf<N> c_buf_t(.in=cond.d.d[0].t, .out=_c_t_buf, .supply=supply);
-            sigbuf<N> c_buf_f(.in=cond.d.d[0].f, .out=_c_f_buf);
+            sigbuf<N> c_buf_f(.in=cond.d.d[0].f, .out=_c_f_buf, .supply=supply);
             
             OR2_X1 c_f_c_t_or(.a=cond.d.d[0].t, .b=cond.d.d[0].f, .y=_c_v,.vdd=supply.vdd,.vss=supply.vss);
             vtree<N> vc(.in=in.d,.out=_in_v,.supply=supply);
@@ -262,8 +262,8 @@ namespace tmpl {
             sigbuf<N> out1_en_buf_t(.in=_en, .out=_en1_X_t, .supply=supply);
             sigbuf<N> out1_en_buf_f(.in=_en, .out=_en1_X_f, .supply=supply);
             INV_X1 out1_a_inv(.a=out1.a,.y=_out1_a_B);
-            sigbuf<N> out1_a_B_buf_f(.in=_out1_a_B,.out=_out1_a_BX_t);
+            sigbuf<N> out1_a_B_buf_f(.in=_out1_a_B,.out=_out1_a_BX_t, .supply=supply);
-            sigbuf<N> out1_a_B_buf_t(.in=_out1_a_B,.out=_out1_a_BX_f);
+            sigbuf<N> out1_a_B_buf_t(.in=_out1_a_B,.out=_out1_a_BX_f, .supply=supply);
             (i:N: 
                 out1_f_buf_func[i].y=out1.d.d[i].f;
                 out1_t_buf_func[i].y=out1.d.d[i].t;
@@ -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,7 +730,7 @@ 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.