uppercase.cpp

Go to the documentation of this file.

 
 
#include "../include/uppercase.hpp"
#include "../../../../../HOST/custom/uppercase/languages/cplusplus/include/config.h"
 
#ifdef USE_HLSLIB_DATAFLOW
#include "../../../../../hlslib/include/hlslib/xilinx/Stream.h"
#include "../../../../../hlslib/include/hlslib/xilinx/Simulation.h"
#endif
 
#ifdef USE_HLSLIB_STREAM
using hlslib::Stream;
#endif
using hls::stream;
 
#define Data_t_in  ap_axiu<INPUT_PTR_WIDTH, 0, 0, 0>
#define Data_t_out ap_axiu<OUTPUT_PTR_WIDTH, 0, 0, 0>
 
PacketFsmType enqueueFSM = WAIT_FOR_META;
PacketFsmType dequeueFSM = WAIT_FOR_META;
PacketFsmType UppercaseFSM  = WAIT_FOR_META;
 
 
typedef char word_t[8];
 
 
void pPortAndDestionation(
    ap_uint<32>             *pi_rank,
    ap_uint<32>             *pi_size,
    stream<NodeId>          &sDstNode_sig,
    ap_uint<32>                 *po_rx_ports
    )
{
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS INLINE
  //-- STATIC VARIABLES (with RESET) ------------------------------------------
  static PortFsmType port_fsm = FSM_WRITE_NEW_DATA;
#pragma HLS reset variable=port_fsm
 
 
  switch(port_fsm)
  {
    default:
    case FSM_WRITE_NEW_DATA:
        //Triangle app needs to be reset to process new rank
        if(!sDstNode_sig.full())
        {
          NodeId dst_rank = (*pi_rank + 1) % *pi_size;
          printf("rank: %d; size: %d; \n", (int) *pi_rank, (int) *pi_size);
          sDstNode_sig.write(dst_rank);
          port_fsm = FSM_DONE;
        }
        break;
    case FSM_DONE:
        *po_rx_ports = 0x1; //currently work only with default ports...
        break;
  }
 
}
 
 
void pRXPath(
    stream<NetworkWord>                              &siSHL_This_Data,
        stream<NetworkMetaStream>                        &siNrc_meta,
    stream<NetworkMetaStream>                        &sRxtoTx_Meta,
    stream<NetworkWord>                              &sRxpToTxp_Data,
    NetworkMetaStream                                meta_tmp,
    unsigned int                                     *processed_word_rx,
    unsigned int                                     *processed_bytes_rx
      #ifdef ENABLE_DDR
                                            ,
    //------------------------------------------------------
    //-- SHELL / Role / Mem / Mp1 Interface
    //------------------------------------------------------             
    membus_t   *lcl_mem0,
    membus_t   *lcl_mem1
    #endif
        )
{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
    //#pragma HLS DATAFLOW interval=1
     #pragma  HLS INLINE off
    //-- LOCAL VARIABLES ------------------------------------------------------
    NetworkWord    netWord;
    word_t text;
    
  switch(enqueueFSM)
  {
    case WAIT_FOR_META: 
      printf("DEBUG in pRXPath: enqueueFSM - WAIT_FOR_META, *processed_word_rx=%u, *processed_bytes_rx=%u\n",
         *processed_word_rx, *processed_bytes_rx);
      if ( !siNrc_meta.empty() && !sRxtoTx_Meta.full() )
      {
        meta_tmp = siNrc_meta.read();
        meta_tmp.tlast = 1; //just to be sure...
        sRxtoTx_Meta.write(meta_tmp);
        enqueueFSM = PROCESSING_PACKET;
      }
      break;
 
    case PROCESSING_PACKET:
      printf("DEBUG in pRXPath: enqueueFSM - PROCESSING_PACKET, *processed_word_rx=%u, *processed_bytes_rx=%u\n",
         *processed_word_rx, *processed_bytes_rx);
      if ( !siSHL_This_Data.empty() && !sRxpToTxp_Data.full() )
      {
        //-- Read incoming data chunk
        netWord = siSHL_This_Data.read();
        
 
    #ifdef ENABLE_DDR
    membus_t tmp_text;
    ap_uint<64> tmp_64_bytes;
    tmp_text.range(63,0) = netWord.tdata;
    tmp_text.range(511,64) = 0;
    lcl_mem0[0]=tmp_text;
    tmp_text=lcl_mem0[0];
    tmp_64_bytes = tmp_text.range(63,0);
    memcpy(&text, &tmp_64_bytes, 64/8);
    //#ifndef __SYNTHESIS__
     printf("%s\n",text);
    // #endif
    #else
        /* Read in one word_t */
        memcpy((char*) text, &netWord.tdata, 64/8);
    #endif
        
        /* Convert lower cases to upper cases byte per byte */
        uppercase_conversion:
        for (unsigned int i = 0; i < sizeof(text); i++ ) {
      //#pragma HLS PIPELINE
      //#pragma HLS UNROLL
 
            if (text[i] >= 'a' && text[i] <= 'z')
            text[i] = text[i] - ('a' - 'A');
        }
        memcpy(&netWord.tdata, (char*) text, 64/8);
        
        sRxpToTxp_Data.write(netWord);
              if(netWord.tlast == 1)
              {
                enqueueFSM = WAIT_FOR_META;
              }
      }
      break;
  }
 
 
}
 
 
 
 
 
