PROTOCOALE

BAZATE PE CONFIRMARE ŞI RETRANSMISIE

PENTRU
NIVELUL DE CONTROL AL LEGĂTURII DE DATE

La baza protocoalelor pentru nivelul (de control al) legăturii de date (DLC) stă
principiul cererii de repetare automată [Automatic Repeat reQuest
(ARQ)], care constă în detectarea, de către receptor (destinatar), a cadrelor ce conţin
erori şi cererea ca, în acest caz, emiţătorul (sursa) să retransmită cadrele eronate.
Înainte de a prezenta aceste protocoale, vom face unele ipoteze cu privire la
modelul comunicaţiei:
1. Nivelul fizic, nivelul (de control al) legăturii de date şi nivelul de reţea
sunt considerate procese independente ce comunică trecându-şi unul altuia
mesaje. În unele cazuri, procesele din nivelul fizic şi cele din nivelul legăturii de
date vor fi rulate de un microprocesor din interiorul unui chip special de I/O, iar
procesele din nivelul de reţea vor fi rulate de unitatea centrală, dar sunt posibile şi
alte implementări (de exemplu: toate trei procesele într-un singur chip I/O;
procesele din nivelurile fizic şi legăturii de date ca proceduri apelate de procesele
din nivelul de reţea, etc.). În orice caz, tratarea celor trei niveluri ca procese separate
face abordarea problemelor mai clară din punct de vedere conceptual şi, în plus,
serveşte la evidenţierea independenţei nivelurilor arhitecturii reţelei.
2. O ipoteză esenţială este aceea că maşina (calculatorul) A vrea să
transmită un şir lung de date către maşina B, utilizând un serviciu fiabil, bazat pe
conexiune (mai târziu se va considera şi cazul când B vrea să transmită şi el,
simultan, către A). Se presupune că A posedă o rezervă infinită de date de
transmis, deci că nu se află nici o dată în situaţia de a aştepta pregătirea datelor
pentru transmisie; când DLC de la A aşteaptă date, nivelul său de reţea este
întotdeauna pregătit să i le furnizeze (şi această restricţie va fi înlăturată ulterior).
3. Din punct de vedere al DLC, pachetul ce vine de la nivelul de reţea,
prin interfaţa dintre ele, constituie date pure, fiecare bit al acestuia trebuind să fie
livrat nivelului de reţea al destinatarului. Faptul că nivelul de reţea al destinatarului
poate interpreta o parte a pachetului drept antet nu îl interesează pe DLC. Pachetul
de la nivelul de reţea, ajuns la DLC, este încapsulat cu un antet şi un marcaj
terminal (ce conţin informaţiile de control) şi apoi transmis la DLC al partenerului
(prin intermediul nivelului fizic şi al liniei). Dacă blocul (cadrul) astfel obţinut
ajunge fără erori la destinatar, DLC de aici verifică şi utilizează informaţiile de
control (din antet) şi, dacă totul este în ordine, datele din cadru (adică pachetul) sunt
trecute nivelului de reţea. În nici un caz nu se pasează nivelului de reţea antetul
cadrului (sau vreo parte din el). În acest fel, protocoalele nivelurilor de reţea şi
de legătură de date devin complet separate. Aceasta permite, pe de o parte,
independenţa nivelului de reţea faţă de soluţia de implementare a nivelului DLC
(schimbarea unuia din ele nu implică schimbarea celuilalt, atâta timp cât schimbarea
nu încalcă regulile de colaborare stabilite) şi, pe de altă parte, simplificarea
substanţială a proiectării
(soft-ului) protocoalelor şi evoluţia lor independentă (cu condiţia asigurării unei
interfeţe rigide între aceste două niveluri).

1
 4. Se admite că există o bibliotecă de proceduri de simulare a
protocoalelor DLC, precum pentru trecerea biţilor unui cadru de la nivelul
legăturii de date la nivelul fizic al emiţătorului - să o numim aici to_
physical_layer - ca şi pentru preluarea de către nivelul legăturii de date a biţilor
cadrului recepţionat de la nivelul fizic - să-i zicem from_ physical_layer. Hard-ul
de la emiţător calculează şi ataşează suma de control, astfel încât soft-ul DLC nu
se ocupă de această problemă. Când un cadru ajunge la receptor, hard-ul acestuia din
urmă verifică suma de control. Dacă aceasta este incorectă (ceea ce înseamnă
existenţa a cel puţin unei erori de transmisie), o procedură de aşteptare - să o numim
aici wait_for_event(&event) - a receptorului returnează valoarea unei variabile -
event - care indică apariţia unui eveniment, aici: suma de control eronată pentru
cadrul recepţionat - să admitem event = cksum_err. La detectarea unor erori în
cadru, se cere retransmisia respectivului cadru. Dacă blocul sosit este fără alterări,
DLC este de asemenea informat - event = frame_arrival -, astfel încât îl poate
prelua pentru inspectare - utilizând procedura from_ physical_layer. Există de
asemenea procedurile from_network_layer - pentru preluarea pachetului de la
nivelul de reţea al emiţătorului - şi to_network_layer - pentru pasarea pachetului
către nivelul de reţea al receptorului.
5. În realitate, DLC nu stă pur şi simplu să aştepte într-o buclă a
procedurii wait până ce apare un eveniment (aşa cum am sugerat), ci va primi o
întrerupere care-l va opri din activitatea curentă pentru a se ocupa de cadrul sosit.
Totuşi, pentru izolarea subproblemei care face obiectul acestui paragraf, vom ignora
detaliile privind activităţile paralele din DLC şi vom presupune că el este dedicat
permanent asigurării canalului virtual de transmisie.
6. Dată fiind posibilitatea retransmisiei, antetul şi marcajul terminal
asociate unui anumit pachet pot fi aceleaşi sau nu. Vom presupune că DLC de la
receptor recunoaşte începutul şi sfârşitul fiecărui cadru, putând deci aplica
corect CRC (sau altă tehnică) pentru detectarea erorilor.
7. Vom presupune de asemenea (presupunere nu tocmai realistă) că toate
cadrele cu erori pot fi detectate la recepţie. În cele ce urmează vom numi cadrele
fără erori de transmisie cadre fără erori [error-free frame] iar pe cele cu erori
de transmisie - cadre eronate [error frame]. Reformulând ipoteza, vom zice că
receptorul poate distinge întotdeauna cadrele eronate de cele fără erori.
8. Se va presupune că fiecare cadru transmis este întârziat cu un timp
arbitrar şi variabil până să ajungă la receptor, iar unele cadre se pot “pierde”,
neajungând nici o dată la destinaţie. Dar cadrele care ajung la destinaţie, vor
ajunge în aceeaşi ordine ca la transmisie - cu sau fără erori.
Fig. 1 exemplifică aceste situaţii pe un model de transmisie a cadrelor între
două maşini (calculatoare). Dreptunghiurile de la maşina A indică, prin lungimea lor,
durata de emisie a fiecărui cadru. Săgeţile indică duratele de propagare ale cadrelor
până la maşina B iar vârfurile săgeţilor indică momentul în care un cadru a fost
recepţionat complet (când se poate calcula CRC şi cadrul este acceptat sau nu).

2
 1 2 3 4 5 C a d r e
A t r a n s m i s e
t d i n A
( e r o a r e d e
t r a n s m i s i e )
( c a d r u M o m e n t e l e
p i e r d u t ) s o s i r i i c o m
B a c a d r e l o r
î n B

F i g . 1

Doi indicatori de performanţă interesează în mod deosebit la algoritmii

