CS2257-OS-LAB-MANUAL-II-IT-by-GBN.pdf

1

SRINIVASAN ENGINEERING COLLEGE

PERAMBALUR-621212

DEPARTMENT OF INFORMATION TECHNOLOGY

CS2257 – OPERATING SYSTEMS LABORATORY

II - IT (2011-2015)

PREPARED BY

Mr. G.Baskaran M.E.,

Assistant professor/Information Technology,

Srinivasan Engineering college, Perambalur-621212

Anna university, Chennai (R-2008)

Academic year (2012-13) IV SEMESTER

2

DEDICATED TO

My Family &

My Friends

3

PREFACE Operating Systems Laboratory Manual is intended as an introduction of executing programs for reader and students. This manual provides a handy guide to the developers in managing computer hardware. The purpose of an operating system is to provide an environment in which a user can execute programs in a convenient and efficient manner.

4

ACKNOWLEDGEMENT Behind every achievement lies an unfathomable sea of gratitude to all those who made the

achievement possible without whom it would never have come into existence.

I give all glory and thanks to our god almighty for showering upon, the necessary wisdom and

grace for accomplishing the lab manual.

I am indebted to our honorable chairman and founder of Dhanalakshmi Srinivasan Group of

institutions, SHRI.A.SRINIVASAN , for his kind encouragement.

I am very much happy to thank our beloved Principal Dr.B.KARTHIKEYAN M.E., Ph.D.,

for his unflinching devotion and continuous encouragement motivated me to complete this lab

manual.

I extend my warm gratitude to our Head of the Department, Mr. S.SATHISHKUMAR ME.,

for his valuable suggestion and kind guidance throughout the manual preparation.

Finally, I thank my parents, and my friends without whom this course would have been a

dream.

5

CS2257 – OPERATING SYSTEMS LABORATORY

(Common to CSE and IT)

(Implement the following on LINUX or other Unix like platform. Use C for high level language

implementation)

LIST OF EXPERIMENTS

1. Write programs using the following system calls of UNIX operating system: fork, exec,

getpid, exit, wait, close, stat, opendir, readdir

2. Write programs using the I/O system calls of UNIX operating system (open, read, write, etc)

3. Write C programs to simulate UNIX commands like ls, grep, etc.

4. Given the list of processes, their CPU burst times and arrival times, display/print the Gantt

chart for FCFS and SJF. For each of the scheduling policies, compute and print the average

waiting time and average turnaround time. (2 sessions)


chart for Priority and Round robin. For each of the scheduling policies, compute and print the

average waiting time and average turnaround time. (2 sessions)

6. Developing Application using Inter Process Communication (using shared memory, or

message queues)

7. Implement the Producer – Consumer problem using semaphores (using UNIX system calls).

8. Implement some memory management schemes – I

9. Implement some memory management schemes – II

10. Implement any file allocation technique (Linked, Indexed or Contiguous)

Total: 45

6

Example for exercises 8 and 9:

Free space is maintained as a linked list of nodes with each node having the starting byte address and

the ending byte address of a free block. Each memory request consists of the process-id and the

amount of storage space required in bytes. Allocated memory space is again maintained as a linked

list of nodes with each node having the process-id, starting byte address and the ending byte address

of the allocated space. When a process finishes (taken as input) the appropriate node from the

allocated list should be deleted and this free disk space should be added to the free space list. [Care

should be taken to merge contiguous free blocks into one single block. This results in deleting more

than one node from the free space list and changing the start and end address in the appropriate node].

For allocation use first fit, worst fit and best fit.

7

CONTENTS

S.NO LIST OF EXPERIMENTS

PAGE NO

1 Implementation of System Calls 7

2 Implementation of I/O System Calls 18

3 Simulation of UNIX Commands 23

4 a Implementation of FCFS Scheduling 28

4 b Implementation of SJF Scheduling 33

5 a Implementation of Priority Scheduling 38

5 b Implementation of Round Robin Scheduling 42

6 a Inter Process Communication Using Shared Memory 47

6 b Inter Process Communication Using Message Queues 50

7 Producer – Consumer Problem Using Semaphores 55

8 Memory Management Schemes – I 59

9 Memory Management Schemes – II 67

10 File Allocation Technique (Linked, Indexed Or Contiguous) 74

8

STUDY OF LINUX

INTRODUCTION TO LINUX

Linux is a generic term referring to Unix-like computer operating systems based on the Linux

kernel. Their development is one of the most prominent examples of free and open source software

collaboration; typically all the underlying source code can be used, freely modified, and redistributed

by anyone.

The name "Linux" comes from the Linux kernel, originally written in 1991 by Linus Torvalds.

The rest of the system usually comprises components such as the Apache HTTP Server, the X

Window System, the K Desktop Environment, and utilities and libraries from the GNU operating

system (announced in 1983 by Richard Stallman). Many quantitative studies of free / open source

software focus on topics including market share and reliability, with numerous studies specifically

examining Linux. The Linux market is growing rapidly, and the revenue of servers, desktops, and

packaged software running Linux was expected to exceed $35.7 billion by 2008.

LINUX FILE SYSTEM

A file system is the methods and data structures that an operating system uses to keep track of

files on a disk or partition; that is, the way the files are organized on the disk. The word is also used

to refer to a partition or disk that is used to store the files or the type of the file system. The difference

between a disk or partition and the file system it contains is important. A few programs (including,

reasonably enough, programs that create file systems) operate directly on the raw sectors of a disk or

partition; if there is an existing file system there it will be destroyed or seriously corrupted. Most

programs operate on a file system, and therefore won't work on a partition that doesn't contain one (or

that contains one of the wrong type). Before a partition or disk can be used as a file system, it needs

to be initialized, and the bookkeeping data structures need to be written to the disk. This process is

called making a file system.

Most UNIX file system types have a similar general structure, although the exact details vary

quite a bit. The central concepts are superblock, inode, data block, directory block, and indirection

block. The superblock contains information about the file system as a whole, such as its size (the

exact information here depends on the file system). An inode contains all information about a file,

except its name. The name is stored in the directory, together with the number of the inode. A

directory entry consists of a filename and the number of the inode which represents the file. The

9

inode contains the numbers of several data blocks, which are used to store the data in the file. There is

space only for a few data block numbers in the inode, however, and if more are needed, more space

for pointers to the data blocks is allocated dynamically. These dynamically allocated blocks are

indirect blocks; the name indicates that in order to find the data block, one has to find its number in

the indirect block first.

Like UNIX, Linux chooses to have a single hierarchical directory structure. Everything starts

from the root directory, represented by /, and then expands into sub-directories instead of having so-

called 'drives'. In the Windows environment, one may put one's files almost anywhere: on C drive, D

drive, E drive etc. Such a file system is called a hierarchical structure and is managed by the programs

themselves (program directories), not by the operating system. On the other hand, Linux sorts

directories descending from the root directory / according to their importance to the boot process.

Linux, like Unix also chooses to be case sensitive. What this means is that the case, whether in

capitals or not, of the characters becomes very important. This feature accounts for a fairly large

proportion of problems for new users especially during file transfer operations whether it may be via

removable disk media such as floppy disk or over the wire by way of FTP.

The image below shows the file system of Linux

10

The following bin/ dev/ home/ lost+found/ proc/ sbin/ usr/ boot/ etc/ lib/ mnt/ root/ tmp/ var/ are

explained in detail.

/sbin - This directory contains all the binaries that are essential to the working of the system.

These include system administration as well as maintenance and hardware configuration

programs.

/bin - In contrast to /sbin, the bin directory contains several useful commands that are used by

both the system administrator as well as non privileged users.

/boot - This directory contains the system.map file as well as the Linux kernel. Lilo places the

boot sector backups in this directory.

11

/dev - This is a very interesting directory that highlights one important characteristic of the

Linux file system - everything is a file or a directory. Look through this directory and you

should see hda1, hda2 etc, which represent the various partitions on the first master drive of

the system. /dev/cdrom and /dev/fd0 represent your CDROM drive and your floppy drive.

/etc - This directory contains all the configuration files for your system. Your lilo.conf file lies

in this directory as does hosts, resolv.conf and fstab.

/home –These are the user home directories, which can be found under /home/username.

