A single server retrial queue with event-dependent arrival rates

In this work, we consider a novel single-server retrial queue with event-dependent arrival rates. Contrary to other related works, the primary customers’ arrival rates depend on the last realized event, which refers either to a departure, or to an arrival of either type, or to when a customer arrives during a busy period, compared with others. Our motivation stems from the modeling of service systems, in which the customers express their willingness to join the system based on the last realized event. We investigate the stability conditions, and derive the stationary distribution both at service completion epochs, and at an arbitrary epoch. We also study the asymptotic behaviour under high rate of retrials. Performance measures are explicitly derived, and extensive numerical examples are performed to investigate the impact of event-dependency. Moreover, constrained optimisation problems are formulated and solved with ultimate goal to derive optimal joining probabilities.


Introduction
In this work, we introduce a novel retrial queueing system, by incorporating a special feature for the customers' behaviour, called event-dependency.Retrial queues are used to model service systems, in which arriving customers choose to get served remotely.Thus, in case they find an idle server they begin their service immediately; otherwise, they leave the service area and enter a pool of blocked customers, called the orbit queue.Three major policies are employed to model the access from the pool: (i) In the classical retrial policy, any blocked customer retries independently of each other to access the server after exponentially distributed random time.(ii) In some situations the time intervals between successive repeated attempts are independent of the number of blocked customers (constant retrial policy).In such a case, it is assumed that the server when becomes available start seeking for a blocked customer, while the seeking time intervals are either exponentially or arbitrarily distributed (i.e., general retrials).(iii) In the linear control policy (assuming exponentially distributed repeated attempts), the classical and the constant retrial policy are combined.
A particular example of such a situation arises in modern call centers, where the call-back option (i.e., the seeking/retrieval time) allows to essentially improve its overall performance; see e.g., Armony and Maglaras (2004a, b); Dudin et al. (2004); Phung-Duc and Kawanishi (2014).Motivated by the fact that often a quick observation of the system (i.e., the nature of the last realized event) may influence customers' decision about the utility of joining a busy system (see e.g., Gencer et al. (2014)), and thus, using the call-back option, our aim is to study a versatile model for the representation of such service systems, by introducing a queueing model with repeated attempts and event-dependent arrival rates.
This phenomenon arises when customers either cannot estimate their expected wait from the observation of the queue length, or they are not aware at all about the queue length.The latter case is common in retrial systems, since the arriving customers is most likely to not be aware of the number of the already blocked customers (i.e., the orbit queue length).Thus, in the call center example, assume that a potential customer is only aware of last realized event.
If he/she receives a busy signal along with the information of the type of customer in service, as well as whether he/she is the first that arrives during the current service or not (see below for more details), he/she analogously adapts his/her arrival rate, leaves his/her contact details and wait to get called back later.In case the last event is a service completion, the customer also adapts its arrival rate to occupy the idle server, but now there is also a competitive stream due to the seeking process.
The main contributions of the paper are summarized as follows.
• On the modelling side, we introduce the concept of event-dependent arrival rates in the retrial setting.We pay particular emphasis to the case of general retrial times, but we also provided results under the linear retrial policy, thus, considering all the retrial policies.In particular, we employ a multi-level event dependency framework, where the customer's willingness to join the system, which is reflected on the choice of the arrival rates depend (i) on the last realized event, i.e., an arrival or a departure, (ii) in the former case, on the type of the customer that has occupied the idle server, (i.e., whether it is a primary or a retrial customer), (iii) on whether an arriving customer is the first after the arrival that has occupied the idle server, or they have already joined the system other primary customers before the corresponding arriving customer.• On the technical side, we investigate the stationary behaviour at service completion epoch, as well as at an arbitrary epoch, and provide explicit expressions for various performance metrics.Under the event-dependency framework, PASTA does not hold, and the arrival process is no longer a standard, but a modified Poisson process.The effect of event-dependency on system's performance, is extensively investigated through numerical experiments.Constraint optimisation problems are solved and provide insights on how event-dependency affects the way an arriving customer join or not the system.Moreover, we investigate the stability condition, and the asymptotic behaviour of our system under high rate of retrials.A basic framework on how we can investigate the optimal admission policy based on a Markov decision process (MDP) is also discussed.

