Higher aggregation of gNodeBs in Cloud-RAN architectures via parallel computing

TL;DR

This paper proposes a parallel computing approach to enhance gNodeB aggregation in Cloud-RAN architectures, improving latency and enabling more efficient virtualization of network functions.

Contribution

It introduces a dynamic multi-threading method for parallel processing of channel coding in Cloud-RAN, demonstrating significant latency reductions on a multi-core platform.

Findings

Latency improvements demonstrated on testbed

Enables increased gNodeB aggregation in edge data centers

Supports virtualization of real-time network functions

Abstract

In this paper, we address the virtualization and the centralization of real-time network functions, notably in the framework of Cloud RAN (C-RAN). We thoroughly analyze the required fronthaul capacity for the deployment of the proposed C-RAN architecture. We are specifically interested in the performance of the software based channel coding function. We develop a dynamic multi-threading approach to achieve parallel computing on a multi-core platform. Measurements from an OAI-based testbed show important gains in terms of latency; this enables the increase of the distance between the radio elements and the virtualized RAN functions and thus a higher aggregation of gNodeBs in edge data centers, referred to as Central Offices (COs).

Tables

Table 1. TABLE I: Required fronthaul capacity in a Cloud-RAN system for various cell bandwidths.

$B{W}_{cell}$	$1.4$	$3$	$5$	$10$	$15$	$20$
FS-I	$153.6$	$307.2$	$614.4$	$1228.8$	$1843.2$	$2457.6$
FS-II	$143.4$	$286.7$	$573.4$	$1146.9$	$1720.3$	$2293.8$
FS-III	$86.4$	$172.8$	$360.0$	$720.0$	$1080.0$	$1140.0$
FS-IV	$60.5$	$121.0$	$252.0$	$504.0$	$756.0$	$1008.0$
FS-V	$30.2$	$60.5$	$126.0$	$252.0$	$378.0$	$504.0$
FS-VI	$6.0$	$12.1$	$25.2$	$50.4$	$75.6$	$100.8$
FS-VII	$5.5$	$11.1$	$23.1$	$46.2$	$69.3$	$92.4$
$B{W}_{cell}$ [MHz], $FS-x$ [Mbps].

Table 2. TABLE II: List of parameters impacting the required fronthaul capacity.

Parameter	Description	Value
$B{W}_{sc}$	sub-carrier bandwidth	$15$ KHz
$B{W}_{LTE}$	LTE bandwidth	$1.4,3,5,10,15,20$ MHz
$B{W}_{uf}$	useful bandwidth	$18$ MHz ($20$MHz)
$f_c$	nominal chip rate	$3.84$ MHz
$f_s$	sampling frequency	e.g., $30.72$ MHz ($20$MHz)
$F_{coding}$	coding factor	$10/8$ or $66/64$
$F_{control}$	control factor	$16/15$ (CPRI)
$F_{oversampling}$	oversampling factor	$1.7$
$k$	code rate	e.g., $11/12$ [16]
$M$	number of bits per sample	$15$
$N_{ant}$	number of antennas for MIMO	e.g., $2x2$
$N_{FFT}$	number of FFT samples per OFDM symbol	e.g., $2048$ ($20$MHz)
$N_{RB}$	total number of resource blocks per subframe	e.g., $100$ ($20$MHz)
$N_{sc}$	total number of sub-carriers per subframe	e.g., $1200$ ($20$MHz)
$N_{sc-pRB}$	number of sub-carriers per resource block	$12$
$N_{sy-psl}$	number of symbols per time slot	$7$ (normal CP)
$N_{sy-psf}$	number of symbols per subframe	$14$ (normal CP)
$O_m$	modulation order	$2$-QPSK,$4$-16QAM,$6$-64QAM,$8$-256QAM
$\rho$	RBs utilization (mean cell-load)	$0.7$
$R_x$	data rate when using the x-th functional split
$T_{CP}$	average duration of a cyclic prefix	$4.76\mu$s (normal CP)
$T_s$	symbol duration	$66.67\mu$s (normal CP)
$T_{UD-psl}$	useful data duration per time slot	$466.67\mu$s (normal CP)