/lib - This contains all the shared libraries that are required by system programs. Windows

equivalent to a shared library would be a DLL file.

/lost+found - Linux should always go through a proper shutdown. Sometimes your system

might crash or a power failure might take the machine down. Either way, at the next boot, a

lengthy filesystem check using fsck will be done. Fsck will go through the system and try to

recover any corrupt files that it finds. The result of this recovery operation will be placed in

this directory.

/mnt - This directory usually contains mount points or sub-directories where you mount your

floppy and your CD.

/opt - This directory contains all the software and add-on packages that are not part of the

default installation.

/proc - This is a special directory on your system.

/root - We talked about user home directories earlier and well this one is the home directory

of the user root.

/tmp - This directory contains mostly files that are required temporarily.

/usr - This is one of the most important directories in the system as it contains all the user

binaries. /usr/src/linux contains the source code for the Linux kernel.

/var - This directory contains spooling data like mail and also the output from the printer

daemon. The above content briefs about Linux and the file system of Linux. Thus the Linux

file system is explained in detail.

12

Uses of Linux

Linux is a widely ported operating system kernel. The Linux kernel runs on a highly diverse range of

computer architectures: in the hand-held ARM-based iPAQ and the mainframe IBM System z9,

System z10; in devices ranging from mobile phones to supercomputers.[68] Specialized distributions

exist for less mainstream architectures. The ELKS kernel fork can run on Intel 8086 or Intel 80286

16-bit microprocessors, while the µClinux kernel fork may run on systems without a memory

management unit. The kernel also runs on architectures that were only ever intended to use a

manufacturer-created operating system, such as Macintosh computers (with both PowerPC and Intel

processors), PDAs, video game consoles, portable music players, and mobile phones. See List of

Linux supported architectures.

Applications of Linux

1. OpenShot (Video editor)

2. Apache (Web server)

3. Firefox (Web browser)

4. Dropbox (Online storage)

5. Asterisk (Telephony)

Linux Advantages

1. Low cost: You don’t need to spend time and money to obtain licenses since Linux and much

of its software come with the GNU General Public License. You can start to work

immediately without worrying that your software may stop working anytime because the free

trial version expire.s

2. Stability: Linux doesn’t need to be rebooted periodically to maintain performance levels. It

doesn’t freeze up or slow down over time due to memory leaks and such. Continuous up-

times of hundreds of days (up to a year or more) are not uncommon.

3. Performance: Linux provides persistent high performance on workstations and on networks.

It can handle unusually large numbers of users simultaneously, and can make old computers

sufficiently responsive to be useful again.

4. Network friendliness: Linux was developed by a group of programmers over the Internet and

has therefore strong support for network functionality; client and server systems can be easily

13

set up on any computer running Linux. It can perform tasks such as network backups faster

and more reliably than alternative systems.

5. Fast and easy installation: Most Linux distributions come with user-friendly installation and

setup programs. Popular Linux distributions come with tools that make installation of

additional software very user friendly as well.

6. Full use of hard disk: Linux continues work well even when the hard disk is almost full.

7. Multitasking: Linux is designed to do many things at the same time; e.g., a large printing job

in the background won’t slow down your other work.

8. Security: Linux is one of the most secure operating systems. “Walls” and flexible file access

permission systems prevent access by unwanted visitors or viruses. Linux users have to option

to select and safely download software, free of charge, from online repositories containing

thousands of high quality packages. No purchase transactions requiring credit card numbers or

other sensitive personal information are necessary.

9. Open Source: If you develop software that requires knowledge or modification of the

operating system code, Linux’s source code is at your fingertips. Most Linux applications are

Open Source as well.

Disadvantages of Linux:

1. Understanding – Becoming familiar with the Linux operating system requires patience as

well as a strong learning curve. You must have the desire to read and figure things out on your

own, rather than having everything done for you. Check out the 20 must read howto’s and

guides for Linux.

2. Compatibility – Because of its free nature, Linux is sometimes behind the curve when it

comes to brand new hardware compatibility. Though the kernel contributors and maintainers

work hard at keeping the kernel up to date, Linux does not have as much of a corporate

backing as alternative operating systems. Sometimes you can find third party applications,

sometimes you can’t.

3. Alternative Programs – Though Linux developers have done a great job at creating

alternatives to popular Windows applications, there are still some applications that exist on

Windows that have no equivalent Linux application. Read Alternatives to Windows

Applications to find out some of the popular alternatives.

14

Ex.No: 1

IMPLEMENTATION OF SYSTEM CALLS

Aim:

To write a program using process system call.

Algorithm:

��NAME

fork – create a new process system call.

SYNOPSIS

#include<unistd.h>

pid_t fork(void);

DESCRIPTION

The fork() function shall create a new process. The new process (child process) shall be an exact copy

of the calling process (parent process). The child process shall have a unique process ID.

System call fork() is used to create processes. It takes no arguments and returns a process ID.

The purpose of fork() is to create a new process, which becomes the child process of the caller. After

a new child process is created, both processes will execute the next instruction following the fork()

system call. Therefore, we have to distinguish the parent from the child. This can be done by testing

the returned value of fork() :

• If fork() returns a negative value, the creation of a child process was unsuccessful.

• fork() returns a zero to the newly created child process.

• fork() returns a positive value, the process ID of the child process, to the parent.

EXECUTION

Parent and children execute concurrently

Parent waits until children terminate

15

��NAME

execl, -execute a file

SYNOPIS

#include<unistd.h>

extern char **environ;

int execl(const char *path, const char *arg(), …/*, (char *)0 */);

DESCRIPTION

The exec family of functions shall replace the current process image with a new process image. The

new image shall be constructed from regular, executable file called the new process image file. There

shall be no return from a successful exec, because the calling process image is overlaid by the new

process image.

Fork-exec is a commonly used technique in Unix whereby an executing process spawns a new

program. fork() is the name of the system call that the parent process uses to "divide" itself ("fork")

into two identical processes. After calling fork(), the created child process is actually an exact copy of

the parent - which would probably be of limited use - so it replaces itself with another process using

the system call exec(). The parent process can either continue execution or wait for the child process

to complete. The child, after discovering that it is the child, replaces itself completely with another

program, so that the code and address space of the original program are lost. If the parent chooses to

wait for the child to die, then the parent will receive the exit code of the program that the child

executed. Otherwise, the parent can ignore the child process and continue executing as it normally

would; to prevent the child becoming a zombie it should wait on children at intervals or on

SIGCHLD. When the child process calls exec(), all data in the original program is lost, and replaced

with a running copy of the new program. This is known as overlaying. Although all data is replaced,

the file descriptors that were open in the parent are closed only if the program has explicitly marked

16

them close-on-exec. This allows for the common practice of the parent creating a pipe prior to calling

fork() and using it to communicate with the executed

program.

Using execl()

The following example executes the ls command, specifying the pathname of the executable (/bin/ls)

and using arguments supplied directly to the command to produce single-column output.

#include<unistd.h>

int ret;

…

ret=execl(“/bin/ls”, “ls”, “-l”, (char *)0);

��NAME

exit, _exit – terminate a process

SYNOPIS

#include<stdlib.h>

void exit(int status);

DESCRIPTION

The exit status will be n, if specified. Otherwise, the value will be the exit value of the last command

executed, or zero if no command was executed. When exit is executed in a trap action, the last

command is considered to be the command that executed immediately preceding the trap action. This

system call is used to terminate (normal/abnormal) the current running program.

��NAME

wait – wait for a child process to stop or terminate

SYNOPIS

#include<sys/types.h>

#include<sys/wait.h>

pid_t wait(int *stat_loc);

DESRIPTION

The wait() and waitpid() functions allow the calling process to obtain status information pertaining to

one of its child processes. Various options permit status information to be obtained for child

17

processes that have terminated or stopped. If status information is available for two or more child

processes, the order in which their status is reported is unspecified.

There are a number of system calls that a process can use to obtain file information. The most useful

one is "stat" system call. The stat() system call is used to obtain file information.

_ A parent process usually needs to synchronize its actions by waiting until the child process has

either stopped or terminated its actions.

_ The wait() system call allows the parent process to suspend its activities until one of these

actions has occurred.

_ The wait() system call accepts a single argument, which is a pointer to an integer and returns a

