Modeling a Linux Packet-Capturing System with a Queueing System with Vacations

Abstract

Monitoring the evolution of the state of networks is an important issue to ensure that many applications provide the required quality of service. The first step in network-monitoring systems consists of capturing packets; that is, packets arrive at the system through a network interface card and are placed into system memory. Then, in this first stage, and usually in relation to the operating system, packets are treated and transferred from the capturing buffer to a higher-layer processing, for instance, to be analyzed in the next step of the system. In this work, we focus on the capturing stage. In particular, we focus on a Linux packet-capturing system. We model it as a single server queue. Taking into account that the server can be in charge not only of the capturing process but also of other tasks, we consider that the queue has vacations, i.e., there is some time when the capturing process cannot be carried out. We also assume that the queue has a finite buffer. We consider three different models and present a rigorous analysis of the derived Markov chain of each of the models. We provide standard performance metrics in all cases. We also evaluate the performance of these models in a real packet-capture probe.

1. Introduction

There is a wide range of applications where the interest resides in identifying the following facts: (i) when the structure of a network changes over time, or (ii) whether some subnetwork is different from the network in which it is contained in some meaningful way. Network monitoring is known to be the field that identifies such changes [1]. Telecommunication companies currently have a big interest in understanding the performance of modern network-monitoring systems [2].

In a network-monitoring system, the first phase consists of capturing the packets from the network to obtain the raw measurement data. This data is then analyzed and presented to the network operators. Recently, several solutions have been presented in the literature to achieve good performance in network-monitoring systems; for instance PF_RING [3], PacketShader [4], Netmap [5], PFQ [6], DPDK [7], OpenOnLoad [8], and HPCAP [9].

However, our goal is to develop a mathematical model to study the performance of network-monitoring systems. In this work, we focus on the capturing phase of a network-monitoring system. The object of our research is to predict the performance of that packet-capturing system by using the solution of a queueing model. Our modeling proposal is a queueing system formed by a single queue with one server. We are interested in the case of network devices with limited resources. Therefore, we will assume that the system only has one processor and one network card. Furthermore, we consider that the network-monitoring system under study needs to perform other tasks when the capturing phase is activated. This means that the server that is in charge of the capturing phase needs to stop this work to deal with other tasks. This is the case, for instance, when the server needs to capture and analyze the data [10]. Here arises the concept of vacation, which represents the period of temporary absence of the server. With all this, we will estimate some performance metrics, such as throughput and probability of packet loss, under different incoming packet traffic conditions and vacation scenarios.

There is a considerable amount of work that models telecommunications networks by using queueing theory, ranging from the very old to the very new systems [11]. Among those published in recent years, we can mention [12], in which an analytical model was elaborated upon to predict some traffic characteristics, quality of service (QoS) indicators, and the overall network performance. In [13] it is proposed a conceptual model of overall telecommunication system with a queueing system; this analytical model was used to solve aspects such as dimensioning of the network and predicting the QoS.

Other even more recent works are related to fifth-generation (5G) networks. In [14] it is presented a queueing model to control the number of user plane functions (UPF) in a 5G network; the system is described by a two-dimensional continuous time Markov chain (CTMC). The authors in [15] developed an analytical queueing model to analyze the network slicing strategies for 5G networks; the solutions and the system’s performance metrics were derived from a two dimensional Markov chain. The authors in [16] formulated a queueing-based model and used it at the network orchestrator to optimally perform a virtual network function (VNF) placement and a resource allocation for the support of the vertical’s requirements in 5G networks. The authors in [17] studies how to determine various performance metrics (system’s waiting time, the throughput and number of resources required to meet users’ needs) of a a vehicular ad hoc network (VANET) with two queueing theory models, namely the M/M/c and the M(N)/M/c models. We can also cite some work on software-defined networking (SDN) modeling. [18] assessed the quality of SDN operation by estimating the average values of packet delay time in M/G/1 and G/G/1 systems for SDN.The authors in [19] proposed an analytical Markovian queueing model based on M/M/c to manage the traffic that transit via the 5G access networks to SDN architecture.

However, we notice the literature regarding mathematical modeling in the field of packet-capturing systems is scarce. For instance, [20] presents the Linux packet-receiving system as a combination of (i) the token bucket algorithm that fits to the network card and device driver-receiving process, and (ii) a queueing system that models the rest of the packet-receiving process. In [21,22], firewalls are represented by a finite queueing system with multiple stages, and the first stage refers to the packet-capturing phase. Finally, another interesting approach is [23] which proposes an analytical model to formulate the performance of the main techniques adopted by three high-speed packet I/O frameworks, such as Netmap, Intel DPDK, and PF_RING ZC.

The main difference of our model with related works is that, in our work, we model a Linux packet-capturing system by using a queueing system with vacations. Queueing systems with vacations have been studied in queueing theory [24,25], but to the best of our knowledge, this work is the first to consider vacations in a model for the capturing phase of a network-monitoring system.

We present three different models. In all cases, there is a limited waiting room in the queue. However, we now present the differences between the models we study. For the sake of clarity of the presentation, we start with the simplest model and we finish with the most difficult one.

• In the first model, M1, we consider exponential service times and the fact that there is not a limitation on the number of packets that can be served. This means that if the capturing process is active, it does not end until there is no packet left in the buffer. It is at this time when the system returns to vacation.
• In the second model, M2, we consider exponential service times with a limited budget of the capturing phase. The budget indicates the maximum number of packets that can be served without a vacation.
• In the last model, M3, we consider arbitrary service times and the fact that the budget of the capturing phase is limited.

The main contribution of this work is to develop the Markov chain related to each of the queueing models we consider and to determine analytical expressions of the performance metrics of all the systems. It is important to remark that model M1 generalizes the work of [26] and model M2 generalizes the work of [27]. In both M1 and M2, we consider an initial phase, which we call the hardware interrupt, which is not considered in [26,27].

The rest of the article is organized as follows. In Section 2, the mechanism of the Linux packet-capturing system and the proposed queueing model that represents it are described. Then, Section 3, Section 4 and Section 5 present the model analysis for three cases of interest: (1) analysis for exponential time distributions and infinite budget, (2) analysis for exponential time distributions and finite budget, and (3) analysis with time distributions of a general type and finite buffer, respectively. The model validation and the obtained results are discussed in Section 6. Finally, we conclude the paper in Section 7.

2. Model Description

This section presents the general aspects of the model that will represent the Linux packet-capturing system. Our model is based on a finite queueing system with vacations. However, before detailing the characteristics of the model, it is necessary to explain how that packet-receiving process works. We will focus on the mechanism called New API (NAPI).

2.1. Linux Network Subsystem

Figure 1 shows the trip of a packet from its arrival on a network interface to its delivery to the user-space application. First, packets arrive at the network interface card (NIC) from the network. Then, packets are transferred into a ring buffer in kernel memory via direct memory access (DMA). It should be pointed out that the DMA transfer does not require any CPU consumption. If the network card drives many packets into the ring buffer but the kernel does not extract them, the buffer will eventually fill up, and new, incoming packets can be rejected.

Traditionally, when a packet was written to kernel memory via DMA, an interrupt request (IRQ) was generated to indicate, to the rest of the system, that data is ready to be processed. However, if large numbers of packets arrive, this can lead to a large number of IRQs. The more IRQs are generated, the less CPU time is available for higher-level tasks (such as user processes). In order to avoid the risk to consume almost all of the CPU time by a high number of IRQs, the Linux network subsystem addresses this issue through NAPI. Drivers based on NAPI use a mechanism that mixes polling and interrupt-driven processing [28]. Therefore, there are two parts: the hardware interrupt (hardirq, henceforth) and the software interrupt (softirq, henceforth). The hardirq is involved by the IRQ handling. It is the fast part (or top half), and it only performs critical actions that cannot be delayed. On the contrary, the softirq is the slower part, or bottom half, it polls the ring buffer to process network packets, and it avoids looping for too much time in a hardirq handler.

When there are no packets in the ring buffer and the first one is written via DMA, the device raises the hardirq that is assigned to it. The interruption service routine (ISR), which runs when a hardirq is raised, is short and performs the following operations.

• Hardirqs related to the network card are disabled.
• The network interface is registered in the poll list of the CPU that is executing the hardirq handler. There is only one poll list in each CPU.
• A function is called to schedule the execution of a softirq (netif_rx_schedule() in Figure 1). The softirq will be triggered later, when the Linux process scheduler allocates CPU resources to it.
• The correct reception of the interruption is also acknowledged to the network card.

When the softirq is invoked, ring buffer packets begin to be treated. The softirq poll() loop aims to transfer packets from the ring buffer to the upper-level structure that is ready to receive data. As Figure 1 shows, this action involves calling several functions (marked with 3 and 4 in Figure 1), as well as using structures named skb [29]. When a packet is dequeued from the ring buffer, its corresponding packet descriptor needs to be reinitialized and refilled.

Since one CPU can handle multiple network cards, during the softirq, the CPU polls each device that is registered in its poll list. In each poll, there is a maximum number of packets that the softirq can process. That limitation is called weight, and its typical value is 64. When the weight is reached, the softirq moves to poll the next device. If the poll does not consume its entire weight, this means that all the packets from that device have already been transferred and, therefore, that device should be removed from the poll list.

Furthermore, there exist other limitations for the softirq.

• The total number of packets that the softirq can handle is limited by the parameter named “budget”. Its default value is 300. When this maximum is reached, the softirq finishes.
• The softirq will still be bounded by a time limit of 2 jiffies, regardless of the assigned budget [30].

If the softirq finishes and there are still packets to pull out, a new softirq is scheduled. On the contrary, once there is no more work to do (that is, there are no more devices registered in the poll list), the NAPI subsystem is disabled and IRQs from the device are reenabled; in other words, there is no scheduled softirq, and hardirqs are enabled again. The process will start back when the first packet arrives at the ring buffer.

2.2. Finite Queue with Vacations

The packet-capturing system described above is modeled by a single server queue with a finite capacity and vacations. We have the following assumptions for the model.

There is an arrival process with rate $\lambda$ representing the incoming packets to the ring buffer (via DMA). In order to ensure that the analytical solution does not become unmanageable, we assume that packets arrive at the system by following a Poisson process with rate $\lambda$.

The ring buffer is represented by a finite waiting queue of size N (maximum number of packets in the buffer). In the real system, N depends on the device driver and the network card. If the buffer is full and new packets arrive, they will be rejected and therefore lost.

