INDEX

PAGE.
S.NO DATE LIST OF EXPERIMENTS SIGN
NO

1 Basics of UNIX commands

2 Shell Programming
CPU scheduling algorithms
a) Round Robin
3 b) SJF
c) FCFS
d) Priority
File Allocation Strategies
a) Sequential
4 b) Indexed
c) Linked

5 Semaphores
File Organization Techniques
a) Single level directory
6 b) Two level
c) Hierarchical
d) DAG

7 Dead Lock Avoidance

8 Dead Lock Detection

Page replacement algorithms

a) FIFO
9 b) LRU
c) LFU

10 Shared Memory and IPC

11 Paging Technique
 12 Threading and Synchronization

****************************************************************
Ex:No: 1 Basic Unix Commands Date:
****************************************************************
Use the following commands to help you manage your Unix account.
IMPORTANT: The Unix (Ultrix) operating system is case sensitive. All
commands must be typed in lower-case letters unless noted otherwise.
1. Displaying a Directory ls–Lists the names of files in a particular Unix
directory. If you type the ls command with no parameters or qualifiers, the
command displays the files listed in your current working directory. When you
give the ls command, you can add one or more modifiers to get additional
information. Example: ls
Result: Lists the names of files in your default directory, in alphabetical order.
Example: ls -l
Result: Gives a "long listing" of the files in your directory. In addition to the file
name, the long listing shows protection information, file owner, number of
characters in file, and the date and time of the last change to the file.
Example: ls -a
Result: Causes all your files to be listed, including those files that begin with a
period (i.e., hidden files).
For more information, type man ls at the Unix system prompt.
2. Displaying and Concatenating (Combining) Files more–Enables
examination of a continuous text one screenful at a time on a terminal. It
normally pauses after each screenful, printing -- More -- at the bottom of the
screen. Press RETURN to display one more line. Press the SPACE BAR to
display another screenful. Press the letter Q to stop displaying the file.
Example: more newfile
Result: Displays the contents of "newfile" one screen ("page") at a time. For
more information about this command, type man more at the Unix system
prompt.
cat-- Displays the contents of a file on your terminal.
Example: cat newfile
Result: Displays the contents of the file "newfile" on your terminal.
Example: cat newfile oldfile
Result: Displays the contents of two files–"newfile" and "oldfile"–on your
terminal as one continuous display.
While a file is being displayed, you can interrupt the output by pressing CTRL +
C and return to the Unix system prompt. CTRL + S suspends the terminal
display of the file and the processing of the command. To resume display, press
CTRL + Q. The interrupted command displays lines beginning at the point at
which processing was interrupted.
The cat command is also used to concatenate (combine) files and put them into
another file. If you concatenate files to another one that already exists, the
existing contents are permanently lost.
Example: cat fileone filetwo filethree > newfile
Result: Links together three files–fileone, filetwo, and filethree–into a new file
called "newfile." The original files remain intact.
For more information about the cat command, type man cat at the Unix system
prompt.
3. Copying Files cp–Makes copies of your files. You can use it to make
copies of files in your default directory, to copy files from one directory to
another directory, or to copy files from other devices.
Example: cp fileone filetwo
Result: Copies the contents of fileone to a file named filetwo. Two separate files
now exist.
Example: cp /usr/neighbor/testfile .
Result: Copies the file testfile from the directory /user/neighbor to your Unix
account. The period( . ) at the end of the command line indicates that the file is
to be copied to your current working directory and the name will remain the
same.
To copy a file from another user's directory on Unix, you must know the person's
username.
Example: cp ~username/file1 yourfile
Result: Copies the file "file1" from user to your Unix account. The name of the
file in your directory becomes yourfile. (Protections must be set for file to be
readable by you in the other user's directory in order to be able to copy the file.)
For more information, type man cp at the Unix system prompt.
4. Deleting Files rm–Deletes specific files. You can enter more than one file
specification on a command line by separating the file specifications with
spaces.
Example: rm newfile
Result: Deletes the file named "newfile."
Example: rm newfile oldfile
Result: Deletes two files–"newfile" and "oldfile." Example:
rm new*
Result: Deletes all files that begin with the prefix new.
For more information, type man rm at the Unix system prompt.
5. Renaming Files mv–This command changes the identification
(name) of one or more files.
Example: mv oldfile newfile
Result: Changes the name of the file "oldfile" to "newfile." Only one file will
exist.
Example: mv oldfile bin/newfile
Result: Changes the name of the file "oldfile" to "newfile" and places it in the
directory /bin. Only ne file will exist.
For more information, type man mv at the Unix system prompt.
6. Printing from Unix
The lpr command prints files on Unix. Use the -Pqueuename option to select a
printer.
Example: lpr -Ppittprint sample.file
Result: This is the default output. Single-sided output, one page-worth of text per
side, portrait format. Output is queued to the Pitt Print Stations.
The Unix operating system is case sensitive; type all commands in lower-case
letters unless noted otherwise.
****************************************************************
Ex:No: 2 b Program to find factorial of a given number Date:
****************************************************************
--------------------------save fact.sh----------------------------------
i=1 f=1
echo "Enter the positive integer value:"
read n while [ $i -le $n ] do f=`expr
$f \* $i` i=`expr $i + 1` done
echo "The factorial of $n is":$f
Steps to run Shell program
1. Download CYGWIN for Unix environment
2. Install and run CYGWIN 3. Open Cygwin.bat
4. Type cd h:
5. Type vi fact.sh
6. Type the Source Code
7. Export SHELLOPTS
8. Set -o igncr
9. bash fact.sh
****************************************************************
Ex:No:
Date:
2 b Program to Check Palindrome or not

****************************************************************
--------------------------------save pali.sh--------------------------------
#!/bin/bash
read -p "Enter the String:" n
len=${#n} flag=1
for((i=0;i<=len/2;i++))
do c1="${n:$i:1}"
c2="${n:$len-$i-1:1}"
#comparing single single charcters from begining and end if
[ $c1 != $c2 ];then
flag=0
echo "String is not palindrome" break
fi
done
if(( $flag==1)); then echo "Input
String is Palindrome" fi

Steps to run Shell program

1. Download CYGWIN for Unix environment

2. Install and run CYGWIN 3. Open Cygwin.bat
4. Type cd h:
5. Type vi fact.sh
6. Type the Source Code
7. Export SHELLOPTS
8. Set -o igncr
9. bash pali.sh
 3 a Program to implement CPU scheduling for Round Robin

****************************************************************
ALGORITHM:
STEP 1: Declare the array size.
STEP 2: Get the number of elements to be inserted.
STEP 3: Get the value.
STEP 4: Set the time sharing system with preemption.
STEP 5: Define quantum is defined from 10 to 100ms.
STEP 6: Declare the queue as a circular.
STEP 7: Make the CPU scheduler goes around the ready queue allocating CPU
to each process for the time interval specified.
STEP 8: Make the CPU scheduler picks the first process and sets time to
interrupt after quantum expired dispatches the process.
STEP 9: If the process has burst less than the time quantum than the process
releases the CPU.
PROGRAM:
****************************************************************
Ex:No:
Date:

#include<stdio.h>
#include<conio.h> void
main()
{
int et[30],ts,n,i,x=0,tot=0;
char pn[10][10]; clrscr();
printf("Enter the no of processes:");
scanf("%d",&n); printf("Enter the
time quantum:"); scanf("%d",&ts);
for(i=0;i<n;i++)
{
printf("enter process name & estimated time:"); scanf("%s
%d",pn[i],&et[i]);
}
printf("The processes are:"); for(i=0;i<n;i++)
printf("process %d: %s\n",i+1,pn[i]);
for(i=0;i<n;i++) tot=tot+et[i];
while(x!=tot)
{
for(i=0;i<n;i++)
{ if(et[i]>ts)
{ x=x+ts;
printf("\n %s -> %d",pn[i],ts);
et[i]=et[i]-ts;
}
else if((et[i]<=ts)&&et[i]!=0)
{ x=x+et[i];
printf("\n %s -> %d",pn[i],et[i]); et[i]=0;}
}}
printf("\n Total Estimated Time:%d",x); getch();
}
OUTPUT

RESULT
The program was executed successfully
3 b Program to implement CPU scheduling for SJF

****************************************************************
ALGORITHM:
Step 1: Declare the array size.
Step 2: Get the number of elements to be inserted.
Step 3: Select the process which have shortest burst will execute first. Step 4:
If two process have same burst length then FCFS scheduling algorithm used.
Step 5: Make the average waiting the length of next process.
Step 6: Start with the first process from it’s selection as above and let other
process to be in queue.
Step 7: Calculate the total number of burst time.
Step 8: Display the values.
PROGRAM
#include<stdio.h>
#include<conio.h>
#include<string.h> void main()
{
int et[20],at[10],n,i,j,temp,st[10],ft[10],wt[10],ta[10]; int totwt=0,totta=0; float
awt,ata;
char pn[10][10],t[10]; clrscr();
printf("Enter the number of process:"); scanf("%d",&n); for(i=0;i<n;i++)
{
printf("Enter process name, arrival time & execution time:"); flushall();
scanf("%s%d%d",pn[i],&at[i],&et[i]);
} for(i=0;i<n;i++)
for(j=0;j<n;j++)
****************************************************************
Ex:No:
Date:

{
if(et[i]<et[j])
{ temp=at[i];
at[i]=at[j];
at[j]=temp;
temp=et[i];
et[i]=et[j];
et[j]=temp;
strcpy(t,pn[i]);
strcpy(pn[i],pn[j]);
strcpy(pn[j],t);
}}
for(i=0;i<n;i++)
{ if(i==0)
st[i]=at[i]; elsest[i]=ft[i-1];
wt[i]=st[i]-at[i];ft[i]=st[i]+et[i];ta[i]=ft[i]-at[i];totwt+=wt[i]; totta+=ta[i];
} awt=(float)totwt/n;
ata=(float)totta/n;
printf("\nPname\tarrivaltime\texecutiontime\twaitingtime\ttatime");
for(i=0;i<n;i++)
printf("\n%s\t%5d\t\t%5d\t\t%5d\t\t%5d",pn[i],at[i],et[i],wt[i],ta[i]); printf("\
nAverage waiting time is:%f",awt);
printf("\nAverage turnaroundtime is:%f",ata); getch();
}
OUTPUT

RESULT
The program was executed successfully

3 c Program to implement CPU scheduling for FCFS

****************************************************************
ALGORITHM:
Step 1: Create the number of process.
Step 2: Get the ID and Service time for each process.
Step 3: Initially, Waiting time of first process is zero and Total time for the first
process is the starting time of that process.
Step 4: Calculate the Total time and Processing time for the remaining processes.
Step 5: Waiting time of one process is the Total time of the previous process.
Step 6: Total time of process is calculated by adding Waiting time and Service
time.
Step 7: Total waiting time is calculated by adding the waiting time for lack
process.
Step 8: Total turn around time is calculated by adding all total time of each
process.
Step 9: Calculate Average waiting time by dividing the total waiting time by total
number of process.
Step 10: Calculate Average turn around time by dividing the total time by the
number of process. Step 11: Display the result.
****************************************************************
Ex:No:
Date:

PROGRAM
#include<stdio.h>
#include<string.h>
#include<conio.h>
main() {
char pn[10][10],t[10];
int arr[10],bur[10],star[10],finish[10],tat[10],wt[10],i,j,n,temp; int
totwt=0,tottat=0;
//clrscr();
printf("Enter the number of processes:"); scanf("%d",&n); for(i=0;i<n;i++)
{
printf("Enter the Process Name, Arrival Time & Burst Time:"); scanf("%s%d
%d",&pn[i],&arr[i],&bur[i]);
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(arr[i]<arr[j])
{ temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
temp=bur[i];
bur[i]=bur[j];
bur[j]=temp;
strcpy(t,pn[i]);
strcpy(pn[i],pn[j]);
strcpy(pn[j],t);
} }}
for(i=0;i<n;i++)
{ if(i==0)
star[i]=arr[i]; else
star[i]=finish[i-1];
wt[i]=star[i]-arr[i];finish[i]=star[i]+bur[i];tat[i]=finish[i]-arr[i];
}
printf("\nPName Arrtime Burtime WaitTime Start TAT Finish"); for(i=0;i<n;i+
+)
{
printf("\n%s\t%3d\t%3d\t%3d\t%3d\t%6d\t%6d",pn[i],arr[i],bur[i],wt[i],star[i],t
at[i],finish[i]); totwt+=wt[i]; tottat+=tat[i];
}
printf("\nAverage Waiting time:%f",(float)totwt/n); printf("\nAverage Turn
Around Time:%f",(float)tottat/n); getch();
return 0; }
OUTPUT
Enter the number of processes: 3
Enter the Process Name, Arrival Time & Burst Time: p1 2 4
Enter the Process Name, Arrival Time & Burst Time: p2 3 5
Enter the Process Name, Arrival Time & Burst Time: p3 1 6
RESULT
The program was executed successfully
****************************************************************
Ex:No: 3 b Program to implement CPU scheduling for Priority Date:
****************************************************************
ALGORITHM:
STEP 1: Declare the array size.
STEP 2: Get the number of elements to be inserted. STEP
3: Get the priority for each process and value
STEP 4: Start with the higher priority process from it’s initial position let other
process to be queue.
STEP 5: Calculate the total number of burst time.
STEP 6: Display the values
PROGRAM:
#include<stdio.h>
#include<conio.h>
#include<string.h> void
main()
{
int et[20],at[10],n,i,j,temp,p[10],st[10],ft[10],wt[10],ta[10];
int totwt=0,totta=0; float awt,ata; char pn[10][10],t[10];
clrscr();
printf("Enter the number of process:");
scanf("%d",&n); for(i=0;i<n;i++)
{
printf("Enter process name,arrivaltime,execution time & priority:");
flushall(); scanf("%s%d%d%d",pn[i],&at[i],&et[i],&p[i]);
} for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
if(p[i]<p[j])
{ temp=p[i];
p[i]=p[j];
p[j]=temp;
temp=at[i];
at[i]=at[j];
at[j]=temp;
temp=et[i];
et[i]=et[j];
et[j]=temp;
strcpy(t,pn[i
]);
strcpy(pn[i],
pn[j]);
strcpy(pn[j],
t);
}}
for(i=0;i<n;i++)
{ if(i==0)
{ st[i]=at[i];
wt[i]=st[i]-at[i];
ft[i]=st[i]+et[i];
ta[i]=ft[i]-at[i];
} else
{ st[i]=ft[i-1];
wt[i]=st[i]-at[i];
ft[i]=st[i]+et[i];
ta[i]=ft[i]-at[i];
} totwt+=wt[i];
totta+=ta[i];
} awt=(float)totwt/n;
ata=(float)totta/n;
printf("\nPname\tarrivaltime\texecutiontime\tpriority\twaitingtime\ttatime");
for(i=0;i<n;i++)
printf("\n%s\t%5d\t\t%5d\t\t%5d\t\t%5d\t\t%5d",pn[i],at[i],et[i],p[i],wt[i],ta[i]);
printf("\nAverage waiting time is:%f",awt);
printf("\nAverage turnaroundtime is:%f",ata); getch();
}

OUTPUT:
RESULT
The program was executed successfully
AIM:
To write a C program for sequential file for processing the student information.

ALGORITHM:

Step-I : Start the program.

Step-2: Get the number of records user want to store in the system.
Step-3: Using Standard Library function open the file to write the data into the file.
Step-4: Store the entered information in the system.
Step-5: Using do..While statement and switch case to create the options such as
I-DISPLAY, 2.SEARCH, 3.EXIT.
Step-6: Close the file using fclose() function.
Step-7: Process it and display the result.
Step-8: Stop the program.

#include<studio.h>
main() {
int f[50],i,st,j,len,c,k;
clrscr();
for(i=0;i<50;i++)
f[i]=0; X:
printf("\n Enter the starting block & length of file");
scanf("%d%d",&st,&len);
for(j=st;j<(st+len);j++)
if(f[j]==0) { f[j]=1;
printf("\n%d->%d",j,f[j]);
} else
{
printf("Block already allocated");
break; } if(j==(st+len))
printf("\n the file is allocated to disk"); printf("\n
if u want to enter more files?(y-1/n-0)");
scanf("%d",&c);
if(c==1) goto X;
else exit();
getch();
}

OUTPUT
RESULT

The program was executed successfully

int f[50],i,k,j,inde[50],n,c,count=0,p;
main() {
clrscr();
for(i=0;i<50;i++)
f[i]=0; x:
printf("enter index block\t");
scanf("%d",&p); if(f[p]==0)
{ f[p]=1;

printf("enter no of files on index\t");

scanf("%d",&n);
} else
{
printf("Block already allocated\n");
goto x; } for(i=0;i<n;i++)
scanf("%d",&inde[i]);
for(i=0;i<n;i++) if(f[inde[i]]==1)
{
printf("Block already allocated");
goto x; } for(j=0;j<n;j++)
f[inde[j]]=1; printf("\n
allocated");
printf("\n file indexed"); for(k=0;k<n;k++)
printf("\n %d->%d:%d",p,inde[k],f[inde[k]]);
printf(" Enter 1 to enter more files and 0 to exit\t");
scanf("%d",&c);
if(c==1) goto x;
else exit();
getch();
}

OUTPUT
RESULT

The program was executed successfully

4c Linked

main() {
int f[50],p,i,j,k,a,st,len,n,c;
clrscr(); for(i=0;i<50;i++)
f[i]=0;
printf("Enter how many blocks that are already allocated"); scanf("%d",&p);
printf("\nEnter the blocks no.s that are already allocated"); for(i=0;i<p;i++)
{ scanf("%d",&a); f[a]=1; } X: printf("Enter the
starting index block & length");
scanf("%d%d",&st,&len); k=len;
for(j=st;j<(k+st);j++)
{ if(f[j]==
0)
{ f[j]=1;
printf("\n%d->%d",j,f[j]);
} else
{
printf("\n %d->file is already allocated",j);
k++;
}}
printf("\n If u want to enter one more file? (yes-1/no-0)");
scanf("%d",&c);
if(c==1) goto X;
else exit();
getch( );
}

OUTPUT
RESULT

The program was executed successfully

***************************************************************
* Ex:No: 5. IMPLEMENT SEMAPHORES
Date:
***************************************************************
*
AIM:
To Write a C-program to implement the producer using semaphores.

ALGORITHM:

Step I : Start the program.

Step 2: Declare the required variables.
Step 3: Initialize the buffer size and get maximum item you want to produce.
Step 4: Get the option, which you want to do either producer, consumer or
exit from the operation.
Step 5: If you select the producer, check the buffer size if it is full the
producer should not produce the item or otherwise produce the item
and increase the value buffer size.
Step 6: If you select the consumer, check the buffer size if it is empty the
consumer should not consume the item or otherwise consume the item
and decrease the value of buffer size.
Step 7: If you select exit come out of the
program.

Step 8: Stop the program.

PROGRAM

#include<stdio.h>
void main() {
int buffer[10], bufsize, in, out, produce, consume, choice=0;
in = 0; out = 0; bufsize = 10; while(choice !=3)
{ printf(“\n1. Produce \t 2. Consume \t3. Exit”);
printf(“\nEnter your choice: ”); scanf(“%d”,
&choice); switch(choice)
{ case 1: if((in+1)%bufsize==out)
printf(“\nBuffer is Full”); else
{ printf(“\nEnter the value: “);
scanf(“%d”, &produce);
buffer[in] = produce; in =
(in+1)%bufsize;
 } Break; case 2: if(in ==
out) printf(“\nBuffer is
Empty”);
else
{ consume = buffer[out]; printf(“\nThe consumed
value is %d”, consume); out = (out+1)%bufsize;
} break;
}
}
}

OUTPUT

1. Produce 2. Consume 3. Exit

Enter your choice: 2
Buffer is Empty
1. Produce 2. Consume 3. Exit
Enter your choice: 1 Enter
the value: 100
1. Produce 2. Consume 3. Exit
Enter your choice: 2
The consumed value is 100
1. Produce 2. Consume 3. Exit
Enter your choice: 3

RESULT

The program was executed successfully

***************************************************************
* Ex:No:
Date:

6 a File Organization Techniques – Single Level Directory

AIM:
To write C program to organize the file using single level directory.

ALGORITHM:
Step-I : Start the program.
Step-2: Declare the count, file name, graphical interface.
Step-3: Read the number of files
Step-4.•Read the file name
Step-5: Declare the root directory
Step-6: Using the file eclipse function define the files in a single level
Step-7: Display the files
Step-8: Stop the program

#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
main() {
int gd=DETECT,gm,count,i,j,mid,cir_x;
char fname[10][20]; clrscr();
initgraph(&gd,&gm,"c:\\tc\\bgi");
cleardevice(); setbkcolor(GREEN);
puts("Enter no of files do u have?");
scanf("%d",&count); for(i=0;i<count;i++)
{ cleardevice();
setbkcolor(GREEN);
printf("Enter file %d name",i+1);
scanf("%s",fname[i]);
setfillstyle(1,MAGENTA);
mid=640/count; cir_x=mid/3;
bar3d(270,100,370,150,0,0);
settextstyle(2,0,4); settextjustify(1,1);
outtextxy(320,125,"Root Directory");
setcolor(BLUE);
for(j=0;j<=i;j++,cir_x+=mid)
{ line(320,150,cir_x,250);
fillellipse(cir_x,250,30,30);
outtextxy(cir_x,250,fname[j]);
}
}
}

****************************************************************
Ex:No: 6 b File Organization Techniques – Two Level Directory Date:
AIM:
To write C program to organize the file using two level directory.

ALGORITHM:

Step-I : Start the program.

Step-2: Declare the count, file name, graphical interface.
Step-3: Read the number of files
Step-4: Read the file name
Step-5: Declare the root directory
Step-6: Using the file eclipse function define the files in a single level
Step-7: Display the files
Step-8: Stop the program
#include<stdio.h>
#include<graphics.h> struct
tree_element
{ char name[20]; int
x,y,ftype,lx,rx,nc,level;
struct tree_element *link[5];
};
typedef struct tree_element node; main()
{
int gd=DETECT,gm; node
*root;
root=NULL;
***************************************************************
* Ex:No:
Date:

create(&root,0,"null",0,639,320); initgraph(&gd,&gm,"c:\\tc\\bgi");
display(root); closegraph();
}
create(node **root,int lev,char *dname,int lx,int rx,int x)
{ int
i,gap;
if(*root==NULL)
{
(*root)=(node*)malloc(sizeof(node));
printf("enter name of dir/file(under
%s):",dname); fflush(stdin); gets((*root)->name);
if(lev==0||lev==1) (*root)->ftype=1; else
(*root)->ftype=2;
(*root)->level=lev;
(*root)->y=50+lev*50;
(*root)->x=x;
(*root)->lx=lx; (*root)->rx=rx;
for(i=0;i<5;i++) (*root)-
>link[i]=NULL;
if((*root)->ftype==1)
{
if(lev==0||lev==1)
{ if((*root)->level==0)
printf("How many users"); else
printf("hoe many files");
printf("(for%s):",(*root)->name);
scanf("%d",&(*root)->nc);
} else
(*root)->nc=0; if((*root)-
>nc==0) gap=rx-lx; else
gap=(rx-lx)/(*root)->nc;
for(i=0;i<(*root)->nc;i++)
create(&((*root)->link[i]),lev+1,(*root)-
>name,lx+gap*i,lx+gap*i+gap,lx+gap*i+gap/2);
} else (*root)-
>nc=0;
}}
display(node *root)
{
int i; settextstyle(2,0,4);
settextjustify(1,1);
setfillstyle(1,BLUE);
setcolor(14);
if(root!=NULL)
{
for(i=0;i<root->nc;i++)
{
line(root->x,root->y,root->link[i]->x,root->link[i]->y);
} if(root->ftype==1)
bar3d(root->x-20,root->y-10,root->x+20,root->y+10,0,0);
else fillellipse(root->x,root->y,20,20); outtextxy(root-
>x,root->y,root->name); for(i=0;i<root->nc;i++)
{ display(root->link[i]);
}
}}
****************************************************************
Ex:No: 6 c File Organization Techniques – Hierarchical Date:
****************************************************************
#include<stdio.h>
#include<graphics.h> struct
tree_element
{ char name[20]; int
x,y,ftype,lx,rx,nc,level;
struct tree_element *link[5];
};
typedef struct tree_element node; void
main()
{
int gd=DETECT,gm; node
*root;
root=NULL;
create(&root,0,"root",0,639,320); initgraph(&gd,&gm,"c:\\tc\\BGI");
display(root); closegraph();
}
create(node **root,int lev,char *dname,int lx,int rx,int x)
{ int
i,gap;
if(*root==NULL)
{
(*root)=(node *)malloc(sizeof(node)); printf("Enter
name of dir/file(under %s) : ",dname);
fflush(stdin); gets((*root)->name);
printf("enter 1 for Dir/2 for file :"); scanf("%d",&(*root)->ftype);
(*root)->level=lev;
(*root)->y=50+lev*50;
(*root)->x=x;
(*root)->lx=lx; (*root)->rx=rx;
for(i=0;i<5;i++) (*root)-
>link[i]=NULL; if((*root)-
>ftype==1)
{
printf("No of sub directories/files(for %s):",(*root)->name);
scanf("%d",&(*root)->nc);
if((*root)->nc==0)
gap=rx-lx; else gap=(rx-
lx)/(*root)->nc;
for(i=0;i<(*root)->nc;i++)
create(&((*root)->link[i]),lev+1,(*root)-
>name,lx+gap*i,lx+gap*i+gap,lx+gap*i+gap/2);
} else (*root)-
>nc=0;
}}
display(node *root)
{
int i;
settextstyle(2,0,4);
settextjustify(1,1);
setfillstyle(1,BLUE);
setcolor(14);
if(root !=NULL)
{
for(i=0;i<root->nc;i++)
{
line(root->x,root->y,root->link[i]->x,root->link[i]->y);
} if(root->ftype==1)
bar3d(root->x-20,root->y-10,root->x+20,root->y+10,0,0);
else fillellipse(root->x,root->y,20,20); outtextxy(root-
>x,root->y,root->name); for(i=0;i<root->nc;i++)
{
display(root->link[i]);
}
}
}
****************************************************************
Ex:No: 6 d File Organization Techniques – DAG Date:
****************************************************************
#include<stdio.h>
#include<graphics.h>
#include<string.h> struct
tree_element
{ char name[20]; int
x,y,ftype,lx,rx,nc,level;
struct tree_element *link[5];
};
typedef struct tree_element node; typedef
struct
{ char
from[20]; char
to[20]; }link;
link L[10]; int
nofl; node *
root; main()
{
int gd=DETECT,gm;
root=NULL;
create(&root,0,"root",0,639,320);
read_links(); clrscr();
initgraph(&gd,&gm,"c:\\tc\\BGI");
draw_link_lines(); display(root);
closegraph();
}
read_links()
{
int i;
printf("how many links");
scanf("%d",&nofl); for(i=0;i<nofl;i++)
{ printf("File/dir:");
fflush(stdin);
gets(L[i].from);
printf("user
name:");
fflush(stdin);
gets(L[i].to);
}}
draw_link_lines()
{ int i,x1,y1,x2,y2;
for(i=0;i<nofl;i++)
{
search(root,L[i].from,&x1,&y1); search(root,L[i].to,&x2,&y2);
setcolor(LIGHTGREEN);
setlinestyle(3,0,1); line(x1,y1,x2,y2);
setcolor(YELLOW);
setlinestyle(0,0,1);
}}
search(node *root,char *s,int *x,int *y)
{
int i;
if(root!=NULL)
{
if(strcmpi(root->name,s)==0)
{
*x=root->x;
*y=root->y;
return; }
Else { for(i=0;i<root-
>nc;i++) search(root-
>link[i],s,x,y);
}
}}
create(node **root,int lev,char *dname,int lx,int rx,int x)
{
int i,gap;
if(*root==NULL)
{
(*root)=(node *)malloc(sizeof(node));
printf("enter name of dir/file(under %s):",dname);
fflush(stdin); gets((*root)->name); printf("enter 1
for dir/ 2 for file:"); scanf("%d",&(*root)->ftype);
(*root)->level=lev;
(*root)->y=50+lev*50;
(*root)->x=x;
(*root)->lx=lx; (*root)->rx=rx;
for(i=0;i<5;i++) (*root)-
>link[i]=NULL; if((*root)-
>ftype==1)
{
printf("no of sub directories /files (for %s):",(*root)->name);
scanf("%d",&(*root)->nc); if((*root)->nc==0)
gap=rx-lx; else gap=(rx-lx)/(*root)->nc;
for(i=0;i<(*root)->nc;i++) create( & ( (*root)-
>link[i] ) , lev+1 , (*root)-
>name,lx+gap*i,lx+gap*i+gap,lx+gap*i+gap/2);
} else (*root)-
>nc=0;
}
}
/* displays the constructed tree in graphics mode */ display(node
*root)
{
int i;
settextstyle(2,0,4);
settextjustify(1,1);
setfillstyle(1,BLUE);
setcolor(14);
if(root !=NULL)
{
for(i=0;i<root->nc;i++)
{
line(root->x,root->y,root->link[i]->x,root->link[i]->y); }
if(root->ftype==1)
bar3d(root->x-20,root->y-10,root->x+20,root->y+10,0,0);
else fillellipse(root->x,root->y,20,20); outtextxy(root-
>x,root->y,root->name); for(i=0;i<root->nc;i++)
{ display(root->link[i]);
}}}
****************************************************************
Ex:No: 7 Deadlock Avoidance – Bankers Algorithm Date:
****************************************************************

AIM:
To 'Mite a C program to implement bankers algorithm for deadlock avoidance.

ALGORITHM:

Step-I : Start the program.

Step-2: Declare the memory for the process.
Step-3: Read the number of process, resources, allocation matrix and available
matrix. Step-4: Compare each and every process using the banker's algorithm.
Step-5: If the process is in safe state then it is a not a deadlock process otherwise it
is a deadlock process
Step-6: produce the result of state of process Step-
7: Stop the program

PROGRAM

#include<stdio.h> #include<conio.h> int

max[10][10], alloc[10][10], need[10][10]; int
avail[10],i,j,p,r,finish[10]={0},flag=0; int
main() { clrscr( );
printf("\n\nSIMULATION OF DEADLOCK PREVENTION");
printf("Enter no. of processes, resources"); scanf("%d
%d",&p,&r);printf("Enter allocation matrix");
for(i=0;i<p;i++) for(j=0;j<r;j++) scanf("%d",&alloc[i]
[j]); printf("enter max matrix");
for(i=0;i<p;i++) /*reading the maximum matrix and availale matrix*/
for(j=0;j<r;j++) scanf("%d",&max[i][j]); printf("enter available
matrix"); for(i=0;i<r;i++) scanf("%d",&avail[i]); for(i=0;i<p;i++)
for(j=0;j<r;j++) need[i][j]=max[i][j]-alloc[i][j]; fun(); /*calling
function*/ if(flag==0)
{
if(finish[i]!=1)
{
printf("\n\n Failing :Mutual exclusion"); for(j=0;j<r;j++)
{ /*checking for mutual exclusion*/
if(avail[j]<need[i][j]) avail[j]=need[i][j];
}fun();
printf("\n By allocating required resources to process %d dead lock is prevented
",i);
printf("\n\n lack of preemption");
for(j=0;j<r;j++)
{
if(avail[j]<need[i][j])
avail[j]=need[i][j]; alloc[i][j]=0;
} fun(
);
printf("\n\n daed lock is prevented by allocating needed resources");
printf(" \n \n failing:Hold and Wait condition "); for(j=0;j<r;j++)
{
if(avail[j]<need[i][j]) avail[j]=need[i][j];
} fun(
);
printf("\n AVOIDING ANY ONE OF THE CONDITION, U CAN PREVENT
DEADLOCK");
}}
getch( ); return 0;
} fun()
{ while(
1) {
for(flag=0,i=0;i<p;i++)
{
if(finish[i]==0)
{ for(j=0;j<r;j++)
{
if(need[i][j]<=avail[j])
continue; else break; }
if(j==r)
{ for(j=0;j<r;j++)
avail[j]+=alloc[i][j];
flag=1; finish[i]=1;
}
}}
if(flag==0)
break; }ret
urn 0;
}
OUTPUT

RESULT

The program was executed successfully

****************************************************************
Ex:No: 8 Deadlock Detection
Date:
****************************************************************
AIM:
To write a C program to implement algorithm for deadlock detection.

ALGORITHM:
Step-I : Start the program.
Step-2: Declare the memory for the process.
Step-3: Read the number of process, resources, allocation matrix and available
matrix.
Step-4: Compare each and every process using the banker's algorithm.
Step-5: If the process is in safe state then it is a not a deadlock process otherwise it
is a deadlock process
Step-6: produce the result of state of process Step-
7: Stop the program

PROGRAM

//Bankers algorithm for deadlock avoidance.

#include<stdio.h>
#include<conio.h> void
main()
{
int n,r,i,j,k,p,u=0,s=0,m; int
block[10],run[10],active[10],newreq[10]; int
max[10][10],resalloc[10][10],resreq[10][10]; int
totalloc[10],totext[10],simalloc[10]; clrscr();
printf("Enter the no of processes:");
scanf("%d",&n);
printf("Enter the no of resource classes:");
scanf("%d",&r);
printf("Enter the total existed resource in each class:");
for(k=1;k<=r;k++) scanf("%d",&totext[k]);
printf("Enter the allocated resources:");
for(i=1;i<=n;i++) for(k=1;k<=r;k++)
scanf("%d",&resalloc);
printf("Enter the process making the new request:");
scanf("%d",&p); printf("Enter the requested
resource:");
for(k=1;k<=r;k++) scanf("%d",&newreq[k]);
printf("Enter the process which are n blocked or running:"); for(i=1;i<=n;i++)
{ if(i!=p)
{ printf("process
%d:
\n",i+1);
scanf("%d%d",&block[i],&run[i]); }}
block[p]=0; run[p]=0;
for(k=1;k<=r;k++) { j=0;
for(i=1;i<=n;i++)
{ totalloc[k]=j+resalloc[i]
[k]; j=totalloc[k]; }}
for(i=1;i<=n;i++)
{ if(block[i]==1||
run[i]==1) active[i]=1; else
active[i]=0; }
for(k=1;k<=r;k++)
{ resalloc[p][k]
+=newreq[k]; totalloc[k]
+=newreq[k]; }
for(k=1;k<=r;k++)
{ if(totext[k] -
totalloc[k]<0) { u=1;break;
}} if(u==0)
{ for(k=1;k<=r;k++)
simalloc[k]=totalloc[k];
for(s=1;s<=n;s++)
for(i=1;i<=n;i++)
{ if(active[i]==1) { j=0;
for(k=1;k<=r;k++)
{
if((totext[k]-simalloc[k])<(max[i][k]-resalloc[i][k]))
{ j=1;break;
}
} } if(j==0) { active[i]=0;
for(k=1;k<=r;k++)
simalloc[k]=resalloc[i][k];
}
}
m=0; for(k=1;k<=r;k++)
resreq[p][k]=newreq[k];
printf("Deadlock willn't occur");
}
else { for(k=1;k<=r;k++)
{ resalloc[p]
[k]=newreq[k];
totalloc[k]=newreq[k]; }
printf("Deadlock will occur");
} getch();
}
OUTPUT

RESULT

The program was executed successfully.

****************************************************************
Ex:No: 9 a Page replacement algorithms - FIFO Date:
****************************************************************
AIM:

To write a C program for implementation of FIFO page replacement algorithm.

ALGORITHM:
Step 1 : Start the program.
Step 2: Declare the necessary variables.
Step 3: Enter the number of frames.
Step 4: Enter the reference string end with zero.
Step 5: FIFO page replacement selects the page that has been in memory the longest
time and when the page must be replaced the oldest page is chosen.
Step 6: When a page is brought into memory, it is inserted at the tail of the
queue. step 7: Initially all the three frames are empty.
Step 8: The page fault range increases as the no of allocated frames also increases.
Step 9: Print the total number of page faults.
Step 10: Stop the program.
#include<stdio.h> #include<conio.h>
int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1; void
main()
{ clrscr();
printf("\n \t\t\t FIFO PAGE REPLACEMENT ALGORITHM");
printf("\n Enter no.of frames...."); scanf("%d",&nof);
printf("Enter number of Pages.\n"); scanf("%d",&nor);
printf("\n Enter the Page No...");
for(i=0;i<nor;i++)
scanf("%d",&ref[i]); printf("\
nThe given Pages are:");
for(i=0;i<nor;i++)
printf("%4d",ref[i]);
for(i=1;i<=nof;i++) frm[i]=-1;
printf("\n"); for(i=0;i<nor;i++)
{ flag=0;
printf("\n\t page no %d->\t",ref[i]); for(j=0;j<nof;j++)
{
if(frm[j]==ref[i])
{ flag=1;
break; }}
if(flag==0)
{ pf++; victim++;
victim=victim%nof;
frm[victim]=ref[i];
for(j=0;j<nof;j++)
printf("%4d",frm[j]);
}}
printf("\n\n\t\t No.of pages faults...%d",pf); getch();
}

OUTPUT
FIFO PAGE REPLACEMENT ALGORITHM
Enter no.of frames....4
Enter number of reference string..
6
Enter the reference string..
564123
The given reference string:
...................................... 5 6 4 1 2 3
Reference np5-> 5 -1 -1 -1
Reference np6-> 5 6 -1 -1
Reference np4-> 5 6 4 -1
Reference np1-> 5 6 4 1
Reference np2-> 2 6 4 1
Reference np3-> 2 3 4 1
No.of pages faults...6

RESULT:
Thus the program FIFO page replacement was successfully executed.
****************************************************************
Ex:No: 9 b Page replacement algorithms - LRU Date:
AIM:
To write a c program to implement LRU page replacement algorithm.

ALGORITHM:
Step l : Start the process
Step 2: Declare the size
Step 3: Get the number of pages to be inserted
Step 4: Get the value
Step 5: Declare counter and stack
Step 6: Select the least recently used page by counter value
Step 7: Stack them according the selection.
Step 8: Display the values
Step 9: Stop the process

#include<stdio.h> #include<conio.h>
int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1; int
recent[10],lrucal[50],count=0;
int lruvictim(); void
main()
{ clrscr();
printf("\n\t\t\t LRU PAGE REPLACEMENT ALGORITHM");
printf("\n Enter no.of Frames...."); scanf("%d",&nof);
printf(" Enter no.of reference string.."); scanf("%d",&nor);
printf("\n Enter reference string..");
for(i=0;i<nor;i++)
scanf("%d",&ref[i]);
printf("\n\n\t\t LRU PAGE REPLACEMENT ALGORITHM ");
printf("\n\t The given reference string:");
printf("\n………………………………..");
for(i=0;i<nor;i++) printf("%4d",ref[i]);
for(i=1;i<=nof;i++)
{ frm[i]=-1;
lrucal[i]=0;
}
for(i=0;i<10;i++)recent[i]=0;
printf("\n"); for(i=0;i<nor;i++)
{ flag=0;
printf("\n\t Reference NO %d->\t",ref[i]); for(j=0;j<nof;j++)
{
if(frm[j]==ref[i])
{ flag=1;
break;
}
} if(flag==0)
{ count++;
if(count<=nof)
victim++; else
victim=lruvictim();
pf++;
frm[victim]=ref[i];
for(j=0;j<nof;j++)
printf("%4d",frm[j]);
} recent[ref[i]]=i;
}
printf("\n\n\t No.of page faults...%d",pf);
getch(); } int lruvictim() { int
i,j,temp1,temp2; for(i=0;i<nof;i++)
{ temp1=frm[i];
lrucal[i]=recent[temp1];
} temp2=lrucal[0];
for(j=1;j<nof;j++)
{ if(temp2>lrucal[j])
temp2=lrucal[j]; }
for(i=0;i<nof;i++)
if(ref[temp2]==frm[i])
return i; return 0;
}

OUTPUT:

LRU PAGE REPLACEMENT ALGORITHM

Enter no.of Frames....3
Enter no.of reference string..6 Enter
reference string..
654231
LRU PAGE REPLACEMENT ALGORITHM
The given reference string:
…………………. 6 5 4 2 3 1
Reference NO 6-> 6 -1 -1
Reference NO 5-> 6 5 -1
Reference NO 4-> 6 5 4
Reference NO 2-> 2 5 4
Reference NO 3-> 2 3 4
Reference NO 1-> 2 3 1
No.of page faults...6

RESULT:

Thus the process LRU page replacement was executed and verified successfully.
****************************************************************
Ex:No: 9 c Page replacement algorithms - LFU Date:
AIM:
To write C program to implement LEU page replacement algorithm.

ALGORITHM:

Step l : Start the process

Step 2: Declare the size
Step 3: Get the number of pages to be inserted
Step 4: Get the value
Step 5: Declare counter and stack
Step 6: Select the least frequently used page by counter value
Step 7: Stack them according the selection.
Step 8: Display the values
Step 9: Stop the process

#include<stdio.h> #include<conio.h>
int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1;
int recent[10],optcal[50],count=0; int optvictim();
void main()
{ clrscr();
printf("\n LFU");
printf("\n......................... ........");
printf("\nEnter the no.of frames");
scanf("%d",&nof);
printf("Enter the no.of reference string"); scanf("%d",&nor);
printf("Enter the reference string");
for(i=0;i<nor;i++)
scanf("%d",&ref[i]); clrscr();
printf("\n LFU");
printf("\n................................");
printf("\nThe given string");
printf("\n....................\n");
for(i=0;i<nor;i++) printf("%4d",ref[i]);
for(i=0;i<nof;i++)
{ frm[i]=-1;
optcal[i]=0;
} for(i=0;i<10;i++)
recent[i]=0;
printf("\n");
for(i=0;i<nor;i++)
{ flag=0;
printf("\n\tref no %d ->\t",ref[i]);
for(j=0;j<nof;j++)
{
if(frm[j]==ref[i])
{ flag=1; break; } }
if(flag==0) { count+
+; if(count<=nof)
victim++; else
victim=optvictim(i);
pf++;
frm[victim]=ref[i];
for(j=0;j<nof;j++)
printf("%4d",frm[j]);
}}
printf("\n Number of page faults: %d",pf);
getch(); }
int optvictim(int index)
{ int
i,j,temp,notfound;
for(i=0;i<nof;i++)
{ notfound=1;
for(j=index;j<nor;j++)
if(frm[i]==ref[j])
{ notfound=0;
optcal[i]=j; break; }
if(notfound==1)
return i; }
temp=optcal[0];
for(i=1;i<nof;i++)
if(temp<optcal[i])
temp=optcal[i];
for(i=0;i<nof;i++)
if(frm[temp]==frm[i])
return i;
return 0;
}
OUTPUT:

LFU PAGE REPLACEMENT ALGORITHM

Enter no. of Frames....3
Enter no. of reference string..6 Enter
reference string..
654231
LFU PAGE REPLACEMENT ALGORITHM
The given reference string:
…………………. 6 5 4 2 3 1
Reference NO 6-> 6 -1 -1
Reference NO 5-> 6 5 -1
Reference NO 4-> 6 5 4
Reference NO 2-> 2 5 4
Reference NO 3-> 2 3 4
Reference NO 1-> 2 3 1
No.of page faults...6

RESULT:

Thus the process LFU page replacement was executed and verified successfully.
****************************************************************
Ex:No: 10 Shared Memory and IPC Date:

AIM:
To a c program to implement IPC using shared memory.

ALGORITHM:

Step I : Start the process

Declare the segment size
Step 3: Create the shared memory
Step 4: Read the data from the shared memory
Step 5: Write the data to the shared memory
Step 6: Edit the data
Step 7: Stop the process
 PROGRAM

//IPC_msgq_send.c

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXSIZE 128 void
die(char *s)
{ perror(s);
exit(1);
}
typedef struct msgbuf
{ long mtype;
char mtext[MAXSIZE];
}; main()
{ int msqid; int msgflg = IPC_CREAT |
0666;
key_t key; struct
msgbuf sbuf;
size_t buflen; key
= 1234;
if ((msqid = msgget(key, msgflg )) < 0) //Get the message queue
ID for the given key
die("msgget"); //Message
Type sbuf.mtype = 1;
printf("Enter a message to add to message queue :
"); scanf("%[^\n]",sbuf.mtext); getchar();
buflen = strlen(sbuf.mtext) + 1 ;
if (msgsnd(msqid, &sbuf, buflen, IPC_NOWAIT) < 0)
{
printf ("%d, %d, %s, %d\n", msqid, sbuf.mtype, sbuf.mtext, buflen);
die("msgsnd");
} else
printf("Message Sent\n");
exit(0);
}
//IPC_msgq_rcv.c

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 128 void
die(char *s)
{ perror(s);
exit(1);
}
typedef struct msgbuf
{ long mtype;
char mtext[MAXSIZE];
};
main() { int msqid;
key_t key; struct
msgbuf rcvbuffer; key
= 1234;
if ((msqid = msgget(key, 0666)) < 0) die("msgget()");
//Receive an answer of message type 1.
if (msgrcv(msqid, &rcvbuffer, MAXSIZE, 1, 0) < 0) die("msgrcv");
printf("%s\n", rcvbuffer.mtext);
exit(0);
}

A simple implementation of IPC Message Queues.

IPC_msgq_send.c adds the message on the message queue .
IPC_msgq_rcv.c removes the message from the message queue.

To use this program first compile and run IPC_msgq_send.c to add a message to the
message queue. To see the Message Queue type ipcs -q on your Unix/Linux
Terminal.
Now compile and run IPC_msgq_rcv.c to read the message from the Message
Queue.
To see that you have read the message again use ipcs -q

OUTPUT
Sent Msg:
Enter a message to add to message queue : HI, I AM DR.S.SELVAKANI Received
Msg:
HI, I AM DR.S.SELVAKANI
RESULT :

The program was executed successfully

****************************************************************
Ex:No: 11 Paging Technique and Memory Management
Date:
****************************************************************

AIM:
To write a c program to implement Paging technique for mcmory managcment.

ALGORIUIM:
Step l : Stan the process
Step 2: I)eclarc page number. page table, frame number and process size.
Step 3: Read the process size, total number of pagcs
Step 4: Read the relative address
Step 5: Calculate the physical address
Step 6: Display the address Step 7: Stop the process
#include <stdio.h> struct
pstruct
{ int
fno; int
pbit;
}ptable[10];
int pmsize,lmsize,psize,frame,page,ftable[20],frameno; void
info()
{
printf("\n\nMEMORY MANAGEMENT USING PAGING\n\n");
printf("\n\nEnter the Size of Physical memory: "); scanf("%d",&pmsize);
printf("\n\nEnter the size of Logical memory: ");
scanf("%d",&lmsize);
printf("\n\nEnter the partition size: ");
scanf("%d",&psize); frame = (int) pmsize/psize; page = (int) lmsize/psize;
printf("\nThe physical memory is divided into %d no.of frames\n",frame);
printf("\nThe Logical memory is divided into %d no.of pages",page);
}
void assign()
{
int i;
for (i=0;i<page;i++)
{ ptable[i].fno = -
1; ptable[i].pbit=
-1;
} for(i=0; i<frame;i+
+) ftable[i] = 32555;
for (i=0;i<page;i++)
{
printf("\n\nEnter the Frame number where page %d must be placed: ",i);
scanf("%d",&frameno); ftable[frameno] = i; if(ptable[i].pbit == -1)
{
ptable[i].fno = frameno;
ptable[i].pbit = 1;
}}
getch();
// clrscr();
printf("\n\nPAGE TABLE\n\n");
printf("PageAddress FrameNo. PresenceBit\n\n"); for
(i=0;i<page;i++)
printf("%d\t\t%d\t\t%d\n",i,ptable[i].fno,ptable[i].pbit);
printf("\n\n\n\tFRAME TABLE\n\n");
printf("FrameAddress PageNo\n\n"); for(i=0;i<frame;i++)
printf("%d\t\t%d\n",i,ftable[i]);
}
void cphyaddr()
{
int laddr,paddr,disp,phyaddr,baddr;
getch();
// clrscr();
printf("\n\n\n\tProcess to create the Physical Address\n\n");
printf("\nEnter the Base Address: "); scanf("%d",&baddr);
printf("\nEnter theLogical Address: ");
scanf("%d",&laddr); paddr
= laddr / psize; disp =
laddr % psize;
if(ptable[paddr].pbit == 1 )
phyaddr = baddr + (ptable[paddr].fno*psize) + disp;
printf("\nThe Physical Address where the instruction present: %d",phyaddr);
} main()
{ info();
assign();
cphyaddr();
}

****************************************************************
Ex:No: 12 Threading Applications
Date:
****************************************************************
AIM:
To write a c program to implement Threading and Synchronization
Applications.

ALGORITHM:

Step 1 : Start the process

Step 2: Declare process thread, thread-id.
Step 3: Read the process thread and thread state.
Step 4: Check the process thread equals to thread-id by using if condition.
Step 5: Check the error state of the thread.
Step 6: Display the completed thread process.
Step 7: Stop the process
PROGRAM

#include <pthread.h>
#include <stdio.h> #include
<stdlib.h> int MAX = 10; int
count = 1; pthread_mutex_t
thr; pthread_cond_t cond; void
*even(void *arg)
{ while(count < MAX)
{ pthread_mutex_lock(&th
r); while(count % 2 != 0) {
pthread_cond_wait(&cond, &thr);
}
printf("%d ", count++);
pthread_mutex_unlock(&thr);
pthread_cond_signal(&cond);
}
pthread_exit(0);
}
void *odd(void *arg)
{ while(count < MAX)
{ pthread_mutex_lock(&thr);
while(count % 2 != 1) {
pthread_cond_wait(&cond, &thr);
}
printf("%d ", count++);
pthread_mutex_unlock(&thr);
pthread_cond_signal(&cond);
}
pthread_exit(0);
} int main(){ pthread_t
thread1; pthread_t thread2;
pthread_mutex_init(&thr, 0);
pthread_cond_init(&cond, 0);
pthread_create(&thread1, 0, &even, NULL);
pthread_create(&thread2, 0, &odd, NULL);
pthread_join(thread1, 0);
pthread_join(thread2, 0);
pthread_mutex_destroy(&thr);
 pthread_cond_destroy(&cond);
return 0;
}

OUTPUT
1 2 3 4 5 6 7 8 9 10

RESULT

The program was executed successfully