value defined as type pid_t.

_ If the calling process does not have any child associated with it, wait will return immediately

with a value of -1.

_ If any child processes are still active, the calling process will suspend its activity until a child

process terminates.

��NAME

Readdir() –To read a directory

SYNOPSIS

#include <sys/types.h>

#include <dirent.h>

struct dirent *readdir(DIR *dir);

DESCRIPTION

The readdir() function returns a pointer to a dirent structure representing the next directory entry in

the directory stream pointed to by dir. It returns NULL on reaching the end-of-file or if an error

occurred. On Linux, the dirent structure is defined as follows:

struct dirent {

ino_t d_ino; /* inode number */

off_t d_off; /* offset to the next dirent */

unsigned short d_reclen; /* length of this record */

unsigned char d_type; /* type of file */

char d_name[256]; /* filename */

18

};

The data returned by readdir() may be overwritten by subsequent calls to readdir() for the same

directory stream.

RETURN VALUE

The readdir() function returns a pointer to a dirent structure, or NULL if an error occurs or end-of-file

is reached. On error, errno is set appropriately.

��NAME

Opendir() – To open a directory

SYNOPSIS

#include <sys/types.h>

#include <dirent.h>

DIR *opendir(const char *name);

DESCRIPTION

The opendir() function opens a directory stream corresponding to the directory name, and returns a

pointer to the directory stream. The stream is positioned at the first entry in the directory.

RETURN VALUE

The opendir() function returns a pointer to the directory stream. On error, NULL is returned, and

errno is set appropriately.

19

Program:

a) fork, execl, getpid, exit, wait

#include<stdio.h>


void main()

{

pid_t pid;

int i;

pid=getpid();

printf("\nbefore fork %d",pid);

pid=fork();

if(pid==0)

printf("/n nth this line from child \n thechild processid %d value=%d",getpid(),i);

else if(pid==1)

printf("\nthis line is from parent value=%d",i);

else if(pid<1)

{

printf("\n fork failed");

exit(1);

}

if(pid==0)

{

execl("/bin/ls", "ls" ,"-1",(char*)0);

}

if(pid > 0)

wait((int *)0);

}

20

OUTPUT:

[cs2002@localhost ~]$ cc psc.c

[cs2002@localhost ~]$ ./a.out

before fork 3749/n nth this line from child

a.out

data

elamugil

hai.c

isc.c

kumar

l4.c

21

b) stat

#include<stdio.h>

#include<sys/stat.h>

main()

{

int fd;

char pathl[10];

struct stat*nfile;

nfile=(struct stat*)malloc(sizeof(struct stat));

printf("\n Enter the file name:\t");

scanf("%s",pathl);

stat(pathl,nfile);

printf("Program inodeno:%d\n",nfile->st_ino);

printf("Program Size :%d\n",nfile->st_blksize);

printf("Access Time :%s\n",ctime(&nfile->st_atime));

printf("Modified Time :%s\n",ctime(&nfile->st_mtime));

printf("Protection :%d\n",nfile->st_mode);

printf("User id :%d\n",nfile->st_uid);

printf("Group id :%d\n",nfile->st_gid);

printf("Device driverno:%d\n",nfile->st_dev);

printf("No. of links :%d\n",nfile->st_nlink);

return 0;

}

22

OUTPUT:

[cse04@LINUXSERVER aravind]$ cc status.c

[cse04@LINUXSERVER aravind]$ ./a.out

Enter the file name: sum.sh

Program inodeno:1815607

Program Size :4096

Access Time :Thu Mar 30 11:45:06 2006

Modified Time :Tue Mar 7 10:31:36 2006

Protection :33204

User id :514

Group id :514

Device driverno:769

No. of links :1

23

c) opendir & readdir

//ls command implementation using opendir & readdir

//ls command implementation

#include<stdio.h>

#include<dirent.h>

main(int argc,char *argv[])

{

DIR * dir;

struct dirent *direntry;

dir=opendir(argv[1]);

while((direntry=readdir(dir))!=NULL)

printf("%d %s\n",direntry->d_ino,direntry->d_name);

closedir(dir);

}

24

OUTPUT:

[cse04@LINUXSERVER vaishu]$ cc ordir.c

[cse04@LINUXSERVER vaishu]$ ./a.out uma

1750301 .

3270767 ..

1750302 aaa

Result:

Thus the process system call program was executed.

25

Ex.No: 2

IMPLEMENTATION OF I/O SYSTEM CALL

Aim:

To write a program for I/O system calls.

DESCRIPTION

File-I/O through system calls is simpler and operates at a lower level than making calls to the C file-

I/O library. There are seven fundamental file-I/O system calls:

creat() Create a file for reading or writing.

open() Open a file for reading or writing.

close() Close a file after reading or writing..

write() Write bytes to file.

read() Read bytes from file.

These calls were devised for the UNIX operating system and are not part of the ANSI C spec. Use of

these system calls requires a header file named "fcntl.h":

The creat() Sytem Call

The "creat()" system call, of course, creates a file.

It has the syntax:

int fp; /* fp is the file descriptor variable */

fp = creat( <filename>, <protection bits> );

Ex: fp=creat(“students.dat”,RD_WR);

This system call returns an integer, called a "file descriptor", which is a number that identifies the file

generated by "creat()". This number is used by other system calls in the program to access the file.

Should the "creat()" call encounter an error, it will return a file descriptor value of -1.

The "filename" parameter gives the desired filename for the new file. The "permission bits" give the

"access rights" to the file. A file has three "permissions" associated with it:

1. Write permission - Allows data to be written to the file.

2. Read permission - Allows data to be read from the file.

3. Execute permission - Designates that the file is a program that can be run.

26

These permissions can be set for three different levels:

User level: Permissions apply to individual user.

Group level: Permissions apply to members of user's defined "group".

System level: Permissions apply to everyone on the system.

The open() Sytem Call

The "open()" system call opens an existing file for reading or writing.

It has the syntax:

<file descriptor variable> = open( <filename>, <access mode> );

The "open()" call is similar to the "creat()" call in that it returns a file descriptor for the given file, and

returns a file descriptor of -1 if it encounters an error. However, the second parameter is an "access

mode", not a permission code. There are three modes (defined in the "fcntl.h" header file):

O_RDONLY Open for reading only.

O_WRONLY Open for writing only.

O_RDWR Open for reading and writing.

For example, to open "data" for writing, assuming that the file had been created by another program,

the following statements would be used:

int fd;

fd = open( "students.dat", O_WRONLY );

A few additional comments before proceeding:

A "creat()" call implies an "open()". There is no need to "creat()" a file and then "open()" it.

The close() Sytem Call

The "close()" system call is very simple. All it does is "close()" an open file when there is no further

need to access it.

The "close()" system call has the syntax:

close( <file descriptor> );

The "close()" call returns a value of 0 if it succeeds, and returns -1 if it encounters an error.

The write() Sytem Call

The "write()" system call writes data to an open file.

It has the syntax:

write( <file descriptor>, <buffer>, <buffer length> );

27

The file descriptor is returned by a "creat()" or "open()" system call. The "buffer" is a pointer to a

variable or an array that contains the data; and the "buffer length" gives the number of bytes to be

written into the file. While different data types may have different byte lengths on different systems,

the "sizeof()" statement can be used to provide the proper buffer length in bytes. A "write()" call

could be specified as follows:

float array[10];

write( fd, array, sizeof( array ) );

The "write()" function returns the number of bytes it actually writes. It will return -1 on an error.

The read() Sytem Call

The "read()" system call reads data from a open file. Its syntax is exactly the same as that of the

"write()" call:

read( <file descriptor>, <buffer>, <buffer length> );

The "read()" function returns the number of bytes it actually returns.

At the end of file it returns 0, or returns -1 on error.

Algorithm:

1. Start the Program.

2. Open a file for O_RDWR for read and write, O_CREATE for creating a file, O_TRUNC for

truncates a file.

3. Using getchar function, read the character and stored in the string [] array.

4. The string [] array is write into a file and close it.

5. Then the file is opened for read only mode and read the characters and displayed it and close

the file.

6. Stop the program.

28

Program:

#include<sys/stat.h>

#include<stdio.h>

#include<fcntl.h>


int main()

