moved the throughput computation to be done via cycle capture instead of osal call...

Signed-off-by: Aravind Batni <aravindbr@ti.com>

diff --git a/test/SaUnitTest/src/testconn2.c b/test/SaUnitTest/src/testconn2.c
index a59ca876f1c3f2eb5300384802bf5a2e148876c2..46189698d4274c439cd66bc3b42b931ebb8deca4 100644 (file)
--- a/test/SaUnitTest/src/testconn2.c
+++ b/test/SaUnitTest/src/testconn2.c
@@ -37,6 +37,10 @@
 #include "testconn.h"
 #include "salldsim/salldcfg.h"
 #include "ti/osal/osal.h"
+#if defined (NSS_LITE2)
+#include "ti/csl/arch/csl_arch.h"
+#include <inttypes.h>
+#endif
 
 /*
  * Declare protocol and connection related handles
@@ -71,6 +75,55 @@ static uint8_t testAad[12] = {0x55, 0x55, 0x55, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0,
 
 #define SAU_TXPKT_TO_HOST   1                                                               
 
+/* Internal local functions for throughput measurement */
+#if defined (BUILD_MCU)
+static void sau_cycle_cnt_init(void)
+{
+    uint32_t val;
+    CSL_armR5PmuCfg(0, 0, 1);
+    /* Clear the overflow */
+    val = CSL_armR5PmuReadCntrOverflowStatus();
+    val &= 0x80000007;
+    CSL_armR5PmuClearCntrOverflowStatus(val);
+    CSL_armR5PmuCfgCntr(CSL_ARM_R5_PMU_CYCLE_COUNTER_NUM, CSL_ARM_R5_PMU_EVENT_TYPE_CYCLE_CNT);
+    CSL_armR5PmuEnableAllCntrs(0);
+    CSL_armR5PmuResetCycleCnt();
+    /* Set PMCR C-bit */
+    CSL_armR5PmuResetCntrs();
+    CSL_armR5PmuEnableAllCntrs(1);
+}
+static uint64_t sau_read_cycle_cnt(void)
+{
+    uint32_t val;
+    uint64_t cnt;
+    val = CSL_armR5PmuReadCntr(CSL_ARM_R5_PMU_CYCLE_COUNTER_NUM);
+    cnt = (uint64_t) val;
+    return (cnt);
+}
+#elif defined (BUILD_MPU)
+static void sau_cycle_cnt_init(void)
+{
+    CSL_initGTC();
+}
+static uint64_t sau_read_cycle_cnt(void)
+{
+    uint64_t cnt;
+    cnt = CSL_getGTCcount();
+    return (cnt);
+}
+#else
+static void sau_cycle_cnt_init(void)
+{
+  /* stub function */
+}
+static uint64_t sau_read_cycle_cnt(void)
+{
+  /* stub function */
+}
+
+#endif
+
+
 /*******************************************************************************
  *  Function: Create a Data Mode channel  
  *******************************************************************************
@@ -991,6 +1044,7 @@ void sauCheckDesc(CSL_UdmapCppi5HMPD *hd, uint32_t connIndex, uint32_t pktNum, u
              lineNum, connIndex, pktNum, pktlen, bufflen); 
       System_flush();
   }
+
 }
 
 /*******************************************************************************
@@ -1106,7 +1160,7 @@ void sauConnDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts,
                   memcpy(authTag, (void *) psDataAddr, infoLen);
                 }
 
-#if defined(SOC_AM64X)
+#if defined (DMA_TYPE_LCDMA)
 #else
                 sauCheckDesc(hd, connIndex, pktNum, __LINE__);
 #endif
@@ -1180,8 +1234,10 @@ void sauConnDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts,
                    System_flush();
                    salld_sim_halt();
                 }
-
+#if defined (DMA_TYPE_LCDMA)
+#else
                 sauCheckDesc(hd, connIndex+1, pktNum, __LINE__);
+#endif
                 salld_sim_print("Conn %d: Receive Data Mode Pkt %d from SA\n", connIndex+1, pktNum); 
                 /* Extract PS Info if exists */
                 psDataAddr = CSL_udmapCppi5GetPsDataAddr((void*) hd, 0, 1);
