1 /******************************************************************************
\r
3 * Copyright (c) 2019 Intel.
\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
9 * http://www.apache.org/licenses/LICENSE-2.0
\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
17 *******************************************************************************/
\r
20 * @brief XRAN layer common functionality for both O-DU and O-RU as well as C-plane and
\r
22 * @file xran_common.c
\r
23 * @ingroup group_source_xran
\r
24 * @author Intel Corporation
\r
29 #include <arpa/inet.h>
\r
30 #include <sys/time.h>
\r
33 #include "xran_common.h"
\r
35 #include "xran_pkt.h"
\r
36 #include "xran_pkt_up.h"
\r
37 #include "xran_up_api.h"
\r
38 #include "xran_lib_mlog_tasks_id.h"
\r
40 #include "../src/xran_printf.h"
\r
41 #include <rte_mbuf.h>
\r
42 #include "xran_mlog_lnx.h"
\r
44 #define MBUFS_CNT 16
\r
46 extern long interval_us;
\r
48 extern int xran_process_rx_sym(void *arg,
\r
49 struct rte_mbuf *mbuf,
\r
50 void *iq_data_start,
\r
55 uint8_t subframe_id,
\r
59 uint16_t start_prbu,
\r
66 extern int xran_process_prach_sym(void *arg,
\r
67 struct rte_mbuf *mbuf,
\r
68 void *iq_data_start,
\r
73 uint8_t subframe_id,
\r
77 uint16_t start_prbu,
\r
83 extern int32_t xran_process_srs_sym(void *arg,
\r
84 struct rte_mbuf *mbuf,
\r
85 void *iq_data_start,
\r
90 uint8_t subframe_id,
\r
94 uint16_t start_prbu,
\r
100 extern int32_t xran_pkt_validate(void *arg,
\r
101 struct rte_mbuf *mbuf,
\r
102 void *iq_data_start,
\r
107 uint8_t subframe_id,
\r
110 struct ecpri_seq_id *seq_id,
\r
112 uint16_t start_prbu,
\r
117 long rx_counter = 0;
\r
118 long tx_counter = 0;
\r
119 long tx_bytes_counter = 0;
\r
120 long rx_bytes_counter = 0;
\r
121 long tx_bytes_per_sec = 0;
\r
122 long rx_bytes_per_sec = 0;
\r
125 struct cb_elem_entry *xran_create_cb(XranSymCallbackFn cb_fn, void *cb_data)
\r
127 struct cb_elem_entry * cb_elm = (struct cb_elem_entry *)malloc(sizeof(struct cb_elem_entry));
\r
129 cb_elm->pSymCallback = cb_fn;
\r
130 cb_elm->pSymCallbackTag = cb_data;
\r
136 int xran_destroy_cb(struct cb_elem_entry * cb_elm)
\r
143 int process_mbuf(struct rte_mbuf *pkt)
\r
146 struct ecpri_seq_id seq;
\r
147 static int symbol_total_bytes = 0;
\r
149 struct xran_device_ctx * p_x_ctx = xran_dev_get_ctx();
\r
152 uint8_t Ant_ID = 0;
\r
153 uint8_t frame_id = 0;
\r
154 uint8_t subframe_id = 0;
\r
155 uint8_t slot_id = 0;
\r
156 uint8_t symb_id = 0;
\r
159 uint16_t start_prbu;
\r
164 uint8_t compMeth = 0;
\r
165 uint8_t iqWidth = 0;
\r
167 void *pHandle = NULL;
\r
168 uint8_t num_eAxc = xran_get_num_eAxc(pHandle);
\r
169 int ret = MBUF_FREE;
\r
170 uint32_t mb_free = 0;
\r
171 int32_t valid_res = 0;
\r
172 int expect_comp = (p_x_ctx->fh_cfg.ru_conf.compMeth != XRAN_COMPMETHOD_NONE);
\r
175 if(p_x_ctx->xran2phy_mem_ready == 0)
\r
178 num_bytes = xran_extract_iq_samples(pkt,
\r
195 if (num_bytes <= 0){
\r
196 print_err("num_bytes is wrong [%d]\n", num_bytes);
\r
200 valid_res = xran_pkt_validate(NULL,
\r
217 if(valid_res != 0) {
\r
218 print_err("valid_res is wrong [%d] ant %u (%u : %u : %u : %u) seq %u num_bytes %d\n", valid_res, Ant_ID, frame_id, subframe_id, slot_id, symb_id, seq.seq_id, num_bytes);
\r
222 if (Ant_ID >= p_x_ctx->srs_cfg.eAxC_offset && p_x_ctx->fh_init.srsEnable) {
\r
223 /* SRS packet has ruportid = 2*num_eAxc + ant_id */
\r
224 Ant_ID -= p_x_ctx->srs_cfg.eAxC_offset;
\r
225 symbol_total_bytes += num_bytes;
\r
227 if (seq.e_bit == 1) {
\r
228 print_dbg("Completed receiving symbol %d, size=%d bytes\n",
\r
229 symb_id, symbol_total_bytes);
\r
231 if (symbol_total_bytes) {
\r
232 int16_t res = xran_process_srs_sym(NULL,
\r
249 if(res == symbol_total_bytes) {
\r
252 print_err("res != symbol_total_bytes\n");
\r
255 symbol_total_bytes = 0;
\r
258 print_dbg("Transport layer fragmentation (eCPRI) is not supported\n");
\r
261 } else if (Ant_ID >= p_x_ctx->PrachCPConfig.eAxC_offset && p_x_ctx->fh_init.prachEnable) {
\r
262 /* PRACH packet has ruportid = num_eAxc + ant_id */
\r
263 Ant_ID -= p_x_ctx->PrachCPConfig.eAxC_offset;
\r
264 symbol_total_bytes += num_bytes;
\r
265 if (seq.e_bit == 1) {
\r
266 print_dbg("Completed receiving PRACH symbol %d, size=%d bytes\n",
\r
267 symb_id, num_bytes);
\r
269 if (symbol_total_bytes) {
\r
270 int16_t res = xran_process_prach_sym(NULL,
\r
286 if(res == symbol_total_bytes) {
\r
289 print_err("res != symbol_total_bytes\n");
\r
292 symbol_total_bytes = 0;
\r
294 print_dbg("Transport layer fragmentation (eCPRI) is not supported\n");
\r
297 } else { /* PUSCH */
\r
298 symbol_total_bytes += num_bytes;
\r
300 if (seq.e_bit == 1) {
\r
301 print_dbg("Completed receiving symbol %d, size=%d bytes\n",
\r
302 symb_id, symbol_total_bytes);
\r
304 if (symbol_total_bytes) {
\r
305 int res = xran_process_rx_sym(NULL,
\r
308 symbol_total_bytes,
\r
321 if(res == symbol_total_bytes) {
\r
324 print_err("res != symbol_total_bytes\n");
\r
327 symbol_total_bytes = 0;
\r
329 print_dbg("Transport layer fragmentation (eCPRI) is not supported\n");
\r
336 static int set_iq_bit_width(uint8_t iq_bit_width, struct data_section_compression_hdr *compr_hdr)
\r
338 if (iq_bit_width == MAX_IQ_BIT_WIDTH)
\r
339 compr_hdr->ud_comp_hdr.ud_iq_width = (uint8_t) 0;
\r
341 compr_hdr->ud_comp_hdr.ud_iq_width = iq_bit_width;
\r
347 /* Send a single 5G symbol over multiple packets */
\r
348 int32_t prepare_symbol_ex(enum xran_pkt_dir direction,
\r
349 uint16_t section_id,
\r
350 struct rte_mbuf *mb,
\r
351 struct rb_map *data,
\r
354 const enum xran_input_byte_order iq_buf_byte_order,
\r
356 uint8_t subframe_id,
\r
362 uint8_t RU_Port_ID,
\r
366 int32_t n_bytes = ((prb_num == 0) ? MAX_N_FULLBAND_SC : prb_num) * N_SC_PER_PRB * sizeof(struct rb_map);
\r
368 n_bytes = ((iqWidth == 0) || (iqWidth == 16)) ? n_bytes : ((3 * iqWidth + 1 ) * prb_num);
\r
370 int32_t prep_bytes;
\r
372 int16_t nPktSize = sizeof(struct ether_hdr) + sizeof(struct xran_ecpri_hdr) +
\r
373 sizeof(struct radio_app_common_hdr)+ sizeof(struct data_section_hdr) + n_bytes;
\r
375 struct xran_up_pkt_gen_params xp = { 0 };
\r
377 if(compMeth != XRAN_COMPMETHOD_NONE)
\r
378 nPktSize += sizeof(struct data_section_compression_hdr);
\r
380 n_bytes = RTE_MIN(n_bytes, XRAN_MAX_MBUF_LEN);
\r
382 /* radio app header */
\r
383 xp.app_params.data_direction = direction;
\r
384 xp.app_params.payl_ver = 1;
\r
385 xp.app_params.filter_id = 0;
\r
386 xp.app_params.frame_id = frame_id;
\r
387 xp.app_params.sf_slot_sym.subframe_id = subframe_id;
\r
388 xp.app_params.sf_slot_sym.slot_id = slot_id;
\r
389 xp.app_params.sf_slot_sym.symb_id = symbol_no;
\r
391 /* convert to network byte order */
\r
392 xp.app_params.sf_slot_sym.value = rte_cpu_to_be_16(xp.app_params.sf_slot_sym.value);
\r
394 xp.sec_hdr.fields.sect_id = section_id;
\r
395 xp.sec_hdr.fields.num_prbu = (uint8_t)prb_num;
\r
396 xp.sec_hdr.fields.start_prbu = (uint8_t)prb_start;
\r
397 xp.sec_hdr.fields.sym_inc = 0;
\r
398 xp.sec_hdr.fields.rb = 0;
\r
401 xp.compr_hdr_param.ud_comp_hdr.ud_comp_meth = compMeth;
\r
402 xp.compr_hdr_param.ud_comp_hdr.ud_iq_width = iqWidth;
\r
403 xp.compr_hdr_param.rsrvd = 0;
\r
405 /* network byte order */
\r
406 xp.sec_hdr.fields.all_bits = rte_cpu_to_be_32(xp.sec_hdr.fields.all_bits);
\r
410 errx(1, "out of mbufs after %d packets", 1);
\r
413 prep_bytes = xran_prepare_iq_symbol_portion(mb,
\r
422 if (prep_bytes <= 0)
\r
423 errx(1, "failed preparing symbol");
\r
425 rte_pktmbuf_pkt_len(mb) = nPktSize;
\r
426 rte_pktmbuf_data_len(mb) = nPktSize;
\r
429 printf("Symbol %2d prep_bytes (%d packets, %d bytes)\n", symbol_no, i, n_bytes);
\r
435 /* Send a single 5G symbol over multiple packets */
\r
436 int send_symbol_ex(enum xran_pkt_dir direction,
\r
437 uint16_t section_id,
\r
438 struct rte_mbuf *mb,
\r
439 struct rb_map *data,
\r
440 const enum xran_input_byte_order iq_buf_byte_order,
\r
442 uint8_t subframe_id,
\r
448 uint8_t RU_Port_ID,
\r
451 uint32_t do_copy = 0;
\r
452 int32_t n_bytes = ((prb_num == 0) ? MAX_N_FULLBAND_SC : prb_num) * N_SC_PER_PRB * sizeof(struct rb_map);
\r
453 struct xran_device_ctx *p_x_ctx = xran_dev_get_ctx();
\r
456 char * pChar = NULL;
\r
457 mb = xran_ethdi_mbuf_alloc(); /* will be freede by ETH */
\r
460 errx(1, "out of mbufs after %d packets", 1);
\r
462 pChar = rte_pktmbuf_append(mb, sizeof(struct xran_ecpri_hdr)+ sizeof(struct radio_app_common_hdr)+ sizeof(struct data_section_hdr) + n_bytes);
\r
465 errx(1, "incorrect mbuf size %d packets", 1);
\r
467 pChar = rte_pktmbuf_prepend(mb, sizeof(struct ether_hdr));
\r
470 errx(1, "incorrect mbuf size %d packets", 1);
\r
472 do_copy = 1; /* new mbuf hence copy of IQs */
\r
474 rte_pktmbuf_refcnt_update(mb, 1); /* make sure eth won't free our mbuf */
\r
477 int32_t sent = prepare_symbol_ex(direction,
\r
497 tx_bytes_counter += rte_pktmbuf_pkt_len(mb);
\r
498 p_x_ctx->send_upmbuf2ring(mb, ETHER_TYPE_ECPRI);
\r
504 printf("Symbol %2d sent (%d packets, %d bytes)\n", symbol_no, i, n_bytes);
\r
510 int send_cpmsg(void *pHandle, struct rte_mbuf *mbuf,struct xran_cp_gen_params *params,
\r
511 struct xran_section_gen_info *sect_geninfo, uint8_t cc_id, uint8_t ru_port_id, uint8_t seq_id)
\r
513 int ret = 0, nsection, i;
\r
514 uint8_t frame_id = params->hdr.frameId;
\r
515 uint8_t subframe_id = params->hdr.subframeId;
\r
516 uint8_t slot_id = params->hdr.slotId;
\r
517 uint8_t dir = params->dir;
\r
518 struct xran_device_ctx *p_x_ctx = xran_dev_get_ctx();
\r
520 nsection = params->numSections;
\r
522 /* add in the ethernet header */
\r
523 struct ether_hdr *const h = (void *)rte_pktmbuf_prepend(mbuf, sizeof(*h));
\r
525 tx_bytes_counter += rte_pktmbuf_pkt_len(mbuf);
\r
526 p_x_ctx->send_cpmbuf2ring(mbuf, ETHER_TYPE_ECPRI);
\r
527 for(i=0; i<nsection; i++)
\r
528 xran_cp_add_section_info(pHandle, dir, cc_id, ru_port_id,
\r
529 (slot_id + subframe_id*SLOTNUM_PER_SUBFRAME)%XRAN_MAX_SECTIONDB_CTX,
\r
530 §_geninfo[i].info);
\r
535 int generate_cpmsg_dlul(void *pHandle, struct xran_cp_gen_params *params, struct xran_section_gen_info *sect_geninfo, struct rte_mbuf *mbuf,
\r
536 enum xran_pkt_dir dir, uint8_t frame_id, uint8_t subframe_id, uint8_t slot_id,
\r
537 uint8_t startsym, uint8_t numsym, uint16_t prb_start, uint16_t prb_num,int16_t iq_buffer_offset, int16_t iq_buffer_len,
\r
538 uint16_t beam_id, uint8_t cc_id, uint8_t ru_port_id, uint8_t comp_method, uint8_t iqWidth, uint8_t seq_id, uint8_t symInc)
\r
540 int ret = 0, nsection, i, loc_sym;
\r
544 params->sectionType = XRAN_CP_SECTIONTYPE_1; // Most DL/UL Radio Channels
\r
545 params->hdr.filterIdx = XRAN_FILTERINDEX_STANDARD;
\r
546 params->hdr.frameId = frame_id;
\r
547 params->hdr.subframeId = subframe_id;
\r
548 params->hdr.slotId = slot_id;
\r
549 params->hdr.startSymId = startsym; // start Symbol ID
\r
550 params->hdr.iqWidth = iqWidth;
\r
551 params->hdr.compMeth = comp_method;
\r
554 sect_geninfo[nsection].info.type = params->sectionType; // for database
\r
555 sect_geninfo[nsection].info.startSymId = params->hdr.startSymId; // for database
\r
556 sect_geninfo[nsection].info.iqWidth = params->hdr.iqWidth; // for database
\r
557 sect_geninfo[nsection].info.compMeth = params->hdr.compMeth; // for database
\r
558 sect_geninfo[nsection].info.id = xran_alloc_sectionid(pHandle, dir, cc_id, ru_port_id, slot_id);
\r
559 sect_geninfo[nsection].info.rb = XRAN_RBIND_EVERY;
\r
560 sect_geninfo[nsection].info.symInc = symInc;
\r
561 sect_geninfo[nsection].info.startPrbc = prb_start;
\r
562 sect_geninfo[nsection].info.numPrbc = prb_num;
\r
563 sect_geninfo[nsection].info.numSymbol = numsym;
\r
564 sect_geninfo[nsection].info.reMask = 0xfff;
\r
565 sect_geninfo[nsection].info.beamId = beam_id;
\r
567 for (loc_sym = 0; loc_sym < XRAN_NUM_OF_SYMBOL_PER_SLOT; loc_sym++) {
\r
568 sect_geninfo[0].info.sec_desc[loc_sym].iq_buffer_offset = iq_buffer_offset;
\r
569 sect_geninfo[0].info.sec_desc[loc_sym].iq_buffer_len = iq_buffer_len;
\r
572 sect_geninfo[nsection].info.ef = 0;
\r
573 sect_geninfo[nsection].exDataSize = 0;
\r
574 // sect_geninfo[nsection].exData = NULL;
\r
577 params->numSections = nsection;
\r
578 params->sections = sect_geninfo;
\r
580 if(unlikely(mbuf == NULL)) {
\r
581 print_err("Alloc fail!\n");
\r
585 ret = xran_prepare_ctrl_pkt(mbuf, params, cc_id, ru_port_id, seq_id);
\r
587 print_err("Fail to build control plane packet - [%d:%d:%d] dir=%d\n",
\r
588 frame_id, subframe_id, slot_id, dir);
\r
589 rte_pktmbuf_free(mbuf);
\r
595 int generate_cpmsg_prach(void *pHandle, struct xran_cp_gen_params *params, struct xran_section_gen_info *sect_geninfo, struct rte_mbuf *mbuf, struct xran_device_ctx *pxran_lib_ctx,
\r
596 uint8_t frame_id, uint8_t subframe_id, uint8_t slot_id,
\r
597 uint16_t beam_id, uint8_t cc_id, uint8_t prach_port_id, uint8_t seq_id)
\r
599 int i, nsection, ret;
\r
600 struct xran_prach_cp_config *pPrachCPConfig = &(pxran_lib_ctx->PrachCPConfig);
\r
601 uint16_t timeOffset;
\r
602 uint16_t nNumerology = pxran_lib_ctx->fh_cfg.frame_conf.nNumerology;
\r
604 if(unlikely(mbuf == NULL)) {
\r
605 print_err("Alloc fail!\n");
\r
609 printf("%d:%d:%d:%d - filter=%d, startSym=%d[%d:%d], numSym=%d, occasions=%d, freqOff=%d\n",
\r
610 frame_id, subframe_id, slot_id, prach_port_id,
\r
611 pPrachCPConfig->filterIdx,
\r
612 pPrachCPConfig->startSymId,
\r
613 pPrachCPConfig->startPrbc,
\r
614 pPrachCPConfig->numPrbc,
\r
615 pPrachCPConfig->numSymbol,
\r
616 pPrachCPConfig->occassionsInPrachSlot,
\r
617 pPrachCPConfig->freqOffset);
\r
619 timeOffset = pPrachCPConfig->timeOffset; //this is the CP value per 38.211 tab 6.3.3.1-1&2
\r
620 timeOffset = timeOffset >> nNumerology; //original number is Tc, convert to Ts based on mu
\r
621 if (pPrachCPConfig->startSymId > 0)
\r
623 timeOffset += (pPrachCPConfig->startSymId * 2048) >> nNumerology;
\r
624 if ((slot_id == 0) || (slot_id == (SLOTNUM_PER_SUBFRAME >> 1)))
\r
627 params->dir = XRAN_DIR_UL;
\r
628 params->sectionType = XRAN_CP_SECTIONTYPE_3;
\r
629 params->hdr.filterIdx = pPrachCPConfig->filterIdx;
\r
630 params->hdr.frameId = frame_id;
\r
631 params->hdr.subframeId = subframe_id;
\r
632 params->hdr.slotId = slot_id;
\r
633 params->hdr.startSymId = pPrachCPConfig->startSymId;
\r
634 params->hdr.iqWidth = xran_get_conf_iqwidth(pHandle);
\r
635 params->hdr.compMeth = xran_get_conf_compmethod(pHandle);
\r
636 /* use timeOffset field for the CP length value for prach sequence */
\r
637 params->hdr.timeOffset = timeOffset;
\r
638 params->hdr.fftSize = xran_get_conf_fftsize(pHandle);
\r
639 params->hdr.scs = xran_get_conf_prach_scs(pHandle);
\r
640 params->hdr.cpLength = 0;
\r
643 sect_geninfo[nsection].info.type = params->sectionType; // for database
\r
644 sect_geninfo[nsection].info.startSymId = params->hdr.startSymId; // for database
\r
645 sect_geninfo[nsection].info.iqWidth = params->hdr.iqWidth; // for database
\r
646 sect_geninfo[nsection].info.compMeth = params->hdr.compMeth; // for database
\r
647 sect_geninfo[nsection].info.id = xran_alloc_sectionid(pHandle, XRAN_DIR_UL, cc_id, prach_port_id, slot_id);
\r
648 sect_geninfo[nsection].info.rb = XRAN_RBIND_EVERY;
\r
649 sect_geninfo[nsection].info.symInc = XRAN_SYMBOLNUMBER_NOTINC;
\r
650 sect_geninfo[nsection].info.startPrbc = pPrachCPConfig->startPrbc;
\r
651 sect_geninfo[nsection].info.numPrbc = pPrachCPConfig->numPrbc,
\r
652 sect_geninfo[nsection].info.numSymbol = pPrachCPConfig->numSymbol*pPrachCPConfig->occassionsInPrachSlot;
\r
653 sect_geninfo[nsection].info.reMask = 0xfff;
\r
654 sect_geninfo[nsection].info.beamId = beam_id;
\r
655 sect_geninfo[nsection].info.freqOffset = pPrachCPConfig->freqOffset;
\r
657 pxran_lib_ctx->prach_last_symbol[cc_id] = sect_geninfo[nsection].info.startSymId + sect_geninfo[nsection].info.numSymbol - 1;
\r
659 sect_geninfo[nsection].info.ef = 0;
\r
660 sect_geninfo[nsection].exDataSize = 0;
\r
661 // sect_geninfo[nsection].exData = NULL;
\r
664 params->numSections = nsection;
\r
665 params->sections = sect_geninfo;
\r
667 ret = xran_prepare_ctrl_pkt(mbuf, params, cc_id, prach_port_id, seq_id);
\r
669 print_err("Fail to build prach control packet - [%d:%d:%d]\n", frame_id, subframe_id, slot_id);
\r
670 rte_pktmbuf_free(mbuf);
\r
676 int process_ring(struct rte_ring *r)
\r
680 struct rte_mbuf *mbufs[MBUFS_CNT];
\r
682 uint32_t remaining;
\r
684 const uint16_t dequeued = rte_ring_dequeue_burst(r, (void **)mbufs,
\r
685 RTE_DIM(mbufs), &remaining);
\r
691 for (i = 0; i < dequeued; ++i) {
\r
692 if (xran_ethdi_filter_packet(mbufs[i], 0) == MBUF_FREE)
\r
693 rte_pktmbuf_free(mbufs[i]);
\r
695 MLogTask(PID_PROCESS_UP_PKT, t1, MLogTick());
\r
700 int32_t ring_processing_func(void)
\r
702 struct xran_ethdi_ctx *const ctx = xran_ethdi_get_ctx();
\r
703 struct xran_device_ctx *const pxran_lib_ctx = xran_dev_get_ctx();
\r
704 int16_t retPoll = 0;
\r
707 rte_timer_manage();
\r
710 if (process_ring(ctx->rx_ring[ETHDI_UP_VF]))
\r
713 if (process_ring(ctx->rx_ring[ETHDI_CP_VF]))
\r
716 if (pxran_lib_ctx->bbdev_dec) {
\r
718 retPoll = pxran_lib_ctx->bbdev_dec();
\r
722 MLogTask(PID_XRAN_BBDEV_UL_POLL + retPoll, t1, t2);
\r
726 if (pxran_lib_ctx->bbdev_enc) {
\r
728 retPoll = pxran_lib_ctx->bbdev_enc();
\r
732 MLogTask(PID_XRAN_BBDEV_DL_POLL + retPoll, t1, t2);
\r
736 if (XRAN_STOPPED == xran_if_current_state)
\r
742 int ring_processing_thread(void *args)
\r
744 struct sched_param sched_param;
\r
747 printf("%s [CPU %2d] [PID: %6d]\n", __FUNCTION__, rte_lcore_id(), getpid());
\r
748 sched_param.sched_priority = XRAN_THREAD_DEFAULT_PRIO;
\r
749 if ((res = pthread_setschedparam(pthread_self(), SCHED_FIFO, &sched_param))){
\r
750 printf("priority is not changed: coreId = %d, result1 = %d\n",rte_lcore_id(), res);
\r
754 if(ring_processing_func() != 0)
\r
757 puts("Pkt processing thread finished.");
\r