El algoritmo de retroceso exponencial binario evita colisiones de paquetes durante el acceso simultáneo al aleatorizar momentos en las estaciones que intentan acceder a los canales inalámbricos. Sin embargo, esta aleatorización no elimina por completo las colisiones de paquetes, lo que lleva a una reducción del rendimiento del sistema y a un mayor retraso y caída de paquetes. Además, el algoritmo BEB da como resultado un acceso injusto al canal entre las estaciones.
Una red ad hoc móvil es un grupo de Nodes inalámbricos que pueden organizarse dinámicamente en una topología arbitraria y temporal sin necesidad de una infraestructura preexistente para formar una red. El Node puede moverse dinámicamente mientras se comunica y hace que el Node sea incalculable. El Node puede abandonar rápidamente la red de topología .
Por lo general, esta red se usa en aplicaciones tales como operaciones de emergencia , control ambiental y aplicaciones militares donde no hay administración o soporte de infraestructura de red centralizada , como enrutadores o estaciones base. En el estándar IEEE 802.11 , el algoritmo de función de coordinación distribuida (DCF) es un algoritmo fundamental y eficiente que garantiza la mejor compatibilidad de MANET con los desafíos de topología en evolución. Basado en el protocolo de acceso múltiple con detección de operador con prevención de colisiones (CSMA/CA), el DCF comparte el acceso al medio, que sigue el principio básico de “escuchar antes de hablar”. El algoritmo BEB se emplea en DCF. Después de la colisión, el Node que desea retransmitir espera una cantidad de tiempo aleatoria que se conoce como tiempo de retroceso. Aquí, el Node que tiene un BT pequeño accederá primero al medio en relación con el Node con el BT más alto.
Función de coordinación distribuida :
Esta función se utiliza para evitar colisiones mediante tramas de reconocimiento CSMA/CA y RTS/CTS . En el momento de la transmisión, el remitente espera el tiempo DIFS (Distributed Coordination Function Interframe Spacing) . Si el canal está inactivo, envía la trama de datos, es decir, la trama RTS ACK mientras el receptor espera la cantidad de tiempo SIFS (Short Inter-Frame Spacing) y luego envía la recepción de la trama CTS al remitente. Si el canal está ocupado, la estación espera el canal hasta que se detecta inactivo durante un tiempo DIFS. En este punto, genera BT aleatorio para enviar la trama de datos.
Algoritmo de retroceso exponencial binario :
Tras una transmisión de datos exitosa, se invoca la función CW() para ajustar el CW a CWmin. Durante las colisiones de datos, el Node invoca la función Double CW() para duplicar el CW hasta que sea igual o mayor que CWmax.
Si el Node intenta enviar datos sin éxito siete veces, también se invoca la función CW() para ajustar CW a CWmin debido a que los aumentos de retraso y caída de paquetes también reducen la probabilidad de retransmisión de las tramas de datos. Además, se produce el problema de la equidad.
Problema de equidad :
Si el tiempo de retroceso de un supuesto Node A es bajo en comparación con el Node B , entonces el Node A llegará a cero primero y restablecerá la ventana de contención al mínimo, por lo que el primer Node transmite y tiene una mayor probabilidad de transmitir su Node una y otra vez. .
Considere un archivo “aaa.txt” . En este archivo, genere los 0 y los 1 . Aquí, los 0 significan sin éxito y los 1 significan éxito. A continuación se muestra el archivo de texto:
1010011000100011
A continuación se muestra la implementación del enfoque anterior:
C
// C program for the above approach
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
// Driver Code
int main()
{
// Slot time
float slot_time = 0.00000166;
int CWmin = 32, CWmax = 1024;
int k;
int i, Curr_BW = 32, counter = 0;
float BT, Total_Backoff_time = 0;
FILE* fp;
char* f_name = "aaa.txt";
char ch;
int x = 0, y = 0;
fp = fopen(f_name, "r+");
// Open File
if (fp == NULL) {
printf("%s does not exists"
" \n",
f_name);
return 0;
}
// Otherwise
else {
printf("%s: opened in read"
" mode.\n\n",
f_name);
}
// Read characters from the file
while ((ch = fgetc(fp)) != EOF) {
// End-of-file is reached
if (ch == '1' || ch == '0') {
printf("frame %c \n ", ch);
}
// If the character is 1
if (ch == '1') {
x = x + 1;
printf("successful "
"Transmission\n");
Curr_BW = CWmin;
printf("the current "
"window is : %d\n",
Curr_BW);
BT = Curr_BW * slot_time;
printf(" =>the backoff"
" time is : %0.8f"
" \n",
BT);
counter = 0;
}
// If the character is 0
else if (ch == '0') {
y = y + 1;
if (counter < 7) {
printf("UNsuccessful "
"Transmission\n");
Curr_BW = Curr_BW * 2;
if (Curr_BW > CWmax) {
Curr_BW = CWmax;
}
printf("the current "
"window is :"
" %d\n",
Curr_BW);
counter = counter + 1;
printf("counter is :"
" %d \n ",
counter);
BT = Curr_BW * slot_time;
printf(" =>the backoff"
" time is : %0.8f"
" \n",
BT);
}
// Otherwise
else {
Curr_BW = CWmin;
printf("the current"
" window is :"
" %d\n",
Curr_BW);
BT = Curr_BW * slot_time;
printf(" =>the backoff"
" time is : %0.8f"
" \n",
BT);
}
}
if (ch == '1' || ch == '0') {
// Find the Backoff Time
Total_Backoff_time = Total_Backoff_time + BT;
printf("\n");
// Print the time
printf("=> Total Back_off"
" time for frame is : "
" %0.8f \n ",
Total_Backoff_time);
printf("\n\n");
}
}
// Print the success and
// unsuccess number
printf(" success num : %d\n", x);
printf(" unsuccess num : %d\n", y);
return 0;
}
Fichero de entrada:
1010011000100011
Producción:
Algoritmo de retroceso exponencial binario refinado y mejorado :
Este algoritmo (también conocido como I-BEB en este artículo) tiene como objetivo resolver el problema de equidad entre los Nodes mientras transmite hasta el punto y reduce el retraso del paquete en comparación con BEB.
Después de la transmisión exitosa por 12ª vez, el contador se establece en 1 y la ventana de contención aumenta exponencialmente. Aún así, I-BEB no resuelve mucho el problema de equidad. Aquí, en este algoritmo, se utiliza el valor de umbral porque puede haber un escenario en el que el número de estaciones activas aumente y aumenten las posibilidades de una colisión. Cuando CW es menor que el umbral, iguala el tamaño de su ventana de contención al umbral para aumentar la probabilidad de transmisión exitosa
C = 12, D = 4, E = 8 y G = 0,125 * CWmin
CWmin = 32 y CWmax = 1024donde,
C => Tiempos de envío exitosos
D => Reducir rápidamente el CW
E => Aumentar linealmente el CW
G => Cantidad de umbral
CW => El tamaño mínimo de la ventana de contención
BT => Tiempo de retroceso
A continuación se muestra la implementación del enfoque anterior:
C
// C program for the above approach
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
// Driver Code
int main()
{
int C = 12, D = 4, E = 8;
int counter = 0;
// Slot time
double slot_time = 0.00000166,
CW;
int CWmax = 1024, CWmin = 32;
double BT, G,
Total_Backoff_time = 0;
// C => successful sending times
// D => Quickly decrease the CW
// E => linearly inc the CW
// G => Threshold quantity
// CW => Minimum Contention Window Size
// BT => Backoff time
// Enter the current BW
printf("Enter the Curr_BW (CW)"
" by user : ");
scanf("%lf", &CW);
FILE* fp;
char* f_name = "aaa.txt";
char ch;
// Open the file
fp = fopen(f_name, "r+");
// If file doesn't exists
if (fp == NULL) {
printf("%s does not exists"
" \n",
f_name);
return 0;
}
// Otherwise
else {
printf("%s: opened in read"
" mode.\n\n",
f_name);
}
// Read character by characters
while ((ch = fgetc(fp)) != EOF) {
// End-of-file
if (ch == '0' || ch == '1') {
printf("frame %c \n ", ch);
}
if (ch == '1' || ch == '0') {
if (counter < C) {
// Print the counter
// value
counter = counter + 1;
printf("counter value"
" is : %d\n ",
counter);
CW = CW / D;
printf(" The CW is :"
" %0.8f\n",
CW);
G = 0.125 * CW;
printf("Value of G "
"[Threshold Quantity]"
" is : %0.8f\n",
G);
if (CW < G) {
CW = G;
BT = CW * slot_time;
printf(
" => The"
" Backoff Time"
" is : %0.8f\n",
BT);
}
else {
BT = CW * slot_time;
printf(
" => The "
"Backoff Time"
" is : %0.8f\n",
BT);
}
}
else {
counter = 1;
CW = CW + (E * CWmin);
printf(" The CW is :"
" %lf\n",
CW);
if (CW > CWmax) {
CW = CWmax;
BT = CW * slot_time;
printf(
" => The "
"Backoff Time"
" is : %0.8f\n",
BT);
}
else {
BT = CW * slot_time;
printf(
" => The "
"Backoff Time"
" is : %0.8f\n",
BT);
}
}
}
if (ch == '1' || ch == '0') {
// Find the Backoff time
Total_Backoff_time = Total_Backoff_time + BT;
printf("\n");
// Print the Back Off Time
printf("=> Total Back_off"
" time for frame is : "
" %0.8f \n ",
Total_Backoff_time);
printf("\n\n");
}
}
}
Fichero de entrada:
1010011000100011
Producción:
Publicación traducida automáticamente
Artículo escrito por kushagrabansal8755 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA