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 #include "xran_fh_o_du.h"
21 #include "xran_compression.h"
22 #include "xran_compression.hpp"
31 const std::string module_name = "bfp";
33 extern int _may_i_use_cpu_feature(unsigned __int64);
36 int checkData(T* inVec1, T* inVec2, int numVals)
39 for (int n = 0; n < numVals; ++n)
41 checkSum += std::abs(inVec1[n] - inVec2[n]);
45 //std::cout << "Test Passed\n";
50 //std::cout << "Test Failed\n";
54 template int checkData(int8_t*, int8_t*, int);
55 template int checkData(int16_t*, int16_t*, int);
57 int checkDataApprox(int16_t *inVec1, int16_t *inVec2, int numVals)
60 for (int n = 0; n < numVals; ++n)
62 if (std::abs(inVec1[n] & 0xFF00) - std::abs(inVec2[n] & 0xFF00)){;
63 printf("[%d]: %d %d\n",n, inVec1[n] & 0xFF00, inVec2[n] & 0xFF00);
69 //std::cout << "Test Passed\n";
74 //std::cout << "Test Failed\n";
80 class BfpCheck : public KernelTests
83 void SetUp() override {
84 init_test("bfp_functional");
87 /* It's called after an execution of the each test case.*/
88 void TearDown() override {
92 CACHE_ALIGNED int16_t loc_dataExpandedIn[288*128];
93 CACHE_ALIGNED int16_t loc_dataExpandedRes[288*128];
94 CACHE_ALIGNED uint8_t loc_dataCompressedDataOut[2*288*128];
96 class BfpPerfEx : public KernelTests
99 struct xranlib_decompress_request bfp_decom_req;
100 struct xranlib_decompress_response bfp_decom_rsp;
101 struct xranlib_compress_request bfp_com_req;
102 struct xranlib_compress_response bfp_com_rsp;
104 void SetUp() override {
105 init_test("bfp_performace_ex");
108 int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
109 int16_t iqWidth = get_input_parameter<int16_t>("iqWidth");
110 int16_t numRBs = get_input_parameter<int16_t>("nRBsize");
111 // Create random number generator
112 std::random_device rd;
113 std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
114 std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);
115 std::uniform_int_distribution<int> randExpShift(0, 4);
117 BlockFloatCompander::ExpandedData expandedData;
118 expandedData.dataExpanded = &loc_dataExpandedIn[0];
119 BlockFloatCompander::ExpandedData expandedDataRes;
120 expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];
122 //printf("iqWidth %d numRBs %d\n", iqWidth, numRBs);
124 for (int m = 0; m < 18*BlockFloatCompander::k_maxNumBlocks; ++m) {
125 auto shiftVal = randExpShift(gen);
126 for (int n = 0; n < 24; ++n) {
127 expandedData.dataExpanded[m*24+n] = int16_t(randInt16(gen) >> shiftVal);
131 BlockFloatCompander::CompressedData compressedData;
132 compressedData.dataCompressed = &loc_dataCompressedDataOut[0];
134 std::memset(&loc_dataCompressedDataOut[0], 0, 288*24);
135 std::memset(&loc_dataExpandedRes[0], 0, 288*24);
137 std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));
138 std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
139 std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
140 std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
142 bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;
143 bfp_com_req.numRBs = numRBs;
144 bfp_com_req.len = numRBs*12*2*2;
145 bfp_com_req.compMethod = compMethod;
146 bfp_com_req.iqWidth = iqWidth;
148 bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);
151 bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);
152 bfp_decom_req.numRBs = numRBs;
153 bfp_decom_req.len = ((3 * iqWidth) + 1) * numRBs;
154 bfp_decom_req.compMethod = compMethod;
155 bfp_decom_req.iqWidth = iqWidth;
157 bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;
158 bfp_decom_rsp.len = 0;
161 /* It's called after an execution of the each test case.*/
162 void TearDown() override {
168 class BfpPerfCp : public KernelTests
171 struct xranlib_decompress_request bfp_decom_req;
172 struct xranlib_decompress_response bfp_decom_rsp;
173 struct xranlib_compress_request bfp_com_req;
174 struct xranlib_compress_response bfp_com_rsp;
176 void SetUp() override {
177 init_test("bfp_performace_cp");
180 int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
181 int16_t iqWidth = get_input_parameter<int16_t>("iqWidth");
182 int16_t AntElm = get_input_parameter<int16_t>("AntElm");
183 int16_t numDataElements = 0;
185 // Create random number generator
186 std::random_device rd;
187 std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
188 std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);
189 std::uniform_int_distribution<int> randExpShift(0, 4);
191 BlockFloatCompander::ExpandedData expandedData;
192 expandedData.dataExpanded = &loc_dataExpandedIn[0];
193 BlockFloatCompander::ExpandedData expandedDataRes;
194 expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];
196 //printf("iqWidth %d numRBs %d\n", iqWidth, numRBs);
197 numDataElements = 2*AntElm;
199 // Generate input data
200 for (int m = 0; m < numRBs; ++m)
202 auto shiftVal = randExpShift(gen);
203 for (int n = 0; n < numDataElements; ++n)
205 expandedData.dataExpanded[m * numDataElements + n] = int16_t(randInt16(gen) >> shiftVal);
209 BlockFloatCompander::CompressedData compressedData;
210 compressedData.dataCompressed = &loc_dataCompressedDataOut[0];
212 std::memset(&loc_dataCompressedDataOut[0], 0, 288*128);
213 std::memset(&loc_dataExpandedRes[0], 0, 288*128);
215 std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));
216 std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
217 std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
218 std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
220 bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;
221 bfp_com_req.numRBs = numRBs;
222 bfp_com_req.numDataElements = numDataElements;
223 bfp_com_req.len = AntElm*4;
224 bfp_com_req.compMethod = compMethod;
225 bfp_com_req.iqWidth = iqWidth;
227 bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);
230 bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);
231 bfp_decom_req.numRBs = numRBs;
232 bfp_decom_req.numDataElements = numDataElements;
233 bfp_decom_req.len = (((numDataElements * iqWidth) >> 3) + 1) * numRBs;
234 bfp_decom_req.compMethod = compMethod;
235 bfp_decom_req.iqWidth = iqWidth;
237 bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;
238 bfp_decom_rsp.len = 0;
241 /* It's called after an execution of the each test case.*/
242 void TearDown() override {
254 template <typename T>
255 void compareData(T* inVecRef, T* inVecTest, ErrorData& err, int numVals)
257 for (int n = 0; n < numVals; ++n)
259 auto valDiff = std::abs(inVecRef[n] - inVecTest[n]);
260 err.checkSum += valDiff;
261 if (inVecRef[n] != 0)
263 err.errorAccum += (float)valDiff / std::abs((float)inVecRef[n]);
268 template void compareData(int8_t*, int8_t*, ErrorData&, int);
269 template void compareData(int16_t*, int16_t*, ErrorData&, int);
271 int checkPass(ErrorData& err, int testType)
275 if (err.checkSum == 0)
277 /*std::cout << "PASS "; */
282 std::cout << "FAIL ";
288 //std::cout << err.errorAccum / err.errorCount;
289 if (err.errorAccum / err.errorCount < 0.1)
291 /*std::cout << " PASS ";*/
296 std::cout << " FAIL ";
301 template <typename KERN_TYPE, typename T1, typename T2>
302 void timeThis(KERN_TYPE kernel, T1& inData, T2* outData)
306 uint64_t thisDuration;
307 uint64_t meanTime = 0;
309 int numRuns = 1000000;
310 for (int cnt = 0; cnt < numRuns; ++cnt)
312 startTime = __rdtsc();
313 kernel(inData, outData);
314 kernel(inData, outData);
315 kernel(inData, outData);
316 kernel(inData, outData);
317 kernel(inData, outData);
318 kernel(inData, outData);
319 kernel(inData, outData);
320 kernel(inData, outData);
321 kernel(inData, outData);
322 kernel(inData, outData);
323 finishTime = __rdtsc();
324 thisDuration = (finishTime - startTime);
325 meanTime += thisDuration;
328 minTime = thisDuration;
330 else if (thisDuration < minTime)
332 minTime = thisDuration;
335 meanTime = meanTime / numRuns;
336 //std::cout << "10 Executions: Mean Time = " << meanTime << ", Min Time = " << minTime << "\n";
337 printf("10 Executions: Mean Time = %5ld Min Time = %5ld\n", meanTime, minTime);
341 int runTest(const int runMode, const int iqWidth, const int numRB, const int numDataElements, const int totNumBlocks)
343 BlockFloatCompander::ExpandedData expandedDataInput;
344 BlockFloatCompander::CompressedData compressedDataRef;
345 BlockFloatCompander::CompressedData compressedDataKern;
346 BlockFloatCompander::ExpandedData expandedDataRef;
347 BlockFloatCompander::ExpandedData expandedDataKern;
349 ErrorData errRef = ErrorData();
350 ErrorData errComp = ErrorData();
351 ErrorData errExp = ErrorData();
353 // Create random number generator
354 std::random_device rd;
355 std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
356 std::uniform_int_distribution<int16_t> randInt16(-32767, 32767);
357 std::uniform_int_distribution<int> randExpShift(0, 4);
359 // expandedDataInput.dataExpanded = &expandedDataInput.dataExpandedIn[0];
360 // compressedDataRef.dataCompressed = &compressedDataRef.dataCompressedDataOut[0];
361 // compressedDataKern.dataCompressed = &compressedDataKern.dataCompressedDataOut[0];
362 // expandedDataRef.dataExpanded = &expandedDataRef.dataExpandedIn[0];
363 // expandedDataKern.dataExpanded = &expandedDataKern.dataExpandedIn[0];
365 expandedDataInput.iqWidth = iqWidth;
366 expandedDataInput.numBlocks = numRB;
367 expandedDataInput.numDataElements = numDataElements;
368 int totExpValsPerCall = numRB * numDataElements;
369 int totCompValsPerCall = (((numDataElements * iqWidth) >> 3) + 1) * numRB;
371 // Assign pointers to input/output data arrays
372 CACHE_ALIGNED int16_t DATAEXPANDED_IN[BlockFloatCompander::k_numSampsExpanded] = { 0 };
373 CACHE_ALIGNED uint8_t DATACOMPRESSED_REF[BlockFloatCompander::k_numSampsCompressed] = { 0 };
374 CACHE_ALIGNED uint8_t DATACOMPRESSED_KERN[BlockFloatCompander::k_numSampsCompressed] = { 0 };
375 CACHE_ALIGNED int16_t DATAEXPANDED_REF[BlockFloatCompander::k_numSampsExpanded] = { 0 };
376 CACHE_ALIGNED int16_t DATAEXPANDED_KERN[BlockFloatCompander::k_numSampsExpanded] = { 0 };
377 expandedDataInput.dataExpanded = DATAEXPANDED_IN;
378 compressedDataRef.dataCompressed = DATACOMPRESSED_REF;
379 expandedDataRef.dataExpanded = DATAEXPANDED_REF;
380 compressedDataKern.dataCompressed = DATACOMPRESSED_KERN;
381 expandedDataKern.dataExpanded = DATAEXPANDED_KERN;
383 //-------------------------------------------------------------------------
384 // KERNEL VERIFICATION LOOP
385 //-------------------------------------------------------------------------
386 for (int blk = 0; blk < totNumBlocks; ++blk)
388 // Generate input data
389 for (int m = 0; m < numRB; ++m)
391 auto shiftVal = randExpShift(gen);
392 for (int n = 0; n < numDataElements; ++n)
394 DATAEXPANDED_IN[m * numDataElements + n] = int16_t(randInt16(gen) >> shiftVal);
397 // Generate reference
398 BlockFloatCompander::BFPCompressRef(expandedDataInput, &compressedDataRef);
399 BlockFloatCompander::BFPExpandRef(compressedDataRef, &expandedDataRef);
400 // Generate kernel output
403 // Run Sunny Cove version
404 switch (numDataElements)
407 BlockFloatCompander::BFPCompressCtrlPlane8AvxSnc(expandedDataInput, &compressedDataKern);
408 BlockFloatCompander::BFPExpandCtrlPlane8AvxSnc(compressedDataRef, &expandedDataKern);
411 BlockFloatCompander::BFPCompressUserPlaneAvxSnc(expandedDataInput, &compressedDataKern);
412 BlockFloatCompander::BFPExpandUserPlaneAvxSnc(compressedDataRef, &expandedDataKern);
415 BlockFloatCompander::BFPCompressCtrlPlane16AvxSnc(expandedDataInput, &compressedDataKern);
416 BlockFloatCompander::BFPExpandCtrlPlane16AvxSnc(compressedDataRef, &expandedDataKern);
419 BlockFloatCompander::BFPCompressCtrlPlane32AvxSnc(expandedDataInput, &compressedDataKern);
420 BlockFloatCompander::BFPExpandCtrlPlane32AvxSnc(compressedDataRef, &expandedDataKern);
423 BlockFloatCompander::BFPCompressCtrlPlane64AvxSnc(expandedDataInput, &compressedDataKern);
424 BlockFloatCompander::BFPExpandCtrlPlane64AvxSnc(compressedDataRef, &expandedDataKern);
430 // Default Skylake/Palm Cove AVX512 version
431 switch (numDataElements)
434 BlockFloatCompander::BFPCompressCtrlPlane8Avx512(expandedDataInput, &compressedDataKern);
435 BlockFloatCompander::BFPExpandCtrlPlane8Avx512(compressedDataRef, &expandedDataKern);
438 if ((iqWidth == 9) && (numRB == 16))
440 BlockFloatCompander::BFPCompressUserPlaneAvx512_9b16RB(expandedDataInput, &compressedDataKern);
441 BlockFloatCompander::BFPExpandUserPlaneAvx512_9b16RB(compressedDataRef, &expandedDataKern);
445 BlockFloatCompander::BFPCompressUserPlaneAvx512(expandedDataInput, &compressedDataKern);
446 BlockFloatCompander::BFPExpandUserPlaneAvx512(compressedDataRef, &expandedDataKern);
450 BlockFloatCompander::BFPCompressCtrlPlane16Avx512(expandedDataInput, &compressedDataKern);
451 BlockFloatCompander::BFPExpandCtrlPlane16Avx512(compressedDataRef, &expandedDataKern);
454 BlockFloatCompander::BFPCompressCtrlPlane32Avx512(expandedDataInput, &compressedDataKern);
455 BlockFloatCompander::BFPExpandCtrlPlane32Avx512(compressedDataRef, &expandedDataKern);
458 BlockFloatCompander::BFPCompressCtrlPlane64Avx512(expandedDataInput, &compressedDataKern);
459 BlockFloatCompander::BFPExpandCtrlPlane64Avx512(compressedDataRef, &expandedDataKern);
464 compareData(expandedDataInput.dataExpanded, expandedDataRef.dataExpanded, errRef, totExpValsPerCall);
465 compareData(compressedDataRef.dataCompressed, compressedDataKern.dataCompressed, errComp, totCompValsPerCall);
466 compareData(expandedDataRef.dataExpanded, expandedDataKern.dataExpanded, errRef, totExpValsPerCall);
470 /*std::cout << "Valid Reference: ";*/
471 resSum += checkPass(errRef, 1);
473 /*std::cout << "Compression: ";*/
474 resSum += checkPass(errComp, 0);
475 /*std::cout << "Expansion: ";*/
476 resSum += checkPass(errExp, 0);
477 /*std::cout << "\n";*/
478 //-------------------------------------------------------------------------
479 // KERNEL TIMING LOOP
480 //-------------------------------------------------------------------------
481 // Generate input data
483 for (int m = 0; m < numRB; ++m)
485 auto shiftVal = randExpShift(gen);
486 for (int n = 0; n < numDataElements; ++n)
488 DATAEXPANDED_IN[m * numDataElements + n] = int16_t(randInt16(gen) >> shiftVal);
491 // Generate reference
492 BlockFloatCompander::BFPCompressRef(expandedDataInput, &compressedDataRef);
496 // Run Sunny Cove version
497 switch (numDataElements)
500 //std::cout << "Timing Control Plane 8 Antennas (SNC)...\n";
501 //std::cout << "Compression: ";
502 printf("BFPCompressCtrlPlane8AvxSnc iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
503 timeThis(BlockFloatCompander::BFPCompressCtrlPlane8AvxSnc, expandedDataInput, &compressedDataKern);
504 //std::cout << "Expansion : ";
505 printf("BFPExpandCtrlPlane8AvxSnc iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
506 timeThis(BlockFloatCompander::BFPExpandCtrlPlane8AvxSnc, compressedDataRef, &expandedDataKern);
509 //std::cout << "Timing User Plane (SNC)...\n";
510 //std::cout << "Compression: ";
511 printf("BFPCompressUserPlaneAvxSnc iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
512 timeThis(BlockFloatCompander::BFPCompressUserPlaneAvxSnc, expandedDataInput, &compressedDataKern);
513 //std::cout << "Expansion : ";
514 printf("BFPExpandUserPlaneAvxSnc iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
515 timeThis(BlockFloatCompander::BFPExpandUserPlaneAvxSnc, compressedDataRef, &expandedDataKern);
518 //std::cout << "Timing Control Plane 16 Antennas (SNC)...\n";
519 //std::cout << "Compression: ";
520 printf("BFPCompressCtrlPlane16AvxSnc iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
521 timeThis(BlockFloatCompander::BFPCompressCtrlPlane16AvxSnc, expandedDataInput, &compressedDataKern);
522 //std::cout << "Expansion : ";
523 printf("BFPExpandCtrlPlane16AvxSnc iqWidth %2d numRB %2d numDataElements %3d ", iqWidth, numRB, numDataElements);
524 timeThis(BlockFloatCompander::BFPExpandCtrlPlane16AvxSnc, compressedDataRef, &expandedDataKern);
527 //std::cout << "Timing Control Plane 32 Antennas (SNC)...\n";
528 //std::cout << "Compression: ";
529 printf("BFPCompressCtrlPlane32AvxSnc iqWidth %2d numRB %2d numDataElements %3d ", iqWidth, numRB, numDataElements);
530 timeThis(BlockFloatCompander::BFPCompressCtrlPlane32AvxSnc, expandedDataInput, &compressedDataKern);
531 //std::cout << "Expansion : ";
532 printf("BFPExpandCtrlPlane32AvxSnc iqWidth %2d numRB %2d numDataElements %3d ", iqWidth, numRB, numDataElements);
533 timeThis(BlockFloatCompander::BFPExpandCtrlPlane32AvxSnc, compressedDataRef, &expandedDataKern);
536 //std::cout << "Timing Control Plane 64 Antennas (SNC)...\n";
537 //std::cout << "Compression: ";
538 printf("BFPCompressCtrlPlane64AvxSnc iqWidth %2d numRB %2d numDataElements %3d ", iqWidth, numRB, numDataElements);
539 timeThis(BlockFloatCompander::BFPCompressCtrlPlane64AvxSnc, expandedDataInput, &compressedDataKern);
540 //std::cout << "Expansion : ";
541 printf("BFPExpandCtrlPlane64AvxSnc iqWidth %2d numRB %2d numDataElements %3d ", iqWidth, numRB, numDataElements);
542 timeThis(BlockFloatCompander::BFPExpandCtrlPlane64AvxSnc, compressedDataRef, &expandedDataKern);
548 // Default Skylake/Palm Cove AVX512 version
549 switch (numDataElements)
552 //std::cout << "Timing Control Plane 8 Antennas (AVX512)...\n";
553 //std::cout << "Compression: ";
554 printf("BFPCompressCtrlPlane8Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
555 timeThis(BlockFloatCompander::BFPCompressCtrlPlane8Avx512, expandedDataInput, &compressedDataKern);
556 //std::cout << "Expansion : ";
557 printf("BFPExpandCtrlPlane8Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
558 timeThis(BlockFloatCompander::BFPExpandCtrlPlane8Avx512, compressedDataRef, &expandedDataKern);
561 if ((iqWidth == 9) && (numRB == 16))
563 //std::cout << "Timing User Plane (AVX512)...\n";
564 //std::cout << "Compression: ";
565 printf("BFPCompressUserPlaneAvx512_9b16RB iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
566 timeThis(BlockFloatCompander::BFPCompressUserPlaneAvx512_9b16RB, expandedDataInput, &compressedDataKern);
567 //std::cout << "Expansion : ";
568 printf("BFPExpandUserPlaneAvx512_9b16RB iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
569 timeThis(BlockFloatCompander::BFPExpandUserPlaneAvx512_9b16RB, compressedDataRef, &expandedDataKern);
573 //std::cout << "Timing User Plane (AVX512)...\n";
574 //std::cout << "Compression: ";
575 printf("BFPCompressUserPlaneAvx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
576 timeThis(BlockFloatCompander::BFPCompressUserPlaneAvx512, expandedDataInput, &compressedDataKern);
577 //std::cout << "Expansion : ";
578 printf("BFPExpandUserPlaneAvx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
579 timeThis(BlockFloatCompander::BFPExpandUserPlaneAvx512, compressedDataRef, &expandedDataKern);
583 //std::cout << "Timing Control Plane 16 Antennas (AVX512)...\n";
584 //std::cout << "Compression: ";
585 printf("BFPCompressCtrlPlane16Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
586 timeThis(BlockFloatCompander::BFPCompressCtrlPlane16Avx512, expandedDataInput, &compressedDataKern);
587 //std::cout << "Expansion : ";
588 printf("BFPExpandCtrlPlane16Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
589 timeThis(BlockFloatCompander::BFPExpandCtrlPlane16Avx512, compressedDataRef, &expandedDataKern);
592 //std::cout << "Timing Control Plane 32 Antennas (AVX512)...\n";
593 //std::cout << "Compression: ";
594 printf("BFPCompressCtrlPlane32Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
595 timeThis(BlockFloatCompander::BFPCompressCtrlPlane32Avx512, expandedDataInput, &compressedDataKern);
596 //std::cout << "Expansion : ";
597 printf("BFPExpandCtrlPlane32Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
598 timeThis(BlockFloatCompander::BFPExpandCtrlPlane32Avx512, compressedDataRef, &expandedDataKern);
601 //std::cout << "Timing Control Plane 64 Antennas (AVX512)...\n";
602 //std::cout << "Compression: ";
603 printf("BFPCompressCtrlPlane64Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
604 timeThis(BlockFloatCompander::BFPCompressCtrlPlane64Avx512, expandedDataInput, &compressedDataKern);
605 //std::cout << "Expansion : ";
606 printf("BFPExpandCtrlPlane64Avx512 iqWidth %2d numRB %2d numDataElements %3d ",iqWidth, numRB, numDataElements);
607 timeThis(BlockFloatCompander::BFPExpandCtrlPlane64Avx512, compressedDataRef, &expandedDataKern);
615 TEST_P(BfpCheck, AVX512_bfp_main)
618 int iqWidth[4] = { 8, 9, 10, 12 };
619 int numRB[3] = { 1, 4, 16 };
620 int numDataElementsUPlane = 24;
621 int numDataElementsCPlane8 = 16;
622 int numDataElementsCPlane16 = 32;
623 int numDataElementsCPlane32 = 64;
624 int numDataElementsCPlane64 = 128;
625 int totNumBlocks = 100;
627 ASSERT_EQ(0, bind_to_cpu(BenchmarkParameters::cpu_id)) << "Failed to bind to cpu!";
629 for (int iqw = 0; iqw < 4; ++iqw)
631 for (int nrb = 0; nrb < 3; ++nrb)
636 //std::cout << "U-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsUPlane << ": ";
637 resSum += runTest(0, iqWidth[iqw], numRB[nrb], numDataElementsUPlane, totNumBlocks);
639 // CONTROL PLANE TESTS : 8 Antennas
640 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane8 << ": ";
641 resSum += runTest(0, iqWidth[iqw], numRB[nrb], numDataElementsCPlane8, totNumBlocks);
643 // CONTROL PLANE TESTS : 16 Antennas
644 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane16 << ": ";
645 resSum += runTest(0, iqWidth[iqw], numRB[nrb], numDataElementsCPlane16, totNumBlocks);
647 // CONTROL PLANE TESTS : 32 Antennas
648 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane32 << ": ";
649 resSum += runTest(0, iqWidth[iqw], numRB[nrb], numDataElementsCPlane32, totNumBlocks);
651 // CONTROL PLANE TESTS : 64 Antennas
652 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane64 << ": ";
653 resSum += runTest(0, iqWidth[iqw], numRB[nrb], numDataElementsCPlane64, totNumBlocks);
657 ASSERT_EQ(0, resSum);
660 TEST_P(BfpCheck, AVXSNC_bfp_main)
663 int iqWidth[4] = { 8, 9, 10, 12 };
664 int numRB[3] = { 1, 4, 16 };
665 int numDataElementsUPlane = 24;
666 int numDataElementsCPlane8 = 16;
667 int numDataElementsCPlane16 = 32;
668 int numDataElementsCPlane32 = 64;
669 int numDataElementsCPlane64 = 128;
670 int totNumBlocks = 100;
672 ASSERT_EQ(0, bind_to_cpu(BenchmarkParameters::cpu_id)) << "Failed to bind to cpu!";
674 if(_may_i_use_cpu_feature(_FEATURE_AVX512IFMA52) == 0)
677 for (int iqw = 0; iqw < 4; ++iqw)
679 for (int nrb = 0; nrb < 3; ++nrb)
684 //std::cout << "U-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsUPlane << ": ";
685 resSum += runTest(1, iqWidth[iqw], numRB[nrb], numDataElementsUPlane, totNumBlocks);
687 // CONTROL PLANE TESTS : 8 Antennas
688 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane8 << ": ";
689 resSum += runTest(1, iqWidth[iqw], numRB[nrb], numDataElementsCPlane8, totNumBlocks);
691 // CONTROL PLANE TESTS : 16 Antennas
692 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane16 << ": ";
693 resSum += runTest(1, iqWidth[iqw], numRB[nrb], numDataElementsCPlane16, totNumBlocks);
695 // CONTROL PLANE TESTS : 32 Antennas
696 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane32 << ": ";
697 resSum += runTest(1, iqWidth[iqw], numRB[nrb], numDataElementsCPlane32, totNumBlocks);
699 // CONTROL PLANE TESTS : 64 Antennas
700 //std::cout << "C-Plane: Testing iqWidth = " << iqWidth[iqw] << ", numRB = " << numRB[nrb] << ", numElements = " << numDataElementsCPlane64 << ": ";
701 resSum += runTest(1, iqWidth[iqw], numRB[nrb], numDataElementsCPlane64, totNumBlocks);
705 ASSERT_EQ(0, resSum);
708 TEST_P(BfpCheck, AVX512_sweep_xranlib)
713 int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
714 int16_t iqWidth[] = {8, 9, 10, 12};
716 int16_t numRBs[] = {16, 18, 32, 36, 48, 70, 113, 273};
717 struct xranlib_decompress_request bfp_decom_req;
718 struct xranlib_decompress_response bfp_decom_rsp;
720 struct xranlib_compress_request bfp_com_req;
721 struct xranlib_compress_response bfp_com_rsp;
723 int numDataElements = 24;
725 // Create random number generator
726 std::random_device rd;
727 std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
728 std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);
729 std::uniform_int_distribution<int> randExpShift(0, 4);
731 BlockFloatCompander::ExpandedData expandedData;
732 expandedData.dataExpanded = &loc_dataExpandedIn[0];
733 BlockFloatCompander::ExpandedData expandedDataRes;
734 expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];
735 for (unsigned int iq_w_id = 0; iq_w_id < sizeof(iqWidth)/sizeof(iqWidth[0]); iq_w_id ++){
736 for (unsigned int tc = 0; tc < sizeof(numRBs)/sizeof(numRBs[0]); tc ++){
738 //printf("[%d]numRBs %d [%d] iqWidth %d\n",tc, numRBs[tc], iq_w_id, iqWidth[iq_w_id]);
739 // Generate random test data for compression kernel
741 for (int m = 0; m < 18*BlockFloatCompander::k_maxNumBlocks; ++m) {
742 auto shiftVal = randExpShift(gen);
743 for (int n = 0; n < numDataElements; ++n) {
744 expandedData.dataExpanded[m*numDataElements+n] = int16_t(randInt16(gen) >> shiftVal);
748 BlockFloatCompander::CompressedData compressedData;
749 compressedData.dataCompressed = &loc_dataCompressedDataOut[0];
751 std::memset(&loc_dataCompressedDataOut[0], 0, 288*numDataElements);
752 std::memset(&loc_dataExpandedRes[0], 0, 288*numDataElements);
754 std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));
755 std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
756 std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
757 std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
759 bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;
760 bfp_com_req.numRBs = numRBs[tc];
761 bfp_com_req.numDataElements = 24;
762 bfp_com_req.len = numRBs[tc]*12*2*2;
763 bfp_com_req.compMethod = compMethod;
764 bfp_com_req.iqWidth = iqWidth[iq_w_id];
766 bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);
769 xranlib_compress_avx512(&bfp_com_req, &bfp_com_rsp);
771 bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);
772 bfp_decom_req.numRBs = numRBs[tc];
773 bfp_decom_req.len = bfp_com_rsp.len;
774 bfp_decom_req.numDataElements = 24;
775 bfp_decom_req.compMethod = compMethod;
776 bfp_decom_req.iqWidth = iqWidth[iq_w_id];
778 bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;
779 bfp_decom_rsp.len = 0;
781 xranlib_decompress_avx512(&bfp_decom_req, &bfp_decom_rsp);
783 resSum += checkDataApprox(expandedData.dataExpanded, expandedDataRes.dataExpanded, numRBs[tc]*numDataElements);
785 ASSERT_EQ(numRBs[tc]*12*2*2, bfp_decom_rsp.len);
786 ASSERT_EQ(0, resSum);
791 TEST_P(BfpCheck, AVXSNC_sweep_xranlib)
796 int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
797 int16_t iqWidth[] = {8, 9, 10, 12};
799 int16_t numRBs[] = {16, 18, 32, 36, 48, 70, 113, 273};
800 struct xranlib_decompress_request bfp_decom_req;
801 struct xranlib_decompress_response bfp_decom_rsp;
803 struct xranlib_compress_request bfp_com_req;
804 struct xranlib_compress_response bfp_com_rsp;
806 int numDataElements = 24;
809 if(_may_i_use_cpu_feature(_FEATURE_AVX512IFMA52) == 0)
812 // Create random number generator
813 std::random_device rd;
814 std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
815 std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);
816 std::uniform_int_distribution<int> randExpShift(0, 4);
818 BlockFloatCompander::ExpandedData expandedData;
819 expandedData.dataExpanded = &loc_dataExpandedIn[0];
820 BlockFloatCompander::ExpandedData expandedDataRes;
821 expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];
822 for (unsigned int iq_w_id = 0; iq_w_id < sizeof(iqWidth)/sizeof(iqWidth[0]); iq_w_id ++){
823 for (unsigned int tc = 0; tc < sizeof(numRBs)/sizeof(numRBs[0]); tc ++){
825 //printf("[%d]numRBs %d [%d] iqWidth %d\n",tc, numRBs[tc], iq_w_id, iqWidth[iq_w_id]);
826 // Generate random test data for compression kernel
828 for (int m = 0; m < 18*BlockFloatCompander::k_maxNumBlocks; ++m) {
829 auto shiftVal = randExpShift(gen);
830 for (int n = 0; n < numDataElements; ++n) {
831 expandedData.dataExpanded[m*numDataElements+n] = int16_t(randInt16(gen) >> shiftVal);
835 BlockFloatCompander::CompressedData compressedData;
836 compressedData.dataCompressed = &loc_dataCompressedDataOut[0];
838 std::memset(&loc_dataCompressedDataOut[0], 0, 288*numDataElements);
839 std::memset(&loc_dataExpandedRes[0], 0, 288*numDataElements);
841 std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));
842 std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
843 std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
844 std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
846 bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;
847 bfp_com_req.numRBs = numRBs[tc];
848 bfp_com_req.numDataElements = 24;
849 bfp_com_req.len = numRBs[tc]*12*2*2;
850 bfp_com_req.compMethod = compMethod;
851 bfp_com_req.iqWidth = iqWidth[iq_w_id];
853 bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);
856 xranlib_compress_avxsnc(&bfp_com_req, &bfp_com_rsp);
858 bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);
859 bfp_decom_req.numRBs = numRBs[tc];
860 bfp_decom_req.len = bfp_com_rsp.len;
861 bfp_decom_req.numDataElements = 24;
862 bfp_decom_req.compMethod = compMethod;
863 bfp_decom_req.iqWidth = iqWidth[iq_w_id];
865 bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;
866 bfp_decom_rsp.len = 0;
868 xranlib_decompress_avxsnc(&bfp_decom_req, &bfp_decom_rsp);
870 resSum += checkDataApprox(expandedData.dataExpanded, expandedDataRes.dataExpanded, numRBs[tc]*numDataElements);
872 ASSERT_EQ(numRBs[tc]*12*2*2, bfp_decom_rsp.len);
873 ASSERT_EQ(0, resSum);
878 TEST_P(BfpCheck, AVX512_cp_sweep_xranlib)
883 int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
884 int16_t iqWidth[] = {8, 9, 10, 12};
886 int16_t antElm[] = {8, 16, 32, 64};
888 struct xranlib_decompress_request bfp_decom_req;
889 struct xranlib_decompress_response bfp_decom_rsp;
891 struct xranlib_compress_request bfp_com_req;
892 struct xranlib_compress_response bfp_com_rsp;
893 int32_t numDataElements;
895 // Create random number generator
896 std::random_device rd;
897 std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
898 std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);
899 std::uniform_int_distribution<int> randExpShift(0, 4);
901 BlockFloatCompander::ExpandedData expandedData;
902 expandedData.dataExpanded = &loc_dataExpandedIn[0];
903 BlockFloatCompander::ExpandedData expandedDataRes;
904 expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];
906 for (unsigned int iq_w_id = 0; iq_w_id < sizeof(iqWidth)/sizeof(iqWidth[0]); iq_w_id ++){
907 for (unsigned int tc = 0; tc < sizeof(antElm)/sizeof(antElm[0]); tc ++){
909 numDataElements = 2*antElm[tc];
911 // Generate input data
912 for (int m = 0; m < numRB; ++m)
914 auto shiftVal = randExpShift(gen);
915 for (int n = 0; n < numDataElements; ++n)
917 expandedData.dataExpanded[m * numDataElements + n] = int16_t(randInt16(gen) >> shiftVal);
921 BlockFloatCompander::CompressedData compressedData;
922 compressedData.dataCompressed = &loc_dataCompressedDataOut[0];
924 std::memset(&loc_dataCompressedDataOut[0], 0, 288*numDataElements);
925 std::memset(&loc_dataExpandedRes[0], 0, 288*numDataElements);
927 std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));
928 std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
929 std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
930 std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
932 bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;
933 bfp_com_req.numRBs = numRB;
934 bfp_com_req.numDataElements = numDataElements;
935 bfp_com_req.len = antElm[tc]*4;
936 bfp_com_req.compMethod = compMethod;
937 bfp_com_req.iqWidth = iqWidth[iq_w_id];
939 bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);
942 xranlib_compress_avx512_bfw(&bfp_com_req, &bfp_com_rsp);
944 bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);
945 bfp_decom_req.numRBs = numRB;
946 bfp_decom_req.numDataElements = numDataElements;
947 bfp_decom_req.len = bfp_com_rsp.len;
948 bfp_decom_req.compMethod = compMethod;
949 bfp_decom_req.iqWidth = iqWidth[iq_w_id];
951 bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;
952 bfp_decom_rsp.len = 0;
954 xranlib_decompress_avx512_bfw(&bfp_decom_req, &bfp_decom_rsp);
956 resSum += checkDataApprox(expandedData.dataExpanded, expandedDataRes.dataExpanded, numRB*numDataElements);
958 ASSERT_EQ(antElm[tc]*4, bfp_decom_rsp.len);
959 ASSERT_EQ(0, resSum);
964 TEST_P(BfpCheck, AVXSNC_cp_sweep_xranlib)
969 int16_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
970 int16_t iqWidth[] = {8, 9, 10, 12};
972 int16_t antElm[] = {8, 16, 32, 64};
974 struct xranlib_decompress_request bfp_decom_req;
975 struct xranlib_decompress_response bfp_decom_rsp;
977 struct xranlib_compress_request bfp_com_req;
978 struct xranlib_compress_response bfp_com_rsp;
979 int32_t numDataElements;
981 // Create random number generator
982 std::random_device rd;
983 std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
984 std::uniform_int_distribution<int16_t> randInt16(-32768, 32767);
985 std::uniform_int_distribution<int> randExpShift(0, 4);
987 BlockFloatCompander::ExpandedData expandedData;
988 expandedData.dataExpanded = &loc_dataExpandedIn[0];
989 BlockFloatCompander::ExpandedData expandedDataRes;
990 expandedDataRes.dataExpanded = &loc_dataExpandedRes[0];
992 if(_may_i_use_cpu_feature(_FEATURE_AVX512IFMA52) == 0)
995 for (unsigned int iq_w_id = 0; iq_w_id < sizeof(iqWidth)/sizeof(iqWidth[0]); iq_w_id ++){
996 for (unsigned int tc = 0; tc < sizeof(antElm)/sizeof(antElm[0]); tc ++){
998 numDataElements = 2*antElm[tc];
1000 // Generate input data
1001 for (int m = 0; m < numRB; ++m)
1003 auto shiftVal = randExpShift(gen);
1004 for (int n = 0; n < numDataElements; ++n)
1006 expandedData.dataExpanded[m * numDataElements + n] = int16_t(randInt16(gen) >> shiftVal);
1010 BlockFloatCompander::CompressedData compressedData;
1011 compressedData.dataCompressed = &loc_dataCompressedDataOut[0];
1013 std::memset(&loc_dataCompressedDataOut[0], 0, 288*numDataElements);
1014 std::memset(&loc_dataExpandedRes[0], 0, 288*numDataElements);
1016 std::memset(&bfp_com_req, 0, sizeof(struct xranlib_compress_request));
1017 std::memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
1018 std::memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
1019 std::memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
1021 bfp_com_req.data_in = (int16_t *)expandedData.dataExpanded;
1022 bfp_com_req.numRBs = numRB;
1023 bfp_com_req.numDataElements = numDataElements;
1024 bfp_com_req.len = antElm[tc]*4;
1025 bfp_com_req.compMethod = compMethod;
1026 bfp_com_req.iqWidth = iqWidth[iq_w_id];
1028 bfp_com_rsp.data_out = (int8_t *)(compressedData.dataCompressed);
1029 bfp_com_rsp.len = 0;
1031 xranlib_compress_avxsnc_bfw(&bfp_com_req, &bfp_com_rsp);
1033 bfp_decom_req.data_in = (int8_t *)(compressedData.dataCompressed);
1034 bfp_decom_req.numRBs = numRB;
1035 bfp_decom_req.numDataElements = numDataElements;
1036 bfp_decom_req.len = bfp_com_rsp.len;
1037 bfp_decom_req.compMethod = compMethod;
1038 bfp_decom_req.iqWidth = iqWidth[iq_w_id];
1040 bfp_decom_rsp.data_out = (int16_t *)expandedDataRes.dataExpanded;
1041 bfp_decom_rsp.len = 0;
1043 xranlib_decompress_avxsnc_bfw(&bfp_decom_req, &bfp_decom_rsp);
1045 resSum += checkDataApprox(expandedData.dataExpanded, expandedDataRes.dataExpanded, numRB*numDataElements);
1047 ASSERT_EQ(antElm[tc]*4, bfp_decom_rsp.len);
1048 ASSERT_EQ(0, resSum);
1053 TEST_P(BfpPerfEx, AVX512_Comp)
1055 performance("AVX512", module_name, xranlib_compress_avx512, &bfp_com_req, &bfp_com_rsp);
1058 TEST_P(BfpPerfEx, AVX512_DeComp)
1060 performance("AVX512", module_name, xranlib_decompress_avx512, &bfp_decom_req, &bfp_decom_rsp);
1063 TEST_P(BfpPerfCp, AVX512_CpComp)
1065 performance("AVX512", module_name, xranlib_compress_avx512_bfw, &bfp_com_req, &bfp_com_rsp);
1068 TEST_P(BfpPerfCp, AVX512_CpDeComp)
1070 performance("AVX512", module_name, xranlib_decompress_avx512_bfw, &bfp_decom_req, &bfp_decom_rsp);
1073 TEST_P(BfpPerfEx, AVXSNC_Comp)
1075 if(_may_i_use_cpu_feature(_FEATURE_AVX512IFMA52))
1076 performance("AVXSNC", module_name, xranlib_compress_avxsnc, &bfp_com_req, &bfp_com_rsp);
1079 TEST_P(BfpPerfEx, AVXSNC_DeComp)
1081 if(_may_i_use_cpu_feature(_FEATURE_AVX512IFMA52))
1082 performance("AVXSNC", module_name, xranlib_decompress_avxsnc, &bfp_decom_req, &bfp_decom_rsp);
1085 TEST_P(BfpPerfCp, AVXSNC_CpComp)
1087 if(_may_i_use_cpu_feature(_FEATURE_AVX512IFMA52))
1088 performance("AVXSNC", module_name, xranlib_compress_avxsnc_bfw, &bfp_com_req, &bfp_com_rsp);
1091 TEST_P(BfpPerfCp, AVXSNC_CpDeComp)
1093 if(_may_i_use_cpu_feature(_FEATURE_AVX512IFMA52))
1094 performance("AVXSNC", module_name, xranlib_decompress_avxsnc_bfw, &bfp_decom_req, &bfp_decom_rsp);
1097 INSTANTIATE_TEST_CASE_P(UnitTest, BfpCheck,
1098 testing::ValuesIn(get_sequence(BfpCheck::get_number_of_cases("bfp_functional"))));
1100 INSTANTIATE_TEST_CASE_P(UnitTest, BfpPerfEx,
1101 testing::ValuesIn(get_sequence(BfpPerfEx::get_number_of_cases("bfp_performace_ex"))));
1103 INSTANTIATE_TEST_CASE_P(UnitTest, BfpPerfCp,
1104 testing::ValuesIn(get_sequence(BfpPerfCp::get_number_of_cases("bfp_performace_cp"))));