There is only one processor (or CPU) and one NIC to perform the capturing task. CPU consumptions are related to the service capacity of the queue, but we keep in mind that there are two types of processing: hardirq processing and softirq processing. For this reason, we define a hardirq service time (${\tau }_H$), i.e., the time required to run the ISR, with an associated rate ${\mu }_H$, which indicates the mean number of hardirqs treated per second. We also have a packet service time in softirq (${\tau }_S$), i.e., the time required to poll each packet, with an associated rate ${\mu }_S$ which indicates the mean number of packets treated per second in a softirq. Moreover, as we identify vacation times, i.e., time in which the CPU is idle or handling processes other than packet capture, we denote ${\tau }_V$ as vacation time and its associated rate as ${\mu }_V$ (mean number of vacations per second). As shown in Figure 2.

Let variable n be the number of packets in the steady state of the system ($0\le n\le N$). Let variable m be the state of the server where $m=H$ indicates that the CPU is running a hardirq’s ISR, $m=V$ indicates that the CPU is on vacation, and a value of m between 1 and B indicates that the CPU is running a softirq and it is attending the mth packet in the current softirq. B is the value of the budget: the maximum number of packets that can be served in a softirq.

Figure 3 shows the overall state diagram of the system. The model aims to collect all its states and transitions in order to represent the behavior of the packet-capture system.

Suppose we start from the empty buffer state $(n=0,m=V)$. As can be seen in Figure 3, the empty buffer state belongs to the set of vacation states, but we will consider it as special, because it is always the state prior to the start of a hardirq. The system remains there until the first packet (with rate $\lambda$) arrives—that is, when we move into the hardirq processing state, and specifically into the initial state of hardirq processing $(n=1,m=H)$. During the execution of the hardirq ISR, new packets can reach the system and n increases, but the system will remain within the set of states $(n,m=H)$ where $1\le n\le N$. These new packets will be accepted as long as the buffer is not completely filled. In case there is no more buffer space (state $(n=N,m=H)$), the new, incoming packets will be rejected, and the system will remain in the same state.

According to the Linux network processing based on NAPI, when the hardirq ends, the softirq is already scheduled, but its execution is not immediate. In this case, the softirq is not in the context of hardirq and it runs at a later time in ksoftirqd [29]. Therefore, in the state diagram of Figure 3, when the hardirq processing ends, we move to a vacation state $(n,m=V)$ where $1\le n\le N$ (notice that it is not possible to move from the hardirq processing to the empty buffer state). Again, the packet arrival remains active regardless of the state m. For this reason, during the vacation, n can increase to N at most.

When the vacation time expires, the transition between the final state of vacation $(n,m=V)$ and the initial state of softirq $(n,m=1)$, where $1\le n\le N$, takes place. The softirq processing is represented by a set of states $(n,m)$ where $1\le n\le N$ and $1\le m\le B$. During the softirq, new packets with rate $\lambda$ can arrive and, therefore, transitions from $(n,m)$ to $(n+1,m)$ can occur, except in the blocking states $(N,m)$. The departure of processed packets is also possible, resulting in transitions from $(n,m)$ to $(n-1,m+1)$ where $2\le n\le N$ and $1\le m\le B-1$. Another important aspect to consider is the completion of the softirq for which there are three options.

• The first option involves the fact that the queue is emptied and, according to the Linux procedure, hardirq is enabled again. In this case, we move from the softirq processing to the empty buffer state (transition marked with $n=0$ in Figure 3). This is a transition from the state $(1,m)$, where $1\le m\le B$, to the state $(0,V)$.
• The second option is to reach the budget without having completely emptied the buffer, states $(n,B)$ where $2\le n\le N$. In this case, Linux schedules a new softirq without enabling hardirqs. We move from the softirq processing to a regular vacation state (transition marked with $n\ne 0$ and $m=B$ in Figure 3). This is a transition from the state $(n,B)$ to a state $(n-1,V)$ where $2\le n\le N$.
• The time limit of 2 jiffies has elapsed. However, we will disregard this case for our model, since we have verified experimentally that this case occurs very rarely.

If we define our queueing model with Kendall’s notation, we can name it as a queue M/G/1/N with limited service discipline, vacations, and a setup period. The queue M/G/1/N with limited service discipline represents the softirq process, whereas the setup period corresponds to the hardirq process.

Taking all this into account, we propose the analysis of three particular cases of the general model presented here. We will start with the simplest case of the three, and end with the most complex. We will call them M1, M2, and M3 as follows:

• M1. Model with infinite budget ($B\to \infty$) and exponential distributions for hardirq- and softirq-processing times and vacations;
• M2. Model with finite budget and exponential distributions for hardirq- and softirq-processing times and vacations; and
• M3. Model with finite budget and general distributions for hardirq- and softirq-processing and vacation times.

3. Analysis for Exponential Time Distributions and Budget $\mathit{B}\to \infty$

The first model, named M1, is based on a finite queue model with a set of Markovian assumptions. First, we assume that network packets arrive at the capturing queue according to a Poisson process with rate $\lambda$. Then, the capture engine’s packet processing is represented by a single server which is devoted to that task in the active period and to other ones in the vacation period. We should remember that there is also a time to attend to the hardirq service routine. The size of the capturing buffer limits the number of packets to N at the queueing system. If there are N packets at the system, the new, incoming packets will be blocked, i.e., those packets do not enter the buffer because it is full.

Model M1 assumes that the packet service time (related to the softirq process) follows an exponential distribution with a mean value of $1/{\mu }_S$. The packet service time can be considered the time the system needs to process a packet and carry it to the user application. That time includes the network stack processing, which is mainly performed by the kernel. In model M1, the softirq process does not end until the queue is emptied. Therefore, we consider an exhaustive service discipline for the softirq.

As far as the hardirq and vacations are concerned, the hardirq service time is also characterized with an exponential distribution of mean value $1/{\mu }_H$ and, similarly, the vacation time is exponential with mean value $1/{\mu }_V$. The procedure followed by the hardirq and vacations is the same as the generic case explained in Section 2.2.

3.1. Markov Chain Related to the Capturing Stage

The first finite queueing model with vacations, M1, is based on a Markov chain with a state space $\mathcal{S}:=\mathcal{N}\times \mathcal{M}$. The state of the system is $s=(n,m)$ with $n\in \mathcal{N}:=\{0,1,\dots ,N\}$ and $m\in \mathcal{M}:=\{H,S,V\}$. The variable n represents the number of packets at the capturing stage, while m indicates whether the server is active in a hardirq processing (in this case, $m=H$), in a softirq processing ($m=S$), i.e., working on capturing packets from the network subsystem to an upper level, or in a vacation period ($m=V$).

Figure 4 shows a state-transition diagram referring to the rates $\lambda$, ${\mu }_H$, ${\mu }_S$, and ${\mu }_V$. It reflects how the system proceeds. First of all, if the system is in the empty state $(0,V)$ and a new packet arrives, this causes the beginning of the hardirq. For that reason, the transition from $(0,V)$ to $(1,H)$ happens with rate $\lambda$. During the hardirq processing, the system is at states $(n,H)$. The number of packets can grow with rate $\lambda$, except for the state $(N,H)$ because the queue is blocked. When the hardirq ends, due to the task scheduler’s policy, the softirq’s packet-capturing process does not start immediately, but it does after a vacation; therefore, there is a transition from a hardirq state $(n,H)$ to a vacation state $(n,V)$ with rate ${\mu }_H$.

During the vacation period, at states $(n,V)$ with $1\le n\le N$, the number of packets can also increase with rate $\lambda$, except for the blocking state $(N,V)$. When the system scheduler decides to finish the vacation, there is a transition from a vacation state $(n,V)$ to a softirq state $(n,S)$ with rate ${\mu }_V$.

At states $(n,S)$, the processor is capturing packets in the softirq. Then, new packets can arrive with rate $\lambda$, except for $(N,S)$, and packets can leave the capturing system with rate ${\mu }_S$. The softirq packet-capturing process only ends when the buffer is completely emptied: transition from $(1,S)$ to $(0,V)$ in Figure 4.

3.2. Balance Equations and Steady-State Probabilities

Let ${\pi }_{n,m}$ be the steady-state probability for the state $(n,m)$. The balance equations [31] related to the states of Figure 4 can be written as follows.

First, at state $(0,V)$,

$$\lambda {\pi }_{0,V}={\mu }_S{\pi }_{1,S}.$$

(1)

At states $(1,m)$ where $m\in \{H,S,V\}$,

$$\begin{array}{cc}\hfill (\lambda +{\mu }_H){\pi }_{1,H}& =\lambda {\pi }_{0,V}\hfill \end{array}$$

(2a)

$$\begin{array}{cc}\hfill (\lambda +{\mu }_V){\pi }_{1,V}& ={\mu }_H{\pi }_{1,H}\hfill \end{array}$$

(2b)

$$\begin{array}{cc}\hfill (\lambda +{\mu }_S){\pi }_{1,S}& ={\mu }_V{\pi }_{1,V}+{\mu }_S{\pi }_{2,S}.\hfill \end{array}$$

(2c)

At states $(n,m)$ where $2\le n\le N-1$ and $m\in \{H,S,V\}$,

$$\begin{array}{cc}\hfill (\lambda +{\mu }_H){\pi }_{n,H}& =\lambda {\pi }_{n-1,H},2\le n\le N-1\hfill \end{array}$$

(3a)

$$\begin{array}{cc}\hfill (\lambda +{\mu }_V){\pi }_{n,V}& =\lambda {\pi }_{n-1,V}+{\mu }_H{\pi }_{n,H},2\le n\le N-1\hfill \end{array}$$

(3b)

$$\begin{array}{cc}\hfill (\lambda +{\mu }_S){\pi }_{n,S}& =\lambda {\pi }_{n-1,S}+{\mu }_V{\pi }_{n,V}+{\mu }_S{\pi }_{n+1,S},2\le n\le N-1.\hfill \end{array}$$

(3c)

Finally, at states $(N,m)$ where $m\in \{H,S,V\}$,

$$\begin{array}{cc}\hfill {\mu }_H{\pi }_{N,H}& =\lambda {\pi }_{N-1,H}\hfill \end{array}$$

(4a)

$$\begin{array}{cc}\hfill {\mu }_V{\pi }_{N,V}& =\lambda {\pi }_{N-1,V}+{\mu }_H{\pi }_{N,H}\hfill \end{array}$$

