Problème : Diagramme des slots d'un réseau

[invitec78c8fde]

Bonjour,

je suis en L2 informatique et j'ai un problème avec un exercice que j'essaie de refaire : je ne comprends pas la correction

http://pairnowel.free.fr/INF2%20R%E9...correction.pdf

c'est l'exercice 2

Ma 1ère incompréhension :
au 1. ils disent "On calcul le nombre de Bits emis durant 1 slot-time, il est de 512 bits soit 64 octets"

Comment ont-ils trouvé ça ?


ma 2ème incompréhension :
à t=6 : collisions entre B, C et D, appel à la fonc
tion BEB.
à t=7 : B émet sa trame car obtient un TBEB = r = 0
----- puis :
à t=13 : collision entre C et D
à t=14 : aucune transmission sur le réseau
à t=15 : collision entre C et D
à t= 16 aucune transmission sur le réseau
à t=17 : D emet sa trame


donc si je comprends bien
quand 2 stations ou plus essayent d'émettre, celle qui émettra est celle qui a la valeur de "Tirage" la plus faible ? (quand B a pu émettre, il avait 1/4 , et quand D à pu émettre ils avaient d'abord 1/4 tout les 2, puis D a eu 1/8 ! on prend le plus faible à chaque fois ?)
mais pourquoi à t = 14 et t=16 on a aucune transmission sur le réseau ?



En vous remerciant de votre aide
-----

[Antoane]

ReBonsoir et bienvenue,

au 1. ils disent "On calcul le nombre de Bits emis durant 1 slot-time, il est de 512 bits soit 64 octets"

Comment ont-ils trouvé ça ?

Le sujet précise (dans le code) que slotTime = 51,2µs et que le débit est de 10 Mbits/s.

****

Si une station a envie d'émettre, elle écoute le canal.
- si le canal est occupé, elle attend qu'il soit libre puis émet.
- si le canal est libre, elle émet.
Si, lorsqu'elle émet, un autre émet en même temps, il y a collision. Chacun des "collisioné" va alors attendre un temps aléatoire avant d'avoir a nouveau envie d'émettre. Note que pendant sa période de back-off, une station n'a pas envie d'émettre.
http://en.wikipedia.org/wiki/Carrier...sion_detection

donc si je comprends bien
quand 2 stations ou plus essayent d'émettre, celle qui émettra est celle qui a la valeur de "Tirage" la plus faible ?
(quand B a pu émettre, il avait 1/4 , et quand D à pu émettre ils avaient d'abord 1/4 tout les 2, puis D a eu 1/8 ! on prend le plus faible à chaque fois ?)

Pas vraiment : chaque station ne connait que son tirage, elle ne sait pas ce que les autres ont tiré.
De plus, le nombre tiré en lui-même n'a pas d'importance, il faut prendre en compte le délai total : r :=delay := int(random*maxBackOff);
car maxBackOff est variable (il est multiplié par 2 à chaque tirage -- dans les limites du raisonnable).

mais pourquoi à t = 14 et t=16 on a aucune transmission sur le réseau ?

A partir de t=8, C et D veulent émettre (ils ont tous les deux eu un delay d'attente de 1, c'est calculé et donné dans le tableau en fin d'exo). Il n'émettent cependant pas car le canal est occupé par B. A t=13, C et D veulent encore émettre et le canal est libre, ils le font donc simultanément. Cela donne une collision. Tous les deux tirent donc un temps de back-off, égal à 1 pour D (=int(4*1/4)) et 1 pour C (=int(4*1/4)). A t=14, C et D sont en back-off, personne n'utilise donc le canal. à t=15, C et D sortent de Back-off, i.e. ils veulent transmettre. Comme le canal est libre, ils transmettent simultanément. Cela donne une collision.
Tous les deux tirent donc (pour la troisième fois) un temps de back-off, égal à 1 pour D (=int(8*1/8)) et 4 pour C (=int(8*1/2)). A t=16, C et D sont en back-off, personne n'utilise donc le canal. à t=17, D sort de Back-off, i.e. il veut donc transmettre. Comme le canal est libre, il transmet. A t=18, C sort de back-off et veut transmettre mais comme le canal est occupé, il doit attendre que D finisse.

[invitec78c8fde]

Le sujet précise (dans le code) que slotTime = 51,2µs et que le débit est de 10 Mbits/s.

ahh ok ! donc pour avoir le nombre de bits émis au total on fait a fait 51,2*10 = 512bits parce qu'on avait 10 Mbits/s c'est ça ?

t'inquiète oui j'ai compris ce qu'est une collision etc ^^

Wow mais attends le truc des nombres aléatoires etc c'est ce que fait le programme en cas de collision ! nous on est pas des programmes donc comment on fait pour choisir la valeur de Random ?

et pour le r delay pareil, ils disent pas non plus comment ils l'ont trouvé ? (vu que dans le programme il provient en partie d'une opération avec random, on fait comment ? on prend pas un nombre au hasard dans notre tête )


d'acc' pour le reste je vais me renseigner un peu sur ce qu'est le backoff/maxbackoff ^^

[Antoane]

Les nombres randoms sont donnés dans le premier tableau (2/3, 1/4, 1/2, 3/4; ...)

La valeur de maxBackOff est calculée par chaque station. La première fois (pour un message à transmettre donné) qu'elle calcule une durée de backoff, elle utilise la valeur 2. La fois suivante (qui n'intervient pas obligatoirement : dans ton exemple elle n'intervient pas pour B), maxBackOff =4. La fois suivante : maxBackOff =8...
C'est dans le code :

CONST
          slotTime = 51,2µs ;
          backOffLimit = 10 ;
 VAR
          r, Delay : integer /*Nombre de slots d’attente avant de retransmettre*/

 Begin
 {
           if attempts = 1  then maxBackOff :=2 ;          /* initialisation : la première fois */
           else {
                    if attempts <= backOffLimit
                               then maxBackOff := maxBackOff*2;          /* les fois suivantes, on multiplie maxBackOff par deux à chaque fois */
                    else maxBackOff := 210;          /* il y a qd même une limite : on ne peut pas dépasser 2^10 */
            }
           r :=delay := int(random*maxBackOff);          /* c'est ici qu'on calcule le delay */
           wait (delay*slotTime);
 }
 End;

Note que l'ensemble :

           if attempts = 1  then maxBackOff :=2 ;          /* initialisation : la première fois */
           else {
                    if attempts <= backOffLimit
                               then maxBackOff := maxBackOff*2;          /* les fois suivantes, on multiplie maxBackOff par deux à chaque fois */
                    else maxBackOff := 210;          /* il y a qd même une limite : on ne peut pas dépasser 2^10 */
            }
           r :=delay := int(random*maxBackOff);          /* c'est ici qu'on calcule le delay */
wait (delay*slotTime);

sert uniquement à générer un delay de durée aléatoire, comprise entre 0 et un certain nombre (égal à la valeur courante de maxBackOff) de fois 51.2µs.

[A voir en vidéo sur Futura]

[invitec78c8fde]

mh d'accord je crois comprendre ce que c'est

EDIT : att j'ai delete mon message j'ai posé une question maisj 'ai trouvé je crois (je vais ré-éditer si j'ai pas compris)

[invitec78c8fde]

YAY J'AI COMPRIS ahah c'est très con en fait d'acc' ! merci beaucoup de ton aide !


(désolé du double post je pouvais plus éditer ^^)