Understanding the Performance of Flexible Functional Split in 5G vRAN Controllers: A Markov Chain-Based Model

We study Flexible Functional Split functionality of 5G vRAN controllers in 5G networks. We propose an innovative model, based on a Markov Chain, which can be used to characterize their performance. We consider both infinite and finite-buffer controllers. In the former, frames would not be lost (provided the system works in a stable regime), and we thus focus on the time frames stay at the controller. For the finite-buffer controller, there might be losses, and we analyze the trade-off between time at the controller (which might hinder the stringent delay requirements of 5G services), and loss probability. Matrix-geometric techniques are used to resolve the corresponding Quasi-Birth-Death process. The validity of the proposed model is assessed by means of an extensive experiment campaign carried out over an ad-hoc event-driven simulator, which is also used to broaden the analysis, considering different service rate distributions, as well as the variability of the studied performance indicators. The results show that the proposed model can be effectively exploited to tackle the dimensioning of these systems, as it sheds light on how their configuration impacts the expected delay and loss rate.

Over the years, Self-organizing Networks (SON) solutions have been proposed to make wireless communication networks more responsive and adaptable to both failures and varying requirements. In this regard, virtual RAN (vRAN) [1] is postulated as the main transformation of 5G networks to enable SON implementation [2]. Under the vRAN paradigm, which exploits Software Defined Networking (SDN) and Network Function Virtualization (NFV) techniques, traditional functionalities of the Radio Access Network (RAN) are virtualized, and the logical Base Station (BS) is divided in different functional entities. Then, the centralization of the virtualized entities allows a tight cooperation among the different access elements, so improving the network performance.
In order to develop the vRAN concept, initially fully centralized solutions, Cloud RAN (C-RAN), were proposed [3], [4]. In C-RAN the Base-Band Unit (BBU) of the base station is fully virtualized and centralized, while a Remote Radio Head (RRH) stays at the particular site position, together with the antenna and basic physical layer functions. Although this approach would yield a tight coordination among the access elements, it also demands high capacity in fronthaul links [5], which connect RRHs and virtualized BBUs, only affordable with a vast deployment of costly fiber links.
To overcome this limitation, industry, academia and standardization bodies have been working together to define different virtualization levels, so called functional splits [2], [6], with various fronthaul communication requirements. The reader may refer to work of Checko et al. [7] for a thorough discussion of the impact of different functional splits, in terms of energy, QoS and cost. This way, according to the configured functional split, part of the RAN functions are virtualized in a Central Unit (CU), typically located close to the transport network edge. The remaining functions are kept close to the access network edge, leading to the socalled Distributed Unit (DU) [8], while the RRH is now also referred to as Radio Unit (RU). More recently, some initiatives have suggested a flexible split selection, so that the virtualized functions in the DU and CU can be dynamically shifted.
One of the main challenges of this new architecture is the management of the fronthaul segment, which goes from being a set of dedicated links to a more complex packet based network, that needs to be appropriately managed. In fact, relevant standardization initiatives have started to define the Next Generation Fronthaul Interface (NGFI) [8], [9]. The NGFI is divided into NGFI-I and NGFI-II, or midhaul, which communicates RUs with DUs, and DUs with CUs, respectively. Altogether, it becomes necessary to develop solutions that jointly consider routing through the fronthaul network, along with the potential dynamic selection of the functional split that satisfies the required QoS. In turn, the split selection would be constrained by the computational resources allocated to the DU. In this sense, an adequate model of controllers, able to capture all these parameters and their impact over the corresponding performance, would be fundamental to tackle the dimensioning of future access networks. It is worth noting that the service chain in vRANs introduces constraints in the way functions are embedded. In particular, the DU and CU host lower and upper layers of the protocol stack, respectively. Thus, opposed to other NFV areas [10], the vRAN servicechain has only a limited set of possible implementations (i.e., a given frame would not go forth and back between elements to traverse the protocol stack).
In this article, we present a controller model for vRAN architectures, which considers both the split selection and computational resources. We do not aim at proposing a particular split selection strategy to optimize the controller behavior, but at building a model able to assess its performance under a given split strategy. More precisely, assuming a particular flexible split selection policy and allocated processing resources, the model provides expected performance of the system, in terms of delay and loss probabilities. Exploiting Markov Chain theory, we model the flexible functional split controller as a Quasi-Birth-Death (QBD) process. We consider two types of controllers: (1) infinite-buffer, where the buffer at the CU is considered to have enough capacity, so frames would not be lost; and (2) a finite-buffer controller, where frames could be discarded, when the buffer gets full. To our best knowledge, this is the first attempt to develop a theoretical model of CU controllers to appropriately analyze the performance of 5G flexible functional split architectures. We note that, although in this work we apply the model to the CU, it could be also used to evaluate the performance of the DU.
The contributions of this work can be summarized as follows: • We model the controller of the flexible functional split architecture, both assuming infinite and limited buffer capacity at the CU. • The model is based on a bi-dimensional Markov Chain, which boils down to a QBD, and that is solved with matrix-geometric techniques. • We validate the model, by comparing the theoretical results with those obtained by an ad-hoc event-driven simulator, in terms of delay, and loss probability. • The simulator is also exploited to broaden the analysis, considering different service time distributions, as well as studying results variability. • The implementation carried out to obtain the results presented in this article, MATLAB scripts and eventdriven simulator (C++), have been made available to the community in a public repository. 1 1 https://github.com/ldiez/5GvRanControllerQBD The rest of this article is structured as follows. In Section II we discuss the related work, pointing out the differences between our research and existing literature. Then, we depict the controller model as a Quasi-Birth-Death process in Section III, and in Section IV we theoretically find its main performance indicators. In Section V we validate the model, comparing its results with those obtained with an event-driven simulator. The paper concludes in Section VI, where we summarize its main outcomes, and we provide an outlook of our future work.

