Fix for SDOCM00103116: netapi_init() error codes not checked in right place.
authorTinku Mannan <tmannan@ti.com>
Wed, 4 Sep 2013 14:29:56 +0000 (10:29 -0400)
committerTinku Mannan <tmannan@ti.com>
Wed, 4 Sep 2013 14:29:56 +0000 (10:29 -0400)
ti/runtime/netapi/test/net_test_bench.c
ti/runtime/netapi/test/net_test_loopback.c
ti/runtime/netapi/test/net_test_max_params.c

index 15177e8bee00b764f22b7739898a661346f714f3..fafdcc11f071feb5e52a86219794433400b53c23 100755 (executable)
-/******************************************\r
- * File: nt_bench.c   \r
- * Purpose:  benchmarks for NT.\r
- **************************************************************\r
- * FILE:  nt_bench.c\r
- * \r
- * DESCRIPTION:  netapi user space transport\r
- *               library  test application : benchmarks\r
- * \r
- * REVISION HISTORY:  rev 0.0.1 \r
- *\r
- *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
- * \r
- *  Redistribution and use in source and binary forms, with or without \r
- *  modification, are permitted provided that the following conditions \r
- *  are met:\r
- *\r
- *    Redistributions of source code must retain the above copyright \r
- *    notice, this list of conditions and the following disclaimer.\r
- *\r
- *    Redistributions in binary form must reproduce the above copyright\r
- *    notice, this list of conditions and the following disclaimer in the \r
- *    documentation and/or other materials provided with the   \r
- *    distribution.\r
- *\r
- *    Neither the name of Texas Instruments Incorporated nor the names of\r
- *    its contributors may be used to endorse or promote products derived\r
- *    from this software without specific prior written permission.\r
- *\r
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
-\r
- *****************************************/\r
-\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include <unistd.h>\r
-#include <string.h>\r
-#include <signal.h>\r
-#include <pthread.h>\r
-#include <sched.h>\r
-\r
-#include "trie.h"\r
-#include "string.h"\r
-#include "netapi.h"\r
-#include "pktio.h"\r
-#include "net_test.h"\r
-#include <ti/drv/sa/salld.h>\r
-\r
-#define netapi_timing_start hplib_mUtilGetPmuCCNT\r
-\r
-static int scnt=0;\r
-static int QUIT=0;\r
-static int XMIT=0;\r
-__thread int our_core;\r
-\r
-void benchmarks1(void);\r
-void benchmarks2(Pktlib_HeapHandle h , int n_trials);\r
-void benchmarks3(Pktlib_HeapHandle h , int n_trials);\r
-\r
-//sig handler\r
-void netTest_utilMySig(int x)\r
-{\r
-  QUIT=1;\r
-  scnt+=1;\r
-  printf(">ifdma-test: recv'd signal %d cnt=%d\n",x,scnt);\r
-  if (scnt > 10) {printf(">ifdma-test: WARNING EXITING WITH PROPER SHUTDOWN, LUTS LEFT ACTIVE\n");exit(1);}\r
-\r
-}\r
-void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],\r
-                         PKTIO_METADATA_T meta[], int n_pkts,\r
-                         uint64_t ts );\r
-\r
-\r
-/*************debug********************/\r
-void netTest_utilDumpDescr(unsigned long *p, int n)\r
-{\r
-   printf("--------dump of descriptor %d %x\n", n, (int) p);\r
-   printf("> %x %x %x %x %x %x %x %x\n",p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);\r
-   printf("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);\r
-   printf("-----------------------------\n");\r
-}\r
-void netTest_utilDumpHeader(unsigned long *p, int n, int a, int r)\r
-{\r
-   printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);\r
-   printf("> %x %x %x %x %x %x %x %x\n",p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);\r
-   printf("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);\r
-   printf("> %x %x %x %x %x %x %x %x\n",p[16],p[17],p[18],p[19],p[20],p[21],p[22],p[23]);\r
-   printf("> %x %x %x %x %x %x %x %x\n",p[24],p[25],p[26],p[27],p[28],p[29],p[30],p[31]);\r
-   printf("-----------------------------\n");\r
-}\r
-/*****************************************/\r
-\r
-\r
-\r
-\r
-\r
-\r
-\r
-/*******************************************\r
- *************NETAPI OBJECTS***************\r
- *****************************************/\r
-static NETAPI_CFG_T our_netapi_default_cfg=\r
-{\r
-TUNE_NETAPI_PERM_MEM_SZ,\r
-128,  //start of packet offset for hw to place data on rx for default flow\r
-TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system\r
-TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use\r
-TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap\r
-64, //#descriptors w/o buffers in default heap\r
-TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap\r
-128   ,  //tail room\r
-256      //extra room \r
-};\r
-\r
-Pktlib_HeapHandle OurHeap;     //default heap, used by producer\r
-PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};\r
-PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};\r
-PKTIO_HANDLE_T * netcp_rx_chan;\r
-PKTIO_HANDLE_T * netcp_tx_chan;\r
-NETAPI_T netapi_handle;\r
-\r
-PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};\r
-\r
-NETCP_CFG_ROUTE_T  test_route=\r
-{\r
-NULL, NULL  //* to be filled in\r
-};\r
-\r
-\r
-/*************************END NETAPI OBJECTS***********************/\r
-\r
-static unsigned char all_mac[]={0,0,0,0,0,0};\r
-\r
-\r
-\r
-//stats\r
-int pkt_rx=0; \r
-int pkt_tx=0; \r
-unsigned long long pkt_rx_cycles=0;\r
-unsigned long long pkt_tx_cycles=0;\r
-unsigned long long pkt_cb_cycles=0;\r
-\r
-\r
-//**********************************\r
-//producer thread\r
-//*********************************\r
-void producer_thread(int coreid)\r
-{\r
-int err;\r
-int i;\r
-Ti_Pkt * tip;\r
-unsigned char * pData;\r
-int len;\r
-PKTIO_METADATA_T meta = {PKTIO_META_IFDMA_TX,{0},0};\r
-int np;\r
-cpu_set_t cpu_set;\r
-unsigned long t1;\r
-unsigned long t2;\r
-\r
-    CPU_ZERO( &cpu_set);\r
-    CPU_SET( 2, &cpu_set);\r
-    hplib_utilSetupThread(2, &cpu_set);\r
-\r
-     //DAL we poll the default pktio channel for pkts from net\r
-      for(i=0;!((volatile) QUIT);i++)\r
-      {\r
-        t1 = netapi_timing_start();\r
-        np = netapi_pktioPoll(netcp_rx_chan,NULL,&err);\r
-        t2 = netapi_timing_start();\r
-        pkt_rx+=np;\r
-       if (np) \r
-        {\r
-           pkt_rx_cycles += (t2-t1);\r
-        }\r
-      }\r
-      printf("nt-bench: receiver  DONE %d pkts rx,  pkt poll cycles=% u; pkt rx cycle=%u pkt tx cycles=%u \n", pkt_rx,\r
-             (unsigned)  (pkt_rx ?  (pkt_rx_cycles - pkt_cb_cycles)/pkt_rx : 0),\r
-             (unsigned)  (pkt_rx ?  (pkt_rx_cycles) /pkt_rx : 0),\r
-             (unsigned)  (pkt_tx ?  (pkt_tx_cycles) /pkt_tx : 0)\r
-            );\r
-     printf("Leaving producer_thread\n");\r
-}\r
-\r
-\r
-//******************************\r
-//  main program\r
-//*****************************\r
-int main(int argc, char **argv)\r
-{\r
-    int err,i;\r
-    int32_t             errCode;\r
-    Pktlib_HeapIfTable*  pPktifTable;\r
-    Pktlib_HeapCfg heapCfg;\r
-    long t1, t2 ;\r
-    cpu_set_t cpu_set;\r
-\r
-\r
-     //install signal handler for ^c\r
-    signal(SIGINT,netTest_utilMySig);\r
-\r
-\r
-\r
-\r
-\r
-\r
-    CPU_ZERO( &cpu_set);\r
-    CPU_SET( 0, &cpu_set);\r
-    hplib_utilSetupThread(2, &cpu_set);\r
-\r
-\r
-    /*******************************************/\r
-    /*************NETAPI STARTUP****************/\r
-    /*******************************************/\r
-\r
-    /* create netapi */\r
-    netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);\r
-    netapi_netcpCfgExceptions(netapi_handle, NETCP_CFG_ALL_EXCEPTIONS, NETCP_CFG_ACTION_DISCARD, (NETCP_CFG_ROUTE_HANDLE_T) NULL);\r
-\r
-    /* open the main heap */\r
-    OurHeap = Pktlib_findHeapByName("netapi");\r
-    if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}\r
-\r
-    //if we want to relay network packets, we create a handle to the \r
-    //default netcp receive queue here\r
-    netcp_rx_chan= netapi_pktioOpen(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb_net, &netcp_rx_cfg,  &err);\r
-    if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}\r
-\r
-    netcp_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_TX, (PKTIO_CB) NULL, &netcp_tx_cfg,  &err);\r
-    if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}\r
-\r
-/*********************************************/\r
-/*****************end NETAPI STARTUP**********/\r
-/*********************************************/\r
-\r
-/*************************************************\r
-********************some basic benchmarks*********\r
-**************************************************/\r
-printf("\n\n*******STARTING MEM ACCESS BENCHMARK*********\n\n");\r
-benchmarks1();\r
-printf("\n\n*******STARTING RAW BENCHMARK2*********\n\n");\r
-benchmarks2(OurHeap, 20);\r
-printf("\n\n*******STARTING RAW BENCHMARK3*********\n\n");\r
-benchmarks3(OurHeap, 20);\r
-printf("\n\n******STARTING RECV BENCHMARK (q to quit)*****\n\n");\r
-\r
-\r
-//now creaate a simple netcp rule\r
-//to get a lot of packets\r
-netapi_netcpCfgCreateMacInterface(\r
-                  netapi_handle,\r
-                  &all_mac[0],\r
-                  0,0,\r
-                  (NETCP_CFG_ROUTE_HANDLE_T)  NULL,\r
-                  (NETCP_CFG_VLAN_T ) NULL ,  //future\r
-                  1,\r
-                  &err);\r
-\r
-//**************************************\r
-//Create a worked thread\r
-//***************************************\r
-{\r
-       pthread_t *thrs;\r
-        int procs =1; \r
-        char c;\r
-        thrs = malloc( sizeof( pthread_t ) * procs );\r
-        if (thrs == NULL)\r
-        {\r
-                perror( "malloc" );\r
-                return -1;\r
-        }\r
-        printf( "benchmark-test: Starting %d threads...\n", procs );\r
-\r
-        if (pthread_create( &thrs[0], NULL, (void*)producer_thread,\r
-                        (void *)0 ))\r
-        {\r
-                        perror( "pthread_create" );\r
-                        exit(1);\r
-        }\r
-        //this thread of execution (main) now just waits on user input\r
-        for(;;)\r
-        {\r
-           printf(">");\r
-           c=getchar();\r
-           if (c=='q') {QUIT=1;break;}\r
-           if (c=='t') {XMIT=!XMIT; printf("XMIT= %d\n", XMIT); }\r
-           else if (c=='s') printf(">IFDMA-TEST STATS:    %d received   %d xmitted \n", pkt_rx,pkt_tx);\r
-           else if (c=='h') printf("> 'q' to quit,  's' for stats, 't' to toggle transmit  'h' for help\n");\r
-        }\r
-\r
-        //wait for completion \r
-        printf("main task now pending on thread completion\n");\r
-        for (i = 0; i < procs; i++)\r
-                pthread_join( thrs[i], NULL );\r
-\r
-        free( thrs );\r
-      \r
-}\r
-\r
-/*************************************************\r
- ************CLEAN UP****************************\r
- ************************************************/\r
-//get rid of rule, in the case that we are relaying packets\r
-//also close our netcp rx channel\r
-netapi_netcpCfgDelMac(netapi_handle,0,&err);\r
-netapi_pktioClose(netcp_rx_chan,&err);\r
-netapi_pktioClose(netcp_tx_chan,&err);\r
-\r
-\r
-//done\r
-netapi_shutdown(netapi_handle);\r
-\r
-\r
-//!finished!\r
-}\r
-static inline void sendit(Ti_Pkt *tip, int len, int out_port)\r
-{\r
-  int err=0;\r
-  PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};\r
-  nwalTxPktInfo_t meta_tx2={0};\r
-  if (len<60)\r
-  {\r
-     unsigned int templen;\r
-     char * p_pkt;\r
-     len=60;\r
-     Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen\r
-     Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);\r
-  }\r
-  Pktlib_setPacketLen(tip,len);\r
-  meta_tx2.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID ; \r
-  meta_tx2.ploadLen = len ;\r
-  meta_tx2.enetPort=out_port;\r
-  meta2.u.tx_meta=&meta_tx2;\r
-  netapi_pktioSend(netcp_tx_chan,tip,&meta2,&err);\r
-}\r
-\r
-//receive callback for packets from net (for consumer)\r
-void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],\r
-                         PKTIO_METADATA_T meta[], int n_pkts,\r
-                         uint64_t ts )\r
-{\r
-int i;\r
-Ti_Pkt * tip;\r
-int len;\r
-unsigned long t1;\r
-unsigned long t2;\r
-unsigned long t3;\r
-unsigned long t4;\r
-pasahoLongInfo_t* protoInfo; \r
-int ifno;\r
-int out_port;\r
-\r
-t1= netapi_timing_start();\r
-for(i=0;i<n_pkts;i++)\r
-{\r
-    tip = p_recv[i];\r
-    len = Pktlib_getPacketLen(tip);\r
-    if (XMIT)\r
-    {\r
-        protoInfo=nwal_mGetProtoInfo(tip);\r
-        ifno = nwal_mGetRxEmacPort( protoInfo);\r
-        //----------------------------------------------------\r
-        //very trivial bridging -> just output to other port!\r
-        //----------------------------------------------------\r
-        if (ifno ==1) out_port=2; else out_port=1;\r
-\r
-       t3= netapi_timing_start();\r
-       sendit(tip,len,out_port);\r
-       pkt_tx+=1;\r
-       t4= netapi_timing_start();\r
-       pkt_tx_cycles += (t4-t3);\r
-    }\r
-    else\r
-      Pktlib_freePacket((Ti_Pkt*)tip);\r
-}\r
-t2 = netapi_timing_start();\r
-pkt_cb_cycles += (t2-t1);\r
-}\r
-\r
-\r
-\r
-\r
-//SOME BENCHMARKS\r
-//sonme benchmarks\r
-void benchmarks1(void)\r
-{\r
-int i,j;\r
-unsigned long v1pop;\r
-unsigned long v2pop;\r
-unsigned long v1push;\r
-unsigned long v2push;\r
-unsigned long v1read;\r
-unsigned long v2read;\r
-unsigned long v1write;\r
-unsigned long v2write;\r
-unsigned long v1read2;\r
-unsigned long v2read2;\r
-#define N 100\r
-Ti_Pkt  pkts[N];\r
-unsigned char * p_pkt;\r
-int len;\r
-int sum=0;\r
-int sum2=0;\r
-char *p=(char *) malloc(1000);\r
-//alloc\r
-v1pop=netapi_timing_start();\r
-for(i=0;i<N;i++)   pkts[i]= Pktlib_allocPacket(OurHeap,1000);\r
-v2pop = netapi_timing_start();\r
-\r
-//write access\r
-Pktlib_getDataBuffer(pkts[0],(uint8_t**)&p_pkt,&len);\r
-v1write=netapi_timing_start();\r
-for(i=0;i<1000;i++) p_pkt[i]=i;\r
-v2write=netapi_timing_start();\r
-\r
-//read access\r
-v1read=netapi_timing_start();\r
-for(j=0;j<10;j++)\r
-for(i=0;i<1000;i++) sum+=p_pkt[i];\r
-v2read=netapi_timing_start();\r
-\r
-// access (from malloc)\r
-v1read2=netapi_timing_start();\r
-for(i=0;i<1000;i++) sum2+=p[i];\r
-v2read2=netapi_timing_start();\r
-\r
-//free packet\r
-v1push=netapi_timing_start();\r
-for(i=0;i<N;i++)   Pktlib_freePacket(pkts[i]);\r
-v2push = netapi_timing_start();\r
-\r
-//resutls\r
-printf("allocs= %d  free=%d   write=%d  read=%d read-malloc=%d (sum=%d %d)\n",\r
-        (v2pop-v1pop)/N, (v2push-v1push)/N,  (v2write-v1write)/1000, (v2read-v1read)/10000,\r
-        (v2read2-v1read2)/1000,sum,sum2);\r
-\r
-\r
-};\r
-\r
-\r
-//raw queue benchmark\r
-#include "ti/drv/nwal/nwal_util.h"\r
-\r
-#define NTOPOP 150\r
-volatile unsigned long t1;\r
-volatile unsigned long t2;\r
-volatile unsigned long t3;\r
-volatile unsigned long t4;\r
-volatile unsigned long t5;\r
-volatile unsigned long t6;\r
-volatile unsigned long sum1=0;\r
-volatile unsigned long sum2=0;\r
-volatile unsigned long sum3=0;\r
-volatile unsigned long sum4=0;\r
-volatile Ti_Pkt * pHd[NTOPOP];\r
-\r
-void * pop_raw(int n)\r
-{\r
-\r
-}\r
-void * p2v (void* in)\r
-{\r
-\r
-\r
-}\r
-void * v2p(void * in)\r
-{\r
-\r
-}\r
-void push_raw(void *pkt, int n)\r
-{\r
-\r
-}\r
-\r
-void benchmarks2(Pktlib_HeapHandle h , int ntrials)\r
-{\r
-int i,j;\r
-int k;\r
-int abort=0;\r
-Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);\r
-\r
-//n_trials of NTOPOP actions\r
-for(i=0;i<ntrials;i++)\r
-{\r
-    abort=0;\r
-    sum1=sum2=sum3=sum4=0;\r
-    //raw pop\r
-    t1= netapi_timing_start();\r
-    for(j=0;j<NTOPOP;j++)\r
-    {\r
-       pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (freeQ));\r
-       if (!pHd[j]) \r
-       {\r
-         printf("abort test. out of descriptors\n"); abort=1;\r
-         break;\r
-       }\r
-    }\r
-    t2= netapi_timing_start();\r
-    k=j;\r
-    for(j=0;j<k;j++)\r
-    {\r
-       pHd[j]  =  Osal_qmssConvertDescPhyToVirt(pHd[j]);\r
-    }\r
-    t3= netapi_timing_start();\r
-    sum1 += (t2-t1);\r
-    sum2 += (t3-t2);\r
-    //raw push\r
-    t4= netapi_timing_start();\r
-    for(j=0;j<k;j++)\r
-    {\r
-       if (!pHd[j]) continue;\r
-       pHd[j]= Osal_qmssConvertDescVirtToPhy(pHd[j]);\r
-    }\r
-    t5= netapi_timing_start();\r
-    for(j=0;j<k;j++)\r
-    {\r
-      pktio_mQmssQueuePushDescSizeRaw(freeQ,\r
-                                             (void *) pHd[j],\r
-                                             128);\r
-    }\r
-    t6= netapi_timing_start();\r
-    sum3 += (t5-t4);\r
-    sum4 += (t6-t5);\r
-\r
-    if (!abort)\r
-    printf("nt=%d raw pop=%d  p2v=%d v2p=%d raw push=%d\n", i,\r
-             sum1/k,  sum2/k, sum3/k, sum4/k);\r
-    sleep(1);\r
-}\r
-return;\r
-}\r
-\r
-//full queue push/pops\r
-void benchmarks3(Pktlib_HeapHandle h , int ntrials)\r
-{\r
-int i,j;\r
-int k;\r
-int abort=0;\r
-Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);\r
-\r
-//n_trials of NTOPOP actions\r
-for(i=0;i<ntrials;i++)\r
-{\r
-    abort=0;\r
-    sum2=sum4=0;\r
-    //raw pop\r
-    t1= netapi_timing_start();\r
-    for(j=0;j<NTOPOP;j++)\r
-    {\r
-       pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(Qmss_queuePop(freeQ));\r
-       if (!pHd[j])\r
-       {\r
-         printf("abort test. out of descriptors\n"); abort=1;\r
-         break;\r
-       }\r
-    }\r
-    t3= netapi_timing_start();\r
-    sum2 += (t3-t1);\r
-    k=j;\r
-    //raw push\r
-    t5= netapi_timing_start();\r
-    for(j=0;j<k;j++)\r
-    {\r
-       if (!pHd[j]) continue;\r
-       Qmss_queuePushDescSize(freeQ, pHd[j], 128);\r
-    }\r
-    t6= netapi_timing_start();\r
-    sum4 += (t6-t5);\r
-    if (!abort)\r
-    printf("nt=%d pop=%d  push=%d\n", i,\r
-              sum2/k, sum4/k);\r
-    sleep(1);\r
-}\r
-return;\r
-}\r
-\r
+/******************************************
+ * File: nt_bench.c   
+ * Purpose:  benchmarks for NT.
+ **************************************************************
+ * FILE:  nt_bench.c
+ * 
+ * DESCRIPTION:  netapi user space transport
+ *               library  test application : benchmarks
+ * 
+ * REVISION HISTORY:  rev 0.0.1 
+ *
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ *****************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <pthread.h>
+#include <sched.h>
+
+#include "trie.h"
+#include "string.h"
+#include "netapi.h"
+#include "pktio.h"
+#include "net_test.h"
+#include <ti/drv/sa/salld.h>
+
+#define netapi_timing_start hplib_mUtilGetPmuCCNT
+
+static int scnt=0;
+static int QUIT=0;
+static int XMIT=0;
+static int CAP=0;
+volatile int RESET=0; //to reset stats
+
+__thread int our_core;
+
+void benchmarks1(void);
+void benchmarks2(Pktlib_HeapHandle h , int n_trials);
+void benchmarks3(Pktlib_HeapHandle h , int n_trials);
+
+//sig handler
+void netTest_utilMySig(int x)
+{
+  QUIT=1;
+  scnt+=1;
+  printf(">ifdma-test: recv'd signal %d cnt=%d\n",x,scnt);
+  if (scnt > 10) {printf(">ifdma-test: WARNING EXITING WITH PROPER SHUTDOWN, LUTS LEFT ACTIVE\n");exit(1);}
+
+}
+void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
+                         PKTIO_METADATA_T meta[], int n_pkts,
+                         uint64_t ts );
+
+
+/*************debug********************/
+void netTest_utilDumpDescr(unsigned long *p, int n)
+{
+   printf("--------dump of descriptor %d %x\n", n, (int) p);
+   printf("> %x %x %x %x %x %x %x %x\n",p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
+   printf("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);
+   printf("-----------------------------\n");
+}
+void netTest_utilDumpHeader(unsigned long *p, int n, int a, int r)
+{
+   printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);
+   printf("> %0x %0x %0x %0x %0x %0x %0x %0x\n",
+          ntohl(p[0]),ntohl(p[1]),ntohl(p[2]),ntohl(p[3]),
+          ntohl(p[4]),ntohl(p[5]),ntohl(p[6]),ntohl(p[7]) );
+#if 0
+   printf("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);
+   printf("> %x %x %x %x %x %x %x %x\n",p[16],p[17],p[18],p[19],p[20],p[21],p[22],p[23]);
+   printf("> %x %x %x %x %x %x %x %x\n",p[24],p[25],p[26],p[27],p[28],p[29],p[30],p[31]);
+#endif
+   printf("-----------------------------\n");
+}
+/*****************************************/
+
+
+unsigned long long CALIB=0;
+unsigned long long calibrate_idle(void)
+{
+volatile unsigned long long  at1;
+volatile unsigned long long  at2;
+volatile unsigned long pt1;
+volatile unsigned long pt2;
+unsigned long long calib;
+at1 = hplib_mUtilGetTimestamp();
+pt1=netapi_timing_start();
+for(;;)
+{
+   pt2=netapi_timing_start()   ;
+   if ((pt2-pt1) >= 100000) break;
+}
+at2 = hplib_mUtilGetTimestamp();
+
+calib = ((unsigned long long) (pt2-pt1))/(at2-at1);
+printf("calibrate:   arm time=%lld  -> arm cycles=%d calib=%lld\n", at2-at1, pt2-pt1, calib);
+
+return calib;
+}
+
+/*******************************************
+ *************NETAPI OBJECTS***************
+ *****************************************/
+static NETAPI_CFG_T our_netapi_default_cfg=
+{
+TUNE_NETAPI_PERM_MEM_SZ,
+128,  //start of packet offset for hw to place data on rx for default flow
+TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
+TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
+TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
+64, //#descriptors w/o buffers in default heap
+TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
+128   ,  //tail room
+256      //extra room 
+};
+
+Pktlib_HeapHandle OurHeap;     //default heap, used by producer
+PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 12};
+PKTIO_HANDLE_T * netcp_rx_chan;
+PKTIO_HANDLE_T * netcp_tx_chan;
+NETAPI_T netapi_handle;
+
+PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};
+PKTIO_CONTROL_T poll_cannel_control={PKTIO_SET_POLL_FLAGS, NULL, nwal_POLL_DEFAULT_GLOB_PKT_Q};
+
+//template for fast path
+nwalTxPktInfo_t txPktInfoNoCrypto =
+{
+    NULL,                                                                                               /* p_pkt */
+    NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
+    0,                                                                                                  /* lpbackPass */
+    0,                                                                                                  /* enetport */
+    0,                                                                                                  /* msuSize */
+    0,                                                                                                   /* startOffset */
+    0,                                                    /* saOffBytes */
+    0,                                                                                                  /* saPayLoadLen */
+    0               ,                                                                                    /* saAhIcvOffBytes */
+    0,                                                                                                 /* saAhMacSize */
+    0,                                              
+   /* etherLenOffBytes */
+    netTest_MAC_HEADER_LEN,         /* ipOffBytes */
+    netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN,                                        /* l4OffBytes */
+    netTest_UDP_HEADER_LEN,                                                             /* l4HdrLen */
+    0,                                                                         /* pseudoHdrChecksum */
+    0                                                                                                   /* pLoadLen */
+};
+
+
+NETCP_CFG_ROUTE_T  test_route=
+{
+NULL, NULL  //* to be filled in
+};
+
+
+/*************************END NETAPI OBJECTS***********************/
+
+static unsigned char all_mac[]={0,0,0,0,0,0};
+
+static unsigned long last_header[32/sizeof(unsigned long)];
+
+
+//stats
+int pkt_rx=0; 
+int pkt_tx=0; 
+unsigned long long pkt_rx_cycles=0L;
+unsigned long long pkt_tx_cycles=0L;
+unsigned long long pkt_cb_cycles=0L;
+unsigned long long idle_cycles=0L;
+volatile unsigned long long start_time;
+unsigned long long end_time;
+
+//**********************************
+//producer thread
+//*********************************
+void producer_thread(int coreid)
+{
+int err;
+int i;
+Ti_Pkt * tip;
+unsigned char * pData;
+int len;
+PKTIO_METADATA_T meta = {PKTIO_META_IFDMA_TX,{0},0};
+int np;
+cpu_set_t cpu_set;
+unsigned long t1;
+unsigned long t2;
+
+    CPU_ZERO( &cpu_set);
+    CPU_SET( 2, &cpu_set);
+    hplib_utilSetupThread(2, &cpu_set);
+    start_time = hplib_mUtilGetTimestamp();
+
+     //DAL we poll the default pktio channel for pkts from net
+      for(i=0;!((volatile) QUIT);i++)
+      {
+        t1 = netapi_timing_start();
+        np = netapi_pktioPoll(netcp_rx_chan,NULL,&err);
+        t2 = netapi_timing_start();
+        pkt_rx+=np;
+       if (np) 
+        {
+           pkt_rx_cycles += (t2-t1);
+        }
+        else
+        {
+          idle_cycles += (t2-t1);
+        }
+        if (RESET)
+        {
+              idle_cycles=0LL;
+              start_time = hplib_mUtilGetTimestamp();
+              pkt_rx=pkt_tx=0;
+              pkt_rx_cycles=pkt_tx_cycles=0LL;
+              pkt_cb_cycles=0LL;
+              RESET=0;
+        }
+      }
+      end_time = hplib_mUtilGetTimestamp();
+      printf("nt-bench: receiver  DONE %d pkts rx,  pkt poll cycles=% u; pkt rx cycle=%u pkt tx cycles=%u idle cycles=%lld duration=%lld ticks idle pct= %lld\n",
+             pkt_rx,
+             (unsigned)  (pkt_rx ?  (pkt_rx_cycles - pkt_cb_cycles)/pkt_rx : 0),
+             (unsigned)  (pkt_rx ?  (pkt_rx_cycles) /pkt_rx : 0),
+             (unsigned)  (pkt_tx ?  (pkt_tx_cycles) /pkt_tx : 0),
+             idle_cycles, (end_time-start_time), 
+             (idle_cycles*100) /( CALIB* (end_time-start_time))
+
+            );
+     printf("Leaving producer_thread\n");
+}
+
+
+//******************************
+//  main program
+//*****************************
+int main(int argc, char **argv)
+{
+    int err,i;
+    int32_t             errCode;
+    Pktlib_HeapIfTable*  pPktifTable;
+    Pktlib_HeapCfg heapCfg;
+    long t1, t2 ;
+    cpu_set_t cpu_set;
+
+
+     //install signal handler for ^c
+    signal(SIGINT,netTest_utilMySig);
+
+
+
+
+
+
+    CPU_ZERO( &cpu_set);
+    CPU_SET( 0, &cpu_set);
+    hplib_utilSetupThread(2, &cpu_set);
+
+
+    /*******************************************/
+    /*************NETAPI STARTUP****************/
+    /*******************************************/
+
+    /* create netapi */
+    netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
+    if (netapi_handle == NULL)
+    {
+        printf("main: netapi_init failure, exiting\n");
+        exit(1);
+    }
+    netapi_netcpCfgExceptions(netapi_handle, NETCP_CFG_ALL_EXCEPTIONS, NETCP_CFG_ACTION_DISCARD, (NETCP_CFG_ROUTE_HANDLE_T) NULL);
+
+    /* open the main heap */
+    OurHeap = Pktlib_findHeapByName("netapi");
+    if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}
+
+    //if we want to relay network packets, we create a handle to the 
+    //default netcp receive queue here
+    netcp_rx_chan= netapi_pktioOpen(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb_net, &netcp_rx_cfg,  &err);
+    if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}
+
+    netcp_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_TX, (PKTIO_CB) NULL, &netcp_tx_cfg,  &err);
+    if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}
+    else  //install a fast path template into the NETCP TX channel
+    {
+            PKTIO_CONTROL_T control2;
+            control2.op = PKTIO_UPDATE_FAST_PATH;
+            PKTIO_CFG_T cfg2;
+            cfg2.fast_path_cfg.fp_send_option = PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT;
+            cfg2.fast_path_cfg.txPktInfo= &txPktInfoNoCrypto;
+            netapi_pktioControl(netcp_tx_chan, NULL, &cfg2, &control2, &err);
+   }
+
+
+/*********************************************/
+/*****************end NETAPI STARTUP**********/
+/*********************************************/
+
+/*************************************************
+********************some basic benchmarks*********
+**************************************************/
+printf("\n\n*******STARTING MEM ACCESS BENCHMARK*********\n\n");
+benchmarks1();
+printf("\n\n*******STARTING RAW BENCHMARK2*********\n\n");
+benchmarks2(OurHeap, 20);
+printf("\n\n*******STARTING RAW BENCHMARK3*********\n\n");
+benchmarks3(OurHeap, 20);
+printf("\n\n******STARTING RECV BENCHMARK (q to quit)*****\n\n");
+
+
+//now creaate a simple netcp rule
+//to get a lot of packets
+netapi_netcpCfgCreateMacInterface(
+                  netapi_handle,
+                  &all_mac[0],
+                  0,0,
+                  (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
+                  (NETCP_CFG_VLAN_T ) NULL ,  //future
+                  1,
+                  &err);
+
+//calibrate idle
+        CALIB = calibrate_idle();
+
+//**************************************
+//Create a worked thread
+//***************************************
+{
+       pthread_t *thrs;
+        int procs =1; 
+        char c;
+        thrs = malloc( sizeof( pthread_t ) * procs );
+        if (thrs == NULL)
+        {
+                perror( "malloc" );
+                return -1;
+        }
+        printf( "benchmark-test: Starting %d threads...\n", procs );
+
+        if (pthread_create( &thrs[0], NULL, (void*)producer_thread,
+                        (void *)0 ))
+        {
+                        perror( "pthread_create" );
+                        exit(1);
+        }
+        //this thread of execution (main) now just waits on user input
+        for(;;)
+        {
+           printf(">");
+           c=getchar();
+           if (c=='c') {CAP=!CAP; printf("CAPTURE= %d\n", CAP); }
+           else if (c=='q') {QUIT=1;break;}
+           else if (c=='t') {XMIT=!XMIT; printf("XMIT= %d\n", XMIT); }
+           else if (c=='s') 
+           {
+              unsigned long long et= hplib_mUtilGetTimestamp();
+              printf(">NT_BENCH STATS:    %d received   %d xmitted,   %lld idle cycles,  %lld duration ticks  idle=%lld\n",
+                       pkt_rx,pkt_tx,
+                       idle_cycles,
+                       (et-start_time),
+                       (idle_cycles*100)/(CALIB*(et-start_time))
+                    );
+           }
+           else if (c=='r')
+           {
+              RESET=1;
+           }
+           else if (c=='h')
+           {
+                printf("> 'q' to quit,  's' for stats, 't' to toggle transmit  'c' to toggle capture, 'd' to dump capture, 'r' to reset idle counters,  'h' for help\n");
+           }
+           else if (c=='d')
+           {
+              netTest_utilDumpHeader(&last_header[0], 0,0,0);
+           }
+        }
+
+        //wait for completion 
+        printf("main task now pending on thread completion\n");
+        for (i = 0; i < procs; i++)
+                pthread_join( thrs[i], NULL );
+
+        free( thrs );
+      
+}
+
+/*************************************************
+ ************CLEAN UP****************************
+ ************************************************/
+//get rid of rule, in the case that we are relaying packets
+//also close our netcp rx channel
+netapi_netcpCfgDelMac(netapi_handle,0,&err);
+netapi_pktioClose(netcp_rx_chan,&err);
+netapi_pktioClose(netcp_tx_chan,&err);
+
+
+//done
+netapi_shutdown(netapi_handle);
+
+
+//!finished!
+}
+static inline void sendit(Ti_Pkt *tip, int len, int out_port)
+{
+  int err=0;
+  PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
+  nwalTxPktInfo_t meta_tx2={0};
+  if (len<60)
+  {
+     unsigned int templen;
+     char * p_pkt;
+     len=60;
+     Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
+     Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
+  }
+  Pktlib_setPacketLen(tip,len);
+  meta_tx2.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID ; 
+  meta_tx2.ploadLen = len ;
+  meta_tx2.enetPort=out_port;
+  meta2.u.tx_meta=&meta_tx2;
+  netapi_pktioSend(netcp_tx_chan,tip,&meta2,&err);
+}
+
+//receive callback for packets from net (for consumer)
+void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
+                         PKTIO_METADATA_T meta[], int n_pkts,
+                         uint64_t ts )
+{
+int i;
+Ti_Pkt * tip;
+int len;
+unsigned long t1;
+unsigned long t2;
+unsigned long t3;
+unsigned long t4;
+pasahoLongInfo_t* protoInfo; 
+int ifno;
+int out_port;
+
+t1= netapi_timing_start();
+for(i=0;i<n_pkts;i++)
+{
+    tip = p_recv[i];
+    len = Pktlib_getPacketLen(tip);
+
+    if (CAP)
+    {
+       unsigned int templen;
+       char * p_pkt;
+       Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
+       memcpy(last_header,p_pkt,32);
+    }
+
+    if (XMIT)
+    {
+        protoInfo=nwal_mGetProtoInfo(tip);
+        ifno = nwal_mGetRxEmacPort( protoInfo);
+        //----------------------------------------------------
+        //very trivial bridging -> just output to other port!
+        //----------------------------------------------------
+        if (ifno ==1) out_port=2; else out_port=1;
+        t3= netapi_timing_start();
+        sendit(tip,len,out_port);
+        pkt_tx+=1;
+        t4= netapi_timing_start();
+        pkt_tx_cycles += (t4-t3);
+    }
+    else
+    {
+      Pktlib_freePacket((Ti_Pkt*)tip);
+    }
+}
+t2 = netapi_timing_start();
+pkt_cb_cycles += (t2-t1);
+}
+
+
+
+
+//SOME BENCHMARKS
+//sonme benchmarks
+void benchmarks1(void)
+{
+int i,j;
+unsigned long v1pop;
+unsigned long v2pop;
+unsigned long v1push;
+unsigned long v2push;
+unsigned long v1read;
+unsigned long v2read;
+unsigned long v1write;
+unsigned long v2write;
+unsigned long v1read2;
+unsigned long v2read2;
+#define N 100
+Ti_Pkt  pkts[N];
+unsigned char * p_pkt;
+int len;
+int sum=0;
+int sum2=0;
+char *p=(char *) malloc(1000);
+//alloc
+v1pop=netapi_timing_start();
+for(i=0;i<N;i++)   pkts[i]= Pktlib_allocPacket(OurHeap,1000);
+v2pop = netapi_timing_start();
+
+//write access
+Pktlib_getDataBuffer(pkts[0],(uint8_t**)&p_pkt,&len);
+v1write=netapi_timing_start();
+for(i=0;i<1000;i++) p_pkt[i]=i;
+v2write=netapi_timing_start();
+
+//read access
+v1read=netapi_timing_start();
+for(j=0;j<10;j++)
+for(i=0;i<1000;i++) sum+=p_pkt[i];
+v2read=netapi_timing_start();
+
+// access (from malloc)
+v1read2=netapi_timing_start();
+for(i=0;i<1000;i++) sum2+=p[i];
+v2read2=netapi_timing_start();
+
+//free packet
+v1push=netapi_timing_start();
+for(i=0;i<N;i++)   Pktlib_freePacket(pkts[i]);
+v2push = netapi_timing_start();
+
+//resutls
+printf("allocs= %d  free=%d   write=%d  read=%d read-malloc=%d (sum=%d %d)\n",
+        (v2pop-v1pop)/N, (v2push-v1push)/N,  (v2write-v1write)/1000, (v2read-v1read)/10000,
+        (v2read2-v1read2)/1000,sum,sum2);
+
+
+};
+
+
+//raw queue benchmark
+#include "ti/drv/nwal/nwal_util.h"
+
+#define NTOPOP 150
+volatile unsigned long t1;
+volatile unsigned long t2;
+volatile unsigned long t3;
+volatile unsigned long t4;
+volatile unsigned long t5;
+volatile unsigned long t6;
+volatile unsigned long sum1=0;
+volatile unsigned long sum2=0;
+volatile unsigned long sum3=0;
+volatile unsigned long sum4=0;
+volatile Ti_Pkt * pHd[NTOPOP];
+
+void * pop_raw(int n)
+{
+
+}
+void * p2v (void* in)
+{
+
+
+}
+void * v2p(void * in)
+{
+
+}
+void push_raw(void *pkt, int n)
+{
+
+}
+
+void benchmarks2(Pktlib_HeapHandle h , int ntrials)
+{
+int i,j;
+int k;
+int abort=0;
+Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
+
+//n_trials of NTOPOP actions
+for(i=0;i<ntrials;i++)
+{
+    abort=0;
+    sum1=sum2=sum3=sum4=0;
+    //raw pop
+    t1= netapi_timing_start();
+    for(j=0;j<NTOPOP;j++)
+    {
+       pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (freeQ));
+       if (!pHd[j]) 
+       {
+         printf("abort test. out of descriptors\n"); abort=1;
+         break;
+       }
+    }
+    t2= netapi_timing_start();
+    k=j;
+    for(j=0;j<k;j++)
+    {
+       pHd[j]  =  Osal_qmssConvertDescPhyToVirt(pHd[j]);
+    }
+    t3= netapi_timing_start();
+    sum1 += (t2-t1);
+    sum2 += (t3-t2);
+    //raw push
+    t4= netapi_timing_start();
+    for(j=0;j<k;j++)
+    {
+       if (!pHd[j]) continue;
+       pHd[j]= Osal_qmssConvertDescVirtToPhy(pHd[j]);
+    }
+    t5= netapi_timing_start();
+    for(j=0;j<k;j++)
+    {
+      pktio_mQmssQueuePushDescSizeRaw(freeQ,
+                                             (void *) pHd[j],
+                                             128);
+    }
+    t6= netapi_timing_start();
+    sum3 += (t5-t4);
+    sum4 += (t6-t5);
+
+    if (!abort)
+    printf("nt=%d raw pop=%d  p2v=%d v2p=%d raw push=%d\n", i,
+             sum1/k,  sum2/k, sum3/k, sum4/k);
+    sleep(1);
+}
+return;
+}
+
+//full queue push/pops
+void benchmarks3(Pktlib_HeapHandle h , int ntrials)
+{
+int i,j;
+int k;
+int abort=0;
+Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
+
+//n_trials of NTOPOP actions
+for(i=0;i<ntrials;i++)
+{
+    abort=0;
+    sum2=sum4=0;
+    //raw pop
+    t1= netapi_timing_start();
+    for(j=0;j<NTOPOP;j++)
+    {
+       pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(Qmss_queuePop(freeQ));
+       if (!pHd[j])
+       {
+         printf("abort test. out of descriptors\n"); abort=1;
+         break;
+       }
+    }
+    t3= netapi_timing_start();
+    sum2 += (t3-t1);
+    k=j;
+    //raw push
+    t5= netapi_timing_start();
+    for(j=0;j<k;j++)
+    {
+       if (!pHd[j]) continue;
+       Qmss_queuePushDescSize(freeQ, pHd[j], 128);
+    }
+    t6= netapi_timing_start();
+    sum4 += (t6-t5);
+    if (!abort)
+    printf("nt=%d pop=%d  push=%d\n", i,
+              sum2/k, sum4/k);
+    sleep(1);
+}
+return;
+}
+
index 3730bf7777472fad7797e5249eb872f5eb75ac6a..1a07f690ec4182783b32d3d2fe9335eb34c47ddd 100755 (executable)
@@ -525,7 +525,11 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
     uint8_t p_add[8];
     uint8_t p_add1[1500];
     int16_t       retVal;
