# A performance analysis of channel fragmentation in dynamic spectrum access systems

## Authors

Open AccessArticle

- First Online:
- Received:
- Revised:

DOI: 10.1007/s11134-012-9317-7

## Abstract

Dynamic Spectrum Access systems offer temporarily available spectrum to opportunistic users capable of spreading transmissions over a number of non-contiguous subchannels. Such methods can be highly beneficial in terms of spectrum utilization, but excessive fragmentation degrades performance and hence off-sets the benefits. To get some insight into acceptable levels of fragmentation, we present experimental and analytical results derived from a mathematical model. According to the model, a system operates at capacity serving requests for bandwidth by assigning a collection of one or more gaps of unused bandwidth to each request as bandwidth becomes available. Our main result is a proof that, even if fragments can be arbitrarily small, the system remains stable in the sense that the average total number of fragments remains bounded. Within the class of dynamic fragmentation models, including models of dynamic storage allocation that have been around for many decades, this result appears to be the first of its kind.

In addition, we provide extensive experimental results that describe behavior, at times unexpected, of fragmentation as parameter values are varied. Different scanning rules for searching gaps of available spectrum, all covered by the above stability result, are also studied. Our model applies to dynamic linked-list storage allocation, and provides a novel analysis in that domain. We prove that, interestingly, a version of the 50 % rule of the classical, non-fragmented allocation model holds for the new model as well. Overall, the paper provides insights into the behavior of practical fragmentation algorithms.

### Keywords

Dynamic spectrum access Fragmentation Ergodicity of Markov chains Cognitive radio Lyapunov function### Mathematics Subject Classification

60J20## 1 Introduction

*white spaces*(also known as

*spectrum holes*) that are not used by the Primary Users but must avoid interfering with active Primary Users (for instance, see Fig. 1).

An SU’s channel allocation may be broken down into a number of *subchannels*, each allocated to a distinct hole of unused bandwidth. As shown in Fig. 1, this can be realized, for example, by employing a variant of Orthogonal Frequency-Division Multiplexing (OFDM) [10, 15, 18–20, 22]. Although the physical-layer aspects of OFDM-based Dynamic Spectrum Access have been extensively studied recently, allowing channel fragmentation introduces several new problems [12, 20, 23] that significantly differ from classical Medium Access Control (MAC).^{1}

In this paper, we study a baseline *theoretical model* in which the spectrum is shared by SUs only. Those users have to transmit and receive data, and accordingly need some bandwidth for given amounts of time. Hence, bandwidth requests of SUs are characterized by a desired total bandwidth and the duration of a time interval over which it is needed. The data transmission can take place over a non-contiguous channel (i.e., a number of subchannels). Once a transmission terminates, some fragments (subchannels) are vacated, and therefore, gaps (spectrum holes/white spaces) develop randomly in both size and position. When allocating a channel to a new SU request, it is fragmented (in the frequency domain) into available gaps until the full requested bandwidth is provided. This process repeats itself, until the next request fails to fit into the available fragments (more details are provided in the model subsection below).

The main goal of the paper is to investigate the phenomena of fragmentation induced by spectrum allocation algorithms. For this purpose, we will ignore the particularities of techniques such as OFDM and make a couple of assumptions (for a complete system description, see Sect. 2): (i) the system operates at capacity and there is always a waiting bandwidth request; and (ii) the fragment size is not bounded from below. Making the first assumption allows us to study the effect of fragmentation in the worst case. Clearly, if there are idle periods, when there are no waiting requests, only departures occur and the fragmentation level of the system decreases during these periods. Similarly, the latter assumption allows us to study the system performance when artificial lower bounds on the fragment size are not imposed. This differs from OFDM-based systems in which a subcarrier has a given minimal bandwidth.

In the application of these spectrum allocation algorithms, intriguing new problems in dynamic allocation arise. For example, because of the dynamic use of the spectrum, the bandwidth available to a new user will usually be distributed among a number of gaps in the spectrum. In principle, the random arrival and departure of users might cause the system to evolve in such a way that sequences of many, very small gaps are often allocated to user requests. In such cases, the system performance will deteriorate, since the algorithms maintaining the state of a highly fragmented spectrum become more time-consuming. To put these remarks on a proper footing, we first need to introduce the details of our model.

### 1.1 The model

A continuous frequency band of given width is made available to users. Each such user makes a request composed of a required total bandwidth and the duration of a residence time for the exchange of data over a channel of this bandwidth. Channels are allocated to requests on a first-come-first-served basis, subject to available bandwidth. A channel must remain fixed while active, and on departure it returns its allocation to the pool of available bandwidth. The channel of an allocated request is allowed to consist of multiple, disjoint bandwidth fragments, each being accommodated by a gap of unused spectrum that was available at the time of allocation.

*u*

_{1},

*u*

_{2},…. We will also use

*u*

_{ i }as the name of the

*i*th user. An initial, non-fragmented state is constructed as follows. Starting at 0, consecutive subintervals of sizes

*u*

_{1},

*u*

_{2},… are assigned as the channels of waiting users until a request size

*u*

_{ i },

*i*>1, is encountered which exceeds available bandwidth, i.e.,

At this point, all *i*−1 of the channels in this initial state begin their residence times. Subsequent state transitions take place at departure epochs when the residence times of currently allocated channels expire. Suppose all requests up to *u*
_{
j
} have been allocated channels and a request *u*
_{
i
}, *i*≤*j*, departs, releasing its allocated channel. If there is still not enough bandwidth for *u*
_{
j+1}, then it must wait for one or more additional departures. Otherwise, *u*
_{
j+1},*u*
_{
j+2},… are allocated their requested bandwidths until, once again, a request is encountered that asks for more bandwidth than is available. All channels then begin or continue their residence times as before until the next departure.

*linear-scan*(LS) rule sets up a channel by scanning the spectrum in order of increasing frequency, allocating gaps of available bandwidth in partial fulfillment of the request until enough bandwidth has been allocated to satisfy the entire request. In general, the last gap is only partially used, in which case the last fragment is left-justified in the last gap. An example is shown in Fig. 2. Allocations are shown for the first eight user requests, assuming that, at time 0, the spectrum is not in use. The requests with sizes

*u*

_{1},

*u*

_{2}, and

*u*

_{3}are the first to be allocated channels;

*u*

_{4}must wait for a departure, since the first four request sizes sum to more than 1. The variables

*t*

_{ i }give the sequence of departure times of allocated requests. We see that the first occurrence of fragmentation takes place at the departure of

*u*

_{2}and the subsequent admission of

*u*

_{4}; an initial fragment of

*u*

_{4}is placed in the gap left by

*u*

