Distributed Systems

Practical File | IT-407

Anumeha Bansal
710/IT/10

Contents
1. To implement Scheduling Algorithms ...................................................................................................................3
First Come First Serve CPU Scheduling .............................................................................................................3
Shortest Job First CPU Scheduling ....................................................................................................................5
2. To implement Socket Programming .....................................................................................................................9
Implement TCP Client Server ............................................................................................................................9
Implement UDP Server-Client ........................................................................................................................12
Implement TCP Server in a loop .....................................................................................................................14
Implement Multicasting .................................................................................................................................16
3. Implement FTP Server and client ........................................................................................................................18
4. Implement Inter-Process Communication Techniques .......................................................................................22
Implement Producer Consumer Problem .......................................................................................................22
Implement a Synchronized Block ...................................................................................................................24

1. To implement Scheduling Algorithms

First Come First Serve CPU Scheduling
#include<stdio.h>
#include<conio.h>
struct pr
{
int at,bt;
int id,pr;
}p[10];
typedef struct pr node;
void fcfs();
int n;
int main()
{
int i,j;
int x;
printf("Enter no. of processes:\n");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Enter burst time for process %d\n",i);
scanf("%d",&p[i].bt);
printf("Enter arrival time for process %d\n",i);
scanf("%d",&p[i].at);
p[i].id=i;
}
fcfs();
}
void fcfs()
{
int t;
float awt=0,ar=0;
int i,j;
node temp;
/*Sort according to arrival time*/
for(i=1;i<=n;i++)
{
for(j=1;j<=n-i;j++)
{
if(p[i].at>p[i+1].at)
{
temp=p[i];
p[i]=p[i+1];
p[i+1]=temp;
}
}
}
t=p[1].at;
for(i=1;i<=n;i++)
{
if(t<p[i].at)
t=p[i].at;
printf("\nProcess P(%d) is executing\tStart Time=%d\n",p[i].id,t);
awt=awt+t-p[i].at;

t=t+p[i].bt;
ar=ar+t-p[i].at;
}
printf("\nAverage waiting time: %f",awt/n);
printf("\nAverage turnaround time: %f",ar/n);
}

 Shortest Job First CPU Scheduling