Equations

$$R_1$$

$$=2\ast M\ast N_{FFT}\ast B{W}_{sc}\ast F_{coding}\ast F_{control}\ast N_{ant},$$

$$\begin{gathered} R_2=2\ast M\ast N_{FFT}\ast (T_s+T_{CP}{)}^{-1}\ast F_{coding} \\ \ast F_{control}\ast N_{ant}, \end{gathered}$$

$$R_3$$

$$=2\ast M\ast N_{sc}\ast (T_s{)}^{-1}\ast F_{coding}\ast F_{control}\ast N_{ant}$$

$$R_4=2\ast M\ast N_{sc}\ast B{W}_{sc}\ast F_{coding}\ast F_{control}\ast N_{ant}\ast \rho$$

$$R_5=2\ast M\ast N_{sc}\ast B{W}_{sc}\ast F_{coding}\ast F_{control}\ast \rho$$

$$R_6=N_{sc}\ast N_{sy-psf}\ast O_m,$$

$$R_7=N_{sc}\ast N_{sy-psf}\ast O_m\ast k,$$

Full text

Keywords: NFV, Cloud-RAN, gNodeB, BBU, channel coding, OAI, multi-core, scheduling.

I Introduction

The next generation of mobile networks promises not only broadband communications and very high data rates but customized and optimized network services for specific vertical markets (e.g, Health, Automotive, Media and Entertainment) [1]. 5G mobile networks consider heterogeneous Radio Access Network (RAN) architectures for targeting different types of mobile access (WiFi, cellular femto, small, and macro cells) and for fulfilling service requirements especially in terms of latency, resilience, coverage, and bandwidth.

In the perspective of achieving specific end-to-end service performances, the virtualization of network functions is highly desirable to flexibly deploy network services in cloud infrastructures according to customer needs. For example, new RAN architectures aim at virtualizing and centralizing higher-RAN functions in the network while keeping lower-RAN functions in distributed units (near to antennas). These two nodes, respectively referred to as Central Unit (CU) and Distributed Unit (DU) by the 3GPP, enable flexible and scalable functional splits, which can be adapted to the required network performance. In addition, the collocation of CU with Mobile/Multi-access Edge Computing facilities opens the door to the realization of low latency services, thus meeting the strict requirements of URLLC (Ultra Reliable Low Latency Communications) identified by the 3GPP [2].

Centralizing RAN functions higher in the network however raises two main issues: low latency processing of radio signals (namely, base-band processing) and high capacity fiber-links in the fronthaul network. These two issues are addressed in the present work.

Given that channel coding processing (i.e., a physical-layer function) is the most consuming in terms of computing resources and also the most sensitive with regard to performance, in particular the robustness of selected codes against interference, it seems essential to keep this function in the CU. Via resource pooling, it is possible to achieve statistical multiplexing in the utilization of cores of a multi-core platform and thus to gain economies of scale while guaranteeing the deadline compliance in the execution of encoding/decoding functions. In addition, a global view of channel coding for several next-Generation Node Bs (gNBs) enables better radio resource management via the adaptation of coding to predictable interference and also Coordinated Multi-point (CoMP) technologies, i.e., interference reduction and better throughput.

In order to reduce fiber bandwidth requirements, we address in this work a bi-directional intra-PHY functional split which transmits both encoded and decoded data, in the downlink (DL) and uplink (UL) directions, respectively over Ethernet. In addition, we increase the fronthaul transmission time budget by improving the execution time of RAN functions.

