A Utility-Driven Multi-Queue Admission Control Solution for Network Slicing

TL;DR

This paper proposes a utility-driven multi-queue admission control system for network slicing in 5G, modeling its behavior and optimizing admission to improve performance over traditional methods.

Contribution

It introduces a novel multi-queue model for slicing admission control and develops a utility-based optimization approach for 5G network slices.

Findings

System can be approximated as Markovian

Improved performance over legacy solutions

Effective handling of heterogeneous tenant requests

Abstract

The combination of recent emerging technologies such as network function virtualization (NFV) and network programmability (SDN) gave birth to the Network Slicing revolution. 5G networks consist of multi-tenant infrastructures capable of offering leased network "slices" to new customers (e.g., vertical industries) enabling a new telecom business model: Slice-as-aService (SlaaS). In this paper, we aim i ) to study the slicing admission control problem by means of a multi-queuing system for heterogeneous tenant requests, ii ) to derive its statistical behavior model, and iii ) to provide a utility-based admission control optimization. Our results analyze the capability of the proposed SlaaS system to be approximately Markovian and evaluate its performance as compared to legacy solutions.

Figures

Tables

Table 1. Table I : Specifications of two reference slice types

Type ($n$)	${𝐜}_n$	${\lambda }_n$	$1/{\eta }_n$	$u_n$	${\alpha }_n$	${\beta }_n$
1	$[0.01,0.05]$	2 (Scenario 1)	5	1	1	0.02
		6 (Scenario 2)
2	$[0.2,0.04]$	0.5 (Scenario 1)	2	10
		1.5 (Scenario 2)

Equations

$$\mathbf{a}\stackrel{\Delta }{=}[a_1,a_2,\dots ,a_M{]}^{\text{T}}=\mathbf{C}\times \mathbf{s},$$

$$\mathbb{S}=\{\mathbf{s}|r_m-a_m\ge 0,\forall 1\le m\le M\}.$$

$$\mathbb{A}=\{\mathbf{s}|\mathbf{s}\in \mathbb{S},\exists n:\mathbf{s}+\Delta {\mathbf{s}}_n\in \mathbb{S}\},$$

$$\Delta {\mathbf{s}}_n=[\underset{n-1}{\underbrace{0,\dots ,0}},1,\underset{N-n}{\underbrace{0,\dots ,0}}],n\in \{1,2,\dots ,N\}.$$

$$\Phi =[{\phi }_1,{\phi }_2,\dots ,{\phi }_{N+1}],$$

$$\begin{array}{rl}\mathbf{\Phi }& =[{\Phi }_1,{\Phi }_2,\dots ,{\Phi }_{|\mathbb{A}|}]\\ & =\left[\begin{array}{cccc}{\varphi }_{1,1}& {\varphi }_{1,2}& \dots & {\varphi }_{1,|\mathbb{A}|}\\ {\varphi }_{2,1}& {\varphi }_{2,2}& \dots & {\varphi }_{2,|\mathbb{A}|}\\ ⋮& ⋮& \ddots & ⋮\\ {\varphi }_{N+1,1}& {\varphi }_{N+1,2}& \dots & {\varphi }_{N+1,|\mathbb{A}|}\end{array}\right],\end{array}$$

$${\varphi }_{I,k}\ne 0,\forall k<n;$$

$$l_n>0;$$

$$\left(\mathbf{s}+\Delta {\mathbf{s}}_{{\varphi }_{n,I}}\right)\in \mathbb{A}.$$

$$\text{Prob}(t_{\text{w},n}>T)=1-\prod _{\mathbf{e}\in {\mathbb{E}}_n}\text{Prob}(Arr(T)=\mathbf{e}),$$

$$\begin{array}{r}\text{Prob}(Arr(T)=\mathbf{e})=\text{Prob}(Arr(T+t)=\mathbf{e}\text{leavevmode}|\text{leavevmode}Arr(t)\ne \mathbf{e})\\ \forall [\mathbf{e},t,T]\in \left({\mathbb{E}}_T\times {\mathbb{N}}^2\right),\end{array}$$

$$\begin{array}{rl}& \text{Prob}(t_{\text{w},n}>T+t)\\ =& 1-\prod _{\mathbf{e}\in {\mathbb{E}}_n}\text{Prob}(Arr(T+t)=\mathbf{e}\text{leavevmode}|\text{leavevmode}Arr(t)\ne \mathbf{e})\\ =& \text{Prob}(t_{\text{w},n}>T+t\text{leavevmode}|\text{leavevmode}{t}_{\text{w},n}>t),\forall [t,T]\in {\mathbb{N}}^2.\end{array}$$

$$L_n={\lambda }_n{\overline{W}}_n,$$

$$p_n(l)=(1-\rho ){\rho }^l,$$