protocoalelor de retransmisie:
a) corectitudinea, care semnifică livrarea fiecărui pachet, o singură dată şi
fără erori, de la DLC receptor la nivelul de reţea aferent;
b) eficienţa, care indică ce procent din capacitatea de transmisie a liniei se
pierde prin aşteptări şi transmisii inutile.
Se vor prezenta în continuare câteva clase de protocoale ARQ, dovedind
că ele sunt corecte şi analizând efectul pe care îl au asupra eficienţei diferiţi parametri
din respectivele clase de protocoale.
Pentru simularea acestor protocoale ARQ (în limbajul de programare C),
vom stabili o serie de declaraţii comune (ce pot fi depuse într-un fişier antet
protocol.h şi incluse în fişierele diverselor protocoale utilizând facilitatea # include)
privind structurile de date şi procedurile utilizate.
Se definesc cinci structuri de date: boolean, packet, frame, frame_kind
şi seq_nr. O variabilă de tip boolean este o variabilă logică având valorile true
(adevărat) şi false (fals). Un packet (pachet) reprezintă unitatea de informaţie
vehiculată fizic între nivelul de reţea şi nivelul legăturii de date dintr-o aceeaşi
maşină şi respectiv vehiculată virtual între nivelurile de reţea de pe două maşini.
Simulările ce urmează vor considera pachete de lungime constantă MAX_PKT (dar
o simulare mai realistă ar trebui să considere pachete de lungime variabilă). Un
frame (cadru/bloc) este unitatea de informaţie vehiculată virtual între nivelurile
legăturii de date din două maşini. El are o structură formată din patru câmpuri:
kind, seq, ack şi info. Primele trei câmpuri conţin informaţii de control şi
formează aşa-numitul antet [header] al cadrului: câmpul kind (fel) indică dacă
respectivul cadru conţine sau nu date informaţionale; câmpurile seq şi ack
servesc respectiv pentru numărul de ordine (al pachetului conţinut de cadru) şi un
mesaj de confirmare (a recepţiei corecte a cadrului); câmpul info al unui cadru cu
date conţine un pachet de transmis, iar pentru un cadru de control (fără date) el este
gol (o implementare mai realistă ar utiliza in câmp info de lungime variabilă, având
o lungime nulă pentru cadrele de control. Variabila seq_nr este un număr întreg
servind la numerotarea pachetelor şi este cuprins între 0 şi MAX_SEQ inclusiv,
această ultimă valoare fiind o constantă stabilită în cadrul protocolului; adesea este
necesar ca acest număr să avaseze circular (după MAX_SEQ să urmeze 0), fapt
implementat prin macro-instrucţiunea inc.

3
/* Structuri de date şi proceduri utilizate în protocoalele simulate */
#define MAX_PKT 1024 /* determină dimensiunea în octeţi a pachetului */
typedef enum {false, true} boolean; /* tip boolean */
typedef unsigned int seq_nr; /* număr de ordine al pachetului sau de ack */
typedef struct {unsigned char data[MAX_PKT];} packet; /* definiţia pachetului */
typedef enum {data, ack, nak} frame_kind; /* definiţia tipurilor de cadre */
typedef struct { /* structura cadrelor de la nivelul legăturii de date */
frame_kind kind; /* felul cadrului */
seq_nr seq; /* numărul de ordine al pachetului din cadru */
seq_nr ack; /* numărul de ordine al pachetului confirmat */
packet info; /* pachetul din cadru */
} frame;
/* Aşteaptă producerea unui eveniment; întoarce tipul acestuia în variabila event */
void wait_for_event (event_type *event);
/* Preia un pachet de la nivelul de reţea pentru a-l transmite */
void from_network_layer(packet *p);
/* Livrează nivelului de reţea destinatar pachetul din cadrul recepţionat */
void to_network_layer(packet *p);
/* Preia biţii cadrului sosiţi de la nivelul fizic şi îi copiază în r */
void from_physical_layer(frame *r);
/* Livrează biţii cadrului către nivelul fizic pentru transmisie */
void to_physical_layer(frame *s);
/* Porneşte ceasul şi activează evenimentul timeout (sfârşit pauză de aşteptare) */
void start_timer(seq_nr k);
/* Opreşte ceasul şi dezactivează evenimentul timeout */
void stop_timer(seq_nr k);
/* Porneşte un ceas auxiliar şi activează evenimentul ack_timeout (confirmare sfârşit pauză de
aşteptare) */
void start_ack_timeout(void);
/* Opreşte ceasul auxiliar şi dezactivează evenimentul ack_timeout */
void stop_ack_timeout(void);
/* Permite nivelului de reţea emiţător să provoace evenimentul network_layer_ready (nivelul de
reţea gata) */
void enable_network_layer (void);
/* Interzice nivelului de reţea emiţător să provoace evenimentul network_layer_ready */
void enable_network_layer (void);
/* Macroinstrucţiunea inc este expandată in-line: îl incrementează circular pe k */
#define inc(k) if (MAX_SEQ) k = k + 1; else k = 0

Procedurile de mai sus sunt rutine de bibliotecă ale căror detalii depind de
implementare şi al căror mod de lucru intern nu ne interesează aici. Procedura
wait_for_event stă într-o buclă, aşteptând să se întâmple un eveniment - după cum
am menţionat anterior. Procedurile to_network_layer şi from_network_layer,
to_physical_layer şi from_physical_layer au fost şi ele menţionate. Pentru cazul
pierderii unor cadre pe canalul fizic, nivelul legăturii de date va trebui să pornească un
contor de timp/ceas intern de fiecare dată când trimite un cadru. Dacă nu se primeşte

4
confirmare de recepţie până la expirarea unei pauze de aşteptare [timeout]
predefinite, nivelul legăturii de date va primi un semnal de întrerupere. În protocoalele
simulate mai departe, aceasta se asigură prin procedura wait_for_event care
întoarce event = timeout. Procedurile start_timer şi stop_timer servesc la
pornirea şi respectiv oprirea contorului (ceasului) de timp. Procedurile
start_ack_timer şi stop_ack_timer sunt folosite pentru a controla un contor
auxiliar de timp, utilizat pentru generarea confirmării recepţiei pachetelor în anumite
condiţii. Procedurile enable_network_layer sunt utilizate în protocoalele mai
evoluate, în care nivelul legăturii de date poate preveni “inundarea” sa cu pachete de
către nivelul de reţea, dezactivând acest din urmă nivel; când nivelul de reţea este
activat - fapt indicat de event = network_layer_ready -, i se permite să întrerupă
pentru a transmite un pachet.

1 Protocol simplex fără restricţii

Pentru a ne familiariza cu conceptele protocoalelor de la nivelul DLC, să

considerăm cel mai simplu astfel de protocol (un protocol utopic) ce presupune că:
- datele sunt transmise numai într-un singur sens (simplex)
- nivelurile de reţea de la emisie şi de la recepţie sunt întotdeauna activate
- durata de prelucrare este neglijabilă
- spaţiul din registrul tampon (buffer) este nelimitat
- canalul fizic nu provoacă nici alterări, nici pierderi ale cadrelor.
Protocolul conţine două proceduri distincte: emisia şi recepţia. Emiţătorul
rulează în nivelul DLC al maşinii sursă, iar receptorul în nivelul DLC al maşinii
destinatar. Nu se utilizează numere de ordine pentru pachete şi nici mesaje de
confirmare, astfel încât nu este nevoie de MAX_SEQ. Singurul tip de eveniment
posibil este sosirea unui cadru corect (event = frame_arrival).
Emi\`torul se află într-o buclă infinită, “pompând” datele în linie cu viteza
maximă posibilă. Corpul buclei constă din trei acţiuni: preluarea unui pachet de la
nivelul de reţea (care e mereu gata de transmisie), construirea unui cadru pentru a fi
transmis (utilizând variabila s) şi transmiterea cadrului (prin intermediul nivelului
fizic). În acest simulator de protocol se utilizează numai câmpul info al cadrului,
întrucât nu există erori de transmisie şi nici reglarea traficului în reţea (care să aibă
nevoie de câmpurile de control).
Receptorul este, de asemenea, foarte simplu. Timpul lui de prelucrare se
presupune a fi neglijabil (el e capabil să prelucreze cu viteză infinită tot ce primeşte
din nivelul fizic. Iniţial, el aşteaptă să se întâmple ceva (singura posibilitate fiind
sosirea unui cadru corect). În cele din urmă, cadrul soseşte şi procedura
wait_for_event se încheie, returnând event = frame_arrival (care, oricum, este
ignorat). Apelul procedurii from_physical_layer elimină cadrul nou sosit din
buffer şi îl pune în variabila r. În final, conţinutul câmpului info este trecut
nivelului de reţea (drept pachet) şi nivelul DLC revine în bucla de aşteptare pentru
următorul cadru - autosuspendându-se efectiv până la sosirea unui nou cadru.
Iată acest protocol:
/* Protocol simplex fără restricţii */
typedef enum {frame_arrival} event_type;
#include “protocol.h”

5
void sender1(void)
{
frame s; /* registru tampon (buffer) pentru cadrul de transmis */
packet buffer; /* buffer pentru pachetul de transmis */
while (true) { /* la nesfârşit */
from_network_layer(&buffer); /* preia un pachet de transmis */
s.info = buffer; /* îl copiază în buffer pentru transmisie */
to_physical_layer(&s); /* îl trimite nivelului fizic */
}
}
void receiver1(void)
{
frame r; /* buffer pentru cadrul de recepţionat */
event_type event; /* realizat de rutina wait, dar neutilizat aici */
while (true) {
wait_for_event(&event); /* singurul eveniment posibil este sosirea unui cadru */
from_physical_layer(&r); /* preia cadrul sosit */
to_network_layer(&r.info); /* predă pachetul nivelului de reţea */
}
}

2 Protocol simplex de tip pas-cu-pas

Vom renunţa acum la cea mai nerealistă restricţie impusă protocolului prezentat
anterior şi anume capacitatea nivelului de reţea de la destinatar de a prelucra datele
sosite cu o viteză infinită (sau, echivalent, prezenţa la nivelul DLC de la receptor a
unui buffer de dimensiune infinită, care să poată stoca toate cadrele sosite şi care îşi
aşteptă rândul să fie preluate de nivelul de reţea de aici).
Principala problemă căreia protocolul trebuie să-i facă faţă este aceea de a
preveni ca emiţătorul să înece cu date receptorul (adică să-i transmită date cu o viteză
mai mare decât cea cu care receptorul poate prelucra datele sosite). În esenţă, dacă
receptorul are nevoie de un timp t ca să execute procedurile from_physical_layer
plus to_network_layer, atunci emiţătorul trebuie să transmită cu o viteză medie mai
mică de 1 cadru în intervalul t. Mai mult, dacă admitem că hard-ul receptorului
nu efectuează nici stocarea automată în buffer, nici gestionarea şirului de aşteptare al
cadrelor sosite, emiţătorul nu trebuie să transmită nici o dată un nou cadru până ce
precedentul nu a fost preluat de procedura from_physical_layer - căci, altfel, s-ar
stoca peste cadrul precedent.
În anumite circumstanţe restrânse (de exemplu, pentru o transmisie asincronă şi
un nivel DLC la receptor complet dedicat prelucrării informaţiilor sosite pe unica
linie convergentă în acel nod), ar fi posibil ca emiţătorul să insereze pur şi simplu o
întârziere în precedentul protocol, pentru a-l încetini suficient ca să nu mai înece
receptorul. Dar, de cele mai multe ori, în practică, fiece nivel DLC operează cu mai
multe linii care converg în acel nod, iar intervalul de timp dintre sosirea unui cadru şi
momentul prelucrării sale poate varia în limite largi. Dacă proiectantul reţelei ar putea
calcula durata cea mai lungă posibilă de prelucrare la receptor, atunci el ar putea
programa viteza de transmisie aemiţătorului la o asemenea viteză joasă încât, chiar
dacă fiecare cadru ar suferi întârzierea maximă, nu s-ar întâmpla o depăşire a
capacităţii de prelucrare a receptorului. Dar o asemenea soluţie ar duce la o utilizare a

6
lărgimii de bandă mult sub valoarea optimă (cu excepţia situaţiei când cazul cel mai
favorabil şi cazul cel mai defavorabil ar fi foarte apropiate între ele - adică atunci când
domeniul de variaţie al timpului de reacţie al nivelului DLC al receptorului ar fi
foarte restrâns).
O soluţie mai bună - prin gradul de generalitate al aplicabilităţii sale - o
constituie instalarea unei reacţii de la receptor la emiţător, prin care nivelul DLC
receptor trimite, după ce a livrat un pachet nivelului său de reţea, un cadru special,
de confirmare [acknowledgement], către nivelul DLC al emiţătorului,
permiţându-i să transmită următorul cadru; cât priveşte nivelul DLC al emiţătorului,
el va trebui să aştepte, după transmiterea unui cadru, un anumit timp (fixat prin
protocol) până ce primeşte cadrul de confirmare. Protocoalele în care emiţătorul
transmite un cadru şi apoi aşteaptă o confirmare a ajungerii pachetului la destinaţie
mai înainte de a transmite următorul cadru se numesc protocoale de tip pas-cu-pas
[stop-and-wait].
Menţionăm că, în ipotezele considerate până aici, nivelul DLC al emiţătorului
nu are nevoie să inspecteze cadrul de confirmare, căci nu există decât o singură
posibilitate, iar, întrucât doar sosirea cadrului de confirmare la emiţător are importanţă
(nu şi conţinutul său), receptorul nici nu ar avea nevoie să depună vreo informaţie în
cadrul de confirmare.
Observaţie : Chiar pentru un trafic de date de tip unidirecţional, vor fi şi cadre
(cele de confirmare) care circulă în sens invers. Deci, canalul fizic de comunicaţie
între cele două calculatoare trebuie să permită o circulaţie în ambele sensuri (cel puţin
pe rând - deci de tip semiduplex).
Să renunţăm acum şi la ipoteza unui canal fizic ce nu induce erori de transmisie
- ceea ce, în sfârşit, corespunde realităţii.
Într-un astfel de canal fizic, cadrele pot fi alterate sau pierdute complet. Vom
păstra, însă, ipoteza că un cadru alterat va fi detectat ca eronat de către hard-ul de la
receptor (prin suma de control). Dacă, totuşi, cadrul alterat este astfel încât suma de
control este corectă, acest protocol - ca, de altfel, toate celelalte protocoale de la acest
nivel - nu va lucra corect (adică va livra pachete incorecte nivelului de reţea).
Strategia protocolului pas-cu-pas, în cazul unui canal fizic supus la
perturbaţii, va fi următoarea:
Primul pachet de la A către B este trimis cu primul cadru şi, apoi,
nivelul DLC de la A aşteaptă o confirmare; dacă acest cadru ajunge la B fără
erori, B trimite lui A un cadru de confirmare (denotat cu “ack ”), iar dacă
respectivul cadru cu date ajunge cu eroare, B trimite lui A un cadru de
confirmare negativă [negative acknowledgement] (denotat cu “nack ”);
întrucât erorile pot apare şi în transmisia de la A la B, dar şi în transmisia de la B
spre A, cadrul de confirmare (ack sau nack) este protejat prin CRC.
Dacă B primeşte un cadru cu date fără eroare iar cadrul de confirmare
(ack) ajunge la A fără erori, atunci A poate transmite un nou pachet înt-un
cadru. În schimb, dacă apar erori detectabile fie la transmisia cadrului cu
date, fie pe cadrul ack/nack, A va retransmite pachetul într-un nou cadru.
În fine, dacă fie cadrul cu date, fie ack sau nack returnate sunt pierdute, A
va retransmite vechiul pachet la expirarea pauzei de aşteptare stabilite.
O astfel de strategie poate prezenta o disfuncţionalitate - după cum se ilustrează
în figura de mai jos:

7
 0 0
A
t

a c k

B
P a c h eP t au cl h 0 e t u l 0 s a u 1

F i g . 2

Întrucât întârzierile în transmisie sunt arbitrare, este posibil ca nodul A să

termine pauza de aşteptare şi să retransmită pachetul atunci când prima transmisie
şi/sau ack corespunzătoare este întârziată în mod anormal. Dacă B primeşte
corect ambele transmisii ale respectivului pachet, el nu poate depista, în nici un fel,
dacă noua transmisie conţine acelaşi pachet - repetat - sau unul nou. Pentru a rezolva
această dilemă, s-ar părea că ar fi suficient ca B să compare cele două pachete. Dar
nu este aşa, mai întâi pentru faptul că este posibil ca două pachete succesive să fie
identice, iar apoi pentru că, din punctul de vedere al nivelului DLC, pachetele
reprezintă şiruri arbitrare de biţi, care pot fi eventual identice, şi ar fi o încălcare a
principiului arhitecturii pe niveluri ierarhizate ca DLC să se bazeze pe nivelurile
superioare pentru a se asigura că pachetele succesive sunt diferite.
Aşadar, rezolvarea nu poate fi decât ca nivelul DLC să asigure ca nici o
combinaţie de erori de transmisie să nu permită livrarea către nivelul de reţea a unei
dubluri a unui pachet. Soluţia cea mai simplă a acestei probleme este ca nivelul
DLC emiţător (A) să utilizeze un număr de ordine [sequence number
(SN)] în antetul cadrului, pentru a identifica pachetele succesive şi a depista
dacă a primit un nou pachet sau dublura aceluiaşi pachet.
Din păcate, nici soluţia numerotării pachetelor la emisie nu asigură o
funcţionare corectă în toate condiţiile. Cauza o constituie pierderea ack pe canalul
de reacţie: astfel, dacă staţia emiţătoare (A) nu primeşte confirmarea pe durata pauzei
de aşteptare - reglată prea scurtă faţă de ack întârziate dar ajunse corecte -, ea
transmite dublura cadrului; când primeşte ack, o poate interpreta ca o confirmare a
dublurii primului pachet şi îl va trimite pe următorul pachet; dacă acest ultim pachet
ajunge eronat (la B) - deci nu va genera o ack -, emiţătorul (A) poate interpreta
eronat ack ajunsă la A după transmiterea ultimului pachet - ca fiind confirmarea
acestuia, în loc de confirmarea dublurii pachetului precedent. Figura 3 ilustrează o
astfel de situaţie.

S N 0 0 1 2
A
t

a c k a c k a c k

B
P a c h e t u l 0

F i g . 3
8
 Pentru a evita aceste situaţii, nivelul DLC receptor (B) va returna pe reacţie
nu o simplă ack sau nack, ci numărul de ordine al următorului pachet aşteptat -
eliminându-se astfel ambiguitatea privind pachetul care se confirmă.
Observaţie : S-ar putea utiliza convenţia (echivalentă) ca să se returneze
numărul de ordine al ultimului pachet primit, dar nu se procedează astfel în practică.
Nodul receptor (B) poate solicita acest următor pachet după primirea fiecărui
pachet - la intervale periodice sau la anumite intervale de timp alese arbitrar - printr-
un număr de ordine cerut [request number (RN)].
Observaţie : În numeroase aplicaţii, în afară de traficul de la A spre B, există
şi un trafic în sens invers (de la B spre A). În astfel de cazuri, cadrele de la B către
A, conţinând cereri [request] de noi pachete de la A destinate lui B, trebuie
intercalate cu cadrele ce transportă date de la A spre B. Însă, cu excepţia efectului
său asupra momentelor transmiterii cererilor de pachete (emise de B către A),
traficul de la B spre A nu afectează strategia pas-cu-pas utilizată pentru traficul
de la A spre B; ca urmare, vom ignora traficul în sens invers (cu excepţia
recunoaşterii faptului că cererile de noi pachete pot fi întârziate).
Un exemplu de funcţionare a acestei strategii este dat în Fig. 4, unde s-a
presupus că pachetul 0 a fost repetat - probabil din cauza pauzei de aşteptare prea
scurte de la nodul A; nodul A întârzie retransmiterea pachetului 1 cerut din nou -
fapt ce nu afectează corectitudinea protocolului, dar evită retransmisiile inutile.

S N 0 0 1 2 3
A
t

B
R N 1 1 2 3

P a c h 0 e t u l e 1 x t r a s 2 3

F i g . 4

Vom prezenta în continuare un algoritm de realizare a acestei strategii.

Menţionăm, însă, mai întâi, că, pentru ca strategie să funcţioneze corect, nodurile A
şi B trebuie iniţializate corect, în sensul că nu există cadre în circulaţie pe linie şi că
receptorul B aşteaptă un cadru cu SN egal cu cel al primului cadru transmis de A.
Nu contează valoarea iniţială a lui SN (atâta timp cât A şi B au convenit asupra
ei), deci se poate lua SN = 0. Iat` algoritmul (pentru transmisia de la A spre B):
| La emiţător (nodul A):
1 - Iniţializează SN = 0.
2 - Acceptă un pachet de la nivelul de reţea din A; dacă nu e
disponibil nici un pachet, va aştepta până apare unul. Atribuie SN
noului pachet.

9
 3 - Transmite pachetul cu numărul de ordine SN într-un cadru ce va
conţine SN în câmpul pentru numărul de ordine al pachetului transmis.
4 - Dacă se primeşte de la B un cadru fără eroare, conţinând un RN
> SN, incrementează SN până ce SN = RN şi trece la pasul 2; dacă
nu se primeşte un astfel de cadru într-un anumit interval de timp (pauza
de aşteptare fixată), se trece la pasul 3.
‚ La receptor (nodul B):
1 - Iniţializează RN = 0 şi repetă la nesfârşit paşii 2 şi 3.
2 - Ori de câte ori se primeşte de la A un cadru fără eroare şi
conţinând
SN = RN, pasează pachetul primit nivelului său de reţea şi
incrementează RN.
3 - La momente arbitrare, dar într-un interval de timp limitat după
recepţionarea de la A a unui cadru cu date corect, transmite un cadru lui
A, conţinând RN în câmpul aferent.
Structura cadrelor utilizate este:

Marcaj terminal
Antet
 
SN RN Pachet CRC

Fig. 5

Se pune problema numărului minim de biţi necesari pentru a înscrie în antet

numărul de ordine al cadrului. Pentru a răspunde, vom remarca mai întâi că singura
ambiguitate într-un astfel de protocol este între un cadru - să zicem cu numărul m -
şi succesorul său - cu numărul m + 1. În situaţia când cadrul m este alterat sau
pierdut, receptorul nu îl va confirma, astfel încât emiţătorul va încerca să îl
retransmită. Odată recepţionat corect, receptorul va transmite o confirmare (ack)
înapoi spre emiţător. Aici apare, însă, o problemă: în funcţie de situaţia în care ajunge
confirmarea înapoi la emiţător - corect sau nu (adică fie alterată, fie pierdută) -,
emiţătorul ar putea transmite cadrul nr. m sau cu nr. m + 1. Evenimentul care
provoacă transmiterea de către emiţător a cadrului cu nr. m + 2 este sosirea unei
confirmări corecte pentru cadrul nr. m + 1. Dar asta implică recepţionarea corectă a
cadrului nr. m (cu date) ca şi recepţionarea corectă la emiţător a confirmării aferente.
Deci singura ambiguitate posibilă este între un anumit cadru şi predecesorul sau
succesorul său imediat - nu între predecesor şi succesor. Aşadar este suficient pentru
numărul de ordine un singur bit (0 sau 1). În fiece moment, receptorul aşteaptă
următorul număr de ordine şi orice cadru sosit având un număr de ordine
necorespunzător va fi rejectat, ca fiind o dublură. Când vine un cadru cu numărul de
ordine corect, el va fi acceptat şi pachetul din el va fi pasat nivelului de reţea, după
care DLC incrementează - modulo 2 - numărul de ordine pe care îl aşteaptă (din 0
în 1 şi din 1 în 0).
Dăm în continuare un astfel de protocol - de tip pas-cu-pas - pentru
transmisia într-un singur sens, în care emiţătorul aşteaptă o confirmare înainte de a
continua cu transmiterea următorului pachet; acest protocol mai este denumit şi cu
confirmare pozitivă şi retransmisie [Positive Acknowledgement with
Retransmission (PAR)]. Menţionăm de la început că, deşi el face faţă pierderii
cadrelor (prin pauza de aşteptare), el necesită ca durata de aşteptare să fie suficient

10
de lungă pentru a permite confirmărilor întârziate să sosească, evitând trimiterea de
dubluri provocatoare de ambiguitate (căci, în caz contrar, emiţătorul va considera, în
mod greşit, că a venit confirmarea ultimului cadru transmis şi nu confirmarea
cadrului precedent, iar, dacă următorul cadru transmis se pierde, dar vine confirmarea
dublurii, emiţătorul nu va încerca retransmisia acestui din urmă cadru). Deci, se va
păstra ipoteza unei alternanţe stricte a transmisiei de cadre cu confirmările de la
receptor, prin alegerea unei valori suficient de mari a duratei pauzei de aşteptare.
Acest protocol diferă de precedentul prin aceea că atât emiţătorul cât şi
receptorul posedă o variabilă a cărei valoare este memorizată atâta timp cât nivelul
DLC este în starea de aşteptare. Emiţătorul păstrează numărul de ordine al
următorului cadru de transmis în next_frame_to_send; receptorul păstrează
numărul de ordine al următorului cadru aşteptat în frame_expected. Fiecare
calculator are o scurtă fază de iniţializare înainte de a intra în bucla infinită.
După transmiterea unui cadru, emiţătorul îşi declanşează contorul de timp
(ceasul). Dacă acesta era deja pornit, el va fi resetat pentru a permite o nouă pauză de
aşteptare completă. Intervalul de timp trebuie ales astfel încât să permită cadrului să
ajungă la receptor, receptorului să îl prelucreze - chiar şi în cel mai dezavantajos caz -
şi confirmării să se propage înapoi până la emiţător. Numai la expirarea acestui timp
(pauza de aşteptare) se va putea admite că s-a pierdut fie cadrul transmis, fie
confirmarea sa şi se va putea transmite dublura respectivului cadru.
După transmiterea unui cadru şi pornirea ceasului său, emiţătorul aşteaptă să
apară un eveniment. Există trei posibilităţi: să sosească o confirmare nealterată; să
sosească o confirmare alterată; să expire pauza de aşteptare fixată la ceas.
Dacă vine o confirmare nealterată, emiţătorul preia următorul pachet de la
nivelul său de reţea şi îl pune în buffer, suprascriind pachetul anterior; apoi face să
avanseze (circular) numărul de ordine (adică din 0 face 1 sau vice-versa). Dacă vine
o confirmare alterată sau nu primeşte nici o confirmare, nu va modifica nici conţinutul
buffer-ului, nici numărul de ordine, aşa că se va transmite dublura ultimului cadru.
/* Protocol PAR */
#define MAX_SEQ 1 /* în acest protocol MAX_SEQ = 1 */
typedef enum {frame_arrival, cksum_err, timeout} event_type; /* evenimentele posibile */
#include “protocol.h”
void sender2(void)
{
seq_nr next_frame_to_send; /* numărul de ordine al următorului cadru de transmis */
frame s; /* variabil\ temporar\ */
packet buffer; /* registru tampon (buffer) pentru pachetul de transmis */
event_type event;
next_frame_to_send = 0; /* iniţializare numere de ordine pentru transmisie */
from_network_layer(&buffer); /* preia primul pachet */
while (true) {
s.info = buffer; /* preia pachetul şi îl pune în cadru */
s.seq = next_frame_to_send; /* inserează în antetul cadrului numărul de ordine */
to_physical_layer(&s); /* pasează cadrul nivelului fizic pentru a-l transmite */
start_timer(s.seq); /* pornirea ceasului pentru pauza de aşteptare */
wait_for_event(&event); /* aşteaptă frame_arrival sau cksum_err sau timeout */
if (event == frame_arrival) {
from_network_layer(&buffer); /* preia următorul pachet de transmis */
inc(next_frame_to_send); /* inversează conţinutul numărului de ordine */
}
}
}
void receiver2(void)
{

11
 seq_nr frame_expected; /* numărul de ordine al cadrului aşteptat la recepţie */
frame r, s; /* variabile temporare */
packet buffer; /* registru tampon (buffer) pentru pachetul de transmis */
event_type event;
frame_expected = 0; /* iniţializare numere de ordine pentru recepţie */
while (true) {
wait_for_event(&event); /* aşteaptă frame_arrival sau cksum_err */
if (event == frame_arrival) { /* a sosit un cadru corect */
from_physical_layer(&r); /* preia cadrul nou sosit de la nivelul fizic */
if (r.seq == frame_expected) { /* este cadrul aşteptat */
to_network_layer(&r.info); /* trece pachetul din cadru nivelului de reţea */
inc(frame_expected); /* inversează conţinutul numărului de ordine */
}
}
to_physical_layer(&s); /* nu e utilizat nici unul din câmpuri */
}
}

Când la receptor soseşte un cadru corect, se verifică numărul său de ordine

pentru a se constata dacă el este duplicatul unui cadru. Dacă nu este o dublură, el va fi
acceptat, iar pachetul din el va fi livrat nivelului de reţea, generându-se un mesaj de
confirmare. Pachetele din cadrele eronate şi dubluri nu sunt trecute nivelului de reţea.
Există mai multe metode convenţionale de stabilire a întârzierilor arbitrare între
transmisiile succesive de cadre din algoritmul prezentat.
Procedeul uzual este ca, la nodul A (emiţător) să se iniţializeze un ceas când
începe transmisia unui cadru. Dacă timpul fixat pentru ceas (pauza de aşteptare)
expiră înainte de primirea unei cereri de la B (receptorul) pentru un nou pachet,
ceasul este resetat şi pachetul este retransmis într-un nou cadru. Dacă se primeăte de la
B o cerere de nou pachet înainte de expirarea timpului fixat la ceas, ceasul este
dezactivat. Acelaşi procedeu se aplică şi la B.
O alternativă ar fi ca B să trimită un cadru care să conţină o cerere pentru
pachetul aşteptat, de fiecare dată când primeşte un cadru de la A.
p
În practică, pe o linie există trafic în ambele sensuri.
O posibilitate de a realiza o transmisie de date duplex este de a avea două
canale de comunicaţie separate şi de a utiliza fiecare canal pentru un trafic de date
simplex într-unul din sensuri. Aceasta ar însemna două circuite fizice separate, fiecare
cu un canal direct pentru date şi un canal de reacţie pentru confirmări. Dar
lărgimea de bandă pentru canalul de reacţie ar fi, astfel, aproape în întregime risipită.
Altfel zis, utilizatorul ar plăti costul a două circuite, utilizând doar capacitatea unuia
din ele.
O soluţie mai bună ar constitui-o utilizarea aceluiaşi circuit în ambele sensuri,
intercalând cadrele cu date de la A spre B cu cele de confirmare de la B spre A.
Protocolul pas-cu-pas (PAR) a făcut uz de transmiterea cadrelor în ambele sensuri,
cu o capacitate egală pentru canalul direct şi cel de reacţie. Receptorul poate
recunoaşte dacă un cadru sosit este cu date sau de confirmare prin simpla inspectare a
câmpului kind din cadrul primit.

12
 O îmbunătăţire a acestei soluţii o constituie tehnica de transmisie numită
ataşare [piggybacking]: confirmările de la B sunt deliberat întârziate până când
nivelul de reţea de la B are de transmis un pachet; atunci se ataşează confirmarea la
coada cadrului ce transportă către A respectivul pachet emis de B - de fapt se
înscrie RN în câmpul destinat confirmării din antetul cadrului cu date plecat de la
B.
Principalul avantaj al acestei metode îl constituie mai buna utilizare a lărgimii
de bandă disponibile pentru canalul fizic (câmpul ack din antetul cadrului consumă
doar câţiva biţi, în timp ce un cadru de confirmare separat ar necesita un antet,
confirmarea şi o sumă de control). În plus, mai puţine cadre transmise înseamnă mai
puţine întreruperi pentru cadre sosite şi, eventual (în funcţie de modul de organizare al
soft-ului de la recepţie), un buffer de volum mai mic la receptor.
Dar tehnica ataşării introduce şi o complicaţie care nu apărea la confirmările
trimise separat: durata cât DLC de la receptor trebuie să aştepte un pachet de la
nivelul său de reţea pentru a-i putea ataşa confirmarea. Dacă acest timp depăşeşte
pauza de aşteptare de la emiţător, cadrul va fi retransmis în mod inutil, creând
complicaţii. Soluţia este următoarea: DLC de la receptor aşteaptă, după primirea
unui cadru cu date corect, un anumit interval de timp (de ordinul milisecundelor);
dacă în acest timp vine un pachet de la nivelul lui de reţea, îi ataşează confirmarea, iar
în caz contrar (la expirarea acestui interval de aşteptare) va trimite un cadru separat de
confirmare.
Se poate dovedi cu uşurinţă că frecvenţa posibilă de transmisie a cadrelor este
mai mică la tehnica ataşării decât la cea cu confirmări separate.
Fie un astfel de protocol pas-cu-pas (PAR) cu trafic în ambele sensuri între
nodurile A şi B. Vom presupune că toate cadrele cu date au aceeaşi lungime şi necesită o
aceeaşi durată de emisie D, cadrele de confirmare necesită o aceeaşi durată de emisie C,
iar propagarea pe linie a cadrelor se face cu o întârziere egală T. Vom admite că atât A cât
şi B au un şir infinit de pachete de transmis, că nu apar erori de transmisie şi că pauza de
aşteptare după care se face retransmisia unui cadru este foarte mare. Vom presupune, de
asemenea, că fiecare nod trimite noi pachete şi confirmări cu frecvenţa maximă posibilă,
conform protocolului pas-cu-pas. Se constată imediat că frecvenţa de transmitere a
cadrelor în fiece sens este:

f =
1
D + C + 2T [s ]
-1

şi aceasta indiferent dacă timpii de start de la nodurile A şi B sunt sincronizaţi ori nu

(lăsăm în seama cititorului să dovedească această ultimă afirmaţie).
Să presupunem acum, în plus, că, ori de câte ori un nod are de transmis o confirmare
şi un cadru cu date, confirmarea este ataşată cadrului cu date (nesesitând tot un timp D
pentru emisie). Vom presupune, de asemenea, că nodul B nu începe să transmită date până
ce nu primeşte primul cadru de la A (cu alte cuvinte, primul cadru de la B va avea cu
sigurnţă o confirmare ataşată). Rezultă că toate cadrele următoare, în fiecare sens, sunt cadre
cu date având ataşată câte o confirmare. Se constată imediat că frecvenţa de transmitere în
fiecare sens este acum:

fp =
1
2D + 2T [s ]
-1

şi se observă că, dacă

D > R

13
(ceea ce este întotdeauna adevărat), atunci
f p < f,

p
Performanţele unui protocol sunt:
A) Corectitudinea [correctness] care se traduce prin faptul că un flux
incontinuu de pachete poate fi acceptat de la nivelul de reţea al emiţătorului (A) şi
livrat nivelului de reţea de la receptor (B) în aceeaşi ordine ca la emisie şi fără
dubluri sau pierderi de pachete. Corectitudinea unui protocol are 2 componente:
a) siguran\a în func\ionare [safety], care înseamnă că protocolul
nu produce rezultate incorecte în nici o situaţie - adică nu livrează nici o dată
nivelului de reţea de la recepţie (B) un pachet în afara ordinii corecte;
b) durata de viaţă nelimitată [liveness], prin aceasta
înţelegându-se că poate produce rezultat la nesfârşit, fără să intre într-o
situaţie de blocare - adică este capabil să accepte incontinuu pachete în A şi să
le livreze în B.
B) Eficienţa (utilizării canalului) [(channel) efficiency], care exprimă
cât din lărgimea de bandă a canalului se foloseşte pentru transmisia unui cadru - ca
medie statistică -, ţinând cont de retransmisii şi de pauza de aşteptare a confirmării.
Ne vom ocupa acum de performanţele protocolului pas-cu-pas (PAR) cu
numerotarea cadrelor emise şi cu cereri de cadre cu număr de ordine specificat.
Pentru analiza corectitudinii acestui algoritm, vom menţine ipotezele:
• toate cadrele afectate de erori sunt detectate de CRC de la receptor
• fiecare cadru ajunge la destinaţie fără erori cu o probabilitate
pe ≤ q (q > 0)

