timing_sha.c

voice test voice test

#include <openssl/crypto.h>
#include <openssl/sha.h>

#include "ippcore.h"


static Ipp8u* SetRandom8u(Ipp8u* pData, int len)
{
   int i;
   for(i=0; i<len; i++ )
      pData[i] = (Ipp8u)(rand( ) >> 4);
   return pData;
}


int compareCycles(const void* pt1, const void* pt2)
{
   Ipp64s t = *((Ipp64s*)pt1) - *((Ipp64s*)pt2);
   return t==0? 0 : (t>0)? 1 : -1;
}

#define MAX_LOOPS (21)

int TimingSHA1(int minLen, int maxLen)
{
   Ipp8u* pData = malloc(maxLen);

   if(pData) {
      int len;
      Ipp64s t[MAX_LOOPS];
      Ipp8u md[SHA_DIGEST_LENGTH];

      SetRandom8u(pData, maxLen);

      for(len=minLen; len<=maxLen; len*=2) {
         Ipp64s start, stop;
         int n;

         for(n=0; n<MAX_LOOPS; n++) {
            //sysTimeTicks(&start);
            start = ippGetCpuClocks();
            SHA1(pData, len, md);
            //sysTimeTicks(&stop);
            stop = ippGetCpuClocks();
            t[n] = (stop-start);
         }
         qsort(t, MAX_LOOPS, sizeof(Ipp64s), compareCycles);

         //fprintf(stdout, "SHA1 DIGEST: len=%5d #cycles=%d\n", len, t[MAX_LOOPS/2]);
         fprintf(stdout, "SHA1,%5d,%6.2f\n", len, (double)t[MAX_LOOPS/2]/len);
      }

      free(pData);
      return 1;
   }
   return 0;
}

int TimingSHA256(int minLen, int maxLen)
{
   Ipp8u* pData = malloc(maxLen);

   if(pData) {
      int len;
      Ipp64s t[MAX_LOOPS];
      Ipp8u md[SHA256_DIGEST_LENGTH];

      SetRandom8u(pData, maxLen);

      for(len=minLen; len<=maxLen; len*=2) {
         Ipp64s start, stop;
         int n;

         for(n=0; n<MAX_LOOPS; n++) {
            //sysTimeTicks(&start);
            start = ippGetCpuClocks();
            SHA256(pData, len, md);
            //sysTimeTicks(&stop);
            stop = ippGetCpuClocks();
            t[n] = (stop-start);
         }
         qsort(t, MAX_LOOPS, sizeof(Ipp64s), compareCycles);

         //fprintf(stdout, "SHA256 DIGEST: len=%5d #cycles=%d\n", len, t[MAX_LOOPS/2]);
         fprintf(stdout, "SHA256,%5d,%6.2f\n", len, (double)t[MAX_LOOPS/2]/len);
      }

      free(pData);
      return 1;
   }
   return 0;
}

int TimingSHA512(int minLen, int maxLen)
{
   Ipp8u* pData = malloc(maxLen);

   if(pData) {
      int len;
      Ipp64s t[MAX_LOOPS];
      Ipp8u md[SHA512_DIGEST_LENGTH];

      SetRandom8u(pData, maxLen);

      for(len=minLen; len<=maxLen; len*=2) {
         Ipp64s start, stop;
         int n;

         for(n=0; n<MAX_LOOPS; n++) {
            //sysTimeTicks(&start);
            start = ippGetCpuClocks();
            SHA512(pData, len, md);
            //sysTimeTicks(&stop);
            stop = ippGetCpuClocks();
            t[n] = (stop-start);
         }
         qsort(t, MAX_LOOPS, sizeof(Ipp64s ), compareCycles);

         //fprintf(stdout, "SHA512 DIGEST: len=%5d #cycles=%d\n", len, t[MAX_LOOPS/2]);
         fprintf(stdout, "SHA512,%5d,%6.2f\n", len, (double)t[MAX_LOOPS/2]/len);
      }

      free(pData);
      return 1;
   }
   return 0;
}


#define MIN_LEN   (128)
#define MAX_LEN   (16384)

int main(void)
{
   fprintf(stdout, "SHA digest alg,data length,cycles/byte\n");

   TimingSHA1(MIN_LEN, MAX_LEN);
   TimingSHA256(MIN_LEN, MAX_LEN);
   TimingSHA512(MIN_LEN, MAX_LEN);
   return 0;
}