$$f(W_n)=\{\begin{array}{ll}0& W_n<0\\ ({\mu }_n-{\lambda }_n)e^{-({\mu }_n-{\lambda }_n)W_n}& W_n\ge 0\end{array},$$

$$F(W_n)=\{\begin{array}{ll}0& W_n<0\\ 1-e^{-({\mu }_n-{\lambda }_n)W_n}& W_n\ge 0\end{array}.$$

$$1-b_n=\{\begin{array}{ll}0& l_n=0\\ 1-{\beta }_n/l_n& l_n\in {\mathbb{N}}^{+}\end{array},$$

$$p_n(l)=\{\begin{array}{ll}\frac{1}{1+({\delta }_n{)}^{1-{\gamma }_n/2}[\Gamma ({\gamma }_n)/{\beta }_n]I_{{\gamma }_n}(2\sqrt{{\delta }_n})}& l=0\\ & \\ \frac{{\delta }_n^l{p}_n(0)}{{\beta }_n(l-1)!{\prod }_{j=0}^{l-1}({\gamma }_n+j)}& l\in {\mathbb{N}}^{+}\end{array},$$

$$P(A_n)$$

$$P(A_n,J_n)$$

$$P(A_n|J_n)$$

$$f_{\text{a}}(W_n)$$

$$f_{\text{r}}(W_n)$$

$$f_{\text{q}}(W_n)$$

$${\overline{W}}_{\text{a},n}$$

$${\overline{W}}_{\text{r},n}$$

$${\overline{W}}_{\text{q},n}$$

$$u_{\Sigma }(t)=\sum _{n=1}^N{s}_n(t)u_n,$$

$${\overline{u}}_{\Sigma }=\sum _{n=1}^N\frac{{\mu }_n{u}_n}{{\eta }_n},$$

$${\overline{W}}_{\text{q}}=\frac{\sum _{n=1}^N{\overline{W}}_{\text{q},n}{L}_n}{\sum _{n=1}^N{L}_n}.$$

$$\overline{P}(A)=\frac{{\sum }_{n=1}^N{\lambda }_{n}P(A_n)}{{\sum }_{n=1}^N{\lambda }_n}.$$

$$\Delta {\mathbf{s}}_0=\underset{N}{\underbrace{[0,0,\dots ,0]}},$$

$${\tilde{\varphi }}_{i,j}=\{\begin{array}{ll}0& j>|\mathbb{A}|\\ {\varphi }_{i,j}& j\le |\mathbb{A}|\end{array},\forall i\in \{1,2,\dots ,N+1\},$$

$$p_0(0)=0,$$

$$\text{Prob}(\mathbf{s}\to \mathbf{s}+\Delta {\mathbf{s}}_n)=\prod _{k=1}^{n-1}{p}_{{\tilde{\varphi }}_{k,J}}(0)(1-p_{{\tilde{\varphi }}_{n,J}}(0)).$$

Full text

I Introduction

Network Slicing [1] is an emerging 5G technology that allows infrastructure providers to offer “slices” of resources (computational, storage and networking) to network tenants. In this way a new business game [2] is introduced as infrastructure providers (sellers) strategically decide which tenants (buyers) get granted slices to deliver their services. Intuitively, this involves a number of challenges that fall in the economic research field, which, in turn, requires a detailed understanding of the context. In particular, the infrastructure provider may rely on this emerging technology as a means to increase its revenue sources. However, to achieve the overall revenue maximization, advanced admission control policies are required as tenants compete for a limited bunch of available resources. ††This is a preprint. © 2019 IEEE

In this competing environment, a brokering solution may act as a mediator between seller and buyers while providing service level agreements (SLAs) guarantees to granted running slices [3]. Admission control policies will guide the broker in the process of deciding the set of network slices that can be installed on the system and the ones to be rejected. As the number of network slices grows—as envisioned for the next few years [4]—it will be necessary to design an automated solution that dynamically decides on the received slice requests while guaranteeing a certain degree of fairness among network tenants. Indeed, network slice requests may be queued while waiting for the next available resources, or may be re-issued.

To properly design such a slicing brokering process, a deep understanding of the slice queuing behavior is needed that accounts, for e.g. the average slice duration (based on the slice type), the frequency of slice requests (based on the tenant), etc. This enables a Slice-as-a-Service (SlaaS) [5] solution that fully supports on-demand slices requests: tenants issue slice requests for given periods of time and decide whether to re-issue the same request upon rejection based on service level agreements. Advanced slicing admission control solutions may have different policies for tenants frequently asking for short-term slices—such as Internet-of-Things (IoT), or crowded event-based network slices—as they will automatically re-issue the same request in the near future, with respect to those that require only few longer network slices—such as Mobile Virtual Network Operators (MVNOs) or Industrial Network Slices [6]—which may be probably lost if not accepted. Moreover, similar as widely recognized in all kinds of queuing systems for service scheduling, tenants may be impatient and choose to leave for another available infrastructure provider instead of waiting in queue, especially when the expected waiting time is long. Such behavior shall also be taken into account while designing a slicing admission control solution to mitigate potential revenues loss in case of resource congestion.

While conventional admission control problems have been extensively studied in the literature, we pioneer a new stochastic model for network slicing that leverages on the multi-queuing system to optimally design an admission control of on-demand network slices as well as to orchestrate them once are accepted. This also allows to account for impatient tenant behaviors and heterogeneous network slice characteristics while, at the same time, enforcing given performance metrics, such as fairness between different tenants or between network slice types or utility-based maximization.

II Model design

We cast our problem into a typical network slicing scenario, where the Mobile Network Operator (MNO) decides to lease infrastructure resources to tenants, willing to pay to take over the control of an independent network slice so as to deliver an end-service to their own users. Hereafter, we deeply describe our assumptions and mathematically formulate the problem.

II-A Resource pool and slice types

Let us consider a single MNO that possesses a static resource pool of $M$ different resources and offers $N=|\mathcal{N}|$ pre-defined types of slices. Depending on the slice type $n\in\mathcal{N}$, it costs a certain resource bundle to create and maintain a slice. Let $\mathbf{r}=[r_{1},r_{2},\dots,r_{M}]^{\text{T}}$, $\mathbf{s}=[s_{1},s_{2},\dots,s_{N}]^{\text{T}}$ and $\mathbf{c}_{n}=[c_{1,n},c_{2,n},\dots,c_{M,n}]^{\text{T}}$ denote the resource pool, the set of slices under maintenance and the resource bundle required to maintain a slice of type $n\in\mathcal{N}$, respectively. The assigned resources can be then represented as

[TABLE]

where $\mathbf{C}=[\mathbf{c}_{1},\mathbf{c}_{2},\dots,\mathbf{c}_{N}]$. At any time instance, the MNO cannot simultaneously maintain more slices than its resource pool may support. This constraint is expressed using the space of resource feasibility[7]:

[TABLE]

Note that $\mathbb{S}$ is a finite discrete set, thus the MNO can be characterized as a finite state machine where each slice set under maintenance represents the system state $\mathbf{s}\in\mathbb{S}$.

II-B Slice admission in SlaaS

We consider a certain number of tenants randomly generating network slice requests. Slices requested by a certain tenant are of the same type. For each tenant, the inter-arrival time between two requests is drawn from an exponential distribution. The request arrivals of different tenants are independent and identically distributed (i.i.d.).

Once a request for slice creation is triggered, the MNO makes a binary decision, i.e., the MNO either accepts or declines it. Upon acceptance, the requested slice is created, and continuously maintained so that a corresponding bundle of network resources is occupied until the slice is terminated (at the end of its lifetime) and the resource bundle is released. It should be noted that the constraint of space of resource feasibility forbids the MNO to accept any request when its current state is close to the border of $\mathbb{S}$. In other words, if the current MNO resource pool is close to be saturated by active slices, it does not accept additional network slice requests that might experience a service disruption. This introduces the well-known concept of admissibility region111The admissibility region has been exhaustively studied in the literature for different use cases and scenarios. We refer the reader to [8], where a stochastic admissibility region is derived for a network slicing admission control. described as

[TABLE]

where $\Delta\mathbf{s}_{n}$ is the unit slice incremental vector of type $n$

[TABLE]

We assume that the lifetime of every slice is an i.i.d. exponentially distributed variable and the expected lifetime depends on the slice type. We also consider that the MNO makes every decision according to a consistent slicing policy, i.e., the decision depends only on the type of requested slice $n$ and the current system state $\mathbf{s}$ that defines the current set of slices under maintenance.

II-C Delayed reattempt upon request denial

If a request for slice creation is declined—because of a temporary shortage of available resources due to many other active slices—the tenant is not able to obtain the requested slice immediately. Instead, its request may be sent to the MNO again for a reconsideration after some delay with the hope that some running slice has expired (i.e., resources have been released). Generally, there are two critical features of the delaying mechanism, which should be taken into account: $i$) resource efficiency and $ii$) fairness. The former requires that the chosen mechanism purses the resource pool utilization maximization whereas the latter requires that the expected delay for different requests is normalized.

Two categories of approaches are commonly used to solve this kind of problem:

Random delay. Every declined request is re-proposed to the MNO after a random delay. This approach provides a good fairness, but generates extra signaling overhead in the control plane being not able to provide the discipline of “First Come, First Served” (FCFS), as described in the next section.

Queuing. Declined requests wait in one or multiple queue(s) for the next opportunity during the MNO’s decisional process. This is the most common solution in cloud service scheduling.

Hereafter, we show how a multi-queuing system may be fully exploited to provide insights on the system behaviors and pave the road towards a slicing orchestration solution.

III Network slicing queuing

In the literature a number of various disciplines have been studied to serve the request queues. Among the others, the most common policies are $i$) First come, first served (FCFS), $ii$) Last come, first served (LCFS), $iii$) Random selection for service (RSS) and $iv$) Priority-based (PR). All of them analyze different behaviors and are used to achieve distinct performance metrics. For instance, the LCFS is used to reduce the fairness whereas the priority-based is implemented when there is some high-level preference of the MNO to be considered. RSS shows huge complexity in the implementation without bringing any significant advantage with respect to the others. Hereafter, we focus on the FCFS case. However, any other discipline may be easily adapted to our analysis.