void pTXPath(
        stream<NetworkWord>         &soTHIS_Shl_Data,
        stream<NetworkMetaStream>   &soNrc_meta,
    stream<NetworkWord>         &sRxpToTxp_Data,
    stream<NetworkMetaStream>   &sRxtoTx_Meta,
  stream<NodeId>          &sDstNode_sig,
        unsigned int                *processed_word_tx, 
        ap_uint<32>                 *pi_rank
        )
{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
    //#pragma HLS DATAFLOW interval=1
    #pragma  HLS INLINE
    //-- LOCAL VARIABLES ------------------------------------------------------
    NetworkWord      netWordTx;
    NetworkMeta  meta_in = NetworkMeta();
    static NodeId dst_rank;
  
  switch(dequeueFSM)
  {
    case WAIT_FOR_META:
      if(!sDstNode_sig.empty())
      {
        dst_rank = sDstNode_sig.read();
        dequeueFSM = WAIT_FOR_STREAM_PAIR;
        //Triangle app needs to be reset to process new rank
      }
      break;
    case WAIT_FOR_STREAM_PAIR:
      printf("DEBUG in pTXPath: dequeueFSM=%d - WAIT_FOR_STREAM_PAIR, *processed_word_tx=%u\n", 
         dequeueFSM, *processed_word_tx);
      //-- Forward incoming chunk to SHELL
      *processed_word_tx = 0;
      
      /*
      printf("!sRxpToTxp_Data.empty()=%d\n", !sRxpToTxp_Data.empty());
      printf("!sRxtoTx_Meta.empty()=%d\n", !sRxtoTx_Meta.empty());
      printf("!soTHIS_Shl_Data.full()=%d\n", !soTHIS_Shl_Data.full());
      printf("!soNrc_meta.full()=%d\n", !soNrc_meta.full());
      */
      
      if (( !sRxpToTxp_Data.empty() && !sRxtoTx_Meta.empty() 
          && !soTHIS_Shl_Data.full() &&  !soNrc_meta.full() )) 
      {
        netWordTx = sRxpToTxp_Data.read();
 
    // in case MTU=8 ensure tlast is set in WAIT_FOR_STREAM_PAIR and don't visit PROCESSING_PACKET
    if (PACK_SIZE == 8) 
    {
        netWordTx.tlast = 1;
    }
        soTHIS_Shl_Data.write(netWordTx);
 
        meta_in = sRxtoTx_Meta.read().tdata;
        NetworkMetaStream meta_out_stream = NetworkMetaStream();
        meta_out_stream.tlast = 1;
        meta_out_stream.tkeep = 0xFF; //just to be sure
 
        meta_out_stream.tdata.dst_rank = dst_rank;
        //meta_out_stream.tdata.dst_port = DEFAULT_TX_PORT;
        meta_out_stream.tdata.src_rank = (NodeId) *pi_rank;
        //meta_out_stream.tdata.src_port = DEFAULT_RX_PORT;
        //printf("rank: %d; size: %d; \n", (int) *pi_rank, (int) *pi_size);
        //printf("meat_out.dst_rank: %d\n", (int) meta_out_stream.tdata.dst_rank);
        meta_out_stream.tdata.dst_port = meta_in.src_port;
        meta_out_stream.tdata.src_port = meta_in.dst_port;
    
    //meta_out_stream.tdata.len = meta_in.len; 
        soNrc_meta.write(meta_out_stream);
 
          (*processed_word_tx)++;
    
        if(netWordTx.tlast != 1)
        {
          dequeueFSM = PROCESSING_PACKET;
        }
      }
      break;
 
    case PROCESSING_PACKET: 
      printf("DEBUG in pTXPath: dequeueFSM=%d - PROCESSING_PACKET, *processed_word_tx=%u\n", 
         dequeueFSM, *processed_word_tx);
      if( !sRxpToTxp_Data.empty() && !soTHIS_Shl_Data.full())
      {
        netWordTx = sRxpToTxp_Data.read();
 
    // This is a normal termination of the axi stream from vitis functions
    if(netWordTx.tlast == 1)
    {
      dequeueFSM = WAIT_FOR_STREAM_PAIR;
    }
    
    // This is our own termination based on the custom MTU we have set in PACK_SIZE.
    // TODO: We can map PACK_SIZE to a dynamically assigned value either through MMIO or header
    //       in order to have a functional bitstream for any MTU size
    (*processed_word_tx)++;
    if (((*processed_word_tx)*8) % PACK_SIZE == 0) 
    {
        netWordTx.tlast = 1;
        dequeueFSM = WAIT_FOR_STREAM_PAIR;
    }
    
        soTHIS_Shl_Data.write(netWordTx);
      }
      break;
  }
}
 
 
 
