testvmx.c

The Valgrind distribution has multiple tools. The most popular is the memory checking tool (called M

/*    Function vec_ld    */
  printf("\n:::::::::::::::::::::::::::::::::::::::\n");
  err = 0;
  memcpy( UCmem, &UCcons1, sizeof(vector unsigned char) );
  UCaux1.v = vec_ld( 0, UCmem );
  Iaux = 1;
  for ( i=0; i< 16; i++ )
  {
    Iaux = Iaux && (UCaux1.e[i]==UCmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ld [type unsigned char]      ===> Error\n");
  else
    printf("Function vec_ld [type unsigned char]      ===> OK\n");
  
  err = 0;
  memcpy( Cmem, &Ccons1, sizeof(vector signed char) );
  Caux1.v = vec_ld( 0, Cmem );
  Iaux = 1;
  for ( i=0; i< 16; i++ )
  {
    Iaux = Iaux && (Caux1.e[i]==Cmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ld [type char]               ===> Error\n");
  else
    printf("Function vec_ld [type char]               ===> OK\n");
  
  err = 0;
  memcpy( USmem, &UScons3, sizeof(vector unsigned short) );
  USaux1.v = vec_ld( 0, USmem );
  Iaux = 1;
  for ( i=0; i< 8; i++ )
  {
    Iaux = Iaux && (USaux1.e[i]==USmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ld [type unsigned short]     ===> Error\n");
  else
    printf("Function vec_ld [type unsigned short]     ===> OK\n");
  
  err = 0;
  memcpy( Smem, &Scons1, sizeof(vector signed short) );
  Saux1.v = vec_ld( 0, Smem );
  Iaux = 1;
  for ( i=0; i< 8; i++ )
  {
    Iaux = Iaux && (Saux1.e[i]==Smem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ld [type short]              ===> Error\n");
  else
    printf("Function vec_ld [type short]              ===> OK\n");
  
  err = 0;
  memcpy( UImem, &UIcons1, sizeof(vector unsigned int) );
  UIaux1.v = vec_ld( 0, UImem );
  Iaux = 1;
  for ( i=0; i< 4; i++ )
  {
    Iaux = Iaux && (UIaux1.e[i]==UImem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ld [type unsigned int]       ===> Error\n");
  else
    printf("Function vec_ld [type unsigned int]       ===> OK\n");
  
  err = 0;
  memcpy( Imem, &Icons1, sizeof(vector signed int) );
  Iaux1.v = vec_ld( 0, Imem );
  Iaux = 1;
  for ( i=0; i< 4; i++ )
  {
    Iaux = Iaux && (Iaux1.e[i]==Imem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ld [type int]                ===> Error\n");
  else
    printf("Function vec_ld [type int]                ===> OK\n");
  
#if defined TEST_FLOATS
  err = 0;
  memcpy( Fmem, &Fcons1, sizeof(vector float) );
  Faux1.v = vec_ld( 0, Fmem );
  Iaux = 1;
  for ( i=0; i< 4; i++ )
  {
    Iaux = Iaux && (Faux1.e[i]==Fmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ld [type float]              ===> Error\n");
  else
    printf("Function vec_ld [type float]              ===> OK\n");
#endif

/*    Function vec_lde    */
  printf("\n:::::::::::::::::::::::::::::::::::::::\n");

  err = 0;
  for (i= 0; i< 16; i++)
    UCmem[i] = (unsigned char)i;
  j = 1;   
  i = j*sizeof(unsigned char);
  UCaux1.v = vec_lde( i, UCmem );
  
  if (UCaux1.e[j] != UCmem[j]) err++;
  
  if (err)
    printf("Function vec_lde [type unsigned char]     ===> Error\n");
  else
    printf("Function vec_lde [type unsigned char]     ===> OK\n");
  
  err = 0;
  for (i= 0; i< 16; i++)
    Cmem[i] = (char)(-i);
  j = 1;   
  i = j*sizeof(char);
  Caux1.v = vec_lde( i, Cmem );
  
  if (Caux1.e[j] != Cmem[j]) err++;
  
  if (err)
    printf("Function vec_lde [type char]              ===> Error\n");
  else
    printf("Function vec_lde [type char]              ===> OK\n");
  
  err = 0;
  for (i= 0; i< 8; i++)
    USmem[i] = (unsigned short)(i);
  j = 1;   
  i = j*sizeof(unsigned short);
  USaux1.v = vec_lde( i, USmem );
  
  if (USaux1.e[j] != USmem[j]) err++;
  
  if (err)
    printf("Function vec_lde [type unsigned short]    ===> Error\n");
  else
    printf("Function vec_lde [type unsigned short]    ===> OK\n");
  
  err = 0;
  for (i= 0; i< 8; i++)
    Smem[i] = (short)(-i);
  j = 1;   
  i = j*sizeof(short);
  Saux1.v = vec_lde( i, Smem );
  
  if (Saux1.e[j] != Smem[j]) err++;

  if (err)
    printf("Function vec_lde [type short]             ===> Error\n");
  else
    printf("Function vec_lde [type short]             ===> OK\n");
  
  err = 0;
  for (i= 0; i< 4; i++)
    UImem[i] = (unsigned int)(i);
  j = 1;   
  i = j*sizeof(unsigned int);
  UIaux1.v = vec_lde( i, UImem );
  
  if (UIaux1.e[j] != UImem[j]) err++;
  
  if (err)
    printf("Function vec_lde [type unsigned int]      ===> Error\n");
  else
    printf("Function vec_lde [type unsigned int]      ===> OK\n");
  
  err = 0;
  for (i= 0; i< 4; i++)
    Imem[i] = (int)(-i);
  j = 1;   
  i = j*sizeof(int);
  Iaux1.v = vec_lde( i, Imem );
  
  if (Iaux1.e[j] != Imem[j]) err++;
  
  if (err)
    printf("Function vec_lde [type int]               ===> Error\n");
  else
    printf("Function vec_lde [type int]               ===> OK\n");
  
#if defined TEST_FLOATS
  err = 0;
  for (i= 0; i< 4; i++)
    Fmem[i] = ((float)(-i)) - 0.5;
  j = 1;   
  i = j*sizeof(float);
  Faux1.v = vec_lde( i, Fmem );
  
  if (Faux1.e[j] != Fmem[j]) err++;
  
  if (err)
    printf("Function vec_lde [type float]             ===> Error\n");
  else
    printf("Function vec_lde [type float]             ===> OK\n");
#endif

#if 0
/*    Function vec_ldl    */
  printf("\n:::::::::::::::::::::::::::::::::::::::\n");
  err = 0;
  memcpy( UCmem, &UCcons1, sizeof(vector unsigned char) );
  UCaux1.v = vec_ldl( 0, UCmem );
  Iaux = 1;
  for ( i=0; i< 16; i++ )
  {
    Iaux = Iaux && (UCaux1.e[i]==UCmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ldl [type unsigned char]     ===> Error\n");
  else
    printf("Function vec_ldl [type unsigned char]     ===> OK\n");

  err = 0;
  memcpy( Cmem, &Ccons1, sizeof(vector signed char) );
  Caux1.v = vec_ldl( 0, Cmem );
  Iaux = 1;
  for ( i=0; i< 16; i++ )
  {
    Iaux = Iaux && (Caux1.e[i]==Cmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ldl [type char]              ===> Error\n");
  else
    printf("Function vec_ldl [type char]              ===> OK\n");
  
  err = 0;
  memcpy( USmem, &UScons3, sizeof(vector unsigned short) );
  USaux1.v = vec_ldl( 0, USmem );
  Iaux = 1;
  for ( i=0; i< 8; i++ )
  {
    Iaux = Iaux && (USaux1.e[i]==USmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ldl [type unsigned short]    ===> Error\n");
  else
    printf("Function vec_ldl [type unsigned short]    ===> OK\n");
  
  err = 0;
  memcpy( Smem, &Scons1, sizeof(vector signed short) );
  Saux1.v = vec_ldl( 0, Smem );
  Iaux = 1;
  for ( i=0; i< 8; i++ )
  {
    Iaux = Iaux && (Saux1.e[i]==Smem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ldl [type short]             ===> Error\n");
  else
    printf("Function vec_ldl [type short]             ===> OK\n");
  
  err = 0;
  memcpy( UImem, &UIcons1, sizeof(vector unsigned int) );
  UIaux1.v = vec_ldl( 0, UImem );
  Iaux = 1;
  for ( i=0; i< 4; i++ )
  {
    Iaux = Iaux && (UIaux1.e[i]==UImem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ldl [type unsigned int]      ===> Error\n");
  else
    printf("Function vec_ldl [type unsigned int]      ===> OK\n");
  
  err = 0;
  memcpy( Imem, &Icons1, sizeof(vector signed int) );
  Iaux1.v = vec_ldl( 0, Imem );
  Iaux = 1;
  for ( i=0; i< 4; i++ )
  {
    Iaux = Iaux && (Iaux1.e[i]==Imem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ldl [type int]               ===> Error\n");
  else
    printf("Function vec_ldl [type int]               ===> OK\n");
  
#if defined TEST_FLOATS
  err = 0;
  memcpy( Fmem, &Fcons1, sizeof(vector float) );
  Faux1.v = vec_ldl( 0, Fmem );
  Iaux = 1;
  for ( i=0; i< 4; i++ )
  {
    Iaux = Iaux && (Faux1.e[i]==Fmem[i]);
  }
  if (Iaux!=1) err++;
  
  if (err)
    printf("Function vec_ldl [type float]             ===> Error\n");
  else
    printf("Function vec_ldl [type float]             ===> OK\n");
#endif
#endif  // #if 0

  /* Free dynamic vector variables */
  free_vec( UCmem );
  free_vec( Cmem );
  free_vec( USmem );
  free_vec( Smem );
  free_vec( UImem );
  free_vec( Imem );
#if defined TEST_FLOATS
  free_vec( Fmem );
#endif

#if defined TEST_FLOATS
/*    Function vec_loge    */
  printf("\n:::::::::::::::::::::::::::::::::::::::\n");
  err = 0;
  Faux1.v = vec_loge( Fcons3 );
  Faux2.v = Fcons3;
  for( i=0; i< 4; i++ )
  {
    Faux = log2(Faux2.e[i]);
    if (Faux!=0.0)
      Faux = (Faux - Faux1.e[i])/Faux;
    else
      Faux = Faux - Faux1.e[i];
    if (Faux>0.1)
      err++;
  }
  if (err)
    printf("Function vec_loge [type float]            ===> Error\n");
  else
    printf("Function vec_loge [type float]            ===> OK\n");
#endif

  return 0;
}




int part2()
{
  TvecChar      Caux1,  Caux2,  Caux3;//,  Caux4;
  TvecUChar     UCaux1, UCaux2, UCaux3;//, UCaux4;
  TvecShort     Saux1,  Saux2,  Saux3,  Saux4;
  TvecUShort    USaux1, USaux2, USaux3, USaux4;
  TvecInt       Iaux1,  Iaux2,  Iaux3;//,  Iaux4;
  TvecUInt      UIaux1, UIaux2, UIaux3;//, UIaux4;
#if defined TEST_FLOATS
  TvecFloat     Faux1,  Faux2,  Faux3,  Faux4;
#endif

  int                  i, err, j, b, bAux;
#if defined TEST_FLOATS
  signed   int         Ivec1, Ivec2, Ivec3;
#endif
//  signed   short       *Svec1;
//  unsigned int         *UIvec1;
//  unsigned short       *USvec1;
//  unsigned char        *UCvec1;
#if defined TEST_FLOATS
//  float                *Fvec1;
#endif

  /* For saturated rutines */
//  long long int         LLaux;

#if defined TEST_FLOATS
  float                 Faux;
#endif
  signed   int          Iaux, I1, I2;
  unsigned int          UIaux, UI1, UI2;
  signed   short        Saux;
  unsigned short        USaux;
  signed   char         Caux;
  unsigned char         UCaux;

  union
  {
    float          f;
    signed   int   si;
    unsigned int   ui;
    signed   short ss[2];
    unsigned short us[2];
    signed   char  sc[4];
    unsigned char  uc[4];
  } INTunion1;//, INTunion2;

/*
  union
  {
    signed   short  ss;
    unsigned short  us;
    signed   char   sc[2];
    unsigned char   uc[2];
  } SHOunion1, SHOunion2;
*/

#if defined (GCC_COMPILER)
  vector signed char    Ccons1   = (vector signed char){-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
  vector signed char    Ccons2   = (vector signed char){1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
//  vector signed char    Ccons3   = (vector signed char){-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127};
  vector unsigned char  UCcons1  = (vector unsigned char){248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7};
  vector unsigned char  UCcons2  = (vector unsigned char){2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
//  vector unsigned char  UCcons3  = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
  vector signed short   Scons1   = (vector signed short){256, 320, 340, -1, 0, 1, 2, 3};
  vector signed short   Scons2   = (vector signed short){256, 320, 340, 1, 1, 1, -10000, -10000};
  vector signed short   Scons3   = (vector signed short){256, 320, 340, 32767, -32768, 32767, -32768, 32767};
  vector unsigned short UScons1  = (vector unsigned short){65532, 65533, 65534, 65535, 0, 1, 2, 3};
  vector unsigned short UScons2  = (vector unsigned short){1, 1, 1, 1, 1, 1, 1, 1};
  vector unsigned short UScons3  = (vector unsigned short){1, 2, 3, 4, 1, 2, 3, 4};
  vector signed int     Icons1   = (vector signed int){-4, -1, 1, 4};
  vector signed int     Icons2   = (vector signed int){1, 1, 1, 1};
  vector signed int     Icons3   = (vector signed int){0x80000000, 0x7FFFFFFF, 0x80000000, 0x7FFFFFFF};
  vector unsigned int   UIcons1  = (vector unsigned int){0xFFFFFFFE, 0xFFFFFFFF, 0, 1};
  vector unsigned int   UIcons2  = (vector unsigned int){1, 1, 1, 1};
  vector unsigned int   UIcons3  = (vector unsigned int){1, 2, 1, 2};

#if defined TEST_FLOATS
  vector float          Fcons1   = (vector float){-1.5, 1.0, 0.5, -3.999};
  vector float          Fcons2   = (vector float){1.0, 1.0, 1.0, 1.0};
  vector float          Fcons3   = (vector float){100000000000.0, 1.0, -1.0, -1234567890.0};
#endif

#elif defined (MAC_COMPILER) || defined (XLC_COMPILER)
  vector signed char    Ccons1   = (vector signed char)(-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7);
  vector signed char    Ccons2   = (vector signed char)(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
  vector signed char    Ccons3   = (vector signed char)(-128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127, -128, 127);
  vector unsigned char  UCcons1  = (vector unsigned char)(248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7);
  vector unsigned char  UCcons2  = (vector unsigned char)(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
//  vector unsigned char  UCcons3  = (vector unsigned char)(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
  vector signed short   Scons1   = (vector signed short)(-4, -3, -2, -1, 0, 1, 2, 3);
  vector signed short   Scons2   = (vector signed short)(-32768, 10000, 1, 1, 1, 1, -10000, -10000);
  vector signed short   Scons3   = (vector signed short)(-32768, 32767, -32768, 32767, -32768, 32767, -32768, 32767);
  vector unsigned short UScons1  = (vector unsigned short)(65532, 65533, 65534, 65535, 0, 1, 2, 3);
  vector unsigned short UScons2  = (vector unsigned short)(1, 1, 1, 1, 1, 1, 1, 1);
  vector unsigned short UScons3  = (vector unsigned short)(1, 2, 3, 4, 1, 2, 3, 4);
  vector signed int     Icons1   = (vector signed int)(-4, -1, 1, 4);
  vector signed int     Icons2   = (vector signed int)(1, 1, 1, 1);
  vector signed int     Ic