Differences between -Xss[size] in linux and windows

Question

Simple thread test program which runs 3000 threads:
startup options on windows:
-server -Xms16m -Xmx16m -Xss7k
startup options on linux:
-server -Xms16m -Xmx16m -Xss97k (Why 90k bigger stack size??)
Linux is using newest kernel and NPTL threads. With 'regular' threads the linux version overflows stack unless -Xss2m is given...
I Think Sun needs to come up with clear specification of threading models, libraries etc... used in both environments. If you search these forums - one of the most common and baffling error is the sig11 on linux. I think the main cause behind it are the library 'mismatches'.
Answers to these questions are really needed:
What is the recommended threading library on linux with each VM version?
Against which library is the VM tested?
If anyone has experiences with NPTL threads on 1.4.2 VM please contribute. How many threads did you manage to create, how much memory that took? What distribution, thread library, start up parameters, etc... did you use.
I'm going to do a bit more experimenting on a real life application during the followin weeks. With simple test program we were able to create over 16000 threads, but if you do the math with the minimum stack size you can guess that the virtual memory usage was sky high!
P.S.
I'll post more exact platform specs when I'm back to work tomorrow..

Answer 1

http://java.sun.com/docs/hotspot/VMOptions.html - see under -Xoss option.
BTW, I ran my test case again, and now i finally succeeded to prove that 'rule' (see that 'another' thread): Xss*nThreads + Xmx < Xmx_MAX. The conclusions are (at least under 32-bit Linux):
1) Xss does limit native stack size
2) the 'rule' seems to be independent of whether u r actually using the allocated stack space or not
Below a test case is attached. Under 32-bit Linux it crashes before it can create 30 threads with
Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread
        at java.lang.Thread.start(Native Method)
        at testlab.StackTest.main(StackTest.java:46)exception, if start up parameters are
java -cp ../../classes -Djava.library.path=./ -Xms1870m -Xmx1870m -Xss1m testlab.StackTest 100 200 1000000The crash point can be moved/eliminated by modifying either Xss param (the smaller the size the later the crush would happen) or Xmn/Xmx (the smaller...., the later....). Exact Xmx_MAX number might depend on what threads library you are running. On my hardware it is as follows:
java -Xms1920M -Xmx1920M
Error occurred during initialization of VM
Could not reserve enough space for object heap
java -Xms1910M -Xmx1910M
Error occurred during initialization of VM
Could not reserve enough space for card marking array
java -Xms1900M -Xmx1900M
<RUNS OK>See how error messages differ. So, in the case above Xmx_MAX is around 1.9G.
Native code was compiled with gcc2.96, under 32-bit RH Linux, no optimizations.
Java code compiled with 1.4.2_02 compiler, run with JVM is 1.4.2_02
Java file:
package testlab;
* Author: volenin
* Date: Dec 4, 2003
* Time: 10:40:20 AM
* under GPL license
public class StackTest extends Thread {
  static byte[] arr;
  static {
    System.loadLibrary("stacktest");
  boolean isStarted = false;
  int allocSize;
  StackTest(int allocSize) {
    this.allocSize = allocSize;
    setDaemon(true);
//    arr2 = new byte[allocSize];
  public void run() {
    isStarted = true;
    allocate(allocSize);
    synchronized (this) {
      try { wait(); }
      catch (InterruptedException Ie) {}
  public native void allocate(int size);
  public static void main(String[] args) throws Exception {
    int nThreads = Integer.parseInt(args[0]);
    int allocSize = Integer.parseInt(args[1]);
    int initSize = Integer.parseInt(args[2]);
    arr = new byte[initSize];
    for (int i = 0; i < nThreads; i++) {
      int n = i+1;
      System.out.println("Creating thread #"+n);
      StackTest test = new StackTest(allocSize);
      System.out.println("Starting thread #"+n);
      test.start();
      System.out.println("Thread started #"+n);
      synchronized (StackTest.class) {
        if (!test.isStarted)   StackTest.class.wait(100);
      System.out.println("Thread running #"+n);
Native .h file:
#include <jni.h>
#ifndef _Included_testlab_StackTest
#define _Included_testlab_StackTest
#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_testlab_StackTest_allocate(JNIEnv *, jobject, jint);
#ifdef __cplusplus
#endif
#endif
Native .cpp file:
#include "testlab_StackTest.h"
JNIEXPORT void JNICALL Java_testlab_StackTest_allocate(JNIEnv *env, jobject jobj, jint allocSize) {
  int arr[allocSize];
  int arrSize = sizeof(arr);
  printf("array allocated: %d, %d\n", allocSize, arrSize);
  getchar();