Literature review
Our work is classified into the intersection of the literature of retrial queues and of queues with state dependent parameters.
For a detailed treatment on the development of retrial queues see the books in Falin and Templeton (1997); Artalejo and Gómez-Corral (2008), and references therein; see also Phung-Duc (2017).The vast majority of works on retrial queues assume the classical retrial policy; see e.g., Langaris and Dimitriou (2010).However, in specific service settings, the time intervals between successive attempts are independent of the number of attempting customers (i.e., the constant retrial policy); see e.g., Farahmand (1990); Fayolle (1986); Dimitriou (2018).In Artalejo and Gomez-Corral (1997), the authors introduced the linear control policy, which combined the classical and the constant retrial policies.In Gómez-Corral (1999), the author presented an exhaustive analysis of the single-server retrial queue with general service and seeking times; see also Choi et al. (1993).We further mention the very recent works in Baron et al. (2018Baron et al. ( , 2022)), where the authors considered the statedependent version of the model in Gómez-Corral (1999) based on the number of customers in orbit by using a probabilistic and an efficient computational method.
The performance analysis of the standard (i.e., without retrials) M/G/1 queue with eventdependent arrival rates was recently introduced in Legros (2018).In Legros and Sezer (2018), the authors studied queueing models where arrivals depend on the remaining service time.Recently, in Legros (2021), the authors investigated the admission control problem with statedependent arrivals, and provided an algorithm for dimensioning the system.In Legros (2022), the author studied a G/M/1 queue with event-dependent service rate.For other works on standard (i.e., without retrials) queues with workload-dependent or waiting time-dependent arrival and/or service rates see e.g., Bekker et al. (2004); Boxma et al. (2005); Kerner (2008); Boxma and Vlasiou (2007); D 'Auria et al. (2022).
To our best knowledge, the concept of event-dependency has never been treated in the retrial queueing literature so far.The main objective of our work is to fill this gap.Our work generalizes the seminal work in Legros (2018) in the retrial setting, and in a multi-level framework due to the the presence of primary and orbiting customers; for initial results on this work see Dimitriou (2022).Our work also differs from Baron et al. (2018), since the arrival-dependency is based on the last realized event instead of the observed number of orbiting customers, and we have also considered all the well known retrial policies.
The rest of the paper is summarized as follows.In Sect.2, we describe in detail the mathematical model with general retrials.The stability condition and the stationary analysis at service completion epochs is given in Sect.3. The stationary analysis at an arbitrary epoch is presented in Sect. 4 (we used both the supplementary variable method and the Markov renewal theory).Explicit expressions for various performance metrics along with an asymptotic result are also given.The stationary analysis for the model with the linear control policy is given in Sect. 5.In Sect.6, we present extensive numerical results that reveal the effect of event-dependency on the system's performance.Moreover, we also solve some interesting constrained optimisation problems in the presence of event-dependency.A conclusion along with some future research plans are given in Sect.7, where we also discuss in detail how one can investigate the optimal admission policy using a constrained MDP framework.

Model description
We consider a single-server queueing system with no waiting space.The service times are iid random variables with cumulative distribution function (cdf) The customers that find the server busy upon arrival, they abandon the system, but leave their contact details At least one external customer has arrived after λ r + the occupation of the idle server by a retrial customer so they are called back by the server in a later instant; hence, we assume that they join an infinite capacity orbit queue, waiting to be retrieved by the server.After finishing service, a customer leaves the system and the server seeks for a customer from the orbit.The seeking/retrieving times are iid random variables with cdf A(.), density a(.) and LST α * (.).However, a new/primary customer may arrive during the seeking process, and in such a case, the server interrupts the seeking process, and starts serving the newly arriving customer.We assume that the interarrival, service and seeking times are mutually independent.Recall that after a service completion, there is a competition between external/primary arrivals and retrials.The type of the customer that will occupy the server influences the arrival rates of the subsequent customers.More precisely, based on the last realized event, the next customer arrives according to a Poisson process, as follows (see also Table 1): -If the last realized event is a service completion, the next primary customer will arrive at a rate λ − .-In case a primary customer has occupied the idle server, then, the first primary customer that arrive during the corresponding busy period will arrive at a rate λ e .Moreover, the subsequent primary customers (i.e., the second, third, etc arriving customers during the corresponding busy period) will arrive at a rate λ e + .-In case a retrial customer has occupied the idle server, then, the first primary customer that arrive during the corresponding busy period will arrive at a rate λ r .Moreover, the subsequent primary customers (i.e., the second, third, etc arriving customers during the corresponding busy period) will arrive at a rate λ r + .
Remark 1 From the customer's perspective one might expect that λ − > λ e ≥ λ e + , and λ r ≥ λ r + .This is justified as follows: if a customer knows that the last realised event is an arrival that has occupied the idle server, she knows that if she decides to join the system, she will be routed to the orbit queue.So she has to wait to be called back by the server in a later instant (i.e., λ − > λ e ).Normally, the subsequent arrivals that already know that other customers have arrived previously, they might be even more doubted to join the orbit queue (thus, λ e ≥ λ e + ).Similar arguments may hold for the case λ r ≥ λ r + .
where B i ∈ {0, 1} is the number of orbiting customers, which enter service at time the i-th service starts (i.e.B i = 1 if the i-th customer is an orbiting customer, and B i = 0 if the i-th customer is an external customer), and A i (B i ) is the number of external arrivals during the time the i-th served customer stays in the service station (A i (0) (resp.A i (1)) is the number of arriving customers during the service of a primary (resp.a retrial) customer).The random variable B i depends on the history of the system before the time τ i−1 only through the variable X i−1 , and its conditional distribution is given by where n is the orbit size and δ 0,n denotes the Kronecker's delta function.The service time of the i-th customer is independent of previous service times and the number of orbiting customers.Denote by S the corresponding service time.We now focus on the distribution of A i .Note that since we consider event-dependent arrival rates, we must take into account all the possible events mentioned at the end of the previous section.More precisely, Case 1: If X i > 0, the last event is a service completion that leaves the server idle.Thus, the next customer that occupies the server is either an external customer (at a Poisson rate λ − ), or a registered (i.e., a retrial) customer.Therefore, the last event for the first customer who arrives during the service of (i + 1)-th customer is either an arrival or a successful retrial.In case the server was occupied by an external customer, the first customer will arrive at rate λ e , and all subsequent customers at rate λ e + .In case the server was occupied by a retrial customer, the first customer will arrive at rate λ r , and all subsequent customers at rate λ r + .With such a framework, the next arrival depends both on the last event (i.e., arrival or service completion), and on the type of the customer that have occupied the server in the last (arrival) event.Case 2: If X i = 0, the last event is a service completion that leaves the system empty.The next customer that occupies the server is an external customer (at rate λ − ).Therefore, the last event for the first customer that will arrive after the server's occupation is an arrival, thus will arrive at rate λ e , and all the subsequent customers will arrive at rate λ e + .Thus, due to the event-dependency we need to obtain the distribution of the number of arrivals in a service of length t given the type of the customer that occupied the server.Denote by N (t) the number of arriving customers during a service of length t and let P e (N (t) = n) = P(N (t) = n | the server is occupied by a primary customer), P r (N (t) = n) = P(N (t) = n | the server is occupied by a retrial customer).
Then, the distribution of N (t), is given by the following set of differential equations: e P e (N (t) = 1) + λ e P e (N (t) = 0), (2)