• linia (canalul fizic) este iniţial liberă, primul pachet de la emiţătorul A

are numărul de ordine SN = 0, iar receptorul B aşteaptă iniţial un pachet cu
numărul de ordine SN = 0.
A-a) Siguranţa în funcţionare este evidentă pentru acest protocol: nodul B
aşteaptă iniţial pachetul cu numărul de ordine 0 şi singurul pachet care îl poate livra
nivelului său de reţea este cel cu numărul de ordine 0. Rezultă (prin inducţie) că
nodul B a livrat nivelului său de reţea, în ordine, toate pachetele până (exclusiv) cel
cu valoarea curentă a RN şi, deci, pachetul cu acea valoare RN este singurul pe
care îl poate accepta şi livra nivelului de reţea. Când se primeşte un cadru fără eroare
conţinând pachetul cu numărul de ordine egal cu RN şi acesta este pasat nivelului de
reţea, valoarea din câmpul RN este incrementată (modulo 2) şi situaţia expusă mai
sus se repetă pentru noua valoare a RN.
A-b) Pentru a analiza dacă acest protocol are o durată de viaţă nelimitată, să
presupunem că nodul A începe să transmită un anumit pachet - fie el cel cu numărul
de ordine i - la momentul t1 (vezi Fig. 6).

14
 S N i i i i t3
A
t1
t

t2
B
R N i i + 1 i + 1

P a c h e t u l e i x t r a s

F i g . 6

Fie t2 momentul când pachetul este recepţionat fără eroare şi livrat nivelului
de reţea de la B (în caz că acest eveniment nu apare, se ia t2 = ∞). Similar, fie t3
momentul în care SN din A este incrementat la valoarea SN = i +1 (dacă acest
eveniment nu se produce nici o dată, se adoptă t3 = ∞).
Vom observa că nu putem avea certitudinea că nivelul de reţea din A va
furniza întotdeauna pachete într-un anumit interval finit de timp, aşa încât noţiunea de
durată de viaţă nelimitată poate reclama, aici, numai o întârziere finită dacă există
pachete de trimis.
Fie RN(t) valoarea variabilei RN de la nodul B şi fie SN(t) valoarea
corespunzătoare a variabilei SN la nodul A. Din algoritm rezultă direct că SN(t)
şi RN(t) nu sunt funcţii descrescătoare în timp. De asemenea, întrucât SN(t) este
cel mai mare număr de ordine de pachet cerut de B, cerere (de confirmare) ajunsă la
A până la momentul t, rezultă că
SN(t) ≤ RN(t). (1)
Admiţând că pachetul cu numărul de ordine i nu a fost transmis nici o dată
înainte de t1 , atunci (conform proprietăţii de siguranţă în funcţionare)
RN(t1) ≤ i .
Cum
SN(t1) = i ,
rezultă că
SN(t1) = RN(t1) = i .
Conform definiţiilor lui t2 şi t3 , RN(t) va fi incrementat la valoarea
RN = i +1 la momentul t2 , iar SN(t) va fi incrementat la valoarea SN = i +1 la
momentul t3 . Ţinând cont de inegalitatea (1), rezultă că
t2 < t3 .
Nodul A transmite repetat pachetul cu numărul de ordine i , cu intervale de
timp finite între transmisiile succesive, de la momentul t1 şi până când el este
recepţionat prima dată fără eroare - adică până la momentul t2 . Dată fiind
probabilitatea q ca fiece retransmisie să fie recepţionată corect şi ţinând seama că
retransmisiile se fac la intervale finite de timp, va avea loc finalmente o recepţie fără

15
eroare la momentul finit t2 . Nodul B va transmite atunci cadrul purtând RN = i
+1 de la momentul t2 şi până când el va fi recepţionat fără eroare în nodul A -
adică la momentul t3 . Întrucât nodul A transmite şi el cadre în acest timp,
intervalul de timp între transmisiile succesive din B este finit şi, cum
q>0,
va exista în final momentul finit t3 . Deci intervalul [t1 , t3] este finit. Am obţinut
aşadar că:
t1 < t2 < t3
[t1 , t3] este finit.
Repetând raţionamentul pentru i = 0, 1, ... rezultă că fiecare pachet va fi
transmis corect într-un anumit interval de timp finit, deci algoritmul are o durată de
viaţă nelimitată.
B) Vom analiza acum eficacitatea utilizării canalului fizic de către acest
protocol (sau, cum i se zice mai pe scurt - deşi nu tocmai corect, eficienţa
protocolului). Eficienţa unui protocol este influenţată de mai mulţi factori, printre care
esenţiali sunt:
• lungimea fixă sau variabilă a unui cadru
• utilizarea sau nu a tehnicii ataşării confirmărilor la traficul de date în sens
invers
• tipul transmisiei - semiduplex sau duplex - pe linie
• caracteristicile statistice ale erorilor de transmisie.
Pentru deducerea eficienţei protocoalelor vom folosi următoarele notaţii:
d = numărul de biţi de date (ai pachetului) din cadru
h = numărul de biţi din antetul cadrului
l (= d + h ) = lungimea totală (în biţi) a cadrului
a = numărul de biţi ai cadrului de confirmare
C = capacitatea (viteza max. de transmisie a) canalului [biţi/s]
p = probabilitatea ca un bit recepţionat să fie eronat
q = probabilitatea ca un cadru cu date sau confirmarea sa să
se piardă ori să fie alterate
p1 = probabilitatea ca un cadru cu date să se piardă ori să fie
alterat
p2 = probabilitatea ca un cadru de confirmare să se piardă ori
să fie alterat
r = numărul mediu de retransmisii pentru un cadru cu date
T = durata de aşteptare a confirmării
τ = durata întreruperii şi servirii + timpul de propagare
S = eficacitatea utilizării canalului fizic
w = lărgimea ferestrei (se va explica în paragraful următor).
Mai înainte de a lua în consideraţie efectul erorilor de transmisie, să vedem care
este eficacitatea utilizării unui canal fizic “perfect”. Să considerăm momentul t = 0
când emiţătorul începe să transmită cadre. La momentul l /C a fost transmis ultimul
bit. La momentul (l /C) + τ , ultimul bit al cadrului a ajuns la receptor, întreruperea