III-A Queuing schemes

We differentiate the queuing systems into two different categories: $i$) single-queue and $ii$) multi-queue systems. When considering the single-queue, only one queue is implemented for all declined requests that need to wait for the next acceptance opportunity. Conversely, the multi-queue system implements multiple queue for declined requests. Specifically, such queues may show different features. We consider homogeneous-mixed queues, wherein each queue consists of requests for slices of different types, and heterogeneous queues, where each queue is specified for only one unique slice type. We next show a simple case-study to justify that the queuing system is suitable for this kind of problems.

III-B Resource efficiency: a simple case-study

Consider a simplified case where $M=1$, $N=2$, $\mathbf{r}=[1]$, $\mathbf{c}_{1}=[0.6]$, $\mathbf{c}_{2}=[0.2]$ and $\mathbf{s}=[1,0]^{\text{T}}$. The first four requests awaiting in the queue(s) are in the sequential order $[1,1,2,2]$. The MNO is taking a greedy strategy that intends to accept all requests received so far the resource pool supports.

Both in the schemes with a single queue and two homogeneous queues, the MNO fails to accept requests of type $2$ as the type $1$ requests are preventing their acceptance. Hence, it has to wait until the currently active slice of type $1$ is released before it can accept the next request in the queue, although it has both enough idle resource and the intention. The heterogeneous multi-queue scheme, in contrast, enables the MNO to fully utilize its resource pool as shown in Fig. 1.

