Resolve NETAPI library coverity warnings.
[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 #define netapi_timing_start hplib_mUtilGetPmuCCNT
82 static int scnt=0;
83 static int QUIT=0;
84 static int XMIT=0;
85 static int CAP=0;
86 volatile int RESET=0; //to reset stats
88 __thread int our_core;
90 void benchmarks1(void);
91 void benchmarks2(Pktlib_HeapHandle h , int n_trials);
92 void benchmarks3(Pktlib_HeapHandle h , int n_trials);
94 //sig handler
95 void netTest_utilMySig(int x)
96 {
97   QUIT=1;
98   scnt+=1;
99   printf(">ifdma-test: recv'd signal %d cnt=%d\n",x,scnt);
100   if (scnt > 10) {printf(">ifdma-test: WARNING EXITING WITH PROPER SHUTDOWN, LUTS LEFT ACTIVE\n");exit(1);}
103 void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
104                          PKTIO_METADATA_T meta[], int n_pkts,
105                          uint64_t ts );
108 /*************debug********************/
109 void netTest_utilDumpDescr(unsigned long *p, int n)
111    printf("--------dump of descriptor %d %x\n", n, (int) p);
112    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]);
113    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]);
114    printf("-----------------------------\n");
116 void netTest_utilDumpHeader(unsigned long *p, int n, int a, int r)
118    printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);
119    printf("> %0x %0x %0x %0x %0x %0x %0x %0x\n",
120           ntohl(p[0]),ntohl(p[1]),ntohl(p[2]),ntohl(p[3]),
121           ntohl(p[4]),ntohl(p[5]),ntohl(p[6]),ntohl(p[7]) );
122 #if 0
123    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]);
124    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]);
125    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]);
126 #endif
127    printf("-----------------------------\n");
129 /*****************************************/
132 unsigned long long CALIB=0;
133 unsigned long long calibrate_idle(void)
135 volatile unsigned long long  at1;
136 volatile unsigned long long  at2;
137 volatile unsigned long pt1;
138 volatile unsigned long pt2;
139 unsigned long long calib;
140 at1 = hplib_mUtilGetTimestamp();
141 pt1=netapi_timing_start();
142 for(;;)
144    pt2=netapi_timing_start()   ;
145    if ((pt2-pt1) >= 100000) break;
147 at2 = hplib_mUtilGetTimestamp();
149 calib = ((unsigned long long) (pt2-pt1))/(at2-at1);
150 printf("calibrate:   arm time=%lld  -> arm cycles=%d calib=%lld\n", at2-at1, pt2-pt1, calib);
152 return calib;
155 /*******************************************
156  *************NETAPI OBJECTS***************
157  *****************************************/
158 static NETAPI_CFG_T our_netapi_default_cfg=
160 TUNE_NETAPI_PERM_MEM_SZ,
161 128,  //start of packet offset for hw to place data on rx for default flow
162 TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
163 TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
164 TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
165 64, //#descriptors w/o buffers in default heap
166 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
167 128,       //tail room
168 256,      //extra room
169 0,
170 NULL
171 };
173 Pktlib_HeapHandle OurHeap;     //default heap, used by producer
174 PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
175 PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 12};
176 PKTIO_HANDLE_T * netcp_rx_chan;
177 PKTIO_HANDLE_T * netcp_tx_chan;
178 NETAPI_T netapi_handle;
180 PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};
181 PKTIO_CONTROL_T poll_cannel_control={PKTIO_SET_POLL_FLAGS, NULL, nwal_POLL_DEFAULT_GLOB_PKT_Q};
183 //template for fast path
184 nwalTxPktInfo_t txPktInfoNoCrypto =
186     NULL,                                                                                               /* p_pkt */
187     NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
188     0,                                                                                                  /* lpbackPass */
189     0,                                                                                                  /* enetport */
190     0,                                                                                                  /* msuSize */
191     0,                                                                                                   /* startOffset */
192     0,                                                    /* saOffBytes */
193     0,                                                                                                  /* saPayLoadLen */
194     0               ,                                                                                    /* saAhIcvOffBytes */
195     0,                                                                                                 /* saAhMacSize */
196     0,                                              
197    /* etherLenOffBytes */
198     netTest_MAC_HEADER_LEN,         /* ipOffBytes */
199     netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN,                                        /* l4OffBytes */
200     netTest_UDP_HEADER_LEN,                                                             /* l4HdrLen */
201     0,                                                                         /* pseudoHdrChecksum */
202     0                                                                                                   /* pLoadLen */
203 };
206 NETCP_CFG_ROUTE_T  test_route=
208 0,
209 NULL,
210 NULL,
211 0//* to be filled in
212 };
215 /*************************END NETAPI OBJECTS***********************/
217 static unsigned char all_mac[]={0,0,0,0,0,0};
219 static unsigned long last_header[32/sizeof(unsigned long)];
222 //stats
223 int pkt_rx=0; 
224 int pkt_tx=0; 
225 unsigned long long pkt_rx_cycles=0L;
226 unsigned long long pkt_tx_cycles=0L;
227 unsigned long long pkt_cb_cycles=0L;
228 unsigned long long idle_cycles=0L;
229 volatile unsigned long long start_time;
230 unsigned long long end_time;
232 //**********************************
233 //producer thread
234 //*********************************
235 void producer_thread(int coreid)
237 int err;
238 int i;
239 Ti_Pkt * tip;
240 unsigned char * pData;
241 int len;
242 PKTIO_METADATA_T meta = {PKTIO_META_IFDMA_TX,{0},0};
243 int np;
244 cpu_set_t cpu_set;
245 unsigned long t1;
246 unsigned long t2;
248     CPU_ZERO( &cpu_set);
249     CPU_SET( 2, &cpu_set);
250     hplib_utilSetupThread(2, &cpu_set, hplib_spinLock_Type_LOL);
251     start_time = hplib_mUtilGetTimestamp();
253      //DAL we poll the default pktio channel for pkts from net
254       for(i=0;!((volatile) QUIT);i++)
255       {
256         t1 = netapi_timing_start();
257         np = netapi_pktioPoll(netcp_rx_chan,NULL,&err);
258         t2 = netapi_timing_start();
259         pkt_rx+=np;
260         if (np) 
261         {
262            pkt_rx_cycles += (t2-t1);
263         }
264         else
265         {
266            idle_cycles += (t2-t1);
267         }
268         if (RESET)
269         {
270               idle_cycles=0LL;
271               start_time = hplib_mUtilGetTimestamp();
272               pkt_rx=pkt_tx=0;
273               pkt_rx_cycles=pkt_tx_cycles=0LL;
274               pkt_cb_cycles=0LL;
275               RESET=0;
276         }
277       }
278       end_time = hplib_mUtilGetTimestamp();
279       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",
280              pkt_rx,
281              (unsigned)  (pkt_rx ?  (pkt_rx_cycles - pkt_cb_cycles)/pkt_rx : 0),
282              (unsigned)  (pkt_rx ?  (pkt_rx_cycles) /pkt_rx : 0),
283              (unsigned)  (pkt_tx ?  (pkt_tx_cycles) /pkt_tx : 0),
284              idle_cycles, (end_time-start_time), 
285              (idle_cycles*100) /( CALIB* (end_time-start_time))
287             );
288      printf("Leaving producer_thread\n");
292 //******************************
293 //  main program
294 //*****************************
295 int main(int argc, char **argv)
297     int err,i;
298     int32_t             errCode;
299     Pktlib_HeapIfTable*  pPktifTable;
300     Pktlib_HeapCfg heapCfg;
301     long t1, t2 ;
302     cpu_set_t cpu_set;
305      //install signal handler for ^c
306     signal(SIGINT,netTest_utilMySig);
310 #if 1
311     if (initRm())
312     {
313         printf("main: initRm() returned error\n");
314         exit(1);
315     }
316 #endif
319     CPU_ZERO( &cpu_set);
320     CPU_SET( 0, &cpu_set);
321     hplib_utilSetupThread(2, &cpu_set, hplib_spinLock_Type_LOL);
324     /*******************************************/
325     /*************NETAPI STARTUP****************/
326     /*******************************************/
328     /* create netapi */
329     netapi_handle = netapi_init(NETAPI_SYS_MASTER,
330                                 &our_netapi_default_cfg);
331     if (netapi_handle == NULL)
332     {
333         printf("main: netapi_init failure, exiting\n");
334         exit(1);
335     }
336     netapi_netcpCfgExceptions(netapi_handle, NETCP_CFG_ALL_EXCEPTIONS, NETCP_CFG_ACTION_DISCARD, (NETCP_CFG_ROUTE_HANDLE_T) NULL);
338     /* open the main heap */
339     OurHeap = Pktlib_findHeapByName("netapi");
340     if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}
342     //if we want to relay network packets, we create a handle to the 
343     //default netcp receive queue here
344     netcp_rx_chan= netapi_pktioOpen(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb_net, &netcp_rx_cfg,  &err);
345     if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}
347     netcp_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_TX, (PKTIO_CB) NULL, &netcp_tx_cfg,  &err);
348     if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}
349     else  //install a fast path template into the NETCP TX channel
350     {
351             PKTIO_CONTROL_T control2;
352             control2.op = PKTIO_UPDATE_FAST_PATH;
353             PKTIO_CFG_T cfg2;
354             cfg2.fast_path_cfg.fp_send_option = PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT;
355             cfg2.fast_path_cfg.txPktInfo= &txPktInfoNoCrypto;
356             netapi_pktioControl(netcp_tx_chan, NULL, &cfg2, &control2, &err);
357    }
360 /*********************************************/
361 /*****************end NETAPI STARTUP**********/
362 /*********************************************/
364 /*************************************************
365 ********************some basic benchmarks*********
366 **************************************************/
367 printf("\n\n*******STARTING MEM ACCESS BENCHMARK*********\n\n");
368 benchmarks1();
369 printf("\n\n*******STARTING RAW BENCHMARK2*********\n\n");
370 benchmarks2(OurHeap, 20);
371 printf("\n\n*******STARTING RAW BENCHMARK3*********\n\n");
372 benchmarks3(OurHeap, 20);
373 printf("\n\n******STARTING RECV BENCHMARK (q to quit)*****\n\n");
376 //now creaate a simple netcp rule
377 //to get a lot of packets
378 netapi_netcpCfgCreateMacInterface(
379                   netapi_handle,
380                   &all_mac[0],
381                   NULL,
382                   0,0,
383                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
384                   (NETCP_CFG_VLAN_T ) NULL ,  //future
385                   1,
386                   &err);
388 //calibrate idle
389         CALIB = calibrate_idle();
391 //**************************************
392 //Create a worked thread
393 //***************************************
395         pthread_t *thrs;
396         int procs =1; 
397         char c;
398         thrs = malloc( sizeof( pthread_t ) * procs );
399         if (thrs == NULL)
400         {
401                 perror( "malloc" );
402                 return -1;
403         }
404         printf( "benchmark-test: Starting %d threads...\n", procs );
406         if (pthread_create( &thrs[0], NULL, (void*)producer_thread,
407                         (void *)0 ))
408         {
409                         perror( "pthread_create" );
410                         exit(1);
411         }
412         //this thread of execution (main) now just waits on user input
413         for(;;)
414         {
415            printf(">");
416            c=getchar();
417            if (c=='c') {CAP=!CAP; printf("CAPTURE= %d\n", CAP); }
418            else if (c=='q') {QUIT=1;break;}
419            else if (c=='t') {XMIT=!XMIT; printf("XMIT= %d\n", XMIT); }
420            else if (c=='s') 
421            {
422               unsigned long long et= hplib_mUtilGetTimestamp();
423               printf(">NT_BENCH STATS:    %d received   %d xmitted,   %lld idle cycles,  %lld duration ticks  idle=%lld\n",
424                        pkt_rx,pkt_tx,
425                        idle_cycles,
426                        (et-start_time),
427                        (idle_cycles*100)/(CALIB*(et-start_time)));
428               Pktlib_HeapStats    pktLibHeapStats;
429               Pktlib_getHeapStats(OurHeap, &pktLibHeapStats);
430               printf("main  heap stats>  #free=%d #zb=%d #garbage=%d\n",
431                                 pktLibHeapStats.numFreeDataPackets,
432                                 pktLibHeapStats.numZeroBufferPackets,
433                                 pktLibHeapStats.numPacketsinGarbage);
434            }
435            else if (c=='r')
436            {
437               RESET=1;
438            }
439            else if (c=='h')
440            {
441                 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");
442            }
443            else if (c=='d')
444            {
445               netTest_utilDumpHeader(&last_header[0], 0,0,0);
446            }
447         }
449         //wait for completion 
450         printf("main task now pending on thread completion\n");
451         for (i = 0; i < procs; i++)
452                 pthread_join( thrs[i], NULL );
454         free( thrs );
455       
458 /*************************************************
459  ************CLEAN UP****************************
460  ************************************************/
461 //get rid of rule, in the case that we are relaying packets
462 //also close our netcp rx channel
463 netapi_netcpCfgDelMac(netapi_handle,0,&err);
464 netapi_pktioClose(netcp_rx_chan,&err);
465 netapi_pktioClose(netcp_tx_chan,&err);
468 //done
469 netapi_shutdown(netapi_handle);
472 //!finished!
474 static inline void sendit(Ti_Pkt *tip, int len, int out_port)
476   int err=0;
477   PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
478   nwalTxPktInfo_t meta_tx2={0};
479   if (len<60)
480   {
481      unsigned int templen;
482      char * p_pkt;
483      len=60;
484      Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
485      Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
486   }
487   Pktlib_setPacketLen(tip,len);
488   meta_tx2.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID ; 
489   meta_tx2.ploadLen = len ;
490   meta_tx2.enetPort=out_port;
491   meta2.u.tx_meta=&meta_tx2;
492   netapi_pktioSend(netcp_tx_chan,tip,&meta2,&err);
495 //receive callback for packets from net (for consumer)
496 void recv_cb_net(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
497                          PKTIO_METADATA_T meta[], int n_pkts,
498                          uint64_t ts )
500 int i;
501 Ti_Pkt * tip;
502 int len;
503 unsigned long t1;
504 unsigned long t2;
505 unsigned long t3;
506 unsigned long t4;
507 pasahoLongInfo_t* protoInfo; 
508 int ifno;
509 int out_port;
511 t1= netapi_timing_start();
512 for(i=0;i<n_pkts;i++)
514     tip = p_recv[i];
515     len = Pktlib_getPacketLen(tip);
517     if (CAP)
518     {
519        unsigned int templen;
520        char * p_pkt;
521        Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
522        memcpy(last_header,p_pkt,32);
523     }
525     if (XMIT)
526     {
527         protoInfo=nwal_mGetProtoInfo(tip);
528         ifno = nwal_mGetRxEmacPort( protoInfo);
529         //----------------------------------------------------
530         //very trivial bridging -> just output to other port!
531         //----------------------------------------------------
532         if (ifno ==1) out_port=2; else out_port=1;
533         t3= netapi_timing_start();
534         sendit(tip,len,out_port);
535         pkt_tx+=1;
536         t4= netapi_timing_start();
537         pkt_tx_cycles += (t4-t3);
538     }
539     else
540     {
541       Pktlib_freePacket((Ti_Pkt*)tip);
542     }
544 t2 = netapi_timing_start();
545 pkt_cb_cycles += (t2-t1);
551 //SOME BENCHMARKS
552 //sonme benchmarks
553 void benchmarks1(void)
555 int i,j;
556 unsigned long v1pop;
557 unsigned long v2pop;
558 unsigned long v1push;
559 unsigned long v2push;
560 unsigned long v1read;
561 unsigned long v2read;
562 unsigned long v1write;
563 unsigned long v2write;
564 unsigned long v1read2;
565 unsigned long v2read2;
566 #define N 100
567 Ti_Pkt  pkts[N];
568 unsigned char * p_pkt;
569 int len;
570 int sum=0;
571 int sum2=0;
572 char *p=(char *) malloc(1000);
573 //alloc
574 v1pop=netapi_timing_start();
575 for(i=0;i<N;i++)   pkts[i]= Pktlib_allocPacket(OurHeap,1000);
576 v2pop = netapi_timing_start();
578 //write access
579 Pktlib_getDataBuffer(pkts[0],(uint8_t**)&p_pkt,&len);
580 v1write=netapi_timing_start();
581 for(i=0;i<1000;i++) p_pkt[i]=i;
582 v2write=netapi_timing_start();
584 //read access
585 v1read=netapi_timing_start();
586 for(j=0;j<10;j++)
587 for(i=0;i<1000;i++) sum+=p_pkt[i];
588 v2read=netapi_timing_start();
590 // access (from malloc)
591 v1read2=netapi_timing_start();
592 for(i=0;i<1000;i++) sum2+=p[i];
593 v2read2=netapi_timing_start();
595 //free packet
596 v1push=netapi_timing_start();
597 for(i=0;i<N;i++)   Pktlib_freePacket(pkts[i]);
598 v2push = netapi_timing_start();
600 //resutls
601 printf("allocs= %d  free=%d   write=%d  read=%d read-malloc=%d (sum=%d %d)\n",
602         (v2pop-v1pop)/N, (v2push-v1push)/N,  (v2write-v1write)/1000, (v2read-v1read)/10000,
603         (v2read2-v1read2)/1000,sum,sum2);
606 };
609 //raw queue benchmark
610 #include "ti/drv/nwal/nwal_util.h"
612 #define NTOPOP 150
613 volatile unsigned long t1;
614 volatile unsigned long t2;
615 volatile unsigned long t3;
616 volatile unsigned long t4;
617 volatile unsigned long t5;
618 volatile unsigned long t6;
619 volatile unsigned long sum1=0;
620 volatile unsigned long sum2=0;
621 volatile unsigned long sum3=0;
622 volatile unsigned long sum4=0;
623 volatile Ti_Pkt * pHd[NTOPOP];
626 void benchmarks2(Pktlib_HeapHandle h , int ntrials)
628 int i,j;
629 int k;
630 int abort=0;
631 Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
633 //n_trials of NTOPOP actions
634 for(i=0;i<ntrials;i++)
636     abort=0;
637     sum1=sum2=sum3=sum4=0;
638     //raw pop
639     t1= netapi_timing_start();
640     for(j=0;j<NTOPOP;j++)
641     {
642        pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (freeQ));
643        if (!pHd[j]) 
644        {
645          printf("abort test. out of descriptors\n"); abort=1;
646          break;
647        }
648     }
649     t2= netapi_timing_start();
650     k=j;
651     for(j=0;j<k;j++)
652     {
653        pHd[j]  =  Osal_qmssConvertDescPhyToVirt(0,pHd[j]);
654     }
655     t3= netapi_timing_start();
656     sum1 += (t2-t1);
657     sum2 += (t3-t2);
658     //raw push
659     t4= netapi_timing_start();
660     for(j=0;j<k;j++)
661     {
662        if (!pHd[j]) continue;
663        pHd[j]= Osal_qmssConvertDescVirtToPhy(0,pHd[j]);
664     }
665     t5= netapi_timing_start();
666     for(j=0;j<k;j++)
667     {
668       pktio_mQmssQueuePushDescSizeRaw(freeQ,
669                                              (void *) pHd[j],
670                                              128);
671     }
672     t6= netapi_timing_start();
673     sum3 += (t5-t4);
674     sum4 += (t6-t5);
676     if (!abort)
677     printf("nt=%d raw pop=%d  p2v=%d v2p=%d raw push=%d\n", i,
678              sum1/k,  sum2/k, sum3/k, sum4/k);
679     sleep(1);
681 return;
684 //full queue push/pops
685 void benchmarks3(Pktlib_HeapHandle h , int ntrials)
687 int i,j;
688 int k;
689 int abort=0;
690 Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
692 //n_trials of NTOPOP actions
693 for(i=0;i<ntrials;i++)
695     abort=0;
696     sum2=sum4=0;
697     //raw pop
698     t1= netapi_timing_start();
699     for(j=0;j<NTOPOP;j++)
700     {
701        pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(Qmss_queuePop(freeQ));
702        if (!pHd[j])
703        {
704          printf("abort test. out of descriptors\n"); abort=1;
705          break;
706        }
707     }
708     t3= netapi_timing_start();
709     sum2 += (t3-t1);
710     k=j;
711     //raw push
712     t5= netapi_timing_start();
713     for(j=0;j<k;j++)
714     {
715        if (!pHd[j]) continue;
716        Qmss_queuePushDescSize(freeQ, pHd[j], 128);
717     }
718     t6= netapi_timing_start();
719     sum4 += (t6-t5);
720     if (!abort)
721     printf("nt=%d pop=%d  push=%d\n", i,
722               sum2/k, sum4/k);
723     sleep(1);
725 return;