-
+    unsigned long t1;
+    unsigned long t2;
+    unsigned long long ct1;
+    unsigned long long ct2;
+    unsigned long long n_c_ops;
     nwalGlobCxtInfo_t   nwalGlobCxt;
     nwalLocCxtInfo_t    nwalLocCxt;
 
@@ -540,6 +544,9 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
 #endif
     p_head=&temp_head;
 
+    t1=hplib_mUtilGetPmuCCNT();
+    ct1 =Osal_cache_op_measure(&n_c_ops);
+
     /* loop over received pkts */
     for(i=0;i<n_pkts;i++)
     {
@@ -699,13 +706,17 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
         {
             if (!netTest_utilCheckHeader(p_head,&meta[i]))
             {
-                stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
+                stats[coreid].n_bad+=1;Pktlib_freePacket(tip);
                 continue;
             }
             //just flip and send
             flip_and_send_pkt(tip,p_pkt,len,0, enet_port);
         }
     }
+    t2=hplib_mUtilGetPmuCCNT();
+    ct2 =Osal_cache_op_measure(&n_c_ops);
+    stats[coreid].app_cycles +=  (unsigned long long) (t2-t1);
+    stats[coreid].tx_cache_cycles += (unsigned long long) (ct2-ct1);
 }
 
 /* Templates to build command labels at startup up time, required by open_pktio_tx_channels() */