{

int n,i=0;

int f1,f2;

char c,strin[100];

f1=open("data",O_RDWR|O_CREAT|O_TRUNC);

while((c=getchar())!='\n')

{

strin[i++]=c;

}

strin[i]='\0';

write(f1,strin,i);

close(f1);

f2=open("data",O_RDONLY);

read(f2,strin,0);

printf("\n%s\n",strin);

close(f2);

return 0;

}

29

OUTPUT:

[cs2002@localhost ~]$ cc isc.c

[cs2002@localhost ~]$ ./a.out

HAI WELCOME TO CSE

HAI WELCOME TO CSE

[cs2002@localhost ~]$

Result:

Thus the I/O system call program was executed.

30

Ex.No:3

SIMULATION OF UNIX COMMANDS

Aim:

To write a program for simulation of unix commands ls and grep.

DESCRIPTION

The ls Command

Syntax:

ls [options] [names]

Description:

"ls" stands for list. It is used to list information about files and directories.

Examples:

ls

This is the basic "ls" command, with no options. It provides a very basic listing of the files in your

current working directory. Filenames beginning with a decimal are considered hidden files, and they

are not shown.

ls -a

The -a option tells the ls command to report information about all files, including hidden files.

ls -l

The -l option tells the "ls" command to provide a long listing of information about the files and

directories it reports. The long listing will provide important information about file permissions, user

and group ownership, file size, and creation date.

ls -al

This command provides a long listing of information about all files in the current directory. It

combines the functionality of the -a and -l options. This is probably the most used version of the ls

command.

ls -al /usr

31

This command lists long information about all files in the "/usr" directory.

ls -alR /usr | more

This command lists long information about all files in the "/usr" directory, and all sub-directories of

/usr. The -R option tells the ls command to provide a recursive listing of all files and sub-directories.

ls -ld /usr

Rather than list the files contained in the /usr directory, this command lists information about the /usr

directory itself (without generating a listing of the contents of /usr). This is very useful when you

want to check the permissions of the directory, and not the files the directory contains.

The grep Command

Syntax:

grep flag PatternList filename

The grep command is a Unix command that is used to search for patterns within one or more files. It

displays the name of the file that contains the matched line.

Following is a list of some flags used with the grep command: Flag Description

-c Displays a count of matching lines.

-f Specifies a file containing search patterns.

-p Displays the entire paragraph containing matched lines.

-v Displays all lines not matching the specified pattern.

PatternList Specifies one or more patterns to be used during the search.

File Specifies the name of the file that is to be searched for the pattern.

Algorithm:

1. Start the program.

2. Enter the options.

3. If the option is “1” call ls command and it display the files.

4. If the option is “2” call gerp command and match the given pattern with the read word and if

it matches, display the line of occurance.

5. If the option is “3” call cp command.

6. If the option is “4” call rm command.


32

Program:

#include<stdio.h>

main()

{

char c;

int n;

printf("1.list of files in the directory\n2.list the lines\n3.copy\n4.remove\n");

scanf("%d",&n);

switch(n)

{

case 1:

system("ls");

break;

case 2:

system("grep argc lsgp.c");

break;

case 3:

system(" cp lsgp.c gpls.c");

printf("the file is copied");

break;

case 4:

system("rm lsgp.c");

printf("the file is deleted");

break;

}

}

33

OUTPUT:

[it53@localhost ~]$ cc lsgp.c

[it53@localhost ~]$ ./a.out

1.list of files in the directory

2.list the lines

3.copy

4.remove

1

3q bit.c ftp.c ospf1.c praba.c rarp.c smp.c sort.sh

a.out forkexec.c io.c praba1.sh praba.sh sample sorting.sh syscall.c



2.list the lines

3.copy

4.remove

2

system("grep argc lsgp.c");



2.list the lines

3.copy

4.remove

3

the file is copied[it53@localhost ~]$ ./a.out


2.list the lines

3.copy

4.remove

4

the file is deleted

34

Result:

Thus the program for simulation of unix commands ls and grep was executed.

35

Ex.No:4(a)

IMPLEMENTATION OF FCFS SCHEDULING

Aim:

To write the program for first come first serve scheduling.

DESCRIPTION

First-Come, First-Served (FCFS) Scheduling

36

Algorithm:


2. Get the number of processes and their burst time.

3. Initialize the waiting time for process 1 is 0.

4. The waiting time and turn around time for other processes are calculated as

p[i].wt=p[i-1].bt+p[i-1].wt;

p[i].tt=p[i].bt+p[i].wt;

5. The waiting time and turn around time for all the processes are summed and then the average

waiting time and turn around time are calculated.

6. The average waiting time and turn around time are displayed.


37

Program:

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

struct process

{

int pid;

int wt,tt,bt;

}

p[100];

void main()

{

int tottt,totwt,avgtt,avgwt,i,j,n;

clrscr();

printf("\nEnter Number of process");

scanf("\n%d",&n);

for(i=1;i<=n;i++)

{

p[i].pid=i;

printf("\nEnter %dst Burst Time:",i);

scanf("\n%d",&p[i].bt);

}

p[1].wt=0;

p[1].tt=p[1].bt+p[1].wt;

i=2;

while(i<=n)

{

p[i].wt=p[i-1].tt;


i++;

}

38

totwt=tottt=0;

i=1;

printf("\n\t=============================");

printf("\n\tProcess id\tBT\tWT\tTT");

printf("\n\t=============================");

while(i<=n)

{

printf("\n\t%d\t%d\t%d\t%d\t",p[i].pid,p[i].bt,p[i].wt,p[i].tt);

totwt=p[i].wt+totwt;

tottt=p[i].tt+tottt;

i++;

}

totwt=totwt/n;

tottt=tottt/n;

printf("\n\n\n\tAVGWT\tAVGTT");

printf("\n\t%d\t%d",totwt,tottt);

getch();

}

39

OUTPUT:

Enter Number of process3

Enter 1st Burst Time:12



===============================

Process id BT WT TT

===============================

1 12 0 12

2 34 12 46

3 56 46 102

AVGWT AVGTT

19 53

Result:

Thus the program for first come first serve algorithm was executed.

40

Ex.No:4(b)

IMPLEMENTATION OF SJF SCHEDULING

Aim:

To write the program for shortest job first scheduling.

DESCRIPTION

Associate with each process the length of its next CPU burst. Use these lengths to schedule the

process with the shortest time

Two schemes:

non preemptive� once CPU given to the process it cannot be preempted until completes its CPU

burst

preemptive � if a new process arrives with CPU burst length less than remaining time of current

executing process, preempt. This scheme is known as the Shortest-Remaining-Time-First (SRTF)

SJF is optimal � gives minimum average waiting time for a given set of processes

41

Algorithm:


2. Get the number of processes and their burst time.


4. The processes are stored according to their burst time.








42

Program:

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

struct process

{

int pid;

int wt,tt,bt;

}

p[100];

void main()

{

struct process temp;


clrscr();


scanf("\n%d",&n);

for(i=1;i<=n;i++)

{

p[i].pid=i;

printf("\nEnter %d Burst Time:",i);


}

for(i=1;i<=n;i++)

{

for(j=i+1;j<=n;j++)

{

if(p[i].bt>p[j].bt)

{

/*temp.pid=p[j].pid;

43

p[j].pid=p[i].pid;

p[i].pid=temp.pid;

temp.bt=p[j].bt;

p[j].bt=p[i].bt;

p[i].bt=temp.bt; */

temp=p[j];

p[j]=p[i];

p[i]=temp;

} } }

p[1].wt=0;

p[1].tt=p[1].bt+p[1].wt;

i=2;

while(i<=n)

{

p[i].wt=p[i-1].tt;


i++;

}

totwt=tottt=0;

i=1;

printf("\n\t=================================");

printf("\n\t Process id \tBT\tWT\tTT");

printf("\n\t================================");

while(i<=n)

{




i++;

}

totwt=totwt/n;

44

tottt=tottt/n;



getch();

}

OUTPUT

Enter Number of process:5

Enter 1 Burst Time: 8





===================================

Process id BT WT TT

===================================

4 2 0 2

2 4 2 6

3 7 6 13

1 8 13 21

5 9 21 30

AVGWT AVGTT

8 14

Result:

Thus the program for shortest job first algorithm was executed.

45

Ex.No:5(a)

IMPLEMENTATION OF PRIORITY SCHEDULING

Aim:

To write the program to perform priority scheduling.

DESCRIPTION

A priority number (integer) is associated with each process

The CPU is allocated to the process with the highest priority (smallest integer => highest priority)

- Preemptive

- non preemptive

SJF is a priority scheduling where priority is the predicted next CPU burst time

Problem Starvation – low priority processes may never execute

Solution Aging – as time progresses increase the priority of the process

Algorithm:


2. Get the number of processes, their burst time and priority.


4. Based upon the priority processes are arranged.








46

Program:

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

struct process

{

int pid;

int wt,tt,bt,prior;

}

p[100],temp;

void main()

{


clrscr();


scanf("\n%d",&n);

for(i=1;i<=n;i++)

{

p[i].pid=i;

printf("\nEnter %dst Burst Time:",i);


printf("\nEnter %dpriority",i);

scanf("\n%d",&p[i].prior);

}

for(i=1;i<=n;i++)

{

for(j=i+1;j<=n;j++)

{

if(p[i].prior>p[j].prior)

{

temp=p[j];

47

p[j]=temp;

} } }

p[1].wt=0;

p[1].tt=p[1].bt+p[1].wt;

i=2;

while(i<=n)

{

p[i].wt=p[i-1].tt;


i++; }

totwt=tottt=0;

i=1;

printf("\n\t===============================");

printf("\n\tPSSID\tBT\tWT\tTT");

printf("\n\t===============================");

while(i<=n)

{




i++;

}

totwt=totwt/n;

tottt=tottt/n;



getch();

}

48

OUTPUT:

Enter Number of process3


Enter 1priority3


Enter 2priority1


Enter 3priority2

===============================

PSSID BT WT TT

===============================

1 5 0 5

2 7 5 12

3 8 12 20

AVGWT AVGTT

5 12

Result:

Thus the program for priority scheduling was executed.

49

Ex.No:5(b)

IMPLEMENTATION OF ROUND ROBIN SCHEDULING

Aim:

To write a program for Round Robin Scheduling.

DESCRIPTION

Each process gets a small unit of CPU time (time quantum), usually 10-100 milliseconds. After this

time has elapsed, the process is preempted and added to the end of the ready queue.

If there are n processes in the ready queue and the time quantum is q, then each process gets 1/n of

the CPU time in chunks of at most q time units at once. No process waits more than (n-1)q time units.

Performance

q large � FIFO

q small � q must be large with respect to context switch, otherwise overhead is too high

50

Algorithm:


2. Get the number of processes, their burst time and time slice for each process.

3. Calculate the total burst time.

4. To check whether the burst time of process is less then the time slice, the required time only

allotted to the process.

5. If the burst time of process is greater than the time slice one time slice is allotted for the

process and burst time is subtracted by one time slice.

6. Step 4 and 5 is repeated up to process burst time is 0.





51

Program:

#include<stdio.h>

#include<conio.h>

struct process

{

int pid,bt,tt,wt;

};

int main()

{

struct process x[10],p[30];

int i,j,k,tot=0,m,n;

float wttime=0.0,tottime,a1,a2;

clrscr();

printf("\nEnter No.of process\t");

scanf("%d",&n);

for(i=1;i<=n;i++)

{

x[i].pid=i;

printf("Enter The Burst Time \t");

scanf("%d",&x[i].bt);

tot=tot+x[i].bt;

}

printf("Total Burst Time:\t%d",tot);

p[0].tt=0;

k=1;

printf("\nEnter The Time Slice:\t");

scanf("%d",&m);

for(j=1;j<=tot;j++)

{

for(i=1;i<=n;i++)

{

52

if(x[i].bt!=0)

{

p[k].pid=i;

if(x[i].bt-m<0)

{

p[k].wt=p[k-1].tt;

p[k].bt=x[i].bt;

p[k].tt=p[k].wt+x[i].bt;

x[i].bt=0;

k++;

}

else

{

p[k].wt=p[k-1].tt;

p[k].tt=p[k].wt+m;

x[i].bt=x[i].bt-m;

k++;

} } }

}

printf("\nprocess id\ttwt\ttt");

for(i=1;i<k;i++)

{

printf("\n\t%d\t%d\t%d",p[i].pid,p[i].wt,p[i].tt);

wttime=wttime+p[i].wt;

tottime=tottime+p[i].tt;

a1=wttime/n;

a2=tottime/n;

}

printf("\n\nAverage Waiting Time:\t%f",a1);

printf("\n\nAverage TurnAround Time:\t%f",a2);

getch();

53

return 0;

}

OUTPUT:

Enter No.of process 3

Enter The Burst Time 5



Total Burst Time: 18

Enter The Time Slice: 3

process id twt tt

1 0 3

2 3 6

3 6 9

1 9 11

2 11 14

3 14 17

3 17 18

Average Waiting Time: 20.000000

Average TurnAround Time: 26.000000

Result:

Thus the program for Round Robin Scheduling was executed.

54

Ex.No:6(a)

INTERPROCESS COMMUNICATION USING

SHARED MEMORY

Aim:

To write a program for interprocess communication using shared memory.

DESCRIPTION

A shared memory is an extra piece of memory that is attached to some address spaces for

their owners to use. As a result, all of these processes share the same memory segment and have

access to it. Consequently, race conditions may occur if memory accesses are not handled properly.

The following figure shows two processes and their address spaces. The yellow rectangle is a shared

memory attached to both address spaces and both process 1 and process 2 can have access to this

shared memory as if the shared memory is part of its own address space. In some sense, the original

address space is "extended" by attaching this shared memory.

Algorithm:

1. Start the program

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 inn shared memory using shmpet 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 shnot pointer

7. Now, detach and rebase the shared memory

8. Stop the program

55

Program:


#include<sys/shm.h>

#include<sys/ipc.h>

main()

{

int shmid;

key_t key=0*10;

shmid=shmget(key,100,IPC_CREAT|0666);

if(shmid<0)

printf("\nfirst SHMID failed\n");

else

printf("\n first SHMID succeded id=%d\n",shmid);


if(shmid<0)

printf("\nsecond SHMID failed\n");

else

printf("\n secondt SHMID succeded id=%d\n",shmid);


if(shmid<0)

printf("\nthird SHMID failed\n");

else

printf("\n third SHMID succeded id=%d\n",shmid);

}

56

OUTPUT:

[cse2@localhost ~]$ cc share.c

[cse2@localhost ~]$ ./a.out

first SHMID succeded id=589833

secondt SHMID succeded id=622604

third SHMID succeded id=655373

[cse2@localhost ~]$

Result:

Thus the interprocess communication using shared memory was successfully executed

57

Ex.No:6(b)

INTER PROCESS COMMUNICATION USING

PIPE PROCESSING

Aim:

To write a program for interprocess communication using pipe processing.

DESCRIPTION

Using pipes for establishing a communication between two processes. As a first step we need

to identify two executables that need to communicate. As an example, consider a case where one

process gets a character string input and communicates it to the other process which reverses strings.

Then we have two processes which need to communicate. Next we define a pipe and connect it

between the processes to facilitate communication. One process gets input strings and writes into the

pipe. The other process, which reverses strings, gets its input (i.e. reads) from the pipe.

Figure explains how the pipes are used. As shown in the upper part of the figure, a pipe has an

input end and an output end. One can write into a pipe from the input end and read from the output

end. A pipe descriptor, therefore, has an array that stores two pointers. One pointer is for its input end

and the other is for its output end. When a process defines a pipe it gets both the addresses, as shown

in the middle part of Figure. Let us suppose array pp is used to store the descriptors. pp[0] stores the

write end address and pp[1] stores the read end address. Suppose two processes, Process A and

Process B, need to communicate, then it is imperative that the process which writes closes its read

end of the pipe and the process which read closes its write end of the pipe. Essentially, for a

communication from Process A to process B the following should happen. Process A should keep its

write end open and close read end of the pipe. Similarly, Process B should keep its read end open and

close its write end.

Let us now describe how we may accomplish this.

1. First we have a parent process which declares a pipe in it.

2. Next we spawn two child processes. Both of these would get the pipe definition which we have