The basic principle to accelerate RAN functions, i.e., to reduce latency, consists of parallelizing the coding and decoding functions, either on the basis of User Equipments (UEs) or Code Blocks (CBs). The CB is the smallest coding unit, which can be individually handled by the coding/decoding function of the RAN. The parallelization principles of channel coding are described in  [3, 4, 5]. In this paper, we go one step forward and focus on the implementation of the proposed thread-based models on a Commercial off-the-shelf (COTS) multi-core server by modifying the Open Air Interface (OAI) Evolved NodeB (eNB) (an open source solution) [6]. We report performance measurements from this platform by connecting the eNB to a second server supporting an OAI-based core network and by observing the traffic generated by UEs (commercial smart-phones), which are connected to the eNB via an USRP card.

We furthermore provide the required fronthaul bandwidth supporting the proposed C-RAN architecture and evaluate the various intra-PHY functional splits currently envisaged by 3GPP [7] and studied by eCPRI [8] and IEEE [9].

The organization of this paper is as follows: In Section II, we review the various functional splits considered in the literature and different solutions to reducing the time necessary to execute RAN functions. In Section III, we evaluate the bandwidth requirements for various functional splits and formulate a recommendation for the best option in our understanding. In Section IV, we describe the implementation of the multi-threading approach for the channel coding function in an OAI open source eNB. Performance results are reported in Section V. Concluding remarks are presented in Section VI.

II Related work

Forthcoming 5G standards consider the coexistence of several functional splits of C-RAN architectures. For instance, the 3GPP proposes eight options for splitting the E-UTRAN protocol at different levels. Each functional split meets the requirement of specific services. The most ambitious one (namely, the PHY-RF split which corresponds to option $8$ of 3GPP TR 38.801 Standard [7]) aims at a high level of centralization and coordination and enables efficient resource management of both radio (e.g., pooling of physical resources, CoMP technologies) and cloud resources (e.g, statistical multiplexing of the computing capacity). However, this configuration (here referred to as Functional Split (FS)**-I) brings some deployment issues, notably tight latency and high-bandwidth on fronthaul links.

In fact, there is an open debate concerning the adoption of the most appropriate fronthaul transmission protocol over fiber. The problem relies not only on the constant bit rate performed by the currently used Common Public Radio Interface (CPRI) [10] protocol but on the high redundancy present in the transmitted In-Phase Quadrature (I/Q) signals. Many efforts are currently being devoted to reducing optic/fiber resource consumption such as I/Q compression [11], non-linear quantization, sampling rate reduction among others. Incoming CPRI variants, notably those proposed by Ericsson et al. [8] perform CPRI packetization via IP or Ethernet. A similar approach to Radio over Ethernet (RoE) is being defined by the IEEE Next Generation fronthaul Interface (1914) working group [9]. It specifies the encapsulation of digitized radio I/Q payload for both control and user data. The xRAN Forum, which gathers industrials and network operators, is also producing an open specification for the fronthaul interface [12]. It considers intra-PHY splitting as defined by 3GPP in TR 38.801 [7]. A detailed fronthaul capacity analysis is addressed in Section III.

While numerous fronthaul solutions are being standardized, less attention is paid by the industry and academia to the runtime latency of virtualized RAN functions. First studies concerning the computing performance are presented in [13]. Authors compare the processing time of different virtualized environments, namely Linux Containers (LXC), Docker and Kernel-based Virtual Machine (KVM); however, the number of concurrent threads/cores per eNB is limited to $3$ since parallel processing of intra-sub-frame is not performed, i.e., a single-core is dedicated to the whole processing of an LTE sub-frame.

On the contrary, the multi-threading model presented in [4] performs data parallelism at a finer granularity, which enables an important latency reduction. The authors carry out an in-depth analysis of the workload and data structures handled during the base-band processing of the radio signals for both the DL [14] and UL [3] directions. Two multi-threading solutions are then proposed for the channel coding function, which is the most resource consuming. First, the sub-frame data is decomposed in smaller data structures so-called Transport Block (TB), which can be executed in parallel. A TB corresponds to the data of a single UE scheduled within one millisecond. It turns out that the runtime of the channel coding function (i.e., encoding in the DL and decoding in the UL) is directly proportional to the Transport Block Size (TBS). A finer breaking of sub-frames is also presented; it considers the execution of CB in parallel. A CB is the smallest data unit, which can be individually treated by the channel coding function. The behavior of both parallelism by UEs and parallelism by CB is evaluated by simulation and presents a gain up to $60\%$. In Section IV, we describe an implementation of the proposed schemes and give the performance results in Section V.