Obviously, both the single-queue and the homogeneous multi-queue schemes can also overcome this issue by introducing a “queue-jumping” mechanism. However, this may require an extra design of (more complex) logic that automatically (and dynamically) decides which request is allowed to jump in the queue(s). Therefore, in this study we consider the scheme with $N$ FCFS heterogeneous queues.

IV Heterogeneous multi-queue admission control

Based on the heterogeneous multi-queue scheme, we propose in this section a novel code to present the MNO’s preference for different slice types in variable states, a multi-queue admission controller for SlaaS, and analyze its queue model.

IV-A Slice-type preference encoder

Differing from existing studies that do not consider queuing and the single-queue scheme, in the multi-queue scheme, the MNO may receive multiple requests for slices of different types simultaneously. Therefore, instead of making a simple binary decision of accepting or declining one request, it has to either choose one from the simultaneously arriving requests to accept while declining the rest ones, or decline all of them. Especially, with heterogeneous queues, the MNO’s preference for some request queue(s) over the others implies its proclivity to some slice type(s) against the others.

For an MNO that offers $N$ different slice types to tenants for request, we can encode an arbitrary preference of the MNO into a preference vector of length $N+1$:

[TABLE]

which is a permutation of $\{0,1,2,\dots,N\}$. The earlier a queue number $1\leq n\leq N$ occurs in $\Phi$, the more likely the MNO prefers slice type $n$ over the others. Note that $n=0$ denotes reserving resource for potential opportunities in future, so that all requests in the queues with values occurring in $\Phi$ after [math] will not be served by the MNO at all.

While being in states on (or close to) the border of space of resource feasibility $\mathbf{s}\in\mathbb{S}-\mathbb{A}$, the MNO cannot accept further request from any queue, hence the preference does not make any impact. Thus, we focus on the admissibility region $\mathbb{A}$ and assume that the MNO’s preference is consistent and depends only on its current state $\mathbf{s}\in\mathbb{A}$. Thus, we can characterize the MNO’s admission strategy with a $(N+1)\times|\mathbb{A}|$ preference matrix as the following

[TABLE]

where each column $\Phi_{i}$ represents the MNO’s preference for different slice types in a specific feasible state in $\mathbb{A}$.

IV-B Mechanism overview

Let $l_{n}$ denote the length of the $n^{\text{th}}$ queue, the decision entity executes the algorithm described in Fig. 2. The MNO keeps waiting for incoming tenant issues and responses to them upon issue arrivals. If the tenant issues to release a slice of its own, the MNO always releases it. If the tenant requests for a new slice, the request will be pushed into the corresponding queue with respect to the type of requested slice. After responding to the issue, the MNO will recursively serve the request queues in a sequence determined by its admission strategy and active slice set, until no more waiting request can be accepted. Then it stops serving the queues and waits for the next tenant issue.

V Network slicing controller design

We analyze different characteristics of the conventional queuing models, highlighting the novel features applied to our model while designing the network slicing controller. This helps to shed the light on the main advantages and limitations of our novel admission control model.

V-A Analysis of inter-acceptance time

We consider request arrivals of every slice type as an independent Poisson process, so that the inter-arrival time between requests in every queue is an independent exponential random process. Conversely, the request acceptance rate of every queue is jointly determined by the slice releases of all types, and the MNO’s preference strategy.

Theorem 1**.**

