test/unit_test/test_xy_filter.h

   1 #ifndef __TEST_XY_FILTER_0B6AC4E9_AA51_4EF9_B255_90792DC07DB9_H__
   2 #define __TEST_XY_FILTER_0B6AC4E9_AA51_4EF9_B255_90792DC07DB9_H__
   3
   4 #include <gtest/gtest.h>
   5 #include <wtypes.h>
   6 #include <math.h>
   7 #include <xmmintrin.h>
   8 #include "xy_malloc.h"
   9
  10 void xy_filter_one_line_c(float *dst, int width, const float *filter, int filter_width);
  11 void xy_filter_sse(float *dst, int width, int height, int stride, const float *filter, int filter_width);
  12 void xy_filter_one_line_sse(float *dst, int width, const float *filter, int filter_width)
  13 {
  14     xy_filter_sse(dst, width, 1, ((width*4)+15)&~15, filter, filter_width);
  15 }
  16
  17 template<typename T>
  18 std::ostream& GetBufString(std::ostream& os, T* buf, int len)
  19 {
  20     for (int i=0;i<len;i++)
  21     {
  22         os<<buf[i]<<" ";
  23     }
  24     return os;
  25 }
  26
  27 // Usable AlmostEqual function
  28
  29 bool AlmostEqual2sComplement(float A, float B, int maxUlps)
  30 {
  31
  32     // Make sure maxUlps is non-negative and small enough that the
  33
  34     // default NAN won't compare as equal to anything.
  35
  36     assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024);
  37
  38     int aInt = *(int*)&A;
  39
  40     // Make aInt lexicographically ordered as a twos-complement int
  41
  42     if (aInt < 0)
  43
  44         aInt = 0x80000000 - aInt;
  45
  46     // Make bInt lexicographically ordered as a twos-complement int
  47
  48     int bInt = *(int*)&B;
  49
  50     if (bInt < 0)
  51         bInt = 0x80000000 - bInt;
  52
  53     int intDiff = abs(aInt - bInt);
  54
  55     if (intDiff <= maxUlps)
  56         return true;
  57
  58     return false;
  59
  60 }
  61
  62 class XyFilterTestData
  63 {
  64 public:
  65     static const int MAX_FILTER_LENGTH = 256;
  66     static const int MAX_DATA_BUFF_SIZE = 512*512;
  67     static const int MAX_BUFF_SIZE = MAX_DATA_BUFF_SIZE + 2*MAX_FILTER_LENGTH;
  68
  69     float *buff_base;
  70
  71     float *filter_f;
  72
  73     float *data;
  74     int w, h, pitch;
  75     int filter_width;
  76     int ex_filter_width;
  77
  78     XyFilterTestData():buff_base(NULL),filter_f(NULL),data(NULL)
  79     {
  80         buff_base = (float*)xy_malloc(MAX_BUFF_SIZE*sizeof(float));
  81         data = buff_base + MAX_FILTER_LENGTH;
  82         filter_f = data + MAX_DATA_BUFF_SIZE;
  83     }
  84     ~XyFilterTestData()
  85     {
  86         xy_free(buff_base);buff_base=NULL;
  87     }
  88
  89     const XyFilterTestData& copy (const XyFilterTestData& rhs)
  90     {
  91         w = rhs.w;
  92         h = rhs.h;
  93         pitch = rhs.pitch;
  94         filter_width = rhs.filter_width;
  95         ex_filter_width = rhs.ex_filter_width;
  96
  97         memcpy(buff_base, rhs.buff_base, MAX_BUFF_SIZE*sizeof(float));
  98         return *this;
  99     }
 100     bool operator== (const XyFilterTestData& rhs) const
 101     {
 102         for (int i=0;i<MAX_BUFF_SIZE;i++)
 103         {
 104             if (!AlmostEqual2sComplement(buff_base[i], rhs.buff_base[i],8))
 105             {
 106                 std::cerr<<"Not almost equal at: "<<i+buff_base-data
 107                     <<" lhs:"<<buff_base[i]
 108                     <<" rhs:"<<rhs.buff_base[i]
 109                     <<std::endl;
 110                 return false;
 111             }
 112         }
 113         return true;
 114     }
 115
 116     void FillRandData(int w, int h, int filter_width)
 117     {
 118         this->w = w;
 119         this->h = h;
 120         this->filter_width = filter_width;
 121         this->ex_filter_width = ((filter_width+3)&~3);
 122         this->pitch = ((w+ex_filter_width+3)&~3)*sizeof(float);
 123
 124         ASSERT(this->pitch*this->h <= MAX_DATA_BUFF_SIZE);
 125
 126         for (int i=0;i<h;i++)
 127         {
 128             float *data2 = (float*)((PUINT8)data + i*pitch);
 129             for (int j=0;j<w+filter_width;j++)
 130             {
 131                 data2[j] = rand()&0xFF;
 132             }
 133         }
 134         float sum = 0;
 135         for (int i=0;i<filter_width;i++)
 136         {
 137             filter_f[i] = abs((rand()&0xFFFFF)+0xFFFFF);
 138             sum += filter_f[i];
 139         }
 140         for (int i=0;i<filter_width;i++)
 141         {
 142             filter_f[i] /= sum;
 143         }
 144         for (int i=filter_width;i<ex_filter_width;i++)
 145         {
 146             filter_f[i] = 0;
 147         }
 148     }
 149 private:
 150     XyFilterTestData(const XyFilterTestData&);
 151     const XyFilterTestData& operator= (const XyFilterTestData& rhs);
 152 };
 153
 154 std::ostream& operator<<( std::ostream& os, const XyFilterTestData& data )
 155 {
 156     os<<"filter:"<<std::endl;
 157     GetBufString<const float>(os, data.filter_f, data.filter_width)<<" | ";
 158     GetBufString<const float>(os, data.filter_f+data.filter_width, data.ex_filter_width - data.filter_width)<<std::endl;
 159     os<<"data:"<<std::endl;
 160     GetBufString<const float>(os, data.data-data.ex_filter_width, data.ex_filter_width)<<" | ";
 161     GetBufString<const float>(os, data.data, data.w-data.ex_filter_width)<<" | ";
 162     GetBufString<const float>(os, data.data+data.w-data.ex_filter_width, data.ex_filter_width)<<std::endl;
 163
 164     return os;
 165 }
 166
 167 class XyFilterTest : public ::testing::Test
 168 {
 169 public:
 170     XyFilterTestData data0, data1, data2;
 171 protected:
 172     virtual void SetUp()
 173     {
 174     }
 175 };
 176
 177 #define LOG_VAR(x) " "#x" "<<x<<" "
 178
 179 TEST_F(XyFilterTest, c_vs_sse)
 180 {
 181     int LOOP_NUM = 10;
 182     for(int WIDTH=4;WIDTH<256;WIDTH+=4)
 183         for (int FILTER_WIDTH=3;FILTER_WIDTH<32;FILTER_WIDTH++)
 184         {
 185             for(int i=0;i<LOOP_NUM;i++)
 186             {
 187                 data0.FillRandData(WIDTH, 1, FILTER_WIDTH);
 188                 data1.copy(data0);
 189                 data2.copy(data0);
 190                 xy_filter_one_line_c(data1.data, data1.w, data1.filter_f, data1.ex_filter_width);
 191                 xy_filter_one_line_sse(data2.data, data2.w, data2.filter_f, data2.ex_filter_width);
 192                 ASSERT_EQ(true, data2.operator==(data1))
 193                     <<LOG_VAR(i)<<LOG_VAR(WIDTH)<<LOG_VAR(FILTER_WIDTH)<<std::endl
 194                     <<"data0:"<<data0
 195                     <<"data1:"<<data1
 196                     <<"data2:"<<data2;
 197             }
 198         }
 199 }
 200
 201
 202 #endif // __TEST_XY_FILTER_0B6AC4E9_AA51_4EF9_B255_90792DC07DB9_H__