III Fronthaul capacity

III-A Problem formulation

One of the main issues of Cloud-RAN (C-RAN) is the required fiber bandwidth to transmit base band signals between the BBU-pool (namely, CU) and each antenna (namely, DU or Radio Remote Head (RRH)). The fronthaul capacity is determined by the number of base band units (one per gNB) hosted in the data center at the edge of the network (referred to as Central Office (CO)). The current widely used protocol for data transmission between antennas and Base Band Units (BBUs) is CPRI which transmits I/Q signals. The transmission rate is constant since CPRI is a serial Constant Bit Rate (CBR) interface. It is then independent of the mobile network load [10]. Several functional splits of the physical layer can then be analyzed in order to save fiber bandwidth [15, 10]. The required fronthaul capacity for the various functional splits is presented below.

III-B Required capacity per functional split

We have illustrated in Figure 1 the various functions executed in a classical RAN. For the downlink direction, IP data packets are first segmented by the PDCP and RLC layers. Then, the MAC layer determines the structure of the subframes (of 1 ms in LTE) forming frames of 10 ms to be transmitted to UEs. Once the MAC layer has fixed the allocation of Physical Resource Blocks (PRB) for the UEs, information is coded in the form of CBs. Then, remaining L1 functions are executed on the encoded data for their transmission (modulation, Fourier transform, giving rise to I/Q signals). In the uplink direction, the functions are executed in reverse order.

The functional split actually defines the centralization level of RAN functions in the cloud-platform, i.e., it determines which functions are processed in dedicated hardware near to antennas (DU) and those which are moved higher in the network to be executed in centralized data centers (CU).

The required fronthaul capacity significantly decreases when the functional split is shifted after the PHY layer or even after the MAC layer [15]. It is worth noting that new RAN implementations consider the coexistence of configurable functional splits where each of them is tailored to the requirements of a specific service or to a network slice. For instance, Ultra-Reliable Low-Latency Communications (URLLC) expects a one-millisecond round-trip latency between the UE and the gNB while enhanced Mobile Broad-Band (eMBB) requires only $4$ milliseconds.

In the following, we shall pay special attention to C-RAN supporting fully centralization. The required fronthaul capacity (given in Mbps) for all intra-PHY functional splits, (denoted, for short, by $FS-N$, $N$ ranging from 1 to 8) is presented in Table I as a function of the cell bandwidth $BW_{cell}$ (given in MHz).

Functional Split I

The fully centralized architecture (Option $8$ according to 3GPP), referred to in this paper as FS-I, only keeps in the DU the down-converter, filters and the Analogic-Digital Converter (ADC). I/Q signals are transmitted from and to the CU by using the CPRI standard. The problem of FS-I is in the fact that the required fronthaul capacity does not depend on the traffic in a cell but of the cell bandwidth. The required data rate per radio element is given by

[TABLE]

where the various variables are defined in Table II.

In Table I, we have computed the fronthaul capacity $R_{1}$ in function of the cell bandwidth. As the cell bandwidth increases, the required front haul capacity per sector can reach $2.4$ GBit/s. Since each site is generally equipped with three sectors, we can observe that the required bandwidth reaches prohibitive values for this functional split.

Functional Split II

When implementing the Cyclic Prefix (CP) removal in the DU, the fronthaul capacity can be reduced. This solution may experiment correlation problems due to the Inter-symbol interference (ISI) apparition. The required data rate for this functional split is given by

[TABLE]