defined in the parent. The child processes, as well as the parent, have both the write and read

58

ends of the pipe open at this time.

3. Next, one child process, say Process A, closes its read end and the other child process, Process B,

closes its write end.

4. The parent process closes both write and read ends.

5. Next, Process A is populated with code to get a string and Process B is populated to reverse a

string. With the above arrangement the output from Process A is piped as input to Process B.

The programs given below precisely achieve this.

In reading the programs, the following interpretations have to be borne in mind:

1. The pipe is defined by the declaration pipe(p_des).

2. The dup command replaces the standard I/O channels by pipe descriptors.

3. The execlp command is used to populate the child process with the desired code.

4. The close command closes the appropriate ends of the pipe.

5. The get_str and rev_str processes are pre-compiled to yield the required executables.

59

Algorithm:


2. Create the child process using fork().

3. Create the pipe structure using pipe().

4. Now close the read end of the parent process using close().

5. Write the data in the pipe using write().

6. Now close the write end of child process using close().

7. Read the data in the pipe using read().

8. Display the string.


60

Program:

#include<unistd.h>

main()

{

int fd[3],pid;

char *msg=("OS LAB\n");

char buff[25];

pipe(fd);

pid=fork();

if(pid==0)

{

puts("child process\n");

close(fd[0]);

write(fd[1],msg,30);

}

else

{

sleep(1);

puts("parent process\n");

close(fd[1]);

read(fd[0],buff,30);

printf("%s",buff);

}

}

61

OUTPUT:

[cse2@localhost ~]$ cc pipe.c

[cse2@localhost ~]$ ./a.out

child process

parent process

OS LAB

[cse2@localhost ~]$

Result:

Thus the interprocess communication using pipe process was successfully executed.

62

Ex.No:7

PRODUCER - CONSUMER PROBLEM USING SEMAPHORE

Aim:

To write a program for producer/consumer problem using semaphores.

DESCRIPTION

This is an illustration of a solution to the classic producer-consumer (bounded-buffer) problem using

semaphores.

CONCEPT�� Producers produce items to be stored in the buffer. Consumers remove and consume

items which have been stored. Mutual exclusion must be enforced on the buffer itself. Moreover,

producers can store only when there is an empty slot, and consumers can remove only when there is a

full slot. Three semaphores are used. The binary semaphore mutex controls access to the buffer itself.

The counting semaphore empty keeps track of empty slots, and the counting semaphore full keeps

track of full slots. In this example, the buffer is implemented as an array of size MAX treated as a

circular (ring) buffer. Variables in and out give the index of the next position for putting in and taking

out (if any). Variable count gives the number of items in the buffer.

Algorithm:


2. Declare the variables in the type of pthread_t as tid_produce tid_consume.

3. Declare a structure for semaphore variables.

4. During run time read the number of items to be produced and consumed.

5. Declare and define semaphore function for creation and destroy.

6. Define producer function.

7. Define consumer function.

8. Call producer and consumer function.

9. Stop the execution.

63

Program:

#include <stdio.h>

#include <semaphore.h>

#include <pthread.h>

#define NBUFF 10

int nitems;

struct {

int buff[NBUFF];

sem_t mutex, nempty, nstored;

} shared;

void *produce (void *);

void *consume (void *);

int main(int argc, char **argv)

{

pthread_t tid_produce, tid_consume;

if(argc !=2)

{

printf("Useage: filename <nitems> ");

return 0;

}

printf ("\n\n Producer - Consumer Problem using Semaphore\n");

printf (" -------------------------------------------\n\n");

nitems=atoi(argv[1]);

sem_init(&shared.mutex,0,1);

sem_init(&shared.nempty,0,NBUFF);

sem_init(&shared.nstored,0,0);

pthread_setconcurrency(2);

pthread_create(&tid_produce,NULL,produce,NULL);

pthread_create(&tid_consume,NULL,consume,NULL);

pthread_join(tid_produce,NULL);

pthread_join(tid_consume,NULL);

64

sem_destroy(&shared.mutex);

sem_destroy(&shared.nempty);

sem_destroy(&shared.nstored);

}

void *produce (void *arg)

{

int i;

for(i=0;i<nitems;i++)

{

sem_wait(&shared.nempty);

sem_wait(&shared.mutex);

shared.buff[i % NBUFF]=i;

printf ("\tProducer.....");

printf ("buff[%d] = %d\n\n",i,shared.buff[i % NBUFF]);

sem_post(&shared.mutex);

sem_post(&shared.nstored);

sleep(3);

}

return NULL;

}

void *consume (void *arg)

{

int i;

for(i=0;i<nitems;i++)

{

sem_wait(&shared.nstored);

sem_wait(&shared.mutex);

printf("\tConsumer.....");

printf("buff[%d] = %d\n\n\n",i,shared.buff[i%NBUFF]);

sem_post(&shared.mutex);

sem_post(&shared.nempty);

65

sleep(3);

}

return NULL;

}

OUTPUT:

[root@NS2-05 root]# cc -pthread prod_cons.c

[root@NS2-05 root]# ./a.out 4

Producer - Consumer Problem using Semaphore

-------------------------------------------

Producer.....buff[0] = 0

Consumer.....buff[0] = 0







Result:

Thus the program to implement producer and consumer problem using semaphores was

executed.

66

Ex.No: 8

MEMORY MANAGEMENT SCHEMES – I

FIRST FIT BEST FIT

Aim:

To write a program for first fit and best fit algorithm for memory management.

DESCRIPTION

��Memory Management Algorithms

In an environment that supports dynamic memory allocation, the memory manager must keep a

record of the usage of each allocatable block of memory. This record could be kept by using almost

any data structure that implements linked lists. An obvious implementation is to define a free list of

block descriptors, with each descriport containing a pointer to the next descriptor, a pointer to the

block, and the length of the block. The memory manager keeps a free list pointer and inserts entries

into the list in some order conducive to its allocation strategy. A number of strategies are used to

allocate space to the processes that are competing for memory.

��First Fit

Another strategy is first fit, which simply scans the free list until a large enough hole is found.

Despite the name, first-fit is generally better than best-fit because it leads to less fragmentation. Small

holes tend to accumulate near the beginning of the free list, making the memory allocator search

farther and farther each time.Solution: Next Fit

��Best Fit

The allocator places a process in the smallest block of unallocated memory in which it will fit. It

requires an expensive search of the entire free list to find the best hole. More importantly, it leads to

the creation of lots of little holes that are not big enough to satisfy any requests. This situation is

called fragmentation, and is a problem for all memory-management strategies, although it is

67

particularly bad for best-fit. One way to avoid making little holes is to give the client a bigger block

than it asked for. For example, we might round all requests up to the next larger multiple of 64 bytes.

That doesn't make the fragmentation go away, it just hides it.

• Unusable space in the form of holes is called external fragmentation

• Unusable space in the form of holes is called external fragmentation

Algorithm:


2. Get the number of segments and size.

3. Get the memory requirement and select the option.

4. If the option is ‘2’ call first fit function.

5. If the option is ‘1’ call best fit function.

6. Otherwise exit.

7. For first fit, allocate the process to first possible segment which is free.

8. For best fit, do the following steps.

a. Sorts the segments according to their sizes.

b. Allocate the process to the segment which is equal to or slightly greater than the

process size.


68

Program:

#include<stdio.h>

#include<conio.h>

#define MAXSIZE 25

void printlayout(int[],int );

int firstfit(int[],int, int);

int bestfit(int[],int, int);

void main()

{

int i,a[25],n,req,choice,pos,ch;

clrscr();

printf("How MAny Segments");

scanf("%d",&n);

for(i=0;i<n;i++)

{

printf("Segent Size");

scanf("%d",&a[i]);

}

loop:

printf("How Much Is Your Memory Requirment");

scanf("%d",&req);

printf("\n1.Bestfit\n2.Firstfit\n3.Exit\n");

printf("Enter Your Choice\n");

scanf("%d",&choice);

switch(choice)

{

case 1:

pos=bestfit(a,n,req);

break;

case 2:

pos=firstfit(a,n,req);

69

break;

}

printf("\tBestfit and Firstfit Algorithm\n");

printf("\t______________________________\n\n");

printlayout(a,n);

printf("Your Memory Requirment is :%d\n\n",req);

printf("Alloted Memory Region is:%d\n\n",a[pos]);

a[pos]=0;

printf("Do You Want To Continue 1/0");

scanf("%d",&ch);

if(ch==1)

goto loop;

getch();

}