123
Similarly, (3) The solutions of systems (2), (3) are respectively Note that the arrival processes are modified Poisson processes (see also Legros (2018)) where the first interarrival time follows a different distribution than the other interarrival times, and at the same time (for the first time in our work) depend also on the type of the customer that occupy the server (i.e., a primary or a retrial customer).Then, for i, n ≥ 0, Similarly, for i, n ≥ 0 r , i.e., A k (z) is the probability generating function (pgf) of the number of customers that arrive at the system during the service time of a customer of type k, k = e, r .Then, extensive computations lead to Remark 2 Note that in case of no event-dependency, i.e., for k = e, r , λ k The one-step transition probabilities p m,n = P(X i = n | X i−1 = m) are given by the formulae: Theorem 1 Let X i be the orbit length at the time of the ith departure, i ≥ 1.Then, Let π n , n ≥ 0, be the stationary probability that n customers are in the orbit at a service completion epoch.Then, the Kolmogorov equations reads: (5) In Theorem 2, we obtain (z), π 0 , and give the condition of the existence of (z), which also ensures the stationary regime.
Theorem 2 Under the stability condition (4), we have where .
Asking π 0 > 0 we have that ( 4) is also necessary for the ergodicity of the chain.

Proof
The proof is straightforward by using (5) and applying the generating function approach.The normalization condition implies the expression for π 0 .
Remark 3 Note that our model exhibits a behaviour closely related to the stochastic decomposition behaviour, which normally arise in the standard (i.e., no event-dependency) retrial systems.In particular, when λ r = λ − , λ r where M/G/1 (z) is the pgf of the number of customers at service completion epochs in the standard M/G/1 queue with event-dependent arrivals in Legros (2018), and , where A (1) k (1), k = e, r , are given in Corollary 2.Moreover, χ 1 (z) is the pgf of the number of orbiting customers given the system is idle.However, although χ 2 (1) = 1, χ 2 (z), is not obvious that constitutes a pgf.

Performance analysis at arbitrary instants
Let X (t) be the number of orbiting customers, C(t) be the state of the server, and I (t) be the last realized event at time t, with values as described in Table 2.
Let also Z (t) be the remaining time until the next service (when C(t) = 1), or seeking time completion (when C(t) = 0) at time t.Then, {(C(t), X (t), I (t), Z (t)); t ≥ 0} is an irreducible continuous time Markov chain describing the system model with state space Let also, We are interested in the steady-state counterparts (as t → ∞) of these probabilities.

The event-independent case
We now consider the event-independent case, where Then, using the previous results, our model reduces to the one in Gómez-Corral (1999), where the eventindependent case was treated.Indeed, it easy to see that when α * (λ) with λ b(1) < α * (λ) being the stability condition; see Theorems 1, 2 in Gómez-Corral (1999).

Performance metrics
Having obtained explicitly the pgfs, we can have in closed form the basic performance metrics.
Proof From the results obtained in Theorem 3 and using the normalization condition, the Corollary 1 is proved after heavy but straightforward computations.
The following corollary provides the throughput (T H S ) generated by the system, the expected orbit queue length (E(X )), and the expected sojourn time (E(W )).