where $T_{CP}$ is the average duration of a CP in a radio symbol. $T_{CP}=(500[us]-T_{s}[us]*7)/7=4.76191$ microseconds. $T_{s}=\frac{1}{BW_{sc}}=\frac{1}{15KHz}$. The useful data duration in a radio slot ($500$ microseconds) is given by $T_{UD-psl}=T_{s}*N_{sy-psl}=66.67*7=466.67$ microseconds. The resulting fronthaul capacity is given in Table I. The reduction in bandwidth requirement is rather small when compared with FS-I.

Functional Split III

By keeping the Fast Fourier Transform (FFT) function near to antennas the required fronthaul capacity can be considerably reduced. In this case, radio signals are transmitted in the frequency domain from radio elements to the CU for the uplink and vice versa for the downlink. This solution prevents from the overhead introduced when sampling the time domain signal. The oversampling factor is given by $F_{oversampling}=\frac{N_{FFT}}{N_{sc}}=~{}1.7$, e.g., $F_{oversampling}=512/300=1.71$ for an LTE bandwidth of $5$MHz. The corresponding fronthaul bit rate is then given by

[TABLE]

As illustrated in Table I, the fronthaul capacity is halved when compared with the initial CPRI solution. In the following, we show that the fronthaul capacity can still be reduced by a factor $10$.

Functional Split IV

When including the de-mapping process in the DU, it is possible to adapt the bandwidth as a function of the traffic load in the cell, then the required fronthaul capacity is directly given by the fraction of utilized radio resources [15].

Here, only the Resource Blocks (RBs), which carry information are transmitted. When considering the behavior of current deployed eNBs of the Orange mobile network serving a high-density zone (e.g, a train station), an eNB presents in average a RB utilization of $11.96\%$ and $20.69\%$ in the uplink and downlink directions, respectively. The highest utilization values observed in current deployed Orange’s eNBs do not exceed $70\%$ in the downlink direction. Thus, if we take $\rho=0.7$ as the mean cell-load (worst-case), this yields a fronthaul bit rate equal to

[TABLE]

Numerical values given in Table I show that the gain with respect to the previous solution is however rather small.

Functional Split V

This configuration presents a gain in the fronthaul load, when Multiple Input Multiple Output (MIMO) schemes are performed. The equalization function combines signals coming from multiple antennas; as a consequence, the required fronthaul capacity is divided by $N_{ant}$. The required front haul capacity is then given by

[TABLE]

Table I shows a drop by a factor $2$ with respect to the previous solution.

Functional Split VI

By keeping the demodulation/modulation function near to antennas, the required data rate is given by

[TABLE]

where $N_{sy-psf}$ is the number of symbols per subframe (i.e., $N_{sy-psf}=14$ when using normal cyclic prefix), $O_{m}$ is the modulation order, i.e., the number of bits per symbol. Taking the highest modulation order currently supported in the deployed networks, i.e, $O_{m}=6$, the required fronthaul capacity is reduced to $100$ Mbps. This represents a significant gain when compared to the initial CPRI (FS-I) solution. It is also worth noting that this solution preserves the gain achievable by C-RAN.

Functional Split VII

Just for the sake of completeness, we consider now the case when keeping the channel coding function near to antennas, redundancy bits are not transmitted. Nevertheless this configuration reduces the advantages of C-RAN. DUs become more complex and expensive. The required fronthaul capacity is

[TABLE]

where $k$ is the code rate, i.e., the ratio between the useful information and the transmitted information including redundancy. In LTE code rate $k$ commonly ranges from $1/12$ to $11/12$ [16]. In Table II, we use $k=11/12$ as the worst-case.

III-C Functional split selection

In view of the analysis carried out in the previous section, functional split VI seems to be the most appropriate. It is then necessary to encapsulate the fronthaul payload within Ethernet, i.e., distributed units are connected to the centralized ones through an Ethernet network. RoE is considered by IEEE Next Generation fronthaul Interface (1914) Working Group as well as by the xRAN fronthaul Working Group of the xRAN Forum.