II. RELATED WORK
In recent years, a number of studies have tackled flexible functional split from different angles. In [11], the roadmap to implement flexible functional splits solutions is described, while the main characteristics of this kind of architectures are defined in [12] and [13]. Similarly, Arnold et al. describe a two-level flexible functional split architecture in [14].
Other works have focused on implementation details, thoroughly analyzing their impact. In this sense, in [15] and [16] Chang et al. studied the interplay of split selection with packetization and scheduling, respectively. Furthermore, compressing and coding solutions are proposed in [17], to enable the implementation of flexible split selection. In a more generic way, an implementation of a flexible functional split framework, along with its performance analysis, can be found in [18], and a real-time demonstrator is described in [19].
If we focus on the split selection policies, a number of works have recently analyzed the requirements and proposed solutions. In this regard, Alba and Kellerer [20] analyzed the performance and requirements of convergence times of split selection algorithms. One of the most common constraints of the split selection policy is related to delay. Indeed, some works pay special attention to such performance indicator. For instance, reinforcement learning is used in [21] to enforce delay constraints in dynamic split selection. Besides delay, other works jointly combine split selection with other relevant parameters for network management and service provisioning. For instance, a joint split selection and content caching solution is proposed in [22]. Some works have also put emphasis on the impact that this type of architectures might have over energy consumption. In this sense, split selection is optimized considering energy constraints in [23], [24], while the authors of [25] propose an energy-aware split selection algorithm for scenarios with Unmanned Aerial Vehicles (UAVs). In the same line, the selection of functional splits in [26], as well as their duration, considers energy constraints over a network with energy harvesting-enabled radio elements. In contrast, the authors of [27] propose a novel solution to optimize split selection taking into account energy and handover strategies.
In addition, some works have studied the implementation of split selection over optical fiber networks [28]- [32]. For instance, the authors of [31] depict an architecture, called F-RAN, able to dynamically choose the best split selection, based on radio performance and optic transport capacity. The architecture employs SDN to manage the underlying optical network, according to the selected split. Similarly, the authors of [32] propose a two-step solution to adapt the transmission of the underlying optical network, when degradation in the light-path occurs, along with split selection reconfiguration. Other works, such as [33], have also analyzed the interplay between dynamic split selection and network slicing.
Worthy of attention are those works that combine functional split selection policy and routing in the fronthaul network. The authors of [34] propose a framework that integrates heuristic solutions to optimize energy efficiency in converged fronthaul/backhaul networks. Although the work does not directly tackle flexible functional split, it is mentioned that reallocation of virtual functions can be done along with the optimization. As an example, an heuristic solution to dynamically allocate new traffic flows is described in [35]. Similarly, Li et al. provide in [36] an architectural view of resource management and energy efficiency for converged fronthaul/backhaul networks. In particular, for the resource management, the authors jointly consider path computation and placement of network functions. Besides, an heuristic algorithm, based on backtracking branch and bound, is proposed in [37] to solve the joint split selection and routing problem. This scenario is further extended in [38], where placement of Mobile Edge Computing (MEC) elements is included, and an algorithm based on Benders decomposition is proposed to solve the resulting problem in [39]. While the previous work considers that the location of the CUs is known, placement of CUs, along with path selection, is included in the optimization problem. In this case, the split configuration is not a direct selection, but a consequence of solving the network embedding problem.
Most of the aforementioned works propose split selection policies, either standalone or in combination with other parameters and techniques, but they are rather different from our work in nature. Our main goal is to define a model that provides expected controller behavior when a particular policy is applied. Based on this model, we could obtain a more accurate expected performance, which could be exploited to assess the mentioned proposals, by using the appropriate statistical behavior of the corresponding split policies.
Another group of works take into account computation capabilities in the controller when performing the split selection, along with other network management techniques. Koutsopoulos [40] proposes a set of heuristics for flexible functional split solutions that minimize the delay, considering the controller processing capacity. Furthermore, an scheduling solution for vRAN is proposed in [41], which ensures that computation resources in the controller do not get exhausted. To this end, the authors propose an adaptive Modulation and Coding Scheme (MCS) solution when computation resources cannot satisfy the demand.
A machine-learning based solution is proposed in [42] to manage computation resources in the vRAN controller. In addition, the authors carefully analyze the computational load required by the different network functions, using a Software Defined Radio (SDR) implementation. Following this line, Rost et al. [43] propose two computation-aware schedulers to maximize the sum-rate, while respecting computation limits. Energy is also considered in [44], where resource allocation in vRAN is jointly tackled with Mobile Cloud Computing (MCC), to perform user tasks. In particular, authors model the BBU to consider the impact of computational capacity on radio resource scheduling. A similar scenario can be found in [45], where task offloading in MEC is tackled, considering flexible functional split. As can be observed, our work clearly differs in its scope. Although these papers consider computational resources, none of them address an appropriate modeling of the vRAN controller.
Furthermore, we have also identified two works that aim to model some aspects of the virtualized network. The authors of [46] provide a quantitative analysis of computation and power savings when using different splits. In particular, the authors seek to estimate processing (power) reduction in the CUs pool when applying different splits. In contrast, we focus on networking and computational metrics related to QoS, such as delay, buffer size, and loss probability. Finally, a queuebased model for packet generation using SDN techniques is proposed in [47]. Although this model might be applied to improve the design of the fronthaul network, by tweaking the corresponding traffic patterns to deal with congestion, the scope of this work is different to ours, which focuses on a model to yield key performance indicators of the vRAN controller.
We can thus conclude that, to our best knowledge, the modeling of the vRAN controller has not been so far tackled. The model we propose herewith is able to provide accurate expected performance, considering key indicators for 5G services, such as delay and loss probabilities. It can be thus exploited to address the dimensioning and planning of this type of network elements, since it can be configured to consider different split selection policies.

