Splitting Algorithms We have seen that slotted Aloha has maximal - - PowerPoint PPT Presentation

Splitting Algorithms

We have seen that slotted Aloha has maximal throughput 1/e Now we will look at more sophisticated collision resolution techniques which have higher achievable throughput These techniques also maintain stability without a complex estimation procedure like in pseudo-Bayesian slotted Aloha The way they obtain this is by choosing different retransmission probability for different nodes, at each time slot during collision resolution the nodes are subdivided into two sets

Information Networks – p.1/24

Splitting Algorithms

A preliminary explanation as to how this is possible is to consider an algorithm that will make new arrivals wait until an ongoing collision has been resolved Assuming a small attempt rate it is most likely to have

• nly two packets colliding

All other nodes will refrain from transmitting until they have observed that those two backlogged packets have been successfully transmitted Each of the colliding packets could then be retransmitted with probability 1/2 leading to successful retransmission of one of them with probability 1/2 and the other could then be transmitted in next slot

Information Networks – p.2/24

Splitting Algorithms

With probability 1/2 another collision or an idle slot

• ccurs

If so, the two packets would again be retransmitted with probability 1/2 until a successful transmission occurred which would be followed by the transmission of the remaining packet The probability of two slots for retransmitting the packets is 1/2 since this happens if there is no further collision Probability for three slots is 1/4, probability for i slots is

2−(i−1)

Information Networks – p.3/24

Splitting Algorithms

The expected value for number of slots to send these two packets is thus

∞

• i=2

i2−(i−1) = 1 (1 − 1/2)2 − 1 = 3

Thus we get a throughput of 2/3 for the period during which the collision is resolved Various ways to choose whether to transmit or not in successive slots: Random choice (“flip an unbiased coin”) Using arrival time of its collided packet Node identifier (in case of finite number of nodes)

Information Networks – p.4/24

Splitting Algorithms

All alternatives have the property that the set of colliding nodes is split into subsets, one of which is transmitting in the next slot If the collision is not resolved, then a further splitting into subsets is performed We assume slotted channel, Poisson arrivals, collision

• r perfect reception, (0, 1, e) immediate feedback,

retransmission of collisions, and an infinite set of nodes When collision occurs in slot k, all nodes not involved in collision goes into waiting mode, the rest are split into two subsets

Information Networks – p.5/24

Tree Algorithms

First subset transmits in slot k + 1 and if that slot is idle

• r successful, the second subset transmits in slot k + 2

Alternatively, if another collision occurs in slot k + 1 the first subset is split again and the second subset waits for the resolution of that collision We can describe the splitting procedure with a binary tree, we call the root set of nodes involved in the initial collision S, and the sets it is split up into L (left) and R (right), further splitting of L gives the subsets LL and

LR, etc

All nodes in the left set and all its descendants (further splitting) is transmitted before the subsets of the right right branch

Information Networks – p.6/24

Tree Algorithms

From the feedback (0, 1, e) each node can construct the tree and keep track of its own subset in that tree and determine when to retransmit An alternative description is to consider a stack, when collision occurs the set of nodes involved is split into two subsets and these are pushed on the stack, then the subset at head of stack is removed and transmitted (with splitting and pushing on stack if collision occurs) A node with a backlogged packet can keep track of when to retransmit by a counter determining the position of its subset on the stack

Information Networks – p.7/24

Tree Algorithms

When packet is involved in collision the counter is set to

0 or 1 depending on which subset it is placed in

When counter is 0 packet is transmitted If counter is nonzero, it is incremented by 1 for each collision and decremented by 1 for each success or idle A collision resolution period (CRP) is defined to be completed when a success or idle occurs and there are no remaining elements on the stack When a CRP is completed a new CRP is started with the packets that arrived during previous CRP

Information Networks – p.8/24

Tree Algorithms

If a lot of slots are required during a CRP it is likely that a lot of packets arrived during that time, these will collide and continue to collide until the subsets get small enough in the new CRP The solution is that at the end of a CRP the new arrivals will be split into j subsets, where j is chosen so that the expected number of nodes per subset is slightly greater than 1 These j subsets are placed on the stack and then a new CRP begins Each node will keep track of the number of elements on the stack and the number of slots since the end of previous CRP , the nodes involved in the CRP will also keep track of its position on the stack

