fhi_lib/test/test_xran/compander_functional.cc

   1 /******************************************************************************\r
   2 *\r
   3 *   Copyright (c) 2019 Intel.\r
   4 *\r
   5 *   Licensed under the Apache License, Version 2.0 (the "License");\r
   6 *   you may not use this file except in compliance with the License.\r
   7 *   You may obtain a copy of the License at\r
   8 *\r
   9 *       http://www.apache.org/licenses/LICENSE-2.0\r
  10 *\r
  11 *   Unless required by applicable law or agreed to in writing, software\r
  12 *   distributed under the License is distributed on an "AS IS" BASIS,\r
  13 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14 *   See the License for the specific language governing permissions and\r
  15 *   limitations under the License.\r
  16 *\r
  17 *******************************************************************************/\r
  18 \r
  19 #include "common.hpp"\r
  20 #include "xran_fh_o_du.h"\r
  21 #include "xran_compression.h"\r
  22 #include "xran_compression.hpp"\r
  23 \r
  24 #include <stdint.h>\r
  25 #include <random>\r
  26 #include <algorithm>\r
  27 #include <iterator>\r
  28 #include <iostream>\r
  29 #include <cstring>\r
  30 \r
  31 const std::string module_name = "bfp";\r
  32 \r
  33 template <typename T>\r
  34 int checkData(T* inVec1, T* inVec2, int numVals)\r
  35 {\r
  36   int checkSum = 0;\r
  37   for (int n = 0; n < numVals; ++n)\r
  38   {\r
  39     checkSum += std::abs(inVec1[n] - inVec2[n]);\r
  40   }\r
  41   if (checkSum == 0)\r
  42   {\r
  43     //std::cout << "Test Passed\n";\r
  44     return 0;\r
  45   }\r
  46   else\r
  47   {\r
  48     //std::cout << "Test Failed\n";\r
  49     return 1;\r
  50   }\r
  51 }\r
  52 template int checkData(int8_t*, int8_t*, int);\r
  53 template int checkData(int16_t*, int16_t*, int);\r
  54 \r
  55 int checkDataApprox(int16_t *inVec1, int16_t *inVec2, int numVals)\r
  56 {\r
  57   int checkSum = 0;\r
  58   for (int n = 0; n < numVals; ++n)\r
  59   {\r
  60     if (std::abs(inVec1[n] & 0xFF00)   - std::abs(inVec2[n] & 0xFF00)){;\r
  61         printf("%d %d\n", inVec1[n] & 0xFF00, inVec2[n] & 0xFF00);\r
  62         checkSum += 1;\r
  63     }\r
  64   }\r
  65   if (checkSum == 0)\r
  66   {\r
  67     //std::cout << "Test Passed\n";\r
  68     return 0;\r
  69   }\r
  70   else\r
  71   {\r
  72     //std::cout << "Test Failed\n";\r
  73     return 1;\r
  74   }\r
  75 }\r
  76 \r
  77 \r
  78 class BfpCheck : public KernelTests\r
  79 {\r
  80 protected:\r
  81     void SetUp() override {\r
  82         init_test("bfp_functional");\r
  83     }\r
  84 \r
  85     /* It's called after an execution of the each test case.*/\r
  86     void TearDown() override {\r
  87     }\r
  88 };\r
  89 \r
  90 class BfpPerf : public KernelTests\r
  91 {\r
  92 protected:\r
  93     void SetUp() override {\r
  94         init_test("bfp_performace");\r
  95     }\r
  96 \r
  97     /* It's called after an execution of the each test case.*/\r
  98     void TearDown() override {\r
  99     }\r
 100 };\r
 101 CACHE_ALIGNED int16_t loc_dataExpandedIn[288*BlockFloatCompander::k_numREReal];\r
 102 CACHE_ALIGNED int16_t loc_dataExpandedRes[288*BlockFloatCompander::k_numREReal];\r
 103 CACHE_ALIGNED uint8_t loc_dataCompressedDataOut[2*288*BlockFloatCompander::k_numREReal];\r
 104 \r
 105 class BfpPerfEx : public KernelTests\r
 106 {\r
 107 protected:\r
 108     struct xranlib_decompress_request  bfp_decom_req;\r
 109     struct xranlib_decompress_response bfp_decom_rsp;\r
 110     struct xranlib_compress_request  bfp_com_req;\r
 111     struct xranlib_compress_response bfp_com_rsp;\r
 112 \r
 113     void SetUp() override {\r
 114         init_test("bfp_performace_ex");\r
 115         int32_t resSum  = 0;\r
 116         int16_t len = 0;\r
 117         int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;\r
 118         int16_t iqWidth    = get_input_parameter<int16_t>("iqWidth");\r
 119         int16_t numRBs = get_input_parameter<int16_t>("nRBsize");\r
 120         // Create random number generator\r
 121         std::random_device rd;\r
 122         std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 123         std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 124         std::uniform_int_distribution<int> randExpShift(0, 4);\r
 125 \r
 126         BlockFloatCompander::ExpandedData expandedData;\r
 127         expandedData.dataExpanded = &loc_dataExpandedIn[0];\r
 128         BlockFloatCompander::ExpandedData expandedDataRes;\r
 129         expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];\r
 130 \r
 131         //printf("iqWidth %d numRBs %d\n", iqWidth, numRBs);\r
 132 \r
 133         for (int m = 0; m < 18*BlockFloatCompander::k_numRB; ++m) {\r
 134             auto shiftVal = randExpShift(gen);\r
 135             for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n) {\r
 136                 expandedData.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 137             }\r
 138         }\r
 139 \r
 140         BlockFloatCompander::CompressedData compressedData;\r
 141         compressedData.dataCompressed = &loc_dataCompressedDataOut[0];\r
 142 \r
 143         std::memset(&loc_dataCompressedDataOut[0], 0, 288*BlockFloatCompander::k_numREReal);\r
 144         std::memset(&loc_dataExpandedRes[0], 0, 288*BlockFloatCompander::k_numREReal);\r
 145 \r
 146         std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));\r
 147         std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));\r
 148         std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));\r
 149         std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));\r
 150 \r
 151         bfp_com_req.data_in    = (int16_t *)expandedData.dataExpanded;\r
 152         bfp_com_req.numRBs     = numRBs;\r
 153         bfp_com_req.len        = numRBs*12*2*2;\r
 154         bfp_com_req.compMethod = compMethod;\r
 155         bfp_com_req.iqWidth    = iqWidth;\r
 156 \r
 157         bfp_com_rsp.data_out   = (int8_t *)(compressedData.dataCompressed);\r
 158         bfp_com_rsp.len        = 0;\r
 159 \r
 160         bfp_decom_req.data_in    = (int8_t *)(compressedData.dataCompressed);\r
 161         bfp_decom_req.numRBs     = numRBs;\r
 162         bfp_decom_req.len        = ((3 * iqWidth) + 1) * numRBs;\r
 163         bfp_decom_req.compMethod = compMethod;\r
 164         bfp_decom_req.iqWidth    = iqWidth;\r
 165 \r
 166         bfp_decom_rsp.data_out   = (int16_t *)expandedDataRes.dataExpanded;\r
 167         bfp_decom_rsp.len        = 0;\r
 168     }\r
 169 \r
 170     /* It's called after an execution of the each test case.*/\r
 171     void TearDown() override {\r
 172 \r
 173     }\r
 174 };\r
 175 \r
 176 TEST_P(BfpCheck, AVX512_12bit)\r
 177 {\r
 178   int resSum = 0;\r
 179 \r
 180   // Create random number generator\r
 181   std::random_device rd;\r
 182   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 183   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 184   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 185 \r
 186   // Generate random test data for compression kernel\r
 187   BlockFloatCompander::ExpandedData expandedDataInput;\r
 188   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 189   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 190     {\r
 191         auto shiftVal = randExpShift(gen);\r
 192         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 193         {\r
 194             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 195         }\r
 196     }\r
 197 \r
 198     BlockFloatCompander::CompressedData compressedDataRef;\r
 199     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 200     BlockFloatCompander::ExpandedData expandedDataRef;\r
 201     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 202     BlockFloatCompander::CompressedData compressedDataKern;\r
 203     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 204     BlockFloatCompander::ExpandedData expandedDataKern;\r
 205     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 206 \r
 207     //std::cout << "Verifying AVX512 12b iqWidth Kernel\n";\r
 208     expandedDataInput.iqWidth = 12;\r
 209     // Generate reference\r
 210     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 211     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 212     // Generate kernel output\r
 213     BlockFloatCompander::BlockFloatCompress_12b_AVX512(expandedDataInput, &compressedDataKern);\r
 214     BlockFloatCompander::BlockFloatExpand_12b_AVX512(compressedDataRef, &expandedDataKern);\r
 215     // Verify\r
 216     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 217     //std::cout << "Compression: ";\r
 218     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 219     //std::cout << "Expansion: ";\r
 220     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 221 \r
 222     ASSERT_EQ(0, resSum);\r
 223 }\r
 224 \r
 225 TEST_P(BfpCheck, AVX512_10bit)\r
 226 {\r
 227   int resSum = 0;\r
 228 \r
 229   // Create random number generator\r
 230   std::random_device rd;\r
 231   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 232   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 233   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 234 \r
 235   // Generate random test data for compression kernel\r
 236   BlockFloatCompander::ExpandedData expandedDataInput;\r
 237   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 238   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 239     {\r
 240         auto shiftVal = randExpShift(gen);\r
 241         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 242         {\r
 243             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 244         }\r
 245     }\r
 246 \r
 247     BlockFloatCompander::CompressedData compressedDataRef;\r
 248     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 249     BlockFloatCompander::ExpandedData expandedDataRef;\r
 250     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 251     BlockFloatCompander::CompressedData compressedDataKern;\r
 252     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 253     BlockFloatCompander::ExpandedData expandedDataKern;\r
 254     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 255 \r
 256     //std::cout << "Verifying AVX512 10b iqWidth Kernel\n";\r
 257     expandedDataInput.iqWidth = 10;\r
 258     // Generate reference\r
 259     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 260     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 261     // Generate kernel output\r
 262     BlockFloatCompander::BlockFloatCompress_10b_AVX512(expandedDataInput, &compressedDataKern);\r
 263     BlockFloatCompander::BlockFloatExpand_10b_AVX512(compressedDataRef, &expandedDataKern);\r
 264     // Verify\r
 265     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 266     //std::cout << "Compression: ";\r
 267     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 268     //std::cout << "Expansion: ";\r
 269     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 270 \r
 271     ASSERT_EQ(0, resSum);\r
 272 \r
 273 //    performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_10b_AVX512, expandedDataInput, &compressedDataKern);\r
 274 }\r
 275 \r
 276 TEST_P(BfpCheck, AVX512_9bit)\r
 277 {\r
 278   int resSum = 0;\r
 279 \r
 280   // Create random number generator\r
 281   std::random_device rd;\r
 282   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 283   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 284   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 285 \r
 286   // Generate random test data for compression kernel\r
 287   BlockFloatCompander::ExpandedData expandedDataInput;\r
 288   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 289   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 290     {\r
 291         auto shiftVal = randExpShift(gen);\r
 292         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 293         {\r
 294             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 295         }\r
 296     }\r
 297 \r
 298     BlockFloatCompander::CompressedData compressedDataRef;\r
 299     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 300     BlockFloatCompander::ExpandedData expandedDataRef;\r
 301     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 302     BlockFloatCompander::CompressedData compressedDataKern;\r
 303     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 304     BlockFloatCompander::ExpandedData expandedDataKern;\r
 305     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 306 \r
 307     //std::cout << "Verifying AVX512 9b iqWidth Kernel\n";\r
 308     expandedDataInput.iqWidth = 9;\r
 309     // Generate reference\r
 310     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 311     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 312     // Generate kernel output\r
 313     BlockFloatCompander::BlockFloatCompress_9b_AVX512(expandedDataInput, &compressedDataKern);\r
 314     BlockFloatCompander::BlockFloatExpand_9b_AVX512(compressedDataRef, &expandedDataKern);\r
 315     // Verify\r
 316     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 317     //std::cout << "Compression: ";\r
 318     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 319     //std::cout << "Expansion: ";\r
 320     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 321 \r
 322     ASSERT_EQ(0, resSum);\r
 323 }\r
 324 \r
 325 \r
 326 TEST_P(BfpCheck, AVX512_8bit)\r
 327 {\r
 328   int resSum = 0;\r
 329 \r
 330   // Create random number generator\r
 331   std::random_device rd;\r
 332   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 333   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 334   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 335 \r
 336   // Generate random test data for compression kernel\r
 337   BlockFloatCompander::ExpandedData expandedDataInput;\r
 338   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 339   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 340     {\r
 341         auto shiftVal = randExpShift(gen);\r
 342         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 343         {\r
 344             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 345         }\r
 346     }\r
 347 \r
 348     BlockFloatCompander::CompressedData compressedDataRef;\r
 349     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 350     BlockFloatCompander::ExpandedData expandedDataRef;\r
 351     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 352     BlockFloatCompander::CompressedData compressedDataKern;\r
 353     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 354     BlockFloatCompander::ExpandedData expandedDataKern;\r
 355     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 356 \r
 357     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 358     expandedDataInput.iqWidth = 8;\r
 359     // Generate reference\r
 360     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 361     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 362     // Generate kernel output\r
 363     BlockFloatCompander::BlockFloatCompress_8b_AVX512(expandedDataInput, &compressedDataKern);\r
 364     BlockFloatCompander::BlockFloatExpand_8b_AVX512(compressedDataRef, &expandedDataKern);\r
 365     // Verify\r
 366     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 367     //std::cout << "Compression: ";\r
 368     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 369     //std::cout << "Expansion: ";\r
 370     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 371 \r
 372     ASSERT_EQ(0, resSum);\r
 373 }\r
 374 \r
 375 TEST_P(BfpPerf, AVX512_8bit_compression)\r
 376 {\r
 377   int resSum = 0;\r
 378 \r
 379   // Create random number generator\r
 380   std::random_device rd;\r
 381   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 382   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 383   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 384 \r
 385   // Generate random test data for compression kernel\r
 386   BlockFloatCompander::ExpandedData expandedDataInput;\r
 387   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 388   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 389     {\r
 390         auto shiftVal = randExpShift(gen);\r
 391         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 392         {\r
 393             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 394         }\r
 395     }\r
 396 \r
 397     BlockFloatCompander::CompressedData compressedDataRef;\r
 398     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 399     BlockFloatCompander::ExpandedData expandedDataRef;\r
 400     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 401     BlockFloatCompander::CompressedData compressedDataKern;\r
 402     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 403     BlockFloatCompander::ExpandedData expandedDataKern;\r
 404     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 405 \r
 406     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 407     expandedDataInput.iqWidth = 8;\r
 408     // Generate reference\r
 409     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 410     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 411     // Generate kernel output\r
 412     BlockFloatCompander::BlockFloatCompress_8b_AVX512(expandedDataInput, &compressedDataKern);\r
 413     BlockFloatCompander::BlockFloatExpand_8b_AVX512(compressedDataRef, &expandedDataKern);\r
 414     // Verify\r
 415     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 416     //std::cout << "Compression: ";\r
 417     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 418     //std::cout << "Expansion: ";\r
 419     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 420 \r
 421     ASSERT_EQ(0, resSum);\r
 422 \r
 423     performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_8b_AVX512, expandedDataInput, &compressedDataKern);\r
 424 }\r
 425 \r
 426 TEST_P(BfpPerf, AVX512_8bit_decompression)\r
 427 {\r
 428   int resSum = 0;\r
 429 \r
 430   // Create random number generator\r
 431   std::random_device rd;\r
 432   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 433   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 434   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 435 \r
 436   // Generate random test data for compression kernel\r
 437   BlockFloatCompander::ExpandedData expandedDataInput;\r
 438   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 439   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 440     {\r
 441         auto shiftVal = randExpShift(gen);\r
 442         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 443         {\r
 444             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 445         }\r
 446     }\r
 447 \r
 448     BlockFloatCompander::CompressedData compressedDataRef;\r
 449     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 450     BlockFloatCompander::ExpandedData expandedDataRef;\r
 451     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 452     BlockFloatCompander::CompressedData compressedDataKern;\r
 453     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 454     BlockFloatCompander::ExpandedData expandedDataKern;\r
 455     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 456 \r
 457     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 458     expandedDataInput.iqWidth = 8;\r
 459     // Generate reference\r
 460     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 461     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 462     // Generate kernel output\r
 463     BlockFloatCompander::BlockFloatCompress_8b_AVX512(expandedDataInput, &compressedDataKern);\r
 464     BlockFloatCompander::BlockFloatExpand_8b_AVX512(compressedDataRef, &expandedDataKern);\r
 465     // Verify\r
 466     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 467     //std::cout << "Compression: ";\r
 468     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 469     //std::cout << "Expansion: ";\r
 470     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 471 \r
 472     ASSERT_EQ(0, resSum);\r
 473 \r
 474     performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_8b_AVX512, compressedDataRef, &expandedDataKern);\r
 475 }\r
 476 \r
 477 \r
 478 \r
 479 TEST_P(BfpPerf, AVX512_9bit_compression)\r
 480 {\r
 481   int resSum = 0;\r
 482 \r
 483   // Create random number generator\r
 484   std::random_device rd;\r
 485   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 486   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 487   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 488 \r
 489   // Generate random test data for compression kernel\r
 490   BlockFloatCompander::ExpandedData expandedDataInput;\r
 491   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 492   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 493     {\r
 494         auto shiftVal = randExpShift(gen);\r
 495         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 496         {\r
 497             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 498         }\r
 499     }\r
 500 \r
 501     BlockFloatCompander::CompressedData compressedDataRef;\r
 502     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 503     BlockFloatCompander::ExpandedData expandedDataRef;\r
 504     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 505     BlockFloatCompander::CompressedData compressedDataKern;\r
 506     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 507     BlockFloatCompander::ExpandedData expandedDataKern;\r
 508     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 509 \r
 510     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 511     expandedDataInput.iqWidth = 9;\r
 512     // Generate reference\r
 513     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 514     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 515     // Generate kernel output\r
 516     BlockFloatCompander::BlockFloatCompress_9b_AVX512(expandedDataInput, &compressedDataKern);\r
 517     BlockFloatCompander::BlockFloatExpand_9b_AVX512(compressedDataRef, &expandedDataKern);\r
 518     // Verify\r
 519     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 520     //std::cout << "Compression: ";\r
 521     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 522     //std::cout << "Expansion: ";\r
 523     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 524 \r
 525     ASSERT_EQ(0, resSum);\r
 526 \r
 527     performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_9b_AVX512, expandedDataInput, &compressedDataKern);\r
 528 }\r
 529 \r
 530 \r
 531 TEST_P(BfpPerf, AVX512_9bit_decompression)\r
 532 {\r
 533   int resSum = 0;\r
 534 \r
 535   // Create random number generator\r
 536   std::random_device rd;\r
 537   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 538   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 539   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 540 \r
 541   // Generate random test data for compression kernel\r
 542   BlockFloatCompander::ExpandedData expandedDataInput;\r
 543   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 544   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 545     {\r
 546         auto shiftVal = randExpShift(gen);\r
 547         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 548         {\r
 549             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 550         }\r
 551     }\r
 552 \r
 553     BlockFloatCompander::CompressedData compressedDataRef;\r
 554     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 555     BlockFloatCompander::ExpandedData expandedDataRef;\r
 556     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 557     BlockFloatCompander::CompressedData compressedDataKern;\r
 558     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 559     BlockFloatCompander::ExpandedData expandedDataKern;\r
 560     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 561 \r
 562     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 563     expandedDataInput.iqWidth = 9;\r
 564     // Generate reference\r
 565     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 566     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 567     // Generate kernel output\r
 568     BlockFloatCompander::BlockFloatCompress_9b_AVX512(expandedDataInput, &compressedDataKern);\r
 569     BlockFloatCompander::BlockFloatExpand_9b_AVX512(compressedDataRef, &expandedDataKern);\r
 570     // Verify\r
 571     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 572     //std::cout << "Compression: ";\r
 573     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 574     //std::cout << "Expansion: ";\r
 575     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 576 \r
 577     ASSERT_EQ(0, resSum);\r
 578 \r
 579     performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_9b_AVX512, compressedDataRef, &expandedDataKern);\r
 580 }\r
 581 \r
 582 \r
 583 TEST_P(BfpPerf, AVX512_10bit_compression)\r
 584 {\r
 585   int resSum = 0;\r
 586 \r
 587   // Create random number generator\r
 588   std::random_device rd;\r
 589   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 590   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 591   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 592 \r
 593   // Generate random test data for compression kernel\r
 594   BlockFloatCompander::ExpandedData expandedDataInput;\r
 595   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 596   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 597     {\r
 598         auto shiftVal = randExpShift(gen);\r
 599         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 600         {\r
 601             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 602         }\r
 603     }\r
 604 \r
 605     BlockFloatCompander::CompressedData compressedDataRef;\r
 606     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 607     BlockFloatCompander::ExpandedData expandedDataRef;\r
 608     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 609     BlockFloatCompander::CompressedData compressedDataKern;\r
 610     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 611     BlockFloatCompander::ExpandedData expandedDataKern;\r
 612     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 613 \r
 614     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 615     expandedDataInput.iqWidth = 10;\r
 616     // Generate reference\r
 617     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 618     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 619     // Generate kernel output\r
 620     BlockFloatCompander::BlockFloatCompress_10b_AVX512(expandedDataInput, &compressedDataKern);\r
 621     BlockFloatCompander::BlockFloatExpand_10b_AVX512(compressedDataRef, &expandedDataKern);\r
 622     // Verify\r
 623     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 624     //std::cout << "Compression: ";\r
 625     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 626     //std::cout << "Expansion: ";\r
 627     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 628 \r
 629     ASSERT_EQ(0, resSum);\r
 630 \r
 631     performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_10b_AVX512, expandedDataInput, &compressedDataKern);\r
 632 }\r
 633 \r
 634 TEST_P(BfpPerf, AVX512_10bit_decompression)\r
 635 {\r
 636   int resSum = 0;\r
 637 \r
 638   // Create random number generator\r
 639   std::random_device rd;\r
 640   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 641   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 642   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 643 \r
 644   // Generate random test data for compression kernel\r
 645   BlockFloatCompander::ExpandedData expandedDataInput;\r
 646   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 647   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 648     {\r
 649         auto shiftVal = randExpShift(gen);\r
 650         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 651         {\r
 652             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 653         }\r
 654     }\r
 655 \r
 656     BlockFloatCompander::CompressedData compressedDataRef;\r
 657     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 658     BlockFloatCompander::ExpandedData expandedDataRef;\r
 659     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 660     BlockFloatCompander::CompressedData compressedDataKern;\r
 661     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 662     BlockFloatCompander::ExpandedData expandedDataKern;\r
 663     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 664 \r
 665     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 666     expandedDataInput.iqWidth = 10;\r
 667     // Generate reference\r
 668     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 669     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 670     // Generate kernel output\r
 671     BlockFloatCompander::BlockFloatCompress_10b_AVX512(expandedDataInput, &compressedDataKern);\r
 672     BlockFloatCompander::BlockFloatExpand_10b_AVX512(compressedDataRef, &expandedDataKern);\r
 673     // Verify\r
 674     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 675     //std::cout << "Compression: ";\r
 676     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 677     //std::cout << "Expansion: ";\r
 678     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 679 \r
 680     ASSERT_EQ(0, resSum);\r
 681 \r
 682     performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_10b_AVX512, compressedDataRef, &expandedDataKern);\r
 683 }\r
 684 \r
 685 TEST_P(BfpPerf, AVX512_12bit_compression)\r
 686 {\r
 687   int resSum = 0;\r
 688 \r
 689   // Create random number generator\r
 690   std::random_device rd;\r
 691   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 692   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 693   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 694 \r
 695   // Generate random test data for compression kernel\r
 696   BlockFloatCompander::ExpandedData expandedDataInput;\r
 697   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 698   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 699     {\r
 700         auto shiftVal = randExpShift(gen);\r
 701         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 702         {\r
 703             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 704         }\r
 705     }\r
 706 \r
 707     BlockFloatCompander::CompressedData compressedDataRef;\r
 708     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 709     BlockFloatCompander::ExpandedData expandedDataRef;\r
 710     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 711     BlockFloatCompander::CompressedData compressedDataKern;\r
 712     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 713     BlockFloatCompander::ExpandedData expandedDataKern;\r
 714     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 715 \r
 716     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 717     expandedDataInput.iqWidth = 12;\r
 718     // Generate reference\r
 719     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 720     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 721     // Generate kernel output\r
 722     BlockFloatCompander::BlockFloatCompress_12b_AVX512(expandedDataInput, &compressedDataKern);\r
 723     BlockFloatCompander::BlockFloatExpand_12b_AVX512(compressedDataRef, &expandedDataKern);\r
 724     // Verify\r
 725     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 726     //std::cout << "Compression: ";\r
 727     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 728     //std::cout << "Expansion: ";\r
 729     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 730 \r
 731     ASSERT_EQ(0, resSum);\r
 732 \r
 733     performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_12b_AVX512, expandedDataInput, &compressedDataKern);\r
 734 }\r
 735 \r
 736 \r
 737 TEST_P(BfpPerf, AVX512_12bit_decompression)\r
 738 {\r
 739   int resSum = 0;\r
 740 \r
 741   // Create random number generator\r
 742   std::random_device rd;\r
 743   std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 744   std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 745   std::uniform_int_distribution<int> randExpShift(0, 4);\r
 746 \r
 747   // Generate random test data for compression kernel\r
 748   BlockFloatCompander::ExpandedData expandedDataInput;\r
 749   expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
 750   for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
 751     {\r
 752         auto shiftVal = randExpShift(gen);\r
 753         for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
 754         {\r
 755             expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 756         }\r
 757     }\r
 758 \r
 759     BlockFloatCompander::CompressedData compressedDataRef;\r
 760     compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
 761     BlockFloatCompander::ExpandedData expandedDataRef;\r
 762     expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
 763     BlockFloatCompander::CompressedData compressedDataKern;\r
 764     compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
 765     BlockFloatCompander::ExpandedData expandedDataKern;\r
 766     expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
 767 \r
 768     //std::cout << "Verifying AVX512 8bit Kernel\n";\r
 769     expandedDataInput.iqWidth = 12;\r
 770     // Generate reference\r
 771     BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
 772     BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
 773     // Generate kernel output\r
 774     BlockFloatCompander::BlockFloatCompress_12b_AVX512(expandedDataInput, &compressedDataKern);\r
 775     BlockFloatCompander::BlockFloatExpand_12b_AVX512(compressedDataRef, &expandedDataKern);\r
 776     // Verify\r
 777     auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
 778     //std::cout << "Compression: ";\r
 779     resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
 780     //std::cout << "Expansion: ";\r
 781     resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
 782 \r
 783     ASSERT_EQ(0, resSum);\r
 784 \r
 785     performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_12b_AVX512, compressedDataRef, &expandedDataKern);\r
 786 }\r
 787 \r
 788 TEST_P(BfpCheck, AVX512_sweep_xranlib)\r
 789 {\r
 790     int32_t resSum  = 0;\r
 791     int16_t len = 0;\r
 792 \r
 793     int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;\r
 794     int16_t iqWidth[]    = {8, 9, 10, 12};\r
 795 \r
 796     int16_t numRBs[] = {16, 18, 32, 36, 48, 70, 113, 273};\r
 797     struct xranlib_decompress_request  bfp_decom_req;\r
 798     struct xranlib_decompress_response bfp_decom_rsp;\r
 799 \r
 800     struct xranlib_compress_request  bfp_com_req;\r
 801     struct xranlib_compress_response bfp_com_rsp;\r
 802 \r
 803     // Create random number generator\r
 804     std::random_device rd;\r
 805     std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
 806     std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
 807     std::uniform_int_distribution<int> randExpShift(0, 4);\r
 808 \r
 809     BlockFloatCompander::ExpandedData expandedData;\r
 810     expandedData.dataExpanded = &loc_dataExpandedIn[0];\r
 811     BlockFloatCompander::ExpandedData expandedDataRes;\r
 812     expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];\r
 813     for (int iq_w_id = 0; iq_w_id < sizeof(iqWidth)/sizeof(iqWidth[0]); iq_w_id ++){\r
 814         for (int tc = 0; tc < sizeof(numRBs)/sizeof(numRBs[0]); tc ++){\r
 815 \r
 816             //printf("[%d]numRBs %d [%d] iqWidth %d\n",tc, numRBs[tc], iq_w_id, iqWidth[iq_w_id]);\r
 817             // Generate random test data for compression kernel\r
 818 \r
 819             for (int m = 0; m < 18*BlockFloatCompander::k_numRB; ++m) {\r
 820                 auto shiftVal = randExpShift(gen);\r
 821                 for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n) {\r
 822                     expandedData.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
 823                 }\r
 824             }\r
 825 \r
 826             BlockFloatCompander::CompressedData compressedData;\r
 827             compressedData.dataCompressed = &loc_dataCompressedDataOut[0];\r
 828 \r
 829             std::memset(&loc_dataCompressedDataOut[0], 0, 288*BlockFloatCompander::k_numREReal);\r
 830             std::memset(&loc_dataExpandedRes[0], 0, 288*BlockFloatCompander::k_numREReal);\r
 831 \r
 832             std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));\r
 833             std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));\r
 834             std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));\r
 835             std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));\r
 836 \r
 837             bfp_com_req.data_in    = (int16_t *)expandedData.dataExpanded;\r
 838             bfp_com_req.numRBs     = numRBs[tc];\r
 839             bfp_com_req.len        = numRBs[tc]*12*2*2;\r
 840             bfp_com_req.compMethod = compMethod;\r
 841             bfp_com_req.iqWidth    = iqWidth[iq_w_id];\r
 842 \r
 843             bfp_com_rsp.data_out   = (int8_t *)(compressedData.dataCompressed);\r
 844             bfp_com_rsp.len        = 0;\r
 845 \r
 846             xranlib_compress_avx512(&bfp_com_req, &bfp_com_rsp);\r
 847 \r
 848             bfp_decom_req.data_in    = (int8_t *)(compressedData.dataCompressed);\r
 849             bfp_decom_req.numRBs     = numRBs[tc];\r
 850             bfp_decom_req.len        = bfp_com_rsp.len;\r
 851             bfp_decom_req.compMethod = compMethod;\r
 852             bfp_decom_req.iqWidth    = iqWidth[iq_w_id];\r
 853 \r
 854             bfp_decom_rsp.data_out   = (int16_t *)expandedDataRes.dataExpanded;\r
 855             bfp_decom_rsp.len        = 0;\r
 856 \r
 857             xranlib_decompress_avx512(&bfp_decom_req, &bfp_decom_rsp);\r
 858 \r
 859             resSum += checkDataApprox(expandedData.dataExpanded, expandedDataRes.dataExpanded, numRBs[tc]*BlockFloatCompander::k_numREReal);\r
 860 \r
 861             ASSERT_EQ(numRBs[tc]*12*2*2, bfp_decom_rsp.len);\r
 862             ASSERT_EQ(0, resSum);\r
 863          }\r
 864     }\r
 865 }\r
 866 \r
 867 TEST_P(BfpPerfEx, AVX512_Comp)\r
 868 {\r
 869      performance("AVX512", module_name, xranlib_compress_avx512, &bfp_com_req, &bfp_com_rsp);\r
 870 }\r
 871 \r
 872 TEST_P(BfpPerfEx, AVX512_DeComp)\r
 873 {\r
 874      performance("AVX512", module_name, xranlib_decompress_avx512, &bfp_decom_req, &bfp_decom_rsp);\r
 875 }\r
 876 \r
 877 INSTANTIATE_TEST_CASE_P(UnitTest, BfpCheck,\r
 878                         testing::ValuesIn(get_sequence(BfpCheck::get_number_of_cases("bfp_functional"))));\r
 879 \r
 880 INSTANTIATE_TEST_CASE_P(UnitTest, BfpPerf,\r
 881                         testing::ValuesIn(get_sequence(BfpPerf::get_number_of_cases("bfp_performace"))));\r
 882 \r
 883 \r
 884 INSTANTIATE_TEST_CASE_P(UnitTest, BfpPerfEx,\r
 885                         testing::ValuesIn(get_sequence(BfpPerf::get_number_of_cases("bfp_performace_ex"))));\r
 886 \r
 887 \r