@@ -1248,9 +1304,9 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
     uint32_t  descType;
 #else
     Int       encFirstTime, decFirstTime;
-    uint64_t  encGtcCumSumVal = 0, decGtcCumSumVal = 0;
-    uint64_t  gtcTxStart, gtcTxEnd;
-    uint64_t  gtcRxStart, gtcRxEnd;
+    volatile uint64_t  encGtcCumSumVal = 0, decGtcCumSumVal = 0;
+    volatile uint64_t  gtcTxStart, gtcTxEnd;
+    volatile uint64_t  gtcRxStart, gtcRxEnd, overhead;
 #endif
     uint16_t  pktNum,  nPkts, payloadLen;
     uint32_t  infoLen, numPktsRx, pLen;
@@ -1260,15 +1316,36 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
     Int       pIdx;
     Int       pktLen[SAU_TPUT_NUM_PKTSIZES] = { 64, 512, 1024, 2048 };
     uint32_t  psFlags;
-/* Temporary arrangement until Board Lib for AM64X sets up the correct R5F Freq */
-#if defined (SOC_AM64X)
-#if defined (BUILD_MCU)
-    Osal_HwAttrs    hwAttrs;
-    hwAttrs.cpuFreqKHz = 800000;
-    Osal_setHwAttrs(OSAL_HWATTR_SET_CPU_FREQ, &hwAttrs);
-#endif
+
+    /* Initialize the cycle counter */
+    sau_cycle_cnt_init();
+    gtcTxStart = sau_read_cycle_cnt();
+    gtcTxEnd = sau_read_cycle_cnt();
+    overhead = gtcTxEnd - gtcTxStart;
+    gtcTxStart = sau_read_cycle_cnt();
+    /* 32 cycle NOP instructions, which can be used to compute the overhead */
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+    asm (" NOP ");     asm (" NOP ");    asm (" NOP ");    asm (" NOP ");
+
+    gtcTxEnd = sau_read_cycle_cnt();
+    /* Total cycle should be 32 cycles + overhead */
+    encGtcCumSumVal = gtcTxEnd - gtcTxStart - overhead;
+
+#if defined(BUILD_MCU)
+    SALog("Captured cycle is = 0x%" PRIx64 " \n", encGtcCumSumVal);
+    SALog("overhead cycle is = 0x%" PRIx64 " \n", overhead);
+#else
+    SALog("Captured cycle is = 0x%" PRIx64 " \n", encGtcCumSumVal);
+    SALog("overhead cycle is = 0x%" PRIx64 " \n", overhead);
 #endif
 
+
 #if SAU_TPUT_TEST_DESC_DUMP
     gSauDescDumpEncIndex =  gSauDescDumpDecIndex = 0;
 #endif
@@ -1334,7 +1411,18 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                     memcpy((void *)&gSauDescEncDumpMem[gSauDescDumpEncIndex++], (void *) hd[i], sizeof(CSL_UdmapCppi5HMPD));
 #endif
                     pLen = CSL_udmapCppi5GetPktLen((void *) hd[i]);
+
+                    /* Benchmarking Ring Push API */
+                    if (i == 0)
+                    {
+                        gtcTxStart = sau_read_cycle_cnt();
+                    }
                     RingPush(tFramework.gTxRingHandle, pLen, (physptr_t) hd[i]);
+                    if (i == 0)
+                    {
+                        gtcTxEnd = sau_read_cycle_cnt();
+                        gSauTputData[pIdx][connIndex].ringPushCycles = gtcTxEnd - gtcTxStart - overhead;
+                    }
                 }
 
                 /*Make sure there is no packet in the Rx ring before enable of TX DMA */
@@ -1344,7 +1432,7 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                 } while (gRxPktCntInRing);
 
                 /* Now start the profile */