Information Networks – p.9/24

Tree Algorithms

On the completion of a CRP each node determines the expected number of new arrivals and from that a new number j of subsets, and those with new arrivals waiting will randomly choose one of those j subsets and set their counter to the corresponding stack position The maximal throughput available with this algorithm,

• ptimized over the choice of j as a function of expected

number of new arrivals, is 0.43 packets per slot If a collision is followed by an idle slot, this means that all packets involved in the collision were assigned to the second subset, then tree algorithm would retransmit this subset with a guaranteed collision

Information Networks – p.10/24

Tree Algorithms, improvement 1

An improvement would be to upon detecting an idle slot following a collision splitting this second set into two sets and just retransmit the first one Similarly if an idle occurs again, the second subset is again split before retransmission, and so forth The improvement can be stated in the stack case too, each node much keep an additional binary state that is 1 if, for some i ≥ 1, the last i slots contained a collision followed by i − 1 idle slots, otherwise the state is 0 If feedback is 0 and state is 1, then state stays at 1 and the set on top of stack is split into two that are pushed

• n stack instead of the old head element

Information Networks – p.11/24

Tree Algorithms, improvement 1

The maximal throughput with this improvement is 0.46 packets per slot In practice there is a problem with this improved algorithm, if an idle slot is incorrectly perceived by the receiver as a collision then the algorithm continues splitting indefinitely Thus, in practice, after some number h of idle slots following a collision, the algorithm should be modified to not split any further but instead retransmit the current subset If the feedback is very reliable h can be fairly large,

• therwise h should be small

Information Networks – p.12/24

Tree Algorithms, improvement 2

Consider a collision followed by another collision. Let x be the number of packets in first collision and xL and xR the number of packets in the L and R subsets from the split, thus x = xL + xR Assuming that x is Poisson and that the splitting into L and R is done randomly so that xL and xR are independent (and due to random splitting Poisson) Given the two collisions, we know xL + xR ≥ 2 and

xL ≥ 2 and since the latter implies the former

conditioning on both is the same as conditioning on the latter only

Information Networks – p.13/24

Tree Algorithms, improvement 2

Given the feedback of two collisions we thus get

P(xR = k|xL ≥ 2) = P(xR = k) since xL and xR are

independent On the other hand

P(xL = k|xL ≥ 2) = P(xL = k)/P(xL ≥ 2) if k ≥ 2 (and 0

• therwise)

Thus most packets are probably in first slot, and the small expected number of packets in R makes it reasonable to not devote a slot to R but instead count the packets in this set as waiting new arrivals With this improvement and splitting done on arrival time we get the first-come first-serve (FCFS) splitting algorithm

Information Networks – p.14/24

Variants of the tree algorithm

Tree algorithm requires all nodes to monitor channel feedback and keep track of when each CRP ends If new arrivals instead just join the subset of nodes at head of stack, and only backlogged nodes monitor the feedback, we get an algorithm called unblocked stack algorithm In contrast the tree algorithm is often called blocked stack algorithm, since new arrivals are blocked until the end of current CRP Since new arrivals are added to head of stack, collisions involve a somewhat larger number of packets

• n the average

Information Networks – p.15/24

Variants of the tree algorithm

Because of likelihood of three or more packets in collision higher maximum throughput can be obtained by splitting into three subsets rather than two Maximal throughput for unblocked stack algorithm is

0.40

Information Networks – p.16/24

FCFS Splitting Algorithm

Splitting will be done based on packet arrival times Each subset will consist of all packets that arrived in some time interval, when a collision occurs that interval will be split into two smaller intervals By always transmitting the earlier arriving interval first, the algorithm will always transmit successful packets in the order of their arrival At each slot k the packets to be transmitted are those that arrived in some earlier interval, from T(k) to

T(k) + α(k), this interval is called the allocation interval

for slot k

Information Networks – p.17/24

FCFS Splitting Algorithm

We can think of the packets arriving after T(k) + α(k) as being in a queue and those arriving between T(k) and