The main issue of an Ethernet-based fronthaul is the latency fluctuation [17]. Transport jitter can be isolated by a buffer, however, the maximum transmission time is constrained by the processing time of centralized functions. The sum of both transmission and processing time must meet RAN requirements (i.e., $1$ ms for DL and $2$ ms for UL).

The transmission time can quickly rise due to the distance and the added latency at each hop (e.g., switches) in the network. The transmission time can be roughly obtained from the light-speed in the optic-fiber (e.g., $2.1$x$10^{8}$ m/s), and latency of $50\mu$s by hop [17]. For instance, the required transmission time for an gNB located $40$ km from the CO rises $280\mu$s$+50*8=680\mu$s. Hence, the remaining time-budget for BBU processing is barely $320\mu$s in the down-link direction. The proof-of-concept of C-RAN acceleration for supporting FS-VI is described below.

IV Testbed and parallelization of coding functions

IV-A Testbed description

To evaluate the proposed C-RAN acceleration method and notably the gain in terms of latency when parallelizing the channel coding, we have set up a testbed basically composed of $2$ servers (COTS PCs), one supporting the OAI EPC (MME, HSS, SPGW) and another equipped with an USRP card and implementing a modified version of the OAI eNB software. This testbed is illustrated in Figure 2.

The platform implements a pool of threads, which perform the parallel processing of both encoding (downlink) and decoding (uplink) functions on a multi-core server. The workload of threads is managed by a global non-preemptive scheduler (so-called, thread manager); a thread is assigned to a dedicated single core with real-time OS priority and is executed until completion without interruption. The isolation of threads is provided by a specific configuration performed in the OS, which prevents from the use of channel coding computing resources for any other job.

IV-B Implementation

The goal of our modification of OAI code is to perform massive parallelization of channel encoding and decoding processes. These functions are detailed below, before presenting the multi-threading mechanism and the scheduling algorithm.

Encoding function

The encoder (See Figure 3 for an illustration) consists of 2 Recursive Systematic Convolutional (RSC) codes separated by an inter-leaver. Before encoding, data (i.e., a subframe) are conditioned and segmented in code blocks of size $T$, which can be encoded in parallel. When the multi-threading model is not implemented, CBs are executed in series under a First In Firs Out (FIFO) discipline. Thus, an incoming data block $b_{i}$ is twice encoded, where the second encoder is preceded of the permutation procedure (inter-leaver). The encoded block $(b_{i},b_{i}^{\prime},b_{i}^{\prime\prime})$ of size $3T$ constitutes the information to be transmitted in the downlink direction. Hence, for each information bit two parity bits are added, i.e., the resulting code rate is given by $r=1/3$. With the aim of reducing the channel coding overhead, a puncturing procedure may be activated for periodically deleting bits. A multiplexer is finally employed to form the encoded block $x_{i}$ to be transmitted. The multiplexer is nothing but a parallel to serial converter which concatenates the systematic output $b_{i}$, and both recursive convolutional encoded output sequences, $b_{i}^{\prime}$, and $b_{i}^{\prime\prime}$.

Decoding function

Unlike encoding, the decoding function is iterative and works with soft bits (real and not binary values). Real values represent the Log-Likelihood Ratio (LLR), i.e., the radio of the probability that a particular bit was 1 and the probability that the same bit was 0 (log is used for better precision).

The decoding function runs as follows: Received data $R(x_{i})$ is firstly de-multiplexed in $R(b_{i})$, $R(b_{i})^{\prime}$, and $R(b_{i})^{\prime\prime}$, which correspond to the systematic information bits of $i$-th code block $b_{i}$ and to the received parity bits $b_{i}^{\prime}$ and $b_{i}^{\prime\prime}$, respectively.

