algoritmos distribuidos

Curso: Sistemas Distribuidos
Docente: Lintol Contreras S.
Alumna: Jessica Huallpa Laguna
Abancay_Apurímac
tema: Algoritmos de Sistemas
Distribuidos

Algoritmode Elección
Algoritmode Bully
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.
Cuando un proceso P detecta que el coordinador actual, por mensaje de tiempo de
espera o fallo, está caído o bloqueado, se encarga de iniciar unas elecciones, este
procedimiento se encargará de elegir el nuevo coordinador realizando las siguientes
acciones: (Hay que tener en cuenta que es posible que varios procesos puedan
descubrir la caída del coordinador de forma concurrente).
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
struct rr
{
char name[10];
int prior;
char state[10];
}proc[10];
int i,j,k,l,m,n;
void main()
{
cout<<"n introduzca el número de procesost";
scanf("%d",&n);
for(i=0;i<n;i++)
{
cout<<"nentrar nombre del procesot";
cin>>proc[i].name;
cout<<"nentrar en la prioridad del procesot";
cin>>proc[i].prior;
strcpy(proc[i].state,"active");
}
for(i=0;i<n-1;i++)
{
for(j=0;j<n-1;j++)
{
if(proc[j].prior<proc[j+1].prior)
{
char ch[5];
int t=proc[j].prior;
proc[j].prior= proc[j+1].prior;
proc[j+1].prior=t;
strcpy(ch,proc[j].name);
strcpy(proc[j].name,proc[j+1].name);
strcpy(proc[j+1].name,ch);
}}}
int min=0;
for(i=0;i<n;i++)
cout<<"n"<<proc[i].name<<"t"<<proc[i].prior;
for(i=0;i<n;i++){
for(i=0;i<n;i++){
if(min<proc[i].prior)
min=proc[i].prior;
}}

for(i=0;i<n;i++){
if(proc[i].prior==min){
cout<<"nprocess "<<proc[i].name<<" seleccione como coordinadorr";
strcpy(proc[i].state,"iactive");
break;}}
int pr;
while(1){
int ch;
cout<<"n1)electiont";
cout<<"n 2) exit t";
cin>>ch;
int max=0;
int ar[20];
k=0;
int fl=0;
switch(ch)
{
case 1: char str[5];
cout<<"n 1)intialise electiont";
cin>>str;
fl=0;
l1: for(i=0;i<n;i++)
{
if(strcmp(str,proc[i].name)==0)
{
pr=proc[i].prior;
} }
//cout<<"n"<<pr;
for(i=0;i<n;i++)
{
if(pr<proc[i].prior)
{
cout<<"nprocess "<<str<<" send message to "<<proc[i].name;
} }
for(i=0;i<n;i++){
if(pr<proc[i].prior && strcmp(proc[i].state,"active")==0 )
{
if(fl==0)
{
ar[k]= proc[i].prior;
k++;
}
cout<<"nprocess "<<proc[i].name<<" send OK message to "<<str;
if(proc[i].prior>max)
max=proc[i].prior;
} }
fl=1;
if(k!=0){
k=k-1;
for(i=0;i<n;i++){
if(ar[k]==proc[i].prior)
strcpy(str,proc[i].name); }
goto l1; }
m=0;
for(j=0;j<n;j++)
{if(proc[j].prior>m && strcmp(proc[j].state,"active")==0 ) {
cout<<"nprocess "<<proc[j].name <<" es seleccionar como nuevo coordinador";
strcpy(proc[j].state,"inactive");
break;
}}
for(i=0;i<n;i++){
if(strcmp(proc[i].state,"active")==0 && proc[j].prior>proc[i].prior){
cout<<"nprocess "<<proc[j].name<<" enviar mensaje de alerta a "<<proc[i].name}}
break;
case 2:exit(1);}}}

