Name: fh87463 Date: 10/19/2001



Test DiningPhilosophers test hung when running with merlin JDK after(include) build 70
on solsparc/solx86/linux platform. It will pass when running with ladybird and merline
JDK before build 69.

All source file and tonga log located under:
/net/jano.sfbay/export/disk20/GammaBase/Bugs/[BugID]

To reproduce the bug:
=====================
1. cd /net/jano.sfbay/export/disk20/GammaBase/Bugs/[BugID]
2. go into one of the sub directory
3. run *tlog file.

Here is java source code:

/******************************************************************************

                DiningPhilosophers.java
     
                This class tests Thread synchronization by means of a classic
        Operating Systems problem called Dining Philosophers.

                Description of Analogy:
                A given number of Philosophers spend their lives thinking and
        eating around a large table with a bowl of rice in the middle. Each
        Philosopher eats with chopsticks - and the Philosophers must share
        their chopsticks. In the classic scenario, each Philosopher has one
        chopstick on his/her right and one chopstick on his/her left.
        Because we are dealing with a finite machine, and not a theoretical
        structure, I've decided to fix the number of chopsticks to two. There
        may be one hundred Philosophers. They all have to share one pair of
        chopsticks. I did this because I wanted to see how well the system keeps
        track of things when there are a lot of Threads waiting by means of
synchronization.
                In both the classic scenario and my own, a Philosopher must have both
        chopsticks in order to eat.


                Implementation :
                The number of Philosophers who share the two chopsticks is given
        as a command-line argument. The program reads the String in, converts it
        to an integer value, and then uses that value to determine the number of
        Philosophers to create.
                Here, I've decided to implement Philosophers as Threads, each of
which have to use both Chopsticks to eat a certain number of "turns".
The actual "Chopsticks" are not implemented as variables in the program.
Instead, to keep everything simpler, I decided to use two boolean arrays,
"left_chopstick_used" and "right_chopstick_used" for the Philosopher Threads
to synchronize on. Both arrays are two-dimensional, with the first dimension
corresponding to the number of concurrent Philosopher Threads, and the second
dimension corresponding to the number of times that Philosopher has eaten.
Every time a Philosopher gains the monitor for one of
these arrays, the Philosopher is said to have grabbed a Chopstick.
Each time a Philosopher Thread gains the monitor for an array, it sets
the value of that array at that index to "true."
Every time a Philosopher Thread gains both Chopsticks, that Philosopher
eats. To represent this, I used a one-dimensional boolean array - "has_eaten"
with a number of entries equal to the number of Philosopher Threads times the
number of turns each Philosopher takes. Each time a Philosopher eats, he
sets the value of one of the indices in "has_eaten" to "true." He also
increments the static int index of that "has_eaten" array. The name of this
static int index is "has_eaten_index" - I am not endeavoring to be terribly
imaginative with names here!!
Note that neither the "has_eaten" array nor its static "has_eaten_index"
have any kind of synchronization code around them. This apparently dangerous
omission has a practical application: only one Philosopher Thread at a time
gets access to both Chopsticks, and therefore only one Philosopher Thread
at a time gets access to the "has_eaten" array, and can only increment its index
in an appropriate fashion if the synchronization code is working according to
the specifications. If the synchronization code does not exclude other
Philosopher Threads, the chances are overwhelming that the public static
int "has_eaten_index" will be incremented in an inappropriate manner, and
therefore the test will fail.
At the very end of the test, after all the Philosopher Threads have
run and died, the "main" goes through all the arrays, checking their boolean
values. if it finds one of these values set to "false", it will exit
with status = 1 (FAIL). If the exit(1) conditions don't trigger, the
test is assumed to have passed, and the message "TEST PASSED" is printed
out for the reader.


*****************************************************************************/



import java.lang.*;
import java.io.*;

/*
"DiningPhilosophers" class

This public class contains the main() which gets everything going
and contains all the public arrays and variables which it checks at the end.

*/

public class DiningPhilosophers{

public static boolean[][] used_left_chopstick;
public static boolean[][] used_right_chopstick;
public static boolean[] has_eaten;
public static int has_eaten_index = 0;
public static int NUMBER_OF_PHILOS;//determined from command-line argument
public static final int NUMBER_OF_TURNS = 100000;//constant - we want it big

public static void main(String argv[]){

NUMBER_OF_PHILOS = Integer.parseInt(argv[0]);
            

used_left_chopstick = new boolean[NUMBER_OF_PHILOS][NUMBER_OF_TURNS];
used_right_chopstick = new boolean[NUMBER_OF_PHILOS][NUMBER_OF_TURNS];
has_eaten = new boolean[NUMBER_OF_PHILOS*NUMBER_OF_TURNS];


//initialize - if any Thread skips one of these, we want it to fail
for(int i=0; i<NUMBER_OF_PHILOS; i++){
for(int j=0; j<NUMBER_OF_TURNS; j++){
used_left_chopstick[i][j] = false;
used_right_chopstick[i][j] = false;
has_eaten[i*j+j] = false;
}//end inner for
}//end outer for

for(int i=1; i<=NUMBER_OF_PHILOS; i++){
new Philosopher(i).start();
}//end for

//wait until all Philosopher Threads have finished.
while (Thread.activeCount()>1)
Thread.currentThread().yield();

//now, we check all three boolean arrays for any values remaining at "false"
for(int i=0; i<NUMBER_OF_PHILOS; i++){
for(int j=0; j<NUMBER_OF_TURNS; j++){
if(! used_left_chopstick[i][j])
System.exit(1);
if(! used_right_chopstick[i][j])
System.exit(1);
if(! has_eaten[i*j+j])
System.exit(1);
}//end inner for
}//end outer for

//if we got to this point, the test passed
System.out.println("TEST PASSED");

}//end main

}//end public class DiningPhilosophers


/*
"Philosopher" class

This class extends Thread, so it can run like a Thread. It
uses synchronization to ensure exclusive access to the "has_eaten" boolean
array and its "has_eaten_index"

*/

class Philosopher extends Thread{

private int index;

//constructor
public Philosopher(int index){
super(String.valueOf(index));
this.index = index;
}//end constructor

public void run(){

for(int steps=0; steps < DiningPhilosophers.NUMBER_OF_TURNS; steps++){
synchronized(DiningPhilosophers.used_left_chopstick){
DiningPhilosophers.used_left_chopstick[index-1][steps] = true;
synchronized(DiningPhilosophers.used_right_chopstick){
DiningPhilosophers.used_right_chopstick[index-1][steps] = true;
DiningPhilosophers.has_eaten[DiningPhilosophers.has_eaten_index++] = true;
}//end synchronized - DiningPhilosophers.used_right_chopstick
}//end synchronized - used_left_chopstick
}//end for

}//end public void run() method

}//end non-public Philosopher class



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