Asymptotic behaviour under high rate of retrials
where P (∞) (z) is the pgf of the number of customers in the system obtained in the seminal paper Legros (2018), by assuming that λ r = λ − , and λ e = λ e + = λ r + = λ + .Note that in such a case, the customers who find the server busy repeat their calls almost immediately.
Note also that if we further assume λ − = λ + = λ, P (∞) (z) coincides with the pgf of the number of customers in the standard M/G/1 queue. .
Proof The proof follows the steps given in Artalejo and Falin (1994), and further details are omitted.
Theorem 4 provides a measure of the proximity between the steady state distributions for the standard M/G/1 queueing system with event dependent arrivals in Legros (2018) and our queueing system.The importance of these bounds is to provide upper and lower estimates for the distance between both distributions.

Explicit expressions for the Markovian case
In the following, we consider the purely Markovian case, where we assume that service, and retrieval times are exponentially distributed with rates μ, and α, respectively.To simplify further the analysis, we also assume that λ r + = λ r , λ e + = λ e .Note that under such a setting there are three events that affect the arrival rates: 1. a service completion, after which an external arrival occurs with rate λ − , 2. a service initiation by an external arrival, after which the next arrivals occur at rate λ e , 3. a service initiation by a retrial customer, after which the next arrivals occur at rate λ r .Let p 0, j = lim t→∞ P(X (t) = j, C(t) = 0, The following theorem states the main result.
Theorem 5 Under the stability condition αλ r + λ − λ e < αμ, the stationary probabilities of the system state are as follows: where z 1 , z 2 , with z i > 1, i = 1, 2, the two zeros of the polynomial Moreover, the probabilities of server's state are:

The Markov regenerative approach
Our aim in this subsection is to provide expressions for the joint distribution of the state of the server, the number of jobs in orbit, and the last realized event by following the method of regenerative processes.This method provides quicker the results on the stationary behaviour than the method of supplementary variables applied in Theorem 3, since the probability distribution of the embedded Markov chain in service completion epochs is known; see Theorem 2. For ease of computations, we assume that the seeking/retrieving times are iid exponentially distributed random variables with rate α (i.e., we adopt the constant retrial policy).
It can be easily verified that {(C(t), X (t), I (t); t ≥ 0)} is a Markov regenerative process with the embedded Markov renewal process {X m ; m ∈ N}.Thus, using the classical limiting theorems in Cinlar (1975), we have that under the ergodicity conditions established in Theorem 1 where ) denotes the expected amount of time spent by the process {(C(t), X (t), I (t); t ≥ 0)} in the state (i, j, E k ) during an interval between two successive service completion epochs, given that at the beginning of this interval there were n jobs in orbit, τ n denotes the expectation of the time interval between two successive service completion epoch given that at the beginning of this interval there were n jobs in orbit, and {π n ; n ≥ 0} are the limiting probabilities of {X m ; m ∈ N}, as given through the pgf in (6) for α * (λ − ) = α α+λ − .For the model at hand, , and π 0 as given in Theorem 2 for α * (λ − ) = α α+λ − .The following theorem states our main result.Theorem 6 Under the stability conditions given in Theorem 1, we have 1.The limiting probabilities are given by q (1) (16)

The partial generating functions
where q (1) , and π 0 as given in Theorem 2 when α Remark 4 With simple but tedious calculations, it is easy to realize that the expressions of pgfs in Theorem 6 coincide with those in Theorem 3 when α * (λ − ) = α α+λ − (i.e., when the seeking/retrieval times are iid exponentially distributed random variables with rate α).

The model under the linear control policy
In this section, we provide results on the model with multi-level event-dependent arrival rates, under the linear retrial policy Artalejo and Gomez-Corral (1997).Note that such a policy incorporates two types of retrial requests, i.e., the classical retrial policy and the constant retrial policy.More precisely, in the former policy, any orbiting customer retries independently to access the server, while in the latter one the time between two successive repeated attempts is independent of the number of customers applying for service.This section deals with the M/G/1 retrial queue with event-dependent arrival rates, allowing the simultaneous presence of both types of repeat requests.
Thus, for the model as described in Sect.2, we assume now that the control policy to access from the orbit queue to the server is governed by an exponential law with linear intensity nα + β(1 − δ 0,n ) when the orbit size is n ≥ 0, where δ 0,n denotes Kronecker's delta.Due to the linear retrial policy, the state probabilities defined in section 4 are the same except the one that refer to the case where the server is idle.Thus, we have p 0, j (t) := P(C(t) = 0, X (t) = j, I (t) = E 1 ), j ≥ 0, and p 0, j = lim t→∞ p 0, j (t).The pgfs in (8) remain valid, and let P 0 (z) = ∞ j=0 p 0, j z j , |z| ≤ 1. Theorem 7 The embedded Markov chain {X i ; i ≥ 0} at service completion epochs is ergodic if and only where A (1) . Proof To prove ergodicity, we use the Foster's criterion as in the proof of Theorem 1.By considering the function f (n) = n, the mean drifts then, lim n→∞ x n < 0 and ( 19) is a sufficient condition for ergodicity.The proof of necessity follows Theorem 1 in Sennott et al. (1983) and further details are omitted.
Theorem 8 If α > 0, β ≥ 0 and A (1) where and s−λ e P 0 (z), , Remark 7 Note that in the special case α = 0, our model refers to the retrial queue with constant retrial policy and event dependent arrival rates.In such a case, (G32) reduces to a simple expression for obtaining P 0 (z), .
In case β = 0, α > 0 we have the model under the classical retrial policy, and P 0 (z) = H (z). The rest expressions are derived by ( 23) for β = 0.