-                gtcTxStart = TimerP_getTimeInUsecs();
+                gtcTxStart = sau_read_cycle_cnt();
                 /* The packets should loop back into queue TF_RING_RXQ after the
                  * udma is enabled
                  */
@@ -1367,11 +1455,11 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
 #if   SAU_TPUT_TEST_DESC_DUMP
 #else
                 /* Stop the profile */
-                gtcTxEnd = TimerP_getTimeInUsecs();
+                gtcTxEnd = sau_read_cycle_cnt();
 
                 /* Book keep */
                 sauBookKeepTx(); 
-                encGtcCumSumVal = gtcTxEnd - gtcTxStart;
+                encGtcCumSumVal = gtcTxEnd - gtcTxStart - overhead;
 
                 /* Check */
                 if (numPktsRx > maxBatch)
@@ -1387,7 +1475,18 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                     FW_CPPI_DESC_T *pAppDesc;
                     pAppDesc = (FW_CPPI_DESC_T *) NULL;
                     hd[i] = (CSL_UdmapCppi5HMPD *)(NULL);
+                                        /* Benchmarking Ring Push API */
+                    if (i == 0)
+                    {
+                        gtcTxStart = sau_read_cycle_cnt();
+                    }
                     RingPop(tFramework.gRxRingHandle, &pAppDesc);
+                    if (i == 0)
+                    {
+                        gtcTxEnd = sau_read_cycle_cnt();
+                        gSauTputData[pIdx][connIndex].ringPopCycles = gtcTxEnd - gtcTxStart - overhead;
+                    }
+
                     if (pAppDesc != (FW_CPPI_DESC_T *) NULL)
                     {
                         hd[i] = &pAppDesc->hostDesc;
@@ -1403,9 +1502,7 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                     }
                 }
 
-                gSauTputData[pIdx][connIndex].cycles = encGtcCumSumVal;
-                /* GTC runs at 200 MHz */
-                gSauTputData[pIdx][connIndex].MegaBps = (8000UL * payloadLen * maxBatch)/encGtcCumSumVal;
+                gSauTputData[pIdx][connIndex].cycles = (uint32_t)encGtcCumSumVal;
 
                 /* Collect the first batch encryption cycles */
                 if (encFirstTime == TRUE)
@@ -1456,7 +1553,19 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                                                    tFramework.txComplRingNum);
 #endif
                     pLen = CSL_udmapCppi5GetPktLen((void *) hd[i]);
+
+                    /* Benchmarking Ring Push API */
+                    if (i == 0)
+                    {
+                        gtcTxStart = sau_read_cycle_cnt();
+                    }
                     RingPush(tFramework.gTxRingHandle, pLen, (physptr_t) hd[i]);
+
+                    if (i == 0)
+                    {
+                        gtcTxEnd = sau_read_cycle_cnt();
+                        gSauTputData[pIdx][connIndex+1].ringPushCycles = gtcTxEnd - gtcTxStart - overhead;
+                    }
                 }
 
                 /* Make sre there are no Rx Pkts before enable of TX DMA */
@@ -1469,16 +1578,15 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                  * udma is unpaused
                  */
 
-                /* Now start the profile */
-                 gtcRxStart = TimerP_getTimeInUsecs();
-
-                 salld_test_controlTxDma(SA2UL_UDMAP_TX_UNPAUSE);
-
 #if   SAU_TPUT_TEST_DESC_DUMP
 #else
                  numPktsRx = 0;
 #endif
 