*Consider a heterogeneous multi-queue slice admission controller that executes the algorithm in Fig. 2 with a consistent preference matrix. The acceptance in different queues are mutually independent Poisson processes, if:

1. the arrivals of new requests and releases of active slices are mutually independent Poisson processes for every individual slice type;

2. the arrivals of different slice types are mutually independent from each other, the releases of different slice types are mutually independent from each other.

Proof.

First, extend the system (MNO) state $\mathbf{s}$ with all queue lengths to obtain the controller state $\hat{\mathbf{s}}=[\mathbf{s},l_{1},l_{2},\dots,l_{N}]$, and therefore the infinite discrete domain $\hat{\mathbb{A}}=\mathbb{A}\times\mathbb{N}^{N}$. Let the bijection $\mathbb{A}\leftrightarrow\{1,2,\dots,|\mathbb{A}|\}$ denoted by $I=I_{\mathbb{A}}(\mathbf{s})$, we call $\hat{\mathbf{s}}\in\hat{\mathbb{A}}$ a transient state if $\exists n\in\mathcal{N}$ such that:

[TABLE]

Otherwise, we call $\hat{\mathbf{s}}$ a steady state. According to the algorithm in Fig. 2, when the controller is in a transient state it always accepts a request in its queues immediately and therefore keeps jumping to another state until it reaches a steady state. Every transient state leads to one and only one certain steady state. On the other hand, the controller can reasonably (but not always) leave a steady state only when a new request arrives or a slice is released.

Thus, given a certain sequence of request arriving and slice releasing events in the next period, we can obtain the transition path of the controller state, and therewith determine whether the first awaiting request in an arbitrary queue will be accepted during that period. Denote the time that the first awaiting request in the $n^{\text{th}}$ queue still has to wait until it is accepted as $t_{\text{w},n}$, it yields that

[TABLE]

where $\mathbb{E}_{n}$ is the set of all event sequences that can lead to an acceptance of request in the $n^{\text{th}}$ queue, and $Arr(T)$ denotes the event sequence arriving in the next period of $T$. As the request arrivals and releases of different slice types are mutually independent Poisson processes, we know that all $\mathbf{e}\in\mathbb{E}_{T}$ are also approximately Poissonian (proven as a feature of dependent trials [9, 10]). Thus, due to the Markovian behavior of Poisson processes, we can write the following

[TABLE]

and thus

[TABLE]

Eq. (12) implies that the remaining waiting time for acceptance of the first request in queue $n$ is memoryless. Due to the fact that the only two classes of memoryless distributions are exponential (continuous) and geometric (discrete) distributions, we can assert that the request acceptance in every queue is a Poisson process. ∎

V-B Queuing-theoretic analysis

While considering both request arrivals and request acceptances (service) as Poisson processes, every request queue is a classic $\text{M}/\text{M}/1$ queuing system, known as single-server birth-death system [11]. Hence, many features of birth-death model can be directly applied.

V-B1 Little’s Formula

For slice type (queue) $n$, given its request arrival rate $\lambda_{n}$, according to the famous Little’s formula[12] there is

[TABLE]

where $L_{n}$ and $\overline{W}_{n}$ represent the mean length of queue $n$ and the average waiting time in queue $n$, respectively.

V-B2 Steady Queue State Probability

Given the request arrival rate $\lambda_{n}$ and acceptance rate $\mu_{n}$ of queue $n$, the probability that the queue steadily consists of $l$ requests at an arbitrary time instant is geometrically distributed, i.e.,

[TABLE]

where $\rho_{n}=\lambda_{n}/\mu_{n}<1$ is the work load rate of queue $n$.

V-B3 Waiting Time Distribution

The probability density function (PDF) of an arbitrary type-$n$ request’s waiting time is

[TABLE]

and the cumulative density function (CDF) is

[TABLE]

V-C Extension: impatient tenants

From Eqs. (13–16) it is clear that both $L_{n}$ and $W_{n}$ converge only when $\lambda_{n}<\mu_{n}$. Otherwise, when the request acceptance rate is lower than the arrival rate in queue $n$, the queue length will infinitely increase, and therefore also the mean waiting time. This is known as the necessary and sufficient condition of statistical equilibrium in queuing processes, as stated and proven by Kendall in work [13].

However, in a real slice admission controller, there are various situations where $\lambda_{n}\geq\mu_{n}$ for some $n$, including cases

• •

when the controller is specified with an inappropriate strategy, so that requests in the queue $n$ is rarely or even never accepted despite of resource feasibility;

• •

when the release rates of active slices are low, so that the resource pool fails to support a sufficiently high $\mu_{n}$ regardless of any admission strategy.

There are two mechanisms that prevent queuing systems from such divergence. On the one hand, the system may force to truncate a queue at some maximal length, and forbid this queue to take any new request before it is shortened. On the other hand, the clients may lose patience while waiting, and leave the queues before being served (e.g., for looking for some other MNO with resource availability). In the scenario of SlaaS, the system (MNO) is probably very cautious with refusing requests, while the waiting time can be critical to the customers (tenants). Therefore, here we consider no queue truncation but queues with impatience.