Numerical results
Our aim here is twofold.First, to focus on the effect of event-dependency on system performance: In particular, we aim to investigate how the event-dependency, i.e., the customers' behaviour based on the last realized event, affects the major performance metrics of our system; see Sect.6.1.In this direction, we model the customer's behaviour by a vector q := (q 1 , q 2 , q 3 , q 4 ) that refers to the joining probabilities of arriving customers after an arrival.In particular, the vector q states the willingness of an arriving customer to join the system when the server is busy, by taking into account the type of the customer that has occupied the server (i.e., either a primary, or a retrial customer), and whether he/she is the first after the arrival that has occupied the idle server, or they have already joined the system other primary customers before him/her.More precisely, let q 1 be the joining probability when the last event is an arrival of an external customer that occupies the idle server, q 2 be the joining probability when at least one customer has arrived after the occupation of the server by an external/primary customer, q 3 be the joining probability when the last event is an arrival of a retrial customer that occupies the idle server, and q 4 be the joining probability when at least one customer has arrived after the occupation of the server by an orbiting customer.Thus, we assume that (λ e , λ e + , λ r , λ r + ) = λ + q = λ + (q 1 , q 2 , q 3 , q 4 ).Second, we aim to obtain optimal joining probabilities that helps a system manager to determine whether an arriving customer will be allowed to enter the system or will be rejected.These probabilities are selected with ultimate goal to maximize the system generated throughput subject to certain constraints on the expected number of orbiting customers; see Sect.6.2.Note that throughput optimisation problems with delay constraints have been recently investigated in several service systems with shared resources as in Chen et al. (2018); Pappas et al. (2018); Ploumidis et al. (2017).
Assume hereon that the service and the retrieval times are such that B ∼ Erlang(M, μ), A ∼ Erlang(N , α), respectively.All the results are based on the derivations in Theorem 3, and in Corollary 2.

The effect of event-dependency on system performance
Example 1a: Set λ + = 0.3, μ = 2.5 and q = (q 1 , q 2 , q 3 , q 4 ) = (0.5, 0.4, 0.6, 0.4).Our aim is to investigate the effect of the number of phases of service times and retrial times on E(X ) for increasing values of λ − .Moreover, we aim to investigate how the relation among λ − and λ + affects E(X ).
Note that by increasing the number of phases of service times, E(X ) is also increasing as expected (see Fig. 1).Moreover, as λ − < λ + , E(X ) decreases, and as λ − ≥ λ + , E(X ) increases.Thus, under such a setting, by keeping the arrival rates after a service time lower than the arrival rates after an arrival, we ensure a better performance.This is due to the fact that keeping lower as possible λ − with respect to λ + , we give better chances for the blocked (i.e., retrial customers) to connect with the server.Thus, under the current setting, the customers feel more comfortable to arrive after an arrival, and connect with the server as retrial customers (as long as λ − < λ + ).
Figure 2 indicate that by decreasing α from 3.5 to 1.5, we cannot have the advantage of the previous setting.Thus, even if λ − < λ + , by increasing λ − , E(X ) increases as expected.
Furthermore, by increasing the number of phases of retrial times, we also fail to retain the advantage of the previous setting (see Fig. 3).This is because in such a case, there is a longer delay for the retrial customers to connect with the server, which in turn results in increasing the expected number of orbiting customers.

Example 1b:
Let know λ + = 0.5, α = 3.5, N = 2, and q = (0.1, 0.4, 0.5, 0.2).In Fig. 4 we observe that by increasing the number of phases of service we effectively reduce the expected waiting time when q 1 < q 2 , as λ − → λ + and beyond.This result is surprising, since as shown in Fig. 5, it is in contradiction with the improvement in the expected waiting time which results from the increase in the variability in the service process when the number of phases decreases and q 1 > q 2 .Example 1c: In Fig. 6 we can observe the effect of λ e = λ + q 1 on the expected number of orbiting customers for λ − = 0.1, (q 2 , q 3 , q 4 ) = (0.5, 0.6, 0.1).It is seen that there is a critical value of λ + (close to 0.5 in that example), where we can achieve a substantial decrease on E(X ).Moreover, we can see that a small increase on q 1 (from 0.2 to 0.4) will cause an increase on E(X ), which is expected.However, by further increasing q 1 , we observe that E(X ) start decreasing.It seems that such a behaviour arises as soon as q 1 > q 2 .Thus, it seems that it is better for the system manager to allow with high probability the arriving customers to join the system when the last event is the occupation of the server by the arrival of an external customer and then, to keep lower the joining probability after that event.
A similar behaviour is observed (even clearer) in Fig. 7, where now we focused the effect of q 3 , which is the joining probability when the last event was an arrival from the orbit that occupied the idle server.It seems that the more we increase q 3 (for fixed values of q 1 = 0.6 > q 2 = 0.5, q 4 = 0.4), the better performance we achieve, i.e., E(X ) decreases.In Fig. 8, we assume that q 1 = 0.2 < q 2 = 0.5, and observe a similar behaviour as in Fig. 7.However, for small values of λ + , E(X ) is smaller when q 3 < q 4 .As λ + increases, E(X ) remains smaller as long as q 3 > q 4 .

