--- /dev/null
+/******************************************************************************
+*
+* Copyright (c) 2020 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.
+*
+*******************************************************************************/
+
+/**
+ * @brief xRAN BFP compression/decompression U-plane implementation and interface functions
+ *
+ * @file xran_compression.cpp
+ * @ingroup group_source_xran
+ * @author Intel Corporation
+ **/
+#include "xran_compression.hpp"
+#include "xran_compression.h"
+#include <complex>
+#include <algorithm>
+#include <immintrin.h>
+#include <limits.h>
+#include <cstring>
+
+using namespace BlockFloatCompander;
+
+/** callback function type for Symbol packet */
+typedef void (*xran_bfp_compress_fn)(const BlockFloatCompander::ExpandedData& dataIn,
+ BlockFloatCompander::CompressedData* dataOut);
+
+/** callback function type for Symbol packet */
+typedef void (*xran_bfp_decompress_fn)(const BlockFloatCompander::CompressedData& dataIn, BlockFloatCompander::ExpandedData* dataOut);
+
+int32_t
+xranlib_compress_avxsnc(const struct xranlib_compress_request *request,
+ struct xranlib_compress_response *response)
+{
+ BlockFloatCompander::ExpandedData expandedDataInput;
+ BlockFloatCompander::CompressedData compressedDataOut;
+ xran_bfp_compress_fn com_fn = NULL;
+ uint16_t totalRBs = request->numRBs;
+ uint16_t remRBs = totalRBs;
+ int16_t len = 0;
+ int16_t block_idx_bytes = 0;
+
+ switch (request->iqWidth) {
+ case 8:
+ case 9:
+ case 10:
+ case 12:
+ com_fn = BlockFloatCompander::BFPCompressUserPlaneAvxSnc;
+ break;
+ default:
+ com_fn = BlockFloatCompander::BFPCompressRef;
+ break;
+ }
+
+ expandedDataInput.iqWidth = request->iqWidth;
+ expandedDataInput.numDataElements = 24;
+
+ while (remRBs){
+ expandedDataInput.dataExpanded = &request->data_in[block_idx_bytes];
+ compressedDataOut.dataCompressed = (uint8_t*)&response->data_out[len];
+ if(remRBs >= 16){
+ expandedDataInput.numBlocks = 16;
+ com_fn(expandedDataInput, &compressedDataOut);
+ len += ((3 * expandedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)16);
+ block_idx_bytes += 16*expandedDataInput.numDataElements;
+ remRBs -= 16;
+ }else if(remRBs >= 4){
+ expandedDataInput.numBlocks = 4;
+ com_fn(expandedDataInput, &compressedDataOut);
+ len += ((3 * expandedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)4);
+ block_idx_bytes +=4*expandedDataInput.numDataElements;
+ remRBs -=4;
+ }else if (remRBs >= 1){
+ expandedDataInput.numBlocks = 1;
+ com_fn(expandedDataInput, &compressedDataOut);
+ len += ((3 * expandedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)1);
+ block_idx_bytes +=1*expandedDataInput.numDataElements;
+ remRBs = remRBs - 1;
+ }
+ }
+
+ response->len = ((3 * expandedDataInput.iqWidth) + 1) * totalRBs;
+
+ return 0;
+}
+
+int32_t
+xranlib_decompress_avxsnc(const struct xranlib_decompress_request *request,
+ struct xranlib_decompress_response *response)
+{
+ BlockFloatCompander::CompressedData compressedDataInput;
+ BlockFloatCompander::ExpandedData expandedDataOut;
+
+ xran_bfp_decompress_fn decom_fn = NULL;
+ uint16_t totalRBs = request->numRBs;
+ uint16_t remRBs = totalRBs;
+ int16_t len = 0;
+ int16_t block_idx_bytes = 0;
+
+ switch (request->iqWidth) {
+ case 8:
+ case 9:
+ case 10:
+ case 12:
+ decom_fn = BlockFloatCompander::BFPExpandUserPlaneAvxSnc;
+ break;
+ default:
+ decom_fn = BlockFloatCompander::BFPExpandRef;
+ break;
+ }
+
+ compressedDataInput.iqWidth = request->iqWidth;
+ compressedDataInput.numDataElements = 24;
+
+ while(remRBs) {
+ compressedDataInput.dataCompressed = (uint8_t*)&request->data_in[block_idx_bytes];
+ expandedDataOut.dataExpanded = &response->data_out[len];
+ if(remRBs >= 16){
+ compressedDataInput.numBlocks = 16;
+ decom_fn(compressedDataInput, &expandedDataOut);
+ len += 16*compressedDataInput.numDataElements;
+ block_idx_bytes += ((3 * compressedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)16);
+ remRBs -= 16;
+ }else if(remRBs >= 4){
+ compressedDataInput.numBlocks = 4;
+ decom_fn(compressedDataInput, &expandedDataOut);
+ len += 4*compressedDataInput.numDataElements;
+ block_idx_bytes += ((3 * compressedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)4);
+ remRBs -=4;
+ }else if (remRBs >= 1){
+ compressedDataInput.numBlocks = 1;
+ decom_fn(compressedDataInput, &expandedDataOut);
+ len += 1*compressedDataInput.numDataElements;
+ block_idx_bytes += ((3 * compressedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)1);
+ remRBs = remRBs - 1;
+ }
+ }
+
+ response->len = totalRBs * compressedDataInput.numDataElements * sizeof(int16_t);
+
+ return 0;
+}
+
+int32_t
+xranlib_compress_avxsnc_bfw(const struct xranlib_compress_request *request,
+ struct xranlib_compress_response *response)
+{
+ BlockFloatCompander::ExpandedData expandedDataInput;
+ BlockFloatCompander::CompressedData compressedDataOut;
+ xran_bfp_compress_fn com_fn = NULL;
+
+ if (request->numRBs != 1){
+ printf("Unsupported numRBs %d\n", request->numRBs);
+ return -1;
+ }
+
+ switch (request->iqWidth) {
+ case 8:
+ case 9:
+ case 10:
+ case 12:
+ switch (request->numDataElements) {
+ case 16:
+ com_fn = BlockFloatCompander::BFPCompressCtrlPlane8AvxSnc;
+ break;
+ case 32:
+ com_fn = BlockFloatCompander::BFPCompressCtrlPlane16AvxSnc;
+ break;
+ case 64:
+ com_fn = BlockFloatCompander::BFPCompressCtrlPlane32AvxSnc;
+ break;
+ case 128:
+ com_fn = BlockFloatCompander::BFPCompressCtrlPlane64AvxSnc;
+ break;
+ case 24:
+ default:
+ printf("Unsupported numDataElements %d\n", request->numDataElements);
+ return -1;
+ break;
+ }
+ break;
+ default:
+ printf("Unsupported iqWidth %d\n", request->iqWidth);
+ return -1;
+ break;
+ }
+
+ expandedDataInput.iqWidth = request->iqWidth;
+ expandedDataInput.numDataElements = request->numDataElements;
+ expandedDataInput.numBlocks = 1;
+ expandedDataInput.dataExpanded = &request->data_in[0];
+ compressedDataOut.dataCompressed = (uint8_t*)&response->data_out[0];
+
+ com_fn(expandedDataInput, &compressedDataOut);
+
+ response->len = (((expandedDataInput.numDataElements * expandedDataInput.iqWidth) >> 3) + 1)
+ * request->numRBs;
+
+ return 0;
+}
+
+int32_t
+xranlib_decompress_avxsnc_bfw(const struct xranlib_decompress_request *request,
+ struct xranlib_decompress_response *response)
+{
+ BlockFloatCompander::CompressedData compressedDataInput;
+ BlockFloatCompander::ExpandedData expandedDataOut;
+ xran_bfp_decompress_fn decom_fn = NULL;
+
+ if (request->numRBs != 1){
+ printf("Unsupported numRBs %d\n", request->numRBs);
+ return -1;
+ }
+
+ switch (request->iqWidth) {
+ case 8:
+ case 9:
+ case 10:
+ case 12:
+ switch (request->numDataElements) {
+ case 16:
+ decom_fn = BlockFloatCompander::BFPExpandCtrlPlane8AvxSnc;
+ break;
+ case 32:
+ decom_fn = BlockFloatCompander::BFPExpandCtrlPlane16AvxSnc;
+ break;
+ case 64:
+ decom_fn = BlockFloatCompander::BFPExpandCtrlPlane32AvxSnc;
+ break;
+ case 128:
+ decom_fn = BlockFloatCompander::BFPExpandCtrlPlane64AvxSnc;
+ break;
+ case 24:
+ default:
+ printf("Unsupported numDataElements %d\n", request->numDataElements);
+ return -1;
+ break;
+ }
+ break;
+ default:
+ printf("Unsupported iqWidth %d\n", request->iqWidth);
+ return -1;
+ break;
+ }
+
+ compressedDataInput.iqWidth = request->iqWidth;
+ compressedDataInput.numDataElements = request->numDataElements;
+ compressedDataInput.numBlocks = 1;
+ compressedDataInput.dataCompressed = (uint8_t*)&request->data_in[0];
+ expandedDataOut.dataExpanded = &response->data_out[0];
+
+ decom_fn(compressedDataInput, &expandedDataOut);
+
+ response->len = request->numRBs * compressedDataInput.numDataElements * sizeof(int16_t);
+
+ return 0;
+}
+
Code Review / o-du / phy.git / blobdiff