Usually, impatience in queues can occur in three different behaviors: $i$) balking, i.e. customers being reluctant to join a queue upon arrival, $ii$) reneging, i.e. customers leaving the queue after joining and waiting, and $iii$) jockeying from long lines to shorter ones. As the heterogeneous multi-queue design disables jockeying, here we consider the balking and reneging phenomena.

Balking Model. The phenomenon of balking can be modeled in such a way, that every arrival request of slice type $n$ enters the queue with a probability $b_{n}$, which is a monotonically decreasing function of the current queue length $l_{n}$. Ancker and Gafarian have proposed two different balking models in [14, 15]. The first model considers a linear balking factor $1-b_{n}=l_{n}/l_{n,\max{}}$, where $l_{n,\max{}}$ is the upper bound of $l_{n}$ for queue truncation. The second one considers a non-linear balking factor as follows

[TABLE]

where $\beta_{n}\in[0,1]$ measures the willingness of tenants requesting type-$n$ slices to wait. In cases that the tenant has knowledge about $\mu_{n}$, Shortle et al. suggest another non-linear balking model $1-b_{n}=1-e^{-\beta_{n}l_{n}/\mu_{n}}$ where $\beta_{n}>0$ [11]. Here we consider the hyperbolic balking model described by Eq. (17).

Reneging Model. The phenomenon of reneging can be modeled by randomly assigning an individual maximal waiting time to every request when it joins the queue. The request will leave the queue after that maximal waiting time if it has not been accepted yet. Following Ancker and Gafarian [15], we consider the maximal waiting time for every type-$n$ request as an exponential random variable $W_{\max{},n}\sim\text{Exp}(\alpha_{n})$, where $1/\alpha_{n}>0$ is the mean maximal waiting time in queue $n$.

V-D Performances with balking and reneging

It should be noted that the balking and reneging processes are with memory, leading to a non-Markovian behavior of request acceptances. However, under low balking and reneging rates, this impact can be negligible and the acceptance process can still be approximated as Poissonian. When the balking and reneging rates rise to significant levels, the memory of acceptance process shall be considered, as demonstrated in Section VII-A by means of simulations.

Under a combination of hyperbolic balking and exponential reneging, the steady state probability of having $l$ requests in the queue $n$ is

[TABLE]

where $\gamma_{n}=\mu_{n}/\alpha_{n}$, $\delta_{n}=\lambda_{n}\beta_{n}/\alpha_{n}$, $I_{\gamma_{n}}(\cdot)$ is the modified Bessel’s function of the first kind and order $\gamma_{n}$.

Meanwhile, we are interested in three different distributions of waiting time spent in a queue $n$: $i$) $f_{\text{a}}(W_{n})$ for requests that are eventually accepted, $ii$) $f_{\text{r}}(W_{n})$ for requests that renege and $iii$) $f_{\text{q}}(W_{n})$ for all requests that join the queue. Let us define $A_{n}$ and $J_{n}$ as the events of request being accepted and joining the queue $n$, respectively. There are

[TABLE]

It can be obtained that

[TABLE]

where $g(W_{n})=\int_{0}^{W_{n}}e^{\alpha_{n}\xi}f_{\text{a}}(\xi)\text{d}\xi$.

The expectations of waiting times are therefore

[TABLE]

VI Strategy optimization

In slice admission control, there are various performance metrics that may include: the overall network utility rate, the admission rate and the average request waiting time.

The network utility of a slice can be differently defined, such as the periodical payment that the MNO receives from the tenant, or the generated network throughput, etc. It is common to consider the utility rate of a slice as determined by the slice type, and the overall network utility rate at any time instant $t$ as the sum of utility rates of all slices under maintenance:

[TABLE]

where $s_{n}(t)$ is the number of type-$n$ slices under maintenance at time $t$, and $u_{n}$ is the utility rate of every type-$n$ slice. In long term, the average overall network utility rate can be estimated from the acceptance and releasing rates of different slice types:

[TABLE]

where $\eta_{n}$ is the releasing rate per type-$n$ slice.

The average waiting time of all requests in queues is

[TABLE]

The overall admission rate is the following

[TABLE]

All three criteria are determined by the request behavior parameters $\alpha_{n},\beta_{n},\lambda_{n}$ and the acceptance rate $\mu_{n}$. Given a certain combination of $[\alpha_{n},\beta_{n},\lambda_{n},\eta_{n}]$, where $1/\eta_{n}$ is the average lifetime of type $n$ slices, $\mu_{n}$ is uniquely determined by the MNO’s strategy, i.e. by the preference matrix $\mathbf{\Phi}$. Hence, with consistent behaviors of request arrival and slice releasing, we can optimize either of them by selecting the best $\mathbf{\Phi}$.

A major challenge for analysis exists in the complex relation between the acceptance rates $[\mu_{1},\mu_{2},\dots,\mu_{N}]$ and the strategy $\mathbf{\Phi}$, as $\mathbf{\Phi}$ does not directly imply the MNO’s action or statistics, but only its preference.