16
a fost servită şi receptorul este gata să înceapă să transmită cadrul de confirmare. La
momentul (l /C) + τ + (a/C) a fost transmis ultimul bit al cadrului de confirmare.
La momentul (l /C) + τ + (a/C) + τ , emiţătorul a procesat confirmarea şi este
gata să transmită următorul cadru cu date. Lărgimea de bandă ocupată de acest cadru
va fi
C ⋅ [(l /C) + (a/C) + 2τ ] = l + a + 2Cτ .
Fie d numărul de biţi de date (ai pachetului) efectiv transmişi. Eficacitatea utilizării
canalului fizic va fi atunci:
d
S = .
h + d + a + 2Cτ
Dacă antetul şi confirmările sunt neglijabile, lărgimea de bandă este mică, iar duratele
de propagare şi servire sunt scurte, atunci eficacitatea utilizării canalului va fi mare;
iar în caz contrar, va fi mai modestă. Oricum, este clar că eficacitatea utilizării
canalului pentru un protocol de tip pas-cu-pas va fi mult sub 100 %, chiar şi
pentru un canal (fizic) fără erori de transmisie.
Să considerăm acum şi efectul erorilor de transmisie. Dacă un cadru este alterat
sau pierdut, emiţătorul va aştepta un timp T după transmiterea ultimului bit al
cadrului până să reia transmisia. Deci o transmisie fără succes va utiliza l + CT biţi
din capacitatea de transmisie. Întrucât numărul mediu de retransmisii pentru un cadru
este r, capacitatea totală a canalului fizic utilizată pentru transmisia a r cadre
eronate şi a unui cadru corect va fi:
r (l + CT ) + (l + a + 2Cτ ) .
Să determinăm şi numărul mediu de retransmisii pentru un cadru.
Un cadru se consideră transmis corect dacă atât datele cât şi confirmarea sunt
recepţionate corect.. Probabilitatea unei transmisii cu succes este
(1 - p2) (1 - p1) .
Deci probabilitatea unei transmisii fără succes va fi
q = 1 - (1 - p2) (1 - p1) .
Probabilitatea de a avea nevoie de k încercări de transmisie (deci k - 1
retransmisii) este
(1 - q ) q k - 1 .
Aceasta conduce la un număr probabil de transmisii pentru un cadru
1
1- q
şi, deci, la un număr probabil de retransmisii
1 q
r ≅ - 1= .
1- q 1- q
Aşadar, eficacitatea utilizării canalului fizic va fi

17
 d
S=
q
(l + CT ) + (l + a + 2 C τ) .
1- q
Dacă timpul de servire al receptorului are o valoare mică, emiţătorul îşi poate
stabili durata pauzei de aşteptare T puţin peste timpul necesar sosirii confirmării,
adică
a
T ≅ + 2τ
C
şi rezultă:
d 1
S = ⋅ (1- p1)(1- p2) ⋅ .
h +d CT
1+
h +d
Primul factor reprezintă pierderea din cauza surplusului de biţi (de
control) [overhead] din antet. Cel de al doilea factor reprezintă pierderea din
cauza erorilor de transmisie. Cel de al treilea factor reprezintă pierderea cauzată de
algoritmul pas-cu-pas.
În continuare vom căuta un model care să redea legătura dintre probabilitatea
ca un cadru să fie eronat (q ) şi lungimea lui (l ). Vom presupune (nu tocmai
realist) că fiece bit are o probabilitate p de a fi alterat în cursul transmisiei,
independent de biţii precedenţi şi cei ulteriori. În această ipoteză şi pentru
a=h ,
rezultă
d 1 (1)
S = ⋅ (1- p)h +d (1 - p)h ⋅ .
h +d CT
1+
h +d
Apare acum, firesc, întrebarea: este dimensiunea optimă a cadrului? Dacă
lungimea cadrelor este prea mică, S va fi scăzută din cauza surplusului de biţi din
antet; dacă l este prea mare, probabilitatea ca un cadru să fie recepţionat fără eroare
va fi scăzută, deci S va scădea din cauza retransmisiilor multiple. Este clar că
valoarea optimă pentru l va depinde de dimensiunea antetului, frecvenţa erorilor,
lărgimea de bandă primară şi durata pauzei de a]teptare. Pentru găsirea valorii
optime, se va anula derivata parţială a lui S (din (1)) în raport cu d :
∂S
=0
∂d
obţinând
h + CT  4 
d opt =  1- - 1 .
2  (h + CT ) ⋅ ln(1 - p) 

Dacă p are o valoare foarte mică - ceea ce este deseori adevărat -, vom putea
face aproximaţia
ln(1 - p) ≅ - e .

18
 În plus, o valoare mică a lui p înseamnă că putem neglija termenii 1 de sub
radical şi de după radical, obţinând:
h + CT
d opt ≅ . (2)
p
Vom remarca faptul că h + CT reprezintă surplusul cauzat de antete şi de
pauzele de aşteptare. Pe măsură ce calitatea liniei se îmbunăţeşte (adică p ÿ 0), d opt
creşte. Dacă nu există erori, singurul surplus provine de la antete şi de la protocolul
pas-cu-pas - ambele reclamând o lungime cât mai mare a cadrului. Pe de altă parte,
o frecvenţă mare a erorilor cere micşorarea lungimii cadrului, pentru a evita
retransmiterea unor cadre lungi.
Pentru a analiza eficacitatea utilizării canalului pentru dimensiuni ale cadrului
apropiate de cea optimă, să introducem notaţia
∆
d = x ⋅ d opt

astfel încât valorile lui x apropiate de 1 reprezintă cadre cu dimensiuni apropiate

de cea optimă.
Din (1) şi (2), utilizând aproximaţia
(1 - p )d ≅ 1 - pd ,
obţinem:
1 - x (h +CT )p
S ≅ (1 - 2hp)
1
1+ (h + CT )p
x
Atâta timp cât radicalul rămâne relativ mic, S nu este foarte sensibilă la
micile abateri de la dimensiunea optimă a cadrului.
Măsurătorile practice ale caracteristicilor erorilor pe liniile telefonice au pus în
evidenţă faptul că erorile nu afectează biţii în mod independent - deci că modelul
p1 = 1 - (1 - p ) h + d
şi
p2 = 1 - (1 - p ) a
nu este potrivit -, ci că erorile apar în rafale - un model mai corect fiind cu
p1 = 1 - k (h + d )α
şi
p2 = 1 - kh α .
Cu metoda de mai sus se pot afla eficacitatea utilizării canalului
d
S= ⋅ k 2 ⋅ [ h (h + d )] α
h + d + CT
şi dimensiunea optimă a cadrului

(1 + α) ( h + CT )  4 αh 
d opt = ⋅  1- - 1 .
2α  (1 + α) 2 ( h + CT ) 

19
 3 Protocoale cu fereastră glisantă

Date fiind dezavantajele protocolului de tip pas-cu-pas de a fi numai

unidirecţionale (simplex) şi de a se potea bloca dacă pauza de aşteptare de la
emiţător este prea mică, s-au căutat alte protocoale care să rămână sincronizate în
condiţiile oricăror combinaţii de cadre alterate şi de pauze de aşteptare prea scurte.
Astfel de protocoale sunt cele din clasa cu fereastră glisantă [sliding window].
În aceste protocoale, fiece cadru emis conţine un număr de ordine de la 0 la
2n - 1 (deci necesită un câmp de n biţi pentru acesta). Protocolul pas-cu-pas
utilizează valoarea n = 1 (numărul de ordine putând fi 0 sau 1).
La baza protocoalelor cu fereastră glisantă stă faptul că, în orice moment,
emiţătorul menţine o listă cu cele n numere de ordine consecutive corespunzătoare
cadrelor cărora li se permite să fie transmise fără a se aştepta confirmarea fiecăruia
în parte. Se zice că aceste cadre se află în fereastra de emisie [sending
window]. Receptorul acceptă pachetele numai în ordinea corectă (am menţinut
ipoteza că protocolul va livra pachetele nivelului de reţea destinatar în aceeaşi
ordine cu cea în care au fost trecute nivelului DLC de la emisie, ca şi ipoteza că
mediul fizic livrează cadrele în ordinea în care acestea au fost transmise) şi trimite
cereri de numere de ordine (RN) către emiţător; efectul unei anumite RN este de a
confirma toate pachetele anterioare lui RN şi a cere transmiterea pachetului cu
numărul de ordine RN.
Mai clar, nodului emiţător A nu i se permite să transmită pachetul i + n
până când pachetul i nu a fost confirmat (adică până când nu i s-a cerut să
transmită pachetul i + 1). Astfel, dacă RN = i este cea mai recentă cerere primită
de la receptorul B, la A va exista o “ferestră” de n pachete (de la i la i + n -1)
pe care emiţătorul are voie să le transmită.
Când un nou pachet soseşte de la nivelul de reţea la nivelul DLC al
emiţătorului, el primeşte numărul de ordine următor celui maxim din fereastră - deci
limita superioară a ferestrei se deplasează cu 1 unitate. Când vine o confirmare,
limita inferioară a ferestrei avansează cu 1 unitate. Astfel, fereastra menţine
permanent o listă a cadrelor trimise şi neconfirmate, “alunecând” spre numere de
ordine tot mai mari (de aici şi numele acestei clase de protocoale).
Întrucât cadrele din fereastra de emisie pot fi alterate sau pierdute în timpul
transmisiei, emiţătorul trebuie să păstreze toate aceste cadre în memorie pentru o
posibilă retransmisie. Pentru o ferestră de dimensiune n, emiţătorul are nevoie de n
buffere pentru a stoca cadrele neconfirmate. Dacă fereastra creşte până la
dimensiunea ei maximă, nivelul DLC al emiţătorului trebuie să oprească nivelul
său de reţea să mai paseze pachete până când un buffer devine liber.
Şi receptorul menţine o fereastră de recepţie [receiving window] ce
corespunde cadrelor pe care receptorul are voie să le accepte. Fereastra emiţătorului
şi cea a receptorului nu trebuie să aibă aceleaşi limite inferioară şi superioară şi
nici măcar aceeaşi dimensiune. Orice cadru sosit la receptor şi care nu face parte din
fereastra de recepţie nu va fi acceptat. Când se primeşte un cadru cu numărul de
ordine egal cu limita inferioară a ferestrei de recepţie, el este pasat nivelului de reţea
receptor şi se generează o confirmare; fereastra se va deplasa cu o unitate. Spre
diferenţă de fereastra emiţătorului, fereastra receptorului rămâne întotdeauna la
dimensiunea sa iniţială.

20
 K Observaţii:
1) După m deplasări (unde m este numărul de biţi pentru SN), o
fereastră de dimensiune n poate conţine aceleaşi numere de ordine ca iniţial (nu e
nevoie de o incrementare permanentă a numerelor de ordine - care ar complica şi
“înscrierea” ei). De aceea se poate vorbi de “rotaţia ferestrei”.
2) O fereastră receptoare de dimensiune 1 înseamnă că nivelul DLC
receptor acceptă cadrele doar în ordine, dar pentru n > 1 nu se întâmplă aşa;
oricum, nivelul de reţea receptor primeşte întotdeauna pachetele în ordinea corectă,
indiferent de dimensiunea ferestrei.
Iată un exemplu cu n = 1 pentru un număr de ordine pe 3 biţi (de la 0 la 7).
Iniţial, nu există cadre de transmis, deci limitele inferioară şi superioară ale
ferestrei sunt egale.

7 0 7 0 7 0 7 0

6 1 6 1 6 1 6 1
E m is ie
5 2 5 2 5 2 5 2

4 3 4 3 4 3 4 3

7 0 7 0 7 0 7 0

6 1 6 1 6 1 6 1
R e c e p ţ ie
5 2 5 2 5 2 5 2

4 3 4 3 4 3 4 3

I ţn i Di a u p l ă t r a Dn s u mp ăi s ir ae cD e u p p ţ ăi a r e c e p ţ i a
p r i m u l u i p c r a i md r u u l u ip cr ia m d er ui c o n f i r m ă r i
F i g . 7
Cazul n =1, deşi prezintă o serie de avantaje faţă de protocolul pas-cu-pas
(este bidirecţional şi mai robust - adică suportă orice combinaţie de erori şi pauze
de aşteptare fără a provoca pierderi sau dublări de pachete), prezintă şi un neajuns.
Până acum am făcut presupunerea tacită că timpul necesar unui cadru pentru a ajunge
la destinaţie plus timpul de transmitere a confirmării constituie o durată neglijabilă
- ceea ce este fals. Iar timpul de propagare dus-întors poate avea implicaţii
importante asupra eficienţei de utilizare a lărgimii de bandă.
Astfel, de exemplu, să considerăm un canal de satelit de capacitate 50
[kbiţi/s], cu o durată de propagare dus-întors de 500 [ms]. Se vor transmite, cu
ajutorul protocolului cu fereastră glisantă de lărgime n = 1, cadre de lungime l
= 1000 biţi. La t = 0, emiţătorul începe să transmită primul cadru. La t = 20 [ms],
cadrul a fost complet transmis. În cele mai bune condiţii (adică fără aşteptare pentru
servire la recepţie şi pentru un cadru de confirmare scurt), cadrul cu date emis va
ajunge de abia la t = 270 [ms], iar confirmarea va ajunge la emiţător de abia la t =
520 [ms]. Aceasta înseamnă că emiţătorul a fost blocat pe 500/520 = 96 % din
timpul total - cu alte cuvinte, a folosit doar 4 % din lărgimea de bandă disponibilă.

21
 Este clar că o combinaţie între un timp lung de propagare, o lărgime de bandă