+                /* Now start the profile */
+                 gtcRxStart = sau_read_cycle_cnt();
+                 salld_test_controlTxDma(SA2UL_UDMAP_TX_UNPAUSE);
+
 #if defined(SOC_AM64X)
                  while (numPktsRx < maxBatch)
                  {
@@ -1496,8 +1604,8 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
 #if   SAU_TPUT_TEST_DESC_DUMP
 #else
                  /* Stop the profile */
-                 gtcRxEnd = TimerP_getTimeInUsecs();
-                 decGtcCumSumVal = gtcRxEnd - gtcRxStart;
+                 gtcRxEnd = sau_read_cycle_cnt();
+                 decGtcCumSumVal = gtcRxEnd - gtcRxStart - overhead;
 
                  /* Pause the Tx UDMAP channel to prevent sa2ul to consume further packets */
                   salld_test_controlTxDma(SA2UL_UDMAP_TX_PAUSE); 
@@ -1516,7 +1624,18 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                      FW_CPPI_DESC_T *pAppDesc;
                      pAppDesc = (FW_CPPI_DESC_T *) NULL;
                      hd[i] = (CSL_UdmapCppi5HMPD *)(NULL);
+                     /* Benchmarking Ring Pop API */
+                     if (i == 0)
+                     {
+                         gtcTxStart = sau_read_cycle_cnt();
+                     }
                      RingPop(tFramework.gRxRingHandle, &pAppDesc);
+                     if (i == 0)
+                     {
+                         gtcTxEnd = sau_read_cycle_cnt();
+                         gSauTputData[pIdx][connIndex+1].ringPopCycles = gtcTxEnd - gtcTxStart - overhead;
+                     }
+
                      if (pAppDesc != (FW_CPPI_DESC_T *) NULL)
                      {
                          hd[i] = &pAppDesc->hostDesc;
@@ -1532,10 +1651,8 @@ void sauConnTputDmPktTest(tFramework_t *tf, saTest_t *pat, uint16_t numPkts)
                      }
 
                  }
-                gSauTputData[pIdx][connIndex].cycles = decGtcCumSumVal;
+                gSauTputData[pIdx][connIndex+1].cycles = (uint32_t)decGtcCumSumVal;
 
-                /* GTC runs at 200 MHz */
-                gSauTputData[pIdx][connIndex+1].MegaBps = (8000UL * payloadLen * maxBatch)/decGtcCumSumVal;
 #endif /* SAU_TPUT_TEST_DESC_DUMP */
 
                 /* Book keep */

diff --git a/test/SaUnitTest/src/tests/test1_7.c b/test/SaUnitTest/src/tests/test1_7.c
index 0da955f09037952320301169b5606cd2e1a864d3..8b4fd2fbf47f848801cd4b9f6600ebf20b7874fe 100644 (file)
--- a/test/SaUnitTest/src/tests/test1_7.c
+++ b/test/SaUnitTest/src/tests/test1_7.c
@@ -38,6 +38,7 @@
 #include "../unittest.h"
 #include "../testconn.h"
 #include "../salldsim/salldcfg.h"
+#include <inttypes.h>
 
 /* Data Mode Basic Functional test.
  * This test is designed to verify the basic opertions of Data Mode
@@ -76,7 +77,6 @@
 #if defined (NSS_LITE2)
 /* Enable the console print post silicon */
 #define ENABLE_TPUT_CONSOLE_PRINT            1
-
 /*
  * Throughput collection arrary
  */
@@ -206,6 +206,144 @@ static sauDataModeConfig_t  testDmCfg[] =
 
 #define SAU_TPUT_MAX_CHANNELS (sizeof(testDmCfg)/sizeof(sauDataModeConfig_t))
 
