9.

IMPLEMENTATION OF ELECTION ALGORITHMS

In distributed computing, leader election is the process of

designating a single process as the organizer of some task
distributed among several computers (nodes). Before the task is
begun, all network nodes are unaware which node will serve as the
"leader," or coordinator, of the task. After a leader election
algorithm has been run, however, each node throughout the
network recognizes a particular, unique node as the task leader.
The network nodes communicate among themselves in order to
decide which of them will get into the "leader" state. For that, they
need some method in order to break the symmetry among them.
For example, if each node has unique identities, then the nodes
can compare their identities, and decide that the node with the
highest identity is the leader.
The definition of this problem is often attributed to LeLann, who
formalized it as a method to create a new token in a token ring
network in which the token has been lost.
Leader election algorithms are designed to be economical in terms
of total bytes transmitted, and time. The algorithm suggested by
Gallager, Humblet, and Spira for general undirected graphs has
had a strong impact on the design of distributed algorithms in
general, and won the Dijkstra Prize for an influential paper in
distributed computing.

a. RING ELECTION ALGORITHM:

The algorithm assumes that each process has a Unique
Identification (UID) and that the processes can arrange themselves
in a unidirectional ring with a communication channel going to the
clockwise and anticlockwise neighbour. The 2 part algorithm can
be described as follows:
 1. Initially each process in the ring is marked as non-
participant.
2. A process that notices a lack of leader starts an election.
It marks itself as participant and creates an election
message containing its UID. It then sends this message
clockwise to its neighbour.
3. When a process receives an election message it
compares the UID with its own, if the current process has a
larger UID it replaces the one in the election message with its
UID. The process then marks itself as participant and again
forwards the election message in a clockwise direction.
4. If the process was already marked as participant when it
receives an election message the procedure is different. In
this case it will compare the UID as before but only forward
the election message if it has needed to replace the UID.

The algorithm finishes when a process receives an election

message containing its own UID. Then the second stage of the
algorithm takes place

1. This process marks itself as non-participant and sends

an elected message to its neighbour announcing its election
and UID.
2. When a process receives an elected message it marks
itself as non-participant records the elected UID and again
forwards the elected message.
3. When the elected message reaches the newly elected
process the election is over.

Assuming there are no failures this algorithm will finish.

For Example:
Let’s assume that we have 7 nodes:
At this current moment in time, node ‘7’ is the coordinator,
because it is the highest numbered node. But then node ‘7’ leaves,
so who is now the coordinator? Lets say node ‘4’ decides it wants
to be the coordinator, then we have:

Here, node ‘4’ has sent a ELECTION to nodes ‘5’, ‘6’ and ‘7’, this is
because none of the nodes know that node ‘7’ has left yet. In this
case, node ‘7’ cannot reply, yet, nodes ‘5’, and ‘6’ are still here, so
they reply to ‘4’ that they are still here:

Now we have nodes ‘5’ and ‘6’ sending out elections. In this case,
node ‘5’ sends an election to node ‘6’ and ‘7’. Whereas node ‘6’
just sends an election to node ‘7’:
Now, since node ‘6’ is still here, then node ‘6’ tells node ‘5’ that it
is still here:

Finally, since node ‘7’ has not replied to node ‘6’, this implies that
node ‘7’ no longer exists, meaning that node ‘6’ is the new
coordinator. So node ‘6’ tells all the other nodes:

Program:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<time.h>
int main()
{ clrscr();
int node_state[6]={1,1,1,1,1,1};
int ring_nodes[6]={9};
int cord = 6;
 int req_node;
int new_req;
int new_del;
int new_act_node;
int fin_req=0;
int oneTimeFlag=0;
int i, k, x=99, m=0, n_req=0;
//destroying the coordinator
node_state[5]=0;
cord=9;
printf("The node 6 has broke down, Have to relect a new coordinator using
ring algorithm.......\n");
getch();
while(fin_req!=999)
{
if(cord==9)
{
//getting request for node
srand ( time(NULL) );
req_node = (rand() % 7);
if(req_node==0)
req_node=1;
if(node_state[req_node-1]==0)
{
//take the node to the right or if node6 is there then take 5
if(req_node==6)
req_node=5;
else
req_node+=1;
}
printf("\nThe random node requesting permission is, Node :
%d",req_node);
getch();
//electing the new coordinator
cord=req_node;
printf("\nThe cordinator node is : %d",cord);
getch();
ring_nodes[0]=req_node;
printf("\nThe ring nodes is : %d", ring_nodes[0]);
getch();
 k=1;
n_req = (req_node+1);
while(x!=req_node)
{
printf("\nEntered loop with x : %d and n_req : %d",x, n_req);
getch();
if(n_req==7)
{
n_req=1;
printf("\nEntered node 6 loop with n_req is : %d",cord);
getch();
}
if(node_state[n_req-1]==1)
{
printf("\nEntered node stated checking and ring_nodes
setting loop, k : %d",k);
getch();
ring_nodes[k]=n_req;
}
else
{
n_req++;
continue;
}
x=n_req;
n_req++;
k++;
}
for(m=0;m<5;m++)
{
if(ring_nodes[m+1]>ring_nodes[m])
{
cord=m+1;
}
}
printf("\nThe new relected coordinator is, Node : %d", cord);
//bringing up a new node
srand ( time(NULL) );
new_req = (rand() % 7);
if(new_req==0)
 new_req=1;
node_state[new_req-1]=1;
printf("\nThe node : %d is up and running....\n", new_req);
getch();
if(new_req>cord)
{
printf("\nThe subsequent coordinator is, Node : %d",new_req);
getch();
cord=new_req;
}
}
//else
//{
//bringing up a new node
srand ( time(NULL) );
new_req = (rand() % 7);
if(new_req==0)
new_req=1;
node_state[new_req-1]=1;
printf("\nThe node : %d is up and running....\n", new_req);
getch();
if(new_req>cord)
{
printf("\nThe subsequent coordinator is, Node : %d",new_req);
getch();
cord=new_req;
}
else
{
printf("\nThe coordinator for this process is, Node : %d",cord);
getch();
}
//}
//Destroying a new node
srand ( time(NULL) );
new_del = (rand() % 7);
if(new_del==0)
new_del=1;
printf("\nThe node : %d has broke down......", new_del);
node_state[new_del-1]=0;
 if(new_del==cord)
{
printf("\nSubsequently, the coordinator is also down and a new
coordinator must be elected\n");
cord=9;
getch();
}
printf("\nPress 999 to exit or any other key to continue.....");
scanf("%d",&fin_req);
}
getch();
return 0;
}

OUTPUT
b. BULLY ELECTION ALGORITHM:
The bully algorithm is a method in distributed computing for
dynamically selecting a coordinator by process ID number.

When a process P determines that the current coordinator is down

because of message timeouts or failure of the coordinator to
initiate a handshake, it performs the following sequence of actions:

1. P broadcasts an election message (inquiry) to all other

processes with higher process IDs.

2. If P hears from no process with a higher process ID than it, it

wins the election and broadcasts victory.

3. If P hears from a process with a higher ID, P waits a certain

amount of time for that process to broadcast itself as the
leader. If it does not receive this message in time, it re-
broadcasts the election message.

Note that if P receives a victory message from a process with a

lower ID number, it immediately initiates a new election. This is
how the algorithm gets its name - a process with a higher ID
number will bully a lower ID process out of the coordinator position
as soon as it comes online.

Program:

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<time.h>
int main()
{
int node_state[6]={1,1,1,1,1,1};
int cord = 6;
int req_node;
int new_req;
int new_del;
int new_act_node;
int fin_req=0;
int oneTimeFlag=0;
int i;
//destroying the coordinator
node_state[5]=0;
cord=9;
printf("The node 6 has broke down, Have to relect a new coordinator
.......\n");
getch();
while(fin_req!=999)
{
if(cord==9)
{
//getting request for node
srand ( time(NULL) );
req_node = (rand() % 7);
if(req_node==0)
req_node=1;
if(node_state[req_node-1]==0)
{
//take the node to the right or if node6 is there then take 5
if(req_node==6)
req_node=5;
else
req_node+=1;
}
printf("\nThe random node requesting permission is, Node :
%d",req_node);
getch();
//electing the new coordinator
cord=req_node;
for(i=req_node; i<6; i++)
{
//check state
if(node_state[i]==1)
cord=i+1;
else
continue;
}
 printf("\nThe new relected coordinator is, Node : %d", cord);
//bringing up a new node
srand ( time(NULL) );
new_req = (rand() % 7);
if(new_req==0)
new_req=1;
node_state[new_req-1]=1;
printf("\nThe node : %d is up and running....\n", new_req);
getch();
if(new_req>cord)
{
printf("\nThe subsequent coordinator is, Node : %d",new_req);
getch();
cord=new_req;
}
}
//else
//{
//bringing up a new node
srand ( time(NULL) );
new_req = (rand() % 7);
if(new_req==0)
new_req=1;
node_state[new_req-1]=1;
printf("\nThe node : %d is up and running....\n", new_req);
getch();
if(new_req>cord)
{
printf("\nThe subsequent coordinator is, Node : %d",new_req);
getch();
cord=new_req;
}
else
{
printf("\nThe coordinator for this process is, Node : %d",cord);
getch();
}
//}
//Destroying a new node
srand ( time(NULL) );
new_del = (rand() % 7);
if(new_del==0)
new_del=1;
printf("\nThe node : %d has broke down......", new_del);
node_state[new_del-1]=0;
if(new_del==cord)
 {
printf("\nSubsequently, the coordinator is also down and a new
coordinator must be elected\n");
cord=9;
getch();
}
printf("\nPress 999 to exit or any other key to continue.....");
scanf("%d",&fin_req);
}
getch();
return 0;
}

OUTPUT