Nevertheless, if the steady-state probability of queue lengths $p_{n}(l)$, as defined in Eq. (14), is known or measurable for all $n\in\mathcal{N}$, we can estimate $\mu_{n}$ for all $n$ with respect to $\mathbf{\Phi}$ and the initial state $\mathbf{s}_{\text{init}}$ as follows.

First, define a bijection $\mathbb{S}\leftrightarrow\{1,2,\dots,|\mathbb{S}|\}$ as $J=J_{\mathbb{S}}(\mathbf{s})$ where $J_{\mathbb{S}}(\mathbf{s})=I_{\mathbb{A}}(\mathbf{s})$ for all $\mathbf{s}\in\mathbb{A}$. Then extend the definitions in Eqs. (4), (6) and (14) with

[TABLE]

respectively. The probability of state transition from any $\mathbf{s}\in\mathbb{S}$ to $\mathbf{s}+\Delta\mathbf{s}$ can be then calculated as

[TABLE]

Thus, when the initial state $\mathbf{s}_{\text{init}}$ is known, we can obtain the long-term probability distribution of system state $\mathbf{s}$ as

[TABLE]

where $\mathbf{\Psi}$ is the transition matrix:

[TABLE]

and $\Psi_{i,j}=\text{Prob}(\mathbf{s}_{i}\to\mathbf{s}_{j})$.

More generally, if not the exact value but the probability distribution of the initial state is available as $P_{\text{init}}=[p_{\text{init}}(\mathbf{s}_{1}),p_{\text{init}}(\mathbf{s}_{2}),\dots,p_{\text{init}}(\mathbf{s}_{|\mathbb{S}|})]$, the long-term probability distribution $\mathbf{s}$ is the following

[TABLE]

We can obtain the expected active slice number $\overline{s}_{n}$ of every slice type $n$ as a function of $\mathbf{\Psi}$ and thus, as a function of $\mathbf{\Phi}$. Now, recalling Eqs. (28–29) it yields that

[TABLE]

and then we can write the following

[TABLE]

Based on this analytical expression, we are able to optimize $[\mu_{1},\mu_{2},\dots,\mu_{n}]$ with respect to $\mathbf{\Phi}$. However, it is evident that Eq. (40) is non-convex w.r.t. $\mathbf{\Phi}$, which prohibits analytical solution of the global optimum. On the other hand, the overall domain size of $\mathbf{\Phi}$ is $2^{(N+1)|\mathbb{A}|}$, which can assume unaffordable high values for any realistic dimension of $|\mathbb{A}|$ in practical networks, making the exhaustive search impossible. This is an integer linear programming (ILP) problem that is proven to be NP-Hard, therefore advanced machine learning and heuristic search methods are needed to solve it with affordable efforts of computation.

VII Numerical simulations

To carry out simulations in a consistently specified environment, we consider an MNO with a two-dimensional ($M=2$) normalized resource pool $\mathbf{r}=[r_{1},r_{2}]=[1,1]$. $N=2$ slice types are defined in two service demand scenarios, as shown in Tab. I. Note that $\alpha_{n}$ and $\beta_{n}$ are only applicable when the simulation considers balking and reneging, respectively.

VII-A Verification of geometric IAT distribution

In case of patient tenants, Theorem 1 can also be verified through numerical simulations. We take the slice specifications in scenario $1$, disable balking and reneging events, and randomly generate $500$ slicing strategies. For each strategy, $20$ rounds of Monte-Carlo tests are executed. In each testing round, an MNO with a 2-queue slice admission controller is initialized to a random but fully resource-utilized state, and then operates under the consistent strategy for $40$ operations periods. Then we investigate the distribution of inter-acceptance time (IAT) for each queue, and fit the measurements with geometric distributions, which is the discrete-time version of exponential distribution. A sample result is shown in Fig. 3(a), where a good fitting performance can be observed.

To quantitatively evaluate the fitness, we compute the Kullback-Leibler divergence (KLD) [16] for every strategy:

[TABLE]

where $p_{\text{IAT}}(k)$ is the empirical probability mess function (PMF) of the measured IAT, and $(1-\hat{p})^{k}\hat{p}$ is the geometric PMF with fitted parameter $\hat{p}$. KLD is an indicator of fitness between two distributions, which equals [math] for two identical distributions and approaches to $1$ for two completely irrelevant distributions. The KLD distribution over all $500$ tested random strategies is depicted in Fig. 3(b), which shows a satisfactory fitness for both queues (slice types).

Furthermore, to verify the impact of impatient tenants’ behavior, we activate the mechanisms of balking and reneging, and repeat the aforementioned simulation procedure in both scenarios $1$ and $2$. The results are illustrated in Fig. 4. Compared to the case of patient tenants, we can observe an increase of KLD in both scenarios here, especially in scenario $2$, confirming our assertion that the behaviors of balking and reneging will remove the Markovian feature of the system. However, when the balking and reneging rates are low (e.g., when the queues are short such like in scenario $1$), such impact can be slight enough to be neglected.

