A solution to the Readers/Writers Problem using semaphores

Introduction

The readers/writers problem is one of the classic synchronization problems. Like the dining philosophers, it is often used to compare and contrast synchronization mechanisms. It is also an eminently practical problem.

Readers/Writers Problem - Classic definition

Two kinds of processes -- readers and writers -- share a database. Readers execute transactions that examine database records; writer transactions both examine and update the database. The database is assumed initially to be in a consistent state (i.e., one in which relations between data are meaningful). Each transaction, if executed in isolation, transforms the database from one consistent state to another. To preclude interference between transactions, a writer process must have exclusive access to the database. Assuming no writer is accessing the database, any number of readers may concurrently execute transactions.

Some time ago at work, we had to implement a server that relays and translates his incoming datafeed to multiple (typically > 32) clients. As this datafeed represents the continuously (but on a non-regular time base) changing (stock/option) market prices, fast relaying is crucial. We developed a solution that consists of one receiving thread, multiple translator threads, and even more sending threads (since we do not want to block the server if a client fails to receive).

Obviously, all the threads need access to the received and / or translated packet. To achieve this without corrupting data, synchronization is necessary. Searching the MSDN, resulted in finding several synchronization objects (CCriticalSection, CMutex, etc.) of which none seem to fulfill our demands: Multiple read-access when not writing. We thus decided to write the desired synchronization object ourselves: CMutexRW.

Formal readers and writers solution using semaphores

Since our problem has extensively been studied (since 1960?) we first turned to some old college-books on parallel formal semantics to refresh our knowledge about the problem. Soon we found the pages describing the readers and writers problem and (several) solution outlines. We chose to implement our solution (with readers preference) using semaphores.

First some quick (probably skipable) refresh course to (formal) semaphores: Semaphores where first introduced by Dijkstra in 1968, who thought it to be an useful tool for implementing mutual exclusion and for signalling the occurrence of events such as interrupts. A semaphore is an instance of an abstract data type: it has a representation that is manipulated only by two special operations, P and V. Because Dijkstra is Dutch, the P andV stand for Dutch words. In particular, P is the first letter of the Dutch word passeren, which means `to pass'; V is the first letter of vrijgeven, which means `to release'. The V operation signals the occurrence of an event; the Poperation is used to delay a process until an event has occurred. In particular, the two operations must be implemented so that they preserve the following property for every semaphore in a program.

N/B: the description is copy and paste......

NetBans Project

Read More»

Dining philosophers problem with GUI in JAVA

Problem statement

Illustration of the dining philosophers problem.

Five silent philosophers sit at a round table with bowls of spaghetti. Forks are placed between each pair of adjacent philosophers.

Each philosopher must alternately think and eat. However, a philosopher can only eat spaghetti when he has both left and right forks. Each fork can be held by only one philosopher and so a philosopher can use the fork only if it is not being used by another philosopher. After he finishes eating, he needs to put down both forks so they become available to others. A philosopher can take the fork on his right or the one on his left as they become available, but cannot start eating before getting both of them.

Eating is not limited by the remaining amounts of spaghetti or stomach space; an infinite supply and an infinite demand are assumed.

The problem is how to design a discipline of behavior (a concurrent algorithm) such that no philosopher will starve; i.e., each can forever continue to alternate between eating and thinking, assuming that no philosopher can know when others may want to eat or think.

Problems

The problem was designed to illustrate the challenges of avoiding deadlock, a system state in which no progress is possible. To see that a proper solution to this problem is not obvious, consider a proposal in which each philosopher is instructed to behave as follows:

• think until the left fork is available; when it is, pick it up;
• think until the right fork is available; when it is, pick it up;
• when both forks are held, eat for a fixed amount of time;
• then, put the right fork down;
• then, put the left fork down;
• repeat from the beginning.

This attempted solution fails because it allows the system to reach a deadlock state, in which no progress is possible. This is a state in which each philosopher has picked up the fork to the left, and is waiting for the fork to the right to become available. With the given instructions, this state can be reached, and when it is reached, the philosophers will eternally wait for each other to release a fork.^[4]

Resource starvation might also occur independently of deadlock if a particular philosopher is unable to acquire both forks because of a timing problem. For example there might be a rule that the philosophers put down a fork after waiting ten minutes for the other fork to become available and wait a further ten minutes before making their next attempt. This scheme eliminates the possibility of deadlock (the system can always advance to a different state) but still suffers from the problem of livelock. If all five philosophers appear in the dining room at exactly the same time and each picks up the left fork at the same time the philosophers will wait ten minutes until they all put their forks down and then wait a further ten minutes before they all pick them up again.

Mutual exclusion is the basic idea of the problem; the dining philosophers create a generic and abstract scenario useful for explaining issues of this type. The failures these philosophers may experience are analogous to the difficulties that arise in real computer programming when multiple programs need exclusive access to shared resources. These issues are studied in the branch of concurrent programming. The original problems of Dijkstra were related to external devices like tape drives. However, the difficulties exemplified by the dining philosophers problem arise far more often when multiple processes access sets of data that are being updated. Systems such as operating system kernels use thousands of locks and synchronizations that require strict adherence to methods and protocols if such problems as deadlock, starvation, or data corruption are to be avoided.