AlgoritmoRing
Sistema síncrono [Chang & Roberts79]. Cada proceso tiene un canal con el siguiente
proceso enelanillo. Los mensajes circulan ensentido 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 asuvecino.
• 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 unparticipante, sustituye elidentificador en
el mensaje porel suyo ylo reenvía alvecino ysemarca como participante.
– Sies mayor elrecibido, reenvía elmensaje ysemarca como participante.
– Si es menor elrecibido yelproceso es unparticipante, no hace nada (no envía ningún
mensaje).
– Siel identificador coincide conel delproceso, eseproceso esel líder.
• El líder se marca como no participante yenví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.
#include<string.h>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
struct rr{
int index;
int id;
int f;
char state[10];
}proc[10];
int i,j,k,m,n;
void main(){
int temp;
char str[10];
cout<<"n introduzca el número de procesot";
cin>>n;
for(i=0;i<n;i++){
proc[i].index;
cout<<"n entrar Identificación del procesot";
cin>>proc[i].id;
strcpy(proc[i].state,"active");
proc[i].f=0;
}
for(i=0;i<n-1;i++)
{
for(j=0;j<n-1;j++)
{

if(proc[j].id>proc[j+1].id){
temp=proc[j].id;
proc[j].id=proc[j+1].id;
proc[j+1].id=temp;
}}}
for(i=0;i<n;i++)
printf("[%d] %dt",i,proc[i].id);
int init;
int ch;
int temp1;
int temp2;
int arr[10];
strcpy(proc[n-1].state,"inactive");
cout<<"nprocess "<<proc[n-1].id<<" seleccione como coordinador";
while(1)
{
cout<<"n1)election 2)quitn";
scanf("%d",&ch);
for(i=0;i<n;i++){
proc[i].f=0;}
switch(ch){
case 1:
cout<<"nintroducir el número de proceso que inilicialice elección" ;
scanf("%d",&init);
temp2=init;
temp1=init+1;
i=0;
while(temp2!=temp1) {
if(strcmp(proc[temp1].state,"active")==0 && proc[temp1].f==0 ) {
cout<<"process "<<proc[init].id<<"send message to
"<<proc[temp1].id<<"n";
proc[temp1].f=1;
init=temp1;
arr[i]=proc[temp1].id;
i++; }
if(temp1==n)
temp1=0;
else
temp1++; }
cout<<"process "<<proc[init].id<<"send message to
"<<proc[temp1].id<<"n";
arr[i]=proc[temp1].id;
i++;
int max=-1;
for(j=0;j<i;j++)
{
if(max<arr[j])
max=arr[j];
}
cout<<"nprocess "<<max<<" seleccione como coordinador";
for(i=0;i<n;i++)
{
if(proc[i].id==max){
strcpy(proc[i].state,"inactive");
// cout<<"n"<<i<<" "<<proc[i].id<<"deactivaten";
} }
break;
break;
}}}

Algoritmos de Planeación
AlgoritmoFIFO
Primeroenentrar,primeroensalir(EninglésFirstin,first out,también se usan las siglas FIFO), es
un concepto utilizado en estructuras de datos, contabilidad de costes y teoría de colas. Guarda
analogía con las personas que esperan en una cola y van siendo atendidas en el orden en que
llegaron, es decir, que la primera persona que entra es la primera persona que sale.
#include <iostream>
#define limite 5
void insertar(char datos[],int tiempo[],int l){
for(int i = 0; i < (l); i++){
cout << "inserte el tiempo en el proceso [" << datos[i] <<
"]: ";
cin >> tiempo[i];
system("cls");
}
}
void fifo(char datos[],int tiempo[], int l){
int tiempoTotal = 0;
float tiempoReturn = 0.0f;
insertar(datos,tiempo, l);
for(int j = 0;j < l; j++){
tiempoTotal += tiempo[j];
tiempoReturn += tiempoTotal;
cout <<"n""tiempo de retorno de["<<datos[j]<<"]:
"<<tiempoTotal<<"t";
}
tiempoReturn = tiempoReturn / l;
cout<<"nEl tiempo de las entradas son: "<<tiempoReturn;
}
int main(){
cout<<"tttSimulacion de FIFO en C++"<<endl;
cout<<"tt_______________________________________n"<<endl;
char datos[limite] = {'a','b','c','d','e'};
int tiempo[limite];
fifo(datos,tiempo,limite);
cin.get();
cin.get();
return ;
}