Optimisation problems
Our goal is to determine the optimal joining probabilities q = (q 1 , q 2 , q 3 , q 4 ) that maximize the throughput (T H S ) generated by the system, subject to constraints on the maximum attained service level on E(X ), and the stability.
These probabilities will dictate the way the arriving customers join the system when the last event is known.Therefore, they can serve as a guide for the system manager to see what would ideally be the arriving customer's behaviour when the last event is known.Equivalently, based on these values, he/she can adequately accept or reject arriving jobs subject to the last realized event, so that to maximize the system throughput.Throughput optimisation problems with delay constraints have been recently investigated in wireless systems with shared resources;  (2017).

Example 2a:
The optimal joining probabilities as functions of λ − that maximize T H S are given in Table 3.We observe that by increasing λ − , T H S increases too.It seems that when λ − < λ + , it is better to reject newly arriving customers after the occupation of the server by a primary customer (i.e., small q 1 , Table 3 Optimal values of joining probabilities as functions of λ − λ − q opt = (q 1 , q 2 , q 3 , q 4 ) Optimal T H S  M q opt = (q 1 , q 2 , q 3 , q 4 ) Optimal T H S q 2 compared with q 3 , q 4 ).When λ − = λ + , T H S is maximized by rejecting all the newly arriving customers that arrive after the occupation of the server by a retrial customer.

Example 2b:
In Table 4 we observe that the more we increase number of phases of retrial times, the less number of arriving customers we allow to enter the system.More precisely, we observe that when N = 30, T H S is maximized when we reject customers that arrive after the arrival of a primary customer, and it is better to accept customers that arrive after a successful retrial that occupies the idle server.This make sense since by increasing the number of phases of retrial times we also increase the time to retrieve an orbiting customer.Thus, if we aim to maximize the system throughput we need to somehow prioritize the orbiting customers, and give more chances to arriving customers to join the system when an orbiting customer is in service.
Under the same setting, but now fixing N = 4, and by varying M, we observe in Table 5 that the optimal joining probabilities are more sensitive on the number of service phases compared with the number of retrieval phases.In particular, if the number of service phases increases, then the maximum throughput decreases very fast.

Example 2c:
We now consider the optimisation problem in (24) with λ − = 1, λ + = 0.5, μ = 1.5, α = 3, M = 4, E(X ) = 20, but now by excluding the constraints q 2 < q 1 , q 4 < q 3 .Table 6 contains the corresponding optimal joining probabilities.We can now observe that contrary to the case in Table 4, there is no specific trend on the values of the optimal joining probabilities.Moreover, in most of the cases q opt 2 > q opt 1 and q opt 4 > q opt 3 .Thus, it seems that N q opt = (q 1 , q 2 , q 3 , q 4 ) Optimal T H S  it is better to accept customers with small probability when the last event is the occupation of the idle server by a primary (resp.orbiting) customer, and then to increase the accepting probability for the subsequent customers.Similarly to the case in Table 4, the number of phases of the retrieval times heavily affects the optimal values of the joining probabilities.
Example 2d: Table 7 contains optimal joining probabilities as functions of λ + , λ − .Remind that these rates characterize the arrival rates when the last event is an arrival and a departure, respectively.We can observe that when both λ + , λ − are small, the maximum throughput is achieved by allowing all the customers that arrive after the occupation of the idle server by either a primary or a retrial customer, but keeping lower joining probability for subsequent arriving customers after the server occupation by an orbiting customer.

Example 2e:
We now investigate the effect of service rate μ of a phase of the service time, on the optimal joining probabilities when the server is busy (we assume no specific ordering of joining probabilities).In particular, we assume that α = 3, M = 4, N = 2. Table 8 contains the optimal joining probabilities when λ − = λ + = 0.5, i.e., we assume that arrivals occur with rate λ + , and if a service completion is the last event, the will join with certainty the system, and seek for optimal joining probabilities when an arrival has occurred (i.e., λ + q i , i = 1, 2, 3, 4).Clearly, the more we increase μ, the less the expected service time, and the maximum throughput is achieved by allowing with high probability the arriving jobs to enter the system.For example, when μ > 4, arriving jobs after the occupation of the idle server by a primary customer are accepted with certainty, and the more we increase μ, the more  we increase the joining probability for subsequent arrivals, as well as for arriving customers when the last event is the occupation of the server by an orbiting customer.