_{2}and a final fragment is placed after

*u*

_{3}. Note also that, even after

*u*

_{2}and

*u*

_{4}have departed, there is still not enough bandwidth for

*u*

_{5}. After the additional departure of

*u*

_{1}, both

*u*

_{5}and

*u*

_{6}, but not

*u*

_{7}, can be allocated bandwidth.

We complete the model description by giving the probability laws governing the residence times and sizes of the waiting requests. With *α*∈(0,1] a parameter of the model, the sizes *u*
_{
j+1},*u*
_{
j+2},… are drawn independently from the uniform distribution on (0,*α*]. The residence times of allocated requests are independent of request sizes and form a sequence of i.i.d. exponentially distributed random variables. For simplicity, the mean is normalized to 1.

### 1.2 Main results

At first glance, since request sizes can be arbitrarily small, the fragments used by bandwidth requests might well become progressively narrower as time passes, in which case the number of fragments could grow without bound. Clearly, such an operational model cannot be supported by a realistic system, so it is of great interest to know whether this can actually happen. The principal theoretical contribution of this paper is a proof that in fact, with high probability, the number of fragments in the system remains acceptably low. A precise statement is deferred to the next section where additional notation and concepts are introduced.

In addition to mathematical results, and in order to gain further insight into the performance of the system, we present the results of extensive experiments. These show that although for a given maximum request size *α*, the number of fragments has a finite expected value, there is a linear relationship between 1/*α* and the expected number of fragments into which a request is divided. This indicates that when the requests are constrained to be small, they are also fragmented into a relatively large number of fragments. From a practical point of view, this implies that, if we can impose a lower bound on the fragment size by rejecting gaps that are too small, then we have a useful control on the ill effects of excessive fragmentation.

Our experiments show that different bandwidth allocation algorithms exhibit significantly different performance in terms of the fragmentation occurring in the system. As one example, an algorithm that scans the gaps in decreasing order of their sizes reduces the fragmentation by almost an order of magnitude compared to LS. Interestingly, the experiments also show that the number of fragments is distributed according to a normal law with a relatively low mean value. Finally, the experiments for small *α* led to the interesting observation that the ratio of the average number of gaps to the average number of requests being served was approximately 1/2. Although we were unable to prove this ratio-of-averages result, we were able to prove a corresponding 50 % limit law for the expected value of the ratio of the number of gaps to the number of requests being served.

The spectrum allocation problems described here can be characterized in the context of dynamic storage allocation problems of computers; see Knuth [14]. In that context, the term “spectrum” refers to the storage unit, “bandwidth requirements” refer to storage requirements, and “channel” refers to a region in storage containing a file. In the original dynamic storage model, fragmentation referred only to the gaps of unoccupied storage interspersed with intervals of occupied storage: files were not fragmented. The reader familiar with that model may have found the 50 % rule observed in our experiments to be reminiscent of Knuth’s 50 % rule, which asserts that the number of gaps is approximately half the number of files when exact fits of files into gaps are rare. Our notion of fragmentation applies also to the files themselves, so our discovery that a similar 50 % rule continued to apply was a surprising one at first. Note that, in terms of the storage application, our model corresponds precisely to *linked-list* allocation of files—channels allocated to requests are sets of linked, disjoint segments of storage allocated to file fragments. Our results provide a novel analysis for such systems, and have implications for the garbage-collection/defragmentation process in linked-list systems. We note that studies of dynamic storage allocation have been around for some 40 years, and widely recognized as posing very challenging problems to both combinatorial and stochastic modeling and analysis. In particular, results of the type found in this paper, rigorous within stochastic models, seem to be quite new.

The remainder of the paper begins in the next section with the introduction of notation, a formalization of the spectrum state space, and the stochastic processes of interest in later sections. Section 3 presents experimental results that bring out the effects of fragmentation, particularly as a function of the maximum request size *α*. In Sect. 4 relations between variables describing the configuration of gaps and fragments are proved in preparation for (1) a *50 % limit law* for the relation between the number of active channels and the number of gaps in the spectrum at departure times, and (2) our main stability result, which shows that the expected value of the total number of fragments and gaps is bounded. These results are proved in Sects. 4 and 5, respectively. Section 5 also proves that, for *α* large enough, an equilibrium distribution exists. Section 6 discusses algorithmic issues, such as changes in performance resulting from alternative allocation algorithms, and Sect. 7 discusses experimental results that exhibit normal approximations for the total number of fragments and gaps. Section 8 concludes the paper with a discussion of the results and future research directions.

## 2 Preliminaries

The state of a fragmentation process must carry the information given by a sequence of gaps alternating with sequences of contiguous fragments. Accordingly, we formalize a state space \({\mathcal{S}}\) for our model as follows.

### Definition 1

*u*is the size of the request waiting at the head of the queue,

*r*≥1 is the number of currently active channels, and

*L*

_{ i }is the list of open subintervals of [0,1] occupied by the fragments of the

*i*th channel. For

*x*to be admissible, the open intervals in ⋃

_{ i }

*L*

_{ i }must be mutually disjoint, and, since the size of

*u*exceeds the bandwidth available,

*u*>1−∑

_{ i }

*s*

_{ i }has to hold, where

*s*

_{ i }is the cumulative size of the fragments in

*L*

_{ i }.

Since channel residence times are i.i.d. exponentially distributed random variables, the process (*X*(*t*)) on \(\mathcal{S}\) is a Markov process. The Markov chain embedded at departure times *t*
_{
n
} will be of special interest.

When treated as a random variable, the size of the request waiting to be allocated bandwidth at time *t* is denoted by *U*(*t*). Similarly, *U*
_{
i
}(*t*) denotes a random variable giving the size of the *i*th request behind the head of the queue. Except for Sect. 5, the dependence on time will usually be omitted. We denote by *R*(*t*) the number of requests with an active channel at time *t*. *F*(*t*) and *G*(*t*) denote, respectively, the numbers of fragments and gaps at time *t*.

*η*>0 and any initial state \(x \in\mathcal{S}\),

*X*started at

*X*(0)=

*x*. While our choice of a uniform distribution for request sizes is a useful one, it is not essential to this result; it holds for more general distributions. The result shows that the sum

*F*(

*t*

_{ n })+

*G*(

*t*

_{ n }) is strongly concentrated near the origin. This fact provides strong support for the informal assertion made in Sect. 1 to the effect that, with high probability, the level of fragmentation stays reasonably low. Our analysis has several basic ingredients: relations between the number of fragments and gaps in the spectrum (Lemma 2); a drift relation of Lyapunov type for the total number of gaps, fragments, and requests (Proposition 1); a general inequality for Markov chains (Theorem 4); and a stability result of [13].

The last of these results refers to the early work of Kipnis and Robert [13] on a non-fragmented version of our model. Channel allocations can be moved as needed in order to put all available bandwidth together in one block, so fragmentation is avoided entirely. They consider a system with arrivals, but with arrival rates sufficiently high, their analysis of maximum throughput gives us an analysis of (*R*(*t*
_{
n
})), assuming that the same probability laws for request sizes and residence times apply. This follows simply from the fact that the admission criterion for waiting requests is the same in both models. A major result in [13] asserts the existence and uniqueness of an invariant measure for (*R*(*t*
_{
n
})). Explicit formulas are hard to come by, but those in [13] for the maximal departure rate in special cases have provided useful checks for our experiments.

In Sect. 6, we shall also evaluate two scanning alternatives to LS. The first is *circular scan* (CS), which is still a linear scan of the gaps, but each scan starts where the previous one left off; after the last gap in [0,1], CS cycles back to the first gap in [0,1]. The second is *largest-first-scan* (LFS), which is intended to further reduce fragmentation by assigning gaps in order of decreasing size. Although these algorithms make different scans of the gap sequence, they are all alike in their treatment of the last gap occupied: *the last fragment is left-justified in the last gap*. This is a key assumption, and it is very likely to hold in practice. In our probability model, it follows that, with probability 1, the last gap used in a channel allocation will be changed to a fragment and a smaller residual gap.

## 3 Experimental results

The experimental study reported in this section serves two related roles. First, it brings out characteristics of the fragmentation process that need to be borne in mind in implementations, particularly where these characteristics show parameter values that must be avoided, if a system with fragmentation is to operate efficiently. The second role is that of experimental mathematics, in which results indicate where behavior might well be formalized and rigorously proved as a contribution to mathematical foundations. In the latter role, this section leads up to the next two sections, which formalize and prove the stability of the fragmentation process.

The experiments were conducted with a discrete-event simulator written in C that also includes a stochastic arrival process, a capability that we intend to explore in future research. The maximum request size *α* is the single parameter surviving the normalizations of the simpler mathematical model of this paper. The simulations were most demanding, of course, for small *α*, when large numbers of departure events were needed to ensure behavior near the stationary regime. For every *α* value chosen in the interval [0.01,1], 20 million departure events were simulated starting in an empty state, with data collected for the last 10 million events. For every choice of *α* in [0.001, 0.01], 100 million departure events were processed and data collection was performed during the last 50 million events. The excellent accuracy of this tool was established in tests against exact results for special classes of queueing systems, and against the maximum throughput results derived in [13]. Examples of the test results can be found in the appendix and in [21].

*α*for small values of

*α*; indeed, the errors in the linear fits are within the thickness of the printed lines. In particular, the asymptotic (as

*α*→0) average number of channels in the spectrum is 2/

*α*. When requests are large relative to the spectrum (i.e., for

*α*>1/3), the behavior is not given by functions quite so simple. As such cases are of less practical interest, we omit the relevant data.

*α*. This is the unexpected version of Knuth’s 50 % rule that we mentioned in Sect. 1. We return to this behavior in the next section, where we prove a 50 % limit law. The linear growth of the average number of fragments per channel may also be unexpected at first glance: the fragmentation of channels

*increases*as the average channel size

*decreases*. This linear growth implies the quadratic growth of the average total number of fragments plotted in Fig. 4 (the accuracy of the fit is as before: the error is within the thickness of the printed lines).

*types*defined as follows: a fragment is of type

*i*, if it is adjacent to

*i*other fragments, where

*i*=0, 1, or 2. It can be seen in Fig. 5 that for small

*α*, more than 90 % of the fragments are type-2 fragments. In addition, clearly, the number of type-0 and type-1 fragments is a function of the number of gaps. These observations and the results illustrated in Figures 3 and 4 indicate that, even for relatively small 1/

*α*, the average total number of type-0 and type-1 fragments grows linearly in 1/

*α*, but the average number of type-2 fragments grows quadratically.

*α*, they are close to each other. The relation holds even for moderately large

*α*, although for

*α*rather close to 1, the difference amounts to about a factor of 2. With this property and the 50 % rule suggested by Fig. 3, the linear growth in the number of fragments per channel (shown in Fig. 3) is easily explained for moderately small

*α*in the following way.

As mentioned above, for moderately small *α*, the number of channels is approximately 2/*α* (i.e., the spectrum size divided by the average request size). By the 50 % rule, the number of gaps is roughly 1/*α*. At any time, the total size of the gaps is at most *α*, since there is a request waiting for departures whose requested bandwidth exceeds the total size of the gaps. Therefore, at most *α* available bandwidth is spread among 1/*α* gaps, giving an average gap size on the order of *α*
^{2}. The average fragment size is at most (and indeed very close to) the average gap size. The fragments must occupy at least 1−*α* of the spectrum since, as mentioned above, at most a fraction *α* of the spectrum is devoted to gaps. Thus, the number of fragments must be on the order of 1/*α*
^{2}, and so the average number of fragments per channel must be on the order of (in particular, linear in) 1/*α*. As *α*→0, the asymptotics of these estimates become more precise.

## 4 Numbers of fragments and gaps

This section presents analytical results relating the numbers of fragments and gaps under the fragmentation process (*X*(*t*)). Recall the definition of fragment types: For *i*=0, 1 or 2, a fragment is said to be of type *i* if it touches exactly *i* other fragments.*N*
_{
i
}(*t*) denotes the number of type *i* fragments at time *t*, so that *F*(*t*)=*N*
_{0}(*t*)+*N*
_{1}(*t*)+*N*
_{2}(*t*) is the total number of fragments.

*σ*(

*t*) denote the sum of the numbers of fragments and gaps,

### Lemma 1

*With probability*1,

*for any*

*t*≥0,

*where*

*I*(

*t*)=1,

*if there is a gap starting at the origin*,

*and*0

*otherwise*.

### Proof

Each gap, except for boundary gaps starting at 0 or ending at 1, separates two fragments. Two gaps surround a type-0 fragment not touching the origin, only one touches a type-1 fragment not touching the origin, and none touch a type-2 fragment, so the gaps strictly inside (0,1) are double-counted in 2*N*
_{0}(*t*)+*N*
_{1}(*t*). Gaps at the boundaries are counted only once in this expression, so if there are gaps touching each boundary, 2 must be added to 2*N*
_{0}(*t*)+*N*
_{1}(*t*) to produce a double count of all gaps. Then *N*
_{0}(*t*)+*N*
_{1}(*t*)/2+1 counts the gaps as called for by the lemma.

With probability 1, a gap always touches the boundary at 1, so the only case left to consider is the absence of a gap touching the origin. In this case, there is a type-0 or type-1 fragment touching the origin, and so a nonexistent gap has been counted in 2*N*
_{0}(*t*)+*N*
_{1}(*t*). This over-count cancels the under-count of the gap touching 1, and so no correction term is needed, i.e., *N*
_{0}(*t*)+*N*
_{1}(*t*)/2 counts all gaps as stated in the lemma. □

### Definition 2

*t*

_{ k }) denote the sequence of departure times, let

*D*

_{ i }(

*t*

_{ k }) denote the number of type

*i*fragments in the channel leaving at time

*t*

_{ k }, and let

*A*(

*t*

_{ k }) denote the number of requests admitted to the spectrum at time

*t*

_{ k }. Finally, define the

*drift*in the total number of fragments and gaps:

*t*

_{0}=

*D*

_{ i }(

*t*

_{0})=

*A*

_{ i }(

*t*

_{0})=0.

The following lemma is the basis of the stability analysis of *σ*(*t*) in Sect. 5, and the 50 % rule proved later in this section.

### Lemma 2

*With probability*1,

*the departure at*

*t*

_{ k }

*creates the following change in the total number of fragments and gaps*:

*with*

*t*

_{0}=0,

*and*

*J*(

*t*

_{ k })=1,

*if a fragment starting at the origin is in the departing channel*,

*and*0

*otherwise*.

### Proof

With probability 1, each new channel allocation covers completely every gap it is allocated, except for the last one, which is only partially covered. Thus, with probability 1, each new channel allocation changes gaps to fragments, except for the last gap which is changed to a fragment plus a gap; this adds one to *σ*(*t*
_{
k−1}) for each admission, which accounts for the total of *A*(*t*
_{
k
}) in (4).

Two fragments of the same channel cannot be contiguous, so it is correct to add up the changes created by departing fragments, with each being treated separately. Suppose first that there is no fragment (0,*b*) against the origin. Then for every type-0 fragment in the departing channel, two gaps and a fragment are replaced by a single gap for a net decrease of two, and for every departing type-1 fragment, a gap and a fragment are replaced by a single gap for a net reduction of one. This gives the reduction of 2*D*
_{0}(*t*
_{
k
})+*D*
_{1}(*t*
_{
k
}) appearing in (4). If there is a fragment (0,*b*), it must be of type 0 or 1; if it is of type 0, then its departure gives a decrease of one; if it is of type 1, its departure has no effect. Each of these contributions is one less than it would be were the fragment not touching the origin. There can only be one such fragment, so the correction shown in *J*(*t*
_{
k
}) for a fragment (0,*b*) follows. □

*G*

^{−}(

*t*

_{ k }) the total number of gaps just after the

*k*th departure, but before new admissions, if any, are made. Note that if we remove

*A*(

*t*

_{ k }) from the right-hand side of (4) and add back the total number of departing fragments at

*t*

_{ k }, i.e.,

*D*

_{0}(

*t*

_{ k })+

*D*

_{1}(

*t*

_{ k })+

*D*

_{2}(

*t*

_{ k }), we get the number of gaps available to admissions at the

*k*th departure:

*J*(

*t*

_{ k })=1 as in Lemma 2.

Knuth’s widely known *50 % rule* appears in a very different context than the model here, so it is difficult to anticipate the apparent fact that it also holds for our fragmentation model. However, one can argue a similar result assuming that the fragmentation process has a stationary distribution. The result is given below as an expected value of a ratio, rather than a ratio of expected values.

### Theorem 1

*Assume that for each*

*α*>0,

*the fragmentation process at departure epochs*(

*X*(

*t*

_{ k }),

*k*≥0)

*with request sizes uniformly distributed in*(0,

*α*)

*admits at least one stationary distribution*.

*For each*

*α*>0

*pick one stationary distribution*

*π*

_{ α }.

*Then*

### Proof

*π*

_{ α }must satisfy \(\mathbb {E}_{\pi_{\alpha}} [ \sigma(t_{1})] = \mathbb{E}_{\pi_{\alpha}} [\sigma(t_{0})]\) and \(\mathbb{E}_{\pi_{\alpha}} [A(t_{1})] = 1\). Thus, using Lemma 2 one gets

*x*having

*R*(0)>0 channels and

*N*

_{ i }(0) type-

*i*(

*i*=0,1,2) fragments, we have from Lemma 1

*R*(0). Using in addition

*I*(0)=0 or 1 one gets

*π*

_{ α }the random variable

*R*(0) under

*π*

_{ α }must be distributed according to the stationary distribution of the non-fragmented model of Kipnis and Robert [13], and one easily checks that \(\mathbb{E}_{\pi_{\alpha}}(1 / R(0))\) goes to 0 as

*α*goes to 0, hence the result. □

Note that, because we have a Lyapunov function (see Proposition 1), the existence of a stationary distribution would be guaranteed if we could prove that the process (*X*(*t*
_{
n
})) has the Feller property, see for instance Proposition 12.1.3 in Meyn and Tweedie [16].

## 5 Stability results

This section establishes that the average total number of fragments and gaps remains bounded and that, for certain distributions of request sizes, ergodicity holds. The analysis leads to the following two results. Recall that (*t*
_{
n
}) is the sequence of departure times (*t*
_{0}=0) and *σ*(*t*)=*F*(*t*)+*G*(*t*), defined in (1), is the total number of fragments and gaps.

### Theorem 2

*There exists some*

*η*>0

*such that*,

*for any initial state*\(x \in \mathcal{S}\),

Clearly, this implies that for any initial state \(x \in\mathcal{S}\), the sequence (\(\mathbb{E}_{x}(\sigma(t_{n}))\), *n*≥0) is bounded. With an additional assumption on the distribution of the request size, a stronger stability result can be proved.

### Theorem 3

*When*
*α*>1/2, *the process* (*X*(*t*)) *is positive Harris recurrent*; *in particular*, *it has a unique stationary distribution*.

A criterion for finite exponential moments using a Lyapunov function is established next. Then, we provide some estimates of the drift of the number of fragments between departures which will show us how to construct such a Lyapunov function. The proofs of Theorems 2 and 3 will finally be given in Sects. 5.4 and 5.5.

### 5.1 A criterion for finite exponential moments

Before stating the main result, some results on Markov chains are needed. In the sequel, ≤_{st} refers to stochastic ordering, i.e., *V*≤_{st}
*Z* means that \(\mathbb{E}(f(V)) \leq\mathbb {E}(f(Z))\) for any increasing function *f*. For reasons that will become clear in Lemma 5, the following lemma focuses on admissions at four consecutive departure times. Recall that (*U*
_{
i
},*i*≥1) are the sizes of the requests waiting to be allocated bandwidth after *U*, the first one, and that they are assumed to be i.i.d.

### Lemma 3

*The random variable*
*A*(*t*
_{1})+⋯+*A*(*t*
_{4}) *is stochastically dominated by a random variable*
*Z*
*such that*
\(\mathbb{E}(e^{\lambda Z}) < +\infty\)
*for some*
*λ*>0.

### Proof

*A*(

*t*

_{1})≤

*Z*+1 where

*z*≥0,

*η*>0 small enough. From this observation, it is not difficult to extend the result to

*A*(

*t*

_{1})+⋯+

*A*(

*t*

_{4}) instead of just

*A*(

*t*

_{1}). □

### Lemma 4

*Let*
*Z*≥0 *be a positive*, *real*-*valued random variable such that*
\(\mathbb{E}(e^{\lambda Z}) < +\infty\)
*for some*
*λ*>0, *and define*
\(c = \lambda^{-2} \mathbb{E}(e^{\lambda Z} - 1 - \lambda Z)\). *Then for any* 0≤*ε*≤*λ*
*and any real*-*valued random variable*
*V*
*such that*
*V*≤_{st}
*Z*, *we have*
\(\mathbb{E} ( e^{\varepsilon V} ) \leq1 + \varepsilon \mathbb{E}(V) + \varepsilon^{2} c\).

The following result is closely related to a result of Hajek [11].

### Theorem 4

*Let*(

*Y*

_{ k })

*be a discrete*-

*time*,

*continuous state*-

*space Markov chain such that for some function*

*f*≥0,

*there exist*

*K*,

*γ*>0

*such that for any initial state*

*y*

*with*

*f*(

*y*)>

*K*,

*the inequality*\(\mathbb{E}_{y}(f(Y_{1}) - f(Y_{0})) \leq-\gamma\)

*holds*.

*Assume that there exists a random variable*

*Z*

*such that for any initial state*

*y*,

*Z*

*dominates stochastically the random variable*

*f*(

*Y*

_{1})−

*f*(

*Y*

_{0})

*under*ℙ

_{ y }.

*Assume finally that*\(\mathbb {E}(e^{\lambda Z}) < +\infty\)

*for some*

*λ*>0.

*Then there exist*

*η*>0

*and*0≤

*C*<+∞

*such that for any initial state y*,

### Proof

*ε*≤

*λ*,

*f*(

*Y*

_{1})−

*f*(

*Y*

_{0}) under ℙ

_{ y }is stochastically dominated by

*Z*for every

*y*, one gets

*f*(

*Y*

_{1})−

*f*(

*Y*

_{0}) under \(\mathbb{P}_{Y_{n}}\):

*f*(

*Y*

_{ n })>

*K*}, one gets

*η*=(

*ε*/(2

*γ*))∧