(4b)

$$\begin{array}{cc}\hfill {\mu }_S{\pi }_{N,S}& =\lambda {\pi }_{N-1,S}+{\mu }_V{\pi }_{N,V}.\hfill \end{array}$$

(4c)

By using the principle of global balance [32], the flow of probability is balanced. If we consider a set of states, the amount of probability flowing in equals the amount flowing out:

$$\begin{array}{c}\hfill \lambda \left({\pi }_{n,H}+{\pi }_{n,V}+{\pi }_{n,S}\right)={\mu }_S{\pi }_{n+1,S},0\le n\le N-1.\end{array}$$

(5)

Given that the sum of probabilities must be 1:

$$\sum _{n=0}^N\left({\pi }_{n,H}+{\pi }_{n,V}+{\pi }_{n,S}\right)=1.$$

(6)

After grouping and rewriting Equations (1)–(5), a matrix-geometric solution is reached:

$$\begin{array}{ccc}\hfill \left(\begin{array}{c}{\pi }_{n,H}\\ {\pi }_{n,V}\\ {\pi }_{n,S}\end{array}\right)& \hfill =& R^n\left(\begin{array}{c}{\pi }_{0,V}\\ 0\\ 0\end{array}\right),1\le n\le N-1,\hfill \end{array}$$

$$\begin{array}{cc}\hfill & \mathrm{where}R=\left(\begin{array}{ccc}\frac{\lambda }{\lambda +{\mu }_H}& 0& 0\\ \frac{\lambda {\mu }_H}{(\lambda +{\mu }_V)(\lambda +{\mu }_H)}& \frac{\lambda }{\lambda +{\mu }_V}& 0\\ \frac{\lambda }{{\mu }_S}& \frac{\lambda }{{\mu }_S}& \frac{\lambda }{{\mu }_S}\end{array}\right).\hfill \end{array}$$

(7a)

$$\begin{array}{ccc}\hfill \left(\begin{array}{c}{\pi }_{N,H}\\ {\pi }_{N,V}\\ {\pi }_{N,S}\end{array}\right)& \hfill =& Q\left(\begin{array}{c}{\pi }_{N-1,H}\\ {\pi }_{N-1,V}\\ {\pi }_{N-1,S}\end{array}\right),\mathrm{where}Q=\left(\begin{array}{ccc}\frac{\lambda }{{\mu }_H}& 0& 0\\ \frac{\lambda }{{\mu }_V}& \frac{\lambda }{{\mu }_V}& 0\\ \frac{\lambda }{{\mu }_S}& \frac{\lambda }{{\mu }_S}& \frac{\lambda }{{\mu }_S}\end{array}\right).\hfill \end{array}$$

(7b)

After imposing the condition of Equation (6), the value of ${\pi }_{0,V}$ is obtained as follows:

$$\begin{array}{cc}\hfill {\pi }_{0,V}& =\frac{1}{K}\hfill \\ \hfill & \mathrm{where}K=\left(\begin{array}{ccc}1& 1& 1\end{array}\right)\left(\sum _{n=0}^{N-1}{R}^n+Q{R}^{N-1}\right)\left(\begin{array}{c}1\\ 0\\ 0\end{array}\right)\hfill \\ \hfill & \mathrm{and}\sum _{n=0}^{N-1}{R}^n={\left(I-R\right)}^{-1}\left(I-R^N\right).\hfill \end{array}$$

(8)

After computing ${\pi }_{0,V}$, it is possible to determine every steady-state probability ${\pi }_{n,m}$ by applying Equations (7a) and (7b).

3.3. Performance Parameters

Once we have the probabilities ${\pi }_{n,m}$, it is already possible to calculate the performance parameters in terms of blocking probability, throughput, CPU usage, hardirq and softirq frequencies, and softirq mean time.

3.3.1. Blocking Probability $\left(P_B\right)$

It is the probability of dropping packets when the buffer is completely full. This happens at states $(N,H)$, $(N,V)$ and $(N,S)$:

$$P_B={\pi }_{N,H}+{\pi }_{N,V}+{\pi }_{N,S}.$$

(9)

3.3.2. Capture Throughput $\left(X_C\right)$

In general, the throughput or completion rate is equal to the number of request completions divided by the time [33]. In our context, capture throughput $\left(X_C\right)$ is defined as the mean number of packets processed per second by the queueing system representing the capturing phase of a network-monitoring system. In other words, it is the rate at which the capturing stage is able to transfer packets to its corresponding upper level. It is worth mentioning that the packet departures from the capturing stage take place at states $(n,S)$ where $1\le n\le N$. Capture throughput is also directly related to the packet-arrival rate and the blocking probability:

$$X_C={\mu }_S\sum _{n=1}^N{\pi }_{n,S}=\lambda \left(1-P_B\right).$$

(10)

3.3.3. CPU Usage $\left(U_C\right)$

This parameter considers the states in which CPU is devoted to hardirq and softirq processing:

$$U_C=\sum _{n=1}^N{\pi }_{n,H}+\sum _{n=1}^N{\pi }_{n,S}.$$

(11)

3.3.4. Hardirq Frequency $\left(f_{hardirq}\right)$

This parameter measures the number of hardirqs executed per second. The frequency $f_{hardirq}$ is related to the cycle composed of (1) empty buffer time, (2) hardirq time, (3) vacation time with not an empty buffer, and (4) softirq time. We denote $T_{cycle}$ as the cycle mean time and $T_{softirq}$ as the execution mean time of a softirq:

$$T_{cycle}=\frac{1}{\lambda }+\frac{1}{{\mu }_H}+\frac{1}{{\mu }_V}+T_{softirq}.$$

(12)

Assuming that the packet arrival is a Poisson process, the empty buffer mean time is equal to $1/\lambda$, and we can obtain $f_{hardirq}$ as follows:

$$\begin{array}{cc}\hfill \frac{1}{\lambda }& =T_{cycle}·{\pi }_{0,V}\hfill \\ \hfill f_{hardirq}& =\frac{1}{T_{cycle}}=\lambda ·{\pi }_{0,V}.\hfill \end{array}$$

(13)

3.3.5. Softirq Frequency $\left(f_{softirq}\right)$

This parameter measures the number of softirqs executed per second. In model M1, there is one softirq for each hardirq. Therefore, both frequencies, $f_{hardirq}$ and $f_{softirq}$, are equal:

$$f_{softirq}=f_{hardirq}=\lambda ·{\pi }_{0,V}.$$

(14)

3.3.6. Softirq Mean Time $\left(T_{softirq}\right)$

As mentioned previously, it is the mean duration of a softirq. We obtain its expression as follows:

$$T_{softirq}=T_{cycle}·\sum _{n=1}^N{\pi }_{n,S}=\frac{{\displaystyle \sum _{n=1}^N}{\pi }_{n,S}}{f_{softirq}}.$$

(15)

4. Analysis for Exponential Time Distributions and an Arbitrary Budget $\mathit{B}<\infty$

The second proposed model, M2, will represent the Linux packet-capturing system with more detail than M1, since it establishes a finite value of the parameter B. Remember that B is the budget, the maximum number of packets that can be processed within a softirq. It can be said that, while M1 has an exhaustive service discipline during the softirq (this does not end until the buffer is left without any packet), M2 has a limited service discipline during the softirq (this ends when the limit set by B is reached). Thus, the variability of the busy period (the duration of the softirq) is reduced.

The rest of the assumptions coincide with those of the model M1. Thus, we keep the rates $\lambda$, ${\mu }_H$, ${\mu }_S$ and ${\mu }_V$, as well as buffer size N.

4.1. Markov Chain Related to the Capturing Stage

The analysis of model M2 is based on a Markov chain with a state space $\mathcal{S}:=\mathcal{N}\times \mathcal{M}$. The state of the system is $s=(n,m)$ with $n\in \mathcal{N}:=\{0,1,\dots ,N\}$ and $m\in \mathcal{M}:=\{H,V,1,2,\dots ,B\}$. As explained in Section 2, n indicates the number of packets in the capturing stage, whereas m allows us to control what type of occupation the server has at any given time.

• $m=H$ if the server is processing a hardirq.
• $m=V$ if the server is on vacation.
• $1\le m\le B$ if the server is processing a softirq and it is serving the mth packet in the current softirq.

The state-transition diagram shown in Figure 5 gathers the procedure of the Linux capturing system. First, if the system is empty, state $(0,V)$, and a packet arrives, this causes the execution of the hardirq service routine. For this reason, in Figure 5, there is a transition for $(0,V)$ to $(1,H)$ with rate $\lambda$. During the hardirq, the system remains at states $(n,H)$. There can be new incoming packets with rate $\lambda$, and the system moves to state $(n+1,H)$. The exception is the state (N,H), which does not accept new packets, because there is no room in the buffer. When the hardirq finishes, the system moves to a vacation state $(n,V)$; this involves a transition from $(n,H)$ to $(n,V)$ with rate ${\mu }_H$. The vacations of M2 are identical to those of M1; therefore, when the task scheduler determines it, the vacation ends and the execution of a softirq starts. This implies the transition from state $(n,V)$ to state $(n,1)$ with rate ${\mu }_V$.

The execution of a softirq is represented by the set of states $(n,m)$, where $1\le n\le N$ and $1\le m\le B$. During the softirq, new incoming packets enter the system with rate $\lambda$; therefore, there are transitions from $(n,m)$ to $(n+1,m)$, except for blocking states $(N,m)$. It is also possible that the packet departure results in transitions from $(n,m)$ to $(n-1,m+1)$ with rate ${\mu }_S$. Another aspect to consider is the representation of the two options that exist to finish a softirq and start a vacation. One is that the queue is emptied with the departure of the last packet; this corresponds to a transition from state $(1,m)$ to state $(0,V)$ with rate ${\mu }_S$. The second option is to reach the budget; in this case, there is a transition from state $(n,B)$ to state $(n-1,V)$ with rate ${\mu }_S$.

4.2. Balance Equations and Steady-State Probabilities

At steady state, the probabilities ${\pi }_{n,m}$ satisfy the balance equations of the states in Figure 5. First, at state $(0,V)$,

$$\lambda {\pi }_{0,V}={\mu }_S\sum _{m=1}^B{\pi }_{1,m}.$$

(16)

At states $(1,m)$, where $m\in \{H,S,1,2,\dots ,B\}$,

$$\left(\lambda +{\mu }_H\right){\pi }_{1,H}=\lambda {\pi }_{0,V}$$