Algoritmo de Round Robin
El sistema de todos contra todos o sistema de liga es un sistema de competición, generalmente
deportiva, en que todos los participantes del torneo se enfrentan entre ellos en un número
constante encuentros. Este tipo de competición es también llamado liguilla o round-robin.
Para determinarel calendariodel torneo,se realiza un simple algoritmo de selección. A cada uno
de loscompetidores se le asigna un número y se van rotando los números, dejando uno fijo. Por
ejemplo, en un torneo con 10 equipos:
1ª ronda: (A contra J, B contra I,…)
A B C D E
J I H G F
2ª ronda: (A contra I, J contra H,…)
A J B C D
I H G F E
package roundrobin;
public class RoundRobin {
public static void main(String[] args) {
RoundRobin rr = new RoundRobin();
for (int i = 0; i < 9; i++) {
rr.mostrar();
rr.combinar();
}
}
private String[] equipos= new String[10];
public RoundRobin() {
this.equipos[0]="A";
this.equipos[1]="B";
this.equipos[2]="C";
this.equipos[3]="D";
this.equipos[4]="E";
this.equipos[5]="F";
this.equipos[6]="G";
this.equipos[7]="H";
this.equipos[8]="I";
this.equipos[9]="J";
}
public void combinar(){
String buffer=equipos[equipos.length-1];
for (int i = equipos.length-1; i > 1; i--) {
equipos[i]=equipos[i-1];
}
equipos[1]=buffer;
}
public void mostrar(){
for (int i = 0, j=equipos.length-1; i<j; i++, j--) {
System.out.println(equipos[i]+" vs "+ equipos[j]);
}
System.out.println("*************************************");
}
} }

AlgoritmoSJF, Short Job First
Es un algoritmode planificaciónnoapropiativaque manejalostrabajosconbase enla duraciónde
su ciclode CPU. Este tipode algoritmode planificaciónse usaparaprocesamientopor lotes en los
cualesse puede sabercuál esel tiempode duraciónde la ejecuciónde cadaprocesoyentonces se
puede seleccionar el trabajo más corto.
#include<conio.h>
#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int np, sre, ses, i, b, c;
float a, pre, pes, s, nM;
float Tll[50], TS[50], TScop[50], TCo[50], TFi[50], TRe[50], TEs[50];
int main() {
cout<<"Ingrese el numero de procesos a planificar: ";
cin>>np;
cout<<endl;
a=0; sre=0; ses=0;
for (i=0;i<np;i++){
cout<<"Ingrese el Tiempo de Llegada del proceso"<<i<<": ";
cin>>Tll[i]; cout<<endl;
cout<<"Ingrese el Tiempo de Servicio del proceso"<<i<<": ";
cin>>TS[i]; cout<<endl;
}
nM=TS[0];
for (i=1;i<np;i++){
if (TS[i]>nM) nM=TS[i];
}
TCo[0]=0;
TFi[0]=TS[0];
for (i=0;i<np;i++){
TScop[i]=TS[i];
}
s=0; c=0;
do{
b=1;
for (i=1;i<np;i++){
if (TScop[b]>TScop[i]){
a=TScop[i];
b=i;
}
}
TCo[b]=TFi[c];
TFi[b]=TCo[b]+TS[b];
TScop[b]=nM+1;
c=b;
s=s+1;

}while(s<(np-1));
for (i=0;i<np;i++){
TRe[i]=TFi[i]-Tll[i];
sre=sre+TRe[i];
TEs[i]=TCo[i]-Tll[i];
ses=ses+TEs[i];
}
pre=sre/np;
pes=ses/np;
cout<<endl;
cout<<"Proceso T.Llegada T.Servicio T.Comienzo T.Finalizacion T.Retorno
T.Espera"<<endl;
for (i=0;i<np;i++){
cout<<" "<<i<<" "<<Tll[i]<<" "<<TS[i]<<" "<<TCo[i]<<" "<<TFi[i]<<"
"<<TRe[i]<<" "<<TEs[i]<<endl;
}
cout<<"Promedio de Tiempo de Retorno: "<<pre<<endl;
cout<<"Promedio de Tiempo de Espera: "<<pes<<endl;
getch();
}
} }

algoritmos distribuidos

Más contenido relacionado

La actualidad más candente (20)

Similar a algoritmos distribuidos (20)

Último (20)

algoritmos distribuidos