fhi_lib/test/test_xran/c_plane_tests.cc

   1 /******************************************************************************\r
   2 *\r
   3 *   Copyright (c) 2019 Intel.\r
   4 *\r
   5 *   Licensed under the Apache License, Version 2.0 (the "License");\r
   6 *   you may not use this file except in compliance with the License.\r
   7 *   You may obtain a copy of the License at\r
   8 *\r
   9 *       http://www.apache.org/licenses/LICENSE-2.0\r
  10 *\r
  11 *   Unless required by applicable law or agreed to in writing, software\r
  12 *   distributed under the License is distributed on an "AS IS" BASIS,\r
  13 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14 *   See the License for the specific language governing permissions and\r
  15 *   limitations under the License.\r
  16 *\r
  17 *******************************************************************************/\r
  18 \r
  19 \r
  20 #include "common.hpp"\r
  21 #include "xran_lib_wrap.hpp"\r
  22 #include "xran_common.h"\r
  23 #include "xran_fh_o_du.h"\r
  24 #include "ethdi.h"\r
  25 #include "ethernet.h"\r
  26 #include "xran_transport.h"\r
  27 #include "xran_cp_api.h"\r
  28 \r
  29 #include <stdint.h>\r
  30 \r
  31 \r
  32 const std::string module_name = "C-Plane";\r
  33 \r
  34 const uint8_t m_bitmask[] = { 0x00, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };\r
  35 \r
  36 extern "C"\r
  37 {\r
  38 \r
  39 /* wrapper function for performace tests to reset mbuf */\r
  40 int xran_ut_prepare_cp(struct rte_mbuf *mbuf, struct xran_cp_gen_params *params,\r
  41                         uint8_t cc_id, uint8_t ant_id, uint8_t seq_id)\r
  42 {\r
  43     rte_pktmbuf_reset(mbuf);\r
  44     return(xran_prepare_ctrl_pkt(mbuf, params, cc_id, ant_id, seq_id));\r
  45 }\r
  46 \r
  47 \r
  48 void cput_fh_rx_callback(void *pCallbackTag, xran_status_t status)\r
  49 {\r
  50     return;\r
  51 }\r
  52 \r
  53 void cput_fh_rx_prach_callback(void *pCallbackTag, xran_status_t status)\r
  54 {\r
  55     rte_pause();\r
  56 }\r
  57 \r
  58 } /* extern "C" */\r
  59 \r
  60 \r
  61 \r
  62 class C_plane: public KernelTests\r
  63 {\r
  64 private:\r
  65     struct xran_section_gen_info *m_pSectGenInfo = NULL;\r
  66     struct xran_section_gen_info *m_pSectResult = NULL;\r
  67 \r
  68 \r
  69 protected:\r
  70     int m_maxSections = 8;  /*  not used */\r
  71     int m_numSections;\r
  72 \r
  73     struct rte_mbuf *m_pTestBuffer;\r
  74 \r
  75     struct xran_cp_gen_params m_params;\r
  76     struct xran_recv_packet_info m_pktInfo;\r
  77     struct xran_cp_gen_params m_result;\r
  78 \r
  79     uint8_t     m_dir;\r
  80     std::string m_dirStr;\r
  81     uint8_t     m_sectionType;\r
  82 \r
  83     uint8_t     m_ccId, m_antId;\r
  84     uint8_t     m_seqId;\r
  85     uint8_t     m_frameId, m_subframeId, m_slotId;\r
  86     uint8_t     m_symStart, m_symNum;\r
  87     uint16_t    *m_prbStart = NULL, *m_prbNum = NULL;\r
  88 \r
  89     uint8_t     m_iqWidth, m_compMethod;\r
  90     uint16_t    m_beamId;\r
  91     uint16_t    m_reMask = 0xfff;\r
  92     uint16_t    m_sectionId;\r
  93     uint8_t     m_filterIndex;\r
  94     uint16_t    m_timeOffset;\r
  95     uint8_t     m_fftSize;\r
  96     uint8_t     m_scs;\r
  97     uint16_t    m_cpLength;\r
  98     int         m_freqOffset;\r
  99 \r
 100     uint16_t  m_ext1_dst_len = 0;\r
 101     int8_t   *m_p_ext1_dst   = NULL;\r
 102     int16_t  *m_p_bfw_iq_src = NULL;\r
 103 \r
 104     struct xran_sectionext1_info m_ext1;\r
 105     struct xran_sectionext2_info m_ext2;\r
 106     struct xran_sectionext4_info m_ext4;\r
 107     struct xran_sectionext5_info m_ext5;\r
 108 \r
 109     int16_t m_bfwIQ[XRAN_MAX_BFW_N*2];\r
 110 \r
 111 \r
 112     void SetUp() override\r
 113     {\r
 114         int i, j;\r
 115 \r
 116         init_test("C_Plane");\r
 117 \r
 118         m_numSections   = get_input_parameter<int>("num_sections");\r
 119         ASSERT_FALSE(m_numSections == 0);\r
 120 \r
 121         m_dirStr        = get_input_parameter<std::string>("direction");\r
 122 \r
 123         if(!m_dirStr.compare("DL")) m_dir = XRAN_DIR_DL;\r
 124         else if(!m_dirStr.compare("UL")) m_dir = XRAN_DIR_UL;\r
 125         else FAIL() << "Invalid direction!";\r
 126 \r
 127         m_sectionType   = get_input_parameter<uint8_t>("section_type");\r
 128         m_ccId          = get_input_parameter<uint8_t>("cc_id");\r
 129         m_antId         = get_input_parameter<uint8_t>("ant_id");\r
 130         m_seqId         = get_input_parameter<uint16_t>("seq_id");\r
 131 \r
 132         m_frameId       = get_input_parameter<uint8_t>("frame_id");\r
 133         m_subframeId    = get_input_parameter<uint8_t>("subframe_id");\r
 134         m_slotId        = get_input_parameter<uint8_t>("slot_id");\r
 135         m_symStart      = get_input_parameter<uint8_t>("symbol_start");\r
 136         m_compMethod    = get_input_parameter<uint8_t>("comp_method");\r
 137         m_iqWidth       = get_input_parameter<uint8_t>("iq_width");\r
 138 \r
 139         m_sectionId     = get_input_parameter<uint8_t>("section_id");\r
 140         m_symNum        = get_input_parameter<uint8_t>("symbol_num");\r
 141         m_beamId        = get_input_parameter<uint16_t>("beam_id");\r
 142 \r
 143         /* reading configurations of start prb and the number of prbs  */\r
 144         std::vector<int> prbstart = get_input_parameter<std::vector<int>>("prb_start");\r
 145         std::vector<int> prbnum = get_input_parameter<std::vector<int>>("prb_num");\r
 146         /* number of sections and  the pair of start/number of prb shall be matched */\r
 147         ASSERT_TRUE((m_numSections == prbstart.size())\r
 148                     && (m_numSections == prbnum.size())\r
 149                     && (prbstart.size() == prbnum.size()));\r
 150 \r
 151         m_prbStart  = new uint16_t [m_numSections];\r
 152         m_prbNum    = new uint16_t [m_numSections];\r
 153         for(i=0; i < m_numSections; i++) {\r
 154             m_prbStart[i] = prbstart[i];\r
 155             m_prbNum[i] = prbnum[i];\r
 156             }\r
 157 \r
 158         switch(m_sectionType) {\r
 159             case XRAN_CP_SECTIONTYPE_1:\r
 160                 m_filterIndex = XRAN_FILTERINDEX_STANDARD;\r
 161                 break;\r
 162 \r
 163             case XRAN_CP_SECTIONTYPE_3:\r
 164                 m_filterIndex   = get_input_parameter<uint8_t>("filter_index");\r
 165                 m_timeOffset    = get_input_parameter<uint16_t>("time_offset");\r
 166                 m_fftSize       = get_input_parameter<uint8_t>("fft_size");\r
 167                 m_scs           = get_input_parameter<uint8_t>("scs");\r
 168                 m_cpLength      = get_input_parameter<uint16_t>("cp_length");\r
 169                 m_freqOffset    = get_input_parameter<int>("freq_offset");\r
 170                 break;\r
 171 \r
 172             default:\r
 173                 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";\r
 174             }\r
 175 \r
 176         /* allocate and prepare required data storage */\r
 177         m_pSectGenInfo = new struct xran_section_gen_info [m_numSections];\r
 178         ASSERT_NE(m_pSectGenInfo, nullptr);\r
 179         m_params.sections = m_pSectGenInfo;\r
 180 \r
 181         m_pSectResult = new struct xran_section_gen_info [m_numSections];\r
 182         ASSERT_NE(m_pSectResult, nullptr);\r
 183         m_result.sections = m_pSectResult;\r
 184 \r
 185         m_ext1_dst_len   = 9600;\r
 186         m_p_ext1_dst   = new int8_t [m_ext1_dst_len];\r
 187         m_p_bfw_iq_src = new int16_t [9600/2];\r
 188 \r
 189         /* allocating an mbuf for packet generatrion */\r
 190         m_pTestBuffer = xran_ethdi_mbuf_alloc();\r
 191 \r
 192         ASSERT_FALSE(m_pTestBuffer == NULL);\r
 193     }\r
 194 \r
 195     void TearDown() override\r
 196     {\r
 197         int i, j;\r
 198 \r
 199         if(m_pTestBuffer != NULL)\r
 200             rte_pktmbuf_free(m_pTestBuffer);\r
 201 \r
 202         if(m_prbStart)\r
 203             delete[] m_prbStart;\r
 204         if(m_prbNum)\r
 205             delete[] m_prbNum;\r
 206 \r
 207         if(m_p_bfw_iq_src)\r
 208             delete[] m_p_bfw_iq_src;\r
 209 \r
 210         if(m_p_ext1_dst)\r
 211             delete[] m_p_ext1_dst;\r
 212 \r
 213         if(m_pSectGenInfo)\r
 214             delete[] m_pSectGenInfo;\r
 215 \r
 216         if(m_pSectResult) {\r
 217             delete[] m_pSectResult;\r
 218             }\r
 219 \r
 220     }\r
 221 \r
 222     int prepare_sections(bool extflag);\r
 223     int prepare_extensions(int sect_num);\r
 224     void verify_sections(void);\r
 225 \r
 226 };\r
 227 \r
 228 \r
 229 \r
 230 int C_plane::prepare_extensions(int sect_num)\r
 231 {\r
 232     int i, numext;\r
 233     int N;\r
 234 \r
 235 \r
 236     N = 8;\r
 237 \r
 238     // extension 1\r
 239     m_ext1.bfwNumber  = 4*N; // 4 ant, 8 UEs\r
 240     m_ext1.bfwiqWidth = 16;\r
 241     m_ext1.bfwCompMeth    = XRAN_BFWCOMPMETHOD_NONE;\r
 242                             /* XRAN_BFWCOMPMETHOD_BLKFLOAT\r
 243                              * XRAN_BFWCOMPMETHOD_BLKSCALE\r
 244                              * XRAN_BFWCOMPMETHOD_ULAW\r
 245                              * XRAN_BFWCOMPMETHOD_BEAMSPACE\r
 246                              */\r
 247     m_ext1.p_bfwIQ = m_bfwIQ;\r
 248 \r
 249     switch (m_ext1.bfwCompMeth) {\r
 250         case XRAN_BFWCOMPMETHOD_BLKFLOAT:\r
 251             m_ext1.bfwCompParam.exponent = 0xa;\r
 252             break;\r
 253         case XRAN_BFWCOMPMETHOD_BLKSCALE:\r
 254             m_ext1.bfwCompParam.blockScaler = 0xa5;\r
 255             break;\r
 256         case XRAN_BFWCOMPMETHOD_ULAW:\r
 257             m_ext1.bfwCompParam.compBitWidthShift = 0x55;\r
 258         case XRAN_BFWCOMPMETHOD_BEAMSPACE:\r
 259             for(i=0; i<N; i++)\r
 260                 m_ext1.bfwCompParam.activeBeamspaceCoeffMask[i] = 0xa0 + i;\r
 261             break;\r
 262         }\r
 263 \r
 264     for(i=0; i<N*4; i++) {\r
 265         m_ext1.p_bfwIQ[i*2]     = 0xcafe;\r
 266         m_ext1.p_bfwIQ[i*2+1]   = 0xbeef;\r
 267         }\r
 268 \r
 269     // extension 2\r
 270     m_ext2.bfAzPtWidth        = 7;\r
 271     m_ext2.bfAzPt             = 0x55 & m_bitmask[m_ext2.bfAzPtWidth];\r
 272     m_ext2.bfZePtWidth        = 7;\r
 273     m_ext2.bfZePt             = 0xaa & m_bitmask[m_ext2.bfAzPtWidth];\r
 274     m_ext2.bfAz3ddWidth       = 7;\r
 275     m_ext2.bfAz3dd            = 0x5a & m_bitmask[m_ext2.bfAzPtWidth];\r
 276     m_ext2.bfZe3ddWidth       = 7;\r
 277     m_ext2.bfZe3dd            = 0xa5 & m_bitmask[m_ext2.bfAzPtWidth];\r
 278     m_ext2.bfAzSI             = 0x2 & m_bitmask[3];\r
 279     m_ext2.bfZeSI             = 0x5 & m_bitmask[3];\r
 280 \r
 281     // extension 4\r
 282     m_ext4.csf                = 1;\r
 283     m_ext4.modCompScaler      = 0x5aa5;\r
 284 \r
 285     // extension 5\r
 286     m_ext5.num_sets = 2;\r
 287     for(i=0; i<m_ext5.num_sets; i++) {\r
 288         m_ext5.mc[i].csf              = i%2;\r
 289         m_ext5.mc[i].mcScaleReMask    = 0xa5a + i;\r
 290         m_ext5.mc[i].mcScaleOffset    = 0x5a5a + i;\r
 291         }\r
 292 \r
 293     numext = 0;\r
 294 \r
 295     m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_1;\r
 296     m_params.sections[sect_num].exData[numext].len  = sizeof(m_ext1);\r
 297     m_params.sections[sect_num].exData[numext].data = &m_ext1;\r
 298     numext++;\r
 299 \r
 300     m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_2;\r
 301     m_params.sections[sect_num].exData[numext].len  = sizeof(m_ext2);\r
 302     m_params.sections[sect_num].exData[numext].data = &m_ext2;\r
 303     numext++;\r
 304 \r
 305     m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_4;\r
 306     m_params.sections[sect_num].exData[numext].len  = sizeof(m_ext4);\r
 307     m_params.sections[sect_num].exData[numext].data = &m_ext4;\r
 308     numext++;\r
 309 \r
 310     m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_5;\r
 311     m_params.sections[sect_num].exData[numext].len  = sizeof(m_ext5);\r
 312     m_params.sections[sect_num].exData[numext].data = &m_ext5;\r
 313     numext++;\r
 314 \r
 315     m_params.sections[sect_num].exDataSize = numext;\r
 316 \r
 317     return (0);\r
 318 }\r
 319 \r
 320 int C_plane::prepare_sections(bool extflag)\r
 321 {\r
 322   int numsec;\r
 323 \r
 324 \r
 325     /* Preparing input data for packet generation */\r
 326     m_params.dir                  = m_dir;\r
 327     m_params.sectionType          = m_sectionType;\r
 328 \r
 329     m_params.hdr.filterIdx        = m_filterIndex;\r
 330     m_params.hdr.frameId          = m_frameId;\r
 331     m_params.hdr.subframeId       = m_subframeId;\r
 332     m_params.hdr.slotId           = m_slotId;\r
 333     m_params.hdr.startSymId       = m_symStart;\r
 334     m_params.hdr.iqWidth          = XRAN_CONVERT_IQWIDTH(m_iqWidth);\r
 335     m_params.hdr.compMeth         = m_compMethod;\r
 336 \r
 337     switch(m_sectionType) {\r
 338         case XRAN_CP_SECTIONTYPE_1:\r
 339             break;\r
 340 \r
 341         case XRAN_CP_SECTIONTYPE_3:\r
 342             m_params.hdr.timeOffset   = m_timeOffset;\r
 343             m_params.hdr.fftSize      = m_fftSize;\r
 344             m_params.hdr.scs          = m_scs;\r
 345             m_params.hdr.cpLength     = m_cpLength;\r
 346             break;\r
 347 \r
 348         default:\r
 349             return (-1);\r
 350         }\r
 351 \r
 352     for(numsec=0; numsec < m_numSections; numsec++) {\r
 353         m_params.sections[numsec].info.type         = m_params.sectionType;       // for database\r
 354         m_params.sections[numsec].info.startSymId   = m_params.hdr.startSymId;    // for database\r
 355         m_params.sections[numsec].info.iqWidth      = m_params.hdr.iqWidth;       // for database\r
 356         m_params.sections[numsec].info.compMeth     = m_params.hdr.compMeth;      // for database\r
 357         m_params.sections[numsec].info.id           = m_sectionId++;\r
 358         m_params.sections[numsec].info.rb           = XRAN_RBIND_EVERY;\r
 359         m_params.sections[numsec].info.symInc       = XRAN_SYMBOLNUMBER_NOTINC;\r
 360         m_params.sections[numsec].info.startPrbc    = m_prbStart[numsec];\r
 361         m_params.sections[numsec].info.numPrbc      = m_prbNum[numsec];\r
 362         m_params.sections[numsec].info.numSymbol    = m_symNum;\r
 363         m_params.sections[numsec].info.reMask       = m_reMask;\r
 364         m_params.sections[numsec].info.beamId       = m_beamId;\r
 365         switch(m_sectionType) {\r
 366             case XRAN_CP_SECTIONTYPE_1:\r
 367                 break;\r
 368 \r
 369             case XRAN_CP_SECTIONTYPE_3:\r
 370                 m_params.sections[numsec].info.freqOffset   = m_freqOffset;\r
 371                 break;\r
 372 \r
 373             default:\r
 374                 return (-1);\r
 375             }\r
 376 \r
 377         /* section extension */\r
 378         if(/*extflag == true*/0) {\r
 379             m_params.sections[numsec].info.ef       = 1;\r
 380             prepare_extensions(numsec);\r
 381             }\r
 382         else {\r
 383             m_params.sections[numsec].info.ef       = 0;\r
 384             m_params.sections[numsec].exDataSize    = 0;\r
 385             }\r
 386         }\r
 387 \r
 388     m_params.numSections        = numsec;\r
 389 \r
 390     return (0);\r
 391 }\r
 392 \r
 393 \r
 394 void C_plane::verify_sections(void)\r
 395 {\r
 396   int i,j;\r
 397 \r
 398     /* Verify the result */\r
 399     EXPECT_TRUE(m_result.dir            == m_params.dir);\r
 400     EXPECT_TRUE(m_result.sectionType    == m_params.sectionType);\r
 401 \r
 402     EXPECT_TRUE(m_result.hdr.filterIdx  == m_params.hdr.filterIdx);\r
 403     EXPECT_TRUE(m_result.hdr.frameId    == m_params.hdr.frameId);\r
 404     EXPECT_TRUE(m_result.hdr.subframeId == m_params.hdr.subframeId);\r
 405     EXPECT_TRUE(m_result.hdr.slotId     == m_params.hdr.slotId);\r
 406     EXPECT_TRUE(m_result.hdr.startSymId == m_params.hdr.startSymId);\r
 407     EXPECT_TRUE(m_result.hdr.iqWidth    == m_params.hdr.iqWidth);\r
 408     EXPECT_TRUE(m_result.hdr.compMeth   == m_params.hdr.compMeth);\r
 409 \r
 410     switch(m_sectionType) {\r
 411         case XRAN_CP_SECTIONTYPE_1:\r
 412             break;\r
 413 \r
 414         case XRAN_CP_SECTIONTYPE_3:\r
 415             EXPECT_TRUE(m_result.hdr.fftSize    == m_params.hdr.fftSize);\r
 416             EXPECT_TRUE(m_result.hdr.scs        == m_params.hdr.scs);\r
 417             EXPECT_TRUE(m_result.hdr.cpLength   == m_params.hdr.cpLength);\r
 418             break;\r
 419 \r
 420         default:\r
 421             FAIL() << "Invalid Section Type - " << m_sectionType << "\n";\r
 422         }\r
 423 \r
 424     ASSERT_TRUE(m_result.numSections    == m_params.numSections);\r
 425     for(i=0; i < m_result.numSections; i++) {\r
 426         EXPECT_TRUE(m_result.sections[i].info.id        == m_params.sections[i].info.id);\r
 427         EXPECT_TRUE(m_result.sections[i].info.rb        == XRAN_RBIND_EVERY);\r
 428         EXPECT_TRUE(m_result.sections[i].info.symInc    == XRAN_SYMBOLNUMBER_NOTINC);\r
 429         EXPECT_TRUE(m_result.sections[i].info.startPrbc == m_params.sections[i].info.startPrbc);\r
 430         EXPECT_TRUE(m_result.sections[i].info.numPrbc   == m_params.sections[i].info.numPrbc);\r
 431         EXPECT_TRUE(m_result.sections[i].info.numSymbol == m_params.sections[i].info.numSymbol);\r
 432         EXPECT_TRUE(m_result.sections[i].info.reMask    == m_params.sections[i].info.reMask);\r
 433         EXPECT_TRUE(m_result.sections[i].info.beamId    == m_params.sections[i].info.beamId);\r
 434         EXPECT_TRUE(m_result.sections[i].info.ef        == m_params.sections[i].info.ef);\r
 435 \r
 436         switch(m_sectionType) {\r
 437             case XRAN_CP_SECTIONTYPE_1:\r
 438                 break;\r
 439 \r
 440             case XRAN_CP_SECTIONTYPE_3:\r
 441                 EXPECT_TRUE(m_result.sections[i].info.freqOffset  == m_params.sections[i].info.freqOffset);\r
 442                 break;\r
 443 \r
 444             default:\r
 445                 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";\r
 446             }\r
 447 \r
 448         if(m_params.sections[i].info.ef) {\r
 449      //       printf("[%d] %d ==  %d\n",i,  m_result.sections[i].exDataSize, m_params.sections[i].exDataSize);\r
 450             EXPECT_TRUE(m_result.sections[i].exDataSize == m_params.sections[i].exDataSize);\r
 451 \r
 452             for(j=0; j < m_params.sections[i].exDataSize; j++) {\r
 453                 EXPECT_TRUE(m_result.sections[i].exData[j].type == m_params.sections[i].exData[j].type);\r
 454 \r
 455                 switch(m_params.sections[i].exData[j].type) {\r
 456                     case XRAN_CP_SECTIONEXTCMD_1:\r
 457                         {\r
 458                         struct xran_sectionext1_info *ext1_params, *ext1_result;\r
 459                         int iq_size, parm_size, N;\r
 460 \r
 461                         ext1_params = (struct xran_sectionext1_info *)m_params.sections[i].exData[j].data;\r
 462                         ext1_result = (struct xran_sectionext1_info *)m_result.sections[i].exData[j].data;\r
 463 \r
 464                         EXPECT_TRUE(ext1_result->bfwiqWidth == ext1_params->bfwiqWidth);\r
 465                         EXPECT_TRUE(ext1_result->bfwCompMeth    == ext1_params->bfwCompMeth);\r
 466 \r
 467                         N = ext1_params->bfwNumber;\r
 468                         switch(ext1_params->bfwCompMeth) {\r
 469                             case XRAN_BFWCOMPMETHOD_BLKFLOAT:\r
 470                                 EXPECT_TRUE(ext1_result->bfwCompParam.exponent == ext1_params->bfwCompParam.exponent);\r
 471                                 break;\r
 472 \r
 473                             case XRAN_BFWCOMPMETHOD_BLKSCALE:\r
 474                                 EXPECT_TRUE(ext1_result->bfwCompParam.blockScaler == ext1_params->bfwCompParam.blockScaler);\r
 475                                 break;\r
 476 \r
 477                             case XRAN_BFWCOMPMETHOD_ULAW:\r
 478                                 EXPECT_TRUE(ext1_result->bfwCompParam.compBitWidthShift == ext1_params->bfwCompParam.compBitWidthShift);\r
 479                                 break;\r
 480 \r
 481                             case XRAN_BFWCOMPMETHOD_BEAMSPACE:\r
 482                                 parm_size = N>>3; if(N%8) parm_size++; parm_size *= 8;\r
 483                                 EXPECT_TRUE(std::memcmp(ext1_result->bfwCompParam.activeBeamspaceCoeffMask, ext1_params->bfwCompParam.activeBeamspaceCoeffMask, parm_size));\r
 484                                 break;\r
 485                             }\r
 486 \r
 487                         /* Get the number of BF weights */\r
 488                         iq_size = N*ext1_params->bfwiqWidth*2;  // total in bits\r
 489                         parm_size = iq_size>>3;                 // total in bytes (/8)\r
 490                         if(iq_size%8) parm_size++;              // round up\r
 491                         EXPECT_TRUE(std::memcmp(ext1_result->p_bfwIQ, ext1_params->p_bfwIQ, parm_size));\r
 492 \r
 493                         }\r
 494                         break;\r
 495 \r
 496                     case XRAN_CP_SECTIONEXTCMD_2:\r
 497                         {\r
 498                         struct xran_sectionext2_info *ext2_params, *ext2_result;\r
 499 \r
 500                         ext2_params = (struct xran_sectionext2_info *)m_params.sections[i].exData[j].data;\r
 501                         ext2_result = (struct xran_sectionext2_info *)m_result.sections[i].exData[j].data;\r
 502 \r
 503                         if(ext2_params->bfAzPtWidth) {\r
 504                             EXPECT_TRUE(ext2_result->bfAzPtWidth    == ext2_params->bfAzPtWidth);\r
 505                             EXPECT_TRUE(ext2_result->bfAzPt         == ext2_params->bfAzPt);\r
 506                             }\r
 507 \r
 508                         if(ext2_params->bfZePtWidth) {\r
 509                             EXPECT_TRUE(ext2_result->bfZePtWidth    == ext2_params->bfZePtWidth);\r
 510                             EXPECT_TRUE(ext2_result->bfZePt         == ext2_params->bfZePt);\r
 511                             }\r
 512                         if(ext2_params->bfAz3ddWidth) {\r
 513                             EXPECT_TRUE(ext2_result->bfAz3ddWidth   == ext2_params->bfAz3ddWidth);\r
 514                             EXPECT_TRUE(ext2_result->bfAz3dd        == ext2_params->bfAz3dd);\r
 515                             }\r
 516                         if(ext2_params->bfZe3ddWidth) {\r
 517                             EXPECT_TRUE(ext2_result->bfZe3ddWidth   == ext2_params->bfZe3ddWidth);\r
 518                             EXPECT_TRUE(ext2_result->bfZe3dd        == ext2_params->bfZe3dd);\r
 519                             }\r
 520 \r
 521                         EXPECT_TRUE(ext2_result->bfAzSI == ext2_params->bfAzSI);\r
 522                         EXPECT_TRUE(ext2_result->bfZeSI == ext2_params->bfZeSI);\r
 523                         }\r
 524                         break;\r
 525 \r
 526                     case XRAN_CP_SECTIONEXTCMD_4:\r
 527                         {\r
 528                         struct xran_sectionext4_info *ext4_params, *ext4_result;\r
 529 \r
 530                         ext4_params = (struct xran_sectionext4_info *)m_params.sections[i].exData[j].data;\r
 531                         ext4_result = (struct xran_sectionext4_info *)m_result.sections[i].exData[j].data;\r
 532 \r
 533                         EXPECT_TRUE(ext4_result->csf            == ext4_params->csf);\r
 534                         EXPECT_TRUE(ext4_result->modCompScaler  == ext4_params->modCompScaler);\r
 535                         }\r
 536                         break;\r
 537                     case XRAN_CP_SECTIONEXTCMD_5:\r
 538                         {\r
 539                         struct xran_sectionext5_info *ext5_params, *ext5_result;\r
 540                         int idx;\r
 541 \r
 542                         ext5_params = (struct xran_sectionext5_info *)m_params.sections[i].exData[j].data;\r
 543                         ext5_result = (struct xran_sectionext5_info *)m_result.sections[i].exData[j].data;\r
 544 \r
 545                         EXPECT_TRUE(ext5_result->num_sets == ext5_params->num_sets);\r
 546                         for(idx=0; idx < ext5_params->num_sets; idx++) {\r
 547                             EXPECT_TRUE(ext5_result->mc[idx].csf == ext5_params->mc[idx].csf);\r
 548                             EXPECT_TRUE(ext5_result->mc[idx].mcScaleReMask == ext5_params->mc[idx].mcScaleReMask);\r
 549                             EXPECT_TRUE(ext5_result->mc[idx].mcScaleOffset == ext5_params->mc[idx].mcScaleOffset);\r
 550                             }\r
 551                         }\r
 552                         break;\r
 553                     }\r
 554                 }\r
 555             }\r
 556         }\r
 557 \r
 558     return;\r
 559 }\r
 560 \r
 561 \r
 562 /***************************************************************************\r
 563  * Functional Test cases\r
 564  ***************************************************************************/\r
 565 \r
 566 TEST_P(C_plane, Section_Ext1)\r
 567 {\r
 568     int i = 0, idRb;\r
 569     int32_t len = 0;\r
 570     int16_t *ptr = NULL;\r
 571     int32_t nRbs = 36;\r
 572     int32_t nAntElm = 32;\r
 573     int8_t  iqWidth = 16;\r
 574     int8_t  compMethod = XRAN_COMPMETHOD_NONE;\r
 575     int8_t  *p_ext1_dst  = NULL;\r
 576     int16_t *bfw_payload = NULL;\r
 577     int32_t expected_len = (3+1)*nRbs + nAntElm*nRbs*4;\r
 578 \r
 579     struct xran_section_gen_info* loc_pSectGenInfo = m_params.sections;\r
 580     struct xran_sectionext1_info m_ext1;\r
 581     struct xran_cp_radioapp_section_ext1 *p_ext1;\r
 582 \r
 583     /* Configure section information */\r
 584     if(prepare_sections(false) < 0) {\r
 585         FAIL() << "Invalid Section configuration\n";\r
 586     }\r
 587     ptr = m_p_bfw_iq_src;\r
 588 \r
 589     for (idRb =0; idRb < nRbs*nAntElm*2; idRb++){\r
 590         ptr[idRb] = i;\r
 591         i++;\r
 592     }\r
 593 \r
 594     len = xran_cp_populate_section_ext_1(m_p_ext1_dst,\r
 595                                          m_ext1_dst_len,\r
 596                                          m_p_bfw_iq_src,\r
 597                                          nRbs,\r
 598                                          nAntElm,\r
 599                                          iqWidth,\r
 600                                          compMethod);\r
 601 \r
 602     ASSERT_TRUE(len == expected_len);\r
 603 \r
 604     p_ext1_dst = m_p_ext1_dst;\r
 605     idRb = 0;\r
 606     do {\r
 607         p_ext1 = (struct xran_cp_radioapp_section_ext1 *)p_ext1_dst;\r
 608         bfw_payload = (int16_t*)(p_ext1+1);\r
 609         p_ext1_dst += p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;\r
 610         idRb++;\r
 611     }while(p_ext1->ef != XRAN_EF_F_LAST);\r
 612 \r
 613     ASSERT_TRUE(idRb == nRbs);\r
 614 \r
 615     /* Update section information */\r
 616     memset(&m_ext1, 0, sizeof (struct xran_sectionext1_info));\r
 617     m_ext1.bfwNumber      = nAntElm;\r
 618     m_ext1.bfwiqWidth     = iqWidth;\r
 619     m_ext1.bfwCompMeth    = compMethod;\r
 620     m_ext1.p_bfwIQ        = (int16_t*)m_p_ext1_dst;\r
 621     m_ext1.bfwIQ_sz       = len;\r
 622 \r
 623     loc_pSectGenInfo->exData[0].type = XRAN_CP_SECTIONEXTCMD_1;\r
 624     loc_pSectGenInfo->exData[0].len  = sizeof(m_ext1);\r
 625     loc_pSectGenInfo->exData[0].data = &m_ext1;\r
 626 \r
 627     loc_pSectGenInfo->info.ef       = 1;\r
 628     loc_pSectGenInfo->exDataSize    = 1;\r
 629 \r
 630     m_params.numSections    = 1;\r
 631 \r
 632     /* Generating C-Plane packet */\r
 633     ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);\r
 634 \r
 635     /* Parsing generated packet */\r
 636     EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);\r
 637 \r
 638     /* Verify the result */\r
 639     //verify_sections();\r
 640 }\r
 641 \r
 642 TEST_P(C_plane, Section_Ext1_9bit)\r
 643 {\r
 644     int i = 0, idRb;\r
 645     int32_t len = 0;\r
 646     int16_t *ptr = NULL;\r
 647     int32_t nRbs = 36;\r
 648     int32_t nAntElm = 32;\r
 649     int8_t  iqWidth = 9;\r
 650     int8_t  compMethod = XRAN_COMPMETHOD_BLKFLOAT;\r
 651     int8_t  *p_ext1_dst  = NULL;\r
 652     int16_t *bfw_payload = NULL;\r
 653     int32_t expected_len = ((nAntElm/16*4*iqWidth)+1)*nRbs + /* bfwCompParam + IQ = */\r
 654                             sizeof(struct xran_cp_radioapp_section_ext1)*nRbs; /* ext1 Headers */\r
 655 \r
 656     struct xran_section_gen_info* loc_pSectGenInfo = m_params.sections;\r
 657     struct xran_sectionext1_info m_ext1;\r
 658     struct xran_cp_radioapp_section_ext1 *p_ext1;\r
 659 \r
 660     /* Configure section information */\r
 661     if(prepare_sections(false) < 0) {\r
 662         FAIL() << "Invalid Section configuration\n";\r
 663     }\r
 664     ptr = m_p_bfw_iq_src;\r
 665 \r
 666     for (idRb =0; idRb < nRbs*nAntElm*2; idRb++){\r
 667         ptr[idRb] = i;\r
 668         i++;\r
 669     }\r
 670 \r
 671     len = xran_cp_populate_section_ext_1(m_p_ext1_dst,\r
 672                                          m_ext1_dst_len,\r
 673                                          m_p_bfw_iq_src,\r
 674                                          nRbs,\r
 675                                          nAntElm,\r
 676                                          iqWidth,\r
 677                                          compMethod);\r
 678 \r
 679     ASSERT_TRUE(len == expected_len);\r
 680 \r
 681     p_ext1_dst = m_p_ext1_dst;\r
 682     idRb = 0;\r
 683     do {\r
 684         p_ext1 = (struct xran_cp_radioapp_section_ext1 *)p_ext1_dst;\r
 685         bfw_payload = (int16_t*)(p_ext1+1);\r
 686         p_ext1_dst += p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;\r
 687         idRb++;\r
 688     }while(p_ext1->ef != XRAN_EF_F_LAST);\r
 689 \r
 690     ASSERT_TRUE(idRb == nRbs);\r
 691 \r
 692     /* Update section information */\r
 693     memset(&m_ext1, 0, sizeof (struct xran_sectionext1_info));\r
 694     m_ext1.bfwNumber      = nAntElm;\r
 695     m_ext1.bfwiqWidth     = iqWidth;\r
 696     m_ext1.bfwCompMeth    = compMethod;\r
 697     m_ext1.p_bfwIQ        = (int16_t*)m_p_ext1_dst;\r
 698     m_ext1.bfwIQ_sz       = len;\r
 699 \r
 700     loc_pSectGenInfo->exData[0].type = XRAN_CP_SECTIONEXTCMD_1;\r
 701     loc_pSectGenInfo->exData[0].len  = sizeof(m_ext1);\r
 702     loc_pSectGenInfo->exData[0].data = &m_ext1;\r
 703 \r
 704     loc_pSectGenInfo->info.ef       = 1;\r
 705     loc_pSectGenInfo->exDataSize    = 1;\r
 706 \r
 707     m_params.numSections    = 1;\r
 708 \r
 709     /* Generating C-Plane packet */\r
 710     ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);\r
 711 \r
 712     /* Parsing generated packet */\r
 713     EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);\r
 714 \r
 715     /* Verify the result */\r
 716     //verify_sections();\r
 717 }\r
 718 \r
 719 \r
 720 \r
 721 TEST_P(C_plane, PacketGen)\r
 722 {\r
 723   int i;\r
 724 \r
 725 \r
 726     /* Configure section information */\r
 727     if(prepare_sections(false) < 0) {\r
 728         FAIL() << "Invalid Section configuration\n";\r
 729         }\r
 730 \r
 731     /* Generating C-Plane packet */\r
 732     ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);\r
 733 \r
 734     /* Parsing generated packet */\r
 735     EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);\r
 736 \r
 737     /* Verify the result */\r
 738     verify_sections();\r
 739 }\r
 740 \r
 741 \r
 742 TEST_P(C_plane, PacketGen_Ext)\r
 743 {\r
 744   int i;\r
 745 \r
 746 \r
 747     /* Configure section information */\r
 748     if(prepare_sections(true) < 0) {\r
 749         FAIL() << "Invalid Section configuration\n";\r
 750         }\r
 751 \r
 752     /* Generating C-Plane packet */\r
 753     ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);\r
 754 \r
 755     /* Parsing generated packet */\r
 756     EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);\r
 757 \r
 758     /* Verify the result */\r
 759     verify_sections();\r
 760 }\r
 761 \r
 762 \r
 763 /***************************************************************************\r
 764  * Performance Test cases\r
 765  ***************************************************************************/\r
 766 TEST_P(C_plane, Perf)\r
 767 {\r
 768     /* Configure section information */\r
 769     if(prepare_sections(false) < 0) {\r
 770         FAIL() << "Invalid Section configuration\n";\r
 771         }\r
 772 \r
 773     /* using wrapper function to reset mbuf */\r
 774     performance("C", module_name,\r
 775             &xran_ut_prepare_cp, m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId);\r
 776 }\r
 777 \r
 778 TEST_P(C_plane, Perf_Ext)\r
 779 {\r
 780     /* Configure section information */\r
 781     if(prepare_sections(true) < 0) {\r
 782         FAIL() << "Invalid Section configuration\n";\r
 783         }\r
 784 \r
 785     /* using wrapper function to reset mbuf */\r
 786     performance("C", module_name,\r
 787             &xran_ut_prepare_cp, m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId);\r
 788 }\r
 789 \r
 790 \r
 791 INSTANTIATE_TEST_CASE_P(UnitTest, C_plane,\r
 792         testing::ValuesIn(get_sequence(C_plane::get_number_of_cases("C_Plane"))));\r
 793 \r