(17a)

$$\left(\lambda +{\mu }_V\right){\pi }_{1,V}={\mu }_H{\pi }_{1,H}+{\mu }_S{\pi }_{2,B}$$

(17b)

$$\left(\lambda +{\mu }_S\right){\pi }_{1,1}={\mu }_V{\pi }_{1,V}$$

(17c)

$$\left(\lambda +{\mu }_S\right){\pi }_{1,m}={\mu }_S{\pi }_{2,m-1},2\le m\le B.$$

(17d)

At states $(n,m)$, where $2\le n\le N-1$ and $m\in \{H,S,1,2,\dots ,B\}$,

$$\left(\lambda +{\mu }_H\right){\pi }_{n,H}=\lambda {\pi }_{n-1,H}$$

(18a)

$$\left(\lambda +{\mu }_V\right){\pi }_{n,V}=\lambda {\pi }_{n-1,V}+{\mu }_H{\pi }_{n,H}+{\mu }_S{\pi }_{n+1,B}$$

(18b)

$$\left(\lambda +{\mu }_S\right){\pi }_{n,1}=\lambda {\pi }_{n-1,1}+{\mu }_V{\pi }_{n,V}$$

(18c)

$$\left(\lambda +{\mu }_S\right){\pi }_{n,m}=\lambda {\pi }_{n-1,m}+{\mu }_S{\pi }_{n+1,m-1},2\le m\le (B-1)$$

(18d)

$$\left(\lambda +{\mu }_S\right){\pi }_{n,B}=\lambda {\pi }_{n-1,B}+{\mu }_S{\pi }_{n+1,B-1}.$$

(18e)

Finally, at states $(N,m)$, where $m\in \{H,S,1,2,\dots ,B\}$,

$${\mu }_H{\pi }_{N,H}=\lambda {\pi }_{N-1,H}$$

(19a)

$${\mu }_V{\pi }_{N,V}=\lambda {\pi }_{N-1,V}+{\mu }_H{\pi }_{N,H}$$

(19b)

$${\mu }_S{\pi }_{N,1}=\lambda {\pi }_{N-1,1}+{\mu }_V{\pi }_{N,V}$$

(19c)

$${\mu }_S{\pi }_{N,m}=\lambda {\pi }_{N-1,m},2\le m\le (B-1)$$

(19d)

$${\mu }_S{\pi }_{N,B}=\lambda {\pi }_{N-1,B}.$$

(19e)

In addition, we have the normalization condition:

$$\sum _{n,m}{\pi }_{n,m}=1.$$

(20)

In order to calculate the steady-state probabilities ${\pi }_{n,m}$, we perform a matrix development for which we define the following probability vectors of dimension $(B+2)\times 1$:

$${\overrightarrow{\pi }}_0=\left(\begin{array}{c}{\pi }_{0,V}\\ 0\\ 0\\ ⋮\\ 0\\ 0\end{array}\right),{\overrightarrow{\pi }}_n=\left(\begin{array}{c}{\pi }_{n,H}\\ {\pi }_{n,V}\\ {\pi }_{n,1}\\ ⋮\\ {\pi }_{n,B-1}\\ {\pi }_{n,B}\end{array}\right),1\le n\le N.$$

(21)

After performing the corresponding development, we obtain the following matrix relationships between probability vectors. All of them result as a function of the probability ${\pi }_{0,V}$:

$$\begin{array}{c}\hfill \left\{\begin{array}{c}{\overrightarrow{\pi }}_1=Z_1{\overrightarrow{\pi }}_0\hfill \\ {\overrightarrow{\pi }}_n=Z_n{\overrightarrow{\pi }}_{n-1},2\le n\le N.\hfill \end{array}\right.\end{array}$$

(22)

Matrices $Z_n$ are the results of matrix operations involving the rates $\lambda$, ${\mu }_S$, ${\mu }_V$, and ${\mu }_H$:

$$\begin{array}{c}\hfill \left\{\begin{array}{c}{Z}_N=-\lambda A^{-1}\hfill \\ Z_n=-\lambda {\left(A-\lambda I+B{Z}_{n+1}\right)}^{-1},2\le n\le N-1\hfill \\ Z_1=-{\left(A-\lambda I+B{Z}_2\right)}^{-1}C.\hfill \end{array}\right.\end{array}$$

(23)

Matrices A, B, and C, which appear in (23), are square matrices of dimension $(B+2)\times (B+2)$. They contain the following elements:

$$\begin{array}{c}\hfill \begin{array}{c}\hfill A=\left(\begin{array}{ccccccc}-{\mu }_H& 0& 0& 0& \cdots & \cdots & 0\\ {\mu }_H& -{\mu }_V& 0& 0& \cdots & \cdots & 0\\ 0& {\mu }_V& -{\mu }_S& 0& \cdots & \cdots & ⋮\\ 0& 0& 0& -{\mu }_S& \cdots & \cdots & ⋮\\ ⋮& ⋮& ⋮& 0& \ddots & \ddots & ⋮\\ ⋮& ⋮& ⋮& ⋮& \ddots & \ddots & 0\\ 0& 0& 0& 0& \cdots & 0& -{\mu }_S\end{array}\right)\end{array}\end{array}$$

(24)

$$\begin{array}{c}\hfill \begin{array}{c}\hfill B=\left(\begin{array}{ccccccc}0& 0& \cdots & \cdots & \cdots & 0& 0\\ 0& 0& \cdots & \cdots & \cdots & 0& {\mu }_S\\ 0& 0& 0& \cdots & \cdots & 0& 0\\ 0& 0& {\mu }_S& 0& \cdots & ⋮& ⋮\\ 0& 0& 0& {\mu }_S& 0& ⋮& ⋮\\ ⋮& ⋮& ⋮& \ddots & \ddots & \ddots & ⋮\\ 0& 0& \cdots & \cdots & 0& {\mu }_S& 0\end{array}\right)\end{array}\end{array}$$

(25)

$$\begin{array}{c}\hfill \begin{array}{c}\hfill C=\left(\begin{array}{cccccc}\lambda & 0& \cdots & \cdots & 0& 0\\ 0& 0& \cdots & \cdots & 0& 0\\ ⋮& ⋮& \ddots & & ⋮& ⋮\\ ⋮& ⋮& & \ddots & ⋮& ⋮\\ 0& 0& \cdots & \cdots & 0& 0\\ 0& 0& \cdots & \cdots & 0& 0\end{array}\right).\end{array}\end{array}$$

(26)

Next, we obtain the value of ${\pi }_{0,V}$ by replacing, within the normalization condition (20), the sum of ${\pi }_{n,m}$ with the sum of the equivalent terms extracted from (21)–(23):

$${\pi }_{0,V}=\frac{1}{S};S=1+\left[\sum _{n=1}^N{\overrightarrow{e}}_1^T\left(\prod _{i=0}^{n-1}{Z}_{n-i}\right){\overrightarrow{e}}_2\right].$$

(27)

${\overrightarrow{e}}_1$ and ${\overrightarrow{e}}_2$ are vectors of dimension $(B+2)\times 1$:

$$\begin{array}{c}\hfill {\overrightarrow{e}}_1^T=\left(11\cdots \cdots 1\right),\\ \hfill {\overrightarrow{e}}_2^T=\left(10\cdots \cdots 0\right).\end{array}$$

(28)

Once we have the value of ${\pi }_{0,V}$, we can determine the probabilities ${\pi }_{n,m}$ by applying (22).

4.3. Performance Parameters

Now, with steady-state probabilities, it is possible to calculate the performance parameters of interest.

4.3.1. Blocking Probability $\left(P_B\right)$

The blocking probability is equal to the sum of the blocking states $(N,m)$ where $m=H$ or $m=V$ or $1\le m\le B$:

$$P_B={\pi }_{N,H}+{\pi }_{N,V}+\sum _{m=1}^B{\pi }_{N,m}.$$

(29)

4.3.2. Capture Throughput $\left(X_C\right)$

The definition of this parameter is the same as that given for model M1. It takes into account the probability of running a softirq and the service rate ${\mu }_S$:

$$X_C={\mu }_S\sum _{n=1}^N\sum _{m=1}^B{\pi }_{n,m}.$$

(30)

4.3.3. CPU Usage $\left(U_C\right)$

This parameter considers the states in which CPU is devoted to hardirq and softirq processing:

$$U_C=\sum _{n=1}^N{\pi }_{n,H}+\sum _{n=1}^N\sum _{m=1}^B{\pi }_{n,m}.$$

(31)

4.3.4. Hardirq Frequency $\left(f_{hardirq}\right)$

This parameter measures, on average, how many times per second the hardirq service routine runs. As was done in model M1, we consider the cycle mean time, $T_{cycle}$, to calculate $f_{hardirq}$. Here, cycle mean time consists of the empty buffer mean time, the hardirq execution mean time, and the mean time of the set of vacations and softirqs until the buffer is completely emptied:

$$T_{cycle}=\frac{1}{\lambda }+\frac{1}{{\mu }_H}+k_s\left(\frac{1}{{\mu }_V}+T_{softirq}\right).$$

(32)

$T_{softirq}$ is the softirq mean time and $k_s$ is the mean number of softirqs within the cycle. Since we assume that arrivals follow a Poisson process:

$$\begin{array}{c}\hfill \frac{1}{\lambda }=T_{cycle}·{\pi }_{0,V}\\ \hfill f_{hardirq}=\frac{1}{T_{cycle}}=\lambda ·{\pi }_{0,V}.\end{array}$$

(33)

4.3.5. Softirq Frequency $\left(f_{softirq}\right)$

As in model M1, this parameter indicates the mean number of softirqs executed per second. In model M2, there is always a vacation with $n>0$ before each softirq. Therefore, we estimate $f_{softirq}$ as follows:

$$\begin{array}{cc}\hfill k_s·\frac{1}{{\mu }_V}& =T_{cycle}\sum _{n=1}^N{\pi }_{n,V}\hfill \\ \hfill f_{softirq}& =\frac{k_s}{T_{cycle}}={\mu }_V\sum _{n=1}^N{\pi }_{n,V}.\hfill \end{array}$$

(34)

4.3.6. Softirq Mean Time $\left(T_{softirq}\right)$

We can get the mean duration of a softirq as follows:

$$T_{softirq}=\frac{{\displaystyle \sum _{n=1}^N}{\displaystyle \sum _{m=1}^B}{\pi }_{n,m}}{{\mu }_V{\displaystyle \sum _{n=1}^N}{\pi }_{n,V}}.$$

(35)

4.3.7. Mean Number of Packets in a Softirq $\left({\overline{m}}_{softirq}\right)$

Once we computed the mean time of softirq, we can estimate the mean number of packets processed in a softirq, ${\overline{m}}_{softirq}$:

$${\overline{m}}_{softirq}=\frac{T_{softirq}}{\frac{1}{{\mu }_S}}={\mu }_S{T}_{softirq}=\frac{{\mu }_S{\displaystyle \sum _{n=1}^N}{\displaystyle \sum _{m=1}^B}{\pi }_{n,m}}{{\mu }_V{\displaystyle \sum _{n=1}^N}{\pi }_{n,V}}.$$

(36)

5. Analysis for General Time Distributions and an Arbitrary Budget $\mathit{B}<\infty$

This section explains the third proposal to represent the Linux packet-capturing stage. We will call it model M3. As with model M2, M3 is also based on a model with vacations and limited service discipline by the budget B of softirq. However, unlike M1 and M2, in this approximation, hardirq and softirq packet-service and vacation times are not exponential, but they follow general distributions. We have the following assumptions for this third model.

• Incoming packets arrive at the system in accordance with a Poisson distribution of rate $\lambda$.
• There is only one processor to capture packets.
• Hardirq processing time, H, softirq packet service time, S, and vacation time, V, are all independent variables with distribution functions $H\left(x\right)$, $S\left(x\right)$, and $V\left(x\right)$, respectively. Their corresponding Laplace–Stieltjes transforms are $H^{*}\left(\theta \right)$, $S^{*}\left(\theta \right)$, and $V^{*}\left(\theta \right)$ [34].
• There is a finite budget that we denote as B.
• There is a finite size buffer to store packets before they are processed by the softirq. N is the maximum number of packets in the system. If there are N packets in the system, new, incoming ones are rejected.
• Model M3 follows the procedure that is graphically represented in the general state diagram in Figure 3.

In order to obtain the performance parameters with those assumptions, we first will pose the embedded Markov chain and get its steady-state distribution. Secondly, we will derive the queue length distribution of the continuous-time process. Finally, we will obtain significant performance parameters.

5.1. Embedded Markov Chain

We examine the system at time epochs $\{t_0,t_1,\dots \}$ of hardirq service routine finishing, of vacation termination, or of softirq packet-service completion. The state space of the system is $\mathcal{S}:=\{L_i,{\delta }_i\}$ defined as follows: $L_i$ is the number of packets in the system at the embedded point $t_i$. If the point $t_i$ is a hardirq finishing instant, then ${\delta }_i=H$. If the embedded point is a vacation termination instant, then ${\delta }_i=V$; otherwise, ${\delta }_i=m$ where $m=1,2,\dots ,B$ indicates that the point $t_i$ is the packet service completion instant of the mth packet in the present softirq. The state transitions in the process $\{L_i,{\delta }_i\}$ occur at hardirq finishing instants, vacation termination instants, and packet-departure instants.

Notice that we could have an ambiguity on the embedded point with $\left(L_i=1,{\delta }_i=V\right)$. It could be the termination point of the empty buffer vacation; i.e., when the first packet arrives at the buffer, this causes the end of the empty buffer vacation and the beginning of a hardirq. However, it can also refer to the end of a regular vacation period with one packet in the buffer; in this case, the system will start with a softirq after the regular vacation. For that reason, we define an embedded point with $\left(L_i=1,{\delta }_i=V_0\right)$, which corresponds to the empty buffer vacation termination followed by a hardirq, whereas the set of embedded points $\left(L_i=n,{\delta }_i=V\right)$, where $n=1,2,\dots ,N$, is related to vacation terminations which are followed by a softirq.

When the system is under steady state, the limiting probability distributions $p_{n,m}$ are defined as follows:

$$\begin{array}{c}\hfill \begin{array}{cc}{p}_{n,H}=\underset{i\to \infty }{lim}Pr\left\{L_i=n,{\delta }_i=H\right\},\hfill & n=1,2,\dots ,N;\hfill \\ p_{n,V}=\underset{i\to \infty }{lim}Pr\left\{L_i=n,{\delta }_i=V\right\},\hfill & n=1,2,\dots ,N;\hfill \\ p_{n,m}=\underset{i\to \infty }{lim}Pr\left\{L_i=n,{\delta }_i=m\right\},\hfill & n=0,1,\dots ,N-1;m=1,2,\dots ,B;\hfill \\ p_{1,V0}=\underset{i\to \infty }{lim}Pr\left\{L_i=1,{\delta }_i=V_0\right\}.\hfill & \end{array}\end{array}$$

Taking into account that packets arrive at the system according to a Poisson process, we also define the probabilities $u_i$, $v_i$, and $w_i$.

$u_i$ is the probability that i packets arrive during a hardirq time H:

$$u_i=\underset{0}{\overset{\infty }{\int }}{e}^{-\lambda x}{\displaystyle \frac{{\left(\lambda x\right)}^i}{i!}}dH\left(x\right).$$

(37)

$v_i$ is the probability that i packets arrive during a vacation time V:

$$v_i=\underset{0}{\overset{\infty }{\int }}{e}^{-\lambda x}{\displaystyle \frac{{\left(\lambda x\right)}^i}{i!}}dV\left(x\right).$$

(38)

$w_i$ is the probability that i packets arrive during a softirq packet processing time S:

$$w_i=\underset{0}{\overset{\infty }{\int }}{e}^{-\lambda x}{\displaystyle \frac{{\left(\lambda x\right)}^i}{i!}}dS\left(x\right).$$

(39)

We also define the probabilities $u_k^c$, $v_k^c$, and $w_k^c$:

$$\begin{array}{c}\hfill u_k^c=\sum _{i=k}^{\infty }{u}_i,v_k^c=\sum _{i=k}^{\infty }{v}_i,w_k^c=\sum _{i=k}^{\infty }{w}_i.\end{array}$$

(40)

If $H^{*\left(i\right)}$, $V^{*\left(i\right)}$ and $S^{*\left(i\right)}$ denote the ith derivative of $H^{*}$, $V^{*}$ and $S^{*}$, then

$$\begin{array}{c}\hfill \begin{array}{c}{u}_i=\left[{\displaystyle \frac{{(-\lambda )}^i}{i!}}\right]H^{*\left(i\right)}\left(\lambda \right),v_i=\left[{\displaystyle \frac{{(-\lambda )}^i}{i!}}\right]V^{*\left(i\right)}\left(\lambda \right),w_i=\left[{\displaystyle \frac{{(-\lambda )}^i}{i!}}\right]S^{*\left(i\right)}\left(\lambda \right),\hfill \end{array}\end{array}$$

(41)

where $H^{*}\left(\theta \right)$, $V^{*}\left(\theta \right)$ and $S^{*}\left(\theta \right)$ are the Laplace–Stieltjes transforms of $H\left(x\right)$, $V\left(x\right)$ and $S\left(x\right)$, respectively.

All those probabilities satisfy a set of equations related to the embedded Markov chain. Below, we state those equations by separating them into different subsets.

At hardirq service routine termination points,

$$\begin{array}{cc}\hfill & p_{n,H}=p_{1,V0}{u}_{n-1},0\le n\le N-1\hfill \end{array}$$

(42a)

$$\begin{array}{cc}\hfill & p_{N,H}=p_{1,V0}{u}_{N-1}^C.\hfill \end{array}$$

(42b)

At vacation termination points that are followed by a softirq,

$$\begin{array}{cc}\hfill & p_{n,V}=\sum _{k=1}^n{v}_{n-k}\left(p_{k,H}+p_{k,B}\right),1\le n\le N\hfill \end{array}$$

(43a)

$$\begin{array}{cc}\hfill & p_{N,V}=\sum _{k=1}^{N-1}{v}_{N-k}^C\left(p_{k,H}+p_{k,B}\right)+p_{N,H}.\hfill \end{array}$$

(43b)

At softirq packet service completion points,

$$\begin{array}{cc}\hfill & p_{n,1}=\sum _{k=1}^{n+1}{w}_{n-k+1}{p}_{k,V},0\le n\le N-2\hfill \end{array}$$

(44a)

$$\begin{array}{cc}\hfill & p_{N-1,1}=\sum _{k=1}^N{w}_{N-k}^C{p}_{k,V}\hfill \end{array}$$

(44b)

$$\begin{array}{cc}\hfill & p_{n,m}=\sum _{k=1}^{n+1}{w}_{n-k+1}{p}_{k,m-1},0\le n\le N-2,2\le m\le B\hfill \end{array}$$

(44c)

$$\begin{array}{cc}\hfill & p_{N-1,m}=\sum _{k=1}^{N-1}{w}_{N-k}^C{p}_{k,m-1},2\le m\le B.\hfill \end{array}$$

(44d)

Finally, at the empty buffer vacation termination point,

$$p_{1,V0}=\sum _{m=1}^B{p}_{0,m}.$$

(45)

We also have the equation of the sum of probabilities:

$$\sum _{n=1}^N{p}_{n,H}+\sum _{n=1}^N{p}_{n,V}+\sum _{n=0}^{N-1}\sum _{m=1}^B{p}_{n,m}+p_{1,V0}=1.$$

(46)

The next step is to solve the probabilities $p_{n,m}$ of the embedded Markov chain under steady state. To do this, we rewrite Equations (42)–(46) in matrix form as a function of coefficients $u_i$, $v_i$, $w_i$, $u_i^c$, $v_i^c$, and $w_i^c$. Applying an analogous method to that used to calculate the steady-state probabilities of model M2 (see Section 4.2), we obtain the probabilities $p_{n,m}$.

Once the probabilities $p_{n,m}$ are obtained, we establish some system parameters that will be used later to estimate some performance parameters. First, we define $b_0$ as the probability of an embedded point to be a vacation termination point prior to a hardirq. Secondly, we define $b_1$ as the probability of an embedded point to be a hardirq termination point. Thirdly, we define $b_2$ as the probability of an embedded point to be a vacation termination point prior to a softirq. Lastly, we define $b_3$ as the probability of an embedded point to be a packet service completion point. Thus, we have

$$b_0=p_{1,V0};b_1=\sum _{n=1}^N{p}_{n,H};b_2=\sum _{n=1}^N{p}_{n,V};b_3=\sum _{n=0}^{N-1}\sum _{m=1}^{m=B}{p}_{n,m}.$$

(47)

Another parameter of interest is the frequency of embedded points. We denote it by $\sigma$. The inverse of $\sigma$ is interpreted as the average interval between consecutive embedded points and it can be expressed by

$${\sigma }^{-1}=b_0\frac{1}{\lambda }+b_{1}E\left(H\right)+b_{2}E\left(V\right)+b_{3}E\left(S\right).$$

(48)

5.2. General Queue Length Distribution

In this subsection, we develop the calculation of the probability distribution of our queue M/G/1/N with hardirq service routines, vacations, and limited service discipline for softirq packet processing.

Let variable L be the number of packets in the steady state of the system at an arbitrary instant of time $(0\le L\le N)$. Let variable $\delta$ be the system state from the processor’s point of view. Thus, if $\delta =H$, the processor is attending a hardirq service routine. If $\delta =V$, the processor is on vacation with $L>0$. If $\delta =V_0$, the processor is also on vacation, but the queue is empty $(L=0)$ and the vacation will finish when the first new packet arrives at the system. Finally, if $\delta =m$ being $1\le m\le B$, it denotes that the processor is serving the mth packet in the present softirq.

The general queue length distribution of the time continuous process can be treated by the supplementary variable technique [26]. For that reason, we consider the following supplementary variables:

• $\widehat{H}=$ forward recurrence hardirq service time, i.e., the remaining service time for the hardirq;
• $\widehat{V}=$ forward recurrence vacation time, i.e., the remaining vacation time for the processor on vacation, not being the buffer empty $(n>0)$;
• ${\widehat{V}}_0=$ forward recurrence vacation time when there is not any packet in the buffer $(n=0)$, i.e., the remaining vacation time until the arrival of the first packet; due to the fact that packet arrivals follow a Poisson process, ${\widehat{V}}_0$ has a exponential distribution; and
• $\widehat{S}=$ forward recurrence softirq packet service time, i.e., the remaining service time for the packet departure in the current softirq execution.

We also define the following backward recurrence service times:

• $\tilde{H}=$ backward recurrence hardirq’s service time, i.e., the elapsed service time for the hardirq;
• $\tilde{V}=$ backward recurrence vacation time, i.e., the elapsed vacation time for the processor on vacation, not being the buffer empty $(n>0)$;
• ${\tilde{V}}_0=$ backward recurrence vacation time, i.e., the elapsed vacation time for the processor on vacation with empty buffer $(n=0)$; and
• $\tilde{S}=$ backward recurrence softirq packet service time, i.e., the elapsed service time for the packet that is being served in softirq.

We intend to determine the expressions of probabilities ${\pi }_{n,H}$, ${\pi }_{n,V}$ and ${\pi }_{n,m}$, starting from

$$\begin{array}{cc}\hfill {\pi }_{n,H}\left(\tau \right)d\tau & =Pr\left\{L=n,\delta =H,\tau <\widehat{H}\le \tau +d\tau \right\},1\le n\le N\hfill \end{array}$$

(49a)

$$\begin{array}{cc}\hfill {\pi }_{0,V}\left(\tau \right)d\tau & =Pr\left\{L=0,\delta =V_0,\tau <{\widehat{V}}_0\le \tau +d\tau \right\}\hfill \end{array}$$

(49b)

$$\begin{array}{cc}\hfill {\pi }_{n,V}\left(\tau \right)d\tau & =Pr\left\{L=n,\delta =V,\tau <\widehat{V}\le \tau +d\tau \right\},1\le n\le N\hfill \end{array}$$

(49c)

$$\begin{array}{cc}\hfill {\pi }_{n,m}\left(\tau \right)d\tau & =Pr\left\{L=n,\delta =m,\tau <\widehat{S}\le \tau +d\tau \right\},1\le n\le N,1\le m\le B,\hfill \end{array}$$

(49d)

and knowing that their corresponding Laplace transforms are

$${\pi }_{n,H}^{*}\left(\theta \right)=\underset{0}{\overset{\infty }{\int }}{e}^{-\theta \tau }{\pi }_{n,H}\left(\tau \right)d\tau ,1\le n\le N$$

(50a)

$${\pi }_{n,V}^{*}\left(\theta \right)=\underset{0}{\overset{\infty }{\int }}{e}^{-\theta \tau }{\pi }_{n,V}\left(\tau \right)d\tau ,0\le n\le N$$

(50b)

$${\pi }_{n,m}^{*}\left(\theta \right)=\underset{0}{\overset{\infty }{\int }}{e}^{-\theta \tau }{\pi }_{n,m}\left(\tau \right)d\tau ,1\le n\le N,1\le m\le B.$$

(50c)

The integrals in Laplace–Stieltjes transforms (50a)–(50c) can be evaluated by conditioning on $\chi (\tilde{H})$, $\chi (\tilde{V})$ and $\chi (\tilde{S})$, the number of packets arrived during $\tilde{H}$, the backward recurrence hardirq service time, $\tilde{V}$, the backward recurrence vacation time, and $\tilde{S}$, the backward recurrence softirq packet service time. Thus, we have the following cases.

• Probabilities related to the hardirq service routine include

$$\begin{array}{cc}\hfill {\pi }_{n,H}^{*}\left(\theta \right)& =Pr\left\{\delta =H\right\}·E\left[e^{-\theta \widehat{H}}|\chi (\tilde{H}=n-1)\right]·Pr\left\{\chi (\tilde{H})=n-1\right\},\hfill \end{array}$$

$$\begin{array}{cc}\hfill & 1\le n\le N-1\hfill \end{array}$$

(51a)

$$\begin{array}{cc}\hfill {\pi }_{N,H}^{*}\left(\theta \right)& =Pr\left\{\delta =H\right\}\sum _{k=N-1}^{\infty }E\left[e^{-\theta \widehat{H}}|\chi (\tilde{H}=k)\right]Pr\left\{\chi (\tilde{H}=k)\right\}.\hfill \end{array}$$

(51b)

• Probabilities related to vacations include

$$\begin{array}{cc}\hfill {\pi }_{0,V}^{*}\left(\theta \right)=Pr\left\{\delta =V_0\right\}& \frac{{\sum }_{m=1}^B{p}_{0,m}E\left[e^{-\theta \widehat{V_0}}|\chi (\widetilde{V_0}=0)\right]Pr\left\{\chi (\widetilde{V_0})=0\right\}}{{\sum }_{m=1}^B{p}_{0,m}}\hfill \\ \hfill {\pi }_{n,V}^{*}\left(\theta \right)=Pr\left\{\delta =V\right\}& ·\frac{{\sum }_{j=1}^n(p_{j,H}+p_{j,B})E\left[e^{-\theta \widehat{V}}|\chi (\tilde{V}=n-j)\right]Pr\left\{\chi (\tilde{V})=n-j\right\}}{{\sum }_{j=1}^N{p}_{j,H}+{\sum }_{j=1}^{N-1}{p}_{j,B}},\hfill \end{array}$$

(52a)

$$\begin{array}{cc}\hfill & 1\le n\le N\hfill \\ \hfill {\pi }_{N,V}^{*}\left(\theta \right)=Pr\left\{\delta =V\right\}& \left(\frac{{\sum }_{j=1}^{N-1}(p_{j,H}+p_{j,B}){\sum }_{k=N-j}^{\infty }E\left[e^{-\theta \widehat{V}}|\chi (\tilde{V}=k)\right]Pr\left\{\chi (\tilde{V})=k\right\}}{{\sum }_{j=1}^N{p}_{j,H}+{\sum }_{j=1}^{N-1}{p}_{j,B}}+\right.\hfill \end{array}$$

(52b)

$$\begin{array}{cc}\hfill & +\left.\frac{p_{N,H}{\sum }_{k=0}^{\infty }E\left[e^{-\theta \widehat{V}}|\chi (\tilde{V}=k)\right]Pr\left\{\chi (\tilde{V})=k\right\}}{{\sum }_{j=1}^N{p}_{j,H}+{\sum }_{j=1}^{N-1}{p}_{j,B}}\right).\hfill \end{array}$$

(52c)

• Probabilities related to softirq packet processing include

$$\begin{array}{c}\hfill {\pi }_{n,1}^{*}\left(\theta \right)=Pr\left\{\delta =1\right\}\frac{{\sum }_{j=1}^n{p}_{j,V}E\left[e^{-\theta \widehat{S}}|\chi (\tilde{S}=n-j)\right]Pr\left\{\chi (\tilde{S})=n-j\right\}}{{\sum }_{j=1}^N{p}_{j,V}},\\ 1\le n\le N-1\hfill \end{array}$$

(53a)

$$\begin{array}{cc}\hfill {\pi }_{N,1}^{*}\left(\theta \right)& =Pr\left\{\delta =1\right\}\frac{{\sum }_{j=1}^N{p}_{j,V}{\sum }_{k=N-j}^{\infty }E\left[e^{-\theta \widehat{S}}|\chi (\tilde{S}=k)\right]Pr\left\{\chi (\tilde{S})=k\right\}}{{\sum }_{j=1}^N{p}_{j,V}}\hfill \end{array}$$

(53b)

$$\begin{array}{c}\hfill {\pi }_{n,m}^{*}\left(\theta \right)=Pr\left\{\delta =m\right\}\frac{{\sum }_{j=1}^n{p}_{j,m-1}E\left[e^{-\theta \widehat{S}}|\chi (\tilde{S}=n-j)\right]Pr\left\{\chi (\tilde{S})=n-j\right\}}{{\sum }_{j=1}^{N-1}{p}_{j,m-1}},\\ 1\le n\le N-1,2\le m\le B\hfill \end{array}$$

(53c)

$$\begin{array}{c}\hfill {\pi }_{N,m}^{*}\left(\theta \right)=Pr\left\{\delta =m\right\}\frac{{\sum }_{j=1}^{N-1}{p}_{j,m-1}{\sum }_{k=N-j}^{\infty }E\left[e^{-\theta \widehat{S}}|\chi (\tilde{S}=k)\right]Pr\left\{\chi (\tilde{S})=k\right\}}{{\sum }_{j=1}^{N-1}{p}_{j,m-1}},\\ 2\le m\le B.\hfill \end{array}$$

(53d)

Probabilities $Pr\left\{\delta \right\}$ can be expressed as a function of the embedded Markov chain probabilities, the average durations of the different types of intervals (hardirq, vacation, or softirq packet service) and the parameter ${\sigma }^{-1}$ (the average interval between consecutive embedded points):

$$\begin{array}{cc}\hfill Pr\{\delta =V_0\}& =\frac{\frac{1}{\lambda }{p}_{1,V0}}{{\sigma }^{-1}}=\frac{\sigma }{\lambda }{p}_{1,V0}=\frac{\sigma }{\lambda }\sum _{m=1}^B{p}_{0,m}\hfill \end{array}$$

(54a)

$$\begin{array}{cc}\hfill Pr\{\delta =H\}& =\frac{E\left[H\right]{\sum }_{n=1}^N{p}_{n,H}}{{\sigma }^{-1}}=\sigma E\left[H\right]\sum _{n=1}^N{p}_{n,H}\hfill \end{array}$$

(54b)

$$\begin{array}{cc}\hfill Pr\{\delta =V\}& =\frac{E\left[V\right]{\sum }_{n=1}^N{p}_{n,V}}{{\sigma }^{-1}}=\sigma E\left[V\right]\sum _{n=1}^N{p}_{n,V}\hfill \end{array}$$

(54c)

$$\begin{array}{cc}\hfill Pr\{\delta =m\}& =\frac{E\left[S\right]{\sum }_{n=0}^{N-1}{p}_{n,m}}{{\sigma }^{-1}}=\sigma E\left[S\right]\sum _{n=0}^{N-1}{p}_{n,m}.\hfill \end{array}$$

(54d)

After performing algebraic manipulation, we get the following expressions:

$$\begin{array}{c}\hfill {\pi }_{0,V}^{*}\left(\theta \right)={\displaystyle \frac{\sigma }{\lambda }}{p}_{1,V0}\left({\displaystyle \frac{\lambda }{\lambda +\theta }}\right)\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)\end{array}$$

(55a)

$$\begin{array}{cc}\hfill {\pi }_{n,H}^{*}\left(\theta \right)& ={\displaystyle \frac{\sigma }{\lambda }}\left\{H^{*}\left(\theta \right)\left(\sum _{j=1}^N{p}_{j,H}\right){\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^n-\sum _{j=1}^n{p}_{j,H}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{n-j+1}\right\},\hfill \\ \hfill & 1\le n\le N-1\hfill \end{array}$$

(55b)

$$\begin{array}{c}\hfill {\pi }_{N,H}^{*}\left(\theta \right)={\displaystyle \frac{-\sigma }{\theta }}\left\{H^{*}\left(\theta \right)\left(\sum _{j=1}^N{p}_{j,H}\right){\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-1}-\sum _{j=1}^N{p}_{j,H}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j}\right\}\end{array}$$

(55c)

$$\begin{array}{cc}\hfill {\pi }_{n,V}^{*}\left(\theta \right)& ={\displaystyle \frac{\sigma }{\lambda }}\left\{V^{*}\left(\theta \right)\sum _{j=1}^n\left(p_{j,H}+p_{j,B}\right){\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{n-j+1}-\sum _{j=1}^n{p}_{j,V}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{n-j+1}\right\},\hfill \\ \hfill & 1\le n\le N-1\hfill \end{array}$$

(55d)

$$\begin{array}{cc}\hfill {\pi }_{N,V}^{*}\left(\theta \right)& ={\displaystyle \frac{-\sigma }{\theta }}\left\{V^{*}\left(\theta \right)\sum _{j=1}^N{p}_{j,H}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j}+V^{*}\left(\theta \right)\sum _{j=1}^{N-1}{p}_{j,B}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j}-\right.\hfill \\ \hfill & \left.-\sum _{j=1}^N{p}_{j,V}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j}\right\}\hfill \end{array}$$