void printlayout(int a[],int n)

{

int i,j;

printf("\t\tMemory Free List");

printf("\n\t\t_______________\n\n");

printf("\t\t|~~~|\n");

for(i=0;i<n;i++)

{

if(a[i]!=0)

{

for(j=1;j<=(a[i]/100);j++)

printf("\t\t| |\n");

printf("\t\t| %d|\n",a[i]);

printf("\t\t|---|\n");

}}

printf("\n\n");

}

70

int firstfit(int a[],int n,int r)

{

int i;

for(i=0;i<n;i++)

if(a[i]>=r)

break;

return i;

}

int bestfit(int a[],int n,int r)

{

int b[25],i,j,temp,val;

for(i=0;i<n;i++)

b[i]=a[i];

for(i=0;i<n-1;i++)

for(j=i;j<n-1;j++)

if(b[i]>b[j])

{

temp=b[i];

b[i]=b[j];

b[j]=temp;

}

for(i=0;i<n;i++)

if(b[i]>=r)

break;

val=b[i];

for(i=0;i<n;i++)

if(a[i]==val)

break;

return i;

}

71

OUTPUT:

How Many Segments4

Segent Size500

Segent Size200

Segent Size300

Segent Size400

How Much Is Your Memory Requirment200

1.Bestfit

2.Firstfit

3.Exit

Enter Your Choice 1

Bestfit and Firstfit Algorithm

___________________________________

Memory Free List

___________________________________

|~~~|

| |

| |

| |

| |

|500|

| --- |

| |

| |

|200|

| --- |

| |

| |

| |

|300|

72

| --- |

| |

| |

| |

| |

|400|

| --- |

Your Memory Requirment is :200

Alloted Memory Region is:200

Do You Want To Continue 1/0

1

How Much Is Your Memory Requirment250

1.Bestfit

2.Firstfit

3.Exit

Enter Your Choice

1

Bestfit and Firstfit Algorithm

___________________________________

Memory Free List

___________________________________

|~~~|

| |

| |

| |

|500|

73

| --- |

| |

| |

|300|

| --- |

| |

| |

| |

|400|

| --- |

Your Memory Requirment is :250

Alloted Memory Region is:300

Do You Want To Continue 1/0

0

Result:

Thus the program for best fit and first fit algorithm for memory management was executed.

74

Ex.No:9

MEMORY MANAGEMENT SCHEMES – II

PAGE REPLACEMENT

Aim:

To write a program for page replacement algorithms (FIFO and LRU) for memory

management.

DESCRIPTION

�Page replacement algorithms are used to decide what pages to page out when a page needs to be

allocated. This happens when a page fault occurs and free page cannot be used to satisfy allocation

FIFO:

�The frames are empty in the beginning and initially no page fault occurs so it is set to minus one.

When a page fault occurs the page reference string is brought into memory. The operating system

keeps track of all the pages in memory, herby keeping track of the most recently arrived and the

oldest one. If the page in the page reference string is not in memory, the page fault is incremented and

the oldest page is replaced. If the page in the page reference string is in the memory, take the next

page without calculating the page fault. Take the next page in the page reference string and check if

the page is already present in the memory or not. Repeat the process until all the pages are referred

and calculate the page fault for all those pages in the page reference string for the number of available

frames.

LRU :

�A good approximation to the optimal algorithm is based on the observation that pages that have

been heavily used in the last few instructions will probably be heavily used again in the next few.

Conversely, pages that have not been used for ages will probably remain unused for a long time. This

idea suggests a realizable algorithm: when a page fault occurs, throw out the page that has been

unused for the longest time. This strategy is called LRU (Least Recently Used) paging.

75

Algorithm:

1. Start the program

2. Obtain the number of sequences, number of frames and sequence string from the user

3. Now when a page is not in the frame comes, increment the number of page fault and remove

the page that come in the first in FIFO algorithm

4. In LRU algorithm, when a page fault occurs, the page which most recently used is removed

5. Display the number of faults

6. Stop the program

76

Program:

#include<stdio.h>

int m,n,i,j,k,flag,count=0,refer[100],page_frame[100][2],fault=0,min,no_frames;

void replace(int z)

{

for(i=0;i<n;i++)

{

flag=1;

for(j=0;j<no_frames;j++)

if(refer[i]==page_frame[j][0])

{

m=j;

flag=0;

}

if(flag)

{

fault++;

min=32000;


if(page_frame[j][1]<min)

{

min=page_frame[j][1];

k=j;

}

page_frame[k][0]=refer[i];

page_frame[k][1]=++count;


printf("%d",page_frame[j][0]);

printf("\n");

}

else

77

{

printf("no page fault\n");

if(z==2)

page_frame[m][1]=++count;

}

}

printf("number of page fault is:%d\n",fault);

}

int main()

{

printf("\nEnter the number of reference:");

scanf("%d",&n);

printf("\nEnter the number of frames:");

scanf("%d",&no_frames);

printf("\nEnter the reference string:");

for(i=0;i<n;i++)

scanf("%d",&refer[i]);

printf("\t\t\tFIFO ALGORITHM \n");

for(i=0;i<no_frames;i++)

{

page_frame[i][0]=-1;

page_frame[i][1]=count;

}

replace(1);

fault=0;

count=0;

printf("\t\t\tLRU ALGORITHM \n");

for(i=0;i<no_frames;i++)

{

page_frame[i][0]=-1;

page_frame[i][1]=count;

78

}

replace(2);

return 0;

getch();

}

79

OUTPUT:

Enter the number of reference:10

Enter the number of frames:3

Enter the reference string:7 0 1 2 0 3 0 4 2 6

FIFO ALGORITHM

7 -1 -1

7 0 -1

7 0 1

2 0 1

no page fault

2 3 1

2 3 0

4 3 0

4 2 0

4 2 6

number of page fault is:9

LRU ALGORITHM

7 -1 -1

7 0 -1

7 0 1

2 0 1

no page fault

2 0 3

no page fault

4 0 3

4 0 2

4 6 2

number of page fault is:8

80

Result:

Thus the program for page replacement algorithms for memory management was successfully

executed.

81

Ex.No:10 FILE ALLOCATION TECHNIQUE-CONTIGUOUS

AIM:

To Write a C Program to implement file allocation technique.

DESCRIPTION

File Allocation Methods

