SlideShare una empresa de Scribd logo
1 de 18
Descargar para leer sin conexión
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Ú
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
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.
➢ 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;
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.
• 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{
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: ";
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;
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]){
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++)
{
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]);
}
}
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;
}
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")
{
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];
//****************************************************************************
*
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)
{
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++)
{
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]);
}
}
}
Console.ReadLine();
}
}
}
______________________________________________________________________________

Más contenido relacionado

La actualidad más candente

Ads sistema-panaderia-ADS
Ads sistema-panaderia-ADSAds sistema-panaderia-ADS
Ads sistema-panaderia-ADSRosarioRuiz35
 
3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOS
3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOS3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOS
3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOSDaniela Barrientos
 
Generador de codigo intermedio
Generador de codigo intermedioGenerador de codigo intermedio
Generador de codigo intermedioGuillermo
 
Sistema operativo distribuidos
Sistema operativo distribuidosSistema operativo distribuidos
Sistema operativo distribuidoschinogallegos
 
2. Casos de uso y diagramas de casos de uso
2. Casos de uso y diagramas de casos de uso2. Casos de uso y diagramas de casos de uso
2. Casos de uso y diagramas de casos de usoSaul Mamani
 
Manejo de los procesos en los sistemas operativos
Manejo de los procesos en los sistemas operativosManejo de los procesos en los sistemas operativos
Manejo de los procesos en los sistemas operativosCarolina Cols
 
Redes Avanzadas; Protocolos de enrutamientos
Redes  Avanzadas; Protocolos de enrutamientos Redes  Avanzadas; Protocolos de enrutamientos
Redes Avanzadas; Protocolos de enrutamientos Victor Ramirez Pulido
 
Notación infija postfija
Notación infija postfijaNotación infija postfija
Notación infija postfijaOmarzingm
 
Definiciones Sistemas Distribuidos
Definiciones Sistemas DistribuidosDefiniciones Sistemas Distribuidos
Definiciones Sistemas DistribuidosJorge Guerra
 
Modelo requisitos UML
Modelo requisitos UMLModelo requisitos UML
Modelo requisitos UMLramirezjaime
 
Estructura de lenguaje ensamblador
Estructura de lenguaje ensambladorEstructura de lenguaje ensamblador
Estructura de lenguaje ensambladorEustakiu Padilla
 
diagrama de casos de uso del negocio y del sistema
diagrama de casos de uso del negocio y del sistemadiagrama de casos de uso del negocio y del sistema
diagrama de casos de uso del negocio y del sistemaUniversidad Tecnológica
 

La actualidad más candente (20)

Modelo paso de mensajes
Modelo paso de mensajesModelo paso de mensajes
Modelo paso de mensajes
 
Ads sistema-panaderia-ADS
Ads sistema-panaderia-ADSAds sistema-panaderia-ADS
Ads sistema-panaderia-ADS
 
Desnormalización de Base de Datos
Desnormalización de Base de DatosDesnormalización de Base de Datos
Desnormalización de Base de Datos
 
3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOS
3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOS3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOS
3.5.2 IDENTIFICACIÓN, IMPACTO Y PROYECCIÓN DEL RIEGOS
 
Scrum vs RUP
Scrum vs RUPScrum vs RUP
Scrum vs RUP
 
VLSM y CIDR
VLSM   y  CIDRVLSM   y  CIDR
VLSM y CIDR
 
Generador de codigo intermedio
Generador de codigo intermedioGenerador de codigo intermedio
Generador de codigo intermedio
 
Sistema operativo distribuidos
Sistema operativo distribuidosSistema operativo distribuidos
Sistema operativo distribuidos
 
2. Casos de uso y diagramas de casos de uso
2. Casos de uso y diagramas de casos de uso2. Casos de uso y diagramas de casos de uso
2. Casos de uso y diagramas de casos de uso
 
Transacciones
TransaccionesTransacciones
Transacciones
 
Manejo de los procesos en los sistemas operativos
Manejo de los procesos en los sistemas operativosManejo de los procesos en los sistemas operativos
Manejo de los procesos en los sistemas operativos
 
Redes Avanzadas; Protocolos de enrutamientos
Redes  Avanzadas; Protocolos de enrutamientos Redes  Avanzadas; Protocolos de enrutamientos
Redes Avanzadas; Protocolos de enrutamientos
 
