Changeset 977 for branches/reconfiguration/modules/dspin_local_crossbar/caba/source/src/dspin_local_crossbar.cpp

Timestamp:

Apr 15, 2015, 4:02:12 PM (9 years ago)

Author:

cfuguet

Message:

reconf: dont test the locality of global to local requests.

• This is to support segment reallocation.

File:

• branches/reconfiguration/modules/dspin_local_crossbar/caba/source/src/dspin_local_crossbar.cpp (modified) (29 diffs)

branches/reconfiguration/modules/dspin_local_crossbar/caba/source/src/dspin_local_crossbar.cpp

@@ -6 +6 @@
   *
   * SOCLIB_LGPL_HEADER_BEGIN
-  * 
+  *
   * This file is part of SoCLib, GNU LGPLv2.1.
-  * 
+  *
   * SoCLib is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as published
   * by the Free Software Foundation; version 2.1 of the License.
-  * 
+  *
   * SoCLib is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
-  * 
+  *
   * You should have received a copy of the GNU Lesser General Public
   * License along with SoCLib; if not, write to the Free Software
@@ -39 +39 @@
 //                  constructor
 //////////////////////////////////////////////////////////
-tmpl(/**/)::DspinLocalCrossbar( sc_module_name       name, 
+tmpl(/**/)::DspinLocalCrossbar( sc_module_name       name,
                                 const MappingTable   &mt,
                                 const size_t         x,
@@ -123 +123 @@
         r_fifo_in  = (GenericFifo<internal_flit_t>*)
         malloc(sizeof(GenericFifo<internal_flit_t>) * (m_local_inputs + 1));
-        
+
         r_fifo_out = (GenericFifo<internal_flit_t>*)
         malloc(sizeof(GenericFifo<internal_flit_t>) * (m_local_outputs + 1));
@@ -179 +179 @@
     ////////////////////////////////////////////////////////////////////////////
     tmpl(size_t)::route( sc_uint<flit_width> data,     // first flit
-                         size_t              input )   // input port index 
+                         size_t              input )   // input port index
     {
         size_t   output;   // selected output port
@@ -185 +185 @@
         size_t   y_dest  = (size_t)(data >> m_y_shift) & m_y_mask;
 
-        if ( (x_dest == m_local_x) and (y_dest == m_local_y) and
-             (m_local_outputs > 0) )          // local dest
+        // there are two types of local request:
+        //  - when destination coordinates correspond to local coordinates
+        //  - when there is a segment reallocation and the new host is local
+        // to support the second case, the locality of the global-to-local
+        // requests is not checked.
+        bool local_dest = ((x_dest == m_local_x) and (y_dest == m_local_y)) or
+                           (input == m_local_inputs);
+
+        if ( local_dest and (m_local_outputs > 0) )             // local dest
         {
             if ( m_use_routing_table )
@@ -194 +201 @@
                 {
                     uint64_t address;
-                    if (flit_width >= m_addr_width) 
+                    if (flit_width >= m_addr_width)
                         address = data>>(flit_width - m_addr_width);
-                    else                          
+                    else
                         address = data<<(m_addr_width - flit_width);
                     output = m_cmd_rt[ address ];
                 }
                 else
-                {   
+                {
                     uint32_t srcid = data >> m_l_shift;
                     output = m_rsp_rt[ srcid ];
@@ -209 +216 @@
             {
                 output = (size_t)(data >> m_l_shift) & m_l_mask;
- 
+
                 if ( output >= m_local_outputs )
                 {
@@ -218 +225 @@
             }
         }
-        else                                                            // global dest
-        {
-            if ( input  == m_local_inputs )
-            {
-                std::cout << "ERROR in DSPIN_LOCAL_CROSSBAR: " << name()
-                          << " illegal global to global request" << std::endl;
-                exit(0);
-            }
-
+        else                                                    // global dest
+        {
             output = m_local_outputs;
         }
@@ -243 +243 @@
         const char* infsm_str[] = { "IDLE", "REQ", "ALLOC", "REQ_BC", "ALLOC_BC" };
 
-        std::cout << "DSPIN_LOCAL_CROSSBAR " << name() << std::hex; 
+        std::cout << "DSPIN_LOCAL_CROSSBAR " << name() << std::hex;
 
         for( size_t i = 0 ; i <= m_local_inputs ; i++)  // loop on input ports
         {
-            std::cout << " / infsm[" << std::dec << i 
+            std::cout << " / infsm[" << std::dec << i
                       << "] = " << infsm_str[r_fsm_in[i].read()];
         }
@@ -257 +257 @@
                 size_t in = r_index_out[out];
                 std::cout << " / in[" << in << "] -> out[" << out << "]";
-            }   
+            }
         }
         std::cout << std::endl;
@@ -273 +273 @@
         // control signals for the input fifos
         bool                fifo_in_write[m_local_inputs+1];
-        bool                fifo_in_read[m_local_inputs+1];    
+        bool                fifo_in_read[m_local_inputs+1];
         internal_flit_t     fifo_in_wdata[m_local_inputs+1];
 
@@ -281 +281 @@
         internal_flit_t     fifo_out_wdata[m_local_outputs+1];
 
-        // reset 
-        if ( p_resetn.read() == false ) 
-        {
-            for(size_t j = 0 ; j <= m_local_outputs ; j++) 
+        // reset
+        if ( p_resetn.read() == false )
+        {
+            for(size_t j = 0 ; j <= m_local_outputs ; j++)
             {
                 r_alloc_out[j] = false;
@@ -290 +290 @@
                 r_fifo_out[j].init();
             }
-            for(size_t i = 0 ; i <= m_local_inputs ; i++) 
+            for(size_t i = 0 ; i <= m_local_inputs ; i++)
             {
                 r_index_in[i]  = 0;
@@ -300 +300 @@
 
         // fifo_in signals default values
-        for(size_t i = 0 ; i < m_local_inputs ; i++) 
-        {
-            fifo_in_read[i]        = false;   
+        for(size_t i = 0 ; i < m_local_inputs ; i++)
+        {
+            fifo_in_read[i]        = false;
             fifo_in_write[i]       = p_local_in[i].write.read();
             fifo_in_wdata[i].data  = p_local_in[i].data.read();
@@ -313 +313 @@
 
         // fifo_out signals default values
-        for(size_t j = 0 ; j < m_local_outputs ; j++) 
+        for(size_t j = 0 ; j < m_local_outputs ; j++)
         {
             fifo_out_read[j]  = p_local_out[j].read.read();
-            fifo_out_write[j] = false;  
+            fifo_out_write[j] = false;
         }
         fifo_out_read[m_local_outputs]  = p_global_out.read.read();
-        fifo_out_write[m_local_outputs] = false;     
+        fifo_out_write[m_local_outputs] = false;
 
         // loop on the output ports:
@@ -326 +326 @@
         for ( size_t j = 0 ; j <= m_local_outputs ; j++ )
         {
-            if( r_alloc_out[j].read() and (r_fifo_out[j].wok()) ) 
+            if( r_alloc_out[j].read() and (r_fifo_out[j].wok()) )
             {
                 get_out[j] = r_index_out[j].read();
             }
             else
-            {                       
-                get_out[j] = 0xFFFFFFFF;  
-            }
-        }
-
-        // loop on the input ports (including global input port, 
+            {
+                get_out[j] = 0xFFFFFFFF;
+            }
+        }
+
+        // loop on the input ports (including global input port,
         // with the convention index[global] = m_local_inputs)
-        // The port state is defined by r_fsm_in[i], r_index_in[i] 
+        // The port state is defined by r_fsm_in[i], r_index_in[i]
         // The req_in[i] computation uses the route() function.
         // Both put_in[i] and req_in[i] depend on the input port state.
@@ -351 +351 @@
                     if ( r_fifo_in[i].rok() ) // packet available in input fifo
                     {
-                        if ( is_broadcast(r_fifo_in[i].read().data ) and 
+                        if ( is_broadcast(r_fifo_in[i].read().data ) and
                              m_broadcast_supported )   // broadcast required
                         {
@@ -398 +398 @@
                     req_in[i]  = 0xFFFFFFFF;                // no request
                     if ( r_fifo_in[i].read().eop and
-                         r_fifo_in[i].rok() and 
+                         r_fifo_in[i].rok() and
                          (get_out[r_index_in[i].read()] == i) )  // last flit transfered
                     {
@@ -416 +416 @@
                     break;
                 }
-                case INFSM_ALLOC_BC:  // output port allocated         
+                case INFSM_ALLOC_BC:  // output port allocated
                 {
                     data_in[i] = r_fifo_in[i].read();
@@ -422 +422 @@
                     req_in[i]  = 0xFFFFFFFF;                // no request
 
-                    if ( r_fifo_in[i].rok() and 
+                    if ( r_fifo_in[i].rok() and
                          get_out[r_index_in[i].read()] == i )  // last flit transfered
                     {
-                        if ( not r_fifo_in[i].read().eop ) 
+                        if ( not r_fifo_in[i].read().eop )
                         {
                             std::cout << "ERROR in DSPIN_LOCAL_CROSSBAR " << name()
@@ -438 +438 @@
             } // end switch
         } // end for input ports
-                                   
-        // loop on the output ports (including global output port, 
+
+        // loop on the output ports (including global output port,
         // with the convention index[global] = m_local_outputs)
         // The r_alloc_out[j] and r_index_out[j] computation
         // implements the round-robin allocation policy.
         // These two registers implement a 2*N states FSM.
-        for( size_t j = 0 ; j <= m_local_outputs ; j++ ) 
+        for( size_t j = 0 ; j <= m_local_outputs ; j++ )
         {
             if( not r_alloc_out[j].read() )  // not allocated: possible new allocation
             {
-                for( size_t k = r_index_out[j].read() + 1 ; 
-                     k <= (r_index_out[j].read() + m_local_inputs + 1) ; 
-                     k++ ) 
-                { 
+                for( size_t k = r_index_out[j].read() + 1 ;
+                     k <= (r_index_out[j].read() + m_local_inputs + 1) ;
+                     k++ )
+                {
                     size_t i = k % (m_local_inputs + 1);
 
-                    if( req_in[i] == j ) 
+                    if( req_in[i] == j )
                     {
                         r_alloc_out[j] = true;
@@ -461 +461 @@
                     }
                 } // end loop on input ports
-            } 
+            }
             else                            // allocated: possible desallocation
             {
                 if ( data_in[r_index_out[j]].eop and
-                     r_fifo_out[j].wok() and 
-                     put_in[r_index_out[j]] ) 
+                     r_fifo_out[j].wok() and
+                     put_in[r_index_out[j]] )
                 {
                     r_alloc_out[j] = false;
@@ -474 +474 @@
 
         // loop on input ports :
-        // fifo_in_read[i] computation 
+        // fifo_in_read[i] computation
         // (computed here because it depends on get_out[])
-        for( size_t i = 0 ; i <= m_local_inputs ; i++ ) 
-        {
-            if ( (r_fsm_in[i].read() == INFSM_REQ) or 
+        for( size_t i = 0 ; i <= m_local_inputs ; i++ )
+        {
+            if ( (r_fsm_in[i].read() == INFSM_REQ) or
                  (r_fsm_in[i].read() == INFSM_ALLOC) or
                  ((r_fsm_in[i].read() == INFSM_ALLOC_BC) and (r_index_in[i].read() == 0)))
@@ -485 +485 @@
             }
             if ( (r_fsm_in[i].read() == INFSM_IDLE) and
-                 is_broadcast( r_fifo_in[i].read().data ) and 
-                 m_broadcast_supported )   
+                 is_broadcast( r_fifo_in[i].read().data ) and
+                 m_broadcast_supported )
             {
                 fifo_in_read[i] = true;
@@ -495 +495 @@
         // The fifo_out_write[j] and fifo_out_wdata[j] computation
         // implements the output port mux
-        for( size_t j = 0 ; j <= m_local_outputs ; j++ ) 
+        for( size_t j = 0 ; j <= m_local_outputs ; j++ )
         {
             if( r_alloc_out[j] )  // output port allocated
@@ -505 +505 @@
 
         //  input FIFOs update
-        for(size_t i = 0 ; i <= m_local_inputs ; i++) 
+        for(size_t i = 0 ; i <= m_local_inputs ; i++)
         {
             r_fifo_in[i].update(fifo_in_read[i],
@@ -514 +514 @@
         //  output FIFOs update
         for(size_t j = 0 ; j <= m_local_outputs ; j++)
-        { 
+        {
             r_fifo_out[j].update(fifo_out_read[j],
                                  fifo_out_write[j],
@@ -525 +525 @@
     {
         // input ports
-        for(size_t i = 0 ; i < m_local_inputs ; i++) 
+        for(size_t i = 0 ; i < m_local_inputs ; i++)
         {
             p_local_in[i].read = r_fifo_in[i].wok();
@@ -532 +532 @@
 
         // output ports
-        for(size_t j = 0 ; j < m_local_outputs ; j++) 
+        for(size_t j = 0 ; j < m_local_outputs ; j++)
         {
             p_local_out[j].write = r_fifo_out[j].rok();