Advances in OS Lab Programs

1. Design, develop and execute a program using any thread library to

create the number of threads specified by the user; each thread
independently generates a random integer as an upper limit, and then
computes and prints the number of primes less than or equal to that
upper limit along with that upper limit.

INTRODUCTION
A process defines a Customized Computations framework in which a program
executes. In traditional operating system the basic unit of CPU utilization is a process.
Each process has its own program counter, its own register states, its own stack, and its
own address space. Now a days, in operating system , the basic unit of CPU utilization is
thread and a process may consist of one or more threads.

PROCESS AND PROCESS CONTROL BLOCK

A process is a program in execution or an instance of a program running on a
computer. Two essential elements of process are program code and a set of data
associated with that code. At any given point of time while the program is executing, the
process can be uniquely characterized by a number of elements including the following,
Identifier: a unique identifier associated with the process, to distinguish it from all other
process.
State: if the process is currently executing it space is in the running state
Priority: priority level relative to other processes.
Program counter: the address of the next instruction in the program to be executed.
Memory pointers: includes pointers to the program court and data associated with the
process plus any memory blocks shared with other processes.
Context data: these are the data that are presenting registers in the processor while the
process is executing.
I/O status information: includes outstanding I/O requests, I/O devices’ assigned to the
process, list of files in use by process and so on.
Accounting Information: May include the amount of processor time and clock time
used, time limits, account numbers and so on.

Dept. of CSE, AIT, Bangalore 1 2011-12

Advances in OS Lab Programs

The information in the proceeding list is stored in a data structure, typically called a
process control block that is created and managed by the OS. The process control block is
that it contains sufficient information so that it is possible to interrupt a running process
and later resume execution as if the interruption had not occurred. The process control
block is the key tool that enables the OS to support multiple processes and to provide for
multiprocessing.

Process State
The behavior of an individual process can be characterized by listing the sequence of
instruction that execute for that process. Such listing is referred to as a trace of process. A
small dispatcher program is there that switches the process from one process to another.
A process can be in any of the five states while it is on the system:
RUNNING: The process that is currently being executed. At most one process at a time
can be in this state.
READY: A process that is prepared to execute when given the opportunity.
BLOCKED/WAITING: A process that cannot execute until some event occurs, such as
the completion of an I/O operation.
NEW:A process that has just been created but has not been admitted to the pool of
executable processes by the OS, Typically, a new process has not yet been loaded into
main memory, although its process control block has been created.
EXIT: A process that has been released from the pool of executable processes by the OS,
either because it halted or because it aborted for some reason.

Dept. of CSE, AIT, Bangalore 2 2011-12

Advances in OS Lab Programs

THREADS
A thread is a basic unit of CPU utilization; it comprises a thread ID, a program
counter, a register set, and a stack. It shares with other threads belonging to the same
process its code section, data section, and other operating-system resources, such as open
files and signals. There are two types of threads one of which is single thread and other
multi thread. A traditional process has a single thread of control. If a process has multiple
threads of control, it can perform more than one task at a time. The difference between a
single-threaded process and multi-threaded process is shown in figure below:

Registers
Code Data Stack
Files Register
Code Register
Data Register
Files

Stack Stack Stack

Single-threaded process Multi-threaded process

Dept. of CSE, AIT, Bangalore 3 2011-12

Advances in OS Lab Programs

In certain situations, a single application may be required to perform several similar tasks.
For example, a web server accepts client requests for web pages, images, sound and so
forth. A busy web server may have several of clients concurrently accessing it. If the web
server ran as a traditional single-threaded process, it would be able to service only one
client at a time. One solution is to have the server run as a single process that accepts
requests. When the server receives a request, it creates a separate process to service that
request. In fact, this process-creation method was in common use before threads became
popular.
Threads play a vital role in remote procedure call(RPC) systems. The RPCs allow
interprocess communication mechanism similar to ordinary function or procedure calls.
RPC servers are multithreaded. Finally, many operating system kernels are now
multithreaded; several threads operate in the kernel, and each thread performs a specific
task, such as managing devices or interrupt handling. For example, Solaris creates a set of
threads in the kernel specifically for interrupt handling.
Benefits
The benefits of multithreaded programming can be broken down into four major
categories:
1. Responsiveness
2. Resource sharing
3. Economy
4. Utilization of multiprocessor architectures
Responsiveness : Multithreading an interactive application may allow a program to
continue running even if part of it is blocked or is performing a lengthy operation, thereby
increasing responsiveness to the user.
Resource sharing: Threads share the memory and the resources of the process to which
they belong. The benefit of sharing code and data is that it allows an application to have
several different threads of activity within the same address space.
Economy: Allocating memory and resources for process creation is costly. Because
threads share resources of the process to which they belong, it is more economical to
create and context-switch threads. In general it is much more time consuming to create
and manage process than threads.
Utilization of multiprocessor architectures: The benefits of multithreading can be
greatly increased in a multiprocessor architecture, where threads may be running in