Notación infija postfija
Notación infija postfijaNotación infija postfija
Notación infija postfija
 
Definiciones Sistemas Distribuidos
Definiciones Sistemas DistribuidosDefiniciones Sistemas Distribuidos
Definiciones Sistemas Distribuidos
 
Modelo requisitos UML
Modelo requisitos UMLModelo requisitos UML
Modelo requisitos UML
 
Algoritmo de dekker
Algoritmo de dekker Algoritmo de dekker
Algoritmo de dekker
 
Estructura de lenguaje ensamblador
Estructura de lenguaje ensambladorEstructura de lenguaje ensamblador
Estructura de lenguaje ensamblador
 
Tarjetas crc
Tarjetas crcTarjetas crc
Tarjetas crc
 
Ejemplo rup
Ejemplo rupEjemplo rup
Ejemplo rup
 
diagrama de casos de uso del negocio y del sistema
diagrama de casos de uso del negocio y del sistemadiagrama de casos de uso del negocio y del sistema
diagrama de casos de uso del negocio y del sistema
 

Similar a Algoritmos distribuidos bully o abusón, ronda,anillo o ring, bizantino

Similar a Algoritmos distribuidos bully o abusón, ronda,anillo o ring, bizantino (20)

Algoritmos
AlgoritmosAlgoritmos
Algoritmos
 
Algoritmos
AlgoritmosAlgoritmos
Algoritmos
 
4 algoritmos
4 algoritmos4 algoritmos
4 algoritmos
 
Act central u1
Act central u1Act central u1
Act central u1
 
Elementos de Criptografia
Elementos de CriptografiaElementos de Criptografia
Elementos de Criptografia
 
151953932 laboratorio-de-codificador-y-decodificador
151953932 laboratorio-de-codificador-y-decodificador151953932 laboratorio-de-codificador-y-decodificador
151953932 laboratorio-de-codificador-y-decodificador
 
Sistemas Distribuidos y Paralelismo - Unidad 2
Sistemas Distribuidos y Paralelismo - Unidad 2Sistemas Distribuidos y Paralelismo - Unidad 2
Sistemas Distribuidos y Paralelismo - Unidad 2
 
Tutorial c++
Tutorial c++Tutorial c++
Tutorial c++
 
Ejclase mpi
Ejclase mpiEjclase mpi
Ejclase mpi
 
1 unidad metodos numericos
1 unidad metodos numericos1 unidad metodos numericos
1 unidad metodos numericos
 
Cesar lenguaje c_
Cesar lenguaje c_Cesar lenguaje c_
Cesar lenguaje c_
 
Linux ud7 - gestion de procesos
Linux   ud7 - gestion de procesosLinux   ud7 - gestion de procesos
Linux ud7 - gestion de procesos
 
Ejercisos condicionales 1
Ejercisos condicionales 1Ejercisos condicionales 1
Ejercisos condicionales 1
 
Plantilla fase1
Plantilla fase1Plantilla fase1
Plantilla fase1
 
Informática
InformáticaInformática
Informática
 
Lenguaje c neo
Lenguaje c neoLenguaje c neo
Lenguaje c neo
 
Elemento1
Elemento1Elemento1
Elemento1
 
Taller de recuperacion
Taller de recuperacionTaller de recuperacion
Taller de recuperacion
 
Proyecto programacion 2.
Proyecto programacion 2.Proyecto programacion 2.
Proyecto programacion 2.
 
Pi3 7538
Pi3 7538Pi3 7538
Pi3 7538
 

Más de John Nelson Rojas

Planeamiento estrategico institucion educativa industrial de abancay
Planeamiento estrategico institucion educativa industrial de abancayPlaneamiento estrategico institucion educativa industrial de abancay
Planeamiento estrategico institucion educativa industrial de abancayJohn Nelson Rojas
 
SERVOMOTORES PARA ARDUINO UNO
SERVOMOTORES PARA ARDUINO UNOSERVOMOTORES PARA ARDUINO UNO
SERVOMOTORES PARA ARDUINO UNOJohn Nelson Rojas
 
INFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORES
INFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORESINFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORES
INFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORESJohn Nelson Rojas
 