(55e)

$$\begin{array}{cc}\hfill {\pi }_{n,1}^{*}\left(\theta \right)& ={\displaystyle \frac{\sigma }{\lambda }}\left\{S^{*}\left(\theta \right)\sum _{j=1}^n{p}_{j,V}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{n-j+1}-\sum _{j=0}^{n-1}{p}_{j,1}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{n-j}\right\},\hfill \\ \hfill & 1\le n\le N-1\hfill \end{array}$$

(55f)

$$\begin{array}{cc}\hfill {\pi }_{N,1}^{*}\left(\theta \right)& ={\displaystyle \frac{-\sigma }{\theta }}\left\{S^{*}\left(\theta \right)\sum _{j=1}^N{p}_{j,V}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j}-\sum _{j=0}^{N-1}{p}_{j,1}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j-1}\right\}\hfill \end{array}$$

(55g)

$$\begin{array}{cc}\hfill {\pi }_{n,m}^{*}\left(\theta \right)& ={\displaystyle \frac{\sigma }{\lambda }}\left\{S^{*}\left(\theta \right)\sum _{j=1}^n{p}_{j,m-1}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{n-j+1}-\sum _{j=0}^{n-1}{p}_{j,m}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{n-j}\right\},\hfill \\ \hfill & 1\le n\le N-1,2\le m\le B\hfill \end{array}$$

