So, as we said, when acknowledgements aren't received, we assume that
collisions occurred, because it's likely that they did, and we have to
re-transmit. So, the way that we deal with it is by
having the stations back off to a later time.
When they back off, they don't want to back off to the exact same point because
you collide with someone, and then you both wait five seconds, and then you
transmit again, then you're going to call out again.
So, they randomize the next transmission and they choose some random time in which
to retransmit in the hope that they're not going to chose the same exact time.
Now, if you have a larger window on which that randomization is chosen, then
clearly there's going to be less of a chance that you chose the same time.
So let's look at a little example here. Take two stations again, A and B.
Which both send data. Then they see that they don't have an
acknowledgement. Okay, then what happens is, once they
don't have an acknowledgement they decide, well, we have to re-transmit.
So they both go through the wait and listen period again.
Which they have to do before they start this back-off period they go through that
wait and listen. Okay, then the backoff starts.
And then they choose a random number between right now and and the current
contention window size. And the contention window gets larger as
we have more interference as we will see in a minute.
But right now, the contention window size is 15.
So they choose at random number between zero and 15 and the contention window
size changes based from what station it is but, so, and again, between zero and
15. And in this case now, A chooses 13,
'okay? So he decides to wait.
13 time slots before we transmit, okay so then here we transmit time slot 13 and B
decides to pick 3 time slots between 0 and 15 and so you can think of this again
as if you have a, a spinning wheel and the wheel that you are spinning now has
15 different sections. So say we cut this up, if that was
possible, into 15 different pieces. And then you're basically going to spin
it and then whichever one you land on you number them 1, 2, 3, 4, and so on.
And then you just choose that random one. And that's what these devices do
internally. And, so this one's choosing three, and
this one's choosing 13. Now, granted that b doesn't take more
than three or more than 10 time slots that transmit, there would be a collision
between these two stations again. Of course, it's possible that they
collide with other stations like CDE, which may also be sharing the same access
point, but still every station goes through the same procedure.
And again, the randomization helps to avoid collision with the same station
again. So you don't want to, you know, keep
colliding with one another. But then, when collisions persist, and
you keep having more and more collisions, then you infer that there's a lot of
congestion happening right now in the network.
And then we have to deal with that. So, the way that we deal with that
congestion is by backing off more and more.
That's by changing that contention window size.
So the possible random numbers of time slots that we're going to choose.
What CSMA mandates is that the exponential backoff be Multiplicative.
Meaning by, and in this case, multiplicative could be by any factor but
by factors of 2. And factor of 2 means that it's binary
exponential backoff. So we could have multiplicative backoff
in general, which would be multiplicative exponential backoff would mean that we're
multiplying by any number. Like it could be 3 or 4.
Or whatever you want, but the, the standard is to do it with binary because
everything computers, logics likes do to a things in terms of [UNKNOWN],
multiplying and increasing by factors of 2 each time.
Doubling, that's just a standard. So, then first you would.
Go by two, then four, then eight, then sixteen times the original and so on.
And just increasing. Keep multiplying it by a factor of two.
And keep doubling the current window size.
So, you're probably wondering why do we do it with multiplicative backoff.
And the reason is really just that from looking at networks and seeing what
works, people thought that linerar backoff, like if we just increased by two
and then we increased by one more, then one more, then one more, so.
From 2 to then to 3 to 4 to 5. They thought that, that really it just
wasn't aggressive enough. So, it's, it's not aggressive enough.
So then when we see congestion we want to back off as soon as possible and say
woah, woah, woah, woah, what's going on here.
Let's try to alleviate this congestion from the network.
So, rather than increasing starting 2, then going to 3, 4, 5, we start at 2,
then go to 4, then 8, then 16. And so on, and so here's an example.
So suppose this is the previous frame, right, and after your initial attempt you
go through a wait and listen period because you had a collision, right, and
you randomly pick one and the current window size is seven right now, okay?
So, you pick a random number between zero and seven, right?
So suppose then you choose three. Then if you have a collision again, then
you do a retry, so then now you're going to just retry.
And then once you have the collision, your window size goes up to 15, okay?
And now you're probably saying well, 15 isn't a factor of two, seven isn't a
factor of two. So the window size is eight, or two to
the three, which is just 2 times 2, times 2.
Which is equal to eight, and then we subtract one just simply because we want
to include zero. So rather than going from 1 to 8, we go
from 0 to 7. It's just the way we count, because zero
with indicate that right after the wait and listen period they're going to
immediately start transmitting, which is also a possibility, right?
So then, in this case we start, we have a window size then of 16 and then we
subtract 1 to get 15. And this case then 16 times 2 is 32.
So we have 32 minus 1 which is equal of 31.
And then we go from 0 to 31 here. And this is from 0 to 15 and so on.
And the next time if there was a collision again, we would go to 64.
It's 32 times 2 is 64 minus 1 is 63. So we would choose a random number
between 0 and 63, and that would determine when we would transmit, again,
next. So again, we subtract 1 from the window
size. So it's the size minus 1 is where we go
up to. And we choose a random number between
that size minus 1. So in this first retry, then Say we
randomly pick one, it's 10. Then we have another collision for some
reason, then we randomly pick one and we get 7.
And then so on and so forth until we finally get our data through.
So we can draw an analogy here to conversation again.
And it's again, we just keep doing analogies because they just make sense
and they can allow us to relate to these. And so, in a, in a typical conversation
with someone, now if you and someone else speak at the same time then you might
wait a second and then you each try to speak again and then you interfere again.
You've probably had that before where then you're just exchanging a bunch of a
bunch of sounds of your voices and they're not really getting anywhere
because each of you doesn't want to keep interfering, but then eventually you
might wait a longer and longer time like, [NOISE] and then eventually someone will
say. Alright, well I'm just going to start
talking right now, and then there won't be any more interference between the two
of you, because they could get their words out and then you would wait until
they were done.