III. CONTROLLER MODEL
We consider a vRAN controller, which is equipped with a single CU, having a certain number of processing and memory resources. Downlink communication is assumed, although the model can be straightforwardly applied for uplink traffic. Frames towards the CU arrive at a rate of λ ms −1 , following a Poisson process. The CU can be configured in s different splits, each of them having a certain service rate μ k ms −1 for k ∈ {1, . . . , s}. We assume that service times follow an exponential distribution, and that a First-Come First-Served (FCFS) policy will be used to process frames.
In the following we define two CU models. In the first one, we will assume that the buffer has enough capacity to store frames before they can be eventually served, provided that it operates at a stable regime. In this case, frames will not be lost. On the other hand, we will also assume a more realistic setup, where the buffer has a finite capacity and so frames could be eventually discarded.
In both cases, the controller can use different split configurations. We assume that a split change is performed after a certain time interval, which is modeled as an exponential random variable, with rate γ ms −1 . Once this timer expires, the controller goes into a stand-by state, where frames are not served, until it becomes again operative. Frames may continue coming, but they are kept in the buffer (if there is capacity  left). We assume that the CU leaves such stand-by state after a time, which is also modeled with an exponential random variable, with mean value ξ −1 ms. Upon this timer expiration, the next configuration split is randomly selected, so that split k th is selected with a probability α k , and k =1...s α k = 1. It is worth noting that split transition rates and probabilities would be defined by the particular split selection policy used. On the other hand, the time spent in the stand-by operation state would depend on computational resources given to the DU and the particular software implementation of the vRAN solution.
We model the state at which the controller is currently operating as a tuple (i, j), where i is the current number of frames at the controller, while j corresponds to the current split. Therefore, if j equals 0, the CU would be at stand-by. Table I enumerates all the symbols that are used in the proposed model and its solution.