void uppercase(
 
    ap_uint<32>             *pi_rank,
    ap_uint<32>             *pi_size,
    //------------------------------------------------------
    //-- SHELL / This / Udp/TCP Interfaces
    //------------------------------------------------------
    stream<NetworkWord>         &siSHL_This_Data,
    stream<NetworkWord>         &soTHIS_Shl_Data,
    stream<NetworkMetaStream>   &siNrc_meta,
    stream<NetworkMetaStream>   &soNrc_meta,
    ap_uint<32>                 *po_rx_ports
    #ifdef ENABLE_DDR
                                            ,
    //------------------------------------------------------
    //-- SHELL / Role / Mem / Mp1 Interface
    //------------------------------------------------------             
    membus_t   *lcl_mem0,
    membus_t   *lcl_mem1
    #endif
    )
{
 
  //-- DIRECTIVES FOR THE BLOCK ---------------------------------------------
 //#pragma HLS INTERFACE ap_ctrl_none port=return
 
  //#pragma HLS INTERFACE ap_stable     port=piSHL_This_MmioEchoCtrl
 
#pragma HLS INTERFACE axis register both port=siSHL_This_Data
#pragma HLS INTERFACE axis register both port=soTHIS_Shl_Data
 
#pragma HLS INTERFACE axis register both port=siNrc_meta
#pragma HLS INTERFACE axis register both port=soNrc_meta
 
#pragma HLS INTERFACE ap_ovld register port=po_rx_ports name=poROL_NRC_Rx_ports
#pragma HLS INTERFACE ap_stable register port=pi_rank name=piFMC_ROL_rank
#pragma HLS INTERFACE ap_stable register port=pi_size name=piFMC_ROL_size
 
#ifdef ENABLE_DDR
    
const unsigned int ddr_mem_depth = TOTMEMDW_512;
const unsigned int ddr_latency = DDR_LATENCY;
const unsigned int num_outstanding_transactions = 256;
const unsigned int MAX_BURST_LENGTH_512=64;//Theoretically is  64, 64*512bit = 4096KBytes;
 
// Mapping LCL_MEM0 interface to moMEM_Mp1 channel
#pragma HLS INTERFACE m_axi depth=ddr_mem_depth port=lcl_mem0 bundle=moMEM_Mp1\
  max_read_burst_length=MAX_BURST_LENGTH_512  max_write_burst_length=MAX_BURST_LENGTH_512 offset=direct \
  num_read_outstanding=num_outstanding_transactions num_write_outstanding=num_outstanding_transactions
  // latency=ddr_latency
 
// Mapping LCL_MEM1 interface to moMEM_Mp1 channel
#pragma HLS INTERFACE m_axi depth=ddr_mem_depth port=lcl_mem1 bundle=moMEM_Mp1 \
  max_read_burst_length=MAX_BURST_LENGTH_512  max_write_burst_length=MAX_BURST_LENGTH_512 offset=direct \
  num_read_outstanding=num_outstanding_transactions num_write_outstanding=num_outstanding_transactions 
  //latency=ddr_latency
 
#endif
 
  //-- LOCAL VARIABLES ------------------------------------------------------
  static stream<NetworkWord>       sRxpToTxp_Data("sRxpToTxP_Data"); // FIXME: works even with no static
  NetworkMetaStream  meta_tmp = NetworkMetaStream();
  static stream<NetworkMetaStream> sRxtoTx_Meta("sRxtoTx_Meta");
  static unsigned int processed_word_rx;
  static unsigned int processed_bytes_rx;
  static unsigned int processed_word_tx;
  //*po_rx_ports = 0x1; //currently work only with default ports...
  static stream<NodeId>            sDstNode_sig   ("sDstNode_sig");
 
 
  
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS DATAFLOW 
#pragma HLS reset variable=enqueueFSM
#pragma HLS reset variable=dequeueFSM
#pragma HLS reset variable=UppercaseFSM
#pragma HLS reset variable=processed_word_rx
#pragma HLS reset variable=processed_word_tx
 
  
 
#ifdef USE_HLSLIB_DATAFLOW
  // Dataflow functions running in parallel
  HLSLIB_DATAFLOW_INIT();
  
  HLSLIB_DATAFLOW_FUNCTION(pRXPath, 
               siSHL_This_Data,
               siNrc_meta,
               sRxtoTx_Meta,
               meta_tmp,
               sRxpToTxp_Data,
               &processed_word_rx,
               &processed_bytes_rx);
 
  HLSLIB_DATAFLOW_FUNCTION(pTXPath,
               soTHIS_Shl_Data,
               soNrc_meta,
               sRxpToTxp_Data,
               sRxtoTx_Meta,
               &processed_word_tx,
               pi_rank,
               pi_size);
 
  HLSLIB_DATAFLOW_FINALIZE();
  
#else // !USE_HLSLIB_DATAFLOW
 
 pPortAndDestionation(
  pi_rank,
  pi_size, 
  sDstNode_sig,
  po_rx_ports);
 
 pRXPath(
    siSHL_This_Data,
  siNrc_meta,
    sRxtoTx_Meta,
    sRxpToTxp_Data,
  meta_tmp,
  &processed_word_rx,
    &processed_bytes_rx
  #ifdef ENABLE_DDR
                                          ,
  //------------------------------------------------------
  //-- SHELL / Role / Mem / Mp1 Interface
  //------------------------------------------------------             
  lcl_mem0,
  lcl_mem1
  #endif
    );
  
  pTXPath(
  soTHIS_Shl_Data,
  soNrc_meta,
    sRxpToTxp_Data,
    sRxtoTx_Meta,
  sDstNode_sig,
  &processed_word_tx,
  pi_rank);
#endif // USE_HLSLIB_DATAFLOW
}