translator_mmips.cpp

改进的基于6个mips核的NOC网络

/*
 *  TU Eindhoven
 *  Eindhoven, The Netherlands
 *
 *  Name            :   translator_mmips.cpp
 *
 *  Author          :   Jose Prats - [e-mail]
 *
 *  Date            :
 *
 *  Function        :   Translator in mmips node
 *
 */

#include "translator_mmips.h"

void TRANSLATOR_MMIPS::buffer()
{
  if( bufw.read() )
    dev_buffer = dev_din.read();
}

//It's necessary to buffer "remote_select" to stop the FSM. It will only makes
//one request to the network even if the data is in the bus indefinitely.
void TRANSLATOR_MMIPS::remote_select_buffer()
{
  if( rst.read() == true )
    buff_remote_select = false;
  else
    buff_remote_select = remote_select_tmp.read(); 
}

void TRANSLATOR_MMIPS::translator_process()
{
   x_mem_addr_int = x_mem_addr.read();         // These signals are necessary to operate with the data
   y_mem_addr_int = y_mem_addr.read();
   my_xaddr_int = my_xaddr.read();
   my_yaddr_int = my_yaddr.read();
   xdimension_int = xdimension.read();
   ydimension_int = ydimension.read();

   //rel_xaddr.write( (my_xaddr <= x_mem_addr) ? (x_mem_addr - my_xaddr) : (xdimension - (my_xaddr - x_mem_addr)) );
   if ( my_xaddr_int <= x_mem_addr_int )
     {
     rel_xaddr = x_mem_addr_int - my_xaddr_int;
     }
   else
     {
     rel_xaddr = xdimension_int - (my_xaddr_int - x_mem_addr_int);
     }
   //rel_yaddr.write( (my_yaddr <= y_mem_addr) ? (y_mem_addr - my_yaddr) : (ydimension - (my_yaddr - y_mem_addr)) );
   if ( my_yaddr_int <= y_mem_addr_int )
     {
     rel_yaddr = y_mem_addr_int - my_yaddr_int;
     }
   else
     {
     rel_yaddr = ydimension_int - (my_yaddr_int - y_mem_addr_int);
     }
     
   rel_xaddr_bit = rel_xaddr;
   rel_yaddr_bit = rel_yaddr;

   // the control word for the remote memory should change depending on reading or writing
   if (int_ram_r.read() && remote_select.read())
      {
      CW.range(31,8) = (control_CW_load,rel_xaddr_bit);
      CW.range(7,0) = rel_yaddr_bit;
      CWeop.range(31,8) = (control_CWeop_load,rel_xaddr_bit);
      CWeop.range(7,0) = rel_yaddr_bit;
      }
   else
      {
      CW.range(31,8) = (control_CW_store,rel_xaddr_bit);
      CW.range(7,0) = rel_yaddr_bit;
      CWeop.range(31,8) = (control_CWeop_store,rel_xaddr_bit);
      CWeop.range(7,0) = rel_yaddr_bit;
      }

  
  // chech whether the address is remote or local. REMOTE-> 0x0 < address < 0xFF
  //remote_select.write(ram_addr.read().range(31,8) == sc_bv<24>(0));
  ram_addr_int = ram_addr.read();
  //remote_select.write( (ram_addr_int >= 16384) && (ram_addr_int <= 19967) && ((ram_w.read()!=sc_bv<2>(0)) || (ram_r.read()!=sc_bv<2>(0)) ) );
  remote_select.write( (ram_addr_int >= 32768) && (ram_addr_int <= 49151) && ((ram_w.read()!=sc_bv<2>(0)) || (ram_r.read()!=sc_bv<2>(0)) ) );
  
  trans_remote_select.write(remote_select);
  remote_select_tmp.write(remote_select);

  // enable or disable the local memory checking the "remote select" signal
  local_ram_w.write( !remote_select ? ram_w.read() : sc_bv<2>(0) );
  local_ram_r.write( !remote_select ? ram_r.read() : sc_bv<2>(0) );

  // decide which data must travel through the network: data to the device or data to the memory node
  trans_dev_din.write( !remote_select ? dev_din.read() : FSMout.read() );

  // Slect the proper signals to send to NI depending on the "remote select"
  //trans_dev_w.write( !remote_select ? dev_w.read() : int_dev_waddr.read() );  
  trans_dev_w.write( !remote_select ? dev_w.read() : int_dev_w.read() ); 
  trans_dev_r.write( !remote_select ? dev_r.read() : int_ram_r.read() ); 
  trans_dev_wdata.write( !remote_select ? dev_wdata.read() : int_dev_wdata.read() );
  trans_dev_waddr.write( !remote_select ? dev_waddr.read() : int_dev_waddr.read() );
  trans_dev_send_eop.write( !remote_select ? dev_send_eop.read() : int_dev_send_eop.read() );

  // Select the proper signals to MEMDEV depending on "remote select"
  trans_send_rdy.write( remote_select ? false : send_rdy.read());
  trans_data_rdy.write( remote_select ? false : data_rdy.read());

}