#include<stdio.h>
#include<conio.h>
struct pr
{
int at,bt;
int id,pr;
}p[10];
typedef struct pr node;
void sjf();
void sjfp();
int n;
int main()
{
int i,j;
int x;
printf("Enter no. of processes:\n");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Enter burst time for process %d\n",i);
scanf("%d",&p[i].bt);
printf("Enter arrival time for process %d\n",i);
scanf("%d",&p[i].at);
p[i].id=i;
}
printf("Enter choice:\n1.SJF(non-preemptive)\n2:SJF(preemptive)\n");
scanf("%d",&x);
switch(x)
{
case 1: sjf();
break;
case 2: sjfp();
break;
}
getch();
return 0;
}
void sjf()
{
int t;
int i,j,m,o,l;
l=n;
float awt=0,ta=0;
node temp;
/*sort according to burst time*/
for(i=1;i<=n;i++)
{
for(j=1;j<=n-i;j++)
{
if(p[i].bt>p[i+1].bt)

{
temp=p[i];
p[i]=p[i+1];
p[i+1]=temp;
}
}
}
int min;
min=p[1].at;
for(i=2;i<=n;i++)
{
if(p[i].at<min)
min=p[i].at;
}
t=min;
for(i=1;i<=5;i++)
{
for(j=1;j<=n;j++)
{
if(t<p[j].at)
continue;
printf("\nProcess %d is executing\t<start time=%d>\n",p[j].id,t);
awt=awt+t-p[j].at;
t=t+p[j].bt;
ta=ta+t-p[j].at;
for(m=j;m<n;m++)
p[m]=p[m+1];
n--;
j--;
}
min=p[1].at;
for(o=j;o<=n;o++)
{
if(p[o].at<min)
min=p[o].at;
}
if(t<min)
t=min;
}
printf("\nAverage waiting time is %f",awt/l);
printf("\nAverage turn-around time is %f",ta/l);
}
void sjfp()
{
int w,i,j,k,t,min,t1,x,y;
float awt=0,tr=0;
node temp;
int z=n;
int s=0,a,b,c;
min=p[1].at;
for(i=1;i<=n;i++)
{
if(p[i].at<min)

min=p[i].at;
}
//Sort according to Burst time
for(i=1;i<=n;i++)
{
for(j=1;j<=n-i;j++)
{
if(p[j].bt>p[j+1].bt)
{
temp=p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
}
}
//Sorting ends
t=min;
for(i=1;i<=5;i++)
{
for(j=1;j<=n;j++)
{
if(t<p[j].at)
continue;
printf("\nProcess %d is executing <start time = %d >",p[j].id,t);
t1=t+p[j].bt;
for(k=1;k<=n;k++)
{
if(p[k].at>t && p[k].at<t1)
{
s++;
break;
}
}
a=t;
if(s==0)
{
awt=awt+t-p[j].at;
t=t1;
tr=tr+t-p[j].at;
for(b=j;b<n;b++)
p[b]=p[b+1];
n--;
j=j-1;
}
else
{
awt=awt+t-p[j].at;
t=p[k].at;
tr=tr+t-p[j].at;
p[j].bt=p[j].bt-(t-a);
p[j].at=t;
for(x=1;x<=n;x++)
{
for(y=1;y<=n-x;y++)

{
if(p[y].bt>p[y+1].bt)
{
temp=p[y];
p[y]=p[y+1];
p[y+1]=temp;
}
}
}
j=0;
}
s=0;
t1=0;
}
min=p[1].at;
for(w=1;w<=n;w++)
{
if(p[w].at<min)
min=p[w].at;
}
if(t<min)
t=min;
}
printf("\nAverage waiting time is given by:%f",awt/z);
printf("\nAverage turn around time is :%f",tr/z);
}

2. To implement Socket Programming

Implement TCP Client Server
//server chat
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<string.h>
#define MAX_BUFFER_SIZE 100
int main()
{
int sockid,newsockid;
int clientaddrsize,numbytes;
char sendbuffer[MAX_BUFFER_SIZE+1]="connection message\n";
char recvbuffer[MAX_BUFFER_SIZE+1];
struct sockaddr_in myaddr, clientaddr;
sockid=socket(AF_INET, SOCK_STREAM, 0);
if(sockid==-1)
{
perror("socket");
}
printf("socketid: %d\n",sockid);
//cout<<"sockid: "<<sockid<<endl;
memset(&myaddr,0,sizeof(myaddr));
myaddr.sin_family=AF_INET;
myaddr.sin_port=htons(8554);
myaddr.sin_addr.s_addr=htonl(INADDR_ANY);
if(bind(sockid, (struct sockaddr *)&myaddr, sizeof(myaddr))==-1)
{
perror("bind");
}
if(listen(sockid,5)==-1)
{
perror("listen");
}
while(1)
{
clientaddrsize=sizeof(clientaddr);
newsockid=accept(sockid,(struct sockaddr *)&clientaddr, &clientaddrsize);
if(newsockid==-1)
{
perror("accept");
}
printf("\nnew socket id: %d\n",newsockid);
//int bufsize= strlen(sendbuffer);
printf("say bye to end conversation\n");
while(1)
{
gets(sendbuffer);
int bufsize= strlen(sendbuffer);
//printf("\nsend data: ");

if(send(newsockid,(void *) sendbuffer, bufsize, MSG_DONTWAIT)<0)

{
perror("send");
}
if(strcmp(sendbuffer,"bye")==0)
{
close(newsockid);
break;
}
numbytes=recv(newsockid, recvbuffer, MAX_BUFFER_SIZE,0);
recvbuffer[numbytes]='\0';
if(numbytes<0)
{
perror("recv");
}
printf("\n%s",recvbuffer);
if(strcmp(recvbuffer,"bye")==0)
{
close(newsockid);
break;
}
}
}
close(sockid);
return 0;
}

//client chat
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<string.h>
#define MAX_BUFFER_SIZE 100
int main()
{
int sockid,newsockid,numbytes;
char sendbuffer[MAX_BUFFER_SIZE+1];
char recvbuffer[MAX_BUFFER_SIZE+1];
int caddrsize;
struct sockaddr_in caddr;
sockid=socket(AF_INET, SOCK_STREAM, 0);
if(sockid==-1)
{
perror("socket");
}
printf("socketid: %d\n",sockid);
memset(&caddr,0,sizeof(caddr));
caddr.sin_family=AF_INET;
caddr.sin_port=htons(8554);
caddr.sin_addr.s_addr=inet_addr("127.0.0.1");

caddrsize=sizeof(caddr);
if(connect(sockid, (struct sockaddr *)&caddr, caddrsize)==-1)
{
perror("connect");
}
/*strcpy(buffer,"connection message");
if(send(sockid,(void *) buffer, strlen(buffer), MSG_DONTWAIT)<0)
{
perror("send");
}*/
while(1)
{
numbytes=recv(sockid, recvbuffer, MAX_BUFFER_SIZE,0);
recvbuffer[numbytes]='\0';
if(numbytes<0)
{
perror("recv");
}
printf("%s\n",recvbuffer);
if(strcmp(recvbuffer,"bye")==0)
{
close(sockid);
break;
}
//printf("send data: ");
gets(sendbuffer);
int bufsize= strlen(sendbuffer);
if(send(sockid,(void *) sendbuffer, bufsize, MSG_DONTWAIT)<0)
{
perror("send");
}
if(strcmp(sendbuffer,"bye")==0)
{
close(sockid);
break;
}
}
close(sockid);
return 0;
}

 Implement UDP Server-Client

//Server UDP
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#define BUFLEN 512
#define NPACK 10
#define PORT 9930
void diep(char *s)
{
perror(s);
exit(1);
}
int main(void)
{
struct sockaddr_in si_me, si_other;
int s, i, slen=sizeof(si_other);
char buf[BUFLEN];
if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
diep("socket");
memset((char *) &si_me, 0, sizeof(si_me));
si_me.sin_family = AF_INET;
si_me.sin_port = htons(PORT);
si_me.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(s, &si_me, sizeof(si_me))==-1)
diep("bind");
for (i=0; i<NPACK; i++) {
if (recvfrom(s, buf, BUFLEN, 0, &si_other, &slen)==-1)
diep("recvfrom()");
printf("Received packet from %s:%d\nData: %s\n\n",
inet_ntoa(si_other.sin_addr), ntohs(si_other.sin_port), buf);
}
close(s);
return 0;
}

