--- /dev/null
+/******************************************************************************\r
+*\r
+* Copyright (c) 2019 Intel.\r
+*\r
+* Licensed under the Apache License, Version 2.0 (the "License");\r
+* you may not use this file except in compliance with the License.\r
+* You may obtain a copy of the License at\r
+*\r
+* http://www.apache.org/licenses/LICENSE-2.0\r
+*\r
+* Unless required by applicable law or agreed to in writing, software\r
+* distributed under the License is distributed on an "AS IS" BASIS,\r
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+* See the License for the specific language governing permissions and\r
+* limitations under the License.\r
+*\r
+*******************************************************************************/\r
+\r
+#include "common.hpp"\r
+#include "xran_fh_o_du.h"\r
+#include "xran_compression.h"\r
+#include "xran_compression.hpp"\r
+\r
+#include <stdint.h>\r
+#include <random>\r
+#include <algorithm>\r
+#include <iterator>\r
+#include <iostream>\r
+#include <cstring>\r
+\r
+const std::string module_name = "bfp";\r
+\r
+template <typename T>\r
+int checkData(T* inVec1, T* inVec2, int numVals)\r
+{\r
+ int checkSum = 0;\r
+ for (int n = 0; n < numVals; ++n)\r
+ {\r
+ checkSum += std::abs(inVec1[n] - inVec2[n]);\r
+ }\r
+ if (checkSum == 0)\r
+ {\r
+ //std::cout << "Test Passed\n";\r
+ return 0;\r
+ }\r
+ else\r
+ {\r
+ //std::cout << "Test Failed\n";\r
+ return 1;\r
+ }\r
+}\r
+template int checkData(int8_t*, int8_t*, int);\r
+template int checkData(int16_t*, int16_t*, int);\r
+\r
+int checkDataApprox(int16_t *inVec1, int16_t *inVec2, int numVals)\r
+{\r
+ int checkSum = 0;\r
+ for (int n = 0; n < numVals; ++n)\r
+ {\r
+ if (std::abs(inVec1[n] & 0xFF00) - std::abs(inVec2[n] & 0xFF00)){;\r
+ printf("%d %d\n", inVec1[n] & 0xFF00, inVec2[n] & 0xFF00);\r
+ checkSum += 1;\r
+ }\r
+ }\r
+ if (checkSum == 0)\r
+ {\r
+ //std::cout << "Test Passed\n";\r
+ return 0;\r
+ }\r
+ else\r
+ {\r
+ //std::cout << "Test Failed\n";\r
+ return 1;\r
+ }\r
+}\r
+\r
+\r
+class BfpCheck : public KernelTests\r
+{\r
+protected:\r
+ void SetUp() override {\r
+ init_test("bfp_functional");\r
+ }\r
+\r
+ /* It's called after an execution of the each test case.*/\r
+ void TearDown() override {\r
+ }\r
+};\r
+\r
+class BfpPerf : public KernelTests\r
+{\r
+protected:\r
+ void SetUp() override {\r
+ init_test("bfp_performace");\r
+ }\r
+\r
+ /* It's called after an execution of the each test case.*/\r
+ void TearDown() override {\r
+ }\r
+};\r
+CACHE_ALIGNED int16_t loc_dataExpandedIn[288*BlockFloatCompander::k_numREReal];\r
+CACHE_ALIGNED int16_t loc_dataExpandedRes[288*BlockFloatCompander::k_numREReal];\r
+CACHE_ALIGNED uint8_t loc_dataCompressedDataOut[2*288*BlockFloatCompander::k_numREReal];\r
+\r
+class BfpPerfEx : public KernelTests\r
+{\r
+protected:\r
+ struct xranlib_decompress_request bfp_decom_req;\r
+ struct xranlib_decompress_response bfp_decom_rsp;\r
+ struct xranlib_compress_request bfp_com_req;\r
+ struct xranlib_compress_response bfp_com_rsp;\r
+\r
+ void SetUp() override {\r
+ init_test("bfp_performace_ex");\r
+ int32_t resSum = 0;\r
+ int16_t len = 0;\r
+ int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;\r
+ int16_t iqWidth = get_input_parameter<int16_t>("iqWidth");\r
+ int16_t numRBs = get_input_parameter<int16_t>("nRBsize");\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ BlockFloatCompander::ExpandedData expandedData;\r
+ expandedData.dataExpanded = &loc_dataExpandedIn[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRes;\r
+ expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];\r
+\r
+ //printf("iqWidth %d numRBs %d\n", iqWidth, numRBs);\r
+\r
+ for (int m = 0; m < 18*BlockFloatCompander::k_numRB; ++m) {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n) {\r
+ expandedData.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedData;\r
+ compressedData.dataCompressed = &loc_dataCompressedDataOut[0];\r
+\r
+ std::memset(&loc_dataCompressedDataOut[0], 0, 288*BlockFloatCompander::k_numREReal);\r
+ std::memset(&loc_dataExpandedRes[0], 0, 288*BlockFloatCompander::k_numREReal);\r
+\r
+ std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));\r
+ std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));\r
+ std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));\r
+ std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));\r
+\r
+ bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;\r
+ bfp_com_req.numRBs = numRBs;\r
+ bfp_com_req.len = numRBs*12*2*2;\r
+ bfp_com_req.compMethod = compMethod;\r
+ bfp_com_req.iqWidth = iqWidth;\r
+\r
+ bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);\r
+ bfp_com_rsp.len = 0;\r
+\r
+ bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);\r
+ bfp_decom_req.numRBs = numRBs;\r
+ bfp_decom_req.len = ((3 * iqWidth) + 1) * numRBs;\r
+ bfp_decom_req.compMethod = compMethod;\r
+ bfp_decom_req.iqWidth = iqWidth;\r
+\r
+ bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;\r
+ bfp_decom_rsp.len = 0;\r
+ }\r
+\r
+ /* It's called after an execution of the each test case.*/\r
+ void TearDown() override {\r
+\r
+ }\r
+};\r
+\r
+TEST_P(BfpCheck, AVX512_12bit)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 12b iqWidth Kernel\n";\r
+ expandedDataInput.iqWidth = 12;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_12b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_12b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+}\r
+\r
+TEST_P(BfpCheck, AVX512_10bit)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 10b iqWidth Kernel\n";\r
+ expandedDataInput.iqWidth = 10;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_10b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_10b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+// performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_10b_AVX512, expandedDataInput, &compressedDataKern);\r
+}\r
+\r
+TEST_P(BfpCheck, AVX512_9bit)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 9b iqWidth Kernel\n";\r
+ expandedDataInput.iqWidth = 9;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_9b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_9b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+}\r
+\r
+\r
+TEST_P(BfpCheck, AVX512_8bit)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 8;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_8b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_8b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+}\r
+\r
+TEST_P(BfpPerf, AVX512_8bit_compression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 8;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_8b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_8b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_8b_AVX512, expandedDataInput, &compressedDataKern);\r
+}\r
+\r
+TEST_P(BfpPerf, AVX512_8bit_decompression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 8;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_8b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_8b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_8b_AVX512, compressedDataRef, &expandedDataKern);\r
+}\r
+\r
+\r
+\r
+TEST_P(BfpPerf, AVX512_9bit_compression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 9;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_9b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_9b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_9b_AVX512, expandedDataInput, &compressedDataKern);\r
+}\r
+\r
+\r
+TEST_P(BfpPerf, AVX512_9bit_decompression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 9;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_9b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_9b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_9b_AVX512, compressedDataRef, &expandedDataKern);\r
+}\r
+\r
+\r
+TEST_P(BfpPerf, AVX512_10bit_compression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 10;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_10b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_10b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_10b_AVX512, expandedDataInput, &compressedDataKern);\r
+}\r
+\r
+TEST_P(BfpPerf, AVX512_10bit_decompression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 10;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_10b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_10b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_10b_AVX512, compressedDataRef, &expandedDataKern);\r
+}\r
+\r
+TEST_P(BfpPerf, AVX512_12bit_compression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 12;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_12b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_12b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatCompress_12b_AVX512, expandedDataInput, &compressedDataKern);\r
+}\r
+\r
+\r
+TEST_P(BfpPerf, AVX512_12bit_decompression)\r
+{\r
+ int resSum = 0;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ // Generate random test data for compression kernel\r
+ BlockFloatCompander::ExpandedData expandedDataInput;\r
+ expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];\r
+ for (int m = 0; m < BlockFloatCompander::k_numRB; ++m)\r
+ {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n)\r
+ {\r
+ expandedDataInput.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedDataRef;\r
+ compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRef;\r
+ expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];\r
+ BlockFloatCompander::CompressedData compressedDataKern;\r
+ compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];\r
+ BlockFloatCompander::ExpandedData expandedDataKern;\r
+ expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];\r
+\r
+ //std::cout << "Verifying AVX512 8bit Kernel\n";\r
+ expandedDataInput.iqWidth = 12;\r
+ // Generate reference\r
+ BlockFloatCompander::BlockFloatCompress_Basic(expandedDataInput, &compressedDataRef);\r
+ BlockFloatCompander::BlockFloatExpand_Basic(compressedDataRef, &expandedDataRef);\r
+ // Generate kernel output\r
+ BlockFloatCompander::BlockFloatCompress_12b_AVX512(expandedDataInput, &compressedDataKern);\r
+ BlockFloatCompander::BlockFloatExpand_12b_AVX512(compressedDataRef, &expandedDataKern);\r
+ // Verify\r
+ auto totNumBytes = ((3 * compressedDataRef.iqWidth) + 1) * BlockFloatCompander::k_numRB;\r
+ //std::cout << "Compression: ";\r
+ resSum += checkData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, totNumBytes);\r
+ //std::cout << "Expansion: ";\r
+ resSum += checkData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, BlockFloatCompander::k_numSampsExpanded);\r
+\r
+ ASSERT_EQ(0, resSum);\r
+\r
+ performance("AVX512", module_name, BlockFloatCompander::BlockFloatExpand_12b_AVX512, compressedDataRef, &expandedDataKern);\r
+}\r
+\r
+TEST_P(BfpCheck, AVX512_sweep_xranlib)\r
+{\r
+ int32_t resSum = 0;\r
+ int16_t len = 0;\r
+\r
+ int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;\r
+ int16_t iqWidth[] = {8, 9, 10, 12};\r
+\r
+ int16_t numRBs[] = {16, 18, 32, 36, 48, 70, 113, 273};\r
+ struct xranlib_decompress_request bfp_decom_req;\r
+ struct xranlib_decompress_response bfp_decom_rsp;\r
+\r
+ struct xranlib_compress_request bfp_com_req;\r
+ struct xranlib_compress_response bfp_com_rsp;\r
+\r
+ // Create random number generator\r
+ std::random_device rd;\r
+ std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()\r
+ std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);\r
+ std::uniform_int_distribution<int> randExpShift(0, 4);\r
+\r
+ BlockFloatCompander::ExpandedData expandedData;\r
+ expandedData.dataExpanded = &loc_dataExpandedIn[0];\r
+ BlockFloatCompander::ExpandedData expandedDataRes;\r
+ expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];\r
+ for (int iq_w_id = 0; iq_w_id < sizeof(iqWidth)/sizeof(iqWidth[0]); iq_w_id ++){\r
+ for (int tc = 0; tc < sizeof(numRBs)/sizeof(numRBs[0]); tc ++){\r
+\r
+ //printf("[%d]numRBs %d [%d] iqWidth %d\n",tc, numRBs[tc], iq_w_id, iqWidth[iq_w_id]);\r
+ // Generate random test data for compression kernel\r
+\r
+ for (int m = 0; m < 18*BlockFloatCompander::k_numRB; ++m) {\r
+ auto shiftVal = randExpShift(gen);\r
+ for (int n = 0; n < BlockFloatCompander::k_numREReal; ++n) {\r
+ expandedData.dataExpanded[m*BlockFloatCompander::k_numREReal+n] = int16_t(randInt16(gen) >> shiftVal);\r
+ }\r
+ }\r
+\r
+ BlockFloatCompander::CompressedData compressedData;\r
+ compressedData.dataCompressed = &loc_dataCompressedDataOut[0];\r
+\r
+ std::memset(&loc_dataCompressedDataOut[0], 0, 288*BlockFloatCompander::k_numREReal);\r
+ std::memset(&loc_dataExpandedRes[0], 0, 288*BlockFloatCompander::k_numREReal);\r
+\r
+ std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));\r
+ std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));\r
+ std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));\r
+ std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));\r
+\r
+ bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;\r
+ bfp_com_req.numRBs = numRBs[tc];\r
+ bfp_com_req.len = numRBs[tc]*12*2*2;\r
+ bfp_com_req.compMethod = compMethod;\r
+ bfp_com_req.iqWidth = iqWidth[iq_w_id];\r
+\r
+ bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);\r
+ bfp_com_rsp.len = 0;\r
+\r
+ xranlib_compress_avx512(&bfp_com_req, &bfp_com_rsp);\r
+\r
+ bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);\r
+ bfp_decom_req.numRBs = numRBs[tc];\r
+ bfp_decom_req.len = bfp_com_rsp.len;\r
+ bfp_decom_req.compMethod = compMethod;\r
+ bfp_decom_req.iqWidth = iqWidth[iq_w_id];\r
+\r
+ bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;\r
+ bfp_decom_rsp.len = 0;\r
+\r
+ xranlib_decompress_avx512(&bfp_decom_req, &bfp_decom_rsp);\r
+\r
+ resSum += checkDataApprox(expandedData.dataExpanded, expandedDataRes.dataExpanded, numRBs[tc]*BlockFloatCompander::k_numREReal);\r
+\r
+ ASSERT_EQ(numRBs[tc]*12*2*2, bfp_decom_rsp.len);\r
+ ASSERT_EQ(0, resSum);\r
+ }\r
+ }\r
+}\r
+\r
+TEST_P(BfpPerfEx, AVX512_Comp)\r
+{\r
+ performance("AVX512", module_name, xranlib_compress_avx512, &bfp_com_req, &bfp_com_rsp);\r
+}\r
+\r
+TEST_P(BfpPerfEx, AVX512_DeComp)\r
+{\r
+ performance("AVX512", module_name, xranlib_decompress_avx512, &bfp_decom_req, &bfp_decom_rsp);\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(UnitTest, BfpCheck,\r
+ testing::ValuesIn(get_sequence(BfpCheck::get_number_of_cases("bfp_functional"))));\r
+\r
+INSTANTIATE_TEST_CASE_P(UnitTest, BfpPerf,\r
+ testing::ValuesIn(get_sequence(BfpPerf::get_number_of_cases("bfp_performace"))));\r
+\r
+\r
+INSTANTIATE_TEST_CASE_P(UnitTest, BfpPerfEx,\r
+ testing::ValuesIn(get_sequence(BfpPerf::get_number_of_cases("bfp_performace_ex"))));\r
+\r
+\r
Code Review / o-du / phy.git / blobdiff