// State machine to read and write in the remote memory
void TRANSLATOR_MMIPS::translatorFSM() {
  if (rst.read() == true) {
    next_state = idle;
    enable_mmips.write(1);
    
    int_dev_send_eop.write(false);   
    int_dev_w.write(false);   
    
  }
  else {
    switch(current_state) {
      case idle:
        if (remote_select)
	  {
          enable_mmips.write(0);
          next_state = send_addr;

          ram_r_int = ram_r.read();
          ram_w_int = ram_w.read();
          int_ram_r.write( (ram_r_int == sc_bv<2>(0)) ? false : true );
          int_ram_w.write( (ram_w_int == sc_bv<2>(0)) ? false : true );
	  }
        else
	  {
          next_state = idle;
          enable_mmips.write(1);
	  }
        break;

      case send_addr:
        if (!remote_select)
	  {
          next_state = idle;
          enable_mmips.write(1);
	  }
        else
	  {
           FSMout.write(ram_addr);

           int_dev_wdata.write(true);
           int_dev_waddr.write(false);
           int_dev_send_eop.write(false);

           next_state = send_CW;
           }
        break;

      case send_CW:
        if (!remote_select)
	  {
          next_state = idle;
          enable_mmips.write(1);
	  }
        else
	  {
           // If we are reading we only send the address, tha data is not neccessary
           if (int_ram_r.read() && remote_select.read())
             {
             next_state = send_CWeop;
             }
           // If we are writing we have to send the address and the data
           else
             {
             FSMout.write(CW);

             int_dev_wdata.write(false);
             int_dev_waddr.write(true);
             int_dev_send_eop.write(false);
	     int_dev_w.write(true); 

             next_state = send_data;
             }
           }
        break;

      case send_data:
     	int_dev_w.write(false); 
        if (!remote_select)
	  {
          next_state = idle;
          enable_mmips.write(1);
	  }
        else
	  {
           //We are waiting for "send_rdy" to be asserted, which means that
           //we can send more data and the CW is not necessary anymore
           if (!send_rdy)
             {
             next_state = send_data;     
             }
           else
             {
             FSMout.write(dev_din);

             int_dev_wdata.write(true);
             int_dev_waddr.write(false);
             int_dev_send_eop.write(false);

             next_state = wait_send_rdy_up;
             }
          }
        break;

      // We have to wait one cycle with "wait_send_rdy_up" asserted for the NI
      case wait_send_rdy_up:
        next_state = send_CWeop;
        break;

      case send_CWeop:
        if (!remote_select)
	  {
          next_state = idle;
          enable_mmips.write(1);
	  }
        else
	  {
           FSMout.write(CWeop);

           int_dev_wdata.write(false);
           int_dev_waddr.write(true);
           int_dev_send_eop.write(true);
     	   int_dev_w.write(true);  

           if(int_ram_r.read() && remote_select.read())
             {
             next_state = wait_rem_mem_data;
             }
           else
             {
             next_state = finish;
             }                   
           }
        break;

      // We have to wait for "data_rdy" to be asserted to have the data received
      // from the memory node in the "reg_data_out" bus. This data will be send
      // to the MEMDV.
      case wait_rem_mem_data:
      	int_dev_w.write(false);  
	int_dev_send_eop.write(false);  
        if (data_rdy)
          {
          trans_ram_dout.write(reg_data_out);
          next_state = finish;
          }
        else
          {
          next_state = wait_rem_mem_data;
          }
        break;

      // We have to wait for "send_rdy" to be asserted to erase the CW from
      // the bus. The FSM is now stopped.
      case finish:
        int_dev_w.write(false);  
        int_dev_send_eop.write(false);  
        if (send_rdy)
          {
          enable_mmips.write(1);
          //buff_remote_select = false;
          next_state = wait_remote_select_down;
          }
        else
          {
          next_state = finish;
          }
        break;

      case wait_remote_select_down:
        if (!remote_select)
          {	  
          next_state = idle;
          }
        else
          {
          next_state = wait_remote_select_down;
          }
        break;
    }
  }
}


// state update of the sending FSM
void TRANSLATOR_MMIPS::change_state()
{
  if( rst.read() ){
    current_state = idle;
  }
  else{
    current_state = next_state;

  }
}