Dept. of CSE, AIT, Bangalore 4 2011-12

Advances in OS Lab Programs

parallel on different processors. A single-threaded process can only run on CPU, no

matter how many are available.

Multithreading Models
Threads support at user level, for user threads, or by the kernel, for kernel
threads. User threads are supported above the kernel and are managed without kernel
support, whereas kernel threads are supported and managed directly by the operating
system.
Many-to-One Model
The many-to-one model maps many user-level threads to one kernel thread.
Thread management is done by the thread library in user space, so it is efficient, but the
entire process will block if a thread makes a blocking system call. Figure shows many-to-
One model.

One-to-One Model
The one-to-one model maps each user thread to a kernel thread. It provides more
concurrency than the many-to-one model by allowing another thread to run when a thread
makes a blocking system call. It also allows multiple threads to run in parallel on
multiprocessors. The only drawback to this model is that creating a user thread requires
creating the corresponding kernel thread. Figure shows One-to-One model

Many-to-Many Model
The Many-to-Many model multiplexes many user-level threads to a smaller or equal
number of kernels threads. The number of kernel threads may be specific to either a
particular application or a particular machine. Whereas the many-to-one model allows the

Dept. of CSE, AIT, Bangalore 5 2011-12

Advances in OS Lab Programs

developer to create as many user threads as they wishes, because the kernel can schedule
only one thread at a time. The many-to-many model suffers from neither of these
shortcomings: Developers can create as many user threads as necessary and
corresponding kernel thread can run in parallel on a multiprocessor.

Java Threads
Threads are the fundamental model of program execution in a Java program, and the Java
language and its API provide a rich set of features for the creation and management of
threads. All Java programs comprise at least a single thread of control. There are two
techniques for creating threads in Java program. One approach is to create a new class
that is derived from the thread class and to override its run() method. An alternative and
more commonly used technique is to define a class that implements the Run able
interface.

Source Code:
import java.util.Random;
import java.io.*;

public class CreateThreads {

public static void main(String args[]) {
try {
int noOfThreads;
BufferedReader br = new BufferedReader(new
InputStreamReader(
System.in));
System.out.println("Enter the Required Number Of Threads\n");

Dept. of CSE, AIT, Bangalore 6 2011-12

Advances in OS Lab Programs

noOfThreads= Integer.parseInt(br.readLine());
for (int index = 0; index < noOfThreads; index++)
{
PrimeNumThread P = new PrimeNumThread();
}
} catch (Exception e)
}
}//end of main method
}//end of class CreateThreads