*λ*. From the definition of

*ρ*

_{ ε }in (10), one can easily check that 0<

*ρ*

_{ η }<1. Therefore, choosing

*ε*=

*η*gives the result. □

Theorem 4 will be applied to the Markov chain (*X*(*t*
_{4n
})) with a function *f* of the form \(\sigma_{\kappa}\stackrel {\mathrm{def}}{=} \sigma+ \kappa R\) for some *κ*>0 suitably chosen. (*X*(*t*
_{4n
})) is not the most natural choice at first glance, but it appears to be needed because of the complexity of the state space.

*σ*(

*t*

_{1})−

*σ*(

*t*

_{0})≤

*A*(

*t*

_{1})+1 and clearly

*R*(

*t*

_{1})−

*R*(0)=

*A*(

*t*

_{1})−1, so that

*σ*

_{ κ }(

*t*

_{4})−

*σ*

_{ κ }(

*t*

_{0}) is stochastically dominated by some random variable

*Z*with an exponential moment. Therefore, one has to establish a negative drift relation for

*σ*

_{ κ }(

*t*

_{4})−

*σ*

_{ κ }(

*t*

_{0}) in order to apply Theorem 4 to the fragmentation process (

*X*(

*t*

_{4n })). This is the purpose of the following two subsections. The most delicate part is to control the term

