Latest working kernel version:
all 2.6 i686 kernels

Earliest failing kernel version:
since change to x86_64 kernels

Distribution:
- Debial 4.0 (Etch)
- SuSE Enterprise Server 10
- openSUSE 10.3 (X86-64)

Hardware Environment:
- VMware ESX host, 1 CPU (Intel(R) Xeon(TM) CPU 3.00GHz)
- MemTotal:      2063116 kB

Software Environment:
SUN's Java JDK / JRE 1.6.0_06 as well as 1.6.0_10 in its 32 bit edition.

Problem Description:
Sproradic but reproducible JVM (Hotspot) crashes getting a SIGSEGV or SIGILL while unning a simple garbage collector stress application seval times in parallel.

hs_err files are generated each time.

The problem only appears using JDK or JRE 1.6 32 bit edition on a Linux 2.6 x86_64 kernel in VMware.

Tests using real hardware, using a i686 kernel and using JDK / JRE 1.6 64 bit edition or JDK / JRE 1.5 (32 bit and 64 bit) could not reproduce the crashes.

Steps to reproduce:

Run the attached simple Java application, no matter if compiled using a JDK 1.5 or JDK 1.6.
Run it in parallel with these parameters to produce it more often:

java -server -Xms32m -Xms256m GCStress 1000 10485760

public class GCStress {
    private static Thread[] threads;
    private static java.util.Random random = new java.util.Random();
    private static int maxBytes;
    private static int numThreads;

    public static void main(String[] args) {
        numThreads = Integer.parseInt(args[0]);
        maxBytes = Integer.parseInt(args[1]);
        threads = new Thread[numThreads];
        for (int x = 0; x < numThreads; x++) {
            threads[x] = new Thread(new Allocator(), "Thread_" + x);
            threads[x].start();
        }

        while (true) {
            for (int x = 0; x < numThreads; x++) {
                if (!threads[x].isAlive()) {
                    threads[x] = new Thread(new Allocator(), "Thread_r" + x);
                    threads[x].start();
                }
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // ignore
            }

        }
    }

    private static class Allocator implements Runnable {
        public void run() {
            while (true) {
                int tSize = random.nextInt(maxBytes);
//                System.out.println(Thread.currentThread().getName()
//                        + " allocating " + tSize / 1024 + "kb");
                byte[] tMemFiller = new byte[tSize];
                try {
                    Thread.sleep(random.nextInt(200));
                } catch (InterruptedException e) {
                    ; // ignore
                }
            }
        }
    };
}



Expected and Actual Results:

After about 5 minutes running (in VMware), some or all applications crash. Often, two and more of the parallel applications crash almost at the same time.

hs_err files are generated and show:
- SIGILL
- SIGSEGV

often but not always while the JVM is in a safepoint, e.g.
VM_Operation (0xe371ee1c): GenCollectForAllocation, mode: safepoint, requested by thread 0x08217000