class PrimeNumThread extends Thread {

PrimeNumThread() {
start();
}

public void run()

{
Random randomObject=new Random();
int upperLimit=randomObject.nextInt(20);
System.out.println("The upperlimit of
"+PrimeNumThread.currentThread()+" is "+upperLimit+"\n\n");
for(int i=2;i<=upperLimit;i++)
{
if(isPrimeNum(i))
System.out.println("ThreadName:
"+PrimeNumThread.currentThread().getName()+" And "+"primeNumber
within:"+upperLimit+"---> " +i);
try
{
sleep(1000);
}
catch(InterruptedException e){}
}

Dept. of CSE, AIT, Bangalore 7 2011-12

Advances in OS Lab Programs

}//end of run method

public boolean isPrimeNum(int num)

{
boolean flag= true;
int limit = (int) Math.sqrt(num);
for (int index = 2; index <= limit; index++)
{
if (num % index == 0)
{
flag = false;
break;
}
}
return flag;
}//end of is PrimeNum method
}// end of PrimeNum Thread class

Output
Enter the Required Number Of Threads
1
The upperlimit of Thread[Thread-0,5,main] is 18
ThreadName: Thread-0 And primeNumber within:18---> 2
ThreadName: Thread-0 And primeNumber within:18---> 3
ThreadName: Thread-0 And primeNumber within:18---> 5
ThreadName: Thread-0 And primeNumber within:18---> 7
ThreadName: Thread-0 And primeNumber within:18---> 11
ThreadName: Thread-0 And primeNumber within:18---> 13
ThreadName: Thread-0 And primeNumber within:18---> 17

Dept. of CSE, AIT, Bangalore 8 2011-12

Advances in OS Lab Programs

2. INTRODUCTION
Process is a program in execution. Process is a passive entity with a
program counter specifying the next instruction to execute and a set of
associated resources. Each process is represented in the operating system by a
process control block (PCB) also called a task control block. It contains
information such as process state, program counter, cpu registers.

System calls:
It provide the interface between a process and the operating system. It is a
routine built in the kernel to perform function that requires communication with
the system’s hardware.
All activities related to file handling, process and memory management and
maintenance of user and system information are handled by the kernel using
these system calls.
For example: when we execute a C program, the CPU runs in user mode till a
system call is invoked. In this mode, the process has access to a limited section
of the computer’s memory and can execute a restricted set of machine
instructions.
However, when the process invokes a system call, the CPU switches
from user mode to a more privileged mode i.e., the kernel mode. In this mode,
it’s kernel that runs on behalf of the user. After the system call has returned, the
CPU switches back to user mode for further execution.
The Unix and Linux Os utilizes same system calls. Portable
Operating system Interface for Computer Environments ( POSIX.1)specifies
the C API that contains the built-in
System calls.

Dept. of CSE, AIT, Bangalore 9 2011-12

Advances in OS Lab Programs

(the users)

Shells and commands

Compilers and interpreters

System libraries

System- call interface to the kernel

Signals terminal file system CPU scheduling

handling handling page replacement

Kernel interface to the hardware

Terminal Device Memory controllers

controllers controllers
, Physical memory
terminals Disks and
tapes

Fig. LINUX system structure

Processor time
The amount of time a process takes to run, given that it has exclusive and uninterrupted
use of the CPU. Note that in a modern computer, this would be very unusual, and so the
processor time calculation for most processes involves adding up all the small amounts of
time the CPU actually spends on the process. Some systems break processor time down
into user time and system time.

Dept. of CSE, AIT, Bangalore 10 2011-12

Advances in OS Lab Programs

Kernel space
It is that portion of memory in which the kernel executes and provides its services.
Kernel space time is the amount of time taken by kernel to execute system calls and other
interrupt services in kernel mode. The division of system memory in Linux-like operating
systems into user space and kernel space plays an important role in maintaining system
stability and security.

DESIGN
Algorithm to create the child processes, also find the real time, processor time,
user space time & kernel space time for each process after creating. Also display
the real time, user space time & kernel space time of the parent process

Algorithm: Create Process( )

//purpose: To create child process
for i0 to 2 do

Dept. of CSE, AIT, Bangalore 11 2011-12

Advances in OS Lab Programs

if (fork( ) == 0) // fork system call is used to create child

process
Child_process(i);
endif
endfor
for i0 to 2 do
Wait( ) // process enters this state when other process is
under execution
endfor

Algorithm: Child_process(process_no)
//Purpose: To generate total prime no and find real time, processor time, user
space time,
kernel space time of each child process
// Input: process_no
// Output:
// processor time at child is created
// generate random no. & total prime no. of each child process
// real time of child process
// user space time of child process
// kernel space time of child process
time Child process //find processor time & store in variable
Rand rand( ) % const value // generate random no. using rand( ) function
Total_prime_no 0
for n 0 to n< Rand do
prime=1 // Initialize prime to 1
for i2 to i< n do
if ( n % i = 0)
prime=0 // if n is not prime
end if
end for

// if prime is true value ie 1 it increments variable total _prime_no.

Dept. of CSE, AIT, Bangalore 12 2011-12

Advances in OS Lab Programs

if (prime)
increment total _prime_ no.
end if
end for
// after generating total prime no. the respective time of each child process and
total prime is shown
print total prime number
print real time of child process
print user space time of child process
print kernel space time of child process

//When the two child process terminates, the following respective time is shown
print real time of parent process
print user space time of parent process
print kernel space time of parent process

// End of algorithm

IMPLEMENTATION
Let us consider the Linux operating system for implementation. Here each
process is identified by its process identifier, which is a unique integer. A new process is
created by the fork system call (child process). The child process consists of a copy of the
address space of the original process.

This mechanism allows the parent process to communicate easily with its child
process. Both processes (the parent and the child) continue execution at the instruction
after the fork system call, with one difference: The value of pid for the child process is
zero but for the parent is an integer value greater than zero.

In this program, times ( ) function which is built in sys/times header file. It stores the
current process time in struct tms datatype. The struct tms is defined in <sys/times.h> as
follows:
Struct tms {

Dept. of CSE, AIT, Bangalore 13 2011-12

Advances in OS Lab Programs

clock_t tms_utime; // user time

,
clock_t tms_stime; // system time
clock_t tms_cutime; // user time of children
clock_t tms_cstime; // system time of children
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/times.h>
child_process(int process_no)
{
int i, n, prime, TotPrimeNo=0;
struct tms chpr_t1, chpr_t2;
long rchprt1, rchprt2;
int Rand;
rchprt1 = times(&chpr_t1); //start time of child process
printf("\n Processor time for child process (%d) = %d", (process_no
+1), rchprt1);
printf("\n Created child process %d ", process_no+1);
srand(process_no);
Rand = random() % 10000;
printf(" \n Random number = %d\t", Rand );
// total prime no generation
for(n=0; n<Rand; n++)
{
prime = 1; // initialize
for(i=2; i<n; i++)
{
if(n % i == 0)
{
prime = 0;

Dept. of CSE, AIT, Bangalore 14 2011-12

 Advances in OS Lab Programs

break;
}
}

if(prime)
{
TotPrimeNo++;
}
}
printf("\nTotal Prime Nos=%d\n", TotPrimeNo);
rchprt2 = times(&chpr_t2); // end time of child process
printf(“------------- The real time, user space and kernel space
for chid process are: ---------------“)

printf("\n Real time for child process (%d) = %d", (process_no +1),
(rchprt2- rchprt1));

printf("\n User space time for child process(%d) = %d", (process_no +1),
(chpr_t2.tms_cutime -
chpr_t1.tms_cutime));
printf("\n kernel space time for child process(%d) = %d\n\n",
(process_no +1),
(chpr_t2.tms_cstime -
chpr_t1.tms_cstime));
exit(0);
}

void CreateProcess()
{
int i;
for (i=0; i<2;i++)
{
if(fork( ) == 0)

Dept. of CSE, AIT, Bangalore 15 2011-12

Advances in OS Lab Programs

child_process(i);
}
for (i=0; i<2;i++)
{
wait( );
}
}

int main ()
{
long p_mt1, p_mt2;
struct tms p_mst1, p_mst2
p_mt1 = times(&p_mst1); //start time of a parent process
CreateProcess();
p_mt2 = times(&p_mst2); // end time of a parent process
printf(“------------- The real time, user space and kernel space for parent process
are: -------/n”);
printf("\n Real time for parent process = %d", p_mt2-p_mt1);
printf("\n User space time for parent process = %d",(p_mst2.tms_utime -
p_mst1.tms_uti
me));
printf("\n Kernel space time for parent process = %d\n\n",(p_mst2.tms_stime -
p_mst1.tms_sti
me));
}

Output:
Processor time for child process (1) = 18847897
Created child process 1
Processor time for child process (2) = 18847897
Created child process 2
Random number = 289383
Total Prime No=25180

Dept. of CSE, AIT, Bangalore 16 2011-12

Advances in OS Lab Programs

------------- The real time, user space and kernel space for chid process are:
---------------
Real time for child process (2) = 1402
User space time for child process(2) = 0
kernel space time for child process(2) = 0
Random number = 289383
Total Prime No=25180
------------- The real time, user space and kernel space for chid process are:
---------------
Real time for child process (1) = 1422
User space time for child process(1) = 0
kernel space time for child process(1) = 0
------------- The real time, user space and kernel space for parent process are:
-------
Real time for parent process = 1424
User space time for parent process = 0
Kernel space time for parent process = 0

Dept. of CSE, AIT, Bangalore 17 2011-12

Advances in OS Lab Programs

3. Design, develop and implement a process with a producer thread and

a consumer thread which make use of bounded buffer (size can be
prefixed at a suitable value) for communication. Use any suitable
synchronization construct.

INTRODUCTION
Interprocess Communication is a mechanism, for processes to communicate and to
synchronize their actions. It has a set of methods for the exchange of data among multiple
threads in one or more processes.

The “Bounded-Buffer (Producer-Consumer) problem” is to create producer thread and

consumer thread allows process to communicate and to synchronize their actions with the
use of a bounded buffer. The bounded-buffer problem is a paradigm for cooperating
processes, where the producer process produces information that is consumed by a
consumer process.

The producer and the consumer, who share a common, fixed-size buffer. The producer's
job is to generate a piece of data, put it into the buffer and start again. At the same time
the consumer is consuming the data (i.e., removing it from the buffer) one piece at a time.
The problem is to make sure that the producer won't try to add data into the buffer if it's
full and that the consumer won't try to remove data from an empty buffer.

DESIGN
This project can be divided mainly into four parts
1. Producer.
2. Consumer.
3. Bounded-Buffer.
4. Integration of all three.

Producer: Producer corresponds to produce the item and stores in the buffer. After
storing the item in the buffer, it has to increment the counter also it has to notice the
consumer to consume the item.

Dept. of CSE, AIT, Bangalore 18 2011-12

Advances in OS Lab Programs

Consumer consumes the item: Consumer corresponds to consume the item available in
the buffer. After consuming the item in the buffer, it has to decrement the counter also it
has to notice the consumer to consume the item.

Bounded-Buffer: It works as the interface between the Producer and the Consumer. It
allows the producer to store the item in the buffer (shared space), also allows the
consumer to consume the item from the buffer (shared space).

Integration of all three: Finally we integrate these three parts of the problem using the
synchronization technique of java.

Interprocess Communication (IPC)

 Mechanism for processes to communicate and to synchronize their actions.
 Message system – processes communicate with each other without resorting to
shared variables.
 IPC facility provides two operations:
 send(message) – message size fixed or variable
 receive(message)
 If A and B wish to communicate, they need to:
 Establish a communication link between them.
 Exchange messages via send/receive.
 Implementation of communication link
 physical (e.g., shared memory, hardware bus)
 logical (e.g., logical properties)

Producer-Consumer Problem
Producer-consumer problem (also known as the bounded-buffer problem) is a classical
example of a multi-process synchronization problem. The problem describes two
processes, the producer and the consumer, who share a common, fixed-size buffer. The
producer's job is to generate a piece of data, put it into the buffer and start again. At the
same time the consumer is consuming the data (i.e., removing it from the buffer) one

Dept. of CSE, AIT, Bangalore 19 2011-12

Advances in OS Lab Programs

piece at a time. The problem is to make sure that the producer won't try to add data into
the buffer if it's full and that the consumer won't try to remove data from an empty buffer.

The solution for the producer is to either go to sleep or discard data if the buffer is full.
The next time the consumer removes an item from the buffer, it notifies the producer who
starts to fill the buffer again. In the same way, the consumer can go to sleep if it finds the
buffer to be empty. The next time the producer puts data into the buffer, it wakes up the
sleeping consumer. The solution can be reached by means of inter-process
communication, typically using semaphores. An inadequate solution could result in a
deadlock where both processes are waiting to be awakened. The problem can also be
generalized to have multiple producers and consumers.
Producer-Consumer problem is a paradigm for cooperating processes; producer process
produces information that consumer process consumes the information.
 Unbounded-buffer places no practical limit on the size of the buffer.
 Bounded-buffer assumes that there is a fixed buffer size.

Advantages of Co-operating process

 Information sharing
 Computation speed-up
 Modularity
 Convenience

Why we need Process Synchronization?

 Concurrent access to shared data may result in data inconsistency.
 Maintaining data consistency requires mechanisms to ensure the orderly execution
of cooperating processes.
 Race condition: The situation where several processes access – and manipulate
shared data concurrently. The final value of the shared data depends upon which
process finishes last.
 To prevent race conditions, concurrent processes must be synchronized.

Dept. of CSE, AIT, Bangalore 20 2011-12

Advances in OS Lab Programs

IMPLEMENTATION

Algorithm
Producer process: Consumer process:
//item nextProduced; //item to be Consumed;
while (buffer_size = =max_size) { while (buffer_size = = 0) {
; /* do nothing */ ; /* do nothing */
wait( ); wait( );
} }
Add item into buffer; Remove item from buffer;
notify( ); notify( );

Creating the Threads

Java threads can be created by:
 Implementing the Runnable interface
The easiest way to create a thread is to create a class that implements the Runnable
interface. Runnable abstracts a unit of executable code. You can construct a thread on
any object that implements Runnable. To implement Runnable, a class need only
implement a single method called run ( ), which is declared like this:
public void run( )
Inside run ( ), you will define the code that constitutes the new thread. It is important to
understand that run( ) can call other methods, use other classes, and declare variables,
just like the main thread can. The only difference is that run ( ) establishes the entry point
for another, concurrent thread of execution within your program. This thread will end
when run ( ) returns.
After you create a class that implements Runnable, you will instantiate an object of
type Thread from within that class. Thread defines several constructors. The one that
we will use is shown here:
Thread(Runnable threadOb, String threadName)
In this constructor, threadOb is an instance of a class that implements the Runnable
interface. This defines where execution of the thread will begin. The name of the new
thread is specified by threadName.

Dept. of CSE, AIT, Bangalore 21 2011-12

Advances in OS Lab Programs

After the new thread is created, it will not start running until you call its start ( ) method,
which is declared within Thread. In essence, start ( ) executes a call to run ( ).
The start ( ) method is shown here:
void start ( )
Example:
// Create a second thread.
class NewThread implements Runnable {
Thread t;
NewThread( ) { // Create a new, second thread
t = new Thread(this, "Demo Thread");
System.out.println("Child thread: " + t);
t.start(); // Start the thread
}
// This is the entry point for the second thread.
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
} catch (InterruptedException e) {
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}
}
class ThreadDemo {
public static void main(String args[]) {
new NewThread( ); // create a new thread
try {
for(int i = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);
Thread.sleep(1000);

Dept. of CSE, AIT, Bangalore 22 2011-12

Advances in OS Lab Programs

}
} catch (InterruptedException e) {
System.out.println("Main thread interrupted.");
}
System.out.println("Main thread exiting.");
}
}
Source Code:
import java.util.ArrayList;
import java.util.List;

class Producer_Consumer
{
public static final int BUFFER_SIZE = 4;
public static final int TOTAL_VALUES = 10;

public static void main(String args[])

{
SharedBuffer m = new SharedBuffer();
Producer prod = new Producer(m);
Consumer cons = new Consumer(m);
prod.start();
cons.start();
}
}

class SharedBuffer
{
private List<Integer> buffer =
new ArrayList<Integer>(Producer_Consumer.BUFFER_SIZE);
public synchronized int get()
{
while (buffer.size() == 0)
{
try
{
wait();
}
catch (InterruptedException e) {}
}
notify();
return buffer.remove(0);
}
public synchronized void put(int message)
{

Dept. of CSE, AIT, Bangalore 23 2011-12

Advances in OS Lab Programs

while (buffer.size() == Producer_Consumer.BUFFER_SIZE)

{
try
{
wait();
}
catch (InterruptedException e) {}
}
buffer.add(message);
notify();
}
}
class Producer extends Thread
{
private SharedBuffer shbuf;

public Producer(SharedBuffer m)
{
shbuf = m;
}

public void run()

{
int j;
for (int i = 0; i < Producer_Consumer.TOTAL_VALUES; i++)
{
j = (int) (Math.random() * 1000);
shbuf.put(j);
System.out.println("Producer placed: " + j);
try
{
sleep((int) (Math.random() * 100));
}
catch (InterruptedException e) { }
}
}
}
class Consumer extends Thread {
private SharedBuffer shbuf;
public Consumer(SharedBuffer m) {
shbuf = m;
}

public void run() {

int message = 0;
for (int i = 0; i < Producer_Consumer.TOTAL_VALUES; i++) {
message = shbuf.get();
System.out.println("Consumer consumed: " + message);
try {

Dept. of CSE, AIT, Bangalore 24 2011-12

Advances in OS Lab Programs

sleep((int) (Math.random() * 100));

}
catch (InterruptedException e) {}
}
}
}
Output:

4. Design, develop, and execute a program to solve a system of n linear equations

using Successive Over-relaxation method and n processes which use Shared
Memory API.

Dept. of CSE, AIT, Bangalore 25 2011-12

Advances in OS Lab Programs

Introduction
A linear equation system is a set of linear equations to be solved simultaneously. A1
linear equation takes the form

where the coefficients and are constants and are the n

unknowns. Following the notation above, a system of linear equations is denoted as

This system consists of linear equations, each with coefficients, and has
unknowns which have to fulfill the set of equations simultaneously. To simplify notation,
it is possible to rewrite the above equations in matrix notation:

In this notation each line forms a linear equation The elements of the matrix
are the coefficients of the equations, and the vectors and have the elements
and respectively. In this notation each line forms a linear equation.

There are many methods to solve a linear system of equations such as diagonal and
triangular systems and gauss-jordan elimination are exact solutions of linear systems and
gauss-seidel method, successive over-relaxation method, Jacobi method are approximate
solutions of linear systems. In numerical linear algebra, the method of successive over-
relaxation (SOR) is a variant of the Gauss–Seidel method for solving a linear system of
equations, resulting in faster convergence. A similar method can be used for any slowly
converging iterative process.
SOR Technique:
Given a square system of n linear equations with unknown x:

Dept. of CSE, AIT, Bangalore 26 2011-12

Advances in OS Lab Programs

Then A can be decomposed into a diagonal component D, and strictly lower and upper
triangular components L and U:
A = D + L + U,
where

The system of linear equations may be rewritten as:

for a constant ω > 1.

The method of successive over-relaxation is an iterative technique that solves the left
hand side of this expression for x, using previous value for x on the right hand side.
Analytically, this may be written as:

However, by taking advantage of the triangular form of (D+ωL), the elements of x(k+1) can
be computed sequentially using forward substitution:

The choice of relaxation factor is not necessarily easy, and depends upon the properties of
the coefficient matrix. For symmetric, positive-definite matrices it can be proven that
0 < ω < 2 will lead to convergence, but we are generally interested in faster convergence
rather than just convergence.

Implementation

Dept. of CSE, AIT, Bangalore 27 2011-12

Advances in OS Lab Programs

#include<stdlib.h>
#include<math.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define A(x,y) A[(u+1)*(x)+y]
#define PRECISION 0.0001
int u;
int is_converged(int n, float *A, float *B, float *p)
{
float *sum;
int i , j;
sum=(float *)malloc(n*sizeof(float));
for(i=0;i<n;++i)
sum[i]=0;
for(i=0;i < n;++i)
{
for(j=0; j < n;++j)
sum[i] += A(i,j)*p[j];
sum[i]=fabs(B[i]-sum[i]);
}
for(i=0;i<n;++i)
{
/* not converged if any result is off by more than PRECISION */
if(sum[i]>PRECISION)
return 0;
}
return 1;
}

/* Does one SOR iteration */

void SOR(int n, float *A, float *B, float *p, float w)

Dept. of CSE, AIT, Bangalore 28 2011-12

Advances in OS Lab Programs

{
float sum;
int i,j;
for(i=0;i < n; ++i)
{
sum=0;
for(j=0;j < i;++j)
{
sum += A(i,j)* p[j];
}
for (j = i+1;j < n; ++j)
{
sum += A(i,j) * p[j];
}
p[i] += w * ( ((B[i]-sum)/A(i,i)) - p[i]);
}
}
//Main//
int main(int argc, char* argv[])
{
float *A,*p,*B;
float w;
int shmid;
key_t key;
int i,j;
printf("\nPlease input the number of lines:");
scanf("%d",&u);
A=(float *)calloc(u*(u+1),sizeof(float));
B=(float *)malloc(u*sizeof(float));
printf("Please input the matrix A(%dx%d):\n", u, u); //n*n
for(i = 1; i <= u; ++i)
{
printf("\nPlease input line %d:",i);

Dept. of CSE, AIT, Bangalore 29 2011-12

Advances in OS Lab Programs

for(j=1;j<=u;++j)
scanf("%f",&A(i-1,j-1));
}
printf("\nPlease input matrix B(1x%d):",u);
for(i=0;i<u;++i)
scanf("%f",&B[i]);
/* shared memory key */
key = 5678;
/* Create the shared memory segment for storing the results of SOR iterations. */

if ((shmid = shmget(key, sizeof (float) * u, IPC_CREAT | 0666)) < 0)

{
perror("shmget");
exit(1);
}
/* Now we attach the segment to our data space. */
if ((p = (float *) shmat(shmid, NULL, 0)) == (float *) -1)
{
perror("shmat");
exit(1);
}

/* Read the starting guess values to the shared memory. This will be used by the
child process computing first SOR iteration */
printf("\nPlease input the start guess (1x%d): ",u);
for(i=0;i < u; ++i)
scanf("%f",&p[i]);
printf("\nPlease input the relax VAR(w): ");
scanf("%f",&w);
while (!is_converged(u, A, B, p))
{
if (fork() == 0)
{

Dept. of CSE, AIT, Bangalore 30 2011-12

Advances in OS Lab Programs

/* Do the SOR iterations in the child process, write the iteration

result in shared memory*/
if ((shmid = shmget(key, sizeof (float) * u, 0666)) < 0)
{
perror("shmget");
exit(1);
}

/* Now we attach the segment to our data space. */

if ((p = (float *) shmat(shmid, NULL, 0)) == (float *) -1)
{
perror("shmat");
exit(1);
}
/* perform one iteration using the child process */
SOR(u, A, B, p, w);
exit(0);
}
wait();
}
printf("The SOR solution:\n");
for(i=0; i < u;++i)
printf("x[%d]=%f \n", i+1, p[i]);
return 0;
}

Output:
Please input the number of lines:2
Please input the matrix A(2x2):
Please input line 1:2 3
Please input line 2:4 9
Please input matrix B(1x2):6 15
Please input the start guess (1x2):1 1

Dept. of CSE, AIT, Bangalore 31 2011-12

Advances in OS Lab Programs

Please input the relax VAR(w):1.5

The SOR solution:
x[1]=1.500061
x[2]=0.999980
-------------------------------------------
Please input the number of lines:2
Please input the matrix A(2x2):
Please input line 1:16 3
Please input line 2:7 -11
Please input matrix B(1x2):11 13
Please input the start guess (1x2):1 1
Please input the relax VAR(w):1
The SOR solution:
x[1]=0.812182
x[2]=-0.664975

5.
INTRODUCTION
Procedure Call (RPC) defines a powerful technology for creating distributed
client/server programs. The RPC run-time stubs and libraries manage most of the

Dept. of CSE, AIT, Bangalore 32 2011-12

Advances in OS Lab Programs

processes relating to network protocols and communication. This enables you to focus on
the details of the application rather than the details of the network.
Examples: File service, Database service, and Authentication service.
Need of RPC: The client needs an easy way to call the procedures of the server to get
some services.
 RPC enables clients to communicate with servers by calling procedures in a
similar way to the conventional use of procedure calls in high-level languages.
 RPC is modeled on the local procedure call, but the called procedure is executed
in a different process and usually a different computer.
Different RPC Systems:
 Sun RPC
 DCE RPC
 DCOM
 CORBA
 Java RMI
 XML RPC, SOAP/.NET, AJAX, REST
Sun RPC: An alternative to sockets is RPC. RPC enables an application to call
procedures that exist on another machine. RPC makes a network connection to a remote
machine using sockets. After the connection is made with the server, one can invoke a
function on the remote machine. The programmer has the illusion of calling a local
procedure, but actually the arguments are packaged and passed to the remote machine.
RPC is easier to use than sockets. There are some drawbacks of using RPC, such as:
 You can only pass simple data types & not objects as arguments.
 The programmer must learn a special Interface Definition Language (IDL).

Remote Interface
A remote interface is an interface, which declares a set of methods that may be invoked
remotely (from a different JVM). All interactions with the remote object will be
performed through this interface. A remote interface must directly or indirectly extend the

Dept. of CSE, AIT, Bangalore 33 2011-12

Advances in OS Lab Programs

java.rmi.Remote interface. Each method declaration in a remote interface must include

java.rmi.RemoteException or one of its superclasses in its throws clause.

Stubs and Skeletons

The skeleton is a server side proxy for the remote object. It is much like the stub class but
resides on the server. The skeleton is responsible for calling the actual remote object
implementation (see Figure 2.1).
Figure 1.1

Bootstrap Name Server

The RMI registry is a simple name server provided for storing references to remote
objects. The server is responsible for registering remote objects with the registry service.
The registry keeps track of the addresses of remote objects. A remote objects handle can
be stored using the methods of java.rmi.Naming class. A client can obtain a reference to a
remote object by looking up in the server(s) registry or as a result of a remote method
call. The registry server is necessary only when making an initial contact with the
application. An application can also run its own registry service. The RMI registry
application (rmiregistry) is included in JDK.
Figure 1.2

Dept. of CSE, AIT, Bangalore 34 2011-12

Advances in OS Lab Programs

RMI Layers
RMI system is organized as a four-layer model. Each layer performs some specific
functions like establishing the connection, marshaling of parameters, etc. Each layer
insulates the layers above it from some details.
The four layers are:
Application layer
Proxy layer
Remote reference layer
Transport layer

RMI API

Dept. of CSE, AIT, Bangalore 35 2011-12

Advances in OS Lab Programs

Implementation
//**SERVER PROGRAM**//

import org.apache.xmlrpc.server.PropertyHandlerMapping;
import org.apache.xmlrpc.webserver.WebServer;

public class RpcServer {

public Integer sum(int x, int y) {
System.out.println("Finding sum for " + x + " and " + y);
return new Integer(x + y);
}
public static void main(String[] args) {
try {
System.out.println("Attempting to start XML-RPC Server...");
WebServer server = new WebServer(8080);
PropertyHandlerMapping phm = new PropertyHandlerMapping();

Dept. of CSE, AIT, Bangalore 36 2011-12

Advances in OS Lab Programs

phm.addHandler("math", RpcServer.class);
server.getXmlRpcServer().setHandlerMapping(phm);
server.start();
System.out.println("Started successfully.");
System.out.println("Accepting requests. (Halt program to stop.)");
}
catch (Exception exception) {
System.err.println("JavaServer: " + exception);
}
}
}

//**CLIENT PROGRAM**//

import java.net.URL;
import java.util.Vector;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;

public class RpcClient {

public static void main(String[] args) throws Exception {
XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
String serverAddress = "localhost:8080";
int val1 = 0;
int val2 = 0;
if (args.length > 0) {
serverAddress = args[0];
}
if (args.length >= 2) {
val1 = Integer.parseInt(args[1]);
val2 = Integer.parseInt(args[2]);
}
config.setServerURL(new URL("http://" + serverAddress + "/RPC2"));

Dept. of CSE, AIT, Bangalore 37 2011-12

Advances in OS Lab Programs

XmlRpcClient server = new XmlRpcClient();

server.setConfig(config);
Vector<Integer> params = new Vector<Integer>();
params.addElement(new Integer(val1));
params.addElement(new Integer(val2));
Object result = server.execute("math.sum", params);
int sum = ((Integer) result).intValue();
System.out.println("The sum is: " + sum);
}
}
Output
Server:
------
Attempting to start XML-RPC Server...
Started successfully.
Accepting requests. (Halt program to stop.)
Finding sum for 17 and 13
Finding sum for 54 and 23

Client:
-------
$ java RpcClient localhost:8080 17 13
The sum is: 30
$ java RpcClient localhost:8080 54 23
The sum is: 77

Dept. of CSE, AIT, Bangalore 38 2011-12