*σ*(

*t*

_{4})−

*σ*(

*t*

_{0}), which is the objective of the following section.

### 5.2 Evolution of the number of fragments

Let \(x\in\mathcal{S}\), the initial state of the system, have *r* active channels, and define the total available gap size *h*=1−(*s*
_{1}+⋯+*s*
_{
r
}). Time 0, referring to the initial state *x*, will usually be omitted; e.g., *σ*(0),*F*(0),*G*(0),… will be simplified to *σ*,*F*,*G*,…. The quantity Δ*σ*(*t*
_{
n
}) is defined in (3) as *σ*(*t*
_{
n
})−*σ*(*t*
_{
n−1}).

### Lemma 5

*Fix* 0<*ε*<1 *and* 0<*η*<1/2, *and let*
\(x \in \mathcal{S}\)
*be an initial state such that*
*σ*=*G*+*F*≥2*K*+1 *for some fixed*
*K*≥0.

*Then*

*F*=

*N*

_{0}+

*N*

_{1}+

*N*

_{2}≥

*K*,

*and*

- (1)
*If**r*=1,*then*\(\mathbb{E}_{x}(\Delta\sigma(t_{1})) \leq\xi- K\). - (2)
*If**r*>1*and**N*_{0}+*N*_{1}≥*εK*,*then*$$\mathbb{E}_x\bigl(\Delta\sigma(t_1)\bigr) \leq\xi+ 1 - \frac{\varepsilon K}{r}. $$