Example 2f:
In all the preceding examples we have assumed that arrivals at an idle server join the system with certainty.Assume now that λ − = λ + q 5 , q 5 ∈ [0, 1].In the following we observe that the T H s is heavily affected by the arrivals that see an idle server; see Table 9.
More precisely, we can observe that in order to maximize the system throughput, it is better to keep low the probabilities of entering the system just after a service completion.This seems to be crucial as λ + increases and μ remains as small as possible.However, as μ increases the situation becomes smoother.Interestingly, in all cases, the maximum throughput is achieved when the joining probability after a departure is strictly less than 1.

Conclusion and future work
In this work, we introduced the concept of event-dependent arrivals in the retrial setting.We studied the stability condition, and investigated the stationary behaviour both at service completion, and at an arbitrary epoch (by applying both the supplementary variable method and the Markov renewal theory).We provided results for all the well known retrial policies, i.e., with general retrials, and under the linear retrial policy (which combines the classical and the constant retrial policy).Explicit expressions for various performance metrics are derived, and used to numerically investigate the effect of event-dependency on system's performance.We also formulated and solved constrained optimisation problems that shown insights into the effect of event dependency on the optimal joining probabilities.It seems that event-dependency is a result of customer's strategic behaviour, although we postpone the formal game-theoretical investigation as a future work.Indeed, consider an initial unobservable system with a potential arrival rate λ.At an arrival epoch, a customer decides either to join or not system.Although the system is unobservable, an arriving customer is informed about the last realized event; an arrival or a service completion.Let the net benefit for a customer who joins by the value of service, B, minus the cost of waiting proportional to a waiting cost per time unit, C. Given that the expected waiting time of an arriving customer is different whether the last event was an arrival or a service completion, a strategy after an arrival and after a service is described by five different probabilities of joining p+ := (q 1 , q 2 , q 3 , q 4 ) and p − , by taking also into account the type of a customer that occupies the server (i.e., a retrial or a primary).More precisely, let λ+ := λ p+ , λ − := λ p − .The values of p − , p+ are such that the stability condition is satisfied, and the values of p+ are such that: q 1 refers to the case the last event is an arrival of an external customer to an idle server, q 2 refers to the case the last event is a subsequent arrival to a busy server, which was initially occupied by an external customer, q 3 refers to the case the last event is an arrival of a retrial customer to an idle server, and q 4 refers to the case the last event is a subsequent arrival to a busy server, which was initially occupied by a retrial customer.Having that description in mind one can consider the net benefit for a customer who arrives after and arrival and service and seeking for optimal joining probabilities and identify the equilibrium, social and profit maximizing strategies.
Several other questions are open for future research.It would be worth investigating the effect of event-dependency on service times, i.e., to allow the service rates to depend on the last realized event.Our modeling framework allows also to consider several characteristics, such as priorities, vacations, breakdowns and repairs.Another option is to investigate the possibility of obtaining the performance metrics through the QMCD (Queueing & Markov Chain Decomposition) method Baron et al. (2018).

