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