X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=fhi_lib%2Ftest%2Ftest_xran%2Fcompander_functional.cc;fp=fhi_lib%2Ftest%2Ftest_xran%2Fcompander_functional.cc;h=d289f188aaf6c589efce73671a28ccc0b5dcf2af;hb=0134817ddd14e0a57f3476fdc5eaa5e7cb75c692;hp=0000000000000000000000000000000000000000;hpb=78b7d242c085573175a20949d3208a63b44fc515;p=o-du%2Fphy.git

diff --git a/fhi_lib/test/test_xran/compander_functional.cc b/fhi_lib/test/test_xran/compander_functional.cc
new file mode 100644
index 0000000..d289f18
--- /dev/null
+++ b/fhi_lib/test/test_xran/compander_functional.cc
@@ -0,0 +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 <stdint.h>
+#include <random>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <cstring>
+
+const std::string module_name = "bfp";
+
+template <typename T>
+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<int16_t>("iqWidth");
+        int16_t numRBs = get_input_parameter<int16_t>("nRBsize");
+        // Create random number generator
+        std::random_device rd;
+        std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
+        std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);
+        std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+  std::uniform_int_distribution<int> 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<int16_t> randInt16(-32768, 32767);
+    std::uniform_int_distribution<int> 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"))));
+
+