mare şi o lungime mică a cadrelor duce la un rezultat dezastruos în ceea ce priveşte
eficacitatea utilizării canalului. Cauza o constituie algoritmul de transmisie, care cere
ca emiţătorul să aştepte confirmarea unui cadru înainte de a-l putea transmite pe
următorul. Soluţia o constituie permisiune ca emiţătorul să transmită n > 1 cadre
înainte de a fi blocat în aşteptarea confirmării. Alegând convenabil lărgimea n a
ferestrei, emiţătorul va fi capabil să transmită continuu cadre pe o durată egală cu
timpul de propagare dus-întors, fără să umple fereastra.
În cazul exemplului de mai sus, va trebui ca n ≥ 26. Dacă emiţătorul începe
să transmită primul cadru la t = 0, atunci la t = 520 [ms] el a terminat de transmis
cele 26 cadre (n = 26) şi tocmai primeşte confirmarea pentru cadrul cu numărul de
ordine 0. Apoi, confirmările vor sosi la fiecare 20 [ms], astfel încât emiţătorul va
avea permanent permisiunea să transmită (dacă are ce transmite). În orice moment
vor exista 25 sau 26 de cadre transmise şi neconfirmate încă. Deci dimensiunea
maximă a ferestrei de emisie este de 26.
Această tehnică de transmisie este numită pompare (pe conductă) /
bandă de asamblare [pipelining]. Dacă avem o capacitate a canalului fizic de
C [biţi/s] ]i o dimensiune a cadrului de l [biţi], iar durata de propagare dus-întors
este de 2τ [s], timpul necesar transmiterii unui cadru va fi l /C [s]. După ce a fost
transmis ultimul bit al cadrului, există un interval de timp de τ [s] până ce acest
bit să ajungă la receptor şi (presupunând că timpul de aşteptare şi de servire la
receptor ≅ 0) încă τ [s] pentru ca să primească confirmarea. La protocolul pas-
cu-pas, linia este ocupată timp de l /C şi este liberă timp de 2 τ , rezultând un
grad (eficacitate) de utilizare a liniei de l /(l + 2Cτ ). Dacă l < 2Cτ , rezultă S < 50
%. Dar, întrucât, în realitate, avem τ > 0 pentru propagarea înapoi a confirmării,
metoda pompării poate fi utilizată, în principiu, pentru a folosi linia în acest timp,
dar dacă τ este mic, complexitatea introdusă suplimentar de această metodă de
transmitere nu este justificată.
Pomparea cadrelor pe o linie nefiabilă ridică unele probleme serioase,
precum: ce se întâmplă dacă se pierde sau se alterează un cadru din mijlocul unui
şir lung de cadre? Este posibil ca un şir lung de cadre (pentru o fereastră de emisie
de dimensiuni mari) să sosească la recepţie mai înainte ca emiţătorul să fie înştiinţat
că vreun cadru n-a ajuns corect. Evident, un cadru alterat va fi refuzat la recepţie.
Dar ce trebuie să facă receptorul cu cadrele sosite corect după cadrul alterat? (A nu
se uita că nivelul DLC al receptorului trebuie să livreze în ordine pachetele către
nivelul său de reţea).
Există două metode de a face faţă erorilor de transmisie la tehnica pomp`rii
cadrelor:

â Metoda întoarcerii cu n înapoi [go back n]

În această metodă, receptorul neglijează pur şi simplu cadrele ce urmează
unui cadru sosit cu eroare - chiar dacă acestea sunt corecte -, ne transmiţând nici o
confirmare.
Această strategie corespunde unei ferestre de recepţie cu lărgimea 1, nivelul
DLC de la recepţie refuzând să accepte orice cadru cu excepţia celui ce conţine

22
următorul pachet pe care trebuie să-l livreze nivelului său de reţea. Dacă fereastra de
emisie se umple înainte ca pauza de aşteptare să expire, “conducta” de cadre va
începe să se golească. În final, pauza de aşteptere se va termina şi emiţătorul va
retransmite toate cadrele neconfirmate, în ordine, începând cu cel alterat sau pierdut.
Să analizăm mai amănunţit efectele erorilor de transmisie asupra acestui
algoritm, pentru cazul n = 4:

F e r e a [ 0 s i s t , r i] ae 3 [1 , ] 4 [2 , ] 5
d e e m
S N 0 1 2 3 4 1 2 3 4
A
t

B
R N 0 1 1 1 1 1 2 3

P a c h 0 e t u l e x t r a s 1 2 3

F i g . 8

Cel de al doilea cadru, purtând pachetul numărul 1, ajunge eronat la B. Ca

atare, nodul B continuă să ceară pachetul 1 (RN = 1) cu fiecare cadru de
confirmare trimis spre A. Pachetele 2, 3 şi 4 de la A ajung în B fără erori, dar
nu sunt acceptate, întrucât B aşteaptă pachetul cu SN = 1. După ce A a transmis
pachetul cu SN = 4, epuizându-şi fereastra de emisie - care este încă [1 , 4] -, îşi
încheie şi pauza de aşteptare şi reia transmisia de la pachetul 1, trimiţând ulterior şi
pachetele 2, 3 şi 4, care se presupune că ajung fără eroare la B. Când vine la A
confirmarea RN = 1, fereastra de emisie “alunecă” la [2 , 5].
Să urmărim acum efectul erorilor asupra confirmărilor de la B spre A:

F e r e a [ s0 i s t r, a
d e e m i ]e 3 [2 , ] 6 [4 , [5 ] 7 , ] 8
S N 0 1 2 3 4 5 2 4 5
A
t

B
R N 0 1 2 3 4 5 6

P a c h 0 e t u1 l 2 e 3x t r 4a s 5

F i g . 9

23
 Primul cadru de confirmare, purtând SN = 1, este alterat în transmisie, dar nu
crează probleme, căci este urmat de o confirmare (RN = 2) care ajunge corect şi
această confirmare ajunge la A mai înainte ca pachetul cu numărul de ordine 3
(ultimul pachet al ferestrei curente de emisie) să fi fost complet transmis şi ca pauza
de aşteptare să fi expirat - ceea ce se traduce la A ca o confirmare a ajungerii corecte
la B a pachetelor 1 şi 2. Cel de al doilea cadru de confirmare alterat (purtând RN
= 3) provoacă retransmisia, întrucât următorul cadru de confirmare (având RN = 4)
este întârziat până când A îşi transmite întreaga fereastră şi îşi epuizează pauza de
aşteptare; aceasta face ca A să se întoarcă cu transmisia de la pachetul 2.
K Observaţii: Se constată că - aşa cum stau lucrurile în exemplul ales -, în
cazul unei ferestre de emisie de lungime mică şi a unor cadre cu date lungi de la B
la care să se ataşeze confirmările, o eroare a confirmării poate întârzia confirmările
până când ultimul pachet al ferestrei de emisie de la A este transmis, făcând ca
emiţătorul A să aştepte sau să se întoarcă pentru retransmisie. Mai observăm că,
atunci când o confirmare întârziată ajunge la emiţător, acesta poate executa un salt
înainte (în cazul exemplului, de la pachetul 3 la pachetul 5).
Este posibil să apară retransmisii chiar în absenţa erorilor de transmisie.
Acesta se întâmplă în cazul unor cadre lungi într-un sens (de la A spre B) şi a
unor cereri de pachete ajungând la emiţător (în A) cu întârziere. Iată un astfel de
caz:
F e r e a [ 0 s i s t , r i ] ae 3 [1 , ] 4 [3 , ] [4 6 , ] 7
d e e m
S N 0 1 2 3 4 1 3 4 5
A
t

B
R N 0 1 3 4 5

P a c h 0 e t u1 l2 e 3 x t r 4 a s

F i g . 1 0
Cererea RN = 1 ajunge la timp pentru a permite pachetului 4 să fie trimis,
dar, după trimiterea pachetului cu SN = 4, nodul A termină pauza de aşteptare şi
se întoarce la pachetul 1.
Dăm mai jos regulile pentru protocolul întoarce cu n înapoi -
presupunând că SN şi RN sunt numere întregi ce pot creşte nelimitat (în
practică, ele sunt modulo m):
- Regulile nu privesc iniţializarea protocolului: vom presupune că, iniţial, nu
sunt cadre de transmis pe linie, că nodul A începe să transmită pachetul 0 şi că
nodul B aşteaptă pachetul 0 (vom aborda mai încolo modul de iniţializare).
- Emiţătorul utilizează variabilele SNmin şi SNmax pentru fereastră (SNmin
este cel mai mic număr de ordine al unui pachet care nu a fost încă confirmat şi
reprezintă limita inferioară a ferestrei de emisie; iar SNmax denotă numărul de
ordine al următorului pachet ce va fi preluat de la nivelul de reţea). Deci nivelul
DLC de la emiţător va încerca să transmită pachetele de la cel cu numărul de ordine
SNmin până la cel cu numărul de ordine SNmax - 1 (păstrate în buffere pentru
eventuala retransmisie).

24
 Iat` acum algoritmul întoarce cu n înapoi :