$R(b_{i})$ and $R(b_{i})^{\prime}$ feed the first decoder which calculates the LLR (namely, extrinsic information) and passes it to the second decoder. The second decoder uses that value to calculate LLR and feeds back it to the first decoder after a de-interleaved process. Hence, the second decoder has three inputs, the extrinsic information (reliability value) from the first decoder, the interleaved received systematic information $R(b_{i})$, and the received values parity bits $R(b_{i})^{\prime\prime}$. See Figure 4 for an illustration.

The decoding procedure iterates until either the final solution is obtained or the allowed maximum number of iterations is reached. At termination, the final decision (i.e., [math] or $1$ decision) is taken to obtain the decoded data block $\widehat{x_{i}}$. The data block is either successfully decoded or not. The stopping criterion corresponds to the average mutual information of LLR; if it converges the decoding process may terminate earlier. Note that there is a trade-off between the runtime (i.e., number of iterations) and the successful decoding of a data block.

Thread-pool

On the basis of massive parallel programming, we propose splitting the channel encoding and decoding function in multiple parallel runnable jobs. The main goal is to improve their performance in terms of latency.

In order to deal with the various parallel runnable jobs, we implement a thread-pool, i.e., a multi-threading environment. A dedicated core is affected to each thread during the channel coding processing. When the number of runnable jobs exceeds the number of free threads, jobs are queued.

To achieve low latency, we implement multi-threading within a single process instead of multitasking across different processes (namely, multi-programming). In a real-time system, creating a new process on the fly becomes extremely expensive because all data structures must be allocated and initialized. In addition, in a multi-programming Inter process communications (IPCs) go through the Operating System (OS), which produces system calls and context switching overhead.

When using a multi-threading (namely, POSIX [18]) process for running encoding and decoding functions, other processes cannot access resources (namely, data space, heap space, program instructions), which are reserved for channel coding processing.

The memory space is shared among all threads belonging to the channel coding process, which enables latency reduction. Each thread performs the whole encoding or decoding flow of a single Channel Coding Data Unit (CCDU). We define a CCDU as the suite of bits, which corresponds to a radio sub-frame (no-parallelism), a TB or even a CB. When performing parallelism, CCDUs arrive in batches every millisecond. These data units are appended to a single queue (see Algorithm 1), which is managed by a global scheduler. We use non-preemptive scheduling, i.e., a thread (CCDU) is assigned to a dedicated single core with real-time OS priority and is executed until completion without interruption.

Isolation of threads is not provided by the POSIX API; hence, a specific configuration has been set up in the OS to prevent the use of channel coding computing resources for any other jobs. The global scheduler (i.e., the thread manager) runs itself within a dedicated thread and performs a FIFO discipline for allocating cores to Channel Coding (CC) jobs, which are waiting in the queue to be processed. Figure 5 illustrates $j$ cores dedicated to channel coding processing, remaining $C-j$ cores are shared among all processes running in the system, including those belonging to the upper-layers of the gNB.

IV-C Queuing principles

The CCDU’s queue is a chained list containing the pointers to the first and last element, the current number of CCDUs in the queue and the mutex (namely, mutual exclusion) signals for managing shared memory. The mutex mechanism is used to synchronize access to memory space in the case when more than one thread require writing at the same time. In order to reduce waiting times, we perform data context isolation per channel coding operation, i.e., dedicated CC threads do not access any global variable of the gNB (referred to as ‘soft-modem’ in OAI).

Scheduler

The scheduler takes from the queue the next CCDU to be processed and updates the counter of jobs (i.e., decrements the counter of remaining CCDUs to be processed). The next free core executes the first job in the queue.

In the case of decoding failure, the scheduler purges all CCDUs belonging to the same UE (TB). In fact, a TB can be successfully decoded only when all CBs have been individually decoded (See Algorithm 2).

Channel coding variables are embedded in a permanent data structure to create an isolated context per channel coding operation; in this way, CC threads do not access any memory variable in the main soft-modem (gNB). The data context is passed between threads by pointers.