@@ -970,15 +981,19 @@ void slow_path_thread(uint32_t index)
     }
     hplib_utilSetupThread(thread_num, &cpu_set);
 #endif
-    worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
-
+    worker_nh[thread_num] = netapi_init(NETAPI_CORE_MASTER,NULL);
+    if (worker_nh[thread_num] == NULL)
+    {
+        printf("slow_path_thread: netapi_init failure, exiting\n");
+        exit(1);
+    }
     netapi_setCookie(worker_nh[thread_num],(void*)(thread_num | NET_TEST_SP_THREAD_MASK));
 
     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
     if (!scheduler[thread_num]) 
     {
         printf("sched create failed for core%d\n",thread_num);
-        exit(1);
+        goto ERR_slow_path_thread;
     }
     scheduler[thread_num]->config.yield = TRUE;
     scheduler[thread_num]->config.pollGarbageQ = TRUE;
@@ -987,6 +1002,7 @@ void slow_path_thread(uint32_t index)
     /* Entry point to scheduler */
     netapi_schedRun(scheduler[thread_num], &err);
 
+ERR_slow_path_thread:
     netapi_shutdown(worker_nh[thread_num]);
 }
 
@@ -1020,22 +1036,26 @@ void fast_path_thread(uint32_t index)
     hplib_utilSetupThread(thread_num, &cpu_set);
 #endif
     worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
-
-   /* open netcp default RX channels*/
+    if (worker_nh[thread_num] == NULL)
+    {
+        printf("fast_path_thread: netapi_init failure, exiting\n");
+        exit(1);
+    }
+    /* open netcp default RX channels*/
     rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
 
     /* create a pktio channel for specially classified pkts */
     /* open netcp default tx, rx queues for sideband crypto */
-     //sb_tx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
-     sb_rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
+    sb_rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
 
     netapi_setCookie(worker_nh[thread_num],(void*)thread_num);
     
     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
     if (!scheduler[thread_num]) 
         {
-        printf("sched create failed for core%d\n",thread_num); 
-        exit(1);
+        printf("sched create failed for core%d\n",thread_num);
+        goto ERR_fast_path_thread;
+        //exit(1);
     }
 
  
@@ -1046,9 +1066,11 @@ void fast_path_thread(uint32_t index)
    /* Entry point to scheduler */
     printf("Fast Path thread: %d setup complete, running on ARM CORE: %d\n", i,i);
     netapi_schedRun(scheduler[thread_num], &err);
-    netapi_pktioClose(rx_chan, &err);
 
+ERR_fast_path_thread:
+    netapi_pktioClose(rx_chan, &err);
     netapi_pktioClose(sb_rx_chan, &err);
+
     netapi_shutdown(worker_nh[thread_num]);
 }
 
@@ -1127,6 +1149,14 @@ int main(int argc, char **argv)
     /* create netapi */
     netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
 
+    if (netapi_handle == NULL)
+    {
+        printf("main: netapi_init failure, exiting\n");
+        exit(1);
+    }
+
+
+
     /* configure expection packet handling with netapi */
     netapi_netcpCfgExceptions(netapi_handle,
                               NETCP_CFG_ALL_EXCEPTIONS,
index 980a78d38d52c61117c133a6d53ca052994d79ca..f5cbf1ce895bdbcecd7e29cae3bf252501806b79 100755 (executable)
@@ -382,11 +382,11 @@ int main(int argc, char **argv)
 
     /* create netapi */
     netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
-
-    if (netapi_handle)
-        printf("main: netapi_init sucess\n");
-    else
-        printf("main: netapi_init fail, null netapi_handle\n");
+    if (netapi_handle == NULL)
+    {
+        printf("main: netapi_init failure, exiting\n");
+        exit(1);
+    }
 
     /* open the main heap */
     ourHeap = Pktlib_findHeapByName("netapi");