El algoritmo abusón es un método, dentro de la computación distribuida, para la elección dinámica de un coordinador según el ID de los procesos. El proceso con el ID mayor será seleccionado como el coordinador del sistema distribuido.

1. ESCUELA ACADÉMICO PROFESIONAL ALGORITMOS DISTRIBUIDOS
INGENIERÍA INFORMÁTICA Y SISTEMAS
UNIVERSIDAD NACIONAL MICAELA BASTIDAS DE APURÍMAC
FACULTAD DE INGENIERÍA
ESCUELA ACADÉMICO PROFESIONAL DE INGENIERÍA INFORMÁTICA Y
SISTEMAS
“ALGORITMOS DISTRIBUIDOS”
Asignatura: Sistemas Distribuidos
Tema: Algoritmos Distribuidos
Autor: Rojas Gonzales Nelson
Año: 2018
Semestre: II
ABANCAY – APURÍMAC
PERÚ

2. INDICE
1 Algoritmos de elección .............................................................................................................2
1.1 Algoritmo Bully o Abusón ................................................................................................2
1.1.1 Tipos de mensaje........................................................................................................2
1.1.2 Características ............................................................................................................2
1.1.3 Implementación..........................................................................................................3
1.1.4 Código fuente en C++ - Algoritmo distribuido Bully................................................3
1.2 Algoritmo del anillo...........................................................................................................4
1.3 Implementación .................................................................................................................5
1.3.1 Código fuente en C++ - Algoritmo distribuido Anillo...............................................5
1.4 Algoritmo Bizantino en C++.............................................................................................7
1.5 Algoritmo Bizantino en C#................................................................................................9
1.6 Algoritmo Ronda en C#...................................................................................................13

3. 1 Algoritmos de elección
Muchas aplicaciones y servicios distribuidos se basan en la existencia de un proceso diferenciado
que coordina el trabajo de un conjunto de procesos. Por ejemplo, acabamos de ver que el
algoritmo centralizado para exclusión mutua distribuida requiere un proceso coordinador. En todas
estas situaciones se requiere detectar que el proceso coordinador falla y elegir un nuevo proceso
que asuma el papel de coordinador. La elección requiere el acuerdo sobre quién va a ser el nuevo
y único coordinador. De nuevo, las decisiones se basan en la existencia de plazos para la recepción
de los mensajes de respuesta.
Por otra parte, para determinar el criterio de elección de un proceso como coordinador se requiere
definir un orden total entre el conjunto de procesos. Supondremos que los procesos tienen
asociados identificadores únicos según los cuales pueden ordenarse.
1.1 Algoritmo Bully o Abusón
El algoritmo abusón es un método, dentro de la computación distribuida, para la elección dinámica
de un coordinador según el ID de los procesos. El proceso con el ID mayor será seleccionado como
el coordinador del sistema distribuido.
Premisas
• El sistema es síncrono y utiliza tiempo de espera para la identificación de fallos en los
procesos.
• Se permite que los procesos se bloqueen/caigan durante la ejecución del algoritmo.
• La entrega de mensajes entre procesos se supone fiable.
• Los IDs de los procesos deben ser conocidos.
1.1.1 Tipos de mensaje
➢ Mensaje de Elección: Enviados para comunicar que se va a seleccionar un nuevo
coordinador.
➢ Mensaje de Respuesta: Encargados de responder al mensaje de elección.
➢ Mensaje de Coordinador: Enviado para comunicar el ID del proceso seleccionado.
1.1.2 Características
➢ Cumple la Pervivencia del sistema distribuido, ya que todos los procesos conocen el ID del
coordinador al finalizar el proceso de elección.
➢ Presenta algunos problemas de Seguridad del sistema distribuido:
➢ Si se cae el proceso P (coordinador), pero se recupera al mismo tiempo que otro
proceso Q decide ser el coordinador, algún proceso puede recibir dos mensajes coordinador
con distintos IDs.