//Client UDP
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#define BUFLEN 512

#define NPACK 10
#define PORT 9930
#define SRV_IP "999.999.999.999"
void diep(char *s)
{
perror(s);
exit(1);
}
int main(void)
{
struct sockaddr_in si_other;
int s, i, slen=sizeof(si_other);
char buf[BUFLEN];
if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
diep("socket");
memset((char *) &si_other, 0, sizeof(si_other));
si_other.sin_family = AF_INET;
si_other.sin_port = htons(PORT);
if (inet_aton(SRV_IP, &si_other.sin_addr)==0) {
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
for (i=0; i<NPACK; i++) {
printf("Sending packet %d\n", i);
sprintf(buf, "This is packet %d\n", i);
if (sendto(s, buf, BUFLEN, 0, &si_other, slen)==-1)
diep("sendto()");
}
close(s);
return 0;

 Implement TCP Server in a loop

//server chat
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<string.h>
#define MAX_BUFFER_SIZE 100
int main()
{
int sockid,newsockid;
int clientaddrsize,numbytes;
char sendbuffer[MAX_BUFFER_SIZE+1]="connection established\n";
char recvbuffer[MAX_BUFFER_SIZE+1];
struct sockaddr_in myaddr, clientaddr;
sockid=socket(AF_INET, SOCK_STREAM, 0);
if(sockid==-1)
{
perror("socket");
}
printf("socketid: %d\n",sockid);
//cout<<"sockid: "<<sockid<<endl;
memset(&myaddr,0,sizeof(myaddr));
myaddr.sin_family=AF_INET;
myaddr.sin_port=htons(8554);
myaddr.sin_addr.s_addr=htonl(INADDR_ANY);
if(bind(sockid, (struct sockaddr *)&myaddr, sizeof(myaddr))==-1)
{
perror("bind");
}
if(listen(sockid,5)==-1)
{
perror("listen");
}
while(1)
{
clientaddrsize=sizeof(clientaddr);
newsockid=accept(sockid,(struct sockaddr *)&clientaddr, &clientaddrsize);
if(newsockid==-1)
{
perror("accept");
}
printf("\nnew socket id: %d\n",newsockid);
//int bufsize= strlen(sendbuffer);
if(fork()==0)
{
close(sockid);
//printf("say bye to end conversation\n");
int bufsize= strlen(sendbuffer);
if(send(newsockid,(void *) sendbuffer, bufsize, MSG_DONTWAIT)<0)
{
perror("send");

}
while(1)
{
numbytes=recv(newsockid, recvbuffer, MAX_BUFFER_SIZE,0);
recvbuffer[numbytes]='\0';
if(numbytes<0)
{
perror("recv");
}
printf("\n%s",recvbuffer);
if(strcmp(recvbuffer,"bye")==0)
{
close(newsockid);
break;
}
gets(sendbuffer);
int bufsize= strlen(sendbuffer);
if(send(newsockid,(void *) sendbuffer, bufsize, MSG_DONTWAIT)<0)
{
perror("send");
}
if(strcmp(sendbuffer,"bye")==0)
{
close(newsockid);
break;
}
}
}
close(newsockid);
}
return 0;
}

 Implement Multicasting
/* sender.c -- multicasts "hello, world!" to a multicast group once a second */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <string.h>
#include <stdio.h>

#define HELLO_PORT 12345

#define HELLO_GROUP "225.0.0.37"
main(int argc, char *argv[])
{
struct sockaddr_in addr;
int fd, cnt;
struct ip_mreq mreq;
char *message="Hello, World!";
/* create what looks like an ordinary UDP socket */
if ((fd=socket(AF_INET,SOCK_DGRAM,0)) < 0) {
perror("socket");
exit(1);
}
/* set up destination address */
memset(&addr,0,sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_addr.s_addr=inet_addr(HELLO_GROUP);
addr.sin_port=htons(HELLO_PORT);
/* now just sendto() our destination! */
while (1) {
if (sendto(fd,message,sizeof(message),0,(struct sockaddr *) &addr,
sizeof(addr)) < 0) {
perror("sendto");
exit(1);
}
sleep(1);
}
}

/* Listener Program*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <string.h>
#include <stdio.h>

#define HELLO_PORT 12345

#define HELLO_GROUP "225.0.0.37"
#define MSGBUFSIZE 256

main(int argc, char *argv[])

{
struct sockaddr_in addr;
int fd, nbytes,addrlen;
struct ip_mreq mreq;
char msgbuf[MSGBUFSIZE];
u_int yes=1;
if ((fd=socket(AF_INET,SOCK_DGRAM,0)) < 0) {
perror("socket");
exit(1);
}

/* allow multiple sockets to use the same PORT number */

if (setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {
perror("Reusing ADDR failed");
exit(1);
}
/* set up destination address */
memset(&addr,0,sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_addr.s_addr=htonl(INADDR_ANY); /* N.B.: differs from sender */
addr.sin_port=htons(HELLO_PORT);
/* bind to receive address */
if (bind(fd,(struct sockaddr *) &addr,sizeof(addr)) < 0) {
perror("bind");
exit(1);
}
/* use setsockopt() to request that the kernel join a multicast group */
mreq.imr_multiaddr.s_addr=inet_addr(HELLO_GROUP);
mreq.imr_interface.s_addr=htonl(INADDR_ANY);
if (setsockopt(fd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq)) < 0) {
perror("setsockopt");
exit(1);
}
/* now just enter a read-print loop */
while (1) {
addrlen=sizeof(addr);
if ((nbytes=recvfrom(fd,msgbuf,MSGBUFSIZE,0,
(struct sockaddr *) &addr,&addrlen)) < 0) {
perror("recvfrom");
exit(1);
}
puts(message);
}
}

3. Implement FTP Server and client

//SERVER
#include "allheaders.h"
#include<string.h>
int mystrcmp(char s1[],char s2[])
{
int len1,len2;
int i;
len1 = strlen(s1);
len2 = strlen(s2);
len1--;
if(len1!=len2)
return 0;
for(i=0;i<len1;i++)
{
if(s1[i]!=s2[i])
return 0;
}
return 1;
}
int main()
{
int sock,connected;
int cli_len,target;
struct sockaddr_in server,client;
/*Buffers to store the username,password,filename*/
char buf1[1024],buf2[1024],buf3[1024];
int p,q,r,s,k;
char res[30];
/*Their respective pointers*/
char file[1024];
char buf[1024],ch;
FILE *source;
if((sock = socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("Socket");
exit(-1);
}
server.sin_port = htons(4433);
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
bzero(&(server.sin_zero),8);
cli_len = sizeof(struct sockaddr_in);
if((bind(sock,(struct sockaddr*)&server,cli_len))==-1)
{
perror("bind");
exit(-1);
}
if(listen(sock,5)==-1)
{
perror("listen");
exit(-1);
}
printf("\n Server is Waiting for connection....\n");

connected = accept(sock,(struct sockaddr*)&client,&cli_len);

printf("\ngot connection(%s,%d)",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
//Receive the username
if((p = recv(connected,buf1,1024,0)) > 0)
{
buf1[p] = '\0';
printf("\n Username Sent by the lcient is : ");
fputs(buf1,stdout);
//printf(" of length = %d ",p);
}/*End of if1*/
if((q = recv(connected,buf2,1024,0))>0)
{
buf2[q]='\0';
printf("\n Password sent by the client is : ");
fputs(buf2,stdout);
//printf(" of length = %d ",q);
}//End of if2
if((mystrcmp(buf1,"admin")) && (mystrcmp(buf2,"password")))
{
strcpy(res,"pass");
send(connected,res,strlen(res),0);
}
else
{
strcpy(res,"Fail");
send(connected,res,strlen(res),0);
exit(-1);
}
if((s = recv(connected,buf3,1024,0))>0) //Take the file name
{
buf3[s-1]='\0';
printf("\n File requested by the client is : ");
fputs(buf3,stdout);
printf(" of length = %d ",q);
source = fopen(buf3,"r");
if(!(source))
{
perror("\nFile opening error \n");
exit(-1);
}
else
{
int pos = 0;
while(!feof(source))
{
ch = fgetc(source);
buf[pos++] = ch;
}//end of while function
buf[pos] = '\0';
//fputs(buf,stdout);
send(connected,buf,strlen(buf),0);
printf("\n File Request Accepted \n ");
}//end of else

}//End of if3
close(connected);
close(sock);
return 0;
}

/* CLIENT */
#include "allheaders.h"
#include <string.h>
int mystrcmp(char s1[],char s2[])
{
int len1,len2;
int i;
len1 = strlen(s1);
len2 = strlen(s2);
if(len1!=len2)
return 0;
for(i=0;i<len1;i++)
{
if(s1[i]!=s2[i])
return 0;
}
return 1;
}
int main()
{
struct sockaddr_in server;
int sock;
char buf[1024],file[1024];
char res[30];
int i,len,target,k;
char username[30] = "\0",password[30] = "\0";
if((sock = socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(-1);
}
server.sin_family = AF_INET;
server.sin_port = htons(4433);
server.sin_addr.s_addr = INADDR_ANY;
bzero(&(server.sin_zero),8);
len = sizeof(struct sockaddr_in);
if((connect(sock,(struct sockaddr*)&server,sizeof(server)))==-1)
{
perror("Connect");
exit(-1);
}
printf("\n Enter Username : ");
fgets(username,30,stdin);
fflush(stdin);
send(sock,username,strlen(username),0);
printf("\n Enter Password : ");
fgets(password,30,stdin);

send(sock,password,strlen(password),0);
if((i = recv(sock,res,1024,0))>0)
{
res[i] = '\0';
if(mystrcmp(res,"pass"))
{
printf("\n Request the file from the server : ");
fgets(file,1024,stdin);
send(sock,file,strlen(file),0);
}
else
{
printf("\n Sorry Try again");
exit(-1);
}
}
int get;
if((get = recv(sock,buf,1024,0))>0)
{
printf("\n The CONTENT OF FILE : ");
fputs(buf,stdout);
}

close(sock);
close(target);
return 0;
}

4. Implement Inter-Process Communication Techniques

Implement Producer Consumer Problem
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#define N 5
sem_t mutex,full,empty;
int front,rear;
int buffer[N];
void *producer(void *arg)
{
int i;
for(i=0;i<10;i++)
{
sem_wait(&empty);
sem_wait(&mutex);
printf("\n Item Produced : %d ",i);
buffer[(rear++)%N] = i;
sleep(1);
sem_post(&mutex);
sem_post(&full);
}
}
void *consumer(void *arg)
{
int i;
for(i=0;i<10;i++)
{
sem_wait(&full);
sem_wait(&mutex);
printf("\n Item Consumed : %d ",buffer[(front++)%N]);
sleep(1);
sem_post(&mutex);
sem_post(&empty);
}

}
main()
{
pthread_t thread_a;
pthread_t thread_b;
sem_init(&mutex,0,1);
sem_init(&full,0,0);
sem_init(&empty,0,N);
pthread_create(&thread_a,NULL,producer,NULL);
pthread_create(&thread_b,NULL,consumer,NULL);
pthread_join(thread_a,NULL);
pthread_join(thread_b,NULL);

//return 0;
}

 Implement a Synchronized Block

#include<stdio.h>
#include<stdlib.h>
#include<semaphore.h>
#include<pthread.h>
#define NUM_READ 5//No of readers
#define NUM_WRIT 5 //No of writers
int reader_name[] = {1,2,3,4,5};
int writer_name[] = {1,2,3,4,5};
sem_t mutex,wrt;
int readcount;
void *performRead(void *n)
{
int i = *(int *)n;
sem_wait(&mutex);
readcount++;
if(readcount==1)
sem_wait(&wrt);
sem_post(&mutex);
printf("\n Reader %d is reading ",i);
sem_wait(&mutex);
readcount--;
if(readcount==0)
sem_post(&wrt);
sem_post(&mutex);
}
void *performWrite(void *n)
{
int i = *(int *)n;
sem_wait(&wrt);
printf("\n Writer %d is writing ",i);
sem_post(&wrt);
}
int main()
{
int i;
pthread_t reader[NUM_READ];
pthread_t writer[NUM_WRIT];
sem_init(&mutex,0,1);
sem_init(&wrt,0,1);
for(i=0;i<NUM_READ;i++)
pthread_create(&reader[i],NULL,performRead,&reader_name[i]);
for(i=0;i<NUM_WRIT;i++)
pthread_create(&writer[i],NULL,performWrite,&writer_name[i]);
for(i=0;i<NUM_READ;i++)
pthread_join(reader[i],NULL);
for(i=0;i<NUM_WRIT;i++)
pthread_join(writer[i],NULL);
return 0;
}