IV-D Performance captor

In order to evaluate the performance of multi-threading, we have implemented a performance captor which gets key timestamps during the channel coding processing for uplink and downlink directions. With the aim of minimizing measurements overhead, data is collected by a separate process, so-called measurements collector, which works out of the real-time domain.

The data transfer between both separate processes, i.e., the performance captor and the measurements collector, is performed via an OS-based pipe (also referred to as named pipe or FIFO pipe because the order of bytes coming in is the same as the order of bytes going out [19]).

Timestamps are got at several instants in order to obtain the following Key Performance Indicators (KPIs):

• •

Pre-processing delay, which includes data conditioning, i.e., code block creation, before triggering the channel coding itself.

• •

Channel coding delay, which measures the runtime of the encoder (decoder) process in the downlink (uplink).

• •

Post-processing delay, including the combination of CBs.

Collected traces contain various performance indicators such as the number of iterations carried out by the decoder per CB as well as the identification of cores affected for both encoding and decoding processes. Decoding failures are detected when a value greater than the maximum number of allowed iterations is registered. As a consequence, the loss rate of channel coding processes as well as the individual workload of cores can be easily obtained.

V Performance results

In order to evaluate the performance of the proposed multi-threading scheme, we use the above described test-bed which contains a multi-core server hosting the gNB. The various UEs perform file transfers in both uplink and downlink directions.

The test scenario is configured as follows: number of cells: $1$ gNB; transmission mode: FDD; maximum number of RB: $100$; available physical cores: $16$; channel coding dedicated cores: $6$; number of UEs: $3$.

The performance captor takes multiple timestamps in order to evaluate the runtime of the encoder/decoder itself, as well as the whole execution time performed by the encoding/decoding function, which includes pre- and post-processing delays, e.g., code block creation, segmentation, assembling, decoder-bits conditioning (log-likelihood). When a given data-unit is not able to be decoded, i.e., when the maximum number of iterations is achieved without success, data is lost and needs to be retransmitted. This issue is quantified by the KPI referred to as loss rate.

Runtime results are presented in Figures 6 and 7 for the uplink and downlink directions, respectively. Decoding function shows a performance gain of $72,6\%$ when executing CBs in parallel, i.e., when scheduling jobs at the finest-granularity. Beyond the important latency reduction, runtime values present less dispersion when performing parallelism, i.e., runtime values are concentrated around the mean especially when executing CBs in parallel. This fact is crucial when dimensioning cloud-computing infrastructures and notably data centers hosting virtual network functions with real-time requirements. When considering the gap between CB-parallelism and no-parallelism maximum runtime values, the C-RAN system (also referred to as BBU-pool) may be moved several tens of kilometers higher in the network.

VI Conclusion

In this work, we have addressed the two main issues of C-RAN architectures, i.e., high fronthaul capacity for transmitting radio signals between the radio elements and the Central Office, and tight latency for the execution of virtualized RAN functions in general purposes servers.

In the aim of taking advantage of the benefits of C-RAN systems (i.e., spectral efficiency, interference reduction, data rate improvement) we focus on the study of fully centralized RAN architectures which notably include the channel coding function in the CU. We have thus proposed an bi-directional intra-PHY functional split (namely, FS-VI) for transmitting encoded and decoded data over Ethernet.

For meeting low latency requirements, we have performed C-RAN acceleration by means of parallel processing of the channel coding function. We concretely implemented on the basis of various open-source solutions, an end-to-end virtualized mobile network, which notably comprises a virtualized RAN. The platform particularly implements a thread-pool and two scheduling strategies, namely, parallelism by UEs and parallelism by CBs. The parallel processing of both encoding (downlink) and decoding (uplink) functions is carried out in a multi-core server within a single OS process in order to avoid multi-tasking overhead. Results show important gains in terms of latency, which opens the door for deploying fully centralized cloud-native RAN architectures.