(55h)

$$\begin{array}{cc}\hfill {\pi }_{N,m}^{*}\left(\theta \right)& ={\displaystyle \frac{-\sigma }{\theta }}\left\{S^{*}\left(\theta \right)\sum _{j=1}^{N-1}{p}_{j,m-1}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j}-\sum _{j=0}^{N-1}{p}_{j,m}{\left({\displaystyle \frac{\lambda }{\lambda -\theta }}\right)}^{N-j-1}\right\},\hfill \\ \hfill & 2\le m\le B.\hfill \end{array}$$

(55i)

Since ${\sigma }^{-1}$ is the average interval between consecutive embedded points, $\sigma /\lambda$ in above equations is interpreted as the inverse of the average number of arrivals between embedded points.

Finally, we obtain the queue length general distribution by introducing $\theta =0$ in the expressions of ${\pi }_{n,m}^{*}\left(\theta \right)$, where $n\in \{0,1,\dots ,N\}$ and $m\in \{H,V,1,2,\dots ,B\}$, in Equations (55a)–(55i), i.e., ${\pi }_{n,m}={\pi }_{n,m}^{*}(\theta =0)$. We have

$$\begin{array}{cc}\hfill {\pi }_{0,V}& ={\displaystyle \frac{\sigma }{\lambda }}{p}_{1,V0}\hfill \end{array}$$

(56a)

$$\begin{array}{cc}\hfill {\pi }_{n,H}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{p_{1,V0}-\sum _{j=1}^n{p}_{j,H}\right\},1\le n\le N-1\hfill \end{array}$$

(56b)

$$\begin{array}{cc}\hfill {\pi }_{N,H}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{\lambda E\left(H\right)p_{1,V0}-(N-1)p_{1,V0}+\sum _{j=1}^N(N-j)p_{j,H}\right\}\hfill \end{array}$$

(56c)

$$\begin{array}{cc}\hfill {\pi }_{n,V}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{\sum _{j=1}^n\left(p_{j,H}+p_{j,B}\right)-\sum _{j=1}^n{p}_{j,V}\right\},1\le n\le N-1\hfill \end{array}$$

(56d)

$$\begin{array}{cc}\hfill {\pi }_{N,V}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{\lambda E\left(V\right)\sum _{j=1}^N\left(p_{j,H}+p_{j,B}\right)-\sum _{j=1}^N\left(p_{j,H}+p_{j,B}\right)(N-j)+\sum _{j=1}^N{p}_{j,V}(N-j)\right\}\hfill \end{array}$$

(56e)

$$\begin{array}{cc}\hfill {\pi }_{n,1}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{\sum _{j=1}^n{p}_{j,V}-\sum _{j=0}^{n-1}{p}_{j,1}\right\},1\le n\le N-1\hfill \end{array}$$

(56f)

$$\begin{array}{cc}\hfill {\pi }_{N,1}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{\lambda E\left(S\right)\sum _{j=1}^N{p}_{j,V}-\sum _{j=1}^N{p}_{j,V}(N-j)+\sum _{j=0}^{N-1}{p}_{j,1}(N-j-1)\right\}\hfill \end{array}$$

(56g)

$$\begin{array}{cc}\hfill {\pi }_{n,m}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{\sum _{j=1}^n{p}_{j,m-1}-\sum _{j=0}^{n-1}{p}_{j,m}\right\},1\le n\le N-1,2\le m\le B\hfill \end{array}$$

(56h)

$$\begin{array}{cc}\hfill {\pi }_{N,m}& ={\displaystyle \frac{\sigma }{\lambda }}\left\{\lambda E\left(S\right)\sum _{j=1}^{N-1}{p}_{j,m-1}-\sum _{j=1}^{N-1}(N-j)p_{j,m-1}+\sum _{j=0}^{N-1}(N-j-1)p_{j,m}\right\},\hfill \\ \hfill & 2\le m\le B.\hfill \end{array}$$

(56i)

5.3. Performance Parameters

After calculating the probabilities of the embedded Markov chain and the joint distribution of the queue length, we can determine the performance parameters of model M3 like blocking probability, capture throughput, hardirq frequency, softirq frequency, softirq mean time, and mean number of packets in a softirq.

5.3.1. Blocking Probability $\left(P_B\right)$

The blocking probability of model M3 can be calculated with the same formula as model M2, that is, by adding the probabilities of blocking states $(N,m)$ where $m\in \left\{H,V,1,2,\dots ,B\right\}$:

$$P_B={\pi }_{N,H}+{\pi }_{N,V}+\sum _{m=1}^B{\pi }_{N,m}.$$

(57)

We can also obtain the blocking probability with the results derived from the analysis of the embedded Markov chain. If we consider softirq as the main activity of our model, since we have packet departures as a result of softirq processing, we can define $\rho =\lambda E\left(S\right)$ as the offered load. We can also define the carried load ${\rho }^{\prime }$ as the fraction of the time that the softirq is busy:

$${\rho }^{\prime }=\frac{b_{3}E\left(S\right)}{b_{1}E\left(H\right)+b_{2}E\left(V\right)+b_{3}E\left(S\right)+b_0\frac{1}{\lambda }}=\sigma b_{3}E\left(S\right).$$

(58)

The blocking probability $P_B$ is also given by

$$P_B=\frac{\left(\rho -{\rho }^{\prime }\right)}{\rho }=1-\frac{{\rho }^{\prime }}{\rho }=1-\frac{\sigma b_3}{\lambda }=1-\frac{\sigma }{\lambda }\sum _{n=0}^{N-1}\sum _{m=1}^B{p}_{n,m}.$$

