allan.jacobs@Eng 1996-12-20

The problem is present in the native thread implementation of the VM. When
run with THREADS_FLAG not present in the environment, no printout appears
when the class is interpreted. When THREADS_FLAG is set to native, the
error message "corruptedMemory" is written to standard output.


tarantula% unsetenv THREADS_FLAG
tarantula% javac -d . e1720101.java
tarantula% java X
tarantula% setenv THREADS_FLAG native
tarantula% java X
corruptedMemory
tarantula% cat e1720101.java

/**
 ** JAVATEST : The Modena JAVA Test Suite, Version 2.0, November 1996
 ** Copyright (c) 1996 Modena Software (I) Pvt. Ltd., All Rights Reserved
 **/

/*
 * Section: 17.2
 *
 * Filename: c1720101.java
 *
 * Purpose: Positive test for section 17.2, para 1:
 *
 * "The actions performed by the main memory for any one variable
 * are totally ordered; that is, for any two actions performed
 * by the main memory on the same variable, one action precedes
 * the other."
 *
 * Section 17.4 para 2:
 * "This matters because a read or write of a double or long
 * variable may be handled by an actual main memory as two
 * 32-bit read or write actions that may be separated in time,
 * with other actions coming between them."
 *
 *
 * Language Specification: October, 1996
 */


//
// Note: When run on JDK1_0_2 for NT4.0/Win95, this test randomly fails runtime
// execution. It is advisable that this test is manually run multiple
// times to ensure the results.
//
//
// Test Description: Several threads simultaneously read/write on the
// same variable for lakhs of times. Variable should
// not have any other value except from the union of
// various predetermined values written by all the threads.
//
// Treats volatile double
//

class T1 extends Thread {
  final static double d1=Double.MAX_VALUE;
  public void run()
  {
    for(int i=0;i<500000;i++)
     {
       double dTemp=X.d;
       if((dTemp!=T1.d1)&&(dTemp!=T2.d2)&&(dTemp!=T3.d3)&&(dTemp!=T4.d4)&&(dTemp!=T5.d5))
        {
        //
        // stop all the threads, since X.d has unexpected value
        //
          X.corruptedMemory=true;
          X.t2.stop();
          X.t3.stop();
          X.t4.stop();
          X.t5.stop();
        }
       else
         X.d=d1;
     }
  }
}

class T2 extends Thread {
  final static double d2=Double.MIN_VALUE;
  public void run()
  {
    for(int i=0;i<500000;i++)
     {
       double dTemp=X.d;
       if((dTemp!=T1.d1)&&(dTemp!=T2.d2)&&(dTemp!=T3.d3)&&(dTemp!=T4.d4)&&(dTemp!=T5.d5))
        {
        //
        // stop all the threads, since X.d has unexpected value
        //
          X.corruptedMemory=true;
          X.t1.stop();
          X.t3.stop();
          X.t4.stop();
          X.t5.stop();
        }
       else
         X.d=d2;
     }
  }
}

class T3 extends Thread {
  final static double d3=0.0;
  public void run()
  {
    for(int i=0;i<500000;i++)
     {
       double dTemp=X.d;
       if((dTemp!=T1.d1)&&(dTemp!=T2.d2)&&(dTemp!=T3.d3)&&(dTemp!=T4.d4)&&(dTemp!=T5.d5))
        {
        //
        // stop all the threads, since X.d has unexpected value
        //
          X.corruptedMemory=true;
          X.t1.stop();
          X.t2.stop();
          X.t4.stop();
          X.t5.stop();
        }
       else
         X.d=d3;
     }
  }
}

class T4 extends Thread {
  final static double d4=999999;
  public void run()
  {
    for(int i=0;i<500000;i++)
     {
       double dTemp=X.d;
       if((dTemp!=T1.d1)&&(dTemp!=T2.d2)&&(dTemp!=T3.d3)&&(dTemp!=T4.d4)&&(dTemp!=T5.d5))
        {
        //
        // stop all the threads, since X.d has unexpected value
        //
          X.corruptedMemory=true;
          X.t1.stop();
          X.t2.stop();
          X.t3.stop();
          X.t5.stop();
        }
       else
         X.d=d4;
     }
  }
}

class T5 extends Thread {
  final static double d5=-777777;
  public void run()
  {
    for(int i=0;i<500000;i++)
     {
       double dTemp=X.d;
       if((dTemp!=T1.d1)&&(dTemp!=T2.d2)&&(dTemp!=T3.d3)&&(dTemp!=T4.d4)&&(dTemp!=T5.d5))
        {
        //
        // stop all the threads, since X.d has unexpected value
        //
          X.corruptedMemory=true;
          X.t1.stop();
          X.t2.stop();
          X.t3.stop();
          X.t4.stop();
        }
       else
         X.d=d5;
     }
  }
}

class X
{
  static boolean corruptedMemory=false;
  static Thread t1=new T1();
  static Thread t2=new T2();
  static Thread t3=new T3();
  static Thread t4=new T4();
  static Thread t5=new T5();
  static volatile double d=T1.d1;
  public static void main(String argv[]) throws InterruptedException
   {
     try {
       t1.start();
       t2.start();
       t3.start();
       t4.start();
       t5.start();
       t1.join();
       t2.join();
       t3.join();
       t4.join();
       t5.join();
     }
     catch(Throwable e) {
       corruptedMemory=true;
       System.err.println(e); // something very wrong
     }
     if (corruptedMemory) {
        System.out.println("corruptedMemory");
     }
   }
}