On the admission control problem
We now discuss how one can investigate the admission control problem Koole (2007) by using an MDP framework.In the admission control problem, the system manager must determine upon the the arrival of a customer whether to allow him/her to enter the system or to reject him/her.
With ultimate goal to maximize the throughput of served customers with a service level constraint on the expected number of orbiting customers, such a decision can be based on the number of customers present in orbit, the distribution of the remaining service time and the last realized event.Due to the fact that a deterministic admission policy is easier (than the randomized) to implement in real system one can focus on determining a threshold policy, depending on the last realized event and on the remaining service time of the customer in service.More precisely, given that there will be k customers in orbit, and the remaining service equal s, we seek for thresholds, say k e,1 s , k e,2 s , k r ,1 s , k r ,2 s , k − such that, -If a primary arrival occurs after an arrival of a primary customer that occupies an idle server, then, this customer is rejected (and leave the system without service) if k > k e,1 s .
-If a primary arrival occurs after at least one primary arrival after the occupation of an idle server by a primary customer, then, this customer is rejected (and leave the system without service) if k > k e,2 s .-If a primary arrival occurs after an arrival of an orbiting customer that occupies an idle server, then, this customer is rejected if k > k r ,1 s .-If a primary arrival occurs after at least one primary arrival after the occupation of an idle server by an orbiting customer, then, this customer is rejected (and leave the system without service) if k > k r ,2 s .-If a primary arrival occurs after a service completion, then, this customer is rejected if k > k − (i.e., we give priority to the orbiting customers to occupy the idle server, if there are more than k − ).
To proceed with the set up of the problem, we assume that the service time is Coxian distributed (note that this is a proper choice to approximate the service time distribution since it is dense in the class of all non-negative distributions.However, one still needs to set the number of phases to appropriately approximate the considered service time distribution Horváth and Telek (2002)).Coxian distribution is defined by the parameters μ j > 0, and r j ∈ [0, 1], 1 ≤ j ≤ N , with r 1 = 0, where r j (resp.r j = 1 − r j ) denotes the probability of entering the remaining phase j − 1 after leaving the remaining phase j (resp.completing the service time after leaving phase j), while and the parameter μ j is the rate of the exponentially distributed random duration of the remaining phase j.For simplicity, we assume that the retrial times can be exponentially distributed with rate α.We seek for necessary conditions under which a deterministic threshold-type policy can be optimal.This can be done by using the value iteration technique, where structural properties of the value function can be proven by induction.
Our problem can be considered as a constrained Markov decision process (MDP) Altman (1999) (i.e., maximize the throughput of served customers with a constraint on the expected number of customers in the system), and can be investigated using various techniques, such that the one that introduces the constraint into the objective function by using a Lagrange multiplier.Then, one can realize that the optimal policy for a certain Lagrange multiplier is optimal for the constrained problem when the value of the constraint under this policy attains exactly E(X ).Thus, it follows that this policy is stationary and randomizes in at most one state.Then, the optimisation problem can be rewritten as min(E(X ) − c × T H S ), where the non-negative coefficient c is the Lagrange multiplier which refers to the relative importance, given by the system manager, of the throughput of served customers (T H S ) compared to the expected number of customers in the system (E(X )).
It would be better to proceed by applying a uniformization method (Puterman (1994), Sect.11.5.2) and consider the discrete time version of the model asking λ − + λ e + λ e + + λ r + λ r + + α + N j=1 μ j = 1.Then, we formulate a two-step value function so that to separate transitions and actions, and then, we define the dynamic programming value functions where the operator W n denotes the decision to accept or to reject a newly arriving customer.
In particular, For each n > 0, x ≥ 0, we have a minimizing action upon a customer's arrival, i.e., to allow this customer to enter the system or reject him/her.In order to obtain the long-run average optimal actions one can use the value iteration method developed in Howard (1960), by recursively evaluating V n using equations ( 25), ( 26), for n ≥ 0. The form of the optimal policy is closely related to the structural properties of the value function, and it would be interesting to derive conditions for which one can have optimal threshold policies based on the number of orbiting customers for a given number of remaining phases of service.We believe that by using a standard MDP approach where structural properties of the value function are proved by induction, one can derive such optimal threshold-type policy.The formal and detailed investigation of this task is postponed as a future research work.
Due to the complicated nature of this problem, it seems to be a difficult task to find, and further to implement the optimal policy in a real system.With that in mind, one can consider a simplified version, where the thresholds on the orbit queue length would depend only on the number of orbiting customers, and further to assume that k y = k + , y ∈ {+ e , + e,1 , + e,2 , + r , + r ,1 , + r ,2 }, so that we would have two thresholds, k + , k − : If an arrival occur after an arrival (resp.a service), this customer is rejected if k > k + (resp.k > k − ).Although the proposed policy would be not optimal, it is simpler to implement in practice.Moreover, compared to the Coxian approximation, which leads to the application of the matrix-geometric method to derive the performance measures, the simplified approach we propose here leads to the derivation of explicit expressions for the performance metrics for any service/retrieval time distribution.
Assuming that k + > k − , the stationary probabilities at departure instants, say p := ( π0 , . . ., πk + ), can be derived using a similar approach as in Sect.3, where now the one step transition probability matrix, say P := ( pi, j ), i, j = 0, . . ., k + , is given by p0 Note that from i = k − + 1 to i = k + , there cannot be any arrival during a service since the first arrival after the service completion cannot occur.Thus, we can only have an orbiting customer that will enter the service with probability 1, and the orbiting customers will be reduced by one at the next service completion.
One can then solve the system π = π P, with k + i=0 πi = 1, to obtain the stationary distribution of the orbit size at service completion epochs.The stationary probabilities at an arbitrary epoch can be also derived in a similar fashion as in Sect.4, so further details are omitted.With these results, one can solve optimisation problems (as for the case of the infinite thresholds in the optimisation problem in (24)) to find optimal thresholds, say k + opt , k − opt , to maximize the generating system throughput.Again, we do not claim that this can be an optimal two-threshold policy.(4) Letting t → ∞, Eqs.(B2)-(B9) reduce to those given in (7).

Appendix C: Proof of Theorem 3
Multiplying the second in ( 7) with e −sr , integrating with respect to s ∈ [0, ∞), and having in mind that p * 0, j (s) = ∞ 0 e −sr p 0, j (r )dr, yields Multiplying with z j , and summing for all j ≥ 0 yields For s = λ − we obtain, ) and substituting back in (C10), By repeating the same procedure for the third in (7), we obtain ) and setting s = λ e yields Substituting back in (C13) yields So the second in (9) has been proved.By applying the same procedure for the forth in (7) we obtain (C19) Summing the above equations and using (C14), we obtain .

Table 1
Summary of event description and the corresponding arrival rates

Table 2
Description of the states of I (t)

Table 6
Optimal values of joining probabilities

Table 9
Optimal values of joining probabilities as functions of λ + , μ λ and indicate if changes were made.The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material.If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder.To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.