A. Markov Chain
As we have considered that all services are modeled by means of exponential random variables, and that frames arrive at the controller following a Poisson process, we can use the 2-dimensional Markov Chain shown in Figure 1 to model the behavior of the CU. As can be seen, each of the rows corresponds to a particular split, where a frame arrival leads to a 1-state rightwards transition, and a frame exiting the system (after it has been completely served) is captured by a 1-state leftwards transition. In the figure we have assumed that the controller has a finite buffer, which can keep up to β frames. In this case, if i = β + 1 (last column at the right side of the Markov Chain), the controller would not accept any incoming frame, which would be lost, and the only possible transition happens when a frame completes its processing (1-state leftwards). If we assumed that the controller would have enough capacity to maintain incoming frames until they could be eventually processed (this requires system stability), the corresponding Markov Chain would have infinite states, and we would not strictly need such last column (β + 1, k ) in the corresponding diagram.
Whenever the DU changes its split configuration, it first goes to the stand-by mode. As was mentioned earlier, we model these split changes with a exponentially distributed timer, whose mean value is 1 γ ms. This is reflected by the transition from each state (i, k), with k = 1, . . . s to (i, 0), at a rate γ ms −1 . We have assumed that γ is the same for all split configurations, but this could be easily adapted, if we wanted to capture situations where some splits could last longer than others. Once the CU is at stand-by, frames stop being served. If there was any frame being served, it is kept at the cache of the processor (i.e., it does not occupy a buffer position), but its processing is frozen, until the stand-by situation finishes. As can be seen on the lower row in Figure 1, during the stand-by situation state transitions just happen rightwards, whenever a new frame arrives, but no frames are processed (i.e., they do not leave the system) and there do not exist leftwards state transitions.
We also model the time the controller stays at the standby configuration with an exponential random variable, with mean value 1 ξ ms. Hence the rate at which the model leaves any state (i, 0) equals ξ ms −1 . As can be observed, we consider that the next configuration split is randomly selected, with a certain probability. Thus, whenever the controller ends its stand-by configuration, it starts split k th with probability α k , with k =1...s α k = 1. This is reflected in Figure 1 with transition rates of α k ·ξ from state (i, 0) to (i , k ), ∀k = 1 . . . s.
As can be seen, the defined model corresponds to a QBD process, which is a generalization of traditional birth-anddeath process, where states are grouped into levels, in our case according to the number of frames at the controller (i.e., each column in Figure 1). The transitions only happen between states within the same level (change of split configuration) or to states in adjacent levels (upon a frame arrival or exit). As will be seen later, this yields to a block tridiagonal matrix representation of the underlying process. The reader can refer to the seminal works of Neuts [48] and Hajek [49], or complete books by Neuts himself [50], or Latouche and Ramaswami [51], for a more thorough discussion of the corresponding theoretical framework, in particular the so-called Matrix Geometric Method, which we will use in the next Section to analyze the behavior of the CU.

IV. CONTROLLER PERFORMANCE
We resolve the model introduced above, using the Matrix Geometric Method, to find its stationary distribution and its average performance, in terms of time spent at the controller and loss probability. We first consider a controller with an infinite-capacity buffer, where frames are never lost (provided it works at a stable regime). Then we also study the performance of a limited-buffer controller.

A. Infinite Buffer Controller
By considering the transition rates of the Markov Chain in Figure 1 (without considering the last column at its right side, β + 1, k ), we can define the infinitesimal matrix of the corresponding QBD process: where L 0 , B, L, F are (s + 1) × (s + 1) matrices. B, F, L are given in equation (2), shown at the bottom of the page. As can be seen, F is a diagonal matrix, with all its elements being λ (it thus corresponds to the identity matrix of the appropriate dimension multiplied by λ). B is also a diagonal matrix, with the first element of the diagonal being 0, while the rest correspond to the service rates of the various splits: μ 1 . . . μ s . On the other hand, L 0 can be straightforwardly calculated as We then define the stationary distribution of the system as Π = [π 0 , π 1 · · · ], where π i is a column vector of length s + 1, so that π i (j ) corresponds to the probability of having i frames in the CU, configured in the j th split. Hence, π i (0) would be the probability of having i frames in the controller, while being on stand-by.
If the system is working in a stable regime, then there exists such stationary distribution, and it can be demonstrated that there is a constant matrix R so that [50, Th. 3.1.1]: In addition, there is a unique positive solution to the following system of equations: where 0 and 1 are column vectors, of length s + 1, with all their elements being 0 and 1, respectively. Then, Π is given by: Since there does not exist a closed solution for the quadratic equation in (3), an iterative method can be used to find R. 2 We could also find the probability that the controller stays at a particular split configuration (or in stand-by), by summing the corresponding probabilities: Such probability equals the fraction of time the controller would stay at a particular configuration. We could also establish it by means of the corresponding rates (ξ and γ), and the probabilities of selecting each split configuration α k : We will afterwards use (7) to validate the model, by comparing it with the results yielded by (6).
The stationary distribution would allow us to establish the performance of the CU. Based on Π, we can easily obtain the average number of frames in the controller: We can then apply Little's Law to find the average time a frame stays in the controller, t t , both waiting and at the 2 In MATLAB 2018, assuming a four-split controller, and an error of = 10 −8 , it takes approximately 230 iterations to find R, in less than 5 ms, using a laptop equipped with an i7 Intel processor.
processor. In this case, frame arrival rate is constant, λ, and so: All the previous results for the infinite-buffer CU controller are valid provided the system is operating at stable regime. In this sense, it is worth recalling that the corresponding QBD process has a stationary solution if and only if the following condition holds: where η is the stationary probability vector (row vector) of matrix A = B + L + F, and 1 is a column vector, of the appropriate length (s + 1), with all its elements being 1. By solving ηA = 0, we obtain that: η 0 = γ γ+ξ and η k = α k ξ γ+ξ , ∀k = 1 . . . s, i.e., they match the split probabilities (7). Then, by substituting into (10), we can finally establish the stability condition for the CU operation: We can define a straightforward bound for λ, since in some cases, it might not be possible knowing the actual split probabilities. Since s k =1 α k · μ k ≤ max k μ k , we can conclude that: In order to assess the looseness of the previous bound, we have made a simple experiment, using the CU configurations that will be used afterwards, in Section V. We assume that λ = ξ = 1 ms −1 , and γ = 1 10 ms −1 . We consider a controller with four different splits, with service rates given by: μ = [1 1.5 3 5]. Furthermore, we use two α vectors, so that both the fastest and slowest rates have a larger probability, leading to fast and slow setups. We then increase the value of μ 1 , so augmenting the processing capacity of the controller, while keeping the ratio of the other service rates, i.e., μ † = μ 1 · [1 1.5 3 5]. Results are shown in Figure 2. As can be seen, when μ 1 is large, the bound behaves worse, but for lower service rates, the bound provides a rather good approximation, in particular for the fast setup, to find the maximum arrival rate that could be accepted to guarantee the controller works within its stable regime.

B. Finite Buffer Controller
We assume in this case that the buffer has a finite capacity, to keep up to β frames before they can be eventually processed, which corresponds to the Markov Chain shown in Figure 1. The infinitesimal generator matrix of the QBD process, Q b is the following finite matrix: all L 0 , B , L, F , L β+1 are (s + 1) × (s + 1) matrices. Hence, the dimension of Q b equals (s + 1) · (β + 2) × (s + 1) · (β + 2). B, F, L are the same matrices that were seen for the infinite buffer model, given in (2). L 0 is still L 0 = L + B , while L β+1 = L + F . In order to find the corresponding stationary distribution, we first establish the constant matrices V and V , which are defined as [49, Sec. 4, Th. 1]: As was the case with R in (3), we use an iterative method to obtain V and V . 3 Based on such matrices, we define H, H , as follows [49,Sec. 4]: We can find the first and last rows of the fundamental matrix N of the corresponding process as can be seen in (16), shown at the bottom of the page [49,Th. 4].
Afterwards, based on (16), we can finally build the matrix M [49, Th. 5]: We can then establish x 0 and x β+1 as the invariant probability distribution of M (its left eigenvector, having an eigenvalue of 1): [x 0 x β+1 ]. We can finally write that [49, Th. 5]: 3 In this case, the number of iterations that were needed for a controller with four splits, and an error of = 10 −8 were, approximately, 220 and MATLAB 2018 took, in a laptop with an i7 Intel processor, ≈ 10 ms Finally, the probability distribution of the corresponding Markov Chain states is defined as: where c is a normalizing constant, which guarantees that the sum of all probabilities equals 1: From the stationary state distribution, we can (as was done for the infinite buffer model) characterize the performance of the system. We can first calculate the probability of working at a particular split, which should also equal the results that were shown in (7): We can also find the average number of frames in the system, as: In order to find the average time at the controller using Little's Law, we first need to calculate the average served frame rate (since in this case there are losses). λ can be calculated as: We can finally write that: As was said earlier, the main difference between the controller with infinite buffer and this one is that frames are lost, when the buffer is fully occupied, and a frame arrives. Exploiting the Poisson-arrivals-see-time-averages (PASTA) property [52], we can obtain the loss probability as follows: In the next section we will discuss all the results that can be obtained by using the presented model, validating it by means of extensive simulations.