+/* Internal data strucure */
+typedef struct sauMetaData_s
+{
+    char        cipherMode[80];
+    char        authMode[80];
+    uint32_t    encKeySize;
+    uint32_t    macKeySize;
+}sauMetaDataInfo_t;
+
+/* Internal functions */
+static void sauDataModeGetMetaDataFromConnId(uint32_t connId, sauMetaDataInfo_t *metaData);
+static void sauDataModeGetMetaDataFromConnId(uint32_t connId, sauMetaDataInfo_t *metaData)
+{
+    Sa_CipherMode_e     cipherMode;
+    Sa_AuthMode_e       authMode;
+    cipherMode = testDmCfg[connId].cipherMode;
+    authMode   = testDmCfg[connId].authMode;
+    metaData->encKeySize    = testDmCfg[connId].encKeySize;
+    metaData->macKeySize    = testDmCfg[connId].macKeySize;
+
+    switch (cipherMode)
+    {
+      case   sa_CipherMode_AES_CTR:
+            strncpy(metaData->cipherMode, "CipherMode_AES_CTR", 40);
+            break;
+      case   sa_CipherMode_AES_F8:
+            strncpy(metaData->cipherMode, "CipherMode_AES_F8", 40);
+            break;
+      case   sa_CipherMode_AES_CBC:
+            strncpy(metaData->cipherMode, "CipherMode_AES_CBC", 40);
+            break;
+      case   sa_CipherMode_DES_CBC:
+            strncpy(metaData->cipherMode, "CipherMode_DES_CBC", 40);
+            break;
+      case   sa_CipherMode_3DES_CBC:
+            strncpy(metaData->cipherMode, "CipherMode_3DES_CBC", 40);
+            break;
+      case   sa_CipherMode_CCM:
+            strncpy(metaData->cipherMode, "CipherMode_CCM", 40);
+            break;
+      case   sa_CipherMode_GCM:
+            strncpy(metaData->cipherMode, "CipherMode_GCM", 40);
+            break;
+      case   sa_CipherMode_GSM_A53:
+            strncpy(metaData->cipherMode, "CipherMode_GSM_A53", 40);
+            break;
+      case   sa_CipherMode_ECSD_A53:
+            strncpy(metaData->cipherMode, "CipherMode_ECSD_A53", 40);
+            break;
+      case   sa_CipherMode_GEA3:
+            strncpy(metaData->cipherMode, "CipherMode_GEA3", 40);
+            break;
+      case   sa_CipherMode_KASUMI_F8:
+            strncpy(metaData->cipherMode, "CipherMode_KASUMI_F8", 40);
+            break;
+      case   sa_CipherMode_SNOW3G_F8:
+            strncpy(metaData->cipherMode, "CipherMode_SNOW3G_F8", 40);
+            break;
+      case   sa_CipherMode_ZUC_F8:
+            strncpy(metaData->cipherMode, "CipherMode_ZUC_F8", 40);
+            break;
+      case   sa_CipherMode_NULL:
+      default:
+            strncpy(metaData->cipherMode, "CipherMode_NULL", 40);
+            break;
+    }
+
+    switch (authMode)
+    {
+      case   sa_AuthMode_MD5:
+            strncpy(metaData->authMode, "AuthMode_MD5", 40);
+            break;
+      case   sa_AuthMode_SHA1:
+          strncpy(metaData->authMode, "AuthMode_SHA1", 40);
+          break;
+      case   sa_AuthMode_SHA2_224:
+          strncpy(metaData->authMode, "AuthMode_SHA2_224", 40);
+          break;
+      case   sa_AuthMode_SHA2_256:
+          strncpy(metaData->authMode, "AuthMode_SHA2_256", 40);
+          break;
+      case   sa_AuthMode_SHA2_384:
+          strncpy(metaData->authMode, "AuthMode_SHA2_384", 40);
+          break;
+      case   sa_AuthMode_SHA2_512:
+          strncpy(metaData->authMode, "AuthMode_SHA2_512", 40);
+          break;
+      case   sa_AuthMode_HMAC_MD5:
+          strncpy(metaData->authMode, "AuthMode_HMAC_MD5", 40);
+          break;
+      case   sa_AuthMode_HMAC_SHA1:
+          strncpy(metaData->authMode, "AuthMode_HMAC_SHA1", 40);
+          break;
+      case   sa_AuthMode_HMAC_SHA2_224:
+          strncpy(metaData->authMode, "AuthMode_HMAC_SHA2_224", 40);
+          break;
+      case   sa_AuthMode_HMAC_SHA2_256:
+          strncpy(metaData->authMode, "AuthMode_HMAC_SHA2_256", 40);
+          break;
+      case   sa_AuthMode_HMAC_SHA2_384:
+          strncpy(metaData->authMode, "AuthMode_HMAC_SHA2_384", 40);
+          break;
+      case   sa_AuthMode_HMAC_SHA2_512:
+          strncpy(metaData->authMode, "AuthMode_HMAC_SHA2_512", 40);
+          break;
+      case   sa_AuthMode_GMAC:
+          strncpy(metaData->authMode, "AuthMode_GMAC", 40);
+          break;
+      case   sa_AuthMode_GMAC_AH:
+          strncpy(metaData->authMode, "AuthMode_GMAC_AH", 40);
+          break;
+      case   sa_AuthMode_CMAC:
+          strncpy(metaData->authMode, "AuthMode_CMAC", 40);
+          break;
+      case   sa_AuthMode_CBC_MAC:
+          strncpy(metaData->authMode, "AuthMode_CBC_MAC", 40);
+          break;
+      case   sa_AuthMode_AES_XCBC:
+          strncpy(metaData->authMode, "AuthMode_AES_XCBC", 40);
+          break;
+      case   sa_AuthMode_KASUMI_F9:
+          strncpy(metaData->authMode, "AuthMode_KASUMI_F9", 40);
+          break;
+      case   sa_AuthMode_SNOW3G_F9:
+          strncpy(metaData->authMode, "AuthMode_SNOW3G_F9", 40);
+          break;
+      case   sa_AuthMode_ZUC_F9:
+          strncpy(metaData->authMode, "AuthMode_ZUC_F9", 40);
+          break;
+      case   sa_AuthMode_NULL:
+      default:
+          strncpy(metaData->authMode, "AuthMode_NULL", 40);
+          break;
+    }
+
+    return;
+}
+
 /* SA Data Mode Basic Functional test */
 void saDataModeTest (UArg a0, UArg a1)
 {
@@ -279,20 +417,23 @@ void saDataModeTest (UArg a0, UArg a1)
 
 #if ENABLE_TPUT_CONSOLE_PRINT
     /* Summarize the throughput test results */
-    SALog(" BenchMark Results: \n \
-    ChNo      PktLen    NumPkts    Mega Bits Per Sec \n \
-    ========  ========  ========   ================   \n ");
+    SALog(" BenchMark Results: \n");
+    SALog(" ================== \n ");
     System_flush();
     for (i = 0; i < SAU_TPUT_NUM_PKTSIZES; i++)
     {
+        sauMetaDataInfo_t mData;
         for (j = 0; j < SAU_TPUT_MAX_CHANNELS; j++)
         {
-
-            SALog(" %d,       %d,       %d,        %d \n", \
-                            gSauTputData[i][j].connId, \
+            sauDataModeGetMetaDataFromConnId(gSauTputData[i][j].connId, &mData);
+            SALog(" %s,\t\t%s,\t\t%d,\t\t%d,\t\t%d,\t\t%d,\t\t%d, \n", \
+                            mData.cipherMode, \
+                            mData.authMode,
                             gSauTputData[i][j].pktLen, \
                             gSauTputData[i][j].numPkts, \
-                            gSauTputData[i][j].MegaBps  \
+                            gSauTputData[i][j].cycles,\
+                            gSauTputData[i][j].ringPushCycles,\
+                            gSauTputData[i][j].ringPopCycles\
                             );
             System_flush();
         }

diff --git a/test/SaUnitTest/src/unittest.h b/test/SaUnitTest/src/unittest.h
index f433891f2da58812d5f7250a5e32f03d9d5b31ee..a11d49c9867bfc3b001f0e9158894a71af0593bf 100644 (file)
--- a/test/SaUnitTest/src/unittest.h
+++ b/test/SaUnitTest/src/unittest.h
@@ -363,8 +363,9 @@ typedef struct sauTest_tputData_s {
     uint32_t         connId;
     uint32_t         pktLen;
     uint32_t         numPkts;
-    uint32_t         MegaBps; /* Mbits/Sec - computed throughput */
-    uint64_t         cycles;
+    uint32_t         cycles;
+    uint32_t         ringPushCycles;
+    uint32_t         ringPopCycles;
 }sauTest_tputData_t;
 
 extern FW_CPPI_DESC_T memDescRamTx[TF_NUM_DESC];