One main problem in file management is how to allocate space for files so that disk space is utilized effectively and files can be accessed quickly. Three major methods of allocating disk space are: * Contiguous Allocation * Linked Allocation * Indexed Allocation. Each method has its advantages and disadvantages. Accordingly, some systems support all three (e.g. Data General's RDOS). More commonly, a system will use one particular method for all files. Contiguous File Allocation

• Each file occupies a set of contiguous block on the disk • Allocation using first fit/best fit. • A need for compaction • Only starting block and length of file in blocks are needed to work with the file • Allows random access • Problems with files that grow

ALGORITHM:

1. Start the process

2. Declare the necessary variables

3. Get the number of files

4.Get the total no. of blocks that fit in to the file

5. Display the file name, start address and size of the file.

6.Stop the program.

82

PROGRAM:

#include<stdio.h>

void main()

{

int i,j,n,block[20],start:

printf(“Enter the no. of file:\n”);

scanf(“%d”,&n);

printf(“Enter the number of blocks needed for each file:\n”);

for(i=0,i<n;i++)

scanf(“%d”,&block[i]);

start=0;

printf(“\t\tFile name\tStart\tSize of file\t\t\n”);

printf(“\n\t\tFile1\t\t%d\t\t\t%d\n”,start,block[0]);

for(i=2;i<=n;i++)

{

Start=start+block[i-2];

Printf(“\t\tFile%d\t\t%d\t\tD\n”,i,start,block[i-1]);

}

}

83

Output

Enter the number of file:4

Enter the number of blocks needed for each file:

3

5

6

1

Filename start size of file

File 1 0 3

File 2 3 5

File 3 8 6

File 4 14 1

Result:

Thus the program for file allocation technique has been done successfully.

84

VIVA VOCE

1. What is an Operating system?

An operating system is a program that manages the computer hardware. It also provides a basis

for application programs and act as an intermediary between a user of a computer and the computer

hardware. It controls and coordinates the use of the hardware among the various application programs

for the various users.

2. What is the Kernel?

A more common definition is that the OS is the one program running at all times on the

computer, usually called the kernel, with all else being application programs.

3. What are Batch systems?

Batch systems are quite appropriate for executing large jobs that need little interaction. The user can

submit jobs and return later for the results. It is not necessary to wait while the job is processed.

Operators batched together jobs with similar needs and ran them through the computer as a group.

4. What do you mean by Time-sharing systems?

Time-sharing or multitasking is a logical extension of multiprogramming. It allows many users to

share the computer simultaneously. The CPU executes multiple jobs by switching among them,but

the switches occur so frequently that the users can interact with each program while it is running.

5. What are multiprocessor systems & give their advantages?

Multiprocessor systems also known as parallel systems or tightly coupled systems are systems

that have more than one processor in close communication, sharing the computer bus, the clock and

sometimes memory & peripheral devices. Their main advantages are

Ø Increased throughput

Ø Economy of scale

Ø Increased reliability

85

6. What is a process?

A process is a program in execution. It is the unit of work in a modern operating system. A

process is an active entity with a program counter specifying the next instructions to execute and a set

of associated resources. It also includes the process stack, containing temporary data and a data

section containing global variables.

7. What is a process state and mention the various states of a process?

As a process executes, it changes state. The state of a process is defined in part by the current

activity of that process. Each process may be in one of the following states: Ø New

Ø Running

Ø Waiting

Ø Ready

Ø Terminated

. Compare user threads and kernel threads.

User threads

User threads are supported above the Kernel threads are supported directly kernel and are

implemented by a thread library at the user level Thread creation & scheduling are done in the user

space, without kernel intervention. Therefore they are fast to create and manage Blocking system call

will cause the entire process to block

8. What is the use of fork and exec system calls?

Kernel threads

Thread creation, scheduling and management are done by the operating If the thread performs

a blocking system call, the kernel can schedule another thread in the application for execution Fork

is a system call by which a new process is created. Exec is also a system call, which is used after a

fork by one of the two processes to replace the process memory space with a new program.

86

9. Define CPU scheduling.

CPU scheduling is the process of switching the CPU among various processes. CPU

scheduling is the basis of multi programmed operating systems. By switching the CPU among

processes, the operating system can make the computer more productive.

10. What is preemptive and non preemptive scheduling?

Under non preemptive scheduling once the CPU has been allocated to a process, the process

keeps the CPU until it releases the CPU either by terminating or switching to the waiting state.

Preemptive scheduling can preempt a process which is utilizing the CPU in between its execution and

give the CPU to another process.

11. Define throughput?

Throughput in CPU scheduling is the number of processes that are completed per unit time.

For long processes, this rate may be one process per hour; for short transactions, throughput might be

10 processes per second.

12. What is turnaround time?

Turnaround time is the interval from the time of submission to the time of completion of a

process. It is the sum of the periods spent waiting to get into memory, waiting in the ready queue,

executing on the CPU, and doing I/O.

13. What is semaphores?

A semaphore ‘S’ is a synchronization tool which is an integer value that, apart from

initialization, is accessed only through two standard atomic operations; wait and signal. Semaphores

can be used to deal with the n-process critical section problem. It can be also used to solve various

synchronization problems. The classic definition of ‘wait’ wait (S) { } while (S<=0) S--; The classic definition of ‘signal’

signal (S)

{

87

}

S++;

;

14. Define deadlock prevention.

Deadlock prevention is a set of methods for ensuring that at least one of the four necessary

conditions like mutual exclusion, hold and wait, no pre- emption and circular wait cannot hold. By

ensuring that that at least one of these conditions cannot hold, the occurrence of a deadlock can be

prevented.

15. Define deadlock avoidance.

An alternative method for avoiding deadlocks is to require additional information about how

resources are to be requested. Each request requires the system consider the resources currently

available, the resources currently allocated to each process, and the future requests and releases of

each possible future deadlock.

16. What is the main function of the memory-management unit?

The runtime mapping from virtual to physical addresses is done by a hardware device called a

memory management unit (MMU).

17. What are the common strategies to select a free hole from a set of available holes?

The most common strategies are

a. First fit

b. Best fit

c. Worst fit

18. What is virtual memory?

Virtual memory is a technique that allows the execution of processes that may not be

completely in memory. It is the separation of user logical memory from physical memory. This

separation provides an extremely large virtual memory, when only a smaller physical memory is

available.

88

19. What is Demand paging?

Virtual memory is commonly implemented by demand paging. In demand paging, the pager

brings only those necessary pages into memory instead of swapping in a whole process. Thus it

avoids reading into memory pages that will not be used anyway, decreasing the swap time and the

amount of physical memory needed.

20. What is the various page replacement algorithms used for page replacement? a. FIFO page replacement

b. Optimal page replacement

c. LRU page replacement

d. LRU approximation page replacement

e. Counting based page replacement

f. Page buffering algorithm.

21. What are the allocation methods of a disk space?

Three major methods of allocating disk space which are widely in use are a. Contiguous allocation

b. Linked allocation

c. Indexed allocation

89

QUESTION SET

1. Write programs using the following system calls of UNIX operating system: fork, exec,

getpid, exit, wait, close, stat, opendir, readdir

2. Write programs using the I/O system calls of UNIX operating system (open, read, write, etc)

3. Write C programs to simulate UNIX commands like ls, grep, etc.


chart for FCFS and SJF. For each of the scheduling policies, compute and print the average

waiting time and average turnaround time. (2 sessions)


chart for Priority and Round robin. For each of the scheduling policies, compute and print the

average waiting time and average turnaround time. (2 sessions)

6. Developing Application using Inter Process Communication (using shared memory, or

message queues)

7. Implement the Producer – Consumer problem using semaphores

(using UNIX system calls).

8. Implement some memory management schemes – I

9. Implement some memory management schemes – II

10. Implement any file allocation technique (Linked, Indexed or Contiguous)

90

FUTURE DEVELOPMENT

Operating systems have evolved through the past years in a rapid manner. As the most important

component in computers, changes in the operating systems have great consequences for users of

computers. With the past changes in operating systems like the giant rise from command-line interface

to the current graphical user interface, many common tasks became easier for the users. Currently

computer users are faced with difficulties when installing new hardware's and some software's because

of technical issues.

In this context one can expect to see many new wizards implemented with the operating system.

Wizards are software's, which give automated step-by-step instructions to carry out a task which

otherwise would be very complicated for a basic computer user to carry out without technical

assistance. Existing operating systems do carry admirable wizards for uninstalling and installing

software's and hardware's (e.g. Windows 95. In the near future wizards will be integrated into the

operating systems, which could carry out tasks like automatically cleaning up systems, deleting

unnecessary files and further simplification of installment procedures of software's and hardware's,

which can produce reports on what and what not a device or system can do. Wizards may also exist

which may ask what to do at the moment, and even glance at the software you are currently installing

and give suggestions on programs and documents for successfully accomplishing the task.

Work is in progress to put out Operating systems integrated with browser features. Microsoft's

strategy called Active Desktop was to use the browser metaphor for searching hard drives and surfing

the Net. The future holds a date where HTML with Active X controls and Java might become THE

file standards on a desktop and applications, their associated documents will be called through these

HTML files. This means that the Network User Interface may replace the Graphical User Interface.

Thus in the future you can access the web directly from the Operating System without opening a

separate Web browser.

91

REFERENCES

1. Silberschatz, Galvin, and Gagne, “Operating System Concepts”, Sixth Edition, Wiley.

India Pvt Ltd, 2003.

2. www.scribd.com/doc/38451142/CS2257

3. www.iannauniversity.com/.../cs2257-operating-systems-lab-.

4. www.webstatschecker.com/stats/.../operating_system_labmannual

CS2257-OS-LAB-MANUAL-II-IT-by-GBN.pdf

Documents

cse04 linuxserver aravind

cse04 linuxserver vaishu

ending byte address

starting byte address

include include main

cpu burst times

average turnaround time

average waiting time