Thursday 29 September 2011


IMPLEMENTATION OF MEMORY MANAGEMENT SCHEME USING BEST FIT

AIM:

To write a program to implement dynamic memory allocation best fit.

ALGORITHM:

1. Start the program.

2. Enter the number of blocks.

3. Enter the base address and size for each block.

4. Enter the size of process.

5. Compute and allocate the smallest block which is large enough to hold the process request.

6. Stop the program.


PROGRAM:
#include<stdio.h>
void line()
{
int i;
printf("\n");
for(i=0;i<80;i++)
printf("-");
}
void main()
{
int bsize[20],i,n,j,temp,psize,baddr[20];
line();
printf("\n\t\tBEST FIT PLACEMENT ALGORITHM\n");
line();
printf("\nEnter the number of blocks:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\n Enter base address of block no %d:",i+1);
scanf("%d",&baddr[i]);
printf("\nEnter free block size no. %d:",i+1);
scanf("%d",&bsize[i]);
}
printf("\nEnter the size of the process to be fit:");
scanf("%d",&psize);
line();
printf("\nBEFORE ALLOCATION:\n");
printf("\nBlock No. \tBase Address \tBlock Size");
for(i=0;i<n;i++)
printf("\n%d\t\t%d\t\t%d",i+1,baddr[i],bsize[i]);
line();
for(i=0;i<n;i++)
for(j=0;j<n-1;j++)
if(bsize[j]>bsize[j+1])
{
temp=bsize[j];
bsize[j]=bsize[j+1];
bsize[j+1]=temp;
temp=baddr[j];
baddr[j]=baddr[j+1];
baddr[j+1]=temp;
}
for(i=0;i<n;i++)
if(bsize[i]<psize)
continue;
else
{
bsize[i]-=psize;
baddr[i]+=psize;
break;
}
if(i==n)
printf("\nThe process has not been fit");
else
{
printf("\nAFTER ALLOCATION:\n");
printf("\nBlock No. \tBase Address \t Block Size");
for(i=0;i<n;i++)
printf("\n%d\t\t%d\t\t%d",i+1,baddr[i],bsize[i]);
}
line();
printf("\n");
}


OUTPUT:
[root@localhost ~]# ./best

--------------------------------------------------------------------------------
BEST FIT PLACEMENT ALGORITHM

--------------------------------------------------------------------------------
Enter the number of blocks:4

Enter base address of block no 1:10

Enter free block size no. 1:45

Enter base address of block no 2:60

Enter free block size no. 2:75

Enter base address of block no 3:150

Enter free block size no. 3:100

Enter base address of block no 4:300

Enter free block size no. 4:140

Enter the size of the process to be fit:50

--------------------------------------------------------------------------------
BEFORE ALLOCATION:

Block No.       Base Address    Block Size
1               10              45
2               60              75
3               150             100
4               300             140
--------------------------------------------------------------------------------
AFTER ALLOCATION:

Block No.       Base Address     Block Size
1               10              45
2               110             25
3               150             100
4               300             140
--------------------------------------------------------------------------------
[root@localhost ~]#
Posted by Praveen at 10:07 0 comments
Labels:

IMPLEMENTATION OF MEMORY MANAGEMENT SCHEME USING BEST FIT

AIM:

To write a program to implement dynamic memory allocation best fit.

ALGORITHM:

1. Start the program.

2. Enter the number of blocks.

3. Enter the base address and size for each block.

4. Enter the size of process.

5. Compute and allocate the smallest block which is large enough to hold the process request.

6. Stop the program.


PROGRAM:
#include<stdio.h>
void line()
{
int i;
printf("\n");
for(i=0;i<80;i++)
printf("-");
}
void main()
{
int bsize[20],i,n,j,temp,psize,baddr[20];
line();
printf("\n\t\tBEST FIT PLACEMENT ALGORITHM\n");
line();
printf("\nEnter the number of blocks:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\n Enter base address of block no %d:",i+1);
scanf("%d",&baddr[i]);
printf("\nEnter free block size no. %d:",i+1);
scanf("%d",&bsize[i]);
}
printf("\nEnter the size of the process to be fit:");
scanf("%d",&psize);
line();
printf("\nBEFORE ALLOCATION:\n");
printf("\nBlock No. \tBase Address \tBlock Size");
for(i=0;i<n;i++)
printf("\n%d\t\t%d\t\t%d",i+1,baddr[i],bsize[i]);
line();
for(i=0;i<n;i++)
for(j=0;j<n-1;j++)
if(bsize[j]>bsize[j+1])
{
temp=bsize[j];
bsize[j]=bsize[j+1];
bsize[j+1]=temp;
temp=baddr[j];
baddr[j]=baddr[j+1];
baddr[j+1]=temp;
}
for(i=0;i<n;i++)
if(bsize[i]<psize)
continue;
else
{
bsize[i]-=psize;
baddr[i]+=psize;
break;
}
if(i==n)
printf("\nThe process has not been fit");
else
{
printf("\nAFTER ALLOCATION:\n");
printf("\nBlock No. \tBase Address \t Block Size");
for(i=0;i<n;i++)
printf("\n%d\t\t%d\t\t%d",i+1,baddr[i],bsize[i]);
}
line();
printf("\n");
}


OUTPUT:
[root@localhost ~]# ./best

--------------------------------------------------------------------------------
BEST FIT PLACEMENT ALGORITHM

--------------------------------------------------------------------------------
Enter the number of blocks:4

Enter base address of block no 1:10

Enter free block size no. 1:45

Enter base address of block no 2:60

Enter free block size no. 2:75

Enter base address of block no 3:150

Enter free block size no. 3:100

Enter base address of block no 4:300

Enter free block size no. 4:140

Enter the size of the process to be fit:50

--------------------------------------------------------------------------------
BEFORE ALLOCATION:

Block No.       Base Address    Block Size
1               10              45
2               60              75
3               150             100
4               300             140
--------------------------------------------------------------------------------
AFTER ALLOCATION:

Block No.       Base Address     Block Size
1               10              45
2               110             25
3               150             100
4               300             140
--------------------------------------------------------------------------------
[root@localhost ~]#
Posted by Praveen at 10:06 0 comments
Labels:

IMPLEMENTATION OF MEMORY MANAGEMENT SCHEME USING FIRST FIT

AIM:

To write a program to implement dynamic memory allocation first fit.

ALGORITHM:

1. Start the program.

2. Enter the number of blocks.

3. Enter the base address and size for each block.

4. Enter the size of process.

5. Compute and allocate the first block which is large enough to hold the process request.

6. Stop the program.

PROGRAM:

#include<stdio.h>
void line()
{
int i;
printf("\n");
for(i=0;i<80;i++)
printf("-");
}
void main()
{
int bsize[20],i,n,psize,baddr[20];
line();
printf("\n\t\tFIRST FIT PLACEMENT ALGORITHM\n");
line();
printf("\nEnter the number of blocks:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\n Enter base address of block no %d:",i+1);
scanf("%d",&baddr[i]);
printf("\nEnter free block size no. %d:",i+1);
scanf("%d",&bsize[i]);
}
printf("\nEnter the size of the process to be fit:");
scanf("%d",&psize);
line();
printf("\nBEFORE ALLOCATION:\n");
printf("\nBlock No. \tBase Address \tBlock Size");
for(i=0;i<n;i++)
printf("\n%d\t\t%d\t\t%d",i+1,baddr[i],bsize[i]);
line();
for(i=0;i<n;i++)
if(bsize[i]<psize)
continue;
else
{
bsize[i]-=psize;
baddr[i]+=psize;
break;
}
if(i==n)
printf("\nThe process has not been fit");
else
{
printf("\nAFTER ALLOCATION:\n");
printf("\nBlock No. \tBase Address \t Block Size");
for(i=0;i<n;i++)
printf("\n%d\t\t%d\t\t%d",i+1,baddr[i],bsize[i]);
}
line();
printf("\n");
}


OUTPUT:

[root@localhost ~]# ./first

--------------------------------------------------------------------------------
FIRST FIT PLACEMENT ALGORITHM

--------------------------------------------------------------------------------
Enter the number of blocks:4

Enter base address of block no 1:10

Enter free block size no. 1:45

Enter base address of block no 2:60

Enter free block size no. 2:75

Enter base address of block no 3:150

Enter free block size no. 3:100

Enter base address of block no 4:300

Enter free block size no. 4:140

Enter the size of the process to be fit:50

--------------------------------------------------------------------------------
BEFORE ALLOCATION:

Block No.       Base Address    Block Size
1               10              45
2               60              75
3               150             100
4               300             140
--------------------------------------------------------------------------------
AFTER ALLOCATION:

Block No.       Base Address     Block Size
1               10              45
2               110             25
3               150             100
4               300             140
--------------------------------------------------------------------------------

RESULT:
Thus the program was executed and the output was verified.
Posted by Praveen at 10:04 0 comments
Labels:

IMPLEMENTATION OF PRODUCER CONSUMER PROBLEM
AIM:

            To write a c program to implement Producer- consumer problem.

ALGORITHM:

            1. Start the program.

            2. Declare the variables required.

            3. If the buffer is empty, Allow the producer to produce the item and add it in the queue.

            4. Note the position of the buffer.

            5. Display the item added to the queue.
             
 6.  If the buffer is full,Producer can't produce the item and the consumer is allowed to
   consume the item.

            7. Decrement the queue and display the values.

            8. Stop the program
  
PROGRAM:
#include<stdio.h>
#define BUFFER_SIZE 5
int in,out=0;
struct semaphore
{
int b[10],c[10],d[10];
};
struct semaphore b[BUFFER_SIZE],c[10],d[10];
int main()
{
int c,q=0;
do
{
printf("\n******** PRODUCER-CONSUMER PROBLEM **********");
printf("\n 1.Producer\n 2.Consumer\n 3.Exit\n");
printf("\nEnter your choice:");
scanf("%d",&c);
switch(c)
{
case 1:
producer();
break;
case 2:
consumer();
break;
case 3:
q=1;
}
}
while(!q);
return 0;
}
producer()
{
int i;
if(((in+1)%BUFFER_SIZE)==5)
printf("\nBUFFER IS FULL\n");
else
{
for(i=1;i<BUFFER_SIZE;i++)
{
printf("\nProducer creates the product:%d\n",i);
b[in]=c[i];
printf("The position of Buffer before production:%d\n",i);
in=(in+1)%BUFFER_SIZE;
printf("The position of the Buffer after production:%d\n",in);
}
}
}
consumer()
{
int i;
if(in==out)
printf("BUFFER IS EMPTY\n");
else
{
for(i=1;i<BUFFER_SIZE;i++)
{
printf("Consumer used the product:%d\n",i);
d[i]=b[out];
printf("The position of buffer before consumption:%d\n",out);
out=(out+1)%BUFFER_SIZE;
printf("The position of the buffer after consumption:%d\n",out);
}
}
}

 OUTPUT:
 [root@localhost ~]# ./pc
  
******** PRODUCER-CONSUMER PROBLEM **********
 1.Producer
 2.Consumer
 3.Exit
Enter your choice:1
Producer creates the product:1
The position of Buffer before production:1
The position of the Buffer after production:1
Producer creates the product:2
The position of Buffer before production:2
The position of the Buffer after production:2
Producer creates the product:3
The position of Buffer before production:3
The position of the Buffer after production:3
Producer creates the product:4
The position of Buffer before production:4
The position of the Buffer after production:4
******** PRODUCER-CONSUMER PROBLEM **********
 1.Producer
 2.Consumer
 3.Exit
Enter your choice:2
Consumer used the product:1
The position of buffer before consumption:0
The position of the buffer after consumption:1
Consumer used the product:2
The position of buffer before consumption:1
The position of the buffer after consumption:2
Consumer used the product:3
The position of buffer before consumption:2
The position of the buffer after consumption:3
Consumer used the product:4
The position of buffer before consumption:3
The position of the buffer after consumption:4
******** PRODUCER-CONSUMER PROBLEM **********
 1.Producer
 2.Consumer
 3.Exit
Enter your choice:3
--------------------------------------------------------------------------------

RESULT:
Thus the program was executed and the output was verified.
Posted by Praveen at 10:04 0 comments
Labels:

IMPLEMENTATION OF INTERPROCESS COMMUNICATION USING PIPES

AIM:
            To implement interprocess communication using pipes.

ALGORITHM:

1. Start the process.
2. Create a child process using fork().
3. Now close the read end of the parent using close().
4. Write the data in the pipe using write().
5. Now close the read end of the child using close().
6. Read the data in the pipe using read().
7. Display the string.
8. Stop the process.

PROGRAM:

#include<stdio.h>
int main()
{
int fd[2],child;
char a[10];
printf(“Enter the string to enter into the pipe:\t”);
scanf(“%s”, a);
pipe(fd);
child=fork();
if(!child)
{
close(fd[0]);
write(fd[1],a,5);
wait(0);
}
else
{
close(fd[1]);
read(fd[0],a,5);
printf(“The string received from the pipe is %s”, a);
}
return 0;
}

OUTPUT:

[root@localhost ~]# ./pipes

Enter the string to enter into the pipe: Welcome

The string retrieved from the pipe is Welcome

RESULT:
Thus the program is executed and the output  is verified.
Posted by Praveen at 10:02 0 comments
Labels:

IMPLEMENTATION OF INTERPROCESS COMMUNICATION USING SHARED MEMORY

AIM:
To implement interprocess communication using shared memory.

ALGORITHM:

1.Start the process.
2.Create the child process using fork().
3.Create the shared memory for parent process using shmget() system call.
4.Now allow the parent process to write in shared memory using shmptr pointer which is return type of shmat().
5.Now across and attach the same shared memory to the child process.
6.The data in the shared memory is read by the child process using the shmptr pointer.
7.Now, detach and reuse the shared memory.
8.Stop the process

PROGRAM:

#include<stdio.h>
#include<sys/shm.h>
#include<sys/ipc.h>
int main()
{
int child, shmid, I;
char *shmptr;
child=fork();
if(!child)
{
shmid=shmget(4041,32,0666| IPC_CREAT);
shmptr=shmat(shmid,0,0);
printf(“\nParent writing:\t”);
for(I=0;I<10;I++)
{
shmptr[I]=’a’+I;
putchar(shmptr[I]);
}
printf(“\n”);
wait(NULL);
}
else
{
shmid=shmget(4041,32,0666);
shmptr=shmat(shmid,0,0);
printf(“\nChild is reading:\t”);
for(I=0;I<10;I++)
putchar(shmptr[I]);
shmdt(NULL);
shmctl(shmid,IPC_RMID,NULL);
}
printf("\n");
return 0;
}

OUTPUT:

[root@localhost ~]# ./ipc

Parent writing:   abcdefghij

Child is reading: abcdefghij

RESULT: 
Thus a interprocess communication using shared memory was implemented in linux platform and the output was verified.
Posted by Praveen at 10:02 0 comments
Labels:

                     IMPLEMENTATION OF PRIORITY SCHEDULING ALGORITHM

AIM:
          To implement the priority scheduling algorithm.

ALGORITHM:

  1. Start the program
  2. Obtain the number of processes from the user
  3. Obtain the CPU burst time and the priorities for each process.
  4. Calculate the waiting time for each process such that the process with lower priority is executed first and the process with highest priority is executed last.
  5. Display all the details for each process along with the average waiting time.
  6. Stop the execution.

PROGRAM:

#include<stdio.h>
int enqueue(int num,int y,int q[]);
int main()
{
int p[5],b[5],w[5],f[5],n,tb,t[5],i,j,tw,tt,temp,wt,pr[10],c[10];
float aw,at;
printf("\n Enter the no. of process:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("Enter the burst time & priority:");
scanf("%d",&b[i]);
scanf("%d",&pr[i]);
p[i]=i+1;
}
for(i=0;i<n;i++)
    for(j=i+1;j<n;j++)
         if(pr[i]>pr[j])
         {
            temp=pr[i];
            pr[i]=pr[j];
            pr[j]=temp;
            temp=b[i];
            b[i]=b[j];
            b[j]=temp;
            temp=p[i];
            p[i]=p[j];
            p[j]=temp;
         }
tw=w[0]=tt=t[0]=tb=0;
for(i=0;i<n;i++)
{
w[i]=tb;
tb=tb+b[i];
t[i]=b[i]+w[i];
tw=tw+w[i];
tt=tt+t[i];
}
aw=(float)tw/n;
at=(float)tt/n;
for(i=0;i<n;i++)
c[i]=w[i];
c[n]=t[n-1];
printf("\n Process time Burst time Waiting time Turnaround time\n");
for(i=0;i<n;i++)
printf("\n\t%d\t\t%d\t\t%d\t\t%d\n",p[i],b[i],w[i],t[i]);
printf("\nGantt chart\n");
for(i=0;i<=n;i++)
for(j=i+1;j<=n;j++)
if(c[i]>c[j])
{
temp=c[i];
c[i]=c[j];
c[j]=temp;
}
for(i=0;i<n;i++)
printf("\t p%d",p[i]);
printf("\n");
for(i=0;i<=n;i++)
printf("\t%d",c[i]);
printf("\n The total waiting time=%d",tw);
printf("\n Total turnaround time is=%d",tt);
printf("\n Average waiting time=%f",aw);
printf("\n Average turnaround time=%f",at);
printf("\n");
}

OUTPUT:

Enter the no. of   process:        4

Enter the burst time for P1:    4
Enter the priority for P1:      2

Enter the burst time for P2:    5
Enter the priority for P2:      3

Enter the burst time for P3:    6
Enter the priority for P3:      1

Enter the burst time for P4:    7
Enter the priority for P4:      4

 Process time   Burst time      Waiting time    Turnaround time

        3                     6                         0                       6

        1                    4                          6                       10

        2                    5                         10                      15

        4                     7                         15                      22

 Gantt chart
            P3      P1      P2      P4
        0       6       10      15      22
 The total waiting time=31
 Total turnaround time is=53
 Average waiting time=7.750000
 Average turnaround time=13.250000

RESULT:
Thus the program using priority scheduling was done and the output was verified.
Posted by Praveen at 10:01 0 comments
Labels:

                      IMPLEMENTATION OF ROUND ROBIN ALGORITHM

AIM:
          To implement the round robin algorithm.

 ALGORITHM:

  1. Start the program.
  2. Read the number of process and the time slice.
  3. Read the burst time for each process.
  4. Calculate the total turn around time, average waiting time based on the time slice.
  5. The Gantt chart is prepared based on the times the process gets executed.
  6. Display the result.
  7. Stop the execution.

PROGRAM:

#include<stdio.h>
int enqueue(int num,int y,int q[]);
int main()
{
int queue[20],i,pro[20];
int rear=0,num,tq,bur[20],wt[20],turn[20];
int flag,j=1,temp,burst[20],wait[20];
float avgwt=0,avgturn=0;
wt[0]=0;
printf("\n ROUND ROBIN SCHEDULING\n");
printf("\n\nEnter the number of process:");
scanf("%d",&num);
printf("\nProcess\tBurst time\n");
for(i=0;i<num;i++)
{
printf("\n p%d\t\t",i+1);
scanf("%d",&bur[i]);
burst[i]=bur[i];
}
printf("\n\nEnter the time quantum:");
scanf("%d",&tq);
do
{
flag=0;
for(i=0;i<num;i++)
{
if(bur[i]>=tq)
{
rear=enqueue(i+1,rear,queue);
bur[i]-=tq;
wt[j]=tq+wt[j-1];
j++;
}
else if((bur[i]>0)&&(bur[i]<tq))
{rear=enqueue(i+1,rear,queue);
wt[j]=bur[i]+wt[j-1];
bur[i]=0;
j++;
}
}
for(i=0;i<num;i++)
if(bur[i]==0)
flag++;
}while(flag!=num);
for(i=1;i<=rear;i++)
queue[i-1]=queue[i];
printf("\n\nGANTT CHART\n");

for(i=0;i<rear;i++)
printf(" p%d\t",queue[i]);
printf("\n");
for(i=0;i<=rear;i++)
printf("%d\t",wt[i]);
for(i=0;i<num;i++)
{
wait[i]=0;
temp=0;
for(j=0;j<rear;j++)
{
if(queue[j]==i+1)
{
wait[i]+=(wt[j]-temp);
temp=wt[j+1];
}
}
}
printf("\n\n**********************************************************");
printf("\nProcess\tBurst time \tWait time \tTurnaround time\n");
printf("**********************************************************\n");
for(i=0;i<num;i++)
{
turn[i]=wait[i]+burst[i];
printf("\np%d\t\t%d\t\t%d\t\t%d",i+1,burst[i],wait[i],turn[i]);
avgwt+=wait[i];
avgturn+=turn[i];
}
printf("\n\nAverage Waiting time is %f",avgwt/num);
printf("\n\nAverage Turnaround time is %f",avgturn/num);
}
}
int enqueue(int n,int rear,int queue[])
{
rear++;
queue[rear]=n;
return rear;
}

OUTPUT:

[root@localhost ~]# ./rr

 ROUND ROBIN SCHEDULING


Enter the number of process: 4

Process Burst time

 P1             3

 P2             6

 P3             4

 P4             2


Enter the time quantum: 2


GANTT CHART
        P1     P2      P3      P4      P1      P2      P3      P2
  0        2        4        6        8        9        11       13      15

**********************************************************
      Process                   Burst time      Wait time       Turnaround time
**********************************************************

           P1                         3                           6                      9
           P2                         6                           9                     15
           P3                         4                           9                     13
           P4                         2                           6                       8

Average waiting time is 7.500000

Average Turnaround time is 11.250000
Posted by Praveen at 10:01 0 comments
Labels:

IMPLEMENTATION OF SJF SCHEDULING
                  
AIM:
To write a C program to perform SJF scheduling in Linux.

ALGORITHM:
1.      Stop the program.
2.      Read the number of request
3.      Read the servicing time for each process
4.      Sort the process by servicing time(i.e. the job having least burst time is executed first)
5.      Calculate the waiting time for all the process.
6.      Calculate the average waiting time.
7.      Draw the gantt chart and print the waiting time, average waiting time, turnaround time and average turnaround time
8.      Stop the process

PROGRAM:

#include<stdio.h>
int  main()
{
int p[5],b[5],w[5],f[5],n,tb,t[5],i,j,tw,tt,temp,wt,c[10];
float aw,at;
printf("\n Enter the no. of process:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("Enter the burst time:");
scanf("%d",&b[i]);
p[i]=i+1;
}
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
if(b[i]>b[j])
{
temp=b[i];
b[i]=b[j];
b[j]=temp;
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
tw=w[0]=tt=t[0]=tb=0;
for(i=0;i<n;i++)
{
w[i]=tb;
tb=tb+b[i];
t[i]=b[i]+w[i];
tw=tw+w[i];
tt=tt+t[i];
}
aw=(float)tw/n;
at=(float)tt/n;
for(i=0;i<n;i++)
c[i]=w[i];
c[n]=t[n-1];
printf("\n Process       Burst time       Waiting time Turnaround time\n");
for(i=0;i<n;i++)
printf("\np%d\t\t%d\t\t%d\t\t%d\n",p[i],b[i],w[i],t[i]);
printf("\nGantt chart\n");
for(i=0;i<=n;i++)
for(j=i+1;j<=n;j++)
if(c[i]>c[j])
{
temp=c[i];
c[i]=c[j];
c[j]=temp;
}
for(i=0;i<n;i++)
printf("\t p%d",p[i]);
printf("\n");
for(i=0;i<=n;i++)
printf("\t%d",c[i]);
printf("\n The total waiting time=%d",tw);
printf("\n Total turnaround time is=%d",tt);
printf("\n Average waiting time=%f",aw);
printf("\n Average turnaround time=%f",at);
printf("\n");
}
}

OUTPUT:

 [root@localhost ~]# ./p5
Enter the no. of process:4
Enter the burst time:3
Enter the burst time:5
Enter the burst time:6
Enter the burst time:1

 Process       Burst time       Waiting time      Turnaround time

P4                     1                        0                               1

P1                     3                        1                               4

P2                    5                         4                               9

P3                    6                         9                              15

Gantt chart
                                        P4      P1        P2      P3
                                        0        1        4       9       15
 The total waiting time=14
 Total turnaround time is=29
 Average waiting time=3.500000
 Average turnaround time=7.250000
Posted by Praveen at 10:00 0 comments
Labels:

IMPLEMENTATION OF FCFS SCHEDULING

AIM:
To write a C Program to perform FCFS Scheduling in Linux.

ALGORITHM:

  1. Start the program.
  2. Read the number of requests
  3. Read the burst(execution) time for each process
  4. The processes are allowed to execute depends of the arrival time.
  5. The waiting time is calculated for all the process.
  6. The gantt chart is drawn representing the process execution.
  7. Calculate the waiting time and the turnaround time for all the process.
  8. Stop the process.

PROGRAM:

#include<stdio.h>
int  main()
{
int a[10],b[10],c[10],n,i,wt=0;
float avgwt;
a[0]=b[0]=0;
printf("\nEnter the no. of processes\t");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Enter the burst time:");
scanf("%d",&a[i]);
}
printf("\n The entered process are");
for(i=1;i<=n;i++)
printf("\np%d %d",i, a[i]);
printf("\n The gantt chart is:\n");
for(i=1;i<=n;i++)
{
printf("\t p%d",i);
}
printf("\n");
printf("\t%d",b[0]);
for(i=1;i<=n;i++)
{
b[i]=a[i]+b[i-1];
printf("\t%d",b[i]);
}
printf("\n The waiting time is");
for(i=0;i<n;i++)
{
printf("\np%d\t%d",i+1,b[i]);
wt=b[i]+wt;
}
avgwt=wt/i;
printf("\nThe average waiting time is %f",avgwt);
printf("\nThe turnaround time is");
wt=0;
for(i=1;i<=n;i++)
{
printf("\np%d\t%d",i,b[i]);
wt=b[i]+wt;
}
avgwt=wt/i;
printf("\nThe average turnaround time is %f",avgwt);
printf("\n");
}

OUTPUT:
[root@localhost ~]# ./p5
Enter the no. of processes      4
Enter the burst time:4
Enter the burst time:3
Enter the burst time:2
Enter the burst time:5
The entered processes are
P1      4
P2       3
P3       2
P4       5
The gantt chart is:
P1       P2      P3       P4
0         4        7         9       14
The waiting time is
P1      0
P2      4
P3      7
P4      9
The average waiting time is 5.000000
The turnaround time is
P1      4
P2      7
P3      9
P4      14
The average turnaround time is 6.000000
Posted by Praveen at 09:59 0 comments
Labels:

SIMULATION OF GREP COMMAND

  AIM:
 To implement the grep command in C.

ALGORITHM:

  1. Start the process.
  2. Declare the required variables.
  3. Obtain the filename and the required word to be searched from the user.
  4. Open the file and read the contents till the end of the file.
  5. Search the given word in the file using strstr() function, if it matches, then the word is found.
  6. Do this till the end of file is reached.
  7. Stop the process.

PROGRAM:

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
Int calc_butsize(char *filename)
{
Struct stat st;
Stat(filename,&st);
Return((int)st.st_size);
}
Int main(int argc,char *argv[])

{
If(argc<3)
Printf(“usage:\n\t %s <word><files>…..\n”,argv[0]);
Return -1;
}

FILE *fp;
Char *filename;
Int *=2;
For(x;x!=argc;x++)
Filename=argv[x];
If((fp=fopen(filename;”r”))==NULL)
{
Printf(“Failed to open file:%s \n “, argv[2]);
Return -2;
}
Int BUFSIZE=calc_bufsize(filename);
Char buf[BUFSIZE];
Fread(&buf,sizeof(char),BUFSIZE,fp);
Char *ans=strstr(buf,argv[1]);
If(ans!=NULL)
Printf(“%s \n”,filename);
Printf(“the word is found “);
Else
Printf(“ the word is not found in the given file \n”);
Fclose(fp);
}

Return 0;
}


OUTPUT:

[cs28@linux ~]$ ./3b “include” 3b.c
3b.c
The given word is found

RESULT:
 Thus the given C Program is executed and output is verified.
Posted by Praveen at 09:59 0 comments
Labels:

SIMULATION OF LS COMMAND

AIM:
To write a C program to simulate ls command.

ALGORITHM:

  1. Start the process.
  2. Create a directory entry using dirent structure.
  3. To define a pointer to a structure, dp predefined structure DIR and another pointer to a structure called ep.
  4. The directory is opened using the opendir() function.
  5. In the while loop read each entry using the readdir() function which returns a pointer.
  6. If no pointer is returned the program is exited, else it will list the files inside the directory.
  7. The closedir() function closes this open directory.
  8. Stop the process.

PROGRAM:
#include<stdio.h>
#include<dirent.h>
Struct dirent *dptr;
int main(int argc,char* argv[])
{
char buff[256];
DIR *dirp;
Dirp=opendir(“.”);
printf(“\n \n enter directory name”);
scanf(“%s”,buff);
if((disp=opendir(buff))==NULL)
{
printf(“error”);
exit(1);
}
while (dptr==readir(disp))
{
printf(“%s \n”,dptr->d_name);
}
closedir(dirp);
}
OUTPUT:
Enter directory name      ex3
a.out
ex1.c
ls
ex3a
ex1
ex3.c

RESULT:
 Thus the given C Program is executed and output is verified.
Posted by Praveen at 09:58 1 comments
Labels:

IMPLEMENTATION OF I/O SYSTEM CALLS
[open(),read(),write()]

AIM:
To write a c program to perform operations on files using LINUX system calls open(),read(),write()

ALGORITHM:

Step1: Start the process.
Step2: Declare and initialize an array variable.
Step3: Declare a file pointer.
Step4: Using the open() system call, open a file in a write mode and store it in a file
Pointer.
Step5: Using the write()system call, write the contents of an array to the file.
Step6: The written file is read with the help of read() system call. Then Close the file.
Step7: Stop the process.

PROGRAM:
#include<stdio.h>
#include<stdlib.h>
double d[10]={1.3,1.0,1.23,1.9,0.91,1.5,1.4,0.0,1.01,8.15};
int main( void)
{
int I;
FILE *fp1;
if((fp=fopen(“my.txt”,”wb”))==NULL)
{
printf(“Cannot open file \n”);
exit(1);
}
/* write the entire array in one step */
if(fwrite(d,sizeof(d),1,fp)!=1)
{
printf(“write error \n”);
exit(1);
}
fclose(fp);
if((fp=fopen(“my.txt”,”rb”))==NULL)
{
printf(“Cannot open file \n”);
exit(1);
}
/*clear the array */
for(i=0;i<10;i++)
d[i]=0.0;
/* read the entire array in one step */
if(fread(d,sizeof(d),1,fp)!=1)
{
printf(“read error \n”);
exit(1);
}
fclose(fp);
/*display the array */
for(i=0;i<10;i++)
printf(“%f”,d[i]);
return 0;
}

OUTPUT:
1.300001.1.000001.230001.90000000.9100001.5000001.40000000.000001.0100008.150000

RESULT:
Thus the given C Program is executed and output is verified.

Posted by Praveen at 09:58 0 comments
Labels:

TO DEMONSTRATE EXECLP ( ) FUNCTION

AIM:
To write a shell program to implement the execlp() function.

ALGORITHM:
1.      Start the program
2.      Obtain the pid value using fork() function.
3.      If pid <0 , then print fork failed.
4.      Else if pid = 0,execlp() function will invoked.
5.      Else print child process complete.
6.      Terminate the program.
PROGRAM:
#include<stdio.h>
main(int argc,char *argv[])
{
int pid;
pid=fork();
if(pid<0)
{
fprintf(stderr,”Fork failed \n”);
exit(-1);
}
elseif(pid==0)
{
execlp(“/bin/ls”,”ls”,NULL);
}
else
{
wait(NULL);
printf(“Child Complete”);
exit(0);
}

OUTPUT:
a.out fib.sh mov.c len.sh str.sh fact.sh copy.c cat.c even.c odd.sh child complete

RESULT
Thus the execlp functions were implemented
Posted by Praveen at 09:57 0 comments
Labels:

IMPLEMENTATION OF LINUX SYSTEM CALL
[stat()]
AIM:

To write a C program to know the status of the file using LINUX system call stat().

ALGORITHM:

Step1: Start the process.
Step2: Define a structure stat.
Step3: Declare two unsigned variables for storing the address and total size of the file
Step4: Specify the filename and check the status of file using stat() system call
Step5: Print the address and size of the file.
Step6: Stop the process.

PROGRAM:

#include<sys/stat.h>
#include<stdio.h>
int main()
{
Struct stat s;
unsigned long a;
unsigned long b;
if(stat(“test.c”,&s)==(-1))
{
perror(“Error:cannot stat file”);
exit(EXIT_FAILURE);
}
a=s.st_blksize;
b=s.st_size;
printf(“%u \t %u \n”,a,b);
return 0;
}

OUTPUT:

gcc stat.c
address:4096                          total size:52

Posted by Praveen at 09:56 0 comments
Labels:

IMPLMENTATION OF LINUX SYSTEM CALLS


IMPLMENTATION OF LINUX SYSTEM CALLS
[opendir (),readdir(),closedir()]
AIM:

To write a C program to access directories using LINUX system calls                           
opendir (),readdir(),closedir().

ALGORITHM:
  1. Start the process.
  2. Create a directory entry in the dirent structure and a directory variable
  3. Get the name of the directory to be opened
  4. Using the system call opendir(),open the given directory and store it in the directory variable.
  5. Read the contents of the directory using readdir()system call and print the list of files in the directory
  6. Close the directory after the read and write process
  7. Stop the process.

PROGRAM:
#include<Stdio.h>
#include<dirent.h>
Struct dirent *dptr;
int main(int argc,char *argv[])
{
char buff[256];
DIR *dirp;
printf(“\n \n enter directory name”);
scanf(“%s”,buff);
if ((disp=opendir(buff))==null);
{
printf(“error”);
exit(1);
} while (dptr=readir(disp))
{
printf(“%s\n”,dptr->d_name);
}
closedir(dirp);
}
OUTPUT:
Enter directory name   raju
Ashwini.c
maha.c

RESULT:
Thus the given C Program is executed and output is verified.
Posted by Praveen at 09:56 0 comments
Labels:

IMPLEMENTATION OF LINUX SYSTEM CALLS


AIM:
To write a C program using LINUX system calls (fork(),wait(),getpid()).

ALGORITHM:
Step1: Start the process.
Step2: Create a new process (parent process) using fork() system call.
Step3: Create a identical copy of parent process(child process) using fork () system call
Step4: Process id is created for both child and parent process using getpid() system call
Step5: The Child process is made to execute.
Step6: After the exiting of the child process parent process will get exit
Step7: Stop the process.

PROGRAM:
#include<stdio.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
void parent ();
void child();
main ()
{
int r;
r=fork();
{
printf(“fork empty”);
}
if(r>0)
parent(r);
else
child(r);
}
void child()
{
int i;
printf(“child starts executing”);
for(i=0;i<5;i++)
{
printf(“\n child %d is executing %d time”,getpid(),i);
sleep(i);
}
printf(“child %d exit \n”,getpid());
}
void parent(pid_t child_pid)
{
printf(“\n Parent %d watiting for child %d to start the executing “, getpid(),child_pid);
printf(“\n”);
waitpid(child_pid,NULL,0);
printf(“Parent %d exit \n”,getpid());
}

OUTPUT:
Parent 269 watiting for child 70 to start the executing
Child starts executing
Child 270 is executing 0 time
Child 270 is executing 1 time
Child 270 is executing 2 time
Child 270 is executing 3 time
Child 270 is executing 4 time
Child 270 exit.
Parent 269 exit

RESULT:
 Thus the given C Program is executed and output is verified.
Posted by Praveen at 09:53 0 comments
Labels:
Subscribe to: Posts (Atom)