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 *******************************************************************************/
21 #include "xran_lib_wrap.hpp"
22 #include "xran_common.h"
23 #include "xran_fh_o_du.h"
26 #include "xran_transport.h"
27 #include "xran_cp_api.h"
31 #define DELETE_ARRAY(x) { if(x) { delete[] x; x = nullptr; } }
33 #define XRAN_MAX_BUFLEN_EXT11 (MAX_RX_LEN - \
34 (RTE_PKTMBUF_HEADROOM \
35 + sizeof(struct xran_ecpri_hdr) \
36 + sizeof(struct xran_cp_radioapp_common_header) \
37 + sizeof(struct xran_cp_radioapp_section1) \
38 + sizeof(union xran_cp_radioapp_section_ext6) \
39 + sizeof(union xran_cp_radioapp_section_ext10) \
42 const std::string module_name = "C-Plane";
44 const uint8_t m_bitmask[] = { 0x00, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
49 /* wrapper function for performace tests to reset mbuf */
50 int xran_ut_prepare_cp(struct xran_cp_gen_params *params,
51 uint8_t cc_id, uint8_t ant_id, uint8_t seq_id, uint16_t start_sect_id)
54 struct rte_mbuf *mbuf;
56 mbuf = xran_ethdi_mbuf_alloc();
58 printf("Failed to allocate buffer!\n");
62 ret = xran_prepare_ctrl_pkt(mbuf, params, cc_id, ant_id, seq_id, start_sect_id);
63 rte_pktmbuf_free(mbuf);
68 void cput_fh_rx_callback(void *pCallbackTag, xran_status_t status)
73 void cput_fh_rx_prach_callback(void *pCallbackTag, xran_status_t status)
82 class C_plane: public KernelTests
85 struct xran_section_gen_info *m_pSectGenInfo = NULL;
86 struct xran_section_recv_info *m_pSectResult = NULL;
98 std::vector<uint8_t> exts;
105 struct xran_sectionext1_info ext1;
106 struct xran_sectionext2_info ext2;
107 struct xran_sectionext3_info ext3;
108 struct xran_sectionext4_info ext4;
109 struct xran_sectionext5_info ext5;
110 struct xran_sectionext6_info ext6;
111 struct xran_sectionext7_info ext7;
112 struct xran_sectionext8_info ext8;
113 struct xran_sectionext9_info ext9;
114 struct xran_sectionext10_info ext10;
115 struct xran_sectionext11_info ext11;
120 int m_maxSections = 8; /* not used */
123 struct rte_mbuf *m_pTestBuffer = nullptr;
124 struct xran_fh_config *m_fh_cfg;
125 struct xran_srs_config *m_srs_cfg;
126 struct xran_device_ctx m_xran_dev_ctx;
128 struct xran_cp_gen_params m_params;
129 struct xran_recv_packet_info m_pktInfo;
130 struct xran_cp_recv_params m_result;
131 struct xran_prb_elm *m_prb_ele = nullptr;
133 struct xran_sectionext1_info m_temp_ext1[XRAN_MAX_PRBS];
136 std::string m_dirStr;
137 uint8_t m_sectionType;
139 uint8_t m_ccId, m_antId;
141 uint8_t m_frameId, m_subframeId, m_slotId;
144 uint8_t m_iqWidth, m_compMethod;
145 uint8_t m_filterIndex;
146 uint16_t m_timeOffset;
151 uint32_t mb_free = MBUF_FREE;
153 struct sectinfo *m_sections;
154 struct extcfginfo *m_extcfgs;
157 uint16_t m_ext1_dst_len = 0;
158 int8_t *m_p_ext1_dst = nullptr;
159 int16_t *m_p_bfw_iq_src = nullptr;
161 struct xran_sectionext1_info m_ext1;
164 struct rte_mbuf_ext_shared_info m_extSharedInfo;
165 uint8_t *m_pBfwIQ_ext = nullptr;
166 int16_t *m_pBfw_src[XRAN_MAX_SET_BFWS];
167 int16_t m_pBfw_rx[XRAN_MAX_SET_BFWS][MAX_RX_LEN];
168 struct xran_ext11_bfw_info m_bfwInfo[XRAN_MAX_SET_BFWS];
170 void SetUp() override
175 std::string ext_name;
177 init_test("C_Plane");
179 m_dirStr = get_input_parameter<std::string>("direction");
181 memset(&m_xran_dev_ctx, 0, sizeof(struct xran_device_ctx));
182 m_srs_cfg = &m_xran_dev_ctx.srs_cfg;
183 m_fh_cfg = &m_xran_dev_ctx.fh_cfg;
185 if(!m_dirStr.compare("DL")) m_dir = XRAN_DIR_DL;
186 else if(!m_dirStr.compare("UL")) m_dir = XRAN_DIR_UL;
187 else FAIL() << "Invalid direction!";
189 m_sectionType = get_input_parameter<uint8_t>("section_type");
190 m_ccId = get_input_parameter<uint8_t>("cc_id");
191 m_antId = get_input_parameter<uint8_t>("ant_id");
192 m_seqId = get_input_parameter<uint16_t>("seq_id");
194 m_frameId = get_input_parameter<uint8_t>("frame_id");
195 m_subframeId = get_input_parameter<uint8_t>("subframe_id");
196 m_slotId = get_input_parameter<uint8_t>("slot_id");
197 m_symStart = get_input_parameter<uint8_t>("symbol_start");
198 m_compMethod = get_input_parameter<uint8_t>("comp_method");
199 m_iqWidth = get_input_parameter<uint8_t>("iq_width");
201 m_xran_dev_ctx.interval_us_local = get_input_parameter<uint8_t>("interval");
202 m_srs_cfg->eAxC_offset = XRAN_MAX_ANTENNA_NR;//m_antId + 4;
203 m_fh_cfg->neAxc = m_antId + 1;
205 switch(m_sectionType) {
206 case XRAN_CP_SECTIONTYPE_1:
207 m_filterIndex = XRAN_FILTERINDEX_STANDARD;
210 case XRAN_CP_SECTIONTYPE_3:
211 m_filterIndex = get_input_parameter<uint8_t>("filter_index");
212 m_timeOffset = get_input_parameter<uint16_t>("time_offset");
213 m_fftSize = get_input_parameter<uint8_t>("fft_size");
214 m_scs = get_input_parameter<uint8_t>("scs");
215 m_cpLength = get_input_parameter<uint16_t>("cp_length");
219 FAIL() << "Invalid Section Type - " << m_sectionType << std::endl;
222 m_numSections = get_input_subsection_size("sections");
223 ASSERT_FALSE(m_numSections == 0);
225 m_sections = new struct sectinfo [m_numSections];
226 for(i=0; i<m_numSections; i++) {
227 m_sections[i].sectionId = get_input_parameter<uint16_t>("sections", i, "sectionId");
228 m_sections[i].rb = get_input_parameter<uint16_t>("sections", i, "rb");
229 m_sections[i].symInc = get_input_parameter<uint16_t>("sections", i, "symInc");
230 m_sections[i].startPrbc = get_input_parameter<uint16_t>("sections", i, "startPrbc");
231 m_sections[i].numPrbc = get_input_parameter<uint16_t>("sections", i, "numPrbc");
232 m_sections[i].reMask = get_input_parameter<uint16_t>("sections", i, "reMask");
233 m_sections[i].numSymbol = get_input_parameter<uint16_t>("sections", i, "numSymbol");
234 m_sections[i].beamId = get_input_parameter<uint16_t>("sections", i, "beamId");
236 switch(m_sectionType) {
237 case XRAN_CP_SECTIONTYPE_3:
238 m_sections[i].freqOffset = get_input_parameter<uint16_t>("sections", i, "freqOffset");
242 m_sections[i].exts = get_input_parameter<std::vector<uint8_t>>("sections", i, "exts");
245 /* allocate and prepare required data storage */
246 m_pSectGenInfo = new struct xran_section_gen_info [m_numSections];
247 ASSERT_NE(m_pSectGenInfo, nullptr);
248 m_params.sections = m_pSectGenInfo;
250 m_pSectResult = new struct xran_section_recv_info [m_numSections];
251 ASSERT_NE(m_pSectResult, nullptr);
252 m_result.sections = m_pSectResult;
254 /* reading configurations of section extension */
255 m_nextcfgs = get_input_subsection_size("extensions");
257 m_extcfgs = new struct extcfginfo [m_nextcfgs];
260 for(i=0; i < m_nextcfgs; i++) {
261 std::vector<uint16_t> beamIDs;
263 ext_type = get_input_parameter<int>("extensions", i, "type");
265 case XRAN_CP_SECTIONEXTCMD_1:
267 /* if section extension type 1 is present, then ignore other extensions */
268 if(i != 0 && m_nextcfgs != 1) {
269 std::cout << "### Extension 1 configuration, ignore other extensions !!\n" << std::endl;
274 m_extcfgs[i].u.ext1.bfwCompMeth = get_input_parameter<uint8_t> ("extensions", i, "bfwCompMeth");
275 m_extcfgs[i].u.ext1.bfwIqWidth = get_input_parameter<uint8_t> ("extensions", i, "bfwIqWidth");
276 m_antElmTRx = get_input_parameter<uint8_t> ("extensions", i, "antelm_trx");
277 struct xran_device_ctx * p_xran_dev_ctx = xran_dev_get_ctx();
278 p_xran_dev_ctx->numSetBFWs_arr[0] = m_numSections;
281 case XRAN_CP_SECTIONEXTCMD_2:
282 m_extcfgs[i].u.ext2.bfAzPtWidth = get_input_parameter<uint8_t>("extensions", i, "bfAzPtWidth") & 0x7;
283 m_extcfgs[i].u.ext2.bfAzPt = get_input_parameter<uint8_t>("extensions", i, "bfAzPt") & 0xf;
284 m_extcfgs[i].u.ext2.bfZePtWidth = get_input_parameter<uint8_t>("extensions", i, "bfZePtWidth") & 0x7;
285 m_extcfgs[i].u.ext2.bfZePt = get_input_parameter<uint8_t>("extensions", i, "bfZePt") & 0xf;
286 m_extcfgs[i].u.ext2.bfAz3ddWidth = get_input_parameter<uint8_t>("extensions", i, "bfAz3ddWidth") & 0x7;
287 m_extcfgs[i].u.ext2.bfAz3dd = get_input_parameter<uint8_t>("extensions", i, "bfAz3dd") & 0xf;
288 m_extcfgs[i].u.ext2.bfZe3ddWidth = get_input_parameter<uint8_t>("extensions", i, "bfZe3ddWidth") & 0x7;
289 m_extcfgs[i].u.ext2.bfZe3dd = get_input_parameter<uint8_t>("extensions", i, "bfZe3dd") & 0xf;
290 m_extcfgs[i].u.ext2.bfAzSI = get_input_parameter<uint8_t>("extensions", i, "bfAzSI") & 0x7;
291 m_extcfgs[i].u.ext2.bfZeSI = get_input_parameter<uint8_t>("extensions", i, "bfZeSI") & 0x7;
294 case XRAN_CP_SECTIONEXTCMD_3:
295 m_extcfgs[i].u.ext3.codebookIdx = get_input_parameter<uint8_t> ("extensions", i, "codebookIdx");
296 m_extcfgs[i].u.ext3.layerId = get_input_parameter<uint8_t> ("extensions", i, "layerId") & 0xf;
297 m_extcfgs[i].u.ext3.numLayers = get_input_parameter<uint8_t> ("extensions", i, "numLayers") & 0xf;
298 m_extcfgs[i].u.ext3.txScheme = get_input_parameter<uint8_t> ("extensions", i, "txScheme") & 0xf;
299 m_extcfgs[i].u.ext3.crsReMask = get_input_parameter<uint16_t>("extensions", i, "crsReMask") & 0xfff;
300 m_extcfgs[i].u.ext3.crsShift = get_input_parameter<uint8_t> ("extensions", i, "crsShift") & 0x1;
301 m_extcfgs[i].u.ext3.crsSymNum = get_input_parameter<uint8_t> ("extensions", i, "crsSymNum") & 0xf;
302 m_extcfgs[i].u.ext3.numAntPort = get_input_parameter<uint16_t>("extensions", i, "numAntPort");
303 m_extcfgs[i].u.ext3.beamIdAP1 = get_input_parameter<uint16_t>("extensions", i, "beamIdAP1");
304 m_extcfgs[i].u.ext3.beamIdAP2 = get_input_parameter<uint16_t>("extensions", i, "beamIdAP2");
305 m_extcfgs[i].u.ext3.beamIdAP3 = get_input_parameter<uint16_t>("extensions", i, "beamIdAP3");
308 case XRAN_CP_SECTIONEXTCMD_4:
309 m_extcfgs[i].u.ext4.csf = get_input_parameter<uint8_t> ("extensions", i, "csf") & 0xf;
310 m_extcfgs[i].u.ext4.modCompScaler= get_input_parameter<uint16_t>("extensions", i, "modCompScaler") & 0x7fff;
313 case XRAN_CP_SECTIONEXTCMD_5:
315 std::vector<uint16_t> csf;
316 std::vector<uint16_t> mcScaleReMask;
317 std::vector<uint16_t> mcScaleOffset;
319 m_extcfgs[i].u.ext5.num_sets = get_input_parameter<uint8_t>("extensions", i, "num_sets");
320 if(m_extcfgs[i].u.ext5.num_sets > XRAN_MAX_MODCOMP_ADDPARMS)
321 FAIL() << "Invalid number of sets in extension 5!";
323 csf = get_input_parameter<std::vector<uint16_t>>("extensions", i, "csf");
324 mcScaleReMask = get_input_parameter<std::vector<uint16_t>>("extensions", i, "mcScaleReMask");
325 mcScaleOffset = get_input_parameter<std::vector<uint16_t>>("extensions", i, "mcScaleOffset");
327 if(csf.size() != m_extcfgs[i].u.ext5.num_sets
328 || mcScaleReMask.size() != m_extcfgs[i].u.ext5.num_sets
329 || mcScaleOffset.size() != m_extcfgs[i].u.ext5.num_sets)
330 FAIL() << "Invalid configuration in extension 5 - different size!";
332 for(j=0; j < m_extcfgs[i].u.ext5.num_sets; j++) {
333 m_extcfgs[i].u.ext5.mc[j].csf = csf[j];
334 m_extcfgs[i].u.ext5.mc[j].mcScaleReMask = mcScaleReMask[j];
335 m_extcfgs[i].u.ext5.mc[j].mcScaleOffset = mcScaleOffset[j];
340 case XRAN_CP_SECTIONEXTCMD_6:
341 m_extcfgs[i].u.ext6.rbgSize = get_input_parameter<uint8_t> ("extensions", i, "rbgSize");
342 m_extcfgs[i].u.ext6.rbgMask = get_input_parameter<uint32_t>("extensions", i, "rbgMask");
343 m_extcfgs[i].u.ext6.symbolMask = get_input_parameter<uint16_t>("extensions", i, "symbolMask");
346 case XRAN_CP_SECTIONEXTCMD_9:
348 m_extcfgs[i].u.ext9.technology = get_input_parameter<uint8_t> ("extensions", i, "technology");
349 m_xran_dev_ctx.dssPeriod = 1;
352 case XRAN_CP_SECTIONEXTCMD_10:
353 m_extcfgs[i].u.ext10.numPortc = get_input_parameter<uint8_t> ("extensions", i, "numPortc");
354 m_extcfgs[i].u.ext10.beamGrpType= get_input_parameter<uint8_t> ("extensions", i, "beamGrpType");
355 switch(m_extcfgs[i].u.ext10.beamGrpType) {
356 case XRAN_BEAMGT_COMMON:
357 case XRAN_BEAMGT_MATRIXIND:
359 case XRAN_BEAMGT_VECTORLIST:
360 beamIDs = get_input_parameter<std::vector<uint16_t>>("extensions", i, "beamID");
361 for(j=0; j < m_extcfgs[i].u.ext10.numPortc; j++)
362 m_extcfgs[i].u.ext10.beamID[j] = beamIDs[j];
365 FAIL() << "Invalid Beam Group Type - " << m_extcfgs[i].u.ext10.beamGrpType << std::endl;
369 case XRAN_CP_SECTIONEXTCMD_11:
372 /* if section extension type 11 is present, then ignore other extensions */
373 if(i != 0 && m_nextcfgs != 1) {
374 std::cout << "### Extension 11 configuration, ignore other extensions !!\n" << std::endl;
380 m_extcfgs[i].u.ext11.RAD = get_input_parameter<uint8_t> ("extensions", i, "RAD");
381 m_extcfgs[i].u.ext11.disableBFWs = get_input_parameter<uint8_t> ("extensions", i, "disableBFWs");
382 m_extcfgs[i].u.ext11.numBundPrb = get_input_parameter<uint8_t> ("extensions", i, "numBundPrb");
383 m_extcfgs[i].u.ext11.bfwCompMeth = get_input_parameter<uint8_t> ("extensions", i, "bfwCompMeth");
384 m_extcfgs[i].u.ext11.bfwIqWidth = get_input_parameter<uint8_t> ("extensions", i, "bfwIqWidth");
385 m_extcfgs[i].u.ext11.numSetBFWs = get_input_parameter<uint8_t> ("extensions", i, "numSetBFWs");
386 m_antElmTRx = get_input_parameter<uint8_t> ("extensions", i, "antelm_trx");
387 beamIDs = get_input_parameter<std::vector<uint16_t>>("extensions", i, "beamID");
389 /* Allocate buffers */
390 m_extcfgs[i].u.ext11.maxExtBufSize = MAX_RX_LEN;
391 m_pBfwIQ_ext = (uint8_t *)xran_malloc(m_extcfgs[i].u.ext11.maxExtBufSize);
392 m_extcfgs[i].u.ext11.pExtBuf = m_pBfwIQ_ext;
394 for(j = 0; j < XRAN_MAX_SET_BFWS; j++) {
395 m_pBfw_src[j] = new int16_t [XRAN_MAX_BFW_N];
396 memset(m_pBfw_src[j], j+1, XRAN_MAX_BFW_N);
399 for(j=0; j < m_extcfgs[i].u.ext11.numSetBFWs; j++) {
400 m_bfwInfo[j].pBFWs = (uint8_t *)(m_pBfw_src[j]);
401 m_bfwInfo[j].beamId = beamIDs[j];
404 /* Initialize Shared information for external buffer */
405 m_extSharedInfo.free_cb = NULL;
406 m_extSharedInfo.fcb_opaque = NULL;
407 rte_mbuf_ext_refcnt_update(&m_extSharedInfo, 0);
408 m_extcfgs[i].u.ext11.pExtBufShinfo = &m_extSharedInfo;
410 /* Check all BFWs can be fit with given buffer */
411 temp = xran_cp_estimate_max_set_bfws(m_antElmTRx, m_extcfgs[i].u.ext11.bfwIqWidth,
412 m_extcfgs[i].u.ext11.bfwCompMeth, m_extcfgs[i].u.ext11.maxExtBufSize);
413 if(m_extcfgs[i].u.ext11.numSetBFWs > temp) {
414 FAIL() << "Too many sets of BFWs - " << m_extcfgs[i].u.ext11.numSetBFWs
415 << " (max " << temp << " for " << m_extcfgs[i].u.ext11.maxExtBufSize << std::endl;
418 temp = xran_cp_prepare_ext11_bfws(m_extcfgs[i].u.ext11.numSetBFWs, m_antElmTRx,
419 m_extcfgs[i].u.ext11.bfwIqWidth, m_extcfgs[i].u.ext11.bfwCompMeth,
420 m_pBfwIQ_ext, XRAN_MAX_BUFLEN_EXT11, m_bfwInfo);
422 FAIL() << "Fail to prepare BFWs!" << std::endl;
424 m_extcfgs[i].u.ext11.totalBfwIQLen = temp;
429 FAIL() << "Invalid Section Type Extension - " << ext_type << std::endl;
431 } /* switch(ext_type) */
433 m_extcfgs[i].type = ext_type;
434 m_extcfgs[i].name = get_input_parameter<std::string>("extensions", i, "name");
438 } /* for(i=0; i < m_nextcfgs; i++) */
444 m_ext1_dst_len = 9600;
445 m_p_ext1_dst = new int8_t [m_ext1_dst_len];
446 m_p_bfw_iq_src = new int16_t [9600/2];
449 void TearDown() override
451 if(m_pTestBuffer != nullptr) {
452 rte_pktmbuf_free(m_pTestBuffer);
453 m_pTestBuffer = nullptr;
457 xran_free(m_prb_ele);
462 xran_free(m_pBfwIQ_ext);
463 m_pBfwIQ_ext = nullptr;
465 for(int i = 0; i < XRAN_MAX_SET_BFWS; i++) {
466 DELETE_ARRAY(m_pBfw_src[i]);
469 DELETE_ARRAY(m_extcfgs);
470 DELETE_ARRAY(m_sections);
471 DELETE_ARRAY(m_p_bfw_iq_src);
472 DELETE_ARRAY(m_p_ext1_dst);
473 DELETE_ARRAY(m_pSectGenInfo);
474 DELETE_ARRAY(m_pSectResult);
477 int prepare_sections(void);
478 int prepare_extensions(void);
479 void verify_sections(void);
481 void test_ext1(void);
486 int C_plane::prepare_extensions()
488 int i, j, numext, sect_num;
491 for(sect_num=0; sect_num < m_numSections; sect_num++) {
494 for(i=0; i < (int)(m_sections[sect_num].exts.size()); i++) {
496 ext_id = m_sections[sect_num].exts[i];
497 if(ext_id >= m_nextcfgs) {
498 std::cout << "Invalid section extension configuration index - " << ext_id << " [max " << m_nextcfgs-1 << "]" << std::endl;
502 switch(m_extcfgs[ext_id].type) {
503 case XRAN_CP_SECTIONEXTCMD_1:
504 // std::cout << "Skip Extension 1 !!" << std::endl;
506 case XRAN_CP_SECTIONEXTCMD_2:
507 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext2);
508 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext2;
510 case XRAN_CP_SECTIONEXTCMD_3:
511 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext3);
512 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext3;
514 case XRAN_CP_SECTIONEXTCMD_4:
515 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext4);
516 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext4;
518 case XRAN_CP_SECTIONEXTCMD_5:
519 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext5);
520 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext5;
522 case XRAN_CP_SECTIONEXTCMD_6:
523 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext6);
524 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext6;
526 case XRAN_CP_SECTIONEXTCMD_9:
527 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext9);
528 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext9;
530 case XRAN_CP_SECTIONEXTCMD_10:
531 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext10);
532 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext10;
534 case XRAN_CP_SECTIONEXTCMD_11:
535 m_params.sections[sect_num].exData[numext].len = sizeof(m_extcfgs[ext_id].u.ext11);
536 m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext11;
538 m_result.sections[sect_num].exts[numext].type = m_extcfgs[ext_id].type;
539 for(j=0 ; j < XRAN_MAX_SET_BFWS; j++)
540 m_result.sections[sect_num].exts[numext].u.ext11.bundInfo[j].pBFWs = (uint8_t *)m_pBfw_rx[j];
544 std::cout << "Invalid Section Extension Type - " << (int)m_extcfgs[ext_id].type << std::endl;
546 } /* switch(m_extcfgs[ext_id].type) */
548 m_params.sections[sect_num].exData[numext].type = m_extcfgs[ext_id].type;
550 } /* for(i=0; i < m_sections[sect_num].exts.size(); i++) */
553 m_params.sections[sect_num].exDataSize = numext;
554 m_params.sections[sect_num].info->ef = 1;
557 m_params.sections[sect_num].exDataSize = 0;
558 m_params.sections[sect_num].info->ef = 0;
560 } /* for(sect_num=0; sect_num < m_numSections; sect_num++) */
566 int C_plane::prepare_sections(void)
571 /* Preparing input data for packet generation */
572 m_params.dir = m_dir;
573 m_params.sectionType = m_sectionType;
575 m_params.hdr.filterIdx = m_filterIndex;
576 m_params.hdr.frameId = m_frameId;
577 m_params.hdr.subframeId = m_subframeId;
578 m_params.hdr.slotId = m_slotId;
579 m_params.hdr.startSymId = m_symStart;
580 m_params.hdr.iqWidth = XRAN_CONVERT_IQWIDTH(m_iqWidth);
581 m_params.hdr.compMeth = m_compMethod;
583 switch(m_sectionType) {
584 case XRAN_CP_SECTIONTYPE_1:
587 case XRAN_CP_SECTIONTYPE_3:
588 m_params.hdr.timeOffset = m_timeOffset;
589 m_params.hdr.fftSize = m_fftSize;
590 m_params.hdr.scs = m_scs;
591 m_params.hdr.cpLength = m_cpLength;
598 for(numsec=0; numsec < m_numSections; numsec++) {
599 m_params.sections[numsec].info = new struct xran_section_info;
600 m_params.sections[numsec].info->type = m_params.sectionType;
601 m_params.sections[numsec].info->startSymId = m_params.hdr.startSymId;
602 m_params.sections[numsec].info->iqWidth = m_params.hdr.iqWidth;
603 m_params.sections[numsec].info->compMeth = m_params.hdr.compMeth;
604 m_params.sections[numsec].info->id = m_sections[numsec].sectionId;
605 m_params.sections[numsec].info->rb = m_sections[numsec].rb;
606 m_params.sections[numsec].info->symInc = m_sections[numsec].symInc;
607 m_params.sections[numsec].info->startPrbc = m_sections[numsec].startPrbc;
608 m_params.sections[numsec].info->numPrbc = m_sections[numsec].numPrbc;
609 m_params.sections[numsec].info->reMask = m_sections[numsec].reMask;
610 m_params.sections[numsec].info->numSymbol = m_sections[numsec].numSymbol;
611 m_params.sections[numsec].info->beamId = m_sections[numsec].beamId;
613 switch(m_sectionType) {
614 case XRAN_CP_SECTIONTYPE_1:
617 case XRAN_CP_SECTIONTYPE_3:
618 m_params.sections[numsec].info->freqOffset = m_sections[numsec].freqOffset;
626 m_params.numSections = numsec;
632 void C_plane::verify_sections(void)
636 /* Verify the result */
637 EXPECT_TRUE(m_result.dir == m_params.dir);
638 EXPECT_TRUE(m_result.sectionType == m_params.sectionType);
640 EXPECT_TRUE(m_result.hdr.filterIdx == m_params.hdr.filterIdx);
641 EXPECT_TRUE(m_result.hdr.frameId == m_params.hdr.frameId);
642 EXPECT_TRUE(m_result.hdr.subframeId == m_params.hdr.subframeId);
643 EXPECT_TRUE(m_result.hdr.slotId == m_params.hdr.slotId);
644 EXPECT_TRUE(m_result.hdr.startSymId == m_params.hdr.startSymId);
645 EXPECT_TRUE(m_result.hdr.iqWidth == m_params.hdr.iqWidth);
646 EXPECT_TRUE(m_result.hdr.compMeth == m_params.hdr.compMeth);
648 switch(m_sectionType) {
649 case XRAN_CP_SECTIONTYPE_1:
652 case XRAN_CP_SECTIONTYPE_3:
653 EXPECT_TRUE(m_result.hdr.fftSize == m_params.hdr.fftSize);
654 EXPECT_TRUE(m_result.hdr.scs == m_params.hdr.scs);
655 EXPECT_TRUE(m_result.hdr.cpLength == m_params.hdr.cpLength);
659 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";
661 // printf("m_result.numSections = %d , m_params.numSections = %d\n",m_result.numSections,i,m_params.numSections);
662 ASSERT_TRUE(m_result.numSections == m_params.numSections);
663 for(i=0; i < m_result.numSections; i++) {
664 // printf("m_result.sections[%d].info.id = %d , m_params.sections[%d].info.id = %d\n",i,m_result.sections[i].info.id,i,m_params.sections[i].info.id);
665 EXPECT_TRUE(m_result.sections[i].info.id == m_params.sections[i].info->id);
666 EXPECT_TRUE(m_result.sections[i].info.rb == m_params.sections[i].info->rb);
667 EXPECT_TRUE(m_result.sections[i].info.symInc == m_params.sections[i].info->symInc);
668 EXPECT_TRUE(m_result.sections[i].info.startPrbc == m_params.sections[i].info->startPrbc);
669 if(m_params.sections[i].info->numPrbc > 255)
670 EXPECT_TRUE(m_result.sections[i].info.numPrbc == 0);
672 EXPECT_TRUE(m_result.sections[i].info.numPrbc == m_params.sections[i].info->numPrbc);
673 EXPECT_TRUE(m_result.sections[i].info.numSymbol == m_params.sections[i].info->numSymbol);
674 EXPECT_TRUE(m_result.sections[i].info.reMask == m_params.sections[i].info->reMask);
675 EXPECT_TRUE(m_result.sections[i].info.beamId == m_params.sections[i].info->beamId);
676 EXPECT_TRUE(m_result.sections[i].info.ef == m_params.sections[i].info->ef);
678 switch(m_sectionType) {
679 case XRAN_CP_SECTIONTYPE_1:
682 case XRAN_CP_SECTIONTYPE_3:
683 EXPECT_TRUE(m_result.sections[i].info.freqOffset == m_params.sections[i].info->freqOffset);
687 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";
690 if(m_params.sections[i].info->ef) {
691 //printf("[%d] %d == %d\n",i, m_result.sections[i].exDataSize, m_params.sections[i].exDataSize);
692 EXPECT_TRUE(m_result.sections[i].numExts == m_params.sections[i].exDataSize);
694 for(j=0; j < (int)m_params.sections[i].exDataSize; j++) {
695 EXPECT_TRUE(m_result.sections[i].exts[j].type == m_params.sections[i].exData[j].type);
697 switch(m_params.sections[i].exData[j].type) {
698 case XRAN_CP_SECTIONEXTCMD_1:
700 struct xran_sectionext1_info *ext1_params, *ext1_result;
701 int iq_size, parm_size, N;
703 ext1_params = (struct xran_sectionext1_info *)m_params.sections[i].exData[j].data;
704 ext1_result = &m_result.sections[i].exts[j].u.ext1;
706 EXPECT_TRUE(ext1_result->bfwIqWidth == ext1_params->bfwIqWidth);
707 EXPECT_TRUE(ext1_result->bfwCompMeth == ext1_params->bfwCompMeth);
709 N = ext1_params->bfwNumber;
710 switch(ext1_params->bfwCompMeth) {
711 case XRAN_BFWCOMPMETHOD_BLKFLOAT:
712 //printf("[%d, %d] %d == %d\n",i, j, ext1_result->bfwCompParam.exponent, ext1_params->bfwCompParam.exponent);
713 EXPECT_TRUE(ext1_result->bfwCompParam.exponent == ext1_params->bfwCompParam.exponent);
716 case XRAN_BFWCOMPMETHOD_BLKSCALE:
717 EXPECT_TRUE(ext1_result->bfwCompParam.blockScaler == ext1_params->bfwCompParam.blockScaler);
720 case XRAN_BFWCOMPMETHOD_ULAW:
721 EXPECT_TRUE(ext1_result->bfwCompParam.compBitWidthShift == ext1_params->bfwCompParam.compBitWidthShift);
724 case XRAN_BFWCOMPMETHOD_BEAMSPACE:
725 parm_size = N>>3; if(N%8) parm_size++; parm_size *= 8;
726 EXPECT_TRUE(std::memcmp(ext1_result->bfwCompParam.activeBeamspaceCoeffMask, ext1_params->bfwCompParam.activeBeamspaceCoeffMask, parm_size));
730 /* Get the number of BF weights */
731 iq_size = N*ext1_params->bfwIqWidth*2; // total in bits
732 parm_size = iq_size>>3; // total in bytes (/8)
733 if(iq_size%8) parm_size++; // round up
734 EXPECT_FALSE(std::memcmp(ext1_result->p_bfwIQ, ext1_params->p_bfwIQ, parm_size));
738 case XRAN_CP_SECTIONEXTCMD_2:
740 struct xran_sectionext2_info *ext2_params, *ext2_result;
742 ext2_params = (struct xran_sectionext2_info *)m_params.sections[i].exData[j].data;
743 ext2_result = &m_result.sections[i].exts[j].u.ext2;
745 if(ext2_params->bfAzPtWidth) {
746 EXPECT_TRUE(ext2_result->bfAzPtWidth == ext2_params->bfAzPtWidth);
747 EXPECT_TRUE(ext2_result->bfAzPt == ext2_params->bfAzPt);
750 if(ext2_params->bfZePtWidth) {
751 EXPECT_TRUE(ext2_result->bfZePtWidth == ext2_params->bfZePtWidth);
752 EXPECT_TRUE(ext2_result->bfZePt == ext2_params->bfZePt);
754 if(ext2_params->bfAz3ddWidth) {
755 EXPECT_TRUE(ext2_result->bfAz3ddWidth == ext2_params->bfAz3ddWidth);
756 EXPECT_TRUE(ext2_result->bfAz3dd == ext2_params->bfAz3dd);
758 if(ext2_params->bfZe3ddWidth) {
759 EXPECT_TRUE(ext2_result->bfZe3ddWidth == ext2_params->bfZe3ddWidth);
760 EXPECT_TRUE(ext2_result->bfZe3dd == ext2_params->bfZe3dd);
763 EXPECT_TRUE(ext2_result->bfAzSI == ext2_params->bfAzSI);
764 EXPECT_TRUE(ext2_result->bfZeSI == ext2_params->bfZeSI);
768 case XRAN_CP_SECTIONEXTCMD_3:
770 struct xran_sectionext3_info *ext3_params, *ext3_result;
772 ext3_params = (struct xran_sectionext3_info *)m_params.sections[i].exData[j].data;
773 ext3_result = &m_result.sections[i].exts[j].u.ext3;
775 EXPECT_TRUE(ext3_result->layerId == ext3_params->layerId);
776 EXPECT_TRUE(ext3_result->codebookIdx== ext3_params->codebookIdx);
777 EXPECT_TRUE(ext3_result->numLayers == ext3_params->numLayers);
779 if(ext3_params->layerId == XRAN_LAYERID_0
780 || ext3_params->layerId == XRAN_LAYERID_TXD) { /* first data layer */
781 EXPECT_TRUE(ext3_result->txScheme == ext3_params->txScheme);
782 EXPECT_TRUE(ext3_result->crsReMask == ext3_params->crsReMask);
783 EXPECT_TRUE(ext3_result->crsShift == ext3_params->crsShift);
784 EXPECT_TRUE(ext3_result->crsSymNum == ext3_params->crsSymNum);
786 EXPECT_TRUE(ext3_result->numAntPort == ext3_params->numAntPort);
788 EXPECT_TRUE(ext3_result->beamIdAP1 == ext3_params->beamIdAP1);
790 if(ext3_params->numAntPort == 4) {
791 EXPECT_TRUE(ext3_result->beamIdAP2 == ext3_params->beamIdAP2);
792 EXPECT_TRUE(ext3_result->beamIdAP3 == ext3_params->beamIdAP3);
798 case XRAN_CP_SECTIONEXTCMD_4:
800 struct xran_sectionext4_info *ext4_params, *ext4_result;
802 ext4_params = (struct xran_sectionext4_info *)m_params.sections[i].exData[j].data;
803 ext4_result = &m_result.sections[i].exts[j].u.ext4;
805 EXPECT_TRUE(ext4_result->csf == ext4_params->csf);
806 EXPECT_TRUE(ext4_result->modCompScaler == ext4_params->modCompScaler);
810 case XRAN_CP_SECTIONEXTCMD_5:
812 struct xran_sectionext5_info *ext5_params, *ext5_result;
815 ext5_params = (struct xran_sectionext5_info *)m_params.sections[i].exData[j].data;
816 ext5_result = &m_result.sections[i].exts[j].u.ext5;
818 EXPECT_TRUE(ext5_result->num_sets == ext5_params->num_sets);
819 for(idx=0; idx < ext5_params->num_sets; idx++) {
820 EXPECT_TRUE(ext5_result->mc[idx].csf == ext5_params->mc[idx].csf);
821 EXPECT_TRUE(ext5_result->mc[idx].mcScaleReMask == ext5_params->mc[idx].mcScaleReMask);
822 EXPECT_TRUE(ext5_result->mc[idx].mcScaleOffset == ext5_params->mc[idx].mcScaleOffset);
826 case XRAN_CP_SECTIONEXTCMD_6:
828 struct xran_sectionext6_info *ext6_params, *ext6_result;
830 ext6_params = (struct xran_sectionext6_info *)m_params.sections[i].exData[j].data;
831 ext6_result = &m_result.sections[i].exts[j].u.ext6;
833 EXPECT_TRUE(ext6_result->rbgSize == ext6_params->rbgSize);
834 EXPECT_TRUE(ext6_result->rbgMask == ext6_params->rbgMask);
835 EXPECT_TRUE(ext6_result->symbolMask == ext6_params->symbolMask);
838 case XRAN_CP_SECTIONEXTCMD_9:
840 struct xran_sectionext9_info *ext9_params, *ext9_result;
842 ext9_params = (struct xran_sectionext9_info *)m_params.sections[i].exData[j].data;
843 ext9_result = &m_result.sections[i].exts[j].u.ext9;
844 EXPECT_TRUE(ext9_result->technology == ext9_params->technology);
847 case XRAN_CP_SECTIONEXTCMD_10:
849 struct xran_sectionext10_info *ext10_params, *ext10_result;
852 ext10_params = (struct xran_sectionext10_info *)m_params.sections[i].exData[j].data;
853 ext10_result = &m_result.sections[i].exts[j].u.ext10;
855 EXPECT_TRUE(ext10_result->numPortc == ext10_params->numPortc);
856 EXPECT_TRUE(ext10_result->beamGrpType == ext10_params->beamGrpType);
857 if(ext10_result->beamGrpType == XRAN_BEAMGT_VECTORLIST) {
858 for(idx=0; idx < ext10_result->numPortc; idx++)
859 EXPECT_TRUE(ext10_result->beamID[idx] == ext10_params->beamID[idx]);
863 case XRAN_CP_SECTIONEXTCMD_11:
865 struct xran_sectionext11_info *ext11_params;
866 struct xran_sectionext11_recv_info *ext11_result;
868 ext11_params = (struct xran_sectionext11_info *)m_params.sections[i].exData[j].data;
869 ext11_result = &m_result.sections[i].exts[j].u.ext11;
871 EXPECT_TRUE(ext11_result->RAD == ext11_params->RAD);
872 EXPECT_TRUE(ext11_result->disableBFWs == ext11_params->disableBFWs);
873 EXPECT_TRUE(ext11_result->numBundPrb == ext11_params->numBundPrb);
874 EXPECT_TRUE(ext11_result->bfwCompMeth == ext11_params->bfwCompMeth);
875 EXPECT_TRUE(ext11_result->bfwIqWidth == ext11_params->bfwIqWidth);
878 EXPECT_TRUE(ext11_result->numSetBFWs == ext11_params->numSetBFWs);
879 for(k=0; k < ext11_result->numSetBFWs; k++) {
880 EXPECT_TRUE(ext11_result->bundInfo[k].beamId == m_bfwInfo[k].beamId);
882 EXPECT_TRUE(ext11_result->bundInfo[k].BFWSize == ext11_params->BFWSize);
884 if(ext11_result->bundInfo[k].pBFWs)
885 EXPECT_TRUE(memcmp(ext11_result->bundInfo[k].pBFWs,
886 ext11_params->bundInfo[k].pBFWs + ext11_params->bundInfo[k].offset + 4,
887 ext11_result->bundInfo[k].BFWSize) == 0);
888 switch(ext11_result->bfwCompMeth) {
889 case XRAN_BFWCOMPMETHOD_NONE:
892 case XRAN_BFWCOMPMETHOD_BLKFLOAT:
893 EXPECT_TRUE(ext11_result->bundInfo[k].bfwCompParam.exponent == ext11_params->bundInfo[k].bfwCompParam.exponent);
897 FAIL() << "Invalid BfComp method - %d" << ext11_result->bfwCompMeth << std::endl;
906 if(m_params.sections[i].info != NULL)
907 delete m_params.sections[i].info;
913 void C_plane::test_ext1(void)
918 int32_t nAntElm = 64;
920 int8_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
922 int8_t *p_ext1_dst = NULL;
923 int8_t *bfw_payload = NULL;
924 // int32_t expected_len = ((nAntElm/16*4*iqWidth)+1)*nRbs + /* bfwCompParam + IQ = */
925 // sizeof(struct xran_cp_radioapp_section_ext1)*nRbs; /* ext1 Headers */
927 int16_t ext_len = 9600;
928 int16_t ext_sec_total = 0;
929 int8_t * ext_buf = nullptr;
930 int8_t * ext_buf_init = nullptr;
932 struct xran_section_gen_info* loc_pSectGenInfo = m_params.sections;
933 struct xran_sectionext1_info m_prep_ext1;
934 struct xran_cp_radioapp_section_ext1 *p_ext1;
935 struct xran_cp_radioapp_section1 *p_section1;
936 struct rte_mbuf_ext_shared_info share_data;
937 struct rte_mbuf *mbuf = NULL;
938 struct xran_sectionext1_info ext1;
941 nAntElm = m_antElmTRx;
942 nRbs = m_params.sections[0].info->numPrbc;
943 iqWidth = m_extcfgs[0].u.ext1.bfwIqWidth;
944 compMethod = m_extcfgs[0].u.ext1.bfwCompMeth;
945 numSections = m_numSections;
949 case XRAN_BFWCOMPMETHOD_NONE:
950 // expected_len = (3+1)*nRbs + nAntElm*nRbs*4;
951 expected_len = sizeof(struct xran_cp_radioapp_section1)*numSections + \
952 sizeof(struct xran_cp_radioapp_section_ext1)*numSections + \
953 nAntElm*numSections*4;
955 case XRAN_BFWCOMPMETHOD_BLKFLOAT:
956 expected_len = ((nAntElm/16*iqWidth)+1)*numSections*4 + /* bfwCompParam + IQ = */
957 sizeof(struct xran_cp_radioapp_section1)*numSections + \
958 sizeof(struct xran_cp_radioapp_section_ext1)*numSections; /* ext1 Headers */
961 FAIL() << "Unsupported Compression Method - " << compMethod << std::endl;
965 if(loc_pSectGenInfo->info->type == XRAN_CP_SECTIONTYPE_1) {
966 ext_buf = ext_buf_init = (int8_t*) xran_malloc(ext_len);
968 ptr = m_p_bfw_iq_src;
970 for (idRb =0; idRb < nRbs*nAntElm*2; idRb++){
975 ext_buf += (RTE_PKTMBUF_HEADROOM +
976 sizeof (struct xran_ecpri_hdr) +
977 sizeof(struct xran_cp_radioapp_common_header));
979 ext_len -= (RTE_PKTMBUF_HEADROOM +
980 sizeof(struct xran_ecpri_hdr) +
981 sizeof(struct xran_cp_radioapp_common_header));
983 m_prb_ele = (xran_prb_elm *) xran_malloc(sizeof(struct xran_prb_elm));
985 m_prb_ele->bf_weight.bfwIqWidth = iqWidth;
986 m_prb_ele->bf_weight.bfwCompMeth = compMethod;
987 m_prb_ele->bf_weight.numSetBFWs = numSections;
988 m_prb_ele->bf_weight.nAntElmTRx = nAntElm;
989 ext_sec_total = xran_cp_populate_section_ext_1((int8_t *)ext_buf,
994 // ASSERT_TRUE(ext_sec_total == expected_len);
995 p_ext1_dst = ext_buf;
997 memset(&m_temp_ext1[0], 0, sizeof (struct xran_sectionext1_info)*XRAN_MAX_PRBS);
1001 p_section1 = (struct xran_cp_radioapp_section1 *)p_ext1_dst;
1002 p_ext1 = (struct xran_cp_radioapp_section_ext1 *)(p_section1+1);
1003 bfw_payload = (int8_t*)(p_ext1+1);
1004 m_pSectGenInfo[idRb].info->id = idRb;
1006 m_pSectGenInfo[idRb].exData[0].type = XRAN_CP_SECTIONEXTCMD_1;
1007 m_pSectGenInfo[idRb].exData[0].len = sizeof(ext1);
1010 m_pSectGenInfo[idRb].info->ef = 1;
1011 m_pSectGenInfo[idRb].exDataSize = 1;
1013 p_ext1_dst += sizeof(struct xran_cp_radioapp_section1) /*+ sizeof(struct xran_cp_radioapp_section_ext1)*/ + p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;
1015 m_temp_ext1[0].bfwNumber = nAntElm;
1016 m_temp_ext1[0].bfwIqWidth = iqWidth;
1017 m_temp_ext1[0].bfwCompMeth = compMethod;
1018 m_temp_ext1[0].p_bfwIQ = (int8_t*)bfw_payload;
1019 m_temp_ext1[0].bfwIQ_sz = p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;
1020 if(compMethod == XRAN_BFWCOMPMETHOD_BLKFLOAT) {
1021 m_temp_ext1[0].bfwCompParam.exponent = *bfw_payload++ & 0xF;
1023 m_pSectGenInfo[idRb].exData[0].data = &m_temp_ext1[0];
1025 } while(idRb < numSections); /*p_ext1->ef != XRAN_EF_F_LAST);*/
1027 ASSERT_TRUE(idRb == numSections);
1029 mbuf = xran_attach_cp_ext_buf(0, ext_buf_init, ext_buf, ext_sec_total, &share_data);
1030 m_params.numSections = numSections;
1032 /* Generating C-Plane packet */
1033 ASSERT_TRUE(xran_prepare_ctrl_pkt(/*m_pTestBuffer*/mbuf, &m_params, m_ccId, m_antId, m_seqId, 0) == XRAN_STATUS_SUCCESS);
1034 EXPECT_TRUE(xran_parse_cp_pkt(/*m_pTestBuffer*/mbuf, &m_result, &m_pktInfo, (void *)&m_xran_dev_ctx, &mb_free) == XRAN_STATUS_SUCCESS);
1037 FAIL() << "xran_malloc failed\n";
1040 /* Verify the result */
1044 xran_free(ext_buf_init);
1048 /***************************************************************************
1049 * Functional Test cases
1050 ***************************************************************************/
1052 TEST_P(C_plane, CPacketGen)
1054 /* Configure section information */
1055 if(prepare_sections() < 0) {
1056 FAIL() << "Invalid Section configuration\n";
1058 if(prepare_extensions() < 0) {
1059 FAIL() << "Invalid Section extension configuration\n";
1062 if(m_extcfgs[0].type == XRAN_CP_SECTIONEXTCMD_1) {
1066 else if(m_extcfgs[0].type == XRAN_CP_SECTIONEXTCMD_11) {
1067 /* use large buffer to linearize external buffer for parsing */
1068 m_pTestBuffer = xran_ethdi_mbuf_alloc();
1069 ASSERT_FALSE(m_pTestBuffer == nullptr);
1071 if(xran_cp_attach_ext_buf(m_pTestBuffer,
1073 m_extcfgs[0].u.ext11.maxExtBufSize,
1074 &m_extSharedInfo) < 0) {
1075 rte_pktmbuf_free(m_pTestBuffer);
1076 m_pTestBuffer = nullptr;
1077 FAIL() << "Failed to attach external buffer !!\n";
1079 rte_mbuf_ext_refcnt_update(&m_extSharedInfo, 0);
1083 if(m_pTestBuffer == nullptr) {
1084 m_pTestBuffer = xran_ethdi_mbuf_alloc();
1085 ASSERT_FALSE(m_pTestBuffer == nullptr);
1088 xran_cp_init_sectiondb((void *)&m_xran_dev_ctx);
1089 /* Generating C-Plane packet */
1090 ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId, 0) == XRAN_STATUS_SUCCESS);
1092 /* Linearize data in the chain of mbufs to parse generated packet*/
1093 ASSERT_TRUE(rte_pktmbuf_linearize(m_pTestBuffer) == 0);
1094 /* Parsing generated packet */
1095 EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo, (void *)&m_xran_dev_ctx, &mb_free) == XRAN_STATUS_SUCCESS);
1097 /* Verify the result */
1101 /***************************************************************************
1102 * Performance Test cases
1103 ***************************************************************************/
1105 TEST_P(C_plane, Perf)
1107 /* Configure section information */
1108 if(prepare_sections() < 0) {
1109 FAIL() << "Invalid Section configuration\n";
1111 if(prepare_extensions() < 0) {
1112 FAIL() << "Invalid Section extension configuration\n";
1115 xran_cp_init_sectiondb((void *)&m_xran_dev_ctx);
1116 /* using wrapper function to reset mbuf */
1117 performance("C", module_name,
1118 &xran_ut_prepare_cp, &m_params, m_ccId, m_antId, m_seqId, 0);
1123 INSTANTIATE_TEST_CASE_P(UnitTest, C_plane,
1124 testing::ValuesIn(get_sequence(C_plane::get_number_of_cases("C_Plane"))));