en el pais de las maravillas CAP.01 ( En torno al hombre )
en el pais de las maravillas CAP.01 ( En torno al hombre )  en el pais de las maravillas CAP.01 ( En torno al hombre )
en el pais de las maravillas CAP.01 ( En torno al hombre ) John Nelson Rojas
 
Objetivos y clasificacion de sistemas
Objetivos y clasificacion de sistemasObjetivos y clasificacion de sistemas
Objetivos y clasificacion de sistemasJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pc
Manual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pcManual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pc
Manual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pcJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PC
 Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PC Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PC
Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PCJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poder
 Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poder Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poder
Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poderJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de Expansion
Manual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de ExpansionManual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de Expansion
Manual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de ExpansionJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAM
Manual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAMManual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAM
Manual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAMJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 3_Discos Duros
Manual Ensamblaje PCS-ACTIVIDAD 3_Discos DurosManual Ensamblaje PCS-ACTIVIDAD 3_Discos Duros
Manual Ensamblaje PCS-ACTIVIDAD 3_Discos DurosJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 2_Microprocesador
 Manual Ensamblaje PCS-ACTIVIDAD 2_Microprocesador Manual Ensamblaje PCS-ACTIVIDAD 2_Microprocesador
Manual Ensamblaje PCS-ACTIVIDAD 2_MicroprocesadorJohn Nelson Rojas
 
Manual Ensamblaje PCS-ACTIVIDAD 1_Placa madre
Manual Ensamblaje PCS-ACTIVIDAD 1_Placa madreManual Ensamblaje PCS-ACTIVIDAD 1_Placa madre
Manual Ensamblaje PCS-ACTIVIDAD 1_Placa madreJohn Nelson Rojas
 

Más de John Nelson Rojas (18)

Monografia de la robotica
Monografia de la roboticaMonografia de la robotica
Monografia de la robotica
 
Drones
DronesDrones
Drones
 
Planeamiento estrategico institucion educativa industrial de abancay
Planeamiento estrategico institucion educativa industrial de abancayPlaneamiento estrategico institucion educativa industrial de abancay
Planeamiento estrategico institucion educativa industrial de abancay
 
SERVOMOTORES PARA ARDUINO UNO
SERVOMOTORES PARA ARDUINO UNOSERVOMOTORES PARA ARDUINO UNO
SERVOMOTORES PARA ARDUINO UNO
 
INFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORES
INFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORESINFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORES
INFORME DE LABORATORIO DE FISICA I - MEDICIONES Y TEORIA DE ERRORES
 
Google chrome OS
Google chrome OS Google chrome OS
Google chrome OS
 
en el pais de las maravillas CAP.01 ( En torno al hombre )
en el pais de las maravillas CAP.01 ( En torno al hombre )  en el pais de las maravillas CAP.01 ( En torno al hombre )
en el pais de las maravillas CAP.01 ( En torno al hombre )
 
Corrientes de la psicologia
Corrientes de la psicologiaCorrientes de la psicologia
Corrientes de la psicologia
 
Objetivos y clasificacion de sistemas
Objetivos y clasificacion de sistemasObjetivos y clasificacion de sistemas
Objetivos y clasificacion de sistemas
 
Manual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pc
Manual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pcManual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pc
Manual Ensamblaje PCS-ACTIVIDAD 7_Ensamblado una pc
 
Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PC
 Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PC Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PC
Manual Ensamblaje PCS-ACTIVIDAD 8_Mantenimiento para PC
 
Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poder
 Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poder Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poder
Manual Ensamblaje PCS-ACTIVIDAD 6_Case y fuente de poder
 
Manual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de Expansion
Manual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de ExpansionManual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de Expansion
Manual Ensamblaje PCS-ACTIVIDAD 5_Tarjetas de Expansion
 
Manual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAM
Manual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAMManual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAM
Manual Ensamblaje PCS-ACTIVIDAD 4_Memoria RAM
 
Manual Ensamblaje PCS-ACTIVIDAD 3_Discos Duros
Manual Ensamblaje PCS-ACTIVIDAD 3_Discos DurosManual Ensamblaje PCS-ACTIVIDAD 3_Discos Duros
Manual Ensamblaje PCS-ACTIVIDAD 3_Discos Duros
 
