SDOCM00113322: kernel RX UDP/TCP checksum offload to NETCP breaks user space tranport...
[keystone-rtos/netapi.git] / ti / runtime / netapi / test / net_test_bench.c
1 /******************************************
2  * File: nt_bench.c   
3  * Purpose:  benchmarks for NT.
4  **************************************************************
5  * FILE:  nt_bench.c
6  * 
7  * DESCRIPTION:  netapi user space transport
8  *               library  test application : benchmarks
9  * 
10  * REVISION HISTORY:  rev 0.0.1 
11  *
12  *  Copyright (c) Texas Instruments Incorporated 2010-2011
13  * 
14  *  Redistribution and use in source and binary forms, with or without 
15  *  modification, are permitted provided that the following conditions 
16  *  are met:
17  *
18  *    Redistributions of source code must retain the above copyright 
19  *    notice, this list of conditions and the following disclaimer.
20  *
21  *    Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in the 
23  *    documentation and/or other materials provided with the   
24  *    distribution.
25  *
26  *    Neither the name of Texas Instruments Incorporated nor the names of
27  *    its contributors may be used to endorse or promote products derived
28  *    from this software without specific prior written permission.
29  *
30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
31  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
32  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
33  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
34  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
35  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
36  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
39  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
40  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  *****************************************/
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <unistd.h>
47 #include <string.h>
48 #include <signal.h>
49 #include <pthread.h>
50 #include <sched.h>
52 //#include "trie.h"
53 #include "string.h"
54 #include "netapi.h"
55 //#include "pktio.h"
56 #include "net_test.h"
57 #include "net_test_sa_utils.h"
58 #include "net_test_utils.h"
59 #include "net_test_thread_utils.h"
60 #include <ti/drv/sa/salld.h>
62 #if defined(DEVICE_K2H)
63 #include <ti/drv/qmss/device/k2h/src/qmss_device.c>
64 #include <ti/drv/cppi/device/k2h/src/cppi_device.c>
65 #elif defined (DEVICE_K2K)
66 #include <ti/drv/qmss/device/k2k/src/qmss_device.c>
67 #include <ti/drv/cppi/device/k2k/src/cppi_device.c>
68 #elif defined (DEVICE_K2L)
69 #include <ti/drv/qmss/device/k2l/src/qmss_device.c>
70 #include <ti/drv/cppi/device/k2l/src/cppi_device.c>
71 #elif defined (DEVICE_K2E)
72 #include <ti/drv/qmss/device/k2e/src/qmss_device.c>
73 #include <ti/drv/cppi/device/k2e/src/cppi_device.c>
74 #else /*Default */
75 #include <ti/drv/qmss/device/k2h/src/qmss_device.c>
76 #include <ti/drv/cppi/device/k2h/src/cppi_device.c>
77 #endif /* Device */
78 extern Rm_ServiceHandle   *rmClientServiceHandle;
80 extern Rm_ServiceHandle   *rmClientServiceHandle;
81 #define netapi_timing_start hplib_mUtilGetPmuCCNT
83 static int scnt=0;
84 static int QUIT=0;
85 static int XMIT=0;
86 static int CAP=0;
87 volatile int RESET=0; //to reset stats
89 __thread int our_core;
91 void benchmarks1(void);
92 void benchmarks2(Pktlib_HeapHandle h , int n_trials);
93 void benchmarks3(Pktlib_HeapHandle h , int n_trials);
95 //sig handler
96 void netTest_utilMySig(int x)
97 {
98   QUIT=1;
99   scnt+=1;
100   printf(">ifdma-test: recv'd signal %d cnt=%d\n",x,scnt);
101   if (scnt > 10) {printf(">ifdma-test: WARNING EXITING WITH PROPER SHUTDOWN, LUTS LEFT ACTIVE\n");exit(1);}
104 void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
105                          PKTIO_METADATA_T meta[], int n_pkts,
106                          uint64_t ts );
109 /*************debug********************/
110 void netTest_utilDumpDescr(unsigned long *p, int n)
112    printf("--------dump of descriptor %d %x\n", n, (int) p);
113    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]);
114    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]);
115    printf("-----------------------------\n");
117 void netTest_utilDumpHeader(unsigned long *p, int n, int a, int r)
119    printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);
120    printf("> %0x %0x %0x %0x %0x %0x %0x %0x\n",
121           ntohl(p[0]),ntohl(p[1]),ntohl(p[2]),ntohl(p[3]),
122           ntohl(p[4]),ntohl(p[5]),ntohl(p[6]),ntohl(p[7]) );
123 #if 0
124    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]);
125    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]);
126    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]);
127 #endif
128    printf("-----------------------------\n");
130 /*****************************************/
133 unsigned long long CALIB=0;
134 unsigned long long calibrate_idle(void)
136 volatile unsigned long long  at1;
137 volatile unsigned long long  at2;
138 volatile unsigned long pt1;
139 volatile unsigned long pt2;
140 unsigned long long calib;
141 at1 = hplib_mUtilGetTimestamp();
142 pt1=netapi_timing_start();
143 for(;;)
145    pt2=netapi_timing_start()   ;
146    if ((pt2-pt1) >= 100000) break;
148 at2 = hplib_mUtilGetTimestamp();
150 calib = ((unsigned long long) (pt2-pt1))/(at2-at1);
151 printf("calibrate:   arm time=%lld  -> arm cycles=%d calib=%lld\n", at2-at1, pt2-pt1, calib);
153 return calib;
156 /*******************************************
157  *************NETAPI OBJECTS***************
158  *****************************************/
159 static NETAPI_CFG_T our_netapi_default_cfg=
161 TUNE_NETAPI_PERM_MEM_SZ,
162 128,  //start of packet offset for hw to place data on rx for default flow
163 TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
164 TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
165 TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
166 64, //#descriptors w/o buffers in default heap
167 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
168 128,       //tail room
169 256,      //extra room
170 0,
171 NULL,
172 -1,
173 -1
174 };
176 Pktlib_HeapHandle OurHeap;     //default heap, used by producer
177 PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
178 PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 12};
179 PKTIO_HANDLE_T * netcp_rx_chan;
180 PKTIO_HANDLE_T * netcp_tx_chan;
181 NETAPI_T netapi_handle;
183 PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};
184 PKTIO_CONTROL_T poll_cannel_control={PKTIO_SET_POLL_FLAGS, NULL, nwal_POLL_DEFAULT_GLOB_PKT_Q};
186 //template for fast path
187 nwalTxPktInfo_t txPktInfoNoCrypto =
189     NULL,                                                                                               /* p_pkt */
190     NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
191     0,                                                                                                  /* lpbackPass */
192     0,                                                                                                  /* enetport */
193     0,                                                                                                  /* msuSize */
194     0,                                                                                                   /* startOffset */
195     0,                                                    /* saOffBytes */
196     0,                                                                                                  /* saPayLoadLen */
197     0               ,                                                                                    /* saAhIcvOffBytes */
198     0,                                                                                                 /* saAhMacSize */
199     0,                                              
200    /* etherLenOffBytes */
201     netTest_MAC_HEADER_LEN,         /* ipOffBytes */
202     netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN,                                        /* l4OffBytes */
203     netTest_UDP_HEADER_LEN,                                                             /* l4HdrLen */
204     0,                                                                         /* pseudoHdrChecksum */
205     0                                                                                                   /* pLoadLen */
206 };
209 NETCP_CFG_ROUTE_T  test_route=
211 0,
212 NULL,
213 NULL,
214 0,
215 0,
216 0,
218 };
221 /*************************END NETAPI OBJECTS***********************/
223 static unsigned char all_mac[]={0,0,0,0,0,0};
225 static unsigned long last_header[32/sizeof(unsigned long)];
228 //stats
229 int pkt_rx=0; 
230 int pkt_tx=0; 
231 unsigned long long pkt_rx_cycles=0L;
232 unsigned long long pkt_tx_cycles=0L;
233 unsigned long long pkt_cb_cycles=0L;
234 unsigned long long idle_cycles=0L;
235 volatile unsigned long long start_time;
236 unsigned long long end_time;
238 //**********************************
239 //producer thread
240 //*********************************
241 void producer_thread(int coreid)
243 int err;
244 int i;
245 Ti_Pkt * tip;
246 unsigned char * pData;
247 int len;
248 PKTIO_METADATA_T meta = {PKTIO_META_IFDMA_TX,{0},0};
249 int np;
250 cpu_set_t cpu_set;
251 unsigned long t1;
252 unsigned long t2;
254     CPU_ZERO( &cpu_set);
255     CPU_SET( 2, &cpu_set);
256     hplib_utilSetupThread(0, &cpu_set, hplib_spinLock_Type_LOL);
257     start_time = hplib_mUtilGetTimestamp();
259      //DAL we poll the default pktio channel for pkts from net
260       for(i=0;!((volatile int) QUIT);i++)
261       {
262         t1 = netapi_timing_start();
263         np = netapi_pktioPoll(netcp_rx_chan,NULL,&err);
264         t2 = netapi_timing_start();
265         pkt_rx+=np;
266         if (np) 
267         {
268            pkt_rx_cycles += (t2-t1);
269         }
270         else
271         {
272            idle_cycles += (t2-t1);
273         }
274         if (RESET)
275         {
276               idle_cycles=0LL;
277               start_time = hplib_mUtilGetTimestamp();
278               pkt_rx=pkt_tx=0;
279               pkt_rx_cycles=pkt_tx_cycles=0LL;
280               pkt_cb_cycles=0LL;
281               RESET=0;
282         }
283       }
284       end_time = hplib_mUtilGetTimestamp();
285       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",
286              pkt_rx,
287              (unsigned)  (pkt_rx ?  (pkt_rx_cycles - pkt_cb_cycles)/pkt_rx : 0),
288              (unsigned)  (pkt_rx ?  (pkt_rx_cycles) /pkt_rx : 0),
289              (unsigned)  (pkt_tx ?  (pkt_tx_cycles) /pkt_tx : 0),
290              idle_cycles, (end_time-start_time), 
291              (idle_cycles*100) /( CALIB* (end_time-start_time))
293             );
294      printf("Leaving producer_thread\n");
298 //******************************
299 //  main program
300 //*****************************
301 int main(int argc, char **argv)
303     int err,i;
304     int32_t             errCode;
305     Pktlib_HeapIfTable*  pPktifTable;
306     Pktlib_HeapCfg heapCfg;
307     long t1, t2 ;
308     cpu_set_t cpu_set;
309     NETCP_CFG_ROUTE_T test_route;
312      //install signal handler for ^c
313     signal(SIGINT,netTest_utilMySig);
315     if (initRm())
316     {
317         printf("main: initRm() returned error\n");
318         exit(1);
319     }
321     CPU_ZERO( &cpu_set);
322     CPU_SET( 0, &cpu_set);
323     hplib_utilSetupThread(0, &cpu_set, hplib_spinLock_Type_LOL);
326     /*******************************************/
327     /*************NETAPI STARTUP****************/
328     /*******************************************/
330     /* create netapi */
331     our_netapi_default_cfg.rmHandle = rmClientServiceHandle;
332     netapi_handle = netapi_init(NETAPI_SYS_MASTER,
333                                 &our_netapi_default_cfg);
334     if (netapi_handle == NULL)
335     {
336         printf("main: netapi_init failure, exiting\n");
337         exit(1);
338     }
340     /* open the main heap */
341     OurHeap = Pktlib_findHeapByName("netapi");
342     if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}
344     //if we want to relay network packets, we create a handle to the 
345     //default netcp receive queue here
346     netcp_rx_chan= netapi_pktioOpen(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb_net, &netcp_rx_cfg,  &err);
347     if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}
349     netcp_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_TX, (PKTIO_CB) NULL, &netcp_tx_cfg,  &err);
350     if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}
351     else  //install a fast path template into the NETCP TX channel
352     {
353             PKTIO_CONTROL_T control2;
354             control2.op = PKTIO_UPDATE_FAST_PATH;
355             PKTIO_CFG_T cfg2;
356             cfg2.fast_path_cfg.fp_send_option = PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT;
357             cfg2.fast_path_cfg.txPktInfo= &txPktInfoNoCrypto;
358             netapi_pktioControl(netcp_tx_chan, NULL, &cfg2, &control2, &err);
359    }
362 /*********************************************/
363 /*****************end NETAPI STARTUP**********/
364 /*********************************************/
366 /*************************************************
367 ********************some basic benchmarks*********
368 **************************************************/
369 printf("\n\n*******STARTING MEM ACCESS BENCHMARK*********\n\n");
370 benchmarks1();
371 printf("\n\n*******STARTING RAW BENCHMARK2*********\n\n");
372 benchmarks2(OurHeap, 20);
373 printf("\n\n*******STARTING RAW BENCHMARK3*********\n\n");
374 benchmarks3(OurHeap, 20);
375 printf("\n\n******STARTING RECV BENCHMARK (q to quit)*****\n\n");
378 //now creaate a simple netcp rule
379 //to get a lot of packets
380 memset(&test_route, 0, sizeof(NETCP_CFG_ROUTE_T));
381 test_route.valid_params = NETCP_CFG_VALID_PARAM_MATCH_ACTION_DEST;
382 test_route.match_destination = NETCP_CFG_ACTION_TO_SW;
383 test_route.routeType = 0;
384 test_route.p_flow = NULL;
385 test_route.p_dest_q = NULL;
387 netapi_netcpCfgCreateMacInterface(
388                   netapi_handle,
389                   &all_mac[0],
390                   NULL,
391                   0,0,
392                   (NETCP_CFG_ROUTE_HANDLE_T)  &test_route,
393                   (NETCP_CFG_VLAN_T ) NULL ,  //future
394                   0,
395                   1,
396                   &err);
398 //calibrate idle
399         CALIB = calibrate_idle();
401 //**************************************
402 //Create a worked thread
403 //***************************************
405         pthread_t *thrs;
406         int procs =1; 
407         int c;
408         thrs = malloc( sizeof( pthread_t ) * procs );
409         if (thrs == NULL)
410         {
411                 perror( "malloc" );
412                 return -1;
413         }
414         printf( "benchmark-test: Starting %d threads...\n", procs );
416         if (pthread_create( &thrs[0], NULL, (void*)producer_thread,
417                         (void *)0 ))
418         {
419                         perror( "pthread_create" );
420                         exit(1);
421         }
422         //this thread of execution (main) now just waits on user input
423         for(;;)
424         {
425            printf(">");
426            c=getchar();
427            if (c=='c') {CAP=!CAP; printf("CAPTURE= %d\n", CAP); }
428            else if (c=='q') {QUIT=1;break;}
429            else if (c=='t') {XMIT=!XMIT; printf("XMIT= %d\n", XMIT); }
430            else if (c=='s') 
431            {
432               unsigned long long et= hplib_mUtilGetTimestamp();
433               printf(">NT_BENCH STATS:    %d received   %d xmitted,   %lld idle cycles,  %lld duration ticks  idle=%lld\n",
434                        pkt_rx,pkt_tx,
435                        idle_cycles,
436                        (et-start_time),
437                        (idle_cycles*100)/(CALIB*(et-start_time)));
438               Pktlib_HeapStats    pktLibHeapStats;
439               Pktlib_getHeapStats(OurHeap, &pktLibHeapStats);
440               printf("main  heap stats>  #free=%d #zb=%d #garbage=%d\n",
441                                 pktLibHeapStats.numFreeDataPackets,
442                                 pktLibHeapStats.numZeroBufferPackets,
443                                 pktLibHeapStats.numPacketsinGarbage);
444            }
445            else if (c=='r')
446            {
447               RESET=1;
448            }
449            else if (c=='h')
450            {
451                 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");
452            }
453            else if (c=='d')
454            {
455               netTest_utilDumpHeader(&last_header[0], 0,0,0);
456            }
457         }
459         //wait for completion 
460         printf("main task now pending on thread completion\n");
461         for (i = 0; i < procs; i++)
462                 pthread_join( thrs[i], NULL );
464         free( thrs );
465       
468 /*************************************************
469  ************CLEAN UP****************************
470  ************************************************/
471 //get rid of rule, in the case that we are relaying packets
472 //also close our netcp rx channel
473 netapi_netcpCfgDelMac(netapi_handle,0,&err);
474 netapi_pktioClose(netcp_rx_chan,&err);
475 netapi_pktioClose(netcp_tx_chan,&err);
478 //done
479 netapi_shutdown(netapi_handle);
482 //!finished!
484 static inline void sendit(Ti_Pkt *tip, int len, int out_port)
486   int err=0;
487   PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
488   nwalTxPktInfo_t meta_tx2={0};
489   if (len<60)
490   {
491      unsigned int templen;
492      char * p_pkt;
493      len=60;
494      Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
495      Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
496   }
497   Pktlib_setPacketLen(tip,len);
498   meta_tx2.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID ; 
499   meta_tx2.ploadLen = len ;
500   meta_tx2.enetPort=out_port;
501   meta2.u.tx_meta=&meta_tx2;
502   netapi_pktioSend(netcp_tx_chan,tip,&meta2,&err);
505 //receive callback for packets from net (for consumer)
506 void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
507                          PKTIO_METADATA_T meta[], int n_pkts,
508                          uint64_t ts )
510 int i;
511 Ti_Pkt * tip;
512 int len;
513 unsigned long t1;
514 unsigned long t2;
515 unsigned long t3;
516 unsigned long t4;
517 pasahoLongInfo_t* protoInfo; 
518 int ifno;
519 int out_port;
521 t1= netapi_timing_start();
522 for(i=0;i<n_pkts;i++)
524     tip = p_recv[i];
525     len = Pktlib_getPacketLen(tip);
527     if (CAP)
528     {
529        unsigned int templen;
530        char * p_pkt;
531        Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
532        memcpy(last_header,p_pkt,32);
533     }
535     if (XMIT)
536     {
537         protoInfo=nwal_mGetProtoInfo(tip);
538         ifno = nwal_mGetRxEmacPort( protoInfo);
539         //----------------------------------------------------
540         //very trivial bridging -> just output to other port!
541         //----------------------------------------------------
542         if (ifno ==1) out_port=2; else out_port=1;
543         t3= netapi_timing_start();
544         sendit(tip,len,out_port);
545         pkt_tx+=1;
546         t4= netapi_timing_start();
547         pkt_tx_cycles += (t4-t3);
548     }
549     else
550     {
551       Pktlib_freePacket((Ti_Pkt*)tip);
552     }
554 t2 = netapi_timing_start();
555 pkt_cb_cycles += (t2-t1);
561 //SOME BENCHMARKS
562 //sonme benchmarks
563 void benchmarks1(void)
565     int i,j;
566     unsigned long v1pop;
567     unsigned long v2pop;
568     unsigned long v1push;
569     unsigned long v2push;
570     unsigned long v1read;
571     unsigned long v2read;
572     unsigned long v1write;
573     unsigned long v2write;
574     unsigned long v1read2;
575     unsigned long v2read2;
576 #define N 100
577     Ti_Pkt  pkts[N];
578     unsigned char * p_pkt;
579     int len;
580     int sum=0;
581     int sum2=0;
582     char *p=(char *) malloc(1000);
584     if(p)
585     {
586         for(i=0;i<1000;i++)
587             p[i] = i;
588         //alloc
589         v1pop=netapi_timing_start();
590         for(i=0;i<N;i++)   pkts[i]= Pktlib_allocPacket(OurHeap,1000);
591         v2pop = netapi_timing_start();
593         //write access
594         Pktlib_getDataBuffer(pkts[0],(uint8_t**)&p_pkt,&len);
595         v1write=netapi_timing_start();
596         for(i=0;i<1000;i++) p_pkt[i]=i;
597         v2write=netapi_timing_start();
599         //read access
600         v1read=netapi_timing_start();
601         for(j=0;j<10;j++)
602         for(i=0;i<1000;i++) sum+=p_pkt[i];
603         v2read=netapi_timing_start();
605         // access (from malloc)
606         v1read2=netapi_timing_start();
607         for(i=0;i<1000;i++) sum2+=p[i];
608         v2read2=netapi_timing_start();
610         //free packet
611         v1push=netapi_timing_start();
612         for(i=0;i<N;i++)   Pktlib_freePacket(pkts[i]);
613         v2push = netapi_timing_start();
615         //resutls
616         printf("allocs= %d  free=%d   write=%d  read=%d read-malloc=%d (sum=%d %d)\n",
617                 (v2pop-v1pop)/N, (v2push-v1push)/N,  (v2write-v1write)/1000, (v2read-v1read)/10000,
618                 (v2read2-v1read2)/1000,sum,sum2);
619         free(p);
620     }
622 };
625 //raw queue benchmark
626 #include "ti/drv/nwal/nwal_util.h"
628 #define NTOPOP 150
629 volatile unsigned long t1;
630 volatile unsigned long t2;
631 volatile unsigned long t3;
632 volatile unsigned long t4;
633 volatile unsigned long t5;
634 volatile unsigned long t6;
635 volatile unsigned long sum1=0;
636 volatile unsigned long sum2=0;
637 volatile unsigned long sum3=0;
638 volatile unsigned long sum4=0;
639 volatile Ti_Pkt * pHd[NTOPOP];
642 void benchmarks2(Pktlib_HeapHandle h , int ntrials)
644 int i,j;
645 int k;
646 int abort=0;
647 Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
649 //n_trials of NTOPOP actions
650 for(i=0;i<ntrials;i++)
652     abort=0;
653     sum1=sum2=sum3=sum4=0;
654     //raw pop
655     t1= netapi_timing_start();
656     for(j=0;j<NTOPOP;j++)
657     {
658        pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (freeQ));
659        if (!pHd[j]) 
660        {
661          printf("abort test. out of descriptors\n"); abort=1;
662          break;
663        }
664     }
665     t2= netapi_timing_start();
666     k=j;
667     for(j=0;j<k;j++)
668     {
669        pHd[j]  =  Osal_qmssConvertDescPhyToVirt(0,pHd[j]);
670     }
671     t3= netapi_timing_start();
672     sum1 += (t2-t1);
673     sum2 += (t3-t2);
674     //raw push
675     t4= netapi_timing_start();
676     for(j=0;j<k;j++)
677     {
678        if (!pHd[j]) continue;
679        pHd[j]= Osal_qmssConvertDescVirtToPhy(0,pHd[j]);
680     }
681     t5= netapi_timing_start();
682     for(j=0;j<k;j++)
683     {
684       pktio_mQmssQueuePushDescSizeRaw(freeQ,
685                                              (void *) pHd[j],
686                                              128);
687     }
688     t6= netapi_timing_start();
689     sum3 += (t5-t4);
690     sum4 += (t6-t5);
692     if (!abort)
693     printf("nt=%d raw pop=%d  p2v=%d v2p=%d raw push=%d\n", i,
694              sum1/k,  sum2/k, sum3/k, sum4/k);
695     sleep(1);
697 return;
700 //full queue push/pops
701 void benchmarks3(Pktlib_HeapHandle h , int ntrials)
703 int i,j;
704 int k;
705 int abort=0;
706 Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
708 //n_trials of NTOPOP actions
709 for(i=0;i<ntrials;i++)
711     abort=0;
712     sum2=sum4=0;
713     //raw pop
714     t1= netapi_timing_start();
715     for(j=0;j<NTOPOP;j++)
716     {
717        pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(Qmss_queuePop(freeQ));
718        if (!pHd[j])
719        {
720          printf("abort test. out of descriptors\n"); abort=1;
721          break;
722        }
723     }
724     t3= netapi_timing_start();
725     sum2 += (t3-t1);
726     k=j;
727     //raw push
728     t5= netapi_timing_start();
729     for(j=0;j<k;j++)
730     {
731        if (!pHd[j]) continue;
732        Qmss_queuePushDescSize(freeQ, pHd[j], 128);
733     }
734     t6= netapi_timing_start();
735     sum4 += (t6-t5);
736     if (!abort)
737     printf("nt=%d pop=%d  push=%d\n", i,
738               sum2/k, sum4/k);
739     sleep(1);
741 return;