| La emi\`tor (nodul A):
1 - Iniţializează SNmin = SNmax = 0
2 - Execută paşii 3, 4 şi 5 repetat, în orice ordine. Pot exista
întârzieri arbitrare - dar limitate - între momentul când sunt
satisfăcute condiţiile pentru un pas şi momentul când pasul este
executat.
3 - Dacă
SNmax < SNmin + n
şi dacă este disponibil un pachet de la nivelul de reţea, acceptă un
nou pachet în DLC, îi atribuie numărul de ordine SNmax şi
incrementează SNmax .
4 - Dacă se primeşte un cadru fără eroare de la B, conţinând
RN > SNmin ,
atunci creşte SNmin până când
SNmin = RN .
5 - Dacă
SNmin < SNmax
şi nu există nici un cadru aflat în curs de transmisie, se alege un
număr
SN ∈ [SNmin , SNmax) ;
se transmite pachetul cu numărul de ordine SN într-un cadru,
punând valoarea lui SN în antetul lui, în câmpul rezervat
numărului de ordine. Se permite cel mult o întârziere limitată între
transmisiile la intervale succesive ale pachetului cu SNmin , dacă
SNmin nu se modifică.
‚ La receptor (nodul B):
1 - Iniţializează RN = 0 şi repetă la nesfârşit paşii 2 şi 3.
2 - Ori de câte ori se primeşte un cadru fără erori de la A, conţinând
SN = RN ,
livrează pachetul sosit nivelului de reţea şi incrementează RN .
3 - La momente arbitrare, dar cu întârzieri limitate după primirea
oricărui cadru fără erori de la A, transmite un cadru către A,
conţinând RN în câmpul pentru numărul de ordine cerut.
Există mai multe metode convenţionale de a stabili temporizările şi ordinea
diferitelor operaţii din algoritmul dat.
Cel mai simplu ar fi ca nodul A să iniţializeze un ceas ori de câte ori
transmite un pachet. Dacă timpul fixat la ceas expiră înainte de sosirea confirmării
pentru acel pachet (adică înainte ca SNmin să depăşească numărul de ordine al
acestui pachet), pachetul va fi retransmis. Câteodată, la utilizarea acestei metode,
emiţătorul, după ce se întoarce şi retransmite pachetul cu SNmin , retransmite

25
automat şi următoarele pachete până la cel cu numărul SNmax - 1, indiferent dacă
se primesc sau nu confirmările cu cererile pentru următoarele pachete.
De exemplu, în cazul prezentat de erori la cadrele de confirmare pentru
protocolul revenire cu 4, emiţătorul ar fi putut trimite pachetul 4 după pachetul
3, în loc de pachetul 5. În conformitate cu algoritmul prezentat, aceasta corespunde
situaţiei ca emiţătorul să întârzie executarea pasului 4 atunci când se află în cursul
retransmiterii ferestrei de pachete.
O altă posibilitate o constituie cea ca A să revină la începutul ferestrei după
transmiterea tuturor pachetelor din fereastră.
De asemenea este posibil ca A să răspundă unei cereri specifice a lui B
pentru retransmisie. O astfel de comunicaţie între A şi B poate fi considerată ca
parte a acestei clase de protocoale, ghidând selecţiile posibile din algoritm.
K Observaţie: Revenirea cu n reprezintă, în fond, o clasă de
protocoale (algoritmi), căci nici temporizările, nici modurile de organizare a
retransmisiilor nu sunt precizate. Mai mult, nu se fixează nici modul de alegere a
pachetelor într-o fereastră.
Cea mai simplă metodă de temporizare la nodul B este ataşarea valorii
curente a RN la cadrele cu date transmise către A (piggybacking), iar când B nu
are date de transmis lui A, să trimită un cadru de confirmare izolat, conţinând RN,
după fiecare recepţie a unui cadru cu date nealterat trimis de A.
Dăm în cele ce urmează un protocol de tip revenire cu n ce poate
transmite o fereastră de lărgime w = MAX_SEQ şi în ipoteza că nivelul de reţea
de la emisie nu are pregătit un pachet în orice moment, ci acesta provoacă un
eveniment de tip Network_Layer_Ready când are un pachet de transmis. La
acest protocol, nivelul DLC de la emisie va împiedica nivelul său de reţea să-i mai
trimită pachete după ce fereastra s-a umplut (de fapt, buffer-ul), permiţându-i să reia
trimiterea de pachete atunci când în fereastră s-a făcut loc (prin transmiterea cu succes
a unui număr de cadre de la începutul ferestrei); aceasta se realizează prin intermediul
funcţiilor disable_network_layer şi respectiv enable_network_layer. Pe de
altă parte, nivelul DLC receptor acceptă cadrele în ordine; cadrele ce urmează după
un cadru alterat de eroare nu mai sunt preluate. În acest protocol s-a adoptat o valoare
MAX_SEQ = 7 (dar ea poate fi schimbată cu orice valoare impară).
/* Protocol Go_back_n */
#define MAX_SEQ 7 /* trebuie să fie 2ˆn = 1 */
typedef enum {frame_arrival, cksum_err, timeout, network_layer_ready} event_type;
/* evenimentele posibile */
#include “protocol.h”
static boolean between(seq_nr a, seq_nr b, seq_nr c)
{
/* întoarce adevărat dacă a < = b < c circular şi fals în caz contrar */
if(((a < = b) && (b < c)) || ((c < a) && (a < = b)) || ((b < c) && c < a)))
return(true);
else
return(false);
}
static void send_data(seq_nr frame_nr, seq_nr frame_expected, packet buffer[ ])

26
{
/* construieşte şi trimite un cadru cu date */
frame s; /* variabilă temporară */
s.info = buffer[frame_nr]; /* inserează pachetul în cadru */
s.seq = frame_nr; /* inserează numărul de ordine al pachetului în cadru */
s.ack = (frame_expected + MAX_SEQ) % (MAX_SEQ + 1); /* ataşează confirmarea */
to_physical_layer(&s); /* transmite cadrul */
start_timer(frame_nr); /* porneşte ceasul pentru pauza de aşteptare */
}
void gobackn(void)
{
seq_nr next_frame_to_send; /* numărul de ordine al următorului cadru de transmis */
seq_nr ack_expected; /* cel mai vechi cadru încă neconfirmat */
seq_nr frame_expected; /* următorul cadru aşteptat la recepţie */
frame r; /* variabilă auxiliară */
packet buffer[MAX_SEQ]; /* buffer pentru cadrele de la emisie */
seq_nr nbuffered; /* număr buffer-e utilizate la emiţător */
seq_nr I; /* index în vectorul de buffer-e */
event_type event;
enable_network_layer(); /* permite evenimente networ_layer_ready */
ack_expected = 0; /* următoarea confirmare aşteptată */
next_frame_to_send = 0; (* următorul cadru transmis */
frame_expected = 0; /* numărul cadrului aşteptet să sosească */
nbuffered = 0; /* iniţial, în buffer-e nu există nici un pachet */
while true {
wait_for_event(&event); /* cele 4 evenimente posibile - vezi event_type */

27
 switch(event) {
case network_layer_ready: /* nivelul de reţea emiţător are un pachet de transmis */
/* acceptă, salvează şi transmite un nou cadru */
from_network_layer(&buffer[next_frame_to_send]); /* preia noul pachet */
nbuffered = nbuffered + 1; /* deplasează fereastra de emisie */
send_data(next_frame_to_send, frame_expected, buffer); /* transmite cadrul */
inc(next_frame_to_send); /* deplasează limita super. a ferestrei de emisie */
case frame_arrival: /* a sosit un cadru cu date sau de control */
from_physical_layer(&r); /* preia cadrul din biţii sosiţi la nivelul fizic */
if (r.seq == frame_expected) {
/* cadrele sunt acceptate doar în ordine */
to_network_layer(&r.info); /* pasează pachetul nivelului de reţea */
inc(frame_expected); /* deplasează limita infer. a ferestrei de emisie */
}
/* confirmarea pachetului n implică confirmările pachetelor n-1, n-2, etc. */
/* se verifică acest lucru */
while (between(ack_expected, r.ack, next_frame_to_send)) {
/* tratează confirmarea ataşată */
nbuffered = nbuffered - 1; /* se eliberează un cadru din buffer */
stop_timer(ack_expected); /* cadrul a sosit nealterat; opreşte ceasul */
inc(ack_expected); /* micşoreză fereastra de emisie */
}
case cksum_err: ; /* cadrele eronate sunt ignorate */
case timeout: /* a expirat pauza de aşteptare; se retransmit */
/* toate cadrele neconfirmate */
next_frame_to_send = ack_expected; /* retransmisia începe de aici */
for (i=1; i<=nbuffered; i++) {
send_data(next_frame_to_send, frame_expected, buffer); /* retransm. 1 cadru */
inc(next_frame_to_send); /* pregăteşte transmiterea următorului cadru */
}
}
if (nbuffered < MAX_SEQ)
enable_network_layer();
else
disable_network_layer();
}
}

Vom observa că, în fiece moment, sunt gata de transmis MAX_SEQ cadre (şi
nu MAX_SEQ + 1 !!), chiar dacă există MAX_SEQ + 1 numere de ordine
(SN): 0, 1, 2, ... , MAX_SEQ .
Pentru a înţelege această restricţie, să considerăm următorul scenariu pentru
MAX_SEQ = 7:
1 - Emiţătorul transmite cadrele de la 0 la 7;
2 - O confirmare, ataşată la un cadru cu date, vine în fine la emiţător;
3 - Emiţătorul transmite alte 8 cadre, cu numerele de ordine 0 ÷ 7;
4 - Soseşte o nouă confirmare (ataşată) pentru cadrul numărul 7.
Se pune întrebarea: cele 8 cadre din al doilea lot au ajuns toate corect sau s-au
pierdut toate (căci toate cadrele ajunse după un cadru eronat sunt ignorate) ? În ambele
cazuri, receptorul trimitea confirmarea pentru numărul 7 şi emiţătorul nu are cum să

28
afle ce s-a întâmplat. De aceea numărul maxim de cadre transmise trebuie limitat la
MAX_SEQ .
Fiecare cadru trebuie asociat unui alt ceas, căci pauza de aşteptare pentru el
poate fi diferită de cele pentru celelalte cadre. Aceste ceasutri pot fi uşor simulate
prin soft, utilizând un singur ceas hard care provoacă periodic întreruperi. Pauzele
de aşteptare formează o listă legată, pentru fiecare “nod ” din listă indicându-se câte
tacturi sunt până la expirarea pauzei de aşteptare, numărul cadrului pentru care se
marchează timpul şi un pointer către următorul nod.
Iată un exemplu:

1 0 : 0 T 0i m : p 0 u l0 r e . a 0l

5 1 8 2 6 3
P o i n t e r c ă t r e u r m ă t o a r e a p a u z ă d e a ş t e
N r . d e o r d i n e a l c a d r u l u i p e n t r u c a r e s
P e r i o a d e r ă m a s e
a )

1 0 : 0 0 : 0 0 . 5

8 2 6 3
b )

F i g . 1 1

Fie un ceas cu perioada de 100 [ms]. Fie timpul iniţial real 10.00:00.0. Să
admitem că vor exista 3 pauze de aşteptare: respectiv până la 10:00:00.5, 10:00:01.3
şi 10:00:01.9. La fiecare perioadă a ceasului hard, timpul real este actualizat şi ceasul
din capul listei este decrementat. Când contorul de perioade (tacturi) ajunge la 0,
pauza de aşteptare s-a terminat şi nodul este eliminat din listă (vezi fig. b)).
Deşi metoda necesită scanarea listei la apelarea funcţiilor start_timer şi
stop_timer, ea nu reclamă multe operaţiuni pentru fiecare tact.

29
 Să analizăm acum performanţele protocolului de tip revenire cu n.
Dacă SN şi RN sunt numere întregi nemărginite, demonstrarea
corectitudinii protocolului este similară cu cea pentru protocolul pas cu pas: vom
presupune şi aici că toate cadrele alterate sunt depistate de CRC de la recepţie, că
fiece cadru ajunge la destinaţie corect cu o probabilitate ≥ q > 0 şi că sistemul este
iniţializat corect (nu există, iniţial, cadre în curs de transmisie, iar nodurile A şi B
încep amândouă cu pasul 1 din algoritmul lor).
Proprietatea de siguranţă a protocolului de tip revenire cu n este exact
aceeaşi ca la protocolul pas cu pas: în speţă, nodul B livrează pachetele, în
ordine, nivelului său de reţea, utilizând RN pentru a urmări viitorul pachet aşteptat.
Pentru a demonstra durata de viaţă nelimitată, să admitem că, la A, la un
anumit moment t1 , avem
SNmin = i .

F e r e a s t r a [i , n +i - 1 ] [i + 2n +, +i 1 ]
d e e m i s i e
S N i i + 1i i + 1i i + i1 + 2
A
t1 t3 t

t2
B
R N i i i + i 1+ 2

P a c h e t u l e x t r ia si + 1

F i g . 1 2

Fie t2 momentul la care pachetul i este recepţionat corect şi livrat nivelului

de reţea din B (dacă aceasta nu se întâmplă, t2 = ∞ ). Similar, fie t3 momentul la
care este incrementat SNmin (dacă aceasta nu se întâmplă, t3 = ∞ ).
Fie RN(t ) valoarea variabilei RN din B în funcţie de timp şi fie SNmin (t
) valoarea corespunzătoare a lui SNmin din A. Se constată direct din algoritm că
SNmin (t ) şi RN(t ) nu sunt descrescătoare în timp. De asemenea, întrucât
SNmin (t ) este cel mai mare RN primit de la B până în momentul t (dacă s-a
primit vreo astfel de confirmare), rezultă că
SNmin (t ) ≤ RN(t ) .
Conform definiţiilor lui t2 şi t3 , RN(t ) este incrementat la valoarea i + 1
în momentul t2 iar SNmin (t ) este incrementat peste valoarea i în momentul t3 .
Ţinând cont de inegalitatea de mai sus, rezultă că
t2 < t3 .
Se va observa că este posibil ca
t2 < t1

30
întrucât pachetul i s-ar fi putut să fie recepţionat fără eroare şi livrat nivelului de
reţea din B mai înainte de momentul t1 şi chiar mai înainte ca SNmin să fi devenit
egal cu i .
Conform algoritmului, A transmite pachetul i în mod repetat, cu întârzieri
finite între retransmisiile succesive, de la t1 până la t3 .
Dacă
t1 < t2 ,
rezultă că
RN(t ) = 1 pentru t ∈ [t1 , t2]
astfel încât prima recepţionare fără erori a pachetului i după momentul t1 va fi
acceptată, pachetul fiind livrat nivelului de reţea din B. Întrucât t2 < t3 , A va
retransmite pachetul i până când acesta va fi confirmat. Întrucât există o
probabilitate q > 0 ca fiece retransmisie să fie recepţionată corect, iar retransmisiile
se fac la intervale finite, rezultă că intervalul de la t1 la t2 este finit. Nodul B -
indiferent dacă t1 < t2 sau vice versa - transmite cadre conţinând RN ≥ i + 1, de
la momentul t2 până când un astfel de cadru este recepţionat corect în A (la
momentul t3). Cum A transmite şi el cadre în acest interval, întârzierea între
transmisiile succesive de la B va fi finită şi, întrucât q > 0, rezultă că intervalul de
timp de la t2 la t3 va fi finit.
Aşadar am obţinut că t3 este finit iar t1 < t3 şi t2 < t3 . Utilizând acest fapt
pentru fiecare valoare succesivă a lui SNmin , rezultă că fiece pachet este transmis
cu o întârziere finită - deci algoritmul are o durată de viaţă nelimitată.
Observaţie: Vom remarca faptul că, în demonstraţia de mai sus, nu s-a făcut
nici o presupunere privitoare la circulaţia în ordine a cadrelor pe linie - deci
algoritmul revine cu n lucrează corect chiar în cazul în care cadrele circulă fără
o anumită ordine. Aşadar, algoritmul se poate folosi şi la nivelul de transport al
reţelelor de calculatoare. În acest caz, rolul nivelului legăturii de date va fi luat de
subreţea, iar rolul cadrului va fi jucat de pachet. În reţelele de calculatoare
transmiţând cu metoda datagramelor, pachetele circulă fără vreo ordine până la
destinatar - deci generalitatea algoritmului revine (întoare înapoi ) cu n se
dovedeşte foarte utilă.
p
Vom dovedi acum corectitudinea protocolului revine cu n şi în cazul
când SN şi RN sunt numere modulo m, cu m > n - dacă se păstrează condiţia ca,
pe linie, cadrele să circule în ordine.
Să analizăm, însă, mai întâi, cu atenţie, ordinea evenimentelor atunci când SN
şi RN sunt întregi nemărginiţi.
Fie transmisia unui cadru oarecare de la A spre B. Să presupunem că acest
cadru începe să fie generat la momentul t1 în A şi este recepţionat în B la
momentul t2 .

31
F e r e a s t r a
d e e m i [s i , i n e + i - 1 ]
S N S N
A
t1 t

t0 t2
B
R N i

F i g . 1 3

Numărul de ordine SN al cadrului transmis trebuie să aparţină ferestrei de

emisie curente, din momentul t1 , de la nodul A, adică
SN ∈ [SNmin (t1) , SNmin (t1) + n - 1] (1)
Valoarea i = SNmin (t1) trebuie să fie egală cu ultima valoare recepţionată a
RN, care este
i = RN (t0) ≤ RN (t2)
Rezultă
SNmin (t1) ≤ RN (t2) (α)
Reciproc, nici un cadru cu număr de ordine SNmin (t1) + n nu putea fi
transmis înainte de momentul t1 , căci această valoare depăşeşte limita superioară a
ferestrei de emisie. Întrucât cadrele circulă în ordine pe linie, nici un cadru cu acest
număr de ordine nu putea ajunge în B înainte de t2 . Rezultă că
RN (t2) ≤ SNmin (t1) + n (β)
Din (α ), (β ) ⇒
RN (t2) ∈ [SNmin (t1) , SNmin (t1) + n - 1] (2)
Din (1), (2) ⇒
RN( t 2 ) - SN ≤ n (3)

Să presupunem acum că, atunci când pachetul cu numărul SN este transmis,

numărul de ordine din cadrul aferent este construit modulo m.
Fie
sn = SN (mod m ) . (4)
Pasul 3 al algoritmului de la receptor (B) trebuie modificat astfel:
3’ - Dacă se primeşte un cadru nealterat de la A, conţinând numărul de
ordine sn dat de (4), livrează pachetul nivelului de reţea din B şi
incrementează RN.
Întrucât am admis că
m > n , (5)
din (3), (4), (5) ⇒
sn = RN (mod m ) ⇔ SN = RN . (6)

32
 Prin urmare, algoritmul lucrează corect.
Să analizăm acum ordinea confirmărilor (RN) aferente ferestrei de emisia din
A - utilizând numere întregi obişnuite (nemărginite).

F e r e a s t r a
d e e m i [s i , i n e + i - 1 ]

A
t2 t

t0 t1
B
R N i R N

F i g . 1 4

Se constată imediat că
RN ∈ [SNmin (t2) , SNmin (t2) + n] (7)

Să considerăm acum că RN este transmis modulo m şi fie

rn = RN (mod m ) . (8)
Atunci pasul 4 al algoritmului de la emisie (A) trebuie modificat astfel:
4’ - Dacă se primeşte un cadru fără eroare de la B, conţinând
r n ≠ SNmin (mod m) , (9)1
atunci incrementează SNmin până când
SNmin (mod m) = rn . (9)2
Din cauza domeniului lui RN din (7), se constată că noua regulă este
echivalentă cu cea veche, fiind suficientă pentru a putea transmite numerele de
ordine ale pachetelor cerute în tehnica modulo m. Se constată, însă, că nu este
necesară memorarea lui SNmin , SNmax şi RN, la A şi respectiv la B, ca numere
întregi obişnuite (nemărginite); lucrând modulo m, algoritmul va funcţiona corect
pentru m > n .
Iată, deci, algoritmul revine (întoarce) înapoi cu n în cazul numerotării
modulo m :
| La emiţător (nodul A):
1’ - Iniţializează snmin = snmax = 0
2’ - Repetă paşii 3’, 4’ şi 5’ în orice ordine. Pot exista întârzieri
arbitrare - dar limitate - între momentul când sunt satisfăcute
condiţiile pentru un pas şi momentul când pasul este executat.
3’ - Dacă
snmax - snmin (mod m ) < n
şi dacă este disponibil un pachet de la nivelul de reţea, acceptă un

33
 nou pachet în nivelul DLC, îi atribuie numărul de ordine snmax şi
incrementează snmax la (snmax + 1) (mod m) .
4’ - Dacă se primeşte un cadru fără eroare de la B, conţinând o
confirmare cu numărul de ordine aşteptat r n şi
(rn - snmin) (mod m ) ≤ (snmax - snmin) (mod m ) ,
atunci face
snmin = rn .
5’ - Dacă
snmin ≠ snmax
şi nu există nici un cadru aflat în curs de transmisie, se alege un
număr sn astfel încât
(sn - snmin) (mod m ) < (snmax - snmin) (mod m );
se transmite pachetul cu numărul de ordine sn într-un cadru,
punând valoarea lui sn în antetul lui, în câmpul rezervat numărului
de ordine de la emisie (“SN”). Se permite cel mult o întârziere
limitată între transmisiile la intervale succesive ale pachetului cu
snmin , dacă snmin nu se modifică.
‚ La receptor (nodul B):
1’ - Iniţializează r n = 0 şi repetă la nesfârşit paşii 2’ şi 3’.
2’ - Ori de câte ori se primeşte un cadru fără erori de la A, conţinând
sn = r n ,
livrează pachetul sosit nivelului de reţea şi incrementează r n la
(rn + 1) (mod m) .
3’ - La momente arbitrare, dar cu întârzieri limitate după primirea
oricărui cadru fără erori de la A, transmite un cadru către A,
conţinând r n în câmpul pentru numărul de ordine cerut (“RN”).
p
Vom analiza în continuare eficacitatea utilizării canalului de către algoritmul
întoarce (revine) cu n înapoi. Vom considera cazul ataşării confirmărilor la
cadrele cu date în sens invers, astfel încât vom ignora aceste confirmări. De
asemenea vom presupune, pentru simplitatea analizei, că timpul de prelucrare a
întreruperii este neglijabil, deci că τ reprezintă doar durata de propagare într-un
sens.
Precizăm că retransmisiile şi întârzierile cauzate de epuizarea pauzei de
aşteptare apar în algoritmul întoarce (revine) cu n înapoi din următoarele 3
motive:
1) Lărgimea ferestrei de emisie şi lungimea mai mare a cadrelor în sens
invers decât a celor în sens direct.
2) Erorile ce afectează cadrele cu date.
3) Erorile ca afectează cadrele de confirmare.
Le vom analiza pe rând.

34
 1 - A) Lărgimea ferestrei (w) de emisie. Distingem cazurile:
a) Fereastra este destul de largă astfel încât emiţătorul poate
transmite cu viteză maximă, întrucât confirmările sosesc înainte ca fereastra
de emisie să se umple.
Durata de transmisie a unui cadru este l /C , astfel încât emiţătorul
poate continua transmisia pe durata w l /C , dup` care trebuie să se oprească
dacă primul cadru nu a fost confirmat. Prima confirmare poate sosi la 2τ
dup` ce primul cadru a fost transmis, deci confirmarea ajunge la momentul l
/C + 2τ (am presupus că primul cadru se construieşte de la momentul t0 =
0). Emiţătorul va putea transmite permanent dacă
wl l
≥ + 2τ
C C
deci pentru o lărgime a ferestrei de emisie
2C τ
w ≥ 1+ .
l
Atunci
d
S = .
h+d
b) Dacă fereastra de emisie este îngustă, emiţătorul va trebui să se
oprească la un moment dat, aşteptând prima confirmare. Apoi va putea
transmite încă un cadru, aşteptând confirmarea lui, etc. Fiece ciclu consumă
un timp l /C + 2τ , servind w cadre (respectiv wd biţi de date). Rezultă că
wd
S= .
l + 2C τ
Aşadar, pentru
2C τ
w < 1+ ,
l
rezultă
d w
S= ⋅
h +d 2Cτ .
1+
h +d
1 - B) Probabilitatea retransmisiilor cauzate de cadrele lungi care circulă
în sens invers poate fi scăzută prin creşterea parametrului n . Din p`cate, valoarea
normală a modulului m în protocoalele standard este m = 8, ceea ce restrânge
valoarea numărului n la maximum 7.
Iată un exemplu în care - chiar pentru τ = 0 - cadrele care circulă în sens
invers, având o lungime de peste 3 ori mai mare ca a celor care circulă în sens
direct, pot cauza retransmisii pentru n = 7.

35
 S N 0 1 2 3 4 5 6 0
A
t

B
R N 0 0 3 6

F i g . 1 5

Se observă că confirmarea pentru pachetul 1 nu a ajuns la emiţător (A) până