*Assume in the remaining cases that*

*r*>1,

*define*

*K*′=

*K*((1−

*ε*)/

*r*−

*ε*)

^{+},

*and let*

*i*

^{∗}∈{1,…,

*r*}

*index a channel*\(L_{i^{*}}\)

*in*

*x*

*with the most type*-2

*fragments*.

- (3)
*If**N*_{0}+*N*_{1}≤*εK**and*\(u > h + s_{i^{*}}\),*then*$$ \mathbb{E}_x\bigl(\Delta\sigma(t_2) \bigr) \leq\xi+ 2 - \frac{K'}{r(r-1)}. $$(12) - (4)
*If**N*_{0}+*N*_{1}≤*εK*, \(u < h + s_{i^{*}}\)*and*\(h + s_{i^{*}} < \eta\alpha\),*then*$$ \mathbb{E}_x\bigl(\Delta\sigma(t_3) \bigr) \leq\xi+ 2 - \frac{(1-\eta)K'}{r^2 (r - 1)}. $$(13) - (5)
*If**N*_{0}+*N*_{1}≤*εK*, \(u < h + s_{i^{*}}\)*and*\(\eta \alpha < h + s_{i^{*}}\),*then there exists a**γ*(*η*)>0*such that*$$ \mathbb{E}_x\bigl(\Delta\sigma(t_4) \bigr) \leq\xi+ 2 - \frac{\gamma(\eta) K'}{r^5}. $$(14)

*It follows that there exists a*\(\overline{\xi}> 0\)

*and a function*

*ψ*(

*r*)>0

*such that for any*

*x*

*with*

*σ*≥2

*K*+1,

### Proof

*G*≤

*F*+1, so 2

*K*+1≤

*σ*=

*F*+

*G*≤2

*F*+1, and hence

*F*≥

*K*as claimed. In what follows, we use repeatedly the two following simple facts:

– *First case*: *r*=1. In this case, right after the only channel initially present leaves, there is no channel allocated bandwidth, and therefore, *σ*(*t*
_{1})=*A*(*t*
_{1}). Note that *r*=1 is only possible when *α*>1/2, and in this case the possibility for a channel to be alone is crucial in the proof of the Harris recurrence stated in Theorem 3.

*Second case*:

*r*>1,

*N*

_{0}+

*N*

_{1}≥

*εK*. Under these assumptions, the inequality follows from (4):

*j*fragments in any channel

*i*

^{∗}which has the most type-2 fragments. If

*N*

_{0}+

*N*

_{1}≤

*εK*, then since

*F*≥

*K*, necessarily

*N*

_{2}≥(1−

*ε*)

*K*and \(N^{*}_{2} \geq (1-\varepsilon)K/r\). Define the event \(D^{*} = \{ \text{channel } L_{i^{*}} \text{ leaves at } t_{1} \}\) and recall that

*G*

^{−}denotes the number of gaps right after \(L_{i^{*}}\) leaves but before new admissions, if any, are made. It follows from (5) that

*G*

^{−}≥

*K*′ in the event

*D*

^{∗}, since

*r*>1, that

*N*

_{0}+

*N*

_{1}≤

*εK*, and that the channel \(L_{i^{*}}\) leaves at

*t*

_{1}.

*Third case*: \(u > h + s_{i^{*}}\). Under this condition,

*A*(

*t*

_{1})=0, since when \(L_{i^{*}}\) leaves it does not provide enough additional bandwidth for

*U*. In particular,

*R*(

*t*

_{1})=

*r*−1 and

*G*(

*t*

_{1})=

*G*

^{−}≥

*K*′, and so

*Fourth case*: \(u < h + s_{i^{*}} < \eta\alpha\). In this case

*U*is admitted at

*t*

_{1}. Thus it makes sense to define the event

*E*

_{4},

*U*is admitted at

*t*

_{1}and leaves at

*t*

_{2}, while

*U*

_{1}stays blocked at

*t*

_{1}and

*t*

_{2}, so that

*G*(

*t*

_{2})=

*G*

^{−}≥

*K*′ and

*R*(

*t*

_{2})=

*r*−1. Hence as in the second case,

_{ x }(

*E*

_{4})=(1−

*η*)/

*r*

^{2}. Thus (13) holds.

*Fifth case*: \(u < h + s_{i^{*}}\) and \(\eta \alpha< h + s_{i^{*}}\). Again,

*U*is admitted at

*t*

_{1}. Letting

*U*

_{ i }denote the sizes of the requests behind

*U*, define the event

*τ*<+∞ almost surely. Moreover, one has in \(E_{5}'\)

*t*

_{2}, exactly

*τ*new requests

*U*

_{1},…,

*U*

_{ τ }have been admitted, and

*U*

_{ τ+1}is blocked. Moreover, for any

*i*∈{1,…,

*τ*}, one has

*h*

^{∗}+

*U*

_{ i }<2

*ηα*<

*U*

_{ τ+1}, so that if one of the

*τ*channels allocated to the (

*U*

_{ i }) leaves,

*U*

_{ τ+1}remains blocked.

*G*

^{−}≥

*K*′ gaps; in the remainder of the analysis, we call an

*initial gap*a gap present right after \(L_{i^{*}}\) left. After \(L_{i^{*}}\) left,

*U*and

*A*(

*t*

_{1})−1 new requests were admitted, and then

*U*left and

*A*(

*t*

_{2}) new requests were admitted at

*t*

_{2}. Thus, at

*t*

_{2}, each initial gap is in either of two states: either it is completely filled, or it is still a gap, i.e., it has not been filled completely. Let

*k*be the number of initial gaps completely filled at

*t*

_{2}, and let

*k*′=

*G*

^{−}−

*k*: then

*k*+

*k*′=

*G*

^{−}≥

*K*′. In each initial gap completely covered at

*t*

_{2}, there is at least one type-2 fragment of one of the

*τ*new channels. Therefore,

*N*

_{1,2}+

*N*

_{2,2}+⋯+

*N*

_{ τ,2}≥

*k*with

*N*

_{ i,2}the number of type-2 fragments of the channel corresponding to

*U*. In particular there is a channel \(L_{j^{*}}\),

*j*

^{∗}∈{1,…,

*τ*} with at least the average

*k*/

*τ*of type-2 fragments: \(N_{j^{*}, 2} \geq k / \tau\). Define finally the event \(E_{5} = E_{5}' \cap \{ L_{j^{*}} \text{ leaves at } t_{3} \}\). Since \(h^{*} + U_{j^{*}} < U_{\tau+ 1}\), then

*U*

_{ τ+1}remains blocked at

*t*

_{3}when

*E*

_{5}occurs, and therefore (note that when

*j*

^{∗}leaves, some gaps may merge, but not two initial gaps),

*t*

_{3},

*R*(

*t*

_{3})=

*r*+

*τ*−2 in

*E*

_{5}. The same kind of reasoning as before then leads to

*f*(

*η*,⋅) defined for

*y*>0 by

*τ*(

*y*)=inf{

*n*≥1:

*U*

_{1}+⋯+

*U*

_{ n }≥

*y*} and

*γ*(

*η*)=inf

_{0<y<1}

*f*(

*η*,

*y*)>0, which then gives the result.

*i*≥0, to arrive at 4 separate bounds on \(\mathbb{E}_{x}(\sigma(t_{4})-\sigma)\). For example, using the former bound for the first two terms and the last term of \(\mathbb{E}_{x}(\sigma(t_{4})-\sigma) = \sum_{1 \leq i \leq4} \mathbb {E}_{x} \Delta\sigma(t_{i})\) and then the bound in (13) for the third term, we find that one of the four bounds, which applies when

*x*satisfies the inequalities of the fourth case, is

*η*=1/4 and

*ε*=1/

*r*

^{2}, one obtains (15) after setting \(\overline{\xi} = 4 \xi+5\) and

*φ*(

*r*)=1−2

*r*

^{−2}. This concludes the proof. □

The bound (15) gives a negative drift for *σ* when the term *Kψ*(*R*(0)) is large enough. But *ψ*(*r*) vanishes when *r* goes to infinity, and so this bound cannot yield a drift uniformly negative, the problem occurring when *R*(0) is large. For this reason *σ* is not a Lyapunov function but the simple modification *σ*
_{
κ
}=*σ*+*κR* introduced earlier is. The purpose of the additional term *κR* is precisely to give a negative drift when *R*(0) is large.

### 5.3 Construction of a Lyapunov function

*R*(

*t*

_{ k }) in the number of channels at a departure is exactly equal to

*A*(

*t*

_{ k })−1, one readily gets that

*σ*

_{ κ }=

*σ*+

*κR*. In particular, if \(x \in \mathcal{S}\) is such that

*σ*≥2

*K*+1 and

*r*=

*R*(0)≤

*K*

_{1}for some

*K*

_{1}≥0, then (from now on, we assume without loss of generality that the function

*ψ*given by (15) in Lemma 5 is decreasing)

*r*≥

*K*

_{1},

*r*large. In this case, the negative drift comes from the fact that, except perhaps at

*t*

_{1}, with high probability there is no admission at a departure, since the channel that leaves is small with high probability.

### Lemma 6

*There exist*
*K*
_{1},*γ*
_{1}>0 *such that if*
\(x \in\mathcal{S}\)
*is such that*
*r*=*R*(0)≥*K*
_{1}, *then*
\(\mathbb{E}_{x}(R(t_{4}) - r) \leq-\gamma_{1}\).

### Sketch of Proof

The proof of this inequality is easier than the proof of Lemma 5, we only give a sketch of it. From *s*
_{1}+⋯+*s*
_{
r
}=1−*h*≤1 one gets #{*i*:*s*
_{
i
}≥*γ*}≤1/*γ*, and therefore, \(\mathbb{P}_{x}(s_{i_{1}} \geq 1/\sqrt{r}) \leq1/\sqrt{r}\) with \(L_{i_{1}}\), *i*
_{1}∈{1,…,*r*}, the channel that leaves at *t*
_{1}. Thus, when *r* is large, with high probability a small channel leaves.

If *h*−*u* is away from *α*, then the event \(\{u_{1} > h - u + s_{i_{1}} + \cdots+ s_{i_{4}} \}\) (with *i*
_{
k
} defined similarly) has high probability, and in this event *A*(*t*
_{1})+⋯+*A*(*t*
_{4})≤1. If in contrast *h*−*u* is large, then with high probability *U*
_{1} is admitted and with high probability *h*−*u*−*U*
_{1} is away from *α*; hence we can do the same again, and get that, with high probability, *A*(*t*
_{1})+⋯+*A*(*t*
_{4})≤2. □

Gathering Lemma 6 and the bound (15) we can now prove that for *κ* suitably chosen, the function *σ*
_{
κ
}=*σ*+*κR* is indeed a Lyapunov function.

### Proposition 1

(Lyapunov function inequality)

*There exist*
*κ*
*and*
*K*>0 *such that if*
\(x \in\mathcal{S}\)
*is such that*
*σ*
_{
κ
}≥*K*, *then*
\(\mathbb{E}_{x}(\sigma_{\kappa}(t_{4}) - \sigma_{\kappa}) \leq- 1\).

### Proof

*K*

_{1}and

*γ*

_{1}be given by Lemma 6, and take

*κ*and

*K*as follows:

*σ*

_{ κ }≥

*K*. If

*r*=

*R*(0)≥

*K*

_{1}, then

*r*≤

*K*

_{1}, and since

*σ*

_{ κ }≥

*K*, this necessarily gives \(\sigma\geq K - \kappa K_{1} = 2\hat{K}+1\) with \(\hat{K} = (K - \kappa K_{1} - 1) / 2\). Thus,

### 5.4 Proof of Theorem 2

*X*(

*t*

_{4n }),

*n*≥0), and the function

*σ*

_{ κ }show that for some

*η*>0 and some constant 0≤

*C*<+∞,

*i*≥0

### 5.5 Proof of Theorem 3

In the following discussion, no conceptual argument is missing, only some formalism needed to handle the continuous state space \(\mathcal{S}\). These details are routine and left to the interested reader. In the analysis below, requests are said to be *big* if their size exceeds 1/2.

We argue that (*X*(*t*)) visits infinitely often a state in which there are no fragmented channels, and such that all size distributions remain the same at all visits. This is enough to show Harris recurrence; see for instance Asmussen [2]. For this purpose, it is convenient to pick a simple regeneration set \(E \subset\mathcal{S}\) in which (i) the spectrum is being used by a big request, alone and with an unfragmented channel of the form (0,*b*), and (ii) the request *U* waiting at the head of the queue is also big. Each of these has the conditional request-size distribution given that its size is larger than 1/2, i.e., the uniform distribution on (1/2,*α*), see [13].

To verify that *E* is visited infinitely often, consider the process (*R*(*t*),*U*(*t*)) with *R*(*t*) the number of requests allocated a channel at time *t* and *U*(*t*) the size of the request at the head of the queue; the process (*R*(*t*),*U*(*t*)) is simply the process (*X*(*t*)) when the data on fragmentation is ignored. This process is positive Harris recurrent, as shown in Kipnis and Robert [13]. In particular it visits infinitely often states with *R*(*t*)=1 and *U*(*t*)>1/2; one can add *U*
_{1}(*t*)>1/2 as well (i.e., the first request in line behind the head of the queue request is also big), since this happens with a geometric probability. Then when the only channel leaves, the process (*X*(*t*)) enters *E*, since there is exactly one channel, it is big, it is necessarily unfragmented and of the form (0,*b*), and a big request is waiting at the head of the queue. Moreover, this argument shows that the time between visits to *E* is integrable, which in turn establishes positive Harris recurrence. This completes the proof.

## 6 Algorithms

Although the focus so far has been on measures of fragmentation as a function of *α*, algorithmic issues are also of obvious interest. For example, more uniform patterns of gaps might be an advantage. The linear scan LS discussed in the previous sections, tends to push the gaps towards the end of the spectrum, particularly when the spectrum is viewed at random times in steady state. Interestingly, our experiments have shown that, for all *α*<1/3, the starting position of the first gap in the spectrum remains very close to 0.64.

To uniformize gap locations, an alternative gap scan resembles the circular-scan sequences of dynamic storage allocation [14]. In our case, circular scan (CS) uses a gap list, in which the successor to the last gap in [0,1] is the first gap in [0,1]. The scan is still linear like LS, but the starting gap of the scan moves as follows: if the last fragment of a channel is placed in gap *g*, then the residual gap of *g* is the first gap scanned in constructing the next channel. Clearly, although CS will tend to uniformize gap sizes as a function of position, boundary effects will persist so long as the spectrum itself is not circular, i.e., gaps and fragments are not allowed to overlap the end of the spectrum, a restriction that would likely be dictated in practice.

*α*expected to be of interest in applications, the effects of a circular scan on gap-search times are only within a few percent relative to LS, as can be seen in Fig. 7. The figure also shows the average number of fragments per channel for LFS. This algorithm is designed to speed up the process of finding a set of gaps sufficient to create a new channel. It selects available gaps in a decreasing order of their sizes and allocates them to a request, thereby greedily minimizing the number of gaps needed to fulfill a request. The extra mechanism needed for such a search will of course tend to reduce overall performance gains. The results in Fig. 7 for LFS show a surprisingly large improvement in the average number of fragments per channel—as can be seen, a reduction by a factor more than 3 is achieved for even moderately small

*α*.

*even when the maximum request size is as much as one fifth of the spectrum size*. This is easily seen in Fig. 9. The convergence rate of LFS to 50 % is intermediate between LS and CS.

## 7 Normal approximations

After the usual scaling (i.e., first centering then normalizing by the standard deviation), the scaled version of the number of channels, *R*, tends in probability to the standard Normal, \({\mathcal{N}}(0,1)\), as *M*→∞, where *M*=⌊1/*α*⌋ (it is convenient to express the asymptotics in this section in terms of *M*). This result follows easily from the corresponding heavy-traffic limits in [4, 5], and the ergodicity of (*R*(*t*)).

*F*of fragments as

*M*→∞ (see for example Fig. 10). This is not surprising, since

*F*is the sum over all requests in system of the numbers

*F*

_{ i }, 1≤

*i*≤

*R*, of fragments allocated to requests. The requests have a mutual dependence, but one whose effect can be expected to weaken for large

*M*. As illustrated in Fig. 7, the mean of

*F*

_{ i }is proportional to

*M*. Our experiment indicate that the standard deviation of

*F*

_{ i }is also approximately proportional to

*M*. Hence, if \(\stackrel{p}{\rightarrow}\) denotes convergence in probability as

*M*→∞, then

*β*≈1.5 and

*θ*≈0.9 formalizes the normal-limit law suggested by our experiments.

Note the two departures from the standard Central Limit Theorem set-up. First, consistent with the linear fragmentation observation, individual request fragmentation scales linearly in *M*, so that the total number of fragments scales as *M*
^{2}. Restating the limit law in terms of the sums of random variables (*F*
_{
i
}/*M*) clearly eliminates this discrepancy. Second, the number of channels (*R*) is random and satisfies the normal-limit law discussed above. Thus, the plausibility of (18) requires an appeal to Central Limit Theorems for random sums (e.g., see [9, p. 258], for an appropriate version). Finally, Fig. 10 gives some idea of the convergence of the fits to the normal density; as can be seen, fits for *α*≤0.1 are indeed close to the simulation data.

*first-admission*pmf in Fig. 12; this is the distribution as seen by the first admission immediately after a departure at just those epochs when there is at least one admission. The third curve is the pmf of the number,

*G*

^{−}, of gaps as seen right after departures, but before determining whether or not the head of the queue fits in the total available bandwidth. The fit to the Normal density is also illustrated in the figure. The proof of a similar limit law for Renyi’s space-filling problem can be found in [6], but extension of known techniques once again faces the difficult challenges posed by our more difficult fragmentation problem.

## 8 Conclusions

The results of this paper prepare the ground for further research on several fronts. Before listing a number of the more important ones, we review what we have learned. Our experiments brought out first an unexpected reappearance of a *50 % rule* relating the expected numbers of gaps and channels in the limit of small request sizes relative to the spectrum size. In our case, we were able to prove the limit law. Also, experimental results described a linear relationship between the inverse of the maximum request size, *α*, and the expected number of fragments into which a request was divided at the time of allocation. Interestingly, the smaller *α* was taken, the greater was the resulting fragmentation of requests.

Our stability results established the beginning of a mathematical foundation of fragmentation processes. Particularly, we showed that for *α*>1/2, the fragmentation process is Harris recurrent. For general *α*, we proved that the total number of fragments is bounded in expected value. We examined alternative algorithms for sequencing through the available gaps and showed that using the largest-first-scan algorithm leads to significantly less fragmentation than using the linear-scan and circular-scan algorithms. Finally, we exhibited experimentally a limiting, small-*α* behavior in which, with appropriate scaling, distributions tend to the normal.

A broad direction for further research is in extending the parameters of our mathematical model. For instance, while Uniform distributions are generally the assumption of choice in fragmentation models, it would be interesting to see what new effects are created by other distributions of request size, e.g., by varying *a* in the generalized uniform distributions on [0,*α*], with densities *x*
^{
a
}/*α*
^{
a+1}. The exponential residence-time assumption is likely to yield simplifications to analysis, but changes in behavior resulting from other distributions are worth investigating. Moreover, instead of a system operating at capacity, in which there is always a request waiting, one could adopt an underlying, fully stochastic model of demand; e.g., a Poisson arrival process, as found in [13].

More realistic, but in all likelihood significantly more difficult models, would relax the independence assumptions. A prime example appropriate for Dynamic Spectrum Access applications would be allowing residence times to depend on fragmentation, the greater the fragmentation of a request, the longer its residence time.

The results regarding the performance of the different algorithms imply that the algorithms’ design should also be considered carefully. Some examples of algorithms that come to mind will aim to better fit the fragments into the available gaps. A more challenging objective would be to develop algorithms that take into account spectrum sensing capabilities during the gap allocation process.

Finally, another broad and very important avenue of research that introduces more realistic models discretizes request sizes and the bandwidth allocation process (as is being done while allocating OFDM subcarriers). As in other models of fragmentation, the continuous limit represented in this paper may conceal important effects, or, conversely, it may introduce effects not present in discrete models. We are actively pursuing this avenue of research.

## Acknowledgements

We would like to thank Charles Bordenave for helpful discussions in relation with Theorem 4. This work was partially supported by NSF grants CNS-0916263, CNS-10-54856, and CIAN NSF ERC under grant EEC-0812072.

### Open Access

This article is distributed under the terms of the Creative Commons Attribution License which permits any use, distribution, and reproduction in any medium, provided the original author(s) and the source are credited.