Manual Ensamblaje PCS-ACTIVIDAD 2_Microprocesador
 Manual Ensamblaje PCS-ACTIVIDAD 2_Microprocesador Manual Ensamblaje PCS-ACTIVIDAD 2_Microprocesador
Manual Ensamblaje PCS-ACTIVIDAD 2_Microprocesador
 
Manual Ensamblaje PCS-ACTIVIDAD 1_Placa madre
Manual Ensamblaje PCS-ACTIVIDAD 1_Placa madreManual Ensamblaje PCS-ACTIVIDAD 1_Placa madre
Manual Ensamblaje PCS-ACTIVIDAD 1_Placa madre
 
Flora de apurimac
Flora de apurimacFlora de apurimac
Flora de apurimac
 

Último

Fisica General.pdf ESCUELA D QUIMICA E INGENIERIA
Fisica General.pdf ESCUELA D QUIMICA E INGENIERIAFisica General.pdf ESCUELA D QUIMICA E INGENIERIA
Fisica General.pdf ESCUELA D QUIMICA E INGENIERIAcoloncopias5
 
CamposGarcia_MariaMagdalena_M1S3AI6.pptx
CamposGarcia_MariaMagdalena_M1S3AI6.pptxCamposGarcia_MariaMagdalena_M1S3AI6.pptx
CamposGarcia_MariaMagdalena_M1S3AI6.pptx241518192
 
que es Planimetría definición importancia en topografia.pptx
que es Planimetría definición importancia en topografia.pptxque es Planimetría definición importancia en topografia.pptx
que es Planimetría definición importancia en topografia.pptxmrzreyes12
 
GRUPO 5 Software en el campo de la salud.pptx
GRUPO 5 Software en el campo de la salud.pptxGRUPO 5 Software en el campo de la salud.pptx
GRUPO 5 Software en el campo de la salud.pptxNicolas Villarroel
 
libro de Ciencias Sociales_6to grado.pdf
libro de Ciencias Sociales_6to grado.pdflibro de Ciencias Sociales_6to grado.pdf
libro de Ciencias Sociales_6to grado.pdfFAUSTODANILOCRUZCAST
 
2º SOY LECTOR PART 2- MD EDUCATIVO (6).pdf
2º SOY LECTOR PART 2- MD  EDUCATIVO (6).pdf2º SOY LECTOR PART 2- MD  EDUCATIVO (6).pdf
2º SOY LECTOR PART 2- MD EDUCATIVO (6).pdfFernandaHernandez312615
 
COMPETENCIAS CIUDADANASadadadadadadada .pdf
COMPETENCIAS CIUDADANASadadadadadadada .pdfCOMPETENCIAS CIUDADANASadadadadadadada .pdf
COMPETENCIAS CIUDADANASadadadadadadada .pdfOscarBlas6
 
El uso de las tic en la vida continúa , ambiente positivo y negativo.
El uso de las tic  en la vida continúa , ambiente positivo y negativo.El uso de las tic  en la vida continúa , ambiente positivo y negativo.
El uso de las tic en la vida continúa , ambiente positivo y negativo.ayalayenifer617
 
Producto académico 03 - Habilidades Comunicativas.pptx
Producto académico 03 - Habilidades Comunicativas.pptxProducto académico 03 - Habilidades Comunicativas.pptx
Producto académico 03 - Habilidades Comunicativas.pptx46828205
 
ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.
ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.
ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.Aldo Fernandez
 
FLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdf
FLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdfFLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdf
FLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdfYuriFuentesMartinez2
 
actividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsx
actividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsxactividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsx
actividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsx241532171
 