în momentul când se termină transmisia pachetului 6, provocând astfel o
retransmisie a pachetului 0.
Se poate dovedi, de asemenea (recomandăm cititorului să o facă), că, dacă
lungimile cadrelor au o distribuţie exponenţială, aceeaşi pentru ambele sensuri,
atunci probabilitatea p ca un cadru să nu fie confirmat până în momentul
terminării ferestrei de emisie (adică înainte de a se transmite următoarele n - 1
cadre) este
p = (1 + n )⋅ 2 -n . (∗)
Ipoteza de mai sus este echivalentă cu următoarea situaţie: momentele t de
transmisie ale cadrelor au o distribuţie exponenţială, având, de exemplu, o densitate
de probabilitate
p (t ) = e -t (t ≥ 0) ,
la terminarea transmisiei unui cadru se începe transmisia următorului cadru (pentru
ambele sensuri), momentele de transmisie sunt independente, iar duratele de
prelucrare şi de propagare sunt neglijabile.
Se va observa (recomandăm cititorului să arate acest lucru) că mulţimea
momentelor la care se termină transmisiile cadrelor la ambele noduri constituie un
proces Poisson şi că un punct din acest proces este posibil cu probabilitate egală să
fie o terminare de transmisie la A sau la B, în condiţii de independenţă între
terminările succesive de cadre.
Pentru n = 7, din (∗) rezultă
1
p = .
16
Uzual, cadrele au o lungime maximă posibilă (dar, bineînţeles, şi o lungime
minimă, din cauza antetului şi a marcajului terminal), astfel încât, în practică, p
are o valoare ceva mai mică. Totuşi, uneori, linia transportă cadre mai lungi într-un
sens decât în celălalt sens şi, în acest caz, gradul de utilizare a liniei (eficienţa)
scade serios pentru n = 7. Când durata de propagare este mare în raport cu
lungimea cadrelor (ca la liniile de viteză mare şi la legăturlile prin satelit), această
scădere a eficacităţii de utilizare a liniei poate fi destul de importantă. Din fericire,
protocoalele standard au şi alternativa de alegere a modulul m = 128.

36
 3) Când apar erori la transmisia în sens invers (la confirmare), confirmarea
este amânată până la următorul cadru care circulă spre A. Această scădere a
eficacităţii de utilizare a liniei într-un sens din cauza erorilor în celălalt sens poate
fi evitată alegând lărgimea w a ferestrei de emisie (respectiv valoarea n) destul de
mare.
2) Să urmărim acum efectul erorilor asupra cadelor cu date. Dacă n este
destul de mare pentru a evita retransmisiile sau întârzierile cauzate de duratele lungi
de propagare şi de cadrele lungi sau de apariţia de erori în sensul opus şi dacă
nivelul DLC emiţător aşteaptă terminarea ferestrei pentru a putea retransmite, atunci
se vor retransmite multe pachete pentru fiecare eroare apărută la transmisia în sens
direct. Soluţia uzuală la această problemă o constituie utilizarea pauzelor de
aşteptare. În versiunea sa cea mai simplă, dacă un pachet nu este confirmat pe durata
unei anumite pauze de aşteptare ce urmează transmisiei, pachetul va fi retransmis.
Perioada de aşteptare trebuie aleasă destul de lungă pentru a include durata de
propagare dus-întors şi durata de prelucrare, plus durata de transmisie pentru două
pachete de lungime maximă în sensul invers (spre A) - unul pentru cadrul în tranzit,
când se recepţionează un pachet, şi unul pentru a transporta noul RN. O versiune
mai sofisticată este aceea în care nivelul DLC emiţător (când se cunosc duratele de
propagare şi de prelucrare) poate determina care cadru în sens invers va trebui să
poarte confirmarea pentru un anume pachet; el se întoarce înapoi dacă acest cadru
este fără eroare şi nu livrează confirmarea.
Creşterea eficacităţii de utilizare a liniei şi scăderea întârzierilor se pot obţine
efectuând întoarcerea înapoi rapid la apariţia unei erori în sensul direct, dar
evitând retransmisiile cauzate de cadre lungi şi erori în sensul invers. O posibilitate
o constituie aceea ca nivelul DLC receptor să transmită înapoi un cadru scurt de
supraveghere la recepţionarea unui cadru alterat, fapt ce permite emiţătorului să se
întoarcă înapoi mult mai devreme decât în cazul când RN ar fi ataşat la un cadru
mai lung în sens opus.

ã Metoda repetării selective [selective repeat]

Chiar dacă se elimină retransmisiile inutile, protocoalele de tip întoarce
înapoi (revine) cu n trebuie să retransmită cadre pe cel puţin durata unei
propagări dus-întors în situaţia apariţiei unei singure erori în pachetul aşteptat.
În multe situaţii, liniile fizice sunt fiabile, prezentând o probabilitate a erorilor
pentru un cadru transmis p ≤ 10 -4. În aceste cazuri, retransmisia unui număr mare
de pachete pentru fiecare cadru alterat are un efect mic asupra eficacităţii de utilizare
a liniei.
Să considerăm un protocol ideal de tip revine cu n, în care, de fiecare dată
când un cadru purtător al unui pachet aşteptat de nivelul DLC receptor este afectat
de erori, nivelul DLC emiţător va retransmite pachetele pe durata propagării dus-
întors. Fie γ numărul probabil de cadre transmise de la A spre B pentru un
pachet acceptat în B. Fie β numărul probabil de cadre transmise de la A spre B
într-un interval de propagare dus-întors - adică între transmisia unui anumit cadru şi
recepţionarea reacţiei privitoare la acel cadru (inclusiv cadrul aflat în transmisie când
soseşte reacţia). Fie p probabilitatea ca un cadru să ajungă în B cu erori
(considerând cadrele succesive drept independente). Să presupunem că A transmite

37
cadre incontinuu, că n este destul de mare pentru ca A să nu se întoarcă înapoi
în absenţa reacţiei şi că A se întoarce întotdeauna înapoi la următorul cadru, după
ce a aflat că, la recepţie, cadrul aşteptat a ajuns alterat.
Se poate arăta (invităm cititorul să demonstreze) că:
γ ≥ 1 + p (β + γ ) .
Se observă că eficacitatea utilizării liniei este:
1
S =
γ
deci
1- p
S ≤
1+ p β
Se constată că, pentru linii nefiabile (p de valori mari) sau linii de mare
viteză ori de legături prin satelit ( β de valori foarte mari), S va avea o valoare
mică - irosindu-se astfel lărgimea de bandă.
Pentru a remedia aceste neajunsuri se foloseşte o altă subclasă a
protocoalelor cu fereastră glisantă - repetarea selectivă [selective repeat].
La aceste protocoale, nivelul DLC receptor memorează toate cadrele corecte sosite
după un cadru eronat (sau pierdut). Când emiţătorul află că un cadru din fereastra de
emisie nu a ajuns corect la destinaţie, el va retransmite numai acel cadru (nu şi
succesoarele lui). Dacă retransmisia reuşeşte, nivelul DLC receptor va dispune
acum de o secvenţă de cadre corecte, în ordine, pe care le poate pasa rapid nivelului
său de reţea, confirmând numărul de ordine (cel mai mare) al ultimului pachet
recepţionat corect.
Deci, un astfel de protocol va accepta şi pachete care nu sunt la rând
(ordonate), dar au fost cerute să fie retransmise. Va existra, ca la protocolul revine
(întoarce înapoi) cu n, o fereastră de emisie de lărgime n, indicând cu cât o
poate lua înainte A cu transmisia pachetelor faţă de pachetul cu numărul de ordine
cel mai mic nerecepţionat încă corect în B. Dar fereastra de la recepţie va fi acum
mai largă decât 1. Orice cadru aparţinând acestei ferestre poate fi acceptat şi
memorat (în buffer) până când toate cadrele precedente şi-au descărcat pachetele în
nivelul de reţea receptor. Fereastra de emisie începe cu lărgimea 0 şi creşte până la
n ; fereastra de recepţie este de lărgime fixă, egală cu n.
Recepţionarea nesecvenţială a cadrelor ridică însă o problemă care nu apărea
la protocoalele în care cadrele erau acceptate doar în ordine. Să ilustrăm această
problemă printr-un exemplu:
Să presupunem că m = 3, deci n = 7.
Nodul A transmite cadrele cu pachetele cu numere de ordine de la 0 la 6.
Între timp, fereastra receptorului permite acceptarea oricărui cadru cu numărul
de ordine de la 0 la 6 (inclusiv). Dacă toate cele 7 cadre transmise ajung corect,
receptorul le va confirma şi îşi va glisa fereastra, permiţând recepţionarea cadrelor
cu numerele de ordine: 7, 0, 1, 2, 3, 4 sau 5. Toate cele 7 buffere sunt marcate
drept goale.
Să presupunem că toate confirmările sunt alterate. Emiţătorul îşi va termina
pauza de aşteptare şi va retransmite cadrul cu pachetul cu nr. 0. Când acest cadru
ajunge la receptor, el este verificat dacă aparţine ferestrei de recepţie. El va aparţine