T(k) + α(k) as being in service

All nodes keep track of the allocation interval over which service (i.e. transmission) is taking place The algorithm is specified by the set of rules by which nodes calculate T(k) and α(k) for each successive k on basis of the feedback from previous slot These rules are the tree algorithm with the two improvements mentioned, specialized to the case of splitting according to arrival time

Information Networks – p.18/24

FCFS Splitting Algorithm

When a collision occurs, the allocation interval is split into two equal subintervals and the leftmost subinterval

L is the allocation interval in slot k + 1

When idle follows collision the previous rightmost interval R is known to contain two or more packets and is immediately split with RL forming the allocation interval in slot k + 1 When collision follows collision we would like to regard

R as if it had never been part of an allocation interval,

by splitting L into LL forming allocation interval and LR waiting, the algorithm simply forgets about R At end of CRP , instead of splitting into some number of subsets we choose a new allocation interval of some given size α0

Information Networks – p.19/24

FCFS Splitting Algorithm

The second improvement, having a right interval lose its identity whenever the corresponding left interval is split, corresponds to pruning the tree so it never has more that two leaves, or in stack language the stack never remembers more that the top two elements Whenever the allocation corresponds to the left subset

• f a split, there is a corresponding right subset that

might have to be transmitted later Conversely, when allocation corresponds to a right subset there are no more waiting intervals Thus the nodes need only remember the allocation interval and whether it is a right or left interval, by convention the initial interval of a CRP is considered a right interval

Information Networks – p.20/24

FCFS Splitting Algorithm

If feedback = e then T(k) = T(k − 1), α(k) = 1

2α(k − 1),

σ(k) = L

If feedback = 1 and σ(k − 1) = L then

T(k) = T(k − 1) + α(k − 1), α(k) = α(k − 1), σ(k) = R

If feedback = 0 and σ(k − 1) = L then

T(k) = T(k − 1) + α(k − 1), α(k) = 1

2α(k − 1), σ(k) = L

If feedback = 0 or 1 and σ(k − 1) = R then

T(k) = T(k − 1) + α(k − 1), α(k) = min(α0, k − T(k)), σ(k) = R

The size of new allocation interval in this last case is some constant value α0 that can be chosen to either minimize delay for a given arrival rate or to maximize the stable throughput

Information Networks – p.21/24

FCFS Splitting Algorithm

Maximum throughput 0.4871 at λα0 = 1.266

λα0 is the expected number of packets in original

allocation interval; as expected it is somewhat larger than 1 If α0 is chosen to be 2.6 = 1.266/0.4871 then FCFS is stable for λ < 0.4871 Expected delay is very hard to analyze, but upper and lower bound have been developed Splitting into equal size subintervals is slightly nonoptimal, the optimal splitting gives maximum throughput 0.4878. An upper bound to maximum stable throughput using our assumptions is 0.587

Information Networks – p.22/24

FCFS Splitting Algorithm

For any finite set of m nodes we can achieve any throughput up to 1 packet per slot with TDM, but with TDM the expected delay (for a given λ) increases linearly with m whereas FCFS achieve a delay bounded independently of m Much higher throughputs than 0.4878 are achievable if the slotted assumption is abandoned and early feedback is available when the channel is idle or experiencing a collision The FCFS has the same problem as first improvement

• f tree algorithm if feedback from an idle slot is

mistaken as a collision. As before we can solve this by specifying a maximum number of splits when seeing idle on left interval.

Information Networks – p.23/24

FCFS Splitting Algorithm

We also assumed that nodes can measure arrival time

• f packets with infinite precision. In practice, if arrival

times are measured with a finite number of bits, each node will generate extra bits as needed for splitting by a pseudo-random number generator. Also delayed feedback can be handled by a slightly modified FCFS algorithm, if the feedback for slot k arrives between beginning of slot k + j − 1 and slot k + j for some fixed j > 1, then we can run one instance of FCFS for each of the j slots in a time division multiplexing manner, the only exception being that the waiting set is common for all j of the FCFS algorithm. Also for this algorithm maximum stable throughput is

0.4871

Information Networks – p.24/24