Practica guiada Menu_ tecnología (Tic's)
Practica guiada Menu_ tecnología (Tic's)Practica guiada Menu_ tecnología (Tic's)
Practica guiada Menu_ tecnología (Tic's)BrianaFrancisco
 
rodriguez_DelAngel_MariaGPE_M1S3AL6.pptx
rodriguez_DelAngel_MariaGPE_M1S3AL6.pptxrodriguez_DelAngel_MariaGPE_M1S3AL6.pptx
rodriguez_DelAngel_MariaGPE_M1S3AL6.pptxssuser61dda7
 
GRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULD
GRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULDGRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULD
GRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULDLeslie Villar
 
Tema 1 - Fundamentos de gestión contable.pptx
Tema 1 - Fundamentos de gestión contable.pptxTema 1 - Fundamentos de gestión contable.pptx
Tema 1 - Fundamentos de gestión contable.pptxchinojosa17
 

Último (16)

Fisica General.pdf ESCUELA D QUIMICA E INGENIERIA
Fisica General.pdf ESCUELA D QUIMICA E INGENIERIAFisica General.pdf ESCUELA D QUIMICA E INGENIERIA
Fisica General.pdf ESCUELA D QUIMICA E INGENIERIA
 
CamposGarcia_MariaMagdalena_M1S3AI6.pptx
CamposGarcia_MariaMagdalena_M1S3AI6.pptxCamposGarcia_MariaMagdalena_M1S3AI6.pptx
CamposGarcia_MariaMagdalena_M1S3AI6.pptx
 
que es Planimetría definición importancia en topografia.pptx
que es Planimetría definición importancia en topografia.pptxque es Planimetría definición importancia en topografia.pptx
que es Planimetría definición importancia en topografia.pptx
 
GRUPO 5 Software en el campo de la salud.pptx
GRUPO 5 Software en el campo de la salud.pptxGRUPO 5 Software en el campo de la salud.pptx
GRUPO 5 Software en el campo de la salud.pptx
 
libro de Ciencias Sociales_6to grado.pdf
libro de Ciencias Sociales_6to grado.pdflibro de Ciencias Sociales_6to grado.pdf
libro de Ciencias Sociales_6to grado.pdf
 
2º SOY LECTOR PART 2- MD EDUCATIVO (6).pdf
2º SOY LECTOR PART 2- MD  EDUCATIVO (6).pdf2º SOY LECTOR PART 2- MD  EDUCATIVO (6).pdf
2º SOY LECTOR PART 2- MD EDUCATIVO (6).pdf
 
COMPETENCIAS CIUDADANASadadadadadadada .pdf
COMPETENCIAS CIUDADANASadadadadadadada .pdfCOMPETENCIAS CIUDADANASadadadadadadada .pdf
COMPETENCIAS CIUDADANASadadadadadadada .pdf
 
El uso de las tic en la vida continúa , ambiente positivo y negativo.
El uso de las tic  en la vida continúa , ambiente positivo y negativo.El uso de las tic  en la vida continúa , ambiente positivo y negativo.
El uso de las tic en la vida continúa , ambiente positivo y negativo.
 
Producto académico 03 - Habilidades Comunicativas.pptx
Producto académico 03 - Habilidades Comunicativas.pptxProducto académico 03 - Habilidades Comunicativas.pptx
Producto académico 03 - Habilidades Comunicativas.pptx
 
ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.
ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.
ChatGPT Inteligencia artificial, funciones, limitaciones y ventajas.
 
FLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdf
FLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdfFLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdf
FLUIDEZ-Teatro-Leido-4to-Grado-El-leon-y-el-raton- (1).pdf
 
actividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsx
actividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsxactividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsx
actividad.06_crea_un_recurso_multimedia_M01_S03_M01.ppsx
 
Practica guiada Menu_ tecnología (Tic's)
Practica guiada Menu_ tecnología (Tic's)Practica guiada Menu_ tecnología (Tic's)
Practica guiada Menu_ tecnología (Tic's)
 
rodriguez_DelAngel_MariaGPE_M1S3AL6.pptx
rodriguez_DelAngel_MariaGPE_M1S3AL6.pptxrodriguez_DelAngel_MariaGPE_M1S3AL6.pptx
rodriguez_DelAngel_MariaGPE_M1S3AL6.pptx
 
GRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULD
GRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULDGRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULD
GRUPO 10 SOFTWARE DE EL CAMPO DE LA SAULD
 
Tema 1 - Fundamentos de gestión contable.pptx
Tema 1 - Fundamentos de gestión contable.pptxTema 1 - Fundamentos de gestión contable.pptx
Tema 1 - Fundamentos de gestión contable.pptx
 

Algoritmos distribuidos bully o abusón, ronda,anillo o ring, bizantino

  • 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]); } } }