Solutions

Resource hierarchy solution

This solution to the problem is the one originally proposed by Dijkstra. It assigns a partial order to the resources (the forks, in this case), and establishing the convention that all resources will be requested in order, and that no two resources unrelated by order will ever be used by a single unit of work at the same time. Here, the resources (forks) will be numbered 1 through 5 and each unit of work (philosopher) will always pick up the lower-numbered fork first, and then the higher-numbered fork, from among the two forks he plans to use. The order in which each philosopher puts down the forks does not matter. In this case, if four of the five philosophers simultaneously pick up their lower-numbered fork, only the highest numbered fork will remain on the table, so the fifth philosopher will not be able to pick up any fork. Moreover, only one philosopher will have access to that highest-numbered fork, so he will be able to eat using two forks.

While the resource hierarchy solution avoids deadlocks, it is not always practical, especially when the list of required resources is not completely known in advance. For example, if a unit of work holds resources 3 and 5 and then determines it needs resource 2, it must release 5, then 3 before acquiring 2, and then it must re-acquire 3 and 5 in that order. Computer programs that access large numbers of database records would not run efficiently if they were required to release all higher-numbered records before accessing a new record, making the method impractical for that purpose.

NetBeans  Project

Read More»

674 - Coin Change (Uva Solution)

674 - Coin Change

import java.util.Scanner;

class Main {
public static long [] ways=new long [10000];

public static void main(String[] args) {


Scanner sc =new Scanner(System.in);
int n;
int [] coin=new int[5];
coin[0]=1;
coin[1]=5;
coin[2]=10;
coin[3]=25;
coin[4]=50;
int i,j;
ways[0]=1;
for(i=0;i<5;i++){
for(j=coin[i];j<10000;j++){
ways[j]+=ways[j-coin[i]];

}

}
while(sc.hasNext())
{

n=sc.nextInt();




System.out.println(ways[n]);

}

}


}

Read More»

541 - Error Correction ( uva solution )

541 - Error Correction



import java.util.Scanner;

public class Main{   //this is mandatory that in the class name "Main" "M" must be capital letter


public static void main(String [] args){
Scanner sc=new Scanner(System.in);
int n;

while(sc.hasNext()){
n=sc.nextInt();

if(n==0) break;
int a[][] =new int[300][300];
int r,c,e,f,in1=0,in2=0;
r=c=e=f=0;
for(int i=0;i<n;i++){

for(int j=0;j<n;j++)
a[i][j]=sc.nextInt();
}
int i,j;
for( i=0;i<n;i++){
r=0;

for( j=0;j<n;j++){
r+=a[i][j];

}
if(r%2!=0){
e++;
in1=i+1;


}


}


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

for( j=0;j<n;j++){
c+=a[j][i];

}
if(c%2!=0){
f++;
in2=i+1;


}


}
if(f==0&&e==0)
System.out.println("OK");
else if(f==1&&e==1)
System.out.println("Change bit ("+in1+","+in2+")");
else
System.out.println("Corrupt");





}
}

}

Read More»

10183 - How Many Fibs? (Uva Solution)

import java.math.BigInteger;
import java.util.Scanner;


class Main {

    public static void main(String[] args) {
       
        Scanner sc=new Scanner(System.in);
        BigInteger [] f=new BigInteger[502];
        f[1]=BigInteger.valueOf(1);
        f[2]=BigInteger.valueOf(2);
        for(int i=3;i<=501;i++)
        {
            f[i]=f[i-1].add(f[i-2]);
           
        }
        while(sc.hasNext())
        {
            int c=0;
            BigInteger a=sc.nextBigInteger();
            BigInteger b=sc.nextBigInteger();
            if(a.compareTo(BigInteger.ZERO)==0&&b.compareTo(BigInteger.ZERO)==0)
                break;
            else if(a.compareTo(BigInteger.ZERO)==0&&b.compareTo(BigInteger.ZERO)==0)
                System.out.println("1");
            else if(a.compareTo(BigInteger.ZERO)==0&&b.compareTo(BigInteger.ONE)==0)
                System.out.println("1");
            else if(a.compareTo(BigInteger.ONE)==0&&b.compareTo(BigInteger.ONE)==0)
                System.out.println("1");
            else
            {
                for(int i=1;i<501;i++)
                {
                    if(f[i].compareTo(a)>=0&&f[i].compareTo(b)<=0)
                        c++;
                }
                System.out.println(c);
               
            }
               
        }
        sc.close();

    }

}

Read More»

11830 - Contract Revision

import java.math.BigInteger;
import java.util.Scanner;

class Main11830 {

public static void main(String[] args) {
// TODO Auto-generated method stub
String ch,s,temp;

int i,j;
Scanner sc=new Scanner(System.in);
BigInteger a;
while(true)
{
temp=new String("");
ch=sc.next();
s=sc.next();
if(ch.charAt(0)=='0'&&s.charAt(0)=='0') break;
for(i=0;i<s.length();i++)
{
if(s.charAt(i)!=ch.charAt(0))
temp=temp+s.charAt(i);


}


if(temp.length()==0) temp="0";
a=new BigInteger(temp);

System.out.println(a);

}

}

}

Read More»