(59)

We have verified that both expressions we have obtained for the blocking probability $P_B$ are equivalent. If we introduce the expressions (56c), (56e) and (56i) of ${\pi }_{N,H}$, ${\pi }_{N,V}$ and ${\pi }_{N,m}$, respectively, in the expression (57) of $P_B$, the result is the same as that of expression (59) of $P_B$.

5.3.2. Capture Throughput $\left(X_C\right)$

We calculate the capture throughput of model M3 with $\lambda$ and the blocking probability $P_B$ computed with (57) or (59):

$$X_C=\lambda (1-P_B).$$

(60)

5.3.3. CPU Usage $\left(U_C\right)$

This parameter is estimated with the steady-state probabilities of hardirq and softirq, by applying the same expression as that of model M2:

$$U_C=\sum _{n=1}^N{\pi }_{n,H}+\sum _{n=1}^N\sum _{m=1}^B{\pi }_{n,m}.$$

(61)

5.3.4. Hardirq Frequency $\left(f_{hardirq}\right)$

As in model M2, we apply the same concepts of cycle mean time $T_{cycle}$, softirq mean time $T_{softirq}$, and Poisson interarrival times, we get the frequency of hardirq $f_{hardirq}$:

$$f_{hardirq}=\frac{1}{T_{cycle}}=\lambda ·{\pi }_{0,V}.$$

(62)

5.3.5. Softirq Frequency $\left(f_{softirq}\right)$

With the same reasoning used for model M2, this is the expression of softirq frequency $f_{softirq}$ for model M3:

$$f_{softirq}=\frac{{\displaystyle \sum _{n=1}^N}{\pi }_{n,V}}{E\left(V\right)}.$$

(63)

5.3.6. Softirq Mean Time $\left(T_{softirq}\right)$

We can get the mean time of a softirq of model M3 as

$$T_{softirq}=\frac{T_{cycle}{\displaystyle \sum _{n=1}^N}{\displaystyle \sum _{m=1}^B}{\pi }_{n,m}}{k_s}=\frac{E\left(V\right){\displaystyle \sum _{n=1}^N}{\displaystyle \sum _{m=1}^B}{\pi }_{n,m}}{{\displaystyle \sum _{n=1}^N}{\pi }_{n,V}}.$$

(64)

5.3.7. Mean Number of Packets in a Softirq $\left({\overline{m}}_{softirq}\right)$

Finally, we compute the mean number of packets processed in a softirq as

$${\overline{m}}_{softirq}=\frac{T_{softirq}}{E\left(S\right)}=\frac{E\left(V\right){\displaystyle \sum _{n=1}^N}{\displaystyle \sum _{m=1}^B}{\pi }_{n,m}}{E\left(S\right){\displaystyle \sum _{n=1}^N}{\pi }_{n,V}}.$$

(65)

It is also possible to estimate ${\overline{m}}_{softirq}$ by using the probabilities of the embedded Markov chain:

$${\overline{m}}_{softirq}=\frac{{\displaystyle \sum _{m=1}^B}m{p}_{0,m}+B{\displaystyle \sum _{n=1}^{N-1}}{p}_{n,B}}{{\displaystyle \sum _{m=1}^B}{p}_{0,m}+{\displaystyle \sum _{n=1}^{N-1}}{p}_{n,B}}.$$

(66)

6. Model Evaluation

This section shows model evaluation results. We obtain the analytical curves derived from models M1, M2, and M3 by implementing them in MATLAB. In addition, in order to carry out some comparisons, we present some experimental values obtained from a real Linux-based packet-capture and analysis probe [35] that operates within a laboratory measurement platform [36]. For comparing both types of results, it is necessary to have some input parameters of the models (for instance, $\lambda$, $1/{\mu }_H$, $1/{\mu }_S$, $1/{\mu }_V$) whose values come from measurements at the experimental platform.

6.1. Evaluation Scenarios

We have three evaluation scenarios: V1, V2, and V3. Each of them is characterized by having different vacation behavior as shown in Figure 6. Specifically, Figure 6 represents the mean time of vacation normalized with respect to the maximum duration of a softirq, $\overline{E}\left(V\right)=\left(1/{\mu }_V\right)/\left(B/{\mu }_S\right)$, for different input packet rates normalized with respect to the softirq packet service rate $\overline{\lambda }=\lambda /{\mu }_S$. We use $B=300$ because this is the typical value of budget. In Figure 6, it can be seen that $\overline{E}\left(V\right)$ does not remain constant. This is because the values of $\overline{E}\left(V\right)$ are extracted from the real probe where analysis operations after the capture require higher computational consumptions as the incoming packet rate increases. Thus, V1 corresponds to a low analysis load scenario, V2 to an intermediate analysis load scenario, and V3 to a high analysis load scenario. The higher the analysis load is, the more time is required for the tasks that the processor should perform on vacation.

6.2. Performance Results

As mentioned before, we have performance results of the analytical models M1, M2, M3 as well as measurements of the real packet-capture probe (we refer to them as “Lab” in the figures of this subsection). Below, we present some examples of them.

First, Figure 7 shows how the normalized capture throughput ${\overline{X}}_C=X_C/{\mu }_S$ varies with the different scenarios. We evaluate it with $N=200$ and $B=300$ (same values as the settings of the network driver of the probe). We observe that model M1 has a similar behavior for scenarios V1, V2, and V3; that is, it is practically unaffected by the different vacation times. This is due to the exhaustive discipline that has been assumed for the capture process, which allows us to extend indefinitely the time spent on the capture. In this way, the maximum throughput is obtained in saturation, ${\overline{X}}_C\approx 1$, at the expense of eliminating, in practice, the periods of vacation. Model M1 begins to saturate from the value $\overline{\lambda }\approx 0.9$. If we compare M1 with laboratory data, it only fits for values below $\overline{\lambda }\approx 0.8$.

On the other hand, unlike M1, model M2 is really affected by the inactivity periods and, consequently, the capture throughput decreases. The case of model M2 with scenario V1 (M2_V1) is very close to the values of the real probe (Lab). The maximum is reached with ${\overline{X}}_C\approx 0.8$. The subsequent decrease is due to the increase in vacation times and the termination of softirq by budget. For the highest rates, $\overline{\lambda }>1$, throughput becomes approximately constant because the mean time of vacation remains stable and the duration of the capture process is set by the limit B. Cases M2_V2 and M2_V3 allow us to predict the system behavior in other scenarios. We can see that the shape is similar to M2_V1, but throughput values are lower.

Secondly, Figure 8 exhibits the variation of throughput with respect to budget B on scenario V1. We keep $N=200$ and the different values of B are $B\to \infty$ (M1 in Figure 8), $B=300$, $B=200$, and $B=100$. Case M2_B300 fits the laboratory values. If the budget is lower, cases M2_B200, and M2_B100, we observe that the throughput decreases in the saturation zone ($\overline{\lambda }>0.8$). In addition, the lower B, the more throughput decreases. This is because when budget is exhausted, the time devoted to capture decreases with B. If we evaluate model M2 for values $B>300$, we obtain throughputs greater than in case M2_B300, but always below the extreme case M1.

Next, Figure 9 represents the variation of softirq frequency. This parameter can give us an idea of the number of context switches between the capture and vacation periods. We distinguish three zones for scenarios V1, V2, and V3. With low rates, as the input rate increases, the number of softirq per second grows until it reaches a peak. From there, with intermediate input rates, due to the increase in vacation times, the frequency of softirq decreases. Finally, there is a third zone for higher input rates where, in the case of model M1, the softirq frequency decreases because the duration of softirq is prolonged indefinitely; there are practically no vacations and $f_{softirq}\to 0$. On the contrary, in the third zone of models with finite budget, the softirq frequency remains constant with a low value. This is due to the fact that, in that third zone, the softirq mean time takes the value $B/{\mu }_S$ in M2 and $B·E\left(S\right)$ in M3. Once again, as can be seen in Figure 9, the case of model M2 with scenario V1 fits the laboratory measurement.

We have also analyzed results of hardirq frequency in models with finite budget. We observe that, for input rates where budget is not reached, $f_{hardirq}\approx f_{softirq}$ and, for input rates in the saturation zone, there is an extreme value such as $f_{hardirq}\to 0$.

Finally, Figure 10 shows the mean number of packets per softirq ${\overline{m}}_{softirq}$. It allows us to see from what input rate, the execution of the softirq exhausts the value of budget ($B=300$ in the graph). Obviously, scenario V3 exhausts the budget with the lowest input rate, and scenario V1 reaches the budget with the highest rate. Again, the case M2_V1 fits the values measured in the laboratory probe.

It is worth mentioning that we have also evaluated models with buffer sizes greater than 200 (specifically, $N=512$). The obtained results have been similar.

7. Conclusions

This work proposes an analytical modeling based on a queueing system with vacations to analyze the performance of a Linux packet-capturing system. The concept of vacation allows us to model the behavior of the processor responsible for capturing packets as well as performing additional tasks in the so-called vacations.

The first proposed model, M1, can be considered a simple model that prioritizes the capture process with the exhaustive service discipline $(B\to \infty )$. If the system is not saturated, the execution of additional tasks in the so-called vacations is guaranteed; however, under saturation conditions, the capture process hogs the processor’s time and an acceptable capture throughput is achieved to the detriment of performing additional tasks.

The second and third models, M2 and M3, are more complex, and their limited service discipline includes some particularities of the Linux packet capture system (hardirq processing, softirq execution, and budget). The limit of the budget in the softirq allows us to ensure the execution of other tasks, although it causes a loss in terms of capture throughput. In these cases, it will be interesting to assess the tradeoff between having vacations for these additional tasks and the potential loss of capture throughput.

The conclusions of this work are satisfactory with regard to the behavior of the models. The main performance parameter of the capturing system is the throughput. The comparison of throughput results of the limited-service discipline models with the measurements taken from the real probe are positive. Further simulations results suggest that M2 and M3 provide similar performance in terms of throughput.

This work, which combines analytical study with experimental measurements, raises several aspects to consider in the near future. Although in this work we do not do it explicitly, from models M1, M2, and M3, it is also possible to obtain latency results. We believe that the fundamentals of the queueing model with vacations applied in this work could be adapted to environments of VNFs. In 5G network environments, there are multiple software components like VNFs that are connected to provide service chains. We consider that the estimation of the latency of a set of VNFs could be modeled with a queueing system with vacations and we are planning to do this in future work.