4. ➢ Los valores de los tiempos de espera son imprecisos (el sistema no es síncrono).
1.1.3 Implementación
1.1.4 Código fuente en C++ - Algoritmo distribuido Bully
______________________________________________________________________________
#include <iostream>
#include<cstdlib>
using namespace std;
void funcion();
void elim();
int n, a[4];
int main(int argc, char *argv[]) {
system("color 0e");
int aux,d;
cout<<"--------------------------------------"<<endl;
cout<<"========= ALGORITMO DISTRIBUIDO BULLY ========="<<endl;
cout<<"--------------------------------------------"<<endl;
cout<<"INGRESE LA CANTIDAD DE NODOS Y SU VALOR: ";
cin>>n;
for(int i=1;i<=n;i++){
cout<<"nodo "<< i<<": ";
cin>>a[i];
}
for (int i=1;i<=n;i++) {
for (int j=i+1;j<=n;j++) {
if (a[i]>a[j]) {
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
}
}
cout<<"__________________________________________"<<endl<<endl;
funcion();
do{
cout<<"Ingrese [0] para simular la falla de la maquina principal :";
cin>>d;
switch(d){
case 0: elim();
break;
}
}while(n!=0);
return 0;
}
void elim(){
n=n-1;
cout<<"LLAMA A ELECCIONES EL NODO ["<<a[n-2]<<"]"<<endl;
cout<<a[n-2]<<" eleccion"<<a[n-1]<<endl;
cout<<a[n-2]<<" eleccion"<<a[n]<<endl;
cout<<a[n-2]<<" eleccion"<<a[n+1]<<endl;
cout<<a[n-1]<<" OK "<<a[n-2]<<endl;

5. cout<<a[n]<<" OK "<<a[n-2]<<endl;
funcion();
}
void funcion(){
cout<<"________________________________________"<<endl<<endl;
cout<<"los nodos en funcionamiento: ";
for (int i=1;i<=n;i++) {
cout<<"["<<a[i]<<"] ";
}
cout<<endl;
cout<<"Toma el control el nodo ["<<a[n]<<"]"<<endl;
cout<<"*****************************************"<<endl;
}
______________________________________________________________________________
1.2 Algoritmo del anillo
➢ Sistema síncrono [Chang & Roberts79]. Cada proceso tiene un canal con el siguiente
proceso en el anillo. Los mensajes circulan en sentido de las agujas del reloj.
➢ El proceso que inicia el algoritmo se marca como participante y envía su identificador en
un mensaje de elección a su vecino.
➢ Cuando un proceso recibe un mensaje de elección compara el identificador recibido con el
suyo.
• Si es menor el recibido y el proceso no es un participante, sustituye el identificador en
el mensaje por el suyo y lo reenvía al vecino y se marca como participante.
• Si es mayor el recibido, reenvía el mensaje y se marca como participante.
• Si es menor el recibido y el proceso es un participante, no hace nada (no envía ningún
mensaje).
• Si el identificador coincide con el del proceso, ese proceso es el líder.
• El líder se marca como no participante y envía un mensaje elegido al siguiente proceso.

6. • Cuando un proceso distinto al líder recibe este mensaje, anota qué proceso es el líder y
reenvía el mensaje.
A tomar muy encuentra en la implementación: Cuando un proceso Pi sospecha que el coordinador
falla, envía a su sucesor P(i+1) mod N un mensaje de elección que contiene el identificador de Pi.
Si Pi+1 no responde (ACK), Pi repite el envío a Pi+2y así hasta que encuentra un proceso que
confirma la recepción.
1.3 Implementación
1.3.1 Código fuente en C++ - Algoritmo distribuido Anillo
______________________________________________________________________________
#include <iostream>
using namespace std;
void funcionando();
void elim();
int n, a[20];
int indice;
int main(int argc, char *argv[]) {
system("color 3f");
int d;
cout<<"------------------------------------------------"<<endl;
cout<<"======== ALGORITMO DISTRIBUIDO - ANILLO ========"<<endl;
cout<<"------------------------------------------------"<<endl;
cout<<"INGRESE CANTIDAD DE NODOS Y SU VALOR: ";
cin>>n;
for(int i=1;i<=n;i++){
cout<<"nodo "<< i <<": ";
cin>>a[i];
}
cout<<"_______________________________________________________"<<endl;
funcionando();
do{

7. cout<<"INGRESE [0] PARA SIMULAR LA FALLA DEL NODO PRINCIPAL :";
cin>>d;
switch(d){
case 0: elim();
break;
}
}while(n!=0);
return 0;
}
void elim(){
//eliminando nodo fallido
int mayor =0;
n=n-1;
//falla
for(int i=1;i<=n;i++)
{
if(indice<=i)
{
a[i]=a[i+1];
}
}
//proceso de seleccion
string cadena ="";
n=n-1;
cout<<"LLAMA A ELECCIONES EL NODO "<<a[1]<<endl;
for(int i=1;i<=n;i++)
{
cadena = cadena +" "+ to_string(a[i]);
cout<<"nodo "<<a[i]<<" envia mensaje ["<<cadena<<" ] --->
"<<a[i+1]<<endl;
}
cadena = cadena + " "+to_string(a[n+1]);
cout<<"nodo "<<a[n+1]<<" envia mensaje ["<<cadena<<" ] --->
"<<a[1]<<endl<<endl;
n++;
//analiza mayor
for (int i=1;i<=n;i++) {
if (a[i] > mayor) {
mayor = a[i];
}
}
cout<<"NUEVO COORDINADOR "<<endl<<endl;
for(int i=1;i<=n;i++)
{
cout<<"nodo "<<a[1]<<" envia mensaje ["<<mayor<<" ] --->
"<<a[i+1]<<endl;
}
funcionando();
}
void funcionando(){
int mayor = 0;
cout<<"NODOS EN FUNCIONAMIENTO: ";

8. for (int i=1;i<=n;i++) {
cout<<"["<<a[i]<<"] ";
}
//analiza el mayor
cout<<""<<endl;
for (int i=1;i<=n;i++) {
if (a[i] > mayor) {
mayor = a[i];
indice = i;
}
}
cout<<"Toma el control el nodo ["<<a[indice]<<"]"<<endl;
cout<<"________________________________________________"<<endl;
}
______________________________________________________________________________
1.4 Algoritmo Bizantino en C++
______________________________________________________________________________
#include <iostream>
using namespace std;
void viz();
void elim();
int n;
char a[5][5];
int count=1;
int main(int argc, char *argv[]) {
int aux,d;
cout<<"ingrese el numero de nodos"<<endl;
cin>>n;
for(int i=1;i<=n;i++){
for(int j=1;j<=n-1;j++){
cout<<"nodo : " <<i<<" = ";
cin>>a[i][j];
}
}
cout<<"-------------------------------------------------------"<<endl;
for(int i=1;i<=n;i++){
cout<<"la informcaion enviada de : "<<i<<" son :";
for(int j=1;j<=n-1;j++){
cout<<a[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;

9. cout<<"-------------------------------------------------------"<<endl;
cout<<endl;
for(int i=2;i<=n;i++){
cout<<"la : "<<i<<" son :";
cout<<a[1][i-1]<<" ";
cout<<endl;
}
cout<<endl;
cout<<"-------------------------------------------------------"<<endl;
cout<<endl;
for(int i=1;i<=n;i++){
cout<<"la : "<<i<<" son :";
if(i==1){
cout<<"la : "<<i<<" son :";
cout<<a[2][i]<<" ";
}else{
if(i==2){
cout<<"la : "<<i<<" son :"<<a[2][i]<<" "<<a[3][1];;
}else{
cout<<"la : "<<i<<" son :"<<a[3][1];;
}
}
cout<<endl;
}
cout<<endl;
cout<<"-------------------------------------------------------"<<endl;
cout<<endl;
for(int i=1;i<=n;i++){
cout<<"la : "<<i<<" son :";
int h=1;
cout<<a[i][1]<<" ";
for(int j=1;j<=n-1;j++){
if(i==1){
cout<<a[j+1][i]<<" ";
}else{
if(i==2){
cout<<a[h][j]<<" ";
h=3;
}else{
if(i==3){
cout<<a[j][2]<<" ";
}
}
}
}
cout<<endl;
}
if(a[1][1]==a[2][1] || a[1][1]==a[3][1] || a[3][1]==a[2][2]){
if(a[1][1]==a[2][1] || a[1][1]==a[3][1]){
cout<<" e....... "<<a[1][1]<<endl;
}else{
if(a[3][1]==a[2][2]){

10. cout<<" e....... "<<a[3][1]<<endl;
}
}
}
if(a[2][1]==a[1][1] || a[2][1]==a[3][2] || a[3][2]==a[1][1]){
if(a[2][1]==a[1][1] || a[2][1]==a[3][2]){
cout<<" e....... "<<a[2][1]<<endl;
}else{
if(a[3][2]==a[1][1]){
cout<<" e....... "<<a[1][1]<<endl;
}
}
}
if(a[3][1]==a[1][2] || a[3][1]==a[2][2] || a[1][2]==a[2][2]){
if(a[3][1]==a[1][2] & a[3][1]==a[2][2]){
cout<<" e....... "<<a[1][1]<<endl;
}else{
if( a[1][2]==a[2][2]){
cout<<" e....... "<<a[1][2]<<endl;
}
}
}
cin>>n;
return 0;
}
______________________________________________________________________________
1.5 Algoritmo Bizantino en C#
______________________________________________________________________________
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AlgoritmoBizantino
{
class Program
{
static void Main(string[] args)
{
int[] Nodo = new int[3];
string[] plan = new string[6];
string[] vualta1 = new string[3];
string[] vualta2 = new string[3];
string[] vuelta3 = new string[3];
//****************************************************************************
*
Console.WriteLine("MOSTRANDO LOS 3 NODOS");
for (int i = 0; i < 3; i++)

11. {
Console.WriteLine("Nodo " + i + " = ");
Nodo[i] = Convert.ToInt32(Console.ReadLine());
}
Console.WriteLine("MOSTRANDO LOS 6 FLUJOS DE CONEXION");
/*for (int j = 0; j < 6; j++)
{
Console.WriteLine("Plan " + j + " = ");
plan[j] = Console.ReadLine();
}*/
plan[0] = "A";
plan[1] = "-";
plan[2] = "A";
plan[3] = "A";
plan[4] = "R";
plan[5] = "R";
for (int j = 0; j < 6; j++)
{
Console.WriteLine("Plan " + j + " = " + plan[j]);
}
//**************************************************************************
Console.WriteLine("El Nodo Que falla es: ");
int falla = int.Parse(Console.ReadLine());
for (int i = 0; i < 3; i++)
{
if (falla == i)
{
Console.WriteLine(Nodo[falla]);
break;
}
}
//************************************************************************
for (int i = 0; i < 6; i++)
{
if (i < 2)
{
Console.WriteLine(Nodo[0] + "______" + plan[i] + "______>"
+ Nodo[i + 1]);
}
else if (i < 4)
{
if (i == 2)
{
Console.WriteLine(Nodo[1] + "______" + plan[i] +
"______>" + Nodo[i - 2]);
}
else if (i == 3)
{
Console.WriteLine(Nodo[1] + "______" + plan[i] +
"______>" + Nodo[i - 1]);
}

12. }
else if (i < 6)
{
if (i == 4)
{
Console.WriteLine(Nodo[2] + "______" + plan[i] +
"______>" + Nodo[i - 4]);
}
else if (i == 5)
{
Console.WriteLine(Nodo[2] + "______" + plan[i] +
"______>" + Nodo[i - 4]);
}
}
}
//****************************************************************************
int cont = 0,cont1 = 0;
string vuelta = null;
Console.WriteLine("SOLO PARA NODO 1");
for (int i = 0; i < 3; i++)
{
if (Nodo[i] == 1)
{
vuelta = plan[(i + 1) * 2 - 1] ;
vualta1[i] = " ";
vualta2[i] = plan[i];
if (plan[i] == "A" )
{
vuelta3[i] = plan[i];
}
else if (vualta2[i] == "A")
{
vuelta3[i] = vualta2[i];
}
}
else if (Nodo[i] == 2)
{
vuelta = plan[((i + 1) * 2) - 1];
vualta1[i] = " ";
vualta2[i] = " ";
if (vuelta == "A")
{
vuelta3[i] = vuelta;
}
}
else if (Nodo[i] == 3)
{
vuelta = plan[(i + 1) * 2 - 1];
vualta1[i] = plan[1];
vualta2[i] = " ";
if (vuelta == "R")
{
vuelta3[i] = vuelta;

13. }
else if (vualta1[i] == "R")
{
vuelta3[i] = vualta1[i];
}
}
Console.Write(Nodo[1] + "t" + vuelta+ "t " + vualta1[i] +
"t " + vualta2[i] + "t " + vuelta3[i]);
if (plan[i] == "A")
{
cont++;
}
Console.WriteLine(" ");
}
if (cont > 1)
{
Console.WriteLine("=====================================");
Console.WriteLine("tttt A");
}
else
{
Console.WriteLine("ttttt R");
}
//****************************************************************************
*
Console.WriteLine("SOLO PARA NODO 2");
for (int i = 0; i < 3; i++)
{
if (Nodo[i] == 1)
{
vuelta = plan[i * 2];
vualta1[i] = " ";
vualta2[i] = plan[1];
if (vuelta == "A")
{
vuelta3[i] = vuelta;
}
else if (vualta2[i] == "A")
{
vuelta3[i] = vualta2[i];
}
}
else if (Nodo[i] == 2)
{
vuelta = plan[i * 2];
vualta1[i] = plan[1];
vualta2[i] = " ";
if (vuelta == "A")
{
vuelta3[i] = vuelta;
}
else if (vualta2[i] == "A")
{

14. vuelta3[i] = vualta2[i];
}
}
else if (Nodo[i] == 3)
{
vuelta = plan[i * 2];
vualta1[i] = " ";
vualta2[i] = " ";
if (vuelta == "A")
{
vuelta3[i] = plan[i];
}
}
Console.Write(Nodo[2] + "t" + vuelta + "t " + vualta1[i] +
"t " + vualta2[i] + "t " + vuelta3[i]);
if (plan[i] == "A")
{
cont++;
}
Console.WriteLine(" ");
}
if (cont > 1)
{
Console.WriteLine("=====================================");
Console.WriteLine("tttt A");
}
else
{
Console.WriteLine("ttttt R");
}
Console.ReadLine();
}
}
}
______________________________________________________________________________
1.6 Algoritmo Ronda en C#
______________________________________________________________________________
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AlgoritmoRonda
{
class Program
{
static void Main(string[] args)
{
int [] Nodo = new int[3];
string [] plan = new string[6];

15. //****************************************************************************
*
Console.WriteLine("MOSTRANDO LOS 3 NODOS");
for (int i = 0; i < 3; i++)
{
Console.WriteLine("Nodo " + i + " = ");
Nodo[i] = Convert.ToInt32( Console.ReadLine());
}
Console.WriteLine("MOSTRANDO LOS 6 FLUJOS DE CONEXION");
plan[0] = "A";
plan[1] = "-";
plan[2] = "A";
plan[3] = "A";
plan[4] = "R";
plan[5] = "R";
for (int j = 0; j < 6; j++)
{
Console.WriteLine("Plan " + j + " = " + plan[j]);
}
//**************************************************************************
Console.WriteLine();
Console.WriteLine("El Nodo Que falla es: ");
int falla = int.Parse(Console.ReadLine());
for (int i = 0; i < 3; i++)
{
if (falla == i)
{
Console.WriteLine(Nodo[falla]);
break;
}
}
//************************************************************************
for (int i = 0; i < 6; i++)
{
if (i < 2)
{
Console.WriteLine(Nodo[0] + "______" + plan[i] + "______>"
+ Nodo[i + 1]);
}
else if (i < 4)
{
if (i == 2)
{
Console.WriteLine(Nodo[1] + "______" + plan[i] +
"______>" + Nodo[i - 2]);
}
else if (i == 3)
{

16. Console.WriteLine(Nodo[1] + "______" + plan[i] +
"______>" + Nodo[i - 1]);
}
}
else if (i < 6)
{
if (i == 4)
{
Console.WriteLine(Nodo[2] + "______" + plan[i] +
"______>" + Nodo[i - 4]);
}
else if (i == 5)
{
Console.WriteLine(Nodo[2] + "______" + plan[i] +
"______>" + Nodo[i - 4]);
}
}
}
//****************************************************************************
**
int cont = 0,cont1 = 0;
for (int i = 0; i < 6; i++)
{
if (i % 2 == 0)
{
Console.Write(Nodo[1] + " " + plan[i]);
if (plan[i] == "A")
{
cont++;
}
}
else
{
Console.Write(Nodo[2] + " " + plan[i]);
if (plan[i] == "A")
{
cont1++;
}
}
Console.WriteLine(" ");
}
if (cont > 1 && cont1 > 1)
{
Console.WriteLine(" " + plan[5] + "n " + plan[1]);
}
//**************************************************************************
Console.WriteLine("Escojer un flujo");
//int indice = 0;
for (int i = 0; i < 6; i++)
{

17. if (i% 2 != 0)
{
if (i != 1)
{
Console.WriteLine("nn " + plan[i]);
//indice = i;
}
}
}
//****************************************************************************
string aux = Console.ReadLine();
for (int i = 0; i < 6; i++)
{
if (i < 2)
{
if (plan[i] == "-")
{
plan[i] = aux;
Console.WriteLine(Nodo[0] + "______" + plan[i] +
"______>" + Nodo[i + 1]);
}
else
{
Console.WriteLine(Nodo[0] + "______" + plan[i] +
"______>" + Nodo[i + 1]);
}
}
else if (i < 4)
{
if (i == 2)
{
Console.WriteLine(Nodo[1] + "______" + plan[i] +
"______>" + Nodo[i - 2]);
}
else if (i == 3)
{
Console.WriteLine(Nodo[1] + "______" + plan[i] +
"______>" + Nodo[i - 1]);
}
}
else if (i < 6)
{
if (i == 4)
{
Console.WriteLine(Nodo[2] + "______" + plan[i] +
"______>" + Nodo[i - 4]);
}
else if (i == 5)
{
Console.WriteLine(Nodo[2] + "______" + plan[i] +
"______>" + Nodo[i - 4]);
}
}
}

18. Console.ReadLine();
}
}
}
______________________________________________________________________________