VII-B Evaluation of the proposed controller

To verify the effectiveness and potential in optimization of the proposed multi-queue slice admission controlling mechanism, we generate $10\leavevmode\nobreak\ 000$ random strategies, and measure all three above-mentioned performances metrics $\overline{u}_{\Sigma}$, $\overline{W}_{\text{q}}$ and $\overline{P}(A)$ for every strategy in both reference scenarios $1$ and $2$. Similar to the last tests, every strategy is evaluated through a $20$-round Monte-Carlo test where each round begins with a random initial state and lasts $40$ operations periods. Impatient tenants are considered.

To provide benchmarks, we test the controller with two specific “naïve” strategies: Prefer Type 1: the preference vector is $[1,2,0]$ at all system states; Prefer Type 2: the preference vector is $[2,1,0]$ at all system states. Moreover, we implement and test a simple “greedy” single-queue slice admission controller that always accepts the first request in its queue regardless of type, as long as the resource pool supports.

The results are illustrated in Fig. 5. It can be observed that the multi-queuing controller, when specified with an appropriate strategy, outperforms the greedy single-queue solution in admission rate, especially when the demand is dense and queues are congested. However, it shall be noted that the performances highly rely on the selection of strategy, leading to a critical necessity of strategy optimization.

VIII Further discussion

In practical wireless networks, both the dynamics of resource availability (e.g. channel fading) and the resource elasticity of active slices must be taken into account. The model in this paper is an approximation with a static resource pool $\mathbf{r}$ and rigid slices, which holds in long-term with appropriate dynamic scheduling to multiplex slices. Note that such a slice multiplexing implicitly enables slice overbooking with a risk to break SLAs [17, 18]. The challenge of balancing the multiplexing gain and the overbooking risk in heterogeneous multi-queue admission control settings deserves future study.

It shall also be noticed that the assumptions of Poisson arrivals/releases may not hold in some practical service scenarios. In this case, the queues are not $M/M/1$ systems and cannot be considered as continuous-time Markov systems. Nevertheless, as pointed out in [11], many such continuous-time non-Markov processes can be easily transformed into discrete-time Markov chains by observing only the state transitions. Therefore, the analyses given above also apply to most scenarios with non-Poisson request arrivals/releases.

IX Related work

We summarize in the following the main research efforts in the literature on the topic of Slice-as-a-Service, queuing theory for cloud services and network slicing admission control.

An overview on multi-tenancy service and 5G network slicing is given in [3] from perspectives of architecture and standardization, introducing the novel concept of network slice broker which executes the admission control. Different attempts have been made in [5, 8] and [19] to demonstrate how admission control can benefit the network resource utilization.

While we have considered network slicing in a generic and abstracted view, which is generally applicable in both radio access network (RAN) and core network (CN) domains, recently there has been a dense specific research interest for RAN slicing and its impact on radio resource management (RRM). On that [20] and [21] provide interesting solutions for efficient resource management and orchestration. From the perspective of slicing admission strategy optimization, the methods reported in [8, 5, 7] can be worthwhile to refer. Although all these works only consider a binary decision mechanism where declined requests simply vanish instead of being served after a delay, the algorithms deployed by them to solve ILP problems will inspire future development of model-less heuristic strategy optimizers for the proposed multi-queue slice admission controller.

SlaaS shall be considered as a specific type of public cloud environment, where service sessions can be categorized into multiple types with significantly heterogeneous resource demands. Queuing theory has been widely applied for cloud computing services to model the statistics of service demand and delivered quality of service (QoS), such as [22] and [23]. Especially, service schedulers with heterogeneous queues for different service types are discussed in [24] and [25]. These models provide valuable reference views in addition to the model proposed in this paper. Finally, balking and reneging behavior of impatient clients in queuing systems are extensively studied in [26, 27].

Differing from the aforementioned works wherein a “strategy” usually represents the decision as a function of the system state, our study proposes a novel mechanism of multi-queuing slice admission control where the slicing strategy represents the MNO’s preference of slice types in different system states. Besides, out paper also considers impatient tenants, which, from the best of our knowledge, has never been investigated in SlaaS environments.

X Conclusion

The network slicing paradigm plays a key-role in the next generation of networks design. However, it involves a number of challenges while devising an admission control solution that takes into account complex network tenants behaviors.

In this paper, we have proposed a multi-queue-based controller that automatically accounts for tenants waiting to get their requests network slices with given request frequency and patience characteristics. Our results validate the proposed model showing that unexpected tenants behaviors may be properly addressed with advanced admission control policies.

Acknowledgments

This work has been partially funded by the European Union Horizon-2020 Projects 5G-MoNArch and 5G-Transformer under Grant Agreements 761445 and 761536 as well as by the Network for the Promotion of Young Scientists (TU-Nachwuchsring), TU Kaiserslautern with individual funding.