1 /******************************************************************************
3 * Copyright (c) 2020 Intel.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 *******************************************************************************/
20 * @brief xRAN BFP compression/decompression U-plane implementation and interface functions
22 * @file xran_compression.cpp
23 * @ingroup group_source_xran
24 * @author Intel Corporation
26 #include "xran_compression.hpp"
27 #include "xran_compression.h"
30 #include <immintrin.h>
34 using namespace BlockFloatCompander;
36 /** callback function type for Symbol packet */
37 typedef void (*xran_bfp_compress_fn)(const BlockFloatCompander::ExpandedData& dataIn,
38 BlockFloatCompander::CompressedData* dataOut);
40 /** callback function type for Symbol packet */
41 typedef void (*xran_bfp_decompress_fn)(const BlockFloatCompander::CompressedData& dataIn, BlockFloatCompander::ExpandedData* dataOut);
44 xranlib_compress_avxsnc(const struct xranlib_compress_request *request,
45 struct xranlib_compress_response *response)
47 BlockFloatCompander::ExpandedData expandedDataInput;
48 BlockFloatCompander::CompressedData compressedDataOut;
49 xran_bfp_compress_fn com_fn = NULL;
50 uint16_t totalRBs = request->numRBs;
51 uint16_t remRBs = totalRBs;
53 int16_t block_idx_bytes = 0;
55 switch (request->iqWidth) {
60 com_fn = BlockFloatCompander::BFPCompressUserPlaneAvxSnc;
63 com_fn = BlockFloatCompander::BFPCompressRef;
67 expandedDataInput.iqWidth = request->iqWidth;
68 expandedDataInput.numDataElements = 24;
71 expandedDataInput.dataExpanded = &request->data_in[block_idx_bytes];
72 compressedDataOut.dataCompressed = (uint8_t*)&response->data_out[len];
74 expandedDataInput.numBlocks = 16;
75 com_fn(expandedDataInput, &compressedDataOut);
76 len += ((3 * expandedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)16);
77 block_idx_bytes += 16*expandedDataInput.numDataElements;
79 }else if(remRBs >= 4){
80 expandedDataInput.numBlocks = 4;
81 com_fn(expandedDataInput, &compressedDataOut);
82 len += ((3 * expandedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)4);
83 block_idx_bytes +=4*expandedDataInput.numDataElements;
85 }else if (remRBs >= 1){
86 expandedDataInput.numBlocks = 1;
87 com_fn(expandedDataInput, &compressedDataOut);
88 len += ((3 * expandedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)1);
89 block_idx_bytes +=1*expandedDataInput.numDataElements;
94 response->len = ((3 * expandedDataInput.iqWidth) + 1) * totalRBs;
100 xranlib_decompress_avxsnc(const struct xranlib_decompress_request *request,
101 struct xranlib_decompress_response *response)
103 BlockFloatCompander::CompressedData compressedDataInput;
104 BlockFloatCompander::ExpandedData expandedDataOut;
106 xran_bfp_decompress_fn decom_fn = NULL;
107 uint16_t totalRBs = request->numRBs;
108 uint16_t remRBs = totalRBs;
110 int16_t block_idx_bytes = 0;
112 switch (request->iqWidth) {
117 decom_fn = BlockFloatCompander::BFPExpandUserPlaneAvxSnc;
120 decom_fn = BlockFloatCompander::BFPExpandRef;
124 compressedDataInput.iqWidth = request->iqWidth;
125 compressedDataInput.numDataElements = 24;
128 compressedDataInput.dataCompressed = (uint8_t*)&request->data_in[block_idx_bytes];
129 expandedDataOut.dataExpanded = &response->data_out[len];
131 compressedDataInput.numBlocks = 16;
132 decom_fn(compressedDataInput, &expandedDataOut);
133 len += 16*compressedDataInput.numDataElements;
134 block_idx_bytes += ((3 * compressedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)16);
136 }else if(remRBs >= 4){
137 compressedDataInput.numBlocks = 4;
138 decom_fn(compressedDataInput, &expandedDataOut);
139 len += 4*compressedDataInput.numDataElements;
140 block_idx_bytes += ((3 * compressedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)4);
142 }else if (remRBs >= 1){
143 compressedDataInput.numBlocks = 1;
144 decom_fn(compressedDataInput, &expandedDataOut);
145 len += 1*compressedDataInput.numDataElements;
146 block_idx_bytes += ((3 * compressedDataInput.iqWidth) + 1) * std::min((int16_t)BlockFloatCompander::k_maxNumBlocks,(int16_t)1);
151 response->len = totalRBs * compressedDataInput.numDataElements * sizeof(int16_t);
157 xranlib_compress_avxsnc_bfw(const struct xranlib_compress_request *request,
158 struct xranlib_compress_response *response)
160 BlockFloatCompander::ExpandedData expandedDataInput;
161 BlockFloatCompander::CompressedData compressedDataOut;
162 xran_bfp_compress_fn com_fn = NULL;
164 if (request->numRBs != 1){
165 printf("Unsupported numRBs %d\n", request->numRBs);
169 switch (request->iqWidth) {
174 switch (request->numDataElements) {
176 com_fn = BlockFloatCompander::BFPCompressCtrlPlane8AvxSnc;
179 com_fn = BlockFloatCompander::BFPCompressCtrlPlane16AvxSnc;
182 com_fn = BlockFloatCompander::BFPCompressCtrlPlane32AvxSnc;
185 com_fn = BlockFloatCompander::BFPCompressCtrlPlane64AvxSnc;
189 printf("Unsupported numDataElements %d\n", request->numDataElements);
195 printf("Unsupported iqWidth %d\n", request->iqWidth);
200 expandedDataInput.iqWidth = request->iqWidth;
201 expandedDataInput.numDataElements = request->numDataElements;
202 expandedDataInput.numBlocks = 1;
203 expandedDataInput.dataExpanded = &request->data_in[0];
204 compressedDataOut.dataCompressed = (uint8_t*)&response->data_out[0];
206 com_fn(expandedDataInput, &compressedDataOut);
208 response->len = (((expandedDataInput.numDataElements * expandedDataInput.iqWidth) >> 3) + 1)
215 xranlib_decompress_avxsnc_bfw(const struct xranlib_decompress_request *request,
216 struct xranlib_decompress_response *response)
218 BlockFloatCompander::CompressedData compressedDataInput;
219 BlockFloatCompander::ExpandedData expandedDataOut;
220 xran_bfp_decompress_fn decom_fn = NULL;
222 if (request->numRBs != 1){
223 printf("Unsupported numRBs %d\n", request->numRBs);
227 switch (request->iqWidth) {
232 switch (request->numDataElements) {
234 decom_fn = BlockFloatCompander::BFPExpandCtrlPlane8AvxSnc;
237 decom_fn = BlockFloatCompander::BFPExpandCtrlPlane16AvxSnc;
240 decom_fn = BlockFloatCompander::BFPExpandCtrlPlane32AvxSnc;
243 decom_fn = BlockFloatCompander::BFPExpandCtrlPlane64AvxSnc;
247 printf("Unsupported numDataElements %d\n", request->numDataElements);
253 printf("Unsupported iqWidth %d\n", request->iqWidth);
258 compressedDataInput.iqWidth = request->iqWidth;
259 compressedDataInput.numDataElements = request->numDataElements;
260 compressedDataInput.numBlocks = 1;
261 compressedDataInput.dataCompressed = (uint8_t*)&request->data_in[0];
262 expandedDataOut.dataExpanded = &response->data_out[0];
264 decom_fn(compressedDataInput, &expandedDataOut);
266 response->len = request->numRBs * compressedDataInput.numDataElements * sizeof(int16_t);