38
noii ferestre, deci va fi acceptat. Receptorul va transmite (prin ataşare) confirmarea
pentru cadrul cu pachetul nr. 6 - întrucât au fost recepţionate pachetele 0 ÷ 6.
Emiţătorul va traduce situaţia ca o transmisie reuşită a cadrelor, avansând
fereastra de emisie şi transmiţând cadrele cu pachetele 7, 0, 1, 2, 3, 4 şi 5.
Cadrul cu SN = 7 va fi acceptat de receptor, pachetul din el fiind pasat nivelului de
reţea. Apoi, imediat, nivelul DLC receptor va verifica dacă are deja un cadru
corect cu pachetul cu numărul 0; va constata că îl are şi va pasa pachetul din acest
cadru nivelului său de reţea. Astfel, nivelul de reţea receptor va primi un pachet
incorect, deci protocolul va da greş.
Cauza care stă la baza acestei incorectitudini este faptul că, după ce receptorul
îşi avansează fereastra, noul interval de numere de ordine valide se suprapune cu cel
vechi. Următorul lot de cadre poate fi ori de dubluri (dacă toate confirmările s-au
pierdut) ori de cadre noi (dacă toate confirmările au fost recepţionate corect) şi
receptorul nu are cum să distingă aceste două situaţii.
Calea de rezolvare a acestei dileme constă în a ne asigura că, după ce
receptorul a avansat fereastra sa, nu există o suprapunere cu fereastra anterioară.
Pentru a fi siguri că nu există suprapunere, dimensiunea maximă a ferestrei va trebui
să fie egală cu cel puţin jumătate din valoarea lui m , adică
m ≥ 2n ; (∗ ∗ )
ţinând cont că
MAX_SEQ = m + 1
]i
w =n ,
se ia în practic`
MAX_ SEQ + 1
w = .
2
De exemplu, pentru m = 4, obţinem MAX_SEQ = 15 şi rezultă că doar
n = 8 cadre pot fi transmise într-o fereastră. Astfel, dacă receptorul a acceptat cadrele
0, ... , 7 şi avansează fereastra pentru a permite acceptarea cadrelor 8, ... , 15, el va
recunoaşte fără dubii dacă următoarele cadre sunt retransmisii (ale cadrelor 0, ... , 7)
sau cadre noi (8, ... , 12).
Acest rezultat se obţine şi din relaţiile (1) şi (2) de la analiza corectitudinii
protocolului întoarce înapoi (revine) cu n, deduse în ipoteza că un cadru generat
în A la t1 este recepţionat în B la t2 ; vom avea:
SN ∈ [RN(t2) - n , RN(t2) + n - 1] . (∗ ∗ ∗
Dacă numerele de ordine sunt construite modulo m şi pachetele )sunt
acceptate în fereastra [RN(t2) , RN(t2) + n - 1] , este necesar ca B să distingă
valorile lui SN în întreaga mulţime (∗ ∗ ∗ ). Rezultă de aici condiţia (∗ ∗ ).
Cu această schimbare, corectitudinea acestei clase de protocoale - de tip
repetare selectivă - se p`streaz`.
O problemă importantă pentru implementarea acestui tip de protocoale este
obţinerea unei eficacităţi maxime de utilizare a canalului.

39
 Se observă că, oricare ar fi protocolul cu fereastră glisantă utilizat, numai
cadrele sosite fără eroare în B pot livra pachetele nivelului de reţea receptor şi, deci,
numărul probabil de pachete livrate în medie lui B de un cadru trimis din A este
mărginit de
S≤ 1-p
(unde p este probabilitatea ca un cadru să ajungă alterat).
Un protocol ideal de tip repetare selectivă ar avea o viteză maximă de
transmisie egală cu 1 - p.
Să remarcăm, mai întâi, că utilizarea numai a RN pentru a furniza informaţii
de confirmare nu este prea eficientă, întrucât, dacă apar mai multe cadre eronate
într-un interval de propagare dus-întors, nodul A nu poate afla despre al 2-lea
cadru eronat până când nu trece un timp egal cu durata de propagare dus-întors
după retransmiterea primului cadru alterat.
Există mai multe modalităţi de a furniza informaţii suplimentare de confirmare
necesare lui A:
• o metodă este aceea ca B să trimită către A cel mai mic număr de
ordine de pachet nerecepţionat corect încă - număr de ordine care trebuie să fie mai
mare decât pβ (numărul probabil de cadre eronate în perioada de propagare dus-
întors), dar care este limitat de informaţia de control (antet) necesară şi pe reacţie;
• o altă posibilitate o constituie transmiterea RN plus k biţi
suplimentari (k = const.), fiece bit furnizând o ack/nack pentru fiecare din cele k
pachete ce urmează după cel cu numărul de ordine RN.
Să presupunem acum că reacţia (cadrele de confirmare) aduce în A suficientă
informaţie pentru ca emiţătorul să poată determina, după o aşteptare de β cadre,
dacă un pachet a fost sau nu recepţionat cu succes. Algoritmul tipic pentru A este,
deci, să repete transmisia pachetelor de îndată ce constată că transmisia lor
anterioară a fost afectată de erori; dacă A descoperă mai multe cadre eronate din
fereastra de emisie, el le va retransmite în ordinea numerelor de ordine ale pachetelor
ce le conţin. Când nu se solicită retransmisii, A continuă să transmită noi pachete,
până la cel cu numărul SMmax - 1. Când atinge această limită, A poate aştepta pe
durata unei anumite pauze de aşteptare fixate sau să se întoarcă imediat înapoi la
cadrul cu pachetul nr. SNmin , pentru a transmite pachetele neconfirmate.
Nodul A acţionează ca un sistem ideal de repetare selectivă până când este
forţat să aştepte sau să se întoarcă înapoi de la SMmax - 1. Când aceasta se
întâmplă, pachetul cu nr. SNmin trebuie să se fi transmis eronat de cca. n /β ori.
Deci, mărind suficient de mult n, probabilitatea unei întoarceri înapoi poate fi
redusă până la valori neglijabile. Dar valorile mari pentru n introduc 2 dificultăţi
(presupunând că pachetele trebuie reordonate la nivelul DLC receptor):
- trebuie asigurată la B o memorie pentru toate pachetele acceptate după cel
cu nr. RN;
- numărul mare de pachete stocate vor fi toate întârziate în aşteptarea celui cu
nr. RN.
p
Iată un program de simulare pentru un protocol de tip repetare selectivă
în care, pentru fiecare cadru transmis este asociat un ceas şi, la expirarea respectivei
pauze de aşteptare, se retransmite doar cadrul cu pachetul respectiv. Fereastra de

40
emisie începe co lărgimea 0 şi creşte până la dimensiunea predefinită MAX_SEQ ;
fereastra de recepţie are dimensiunea fixă MAX_SEQ. Receptorul are câte un buffer
rezervat pentru fiecare număr de ordine din fereastră, iar fiecărui buffer îi este asociat
un bit arrived (“sosit”) care indică dacă buffer-ul este plin sau gol; pentru fiecare
cadru sosit, o funcţie numită between (“în_fereastră”) verifică dacă numărul de
ordine aparţine ferestrei şi, dacă acest lucru este adevărat şi cadrul nu a fost încă
primit, îl acceptă şi îl stochează - indiferent dacă el conţine sau nu următorul pachet
aşteptat de nivelul de reţea receptor (fireşte, el va fi păstrat fără a fi livrat nivelului de
reţea, până când toate pachetele cu numerele de ordine precedente au fost livrate, în
ordinea corectă, nivelului de reţea).
/* Protocol Nonsequential receive */
#define MAX_SEQ 7 /* trebuie să fie 2ˆn = 1 */
#define NR_BUFS ((MAX_SEQ + 1)/2)
typedef enum {frame_arrival, cksum_err, timeout, network_layer_ready, ack_timeout}
event_type; /* evenimentele posibile */
#include “protocol.h”
boolean no_nak = true; /* nu s-a transmis încă nici o confirmare negativă */
static boolean between(seq_nr a, seq_nr b, seq_nr c)
{
/* asem\n\tor cu between din Protocolul Go back n, dar mai scurt */
return ((a <= b) && (b < c)) || ((c < a) && (a <= b)) || ((b < c) && c < a));
}
static void send_frame(frame_kind fk, seq_nr frame_nr, seq_nr frame_expected, packet buffer[ ])
{
/* construie[te [i trimite un cadru cu date de ack sau de nak */
frame s; /* variabilă temporară */
s.kind = fk; /* kind == data, ack sau nak */
if (fk == data) s.info - buffer[frame_nr % NR_BUFS];
s.seq = frame_nr; /* inserează numărul de ordine al pachetului în cadru */
s.ack = (frame_expected + MAX_SEQ) % (MAX_SEQ + 1); /* ataşează confirmarea */
if (fk == nak) no_nak = false; /* doar o nak pentru un cadru */
to_physical_layer(&s); /* transmite cadrul */
if (fk == data) start_timer(frame_nr % NR_BUFS);
/* porneşte ceasul pt. pauza de aşteptare */
stop_ack_timer(); /* nu este nevoie de un cadru separat de ack */
}
void selectrep(void)
{
seq_nr = ack_expected; /* limita inferioară a ferestrei emiţătorului */
seq_nr = next_frame_to_send; /* limita superioară a ferestrei emiţătorului + 1 */
seq_nr frame_expected; /* limita inferioară a ferestrei receptorului */
seq_nr too_far; /* limita superioară a ferestrei receptorului + 1 */
seq_nr oldest_frame; /* cărui cadru i-a expirat pauza de aşteptare ? */
int i; /* indice de buffer */
frame r; /* variabilă auxiliară */
packet out_buffer[NR_BUFS]; /* buffer pentru cadrele de la emisie */
packet in_buffer[NR_BUFS]; /* buffer pentru cadrele de la recepţie */
boolean arrived[NR_BUFS]; /* configuraţie de biţi asociată buffer-lor la recepţie */
seq_nr nbuffered; /* număr buffer-e utilizate la emiţător */
event_type event;
enable_network_layer(); /* permite evenimente networ_layer_ready */
ack_expected = 0; /* următoarea confirmare aşteptată */
next_frame_to_send = 0; (* numărul următorului cadru transmis */

41
 frame_expected = 0; /* numărul cadrului aşteptat să sosească */
too_far = NR_BUFS;
nbuffered = 0; /* iniţial, în buffer-e nu există nici un pachet */
for (i = 0; i < NR_BUFS; i++) arrived[i] = false;
wait_for_event(); /* cele 5 evenimente posibile - vezi event_type */
switch(event) {
case network_layer_ready: /* nivelul de reţea emiţător are un pachet de transmis */
/* accept\, salvează şi transmite un nou cadru */
nbuffered = nbuffered + 1; /* extinde fereastra de emisie */
from_network _layer(&out _buf[next_frame_to_send % NR_BUFS]); /* preia pachet */
send_frame(data, next_frame_to_send, frame_expected, out_buf); /* trimite cadru */
inc(next_frame_to_send); /* deplasează limita super. a ferestrei de emisie */
case frame_arrival: /* a sosit un cadru cu date sau de control */
from_physical_layer(&r); /* preia cadrul din biţii sosiţi la nivelul fizic */
if (r.kind == data) {
/* a sosit un cadru nealterat */
if ((r.seq != frame_expected) && no_nak)
send_frame(nak, 0, frame_expected, out_buf); else start _ack_timer();
if (between(frame_expected, r.seq, too_far) && (arrived[r.seq % NR_BUFS] == false)) {
/* cadrele pot fi acceptate în orice ordine */
arrived[r.seq % NR_BUFS] = true; /* marchează buffer-ul ca fiind plin */
in_buf[r.seq % NR_BUFS] = r.info; /* introduce datele în buffer */
while (arrived[frame_expected % NR_BUFS] {
/* predă cadrele şi avansează fereastra */
to_network_layer(&in_buf[frame_expected % NR_BUFS]);
no_nak = true;
arrived[frame_expected % NR_BUFS] = false;
inc(frame_expected); /* avansează limita infer. a ferestrei receptorului */
inc(too_far); /* avansează limita super. a ferestrei receptorului */
start_ack_timer(); /* stabileşte dacă e necesară o ack separat\ */
}
}
}

if ((r.kind == nak) && between(ack _expected, (r.ack+1)%(MAX _SEQ+1),

next_frame_to_send))
send_frame(data, (r.ack+1)%(MAX_SEQ+1), frame_expected, out_buf);
while (between(ack_expected, r.ack, next_frame_to_send)) {
/* tratează confirmarea ataşată */
nbuffered = nbuffered - 1; /* tratează ack ataşată */
stop_timer(ack _expected % NR_BUFS); /* cadru sosit nealterat: opreşte ceasul */
inc(ack_expected); /* avansează limita infer. a ferestrei de emisie */
}
case cksum_err:
if (no_nak) send_frame(nak, 0, frame_expected, out_buf); /* cadru eronat */
case timeout:
send_frame(data, oldest_frame, frame_expected, out_buf); /* a expirat pauza */
case ack_timeout:
send_frame(ack, 0, frame_expected, out_buf); /* a expirat timpul pt. ack; trimite ack */
}
if (nbuffered ( NR_BUFS) enable_network_layer(); else disable_network_layer;
}

42
 O problemă cu acest protocol o constituie numărul necesar de buffer-e de la
receptor. Este clar că receptorul nu va accepta nici o dată cadre cu număr de ordine
mai mic decât limita inferioară a ferestrei sau cu număr de ordine mai mare decât
limita superioară a ferestrei. Deci, numărul de buffer-e necesar este egal cu
dimensiunea ferestrei (nu cu intervalul de numere de ordine valide !).
De exemplu, pentru m = 4 sunt necesare 8 buffer-e (numerotate de la 0 la
7). Când soseşte cadrul i , el este depus în buffer-ul nr. i mod 8. Se va observa că,
deşi cadrele i şi (i + 8) mod 8 “concurează” pentru acelaşi buffer, ele nu se află
nici o dată simultan în aceeaşi fereastră (căci aceasta ar implica o lărgime a ferestrei
cel puţin egală cu 9).
Cantitatea necesară de memorie poate fi micşorată la n - β fără probleme,
întrucât, de fiecare dată când apare o întoarcere înapoi la SNmax - 1, nodul A nu
mai poate transmite noi pachete dincolo de SNmax - 1 pe durata unei perioade de
propagare dus-întors. Deci el ar putea, foarte bine, să retransmită pachetele încă
neconfirmate de la SNmax - β până la SNmax - 1. Aceasta înseamnă că B nu
trebuie să salveze aceste pachete.
Numărul necesar de contoare de timp este egal cu numărul de buffer-e (nu cu
intervalul de numere de ordine valide !). Există câte un contor de timp asociat fiecărui
buffer. Când timpul contorului expiră, se retransmite conţinutul buffer-ului.
Spre diferenţă de protocolul Go_back_n - la care, dacă traficul într-un sens
este mare iar în sens invers este inexistent, sunt trimise doar MAX_SEQ cadre,
după care protocolul se blochează - la protocolul Nonsequential receive acest
lucru nu se petrece. După sosirea unui cadru dintr-o secvenţă, este pornit un ceas
(contor de timp) auxiliar prin start_ack_timer. Dacă nu apare trafic în sens invers
până la expirarea timpului fixat la acest ceas, se va trimite un cadru de confirmare
separat. Întreruperea provocată de acest ceas auxiliar este evenimentul ack_timeout.
În acest fel, lipsa unui trafic în sens invers, la care să se ataşeze confirmările, nu mai
constituie un impediment. Este esenţial ca intervalul de timp fixat la acest contor
auxiliar să fie mult mai scurt decât cel al pauzei de aşteptare, asigurându-se asfel că o
confirmare pentru un cadru corect recepţionat soseşte înainte de retransmiterea
cadrului din cauza expirării pauzei de aşteptare.
Protocolul tip repetare selectivă (Nonsequential receive) utilizează o
strategie mai eficientă de tratare a erorilor decât protoculul tip revenire cu n
Go_back_n. Ori de câte ori receptorul constată o eroare, el trimite o confirmare
negativă (nak) către emiţător. Cadrul cu nak reprezintă o cerere de retransmitere a
cadrului cu date specificat în nak. Transmiterea unei nak se face în două situaţii:
când se primeşte un cadru alterat sau când soseşte un cadru fără eroare dar nu cel
aşteptat (posibil un cadru “pierdut”). Pentru a evita apariţia de cereri multiple de
retransmisie a aceluiaşi cadru “pierdut”, receptorul va ţine evidenţa dacă s-a transmis
deja o nak pentru un anumit cadru. Variabila no_nak are valoarea adevărat dacă
nu s-a trimis încă nici o nak pentru cadrul aşteptat (frame_expected ). Dacă nak
este alterată sau se pierde, nu este grav, întrucât emiţătorul îşi va termina pauza de
aşteptare şi va retransmite oricum cadrul care lipsea la recepţie. Dacă un cadru eronat
soseşte după ce o nak a fost transmisă şi pierdută, no_nak va lua valoarea
adevărat şi va porni contorul de timp auxiliar; la expirarea timpului acestuia, va fi
trimisă o ack pentru resincronizarea emiţătorului cu starea curentă a receptorului.

43
 În unele situaţii, intervalul de timp necesar pentru propagarea cadrului şi a
confirmării, plus cel pentru procesarea cadrelor cu date la receptor şi elaborarea
confirmării este (relativ) constant. Atunci, emiţătorul îşi poate regla pauza de
aşteptare astfel încât să fie cu puţin mai mare decât intervalul (probabil) normal
dintre momentul transmisiei cadrului şi cel al recepţionării confirmării sale. Dar
dacă acest interval de timp este puternic variabil, emiţătorul este pus în situaţia să
aleagă între două alternative: o pauză de aşteptare mică, riscând astfel retransmisii
inutile şi risipind lărgimea de bandă, sau o pauză de aşteptare mare, rămânând astfel
inactiv o bună bucată de timp după producerea unei erori de transmisie şi risipind şi
în acest caz lărgimea de bandă. Dacă traficul în sens invers este sporadic, durata până
la confirmare va fi neregulată - scurtă când există trafic în sens invers şi lungă în caz
contrar. Şi durata diferită de prelucrare de la receptor poate crea probleme în acest
sens. În general, atunci când abaterea standard a intervalului de timp până la
confirmare este mică în comparaţie cu intervalul însuşi, ceasul poate fi reglat pentru o
pauză de aşteptare scurtă şi nak nu sunt utile; în caz contrar, ceasul trebuie reglat
pentru o pauză de aşteptare mai mare, iar nak pot accelera în mod substanţial
retransmisia cadrelor alterate sau pierdute.
O problemă strâns legată de pauza de aşteptare şi de nak-uri este aceea de a
determina care anume cadru a provocat espirarea pauzei de aşteptare. În protoculu
tip revenire cu n (Go_back_n), acest cadru era întotdeauna confirmarea aşteptată
(ack_expected ), căci ea era mereu cel mai vechi cadru. În protocolul tip repetare
selectivă (Nonsequential receive) nu exist` o modalitate simplă de a determina
cadrul care a produs expirarea pauzei de aşteptare. Într-adevăr, să presupunem că au
fost transmise cadrele 0 ÷ 4, ceea ce înseamnă că lista cadrelor transmise şi
neconfirmate încă, în ordinea de la cel mai vechi la cel mai recent, este 0, 1, 2, 3, 4.
Să presupunem că: pauza de aşteptare pentru cadrul 0 s-a terminat, se transmite noul
cadru 5, pauzele de aşteptare pentru cadrele 1 şi 2 expiră şi este transmis noul
cadru 6. În acest moment, lista cadrelor transmise şi neconfirmate, de la cel mai vechi
la cel mai nou cadru, este: 3, 4, 0, 5, 1, 2, 6. Dacă se pierd toate confirmările,
pauzele de aşteptare aferente celor 7 cadre vor expira în această ordine.
Fără a ne ocupa de administrarea timpului (care ar îngreuna exemplificarea),
vom presupune că variabilei oldest_frame (cel mai vechi cadru) i se atribuie
valoarea pauzei de aşteptare astfel încât să indice care este cadrul care a provocat
expirarea pauzei de aşteptare.
p
Să analizăm acum eficacitatea utilizării canalului fizic de către protocolul
repetării selective.
În cazul unei ferestre largi, transmisia se face tot continuu, dar trebuie trimise
cadre suplimentare pentru a “corecta” cadrele eronate. Am văzut că numărul probabil
de transmisii pentru un cadru este
1
1- q
w
astfel încât, pentru a recepţiona w cadre fără eroare, trebuie transmise
1- q
cadre. Rezultă că:

44
 • pentru o fereastră largă şi erori de transmisie:
d
S= ⋅ (1 - q )
h+d
• pentru o fereastră îngustă şi erori de transmisie:
d w
S= ⋅ (1 - q ) ⋅
h+d 2Cτ
1+
h+d
S scăzând din cauza retransmisiilor.
Observaţie: În prezenţa erorilor, eficacitatea protocoalelor cu fereastră
glisantă este diferită, din cauza numărului diferit de cadre ce trebuie retransmise
după o eroare. Astfel, pentru protocolul cu întoarcere cu n înapoi vom avea:
• pentru o fereastră largă şi erori de transmisie:
d 1- q
S= ⋅
h + d 1 + q (w - 1)
ţinând cont că numărul maxim de cadre care pot fi transmise înainte de a
2C τ
primi o confirmare este 1 +
h +d

45
 • pentru o fereastră îngustă şi erori de transmisie:
d w (1 - q )
⋅ S=
h+d  2C τ 
1 +  [1 + q (w - 1)]
 h+d
căci trebuie retransmise w - 1 cadre de un număr de q (w - 1) ori,
2C τ
apărând pentru fiecare o întârziere egală cu 1 + .
h +d
În formulele pentru S, limita dintre ferestrele mari şi cele mici este
2C τ
. w = 1+
l
Timpul τ este timpul de propagare într-un singur sens pe canal, astfel încât,
produsul C ⋅ τ reprezintă numărul de biţi ce pot fi transmişi în acest timp, respectiv
numărul de biţi ce pot fi “conţinuţi” de cablu sau, încă, “lungimea” cablului
exprimată în biţi. Deci C τ /l este “lungimea” cablului exprimată în cadre. Aşadar,
w este cu 1 unitate mai mare decât numărul de cadre ce pot “umple” cablul în
ambele sensuri.
Dacă w este cel puţin cu o unitate mai mare decât numărul de cadre ce
încap în cablu, transmisia se poate desfăşura continuu (altfel zis: emiţătorul nu se va
bloca din cauza unei ferestre umplute în timpul necesar primului cadru să ajungă la
receptor şi să fie prelucrat acolo, plus timpul de propagare a confirmării).
Ultimul factor din expresia lui S pentru o fereastră îngustă reprezintă
raportul dintre lărgimea w a ferestrei şi lărgimea minimă a ferestrei necesare pentru
o transmisie continuă.
S S
1 , 0 1 , 0

0 , 8 0 , 8
h = 2 0 o c t e ţ i C
d = 8 0 o c t e ţ i l = 1
C = 3
l
0 , 6 f e r e a s t r ă 0 , 6
g lis a n t ă
(w = 7 )

0 , 4 0 , 4 C = 5
l

p a s - c u - p a s
0 , 2 (w = 1 ) 0 , 2 h = 2 0 o c t e ţ i
d = 8 0 o c t e ţ i

0 C 0 w
0 2 4 6 8 1 0l 0 2 4 6 8 1 0
a ) b )
F i g . 1 6

46
 Din fig. a) se constată că S scade rapid cu Cτ /l pentru protocolul pas-
cu-pas, întrucât majoritatea timpului este consumat pentru aşteptarea confirmărilor.
Din fig. b) se observă că S creşte odată cu w şi că, pentru orice w, S
este mai mic pentru un cablu lung decât pentru un cablu scurt.

Observaţii:
• pentru LAN cu C = 10 [Mbiţi/s] şi lungimea cablului de 1
[km] rezultă Cτ ≅ 50 biţi şi, deci, Cτ /l << 1;
• pentru o linie transcontinentală de C = 64 [kbiţi/s] şi lungimea
cablului de 3 000 [km] rezultă Cτ ≅ 960 biţi;
• pentru un canal de satelit cu C = 64 [kbiţi/s] şi τ = 270 [ms]
rezultă Cτ ≅ 17 280 biţi şi, pentru multe cadre, vom avea Cτ /l >> 1.

47