V. RESULTS
In this section, we discuss the results yielded by the proposed model. We compare them with the performance obtained by means of an extensive experiment campaign that was carried out using a proprietary event-driven simulator, implemented in C++. This allows us to assess the validity of both the model and the simulator, which will be afterwards used to broaden the analysis.
The simulator defines four different types of events: (1) arrival of a new frame; (2) frame service completion (a frame exits the CU); (3) split configuration change (transition to stand-by); (4) end of the stand-by state. The events are processed according to the CU state, which takes into account the current number of frames. For instance, whenever a frame arrival event is processed, the simulator engine checks whether the processor is empty and, if such is the case, it schedules the exit of such frame, using an instance of the corresponding time distribution. On the other hand, if there was already another frame being processed, the buffer length is increased. As can be seen, differently to the proposed model, the simulator is not constrained by any particular time distribution, so that different choices can be used to schedule the forthcoming events, according to the particular experiment configurations. In this sense, this tool can be also used to analyze the behavior when the model assumptions do not hold. 4 We consider the scenarios that are depicted in Table II. We assume that the CU has four different splits, each of them with a different service rate, sorted in ascending order. In the first scenario (A), the slowest service is more likely to be used, while in the second setup (B), the fastest service rate has a greater probability. We further assume that γ = 0.1 ms −1 and ξ = 1 ms −1 . For the finite buffer controller, we will study the impact of its length, while we will ensure that the infinite buffer CU always operates at a stable regime.
We start by analyzing the probability of having a number of frames in the controller. Figure 3 shows such probabilities, for the two aforementioned scenarios, and for both controller models. Upper subfigures correspond to the infinitive buffer (β = ∞) controller, while the bottom plots show the results for the finite buffer, for which we used a buffer length of β = 8. For scenario A we assume a frame rate of λ = 1 ms −1 , and we increase it to λ = 1.5 ms −1 for setup B. In both cases, we guarantee that the infinite-buffer controller is working at a stable regime. With the simulator, we run experiments comprising 200000 frames, to ensure statistically tight results.
We use a stacked bar representation, so that each bar corresponds to a particular value of frames, as indicated in the x-axis (n), and it is as well divided into a number of chunks, which reflect the probability of each of the four splits and the stand-by situation. First of all, we can see that there is an almost perfect match between the theoretical results and those obtained with the simulator, which proves their correctness. We can also see that the presence of the faster splits is much more relevant for low n values, and they quickly become less visible when n gets higher. This is sensible, since the controller would be able to serve more frames when working at a quicker pace, and it would thus take less time to reach the corresponding (0, k ) state. On the other hand, the stand-by probability does not vary with n, as could have been expected, since the 4 More details are given in the README file in https://github.com/ldiez/5GvRanControllerQBD. values of ξ and γ do not depend on the service rates, nor on the particular configuration.
The aforementioned match between analytical and simulation results is also reflected in the probabilities of working at a particular split. We recall that these are given by (7). Table III shows the corresponding probabilities for the four configurations, and the values that were obtained with both the proposed model and the simulator. As can be seen, the values that are obtained by summing the corresponding state probabilities, as given by (6) and (21), perfectly match the theoretical values (7). On the other hand, the results obtained with the simulator (again after a single experiment comprising 200000 frames) are also very close.
We now analyze the performance of the CU, considering both the time that a frame stays at the controller, as well as the loss probability (for the finite-buffer case). Figure 4 shows the average time a frame stays at the controller. In all cases, we represent with solid lines the theoretical results (those obtained by exploiting the model discussed in Section III), and markers correspond to the values yielded by the simulation, after 100 independent experiments, each of them comprising 10000 frames, ensuring statistical tightness. Last, dashed lines are the results that were obtained by using the simulator, using constant service times, instead of exponentially distributed ones.
First of all we can again see the almost perfect match between the theoretical results and the values offered by the simulator. More interestingly, the difference when constant service times are used is not very relevant. In the case of the infinite buffer controller (Figure 4(a)) we can observe that the average time in the controller heavily increases with λ. This is more relevant for scenario A, where the λ range that guarantees a stable regime is shorter. The behavior is different when a finite buffer is used, as can be seen in Figures 4(b)  Fig. 4. Total time Vs. λ. Model results are shown with solid lines. Simulation results with exponential and constant service time are represented with markers and dashed lines, respectively. and 4(c), for setups A and B, respectively. We can see that the time tends to stabilize when λ gets higher. In addition, it also increases as long as the capacity of the buffer is larger. Both observations could have been expected. When the buffer capacity is lower, there would be more losses (this will be discussed afterwards) for greater arrival rates, but the time a frame waits to be served does not increase, and is limited. In this sense, we can see that the aforementioned stabilization happens earlier when the buffer length is shorter, while we do not even see this for the longest buffers (β = 32). For the finite-buffer controller we can also see that there is a slightly larger difference between the constant and exponentially distributed service times, as long as b increases, being more relevant in scenario A, which is characterized by a larger load.
For the two types of controller, these results would yield a reasonable limit on the maximum allowable frame arrival rate. As was mentioned previously, 5G use cases set stringent delay requirements, and the presented model can shed light on the impact that CU might have. In the case of the finite-buffer, we can see that such time does not heavily increase for short buffer lengths, although as will be seen below, there is a strong impact on the corresponding frame loss probability.
We have assumed that the infinite buffer controller, provided that the system works in a stable regime, would keep frames in the buffer until they can be eventually served, and so there do not exist losses. In more realistic scenarios, it is sensible to assume that the CU would actually have a certain buffer length, and incoming frames would be lost if there is not available capacity. Figure 5 shows the loss probability that was obtained for the finite-buffer CU, for the two setups. We keep using solid lines to represent the results yielded by the proposed model, markers correspond to the values obtained with the simulator, while the dashed lines are the loss probabilities that were seen (again exploiting the simulator) when using constant service times, instead of exponentially distributed. All the results obtained with the simulator are based on 100 independent experiments, each of them entailing the transmission of 10000 frames. There is again a perfect match between theoretical and simulation results. As was expected, loss probability increases with λ, and it is more relevant for shorter buffer lengths. It is worth noting that, despite the finite-buffer model does not strictly impose a maximum frame arrival rate, the loss probabilities that are seen for large λ are clearly unacceptable. Again, the proposed model would allow addressing the design of these systems, based on the requirements of the corresponding services.
Opposed to the average time (see Figure 4), the differences observed between the loss probabilities when constant service times are used, instead of the exponentially distributed ones, are more relevant as long as the buffer length gets shorter.
The results discussed so far for the finite-buffer controller have shown that longer buffer lengths would yield lower loss probabilities, but at the cost of heavily increasing the time spent at the controller. This sets a clear trade-off between these two performance indicators, since in 5G loss probabilities should be kept low, but the average transfer time should not heavily increase if the stringent delay requirements are to be respected. In order to study this trade-off, Figure 6 shows the performance region for the finite-buffer controller. We fix λ to three different values, and we increase the buffer length. The figure plots how the loss probability varies against the average total time in the controller. As in previous results, solid lines were yielded by the proposed model, markers correspond to the results obtained with the simulator (100 independent runs with 10000 frames each), while the dashed lines show the values (again using the simulator) that were obtained for constant service times. In this case we also represent, as point clouds, all the values that were obtained with the simulator, to show the variability of the results. We can still see a very tight match between the values yielded by the proposed model, and the simulator results (with a slight difference for high λ and large buffers (see the red line in Figure 6(b)). The differences that were observed in Figure 5 between constant and exponentially distributed service times are reflected as well.
For scenario A, which has a larger load (slower CU configuration), we can see that, when λ is high, increasing the buffer does not heavily improve the performance of the controller, with a slight decrease of loss probability, albeit relevant longer transfer times. However, in the results obtained for scenario B, we can observe how the increase of the buffer length might yield a sharp decrease on the loss probability without a relevant increase of the time spent at the controller. We can also see that for lower λ and shorter buffer lengths, the performance of the controller is much more predictable, and the corresponding results are rather tight, both in terms of delay and loss probability. However, when the buffer length increases, there is a much wider range of performances, although the average behavior matches the one yielded by the proposed model. This is corroborated by the next set of results.
So far, we have focused on the average behavior exhibited by the controller, but it is also interesting to assess the variability of such performance indicators. In order to study their statistical tightness, we will exploit the simulator, since the proposed theoretical model only yields the average values. First, Figure 7 uses whisker plots to capture the variability of the time frames spend at the controller, both for the infinitebuffer (β = ∞) and finite-buffer (with various buffer lengths) CU. Each whisker plot corresponds to a single experiment, comprising 200000 frames, and it shows the median (0.5 percentile) of the time (horizontal line within the box), the 0.25 and 0.75 percentiles (upper and lower box limits), as well as the 0.05 and 0.95 percentiles. We have also included (with a circular marker) the average value, which corresponds to the ones shown in the previous figures. The upper figure corresponds to the exponentially distributed time, while the lower one shows the results obtained when the service time was constant.
As can be seen, for low λ, the variability is rather low, and it does not depend on the buffer length (it does not even increase for the infinite-buffer configuration). However, when the frame arrival rate increases, we can see that the variability of the time frames need to stay at the controller gets considerably higher. This is more relevant as long as the length of the buffer is larger. In fact, the highest variance is seen for the infinitebuffer model. In addition, Figure 8 shows the variability of the loss probability. The configurations are the same that were just described, when discussing Figure 7. In this case we do not include the infinite-buffer controller, since frames are not lost. Again we see that the larger λ, the larger the variability, although the increase is not as relevant as it was seen for the transfer time (this was also observed in Figure 6). Furthermore, while we saw that the variance exhibited by the time was strongly affected by the corresponding buffer length, this is not reflected in the loss probability, and different buffer lengths yield similar variabilities for the same arrival rate.
We have also exploited the simulator to analyze the behavior of a realistic controller configurations. We have used the metrics reported in [11], where the authors assess the performance of real dynamic functional split implementations. In particular, they study the standby time under different split changing implementations. As it is our case, the authors do not propose particular split selection policies, but they implement a SDR based solution able to be used by a given policy. We used the values shown in [11,Fig. 5]. In particular we configured the simulator with a controller having 2 split options, which correspond to the MAC-PHY and PDCP-RLC splits implemented in [11]. Traffic arrives with an Inter arrival Time (IaT) between frames of 8 ms (i.e., yielding a frame arrival rate λ = 0.125 ms −1 ). According to the capacity values mentioned in [11, Fig. 4], service times are set to 5 and 10 ms for each split respectively. Hence, service rates are μ 1 = 0.2 ms −1 and μ 2 = 0.1 ms −1 . Eventually, the standby time is modeled using a uniform distribution, as shown in [11, Fig. 5], as well as using an exponential distribution, to assess the impact of the assumptions the model takes. We consider that both split configurations are equiprobable, i.e., α 1 = α 2 = 0.5, and the average time between split changes is 10 times higher than the standby duration. Figure 9 compares the controller performance when both uniform and exponential distributions are assumed for the standby time, using different buffer sizes. First, Figures 9(a) and 9(b) show the distribution of the time frames spend at the controller, and the loss probability, respectively. We can see that the behavior is similar than the one observed earlier. When we increase the buffer length, we can notably reduce the loss probability, at the cost of heavily increasing the time spent at the controller. We can also see that the impact of assuming the exponential distribution for the stand-by duration is not very relevant, since the results obtained with the uniform distribution are rather similar, both in terms of the average value and the corresponding variability. Finally, Figure 9(c) shows the trade-off between loss probability and total time at the controller, as we increase the buffer length. Once again, the results evince that both configurations yield very similar behaviors. As was also seen earlier, greater buffer lengths lead to smaller loss probabilities, at the cost of longer delays, which might hinder the strict delay requirements of 5G communications. We can also see that such configurations are also characterized by showing a less predictable behavior, with a larger variability in the results.

VI. CONCLUSION
We have introduced a novel model that can be used to appropriately capture the performance of Flexible Functional Split in vRAN 5G controllers. In spite of the growing interest on this type of network elements, and to our best knowledge, this is the first proposal that can be effectively used to tackle their adequate dimensioning.
The model is based on a bi-dimensional Markov Chain, which can consider both infinite and finite-buffer controllers. In the former group, we assume that the controller has enough capacity in its buffer to keep incoming frames, until they can be eventually served, and so there do not exist any losses. In the second group, we assume the controller to have a limited buffer, and so frames would be lost. Matrix geometric techniques have been use to solve the corresponding Quasi-Birth-Death process.
A proprietary event-driven simulator has been first used to assess the validity of the proposed model. The obtained results, after an extensive simulation campaign, show an almost perfect match between both approaches, which are thus validated. Then, we have exploited the simulator to broaden the analysis, considering different service time distributions, as well as the statistical variability of the performance indicators.
For the infinite-buffer model we have focused on the time frames need to stay at the controller. Based on 5G stringent delay requirement, this could be used to establish sensible configurations, or a maximum admissible frame arrival rate. On the other hand, for the finite-buffer controller, we have studied the trade-off between transfer time and loss probability, and the impact of the buffer length. We also used realistic Fig. 9. Realistic controller (configuration taken from [11]) performance for exponential and uniform distributions for the standby duration. configuration values of a real controller implementation to assess its peformance, by exploiting the developed simulator.
The proposed model can undoubtedly serve to tackle an appropriate design of vRAN controllers, since it can shed light on the impact of their configuration over performance indicators, to ensure that requirements posed by 5G services are adequately met. In this sense, we have made the code available to the scientific community, in a public github repository.
In our future work, we plan to exploit the model in more specific scenarios and use-cases, making the corresponding adjustments in the controller configuration. We are also starting to look at the performance of these network elements on a lower scale, by considering scheduling policies and dynamic queue management techniques. In this sense, we will use both the model and the simulator to evakuate the behavior of particular split selection policies, which might yield optimum performance in terms of a variety of metrics, including latency and loss probability.