Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Thu Nov 04 15:19:16 2010 -0700
     1.2 +++ b/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Thu Nov 04 16:17:54 2010 -0700
     1.3 @@ -664,7 +664,7 @@
     1.4    // Use temps to avoid kills
     1.5    LIR_Opr t1 = FrameMap::G1_opr;
     1.6    LIR_Opr t2 = FrameMap::G3_opr;
     1.7 -  LIR_Opr addr = (type == objectType) ? new_register(T_OBJECT) : new_pointer_register();
     1.8 +  LIR_Opr addr = new_pointer_register();
     1.9  
    1.10    // get address of field
    1.11    obj.load_item();

     2.1 --- a/src/cpu/sparc/vm/globals_sparc.hpp	Thu Nov 04 15:19:16 2010 -0700
     2.2 +++ b/src/cpu/sparc/vm/globals_sparc.hpp	Thu Nov 04 16:17:54 2010 -0700
     2.3 @@ -62,3 +62,5 @@
     2.4  
     2.5  define_pd_global(bool, RewriteBytecodes,     true);
     2.6  define_pd_global(bool, RewriteFrequentPairs, true);
     2.7 +
     2.8 +define_pd_global(bool, UseMembar,            false);

     3.1 --- a/src/cpu/x86/vm/c1_CodeStubs_x86.cpp	Thu Nov 04 15:19:16 2010 -0700
     3.2 +++ b/src/cpu/x86/vm/c1_CodeStubs_x86.cpp	Thu Nov 04 16:17:54 2010 -0700
     3.3 @@ -499,7 +499,7 @@
     3.4    Register new_val_reg = new_val()->as_register();
     3.5    __ cmpptr(new_val_reg, (int32_t) NULL_WORD);
     3.6    __ jcc(Assembler::equal, _continuation);
     3.7 -  ce->store_parameter(addr()->as_register(), 0);
     3.8 +  ce->store_parameter(addr()->as_pointer_register(), 0);
     3.9    __ call(RuntimeAddress(Runtime1::entry_for(Runtime1::g1_post_barrier_slow_id)));
    3.10    __ jmp(_continuation);
    3.11  }

     4.1 --- a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp	Thu Nov 04 15:19:16 2010 -0700
     4.2 +++ b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp	Thu Nov 04 16:17:54 2010 -0700
     4.3 @@ -765,7 +765,7 @@
     4.4      ShouldNotReachHere();
     4.5    }
     4.6  
     4.7 -  LIR_Opr addr = (type == objectType) ? new_register(T_OBJECT) : new_pointer_register();
     4.8 +  LIR_Opr addr = new_pointer_register();
     4.9    LIR_Address* a;
    4.10    if(offset.result()->is_constant()) {
    4.11      a = new LIR_Address(obj.result(),

     5.1 --- a/src/cpu/x86/vm/globals_x86.hpp	Thu Nov 04 15:19:16 2010 -0700
     5.2 +++ b/src/cpu/x86/vm/globals_x86.hpp	Thu Nov 04 16:17:54 2010 -0700
     5.3 @@ -63,3 +63,5 @@
     5.4  
     5.5  define_pd_global(bool, RewriteBytecodes,     true);
     5.6  define_pd_global(bool, RewriteFrequentPairs, true);
     5.7 +
     5.8 +define_pd_global(bool, UseMembar,            false);

     6.1 --- a/src/cpu/zero/vm/globals_zero.hpp	Thu Nov 04 15:19:16 2010 -0700
     6.2 +++ b/src/cpu/zero/vm/globals_zero.hpp	Thu Nov 04 16:17:54 2010 -0700
     6.3 @@ -45,3 +45,5 @@
     6.4  
     6.5  define_pd_global(bool,  RewriteBytecodes,     true);
     6.6  define_pd_global(bool,  RewriteFrequentPairs, true);
     6.7 +
     6.8 +define_pd_global(bool,  UseMembar,            false);

     7.1 --- a/src/os/linux/vm/attachListener_linux.cpp	Thu Nov 04 15:19:16 2010 -0700
     7.2 +++ b/src/os/linux/vm/attachListener_linux.cpp	Thu Nov 04 16:17:54 2010 -0700
     7.3 @@ -176,10 +176,10 @@
     7.4  
     7.5    int n = snprintf(path, UNIX_PATH_MAX, "%s/.java_pid%d",
     7.6                     os::get_temp_directory(), os::current_process_id());
     7.7 -  if (n <= (int)UNIX_PATH_MAX) {
     7.8 +  if (n < (int)UNIX_PATH_MAX) {
     7.9      n = snprintf(initial_path, UNIX_PATH_MAX, "%s.tmp", path);
    7.10    }
    7.11 -  if (n > (int)UNIX_PATH_MAX) {
    7.12 +  if (n >= (int)UNIX_PATH_MAX) {
    7.13      return -1;
    7.14    }
    7.15  

     8.1 --- a/src/os/linux/vm/objectMonitor_linux.cpp	Thu Nov 04 15:19:16 2010 -0700
     8.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.3 @@ -1,24 +0,0 @@
     8.4 -
     8.5 -/*
     8.6 - * Copyright (c) 1999, 2005, Oracle and/or its affiliates. All rights reserved.
     8.7 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.8 - *
     8.9 - * This code is free software; you can redistribute it and/or modify it
    8.10 - * under the terms of the GNU General Public License version 2 only, as
    8.11 - * published by the Free Software Foundation.
    8.12 - *
    8.13 - * This code is distributed in the hope that it will be useful, but WITHOUT
    8.14 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    8.15 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    8.16 - * version 2 for more details (a copy is included in the LICENSE file that
    8.17 - * accompanied this code).
    8.18 - *
    8.19 - * You should have received a copy of the GNU General Public License version
    8.20 - * 2 along with this work; if not, write to the Free Software Foundation,
    8.21 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    8.22 - *
    8.23 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    8.24 - * or visit www.oracle.com if you need additional information or have any
    8.25 - * questions.
    8.26 - *
    8.27 - */

     9.1 --- a/src/os/linux/vm/objectMonitor_linux.hpp	Thu Nov 04 15:19:16 2010 -0700
     9.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.3 @@ -1,25 +0,0 @@
     9.4 -/*
     9.5 - * Copyright (c) 1999, 2005, Oracle and/or its affiliates. All rights reserved.
     9.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     9.7 - *
     9.8 - * This code is free software; you can redistribute it and/or modify it
     9.9 - * under the terms of the GNU General Public License version 2 only, as
    9.10 - * published by the Free Software Foundation.
    9.11 - *
    9.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
    9.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    9.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    9.15 - * version 2 for more details (a copy is included in the LICENSE file that
    9.16 - * accompanied this code).
    9.17 - *
    9.18 - * You should have received a copy of the GNU General Public License version
    9.19 - * 2 along with this work; if not, write to the Free Software Foundation,
    9.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    9.21 - *
    9.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    9.23 - * or visit www.oracle.com if you need additional information or have any
    9.24 - * questions.
    9.25 - *
    9.26 - */
    9.27 -
    9.28 - private:

    10.1 --- a/src/os/linux/vm/objectMonitor_linux.inline.hpp	Thu Nov 04 15:19:16 2010 -0700
    10.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.3 @@ -1,23 +0,0 @@
    10.4 -/*
    10.5 - * Copyright (c) 1999, 2005, Oracle and/or its affiliates. All rights reserved.
    10.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    10.7 - *
    10.8 - * This code is free software; you can redistribute it and/or modify it
    10.9 - * under the terms of the GNU General Public License version 2 only, as
   10.10 - * published by the Free Software Foundation.
   10.11 - *
   10.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   10.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   10.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   10.15 - * version 2 for more details (a copy is included in the LICENSE file that
   10.16 - * accompanied this code).
   10.17 - *
   10.18 - * You should have received a copy of the GNU General Public License version
   10.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   10.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   10.21 - *
   10.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   10.23 - * or visit www.oracle.com if you need additional information or have any
   10.24 - * questions.
   10.25 - *
   10.26 - */

    11.1 --- a/src/os/linux/vm/os_linux.cpp	Thu Nov 04 15:19:16 2010 -0700
    11.2 +++ b/src/os/linux/vm/os_linux.cpp	Thu Nov 04 16:17:54 2010 -0700
    11.3 @@ -1,5 +1,5 @@
    11.4  /*
    11.5 - * Copyright (c) 1999, 2009, Oracle and/or its affiliates. All rights reserved.
    11.6 + * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
    11.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    11.8   *
    11.9   * This code is free software; you can redistribute it and/or modify it
   11.10 @@ -827,8 +827,10 @@
   11.11  
   11.12        switch (thr_type) {
   11.13        case os::java_thread:
   11.14 -        // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
   11.15 -        if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create();
   11.16 +        // Java threads use ThreadStackSize which default value can be
   11.17 +        // changed with the flag -Xss
   11.18 +        assert (JavaThread::stack_size_at_create() > 0, "this should be set");
   11.19 +        stack_size = JavaThread::stack_size_at_create();
   11.20          break;
   11.21        case os::compiler_thread:
   11.22          if (CompilerThreadStackSize > 0) {
   11.23 @@ -3922,12 +3924,21 @@
   11.24    Linux::signal_sets_init();
   11.25    Linux::install_signal_handlers();
   11.26  
   11.27 +  // Check minimum allowable stack size for thread creation and to initialize
   11.28 +  // the java system classes, including StackOverflowError - depends on page
   11.29 +  // size.  Add a page for compiler2 recursion in main thread.
   11.30 +  // Add in 2*BytesPerWord times page size to account for VM stack during
   11.31 +  // class initialization depending on 32 or 64 bit VM.
   11.32 +  os::Linux::min_stack_allowed = MAX2(os::Linux::min_stack_allowed,
   11.33 +            (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
   11.34 +                    2*BytesPerWord COMPILER2_PRESENT(+1)) * Linux::page_size());
   11.35 +
   11.36    size_t threadStackSizeInBytes = ThreadStackSize * K;
   11.37    if (threadStackSizeInBytes != 0 &&
   11.38 -      threadStackSizeInBytes < Linux::min_stack_allowed) {
   11.39 +      threadStackSizeInBytes < os::Linux::min_stack_allowed) {
   11.40          tty->print_cr("\nThe stack size specified is too small, "
   11.41                        "Specify at least %dk",
   11.42 -                      Linux::min_stack_allowed / K);
   11.43 +                      os::Linux::min_stack_allowed/ K);
   11.44          return JNI_ERR;
   11.45    }
   11.46  
   11.47 @@ -4839,7 +4850,7 @@
   11.48  
   11.49    // Next, demultiplex/decode time arguments
   11.50    timespec absTime;
   11.51 -  if (time < 0) { // don't wait at all
   11.52 +  if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
   11.53      return;
   11.54    }
   11.55    if (time > 0) {

    12.1 --- a/src/os/solaris/vm/objectMonitor_solaris.cpp	Thu Nov 04 15:19:16 2010 -0700
    12.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.3 @@ -1,23 +0,0 @@
    12.4 -/*
    12.5 - * Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
    12.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    12.7 - *
    12.8 - * This code is free software; you can redistribute it and/or modify it
    12.9 - * under the terms of the GNU General Public License version 2 only, as
   12.10 - * published by the Free Software Foundation.
   12.11 - *
   12.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   12.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   12.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   12.15 - * version 2 for more details (a copy is included in the LICENSE file that
   12.16 - * accompanied this code).
   12.17 - *
   12.18 - * You should have received a copy of the GNU General Public License version
   12.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   12.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   12.21 - *
   12.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   12.23 - * or visit www.oracle.com if you need additional information or have any
   12.24 - * questions.
   12.25 - *
   12.26 - */

    13.1 --- a/src/os/solaris/vm/objectMonitor_solaris.hpp	Thu Nov 04 15:19:16 2010 -0700
    13.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.3 @@ -1,25 +0,0 @@
    13.4 -/*
    13.5 - * Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
    13.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    13.7 - *
    13.8 - * This code is free software; you can redistribute it and/or modify it
    13.9 - * under the terms of the GNU General Public License version 2 only, as
   13.10 - * published by the Free Software Foundation.
   13.11 - *
   13.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   13.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13.15 - * version 2 for more details (a copy is included in the LICENSE file that
   13.16 - * accompanied this code).
   13.17 - *
   13.18 - * You should have received a copy of the GNU General Public License version
   13.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   13.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   13.21 - *
   13.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   13.23 - * or visit www.oracle.com if you need additional information or have any
   13.24 - * questions.
   13.25 - *
   13.26 - */
   13.27 -
   13.28 - private:

    14.1 --- a/src/os/solaris/vm/objectMonitor_solaris.inline.hpp	Thu Nov 04 15:19:16 2010 -0700
    14.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.3 @@ -1,23 +0,0 @@
    14.4 -/*
    14.5 - * Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
    14.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    14.7 - *
    14.8 - * This code is free software; you can redistribute it and/or modify it
    14.9 - * under the terms of the GNU General Public License version 2 only, as
   14.10 - * published by the Free Software Foundation.
   14.11 - *
   14.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   14.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14.15 - * version 2 for more details (a copy is included in the LICENSE file that
   14.16 - * accompanied this code).
   14.17 - *
   14.18 - * You should have received a copy of the GNU General Public License version
   14.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   14.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   14.21 - *
   14.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   14.23 - * or visit www.oracle.com if you need additional information or have any
   14.24 - * questions.
   14.25 - *
   14.26 - */

    15.1 --- a/src/os/solaris/vm/os_solaris.cpp	Thu Nov 04 15:19:16 2010 -0700
    15.2 +++ b/src/os/solaris/vm/os_solaris.cpp	Thu Nov 04 16:17:54 2010 -0700
    15.3 @@ -1,5 +1,5 @@
    15.4  /*
    15.5 - * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
    15.6 + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
    15.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    15.8   *
    15.9   * This code is free software; you can redistribute it and/or modify it
   15.10 @@ -4878,18 +4878,17 @@
   15.11    // Check minimum allowable stack size for thread creation and to initialize
   15.12    // the java system classes, including StackOverflowError - depends on page
   15.13    // size.  Add a page for compiler2 recursion in main thread.
   15.14 -  // Add in BytesPerWord times page size to account for VM stack during
   15.15 +  // Add in 2*BytesPerWord times page size to account for VM stack during
   15.16    // class initialization depending on 32 or 64 bit VM.
   15.17 -  guarantee((Solaris::min_stack_allowed >=
   15.18 -    (StackYellowPages+StackRedPages+StackShadowPages+BytesPerWord
   15.19 -     COMPILER2_PRESENT(+1)) * page_size),
   15.20 -    "need to increase Solaris::min_stack_allowed on this platform");
   15.21 +  os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed,
   15.22 +            (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
   15.23 +                    2*BytesPerWord COMPILER2_PRESENT(+1)) * page_size);
   15.24  
   15.25    size_t threadStackSizeInBytes = ThreadStackSize * K;
   15.26    if (threadStackSizeInBytes != 0 &&
   15.27 -    threadStackSizeInBytes < Solaris::min_stack_allowed) {
   15.28 +    threadStackSizeInBytes < os::Solaris::min_stack_allowed) {
   15.29      tty->print_cr("\nThe stack size specified is too small, Specify at least %dk",
   15.30 -                  Solaris::min_stack_allowed/K);
   15.31 +                  os::Solaris::min_stack_allowed/K);
   15.32      return JNI_ERR;
   15.33    }
   15.34  
   15.35 @@ -5837,7 +5836,7 @@
   15.36  
   15.37    // First, demultiplex/decode time arguments
   15.38    timespec absTime;
   15.39 -  if (time < 0) { // don't wait at all
   15.40 +  if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
   15.41      return;
   15.42    }
   15.43    if (time > 0) {

    16.1 --- a/src/os/windows/vm/objectMonitor_windows.cpp	Thu Nov 04 15:19:16 2010 -0700
    16.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.3 @@ -1,25 +0,0 @@
    16.4 -/*
    16.5 - * Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
    16.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    16.7 - *
    16.8 - * This code is free software; you can redistribute it and/or modify it
    16.9 - * under the terms of the GNU General Public License version 2 only, as
   16.10 - * published by the Free Software Foundation.
   16.11 - *
   16.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   16.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   16.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   16.15 - * version 2 for more details (a copy is included in the LICENSE file that
   16.16 - * accompanied this code).
   16.17 - *
   16.18 - * You should have received a copy of the GNU General Public License version
   16.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   16.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   16.21 - *
   16.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   16.23 - * or visit www.oracle.com if you need additional information or have any
   16.24 - * questions.
   16.25 - *
   16.26 - */
   16.27 -
   16.28 -#include "incls/_precompiled.incl"

    17.1 --- a/src/os/windows/vm/objectMonitor_windows.hpp	Thu Nov 04 15:19:16 2010 -0700
    17.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.3 @@ -1,25 +0,0 @@
    17.4 -/*
    17.5 - * Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
    17.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    17.7 - *
    17.8 - * This code is free software; you can redistribute it and/or modify it
    17.9 - * under the terms of the GNU General Public License version 2 only, as
   17.10 - * published by the Free Software Foundation.
   17.11 - *
   17.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   17.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   17.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   17.15 - * version 2 for more details (a copy is included in the LICENSE file that
   17.16 - * accompanied this code).
   17.17 - *
   17.18 - * You should have received a copy of the GNU General Public License version
   17.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   17.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   17.21 - *
   17.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   17.23 - * or visit www.oracle.com if you need additional information or have any
   17.24 - * questions.
   17.25 - *
   17.26 - */
   17.27 -
   17.28 - private:

    18.1 --- a/src/os/windows/vm/objectMonitor_windows.inline.hpp	Thu Nov 04 15:19:16 2010 -0700
    18.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.3 @@ -1,23 +0,0 @@
    18.4 -/*
    18.5 - * Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
    18.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    18.7 - *
    18.8 - * This code is free software; you can redistribute it and/or modify it
    18.9 - * under the terms of the GNU General Public License version 2 only, as
   18.10 - * published by the Free Software Foundation.
   18.11 - *
   18.12 - * This code is distributed in the hope that it will be useful, but WITHOUT
   18.13 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   18.14 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   18.15 - * version 2 for more details (a copy is included in the LICENSE file that
   18.16 - * accompanied this code).
   18.17 - *
   18.18 - * You should have received a copy of the GNU General Public License version
   18.19 - * 2 along with this work; if not, write to the Free Software Foundation,
   18.20 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   18.21 - *
   18.22 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   18.23 - * or visit www.oracle.com if you need additional information or have any
   18.24 - * questions.
   18.25 - *
   18.26 - */

    19.1 --- a/src/os/windows/vm/os_windows.cpp	Thu Nov 04 15:19:16 2010 -0700
    19.2 +++ b/src/os/windows/vm/os_windows.cpp	Thu Nov 04 16:17:54 2010 -0700
    19.3 @@ -3311,7 +3311,6 @@
    19.4    }
    19.5  }
    19.6  
    19.7 -
    19.8  // this is called _after_ the global arguments have been parsed
    19.9  jint os::init_2(void) {
   19.10    // Allocate a single page and mark it as readable for safepoint polling
   19.11 @@ -3390,6 +3389,21 @@
   19.12      actual_reserve_size = default_reserve_size;
   19.13    }
   19.14  
   19.15 +  // Check minimum allowable stack size for thread creation and to initialize
   19.16 +  // the java system classes, including StackOverflowError - depends on page
   19.17 +  // size.  Add a page for compiler2 recursion in main thread.
   19.18 +  // Add in 2*BytesPerWord times page size to account for VM stack during
   19.19 +  // class initialization depending on 32 or 64 bit VM.
   19.20 +  size_t min_stack_allowed =
   19.21 +            (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
   19.22 +            2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
   19.23 +  if (actual_reserve_size < min_stack_allowed) {
   19.24 +    tty->print_cr("\nThe stack size specified is too small, "
   19.25 +                  "Specify at least %dk",
   19.26 +                  min_stack_allowed / K);
   19.27 +    return JNI_ERR;
   19.28 +  }
   19.29 +
   19.30    JavaThread::set_stack_size_at_create(stack_commit_size);
   19.31  
   19.32    // Calculate theoretical max. size of Threads to guard gainst artifical
   19.33 @@ -3992,7 +4006,7 @@
   19.34    if (time < 0) { // don't wait
   19.35      return;
   19.36    }
   19.37 -  else if (time == 0) {
   19.38 +  else if (time == 0 && !isAbsolute) {
   19.39      time = INFINITE;
   19.40    }
   19.41    else if  (isAbsolute) {

    20.1 --- a/src/share/vm/c1/c1_LIRGenerator.cpp	Thu Nov 04 15:19:16 2010 -0700
    20.2 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp	Thu Nov 04 16:17:54 2010 -0700
    20.3 @@ -1350,7 +1350,6 @@
    20.4      addr = ptr;
    20.5    }
    20.6    assert(addr->is_register(), "must be a register at this point");
    20.7 -  assert(addr->type() == T_OBJECT, "addr should point to an object");
    20.8  
    20.9    LIR_Opr xor_res = new_pointer_register();
   20.10    LIR_Opr xor_shift_res = new_pointer_register();

    21.1 --- a/src/share/vm/classfile/classFileParser.cpp	Thu Nov 04 15:19:16 2010 -0700
    21.2 +++ b/src/share/vm/classfile/classFileParser.cpp	Thu Nov 04 16:17:54 2010 -0700
    21.3 @@ -4309,20 +4309,21 @@
    21.4  }
    21.5  
    21.6  
    21.7 -// Unqualified names may not contain the characters '.', ';', or '/'.
    21.8 -// Method names also may not contain the characters '<' or '>', unless <init> or <clinit>.
    21.9 -// Note that method names may not be <init> or <clinit> in this method.
   21.10 -// Because these names have been checked as special cases before calling this method
   21.11 -// in verify_legal_method_name.
   21.12 -bool ClassFileParser::verify_unqualified_name(char* name, unsigned int length, int type) {
   21.13 +// Unqualified names may not contain the characters '.', ';', '[', or '/'.
   21.14 +// Method names also may not contain the characters '<' or '>', unless <init>
   21.15 +// or <clinit>.  Note that method names may not be <init> or <clinit> in this
   21.16 +// method.  Because these names have been checked as special cases before
   21.17 +// calling this method in verify_legal_method_name.
   21.18 +bool ClassFileParser::verify_unqualified_name(
   21.19 +    char* name, unsigned int length, int type) {
   21.20    jchar ch;
   21.21  
   21.22    for (char* p = name; p != name + length; ) {
   21.23      ch = *p;
   21.24      if (ch < 128) {
   21.25        p++;
   21.26 -      if (ch == '.' || ch == ';') {
   21.27 -        return false;   // do not permit '.' or ';'
   21.28 +      if (ch == '.' || ch == ';' || ch == '[' ) {
   21.29 +        return false;   // do not permit '.', ';', or '['
   21.30        }
   21.31        if (type != LegalClass && ch == '/') {
   21.32          return false;   // do not permit '/' unless it's class name

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/src/share/vm/classfile/stackMapTableFormat.hpp	Thu Nov 04 16:17:54 2010 -0700
    22.3 @@ -0,0 +1,916 @@
    22.4 +/*
    22.5 + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
    22.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    22.7 + *
    22.8 + * This code is free software; you can redistribute it and/or modify it
    22.9 + * under the terms of the GNU General Public License version 2 only, as
   22.10 + * published by the Free Software Foundation.
   22.11 + *
   22.12 + * This code is distributed in the hope that it will be useful, but WITHOUT
   22.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   22.14 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   22.15 + * version 2 for more details (a copy is included in the LICENSE file that
   22.16 + * accompanied this code).
   22.17 + *
   22.18 + * You should have received a copy of the GNU General Public License version
   22.19 + * 2 along with this work; if not, write to the Free Software Foundation,
   22.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   22.21 + *
   22.22 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   22.23 + * or visit www.oracle.com if you need additional information or have any
   22.24 + * questions.
   22.25 + *
   22.26 + */
   22.27 +
   22.28 +// These classes represent the stack-map substructures described in the JVMS
   22.29 +// (hence the non-conforming naming scheme).
   22.30 +
   22.31 +// These classes work with the types in their compressed form in-place (as they
   22.32 +// would appear in the classfile).  No virtual methods or fields allowed.
   22.33 +
   22.34 +class verification_type_info {
   22.35 + private:
   22.36 +  // u1 tag
   22.37 +  // u2 cpool_index || u2 bci (for ITEM_Object & ITEM_Uninitailized only)
   22.38 +
   22.39 +  address tag_addr() const { return (address)this; }
   22.40 +  address cpool_index_addr() const { return tag_addr() + sizeof(u1); }
   22.41 +  address bci_addr() const { return cpool_index_addr(); }
   22.42 +
   22.43 + protected:
   22.44 +  // No constructors  - should be 'private', but GCC issues a warning if it is
   22.45 +  verification_type_info() {}
   22.46 +  verification_type_info(const verification_type_info&) {}
   22.47 +
   22.48 + public:
   22.49 +
   22.50 +  static verification_type_info* at(address addr) {
   22.51 +    return (verification_type_info*)addr;
   22.52 +  }
   22.53 +
   22.54 +  static verification_type_info* create_at(address addr, u1 tag) {
   22.55 +    verification_type_info* vti = (verification_type_info*)addr;
   22.56 +    vti->set_tag(tag);
   22.57 +    return vti;
   22.58 +  }
   22.59 +
   22.60 +  static verification_type_info* create_object_at(address addr, u2 cp_idx) {
   22.61 +    verification_type_info* vti = (verification_type_info*)addr;
   22.62 +    vti->set_tag(ITEM_Object);
   22.63 +    vti->set_cpool_index(cp_idx);
   22.64 +    return vti;
   22.65 +  }
   22.66 +
   22.67 +  static verification_type_info* create_uninit_at(address addr, u2 bci) {
   22.68 +    verification_type_info* vti = (verification_type_info*)addr;
   22.69 +    vti->set_tag(ITEM_Uninitialized);
   22.70 +    vti->set_bci(bci);
   22.71 +    return vti;
   22.72 +  }
   22.73 +
   22.74 +  static size_t calculate_size(u1 tag) {
   22.75 +    if (tag == ITEM_Object || tag == ITEM_Uninitialized) {
   22.76 +      return sizeof(u1) + sizeof(u2);
   22.77 +    } else {
   22.78 +      return sizeof(u1);
   22.79 +    }
   22.80 +  }
   22.81 +
   22.82 +  static size_t max_size() { return sizeof(u1) + sizeof(u2); }
   22.83 +
   22.84 +  u1 tag() const { return *(u1*)tag_addr(); }
   22.85 +  void set_tag(u1 tag) { *((u1*)tag_addr()) = tag; }
   22.86 +
   22.87 +  bool is_object() const { return tag() == ITEM_Object; }
   22.88 +  bool is_uninitialized() const { return tag() == ITEM_Uninitialized; }
   22.89 +
   22.90 +  u2 cpool_index() const {
   22.91 +    assert(is_object(), "This type has no cp_index");
   22.92 +    return Bytes::get_Java_u2(cpool_index_addr());
   22.93 +  }
   22.94 +  void set_cpool_index(u2 idx) {
   22.95 +    assert(is_object(), "This type has no cp_index");
   22.96 +    Bytes::put_Java_u2(cpool_index_addr(), idx);
   22.97 +  }
   22.98 +
   22.99 +  u2 bci() const {
  22.100 +    assert(is_uninitialized(), "This type has no bci");
  22.101 +    return Bytes::get_Java_u2(bci_addr());
  22.102 +  }
  22.103 +
  22.104 +  void set_bci(u2 bci) {
  22.105 +    assert(is_uninitialized(), "This type has no bci");
  22.106 +    Bytes::put_Java_u2(bci_addr(), bci);
  22.107 +  }
  22.108 +
  22.109 +  void copy_from(verification_type_info* from) {
  22.110 +    set_tag(from->tag());
  22.111 +    if (from->is_object()) {
  22.112 +      set_cpool_index(from->cpool_index());
  22.113 +    } else if (from->is_uninitialized()) {
  22.114 +      set_bci(from->bci());
  22.115 +    }
  22.116 +  }
  22.117 +
  22.118 +  size_t size() const {
  22.119 +    return calculate_size(tag());
  22.120 +  }
  22.121 +
  22.122 +  verification_type_info* next() {
  22.123 +    return (verification_type_info*)((address)this + size());
  22.124 +  }
  22.125 +
  22.126 +  // This method is used when reading unverified data in order to ensure
  22.127 +  // that we don't read past a particular memory limit.  It returns false
  22.128 +  // if any part of the data structure is outside the specified memory bounds.
  22.129 +  bool verify(address start, address end) {
  22.130 +    return ((address)this >= start &&
  22.131 +            (address)this < end &&
  22.132 +            (bci_addr() + sizeof(u2) <= end ||
  22.133 +                !is_object() && !is_uninitialized()));
  22.134 +  }
  22.135 +
  22.136 +#ifdef ASSERT
  22.137 +  void print_on(outputStream* st) {
  22.138 +    switch (tag()) {
  22.139 +      case ITEM_Top: st->print("Top"); break;
  22.140 +      case ITEM_Integer: st->print("Integer"); break;
  22.141 +      case ITEM_Float: st->print("Float"); break;
  22.142 +      case ITEM_Double: st->print("Double"); break;
  22.143 +      case ITEM_Long: st->print("Long"); break;
  22.144 +      case ITEM_Null: st->print("Null"); break;
  22.145 +      case ITEM_UninitializedThis:
  22.146 +        st->print("UninitializedThis"); break;
  22.147 +      case ITEM_Uninitialized:
  22.148 +        st->print("Uninitialized[#%d]", bci()); break;
  22.149 +      case ITEM_Object:
  22.150 +        st->print("Object[#%d]", cpool_index()); break;
  22.151 +      default:
  22.152 +        assert(false, "Bad verification_type_info");
  22.153 +    }
  22.154 +  }
  22.155 +#endif
  22.156 +};
  22.157 +
  22.158 +#define FOR_EACH_STACKMAP_FRAME_TYPE(macro, arg1, arg2) \
  22.159 +  macro(same_frame, arg1, arg2) \
  22.160 +  macro(same_frame_extended, arg1, arg2) \
  22.161 +  macro(same_frame_1_stack_item_frame, arg1, arg2) \
  22.162 +  macro(same_frame_1_stack_item_extended, arg1, arg2) \
  22.163 +  macro(chop_frame, arg1, arg2) \
  22.164 +  macro(append_frame, arg1, arg2) \
  22.165 +  macro(full_frame, arg1, arg2)
  22.166 +
  22.167 +#define SM_FORWARD_DECL(type, arg1, arg2) class type;
  22.168 +FOR_EACH_STACKMAP_FRAME_TYPE(SM_FORWARD_DECL, x, x)
  22.169 +#undef SM_FORWARD_DECL
  22.170 +
  22.171 +class stack_map_frame {
  22.172 + protected:
  22.173 +  address frame_type_addr() const { return (address)this; }
  22.174 +
  22.175 +  // No constructors  - should be 'private', but GCC issues a warning if it is
  22.176 +  stack_map_frame() {}
  22.177 +  stack_map_frame(const stack_map_frame&) {}
  22.178 +
  22.179 + public:
  22.180 +
  22.181 +  static stack_map_frame* at(address addr) {
  22.182 +    return (stack_map_frame*)addr;
  22.183 +  }
  22.184 +
  22.185 +  stack_map_frame* next() const {
  22.186 +    return at((address)this + size());
  22.187 +  }
  22.188 +
  22.189 +  u1 frame_type() const { return *(u1*)frame_type_addr(); }
  22.190 +  void set_frame_type(u1 type) { *((u1*)frame_type_addr()) = type; }
  22.191 +
  22.192 +  // pseudo-virtual methods
  22.193 +  inline size_t size() const;
  22.194 +  inline int offset_delta() const;
  22.195 +  inline void set_offset_delta(int offset_delta);
  22.196 +  inline int number_of_types() const; // number of types contained in the frame
  22.197 +  inline verification_type_info* types() const; // pointer to first type
  22.198 +  inline bool is_valid_offset(int offset_delta) const;
  22.199 +
  22.200 +  // This method must be used when reading unverified data in order to ensure
  22.201 +  // that we don't read past a particular memory limit.  It returns false
  22.202 +  // if any part of the data structure is outside the specified memory bounds.
  22.203 +  inline bool verify(address start, address end) const;
  22.204 +#ifdef ASSERT
  22.205 +  inline void print_on(outputStream* st) const;
  22.206 +#endif
  22.207 +
  22.208 +  // Create as_xxx and is_xxx methods for the subtypes
  22.209 +#define FRAME_TYPE_DECL(stackmap_frame_type, arg1, arg2) \
  22.210 +  inline stackmap_frame_type* as_##stackmap_frame_type() const; \
  22.211 +  bool is_##stackmap_frame_type() { \
  22.212 +    return as_##stackmap_frame_type() != NULL; \
  22.213 +  }
  22.214 +
  22.215 +  FOR_EACH_STACKMAP_FRAME_TYPE(FRAME_TYPE_DECL, x, x)
  22.216 +#undef FRAME_TYPE_DECL
  22.217 +};
  22.218 +
  22.219 +class same_frame : public stack_map_frame {
  22.220 + private:
  22.221 +  static int frame_type_to_offset_delta(u1 frame_type) {
  22.222 +      return frame_type + 1; }
  22.223 +  static u1 offset_delta_to_frame_type(int offset_delta) {
  22.224 +      return (u1)(offset_delta - 1); }
  22.225 +
  22.226 + public:
  22.227 +
  22.228 +  static bool is_frame_type(u1 tag) {
  22.229 +    return tag < 64;
  22.230 +  }
  22.231 +
  22.232 +  static same_frame* at(address addr) {
  22.233 +    assert(is_frame_type(*addr), "Wrong frame id");
  22.234 +    return (same_frame*)addr;
  22.235 +  }
  22.236 +
  22.237 +  static same_frame* create_at(address addr, int offset_delta) {
  22.238 +    same_frame* sm = (same_frame*)addr;
  22.239 +    sm->set_offset_delta(offset_delta);
  22.240 +    return sm;
  22.241 +  }
  22.242 +
  22.243 +  static size_t calculate_size() { return sizeof(u1); }
  22.244 +
  22.245 +  size_t size() const { return calculate_size(); }
  22.246 +  int offset_delta() const { return frame_type_to_offset_delta(frame_type()); }
  22.247 +
  22.248 +  void set_offset_delta(int offset_delta) {
  22.249 +    assert(offset_delta <= 64, "Offset too large for same_frame");
  22.250 +    set_frame_type(offset_delta_to_frame_type(offset_delta));
  22.251 +  }
  22.252 +
  22.253 +  int number_of_types() const { return 0; }
  22.254 +  verification_type_info* types() const { return NULL; }
  22.255 +
  22.256 +  bool is_valid_offset(int offset_delta) const {
  22.257 +    return is_frame_type(offset_delta_to_frame_type(offset_delta));
  22.258 +  }
  22.259 +
  22.260 +  bool verify_subtype(address start, address end) const {
  22.261 +    return true;
  22.262 +  }
  22.263 +
  22.264 +#ifdef ASSERT
  22.265 +  void print_on(outputStream* st) const {
  22.266 +    st->print("same_frame(%d)", offset_delta());
  22.267 +  }
  22.268 +#endif
  22.269 +};
  22.270 +
  22.271 +class same_frame_extended : public stack_map_frame {
  22.272 + private:
  22.273 +  enum { _frame_id = 251 };
  22.274 +  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }
  22.275 +
  22.276 + public:
  22.277 +  static bool is_frame_type(u1 tag) {
  22.278 +    return tag == _frame_id;
  22.279 +  }
  22.280 +
  22.281 +  static same_frame_extended* at(address addr) {
  22.282 +    assert(is_frame_type(*addr), "Wrong frame type");
  22.283 +    return (same_frame_extended*)addr;
  22.284 +  }
  22.285 +
  22.286 +  static same_frame_extended* create_at(address addr, u2 offset_delta) {
  22.287 +    same_frame_extended* sm = (same_frame_extended*)addr;
  22.288 +    sm->set_frame_type(_frame_id);
  22.289 +    sm->set_offset_delta(offset_delta);
  22.290 +    return sm;
  22.291 +  }
  22.292 +
  22.293 +  static size_t calculate_size() { return sizeof(u1) + sizeof(u2); }
  22.294 +
  22.295 +  size_t size() const { return calculate_size(); }
  22.296 +  int offset_delta() const {
  22.297 +    return Bytes::get_Java_u2(offset_delta_addr()) + 1;
  22.298 +  }
  22.299 +
  22.300 +  void set_offset_delta(int offset_delta) {
  22.301 +    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);
  22.302 +  }
  22.303 +
  22.304 +  int number_of_types() const { return 0; }
  22.305 +  verification_type_info* types() const { return NULL; }
  22.306 +  bool is_valid_offset(int offset) const { return true; }
  22.307 +
  22.308 +  bool verify_subtype(address start, address end) const {
  22.309 +    return frame_type_addr() + size() <= end;
  22.310 +  }
  22.311 +
  22.312 +#ifdef ASSERT
  22.313 +  void print_on(outputStream* st) const {
  22.314 +    st->print("same_frame_extended(%d)", offset_delta());
  22.315 +  }
  22.316 +#endif
  22.317 +};
  22.318 +
  22.319 +class same_frame_1_stack_item_frame : public stack_map_frame {
  22.320 + private:
  22.321 +  address type_addr() const { return frame_type_addr() + sizeof(u1); }
  22.322 +
  22.323 +  static int frame_type_to_offset_delta(u1 frame_type) {
  22.324 +      return frame_type - 63; }
  22.325 +  static u1 offset_delta_to_frame_type(int offset_delta) {
  22.326 +      return (u1)(offset_delta + 63); }
  22.327 +
  22.328 + public:
  22.329 +  static bool is_frame_type(u1 tag) {
  22.330 +    return tag >= 64 && tag < 128;
  22.331 +  }
  22.332 +
  22.333 +  static same_frame_1_stack_item_frame* at(address addr) {
  22.334 +    assert(is_frame_type(*addr), "Wrong frame id");
  22.335 +    return (same_frame_1_stack_item_frame*)addr;
  22.336 +  }
  22.337 +
  22.338 +  static same_frame_1_stack_item_frame* create_at(
  22.339 +      address addr, int offset_delta, verification_type_info* vti) {
  22.340 +    same_frame_1_stack_item_frame* sm = (same_frame_1_stack_item_frame*)addr;
  22.341 +    sm->set_offset_delta(offset_delta);
  22.342 +    if (vti != NULL) {
  22.343 +      sm->set_type(vti);
  22.344 +    }
  22.345 +    return sm;
  22.346 +  }
  22.347 +
  22.348 +  static size_t calculate_size(verification_type_info* vti) {
  22.349 +    return sizeof(u1) + vti->size();
  22.350 +  }
  22.351 +
  22.352 +  static size_t max_size() {
  22.353 +    return sizeof(u1) + verification_type_info::max_size();
  22.354 +  }
  22.355 +
  22.356 +  size_t size() const { return calculate_size(types()); }
  22.357 +  int offset_delta() const { return frame_type_to_offset_delta(frame_type()); }
  22.358 +
  22.359 +  void set_offset_delta(int offset_delta) {
  22.360 +    assert(offset_delta > 0 && offset_delta <= 64,
  22.361 +           "Offset too large for this frame type");
  22.362 +    set_frame_type(offset_delta_to_frame_type(offset_delta));
  22.363 +  }
  22.364 +
  22.365 +  void set_type(verification_type_info* vti) {
  22.366 +    verification_type_info* cur = types();
  22.367 +    cur->copy_from(vti);
  22.368 +  }
  22.369 +
  22.370 +  int number_of_types() const { return 1; }
  22.371 +  verification_type_info* types() const {
  22.372 +    return verification_type_info::at(type_addr());
  22.373 +  }
  22.374 +
  22.375 +  bool is_valid_offset(int offset_delta) const {
  22.376 +    return is_frame_type(offset_delta_to_frame_type(offset_delta));
  22.377 +  }
  22.378 +
  22.379 +  bool verify_subtype(address start, address end) const {
  22.380 +    return types()->verify(start, end);
  22.381 +  }
  22.382 +
  22.383 +#ifdef ASSERT
  22.384 +  void print_on(outputStream* st) const {
  22.385 +    st->print("same_frame_1_stack_item_frame(%d,", offset_delta());
  22.386 +    types()->print_on(st);
  22.387 +    st->print(")");
  22.388 +  }
  22.389 +#endif
  22.390 +};
  22.391 +
  22.392 +class same_frame_1_stack_item_extended : public stack_map_frame {
  22.393 + private:
  22.394 +  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }
  22.395 +  address type_addr() const { return offset_delta_addr() + sizeof(u2); }
  22.396 +
  22.397 +  enum { _frame_id = 247 };
  22.398 +
  22.399 + public:
  22.400 +  static bool is_frame_type(u1 tag) {
  22.401 +    return tag == _frame_id;
  22.402 +  }
  22.403 +
  22.404 +  static same_frame_1_stack_item_extended* at(address addr) {
  22.405 +    assert(is_frame_type(*addr), "Wrong frame id");
  22.406 +    return (same_frame_1_stack_item_extended*)addr;
  22.407 +  }
  22.408 +
  22.409 +  static same_frame_1_stack_item_extended* create_at(
  22.410 +      address addr, int offset_delta, verification_type_info* vti) {
  22.411 +    same_frame_1_stack_item_extended* sm =
  22.412 +       (same_frame_1_stack_item_extended*)addr;
  22.413 +    sm->set_frame_type(_frame_id);
  22.414 +    sm->set_offset_delta(offset_delta);
  22.415 +    if (vti != NULL) {
  22.416 +      sm->set_type(vti);
  22.417 +    }
  22.418 +    return sm;
  22.419 +  }
  22.420 +
  22.421 +  static size_t calculate_size(verification_type_info* vti) {
  22.422 +    return sizeof(u1) + sizeof(u2) + vti->size();
  22.423 +  }
  22.424 +
  22.425 +  size_t size() const { return calculate_size(types()); }
  22.426 +  int offset_delta() const {
  22.427 +    return Bytes::get_Java_u2(offset_delta_addr()) + 1;
  22.428 +  }
  22.429 +
  22.430 +  void set_offset_delta(int offset_delta) {
  22.431 +    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);
  22.432 +  }
  22.433 +
  22.434 +  void set_type(verification_type_info* vti) {
  22.435 +    verification_type_info* cur = types();
  22.436 +    cur->copy_from(vti);
  22.437 +  }
  22.438 +
  22.439 +  int number_of_types() const { return 1; }
  22.440 +  verification_type_info* types() const {
  22.441 +    return verification_type_info::at(type_addr());
  22.442 +  }
  22.443 +  bool is_valid_offset(int offset) { return true; }
  22.444 +
  22.445 +  bool verify_subtype(address start, address end) const {
  22.446 +    return type_addr() < end && types()->verify(start, end);
  22.447 +  }
  22.448 +
  22.449 +#ifdef ASSERT
  22.450 +  void print_on(outputStream* st) const {
  22.451 +    st->print("same_frame_1_stack_item_extended(%d,", offset_delta());
  22.452 +    types()->print_on(st);
  22.453 +    st->print(")");
  22.454 +  }
  22.455 +#endif
  22.456 +};
  22.457 +
  22.458 +class chop_frame : public stack_map_frame {
  22.459 + private:
  22.460 +  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }
  22.461 +
  22.462 +  static int frame_type_to_chops(u1 frame_type) {
  22.463 +    int chop = 251 - frame_type;
  22.464 +    return chop;
  22.465 +  }
  22.466 +
  22.467 +  static u1 chops_to_frame_type(int chop) {
  22.468 +    return 251 - chop;
  22.469 +  }
  22.470 +
  22.471 + public:
  22.472 +  static bool is_frame_type(u1 tag) {
  22.473 +    return frame_type_to_chops(tag) > 0 && frame_type_to_chops(tag) < 4;
  22.474 +  }
  22.475 +
  22.476 +  static chop_frame* at(address addr) {
  22.477 +    assert(is_frame_type(*addr), "Wrong frame id");
  22.478 +    return (chop_frame*)addr;
  22.479 +  }
  22.480 +
  22.481 +  static chop_frame* create_at(address addr, int offset_delta, int chops) {
  22.482 +    chop_frame* sm = (chop_frame*)addr;
  22.483 +    sm->set_chops(chops);
  22.484 +    sm->set_offset_delta(offset_delta);
  22.485 +    return sm;
  22.486 +  }
  22.487 +
  22.488 +  static size_t calculate_size() {
  22.489 +    return sizeof(u1) + sizeof(u2);
  22.490 +  }
  22.491 +
  22.492 +  size_t size() const { return calculate_size(); }
  22.493 +  int offset_delta() const {
  22.494 +    return Bytes::get_Java_u2(offset_delta_addr()) + 1;
  22.495 +  }
  22.496 +  void set_offset_delta(int offset_delta) {
  22.497 +    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);
  22.498 +  }
  22.499 +
  22.500 +  int chops() const {
  22.501 +    int chops = frame_type_to_chops(frame_type());
  22.502 +    assert(chops > 0 && chops < 4, "Invalid number of chops in frame");
  22.503 +    return chops;
  22.504 +  }
  22.505 +  void set_chops(int chops) {
  22.506 +    assert(chops > 0 && chops <= 3, "Bad number of chops");
  22.507 +    set_frame_type(chops_to_frame_type(chops));
  22.508 +  }
  22.509 +
  22.510 +  int number_of_types() const { return 0; }
  22.511 +  verification_type_info* types() const { return NULL; }
  22.512 +  bool is_valid_offset(int offset) { return true; }
  22.513 +
  22.514 +  bool verify_subtype(address start, address end) const {
  22.515 +    return frame_type_addr() + size() <= end;
  22.516 +  }
  22.517 +
  22.518 +#ifdef ASSERT
  22.519 +  void print_on(outputStream* st) const {
  22.520 +    st->print("chop_frame(%d,%d)", offset_delta(), chops());
  22.521 +  }
  22.522 +#endif
  22.523 +};
  22.524 +
  22.525 +class append_frame : public stack_map_frame {
  22.526 + private:
  22.527 +  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }
  22.528 +  address types_addr() const { return offset_delta_addr() + sizeof(u2); }
  22.529 +
  22.530 +  static int frame_type_to_appends(u1 frame_type) {
  22.531 +    int append = frame_type - 251;
  22.532 +    return append;
  22.533 +  }
  22.534 +
  22.535 +  static u1 appends_to_frame_type(int appends) {
  22.536 +    assert(appends > 0 && appends < 4, "Invalid append amount");
  22.537 +    return 251 + appends;
  22.538 +  }
  22.539 +
  22.540 + public:
  22.541 +  static bool is_frame_type(u1 tag) {
  22.542 +    return frame_type_to_appends(tag) > 0 && frame_type_to_appends(tag) < 4;
  22.543 +  }
  22.544 +
  22.545 +  static append_frame* at(address addr) {
  22.546 +    assert(is_frame_type(*addr), "Wrong frame id");
  22.547 +    return (append_frame*)addr;
  22.548 +  }
  22.549 +
  22.550 +  static append_frame* create_at(
  22.551 +      address addr, int offset_delta, int appends,
  22.552 +      verification_type_info* types) {
  22.553 +    append_frame* sm = (append_frame*)addr;
  22.554 +    sm->set_appends(appends);
  22.555 +    sm->set_offset_delta(offset_delta);
  22.556 +    if (types != NULL) {
  22.557 +      verification_type_info* cur = sm->types();
  22.558 +      for (int i = 0; i < appends; ++i) {
  22.559 +        cur->copy_from(types);
  22.560 +        cur = cur->next();
  22.561 +        types = types->next();
  22.562 +      }
  22.563 +    }
  22.564 +    return sm;
  22.565 +  }
  22.566 +
  22.567 +  static size_t calculate_size(int appends, verification_type_info* types) {
  22.568 +    size_t sz = sizeof(u1) + sizeof(u2);
  22.569 +    for (int i = 0; i < appends; ++i) {
  22.570 +      sz += types->size();
  22.571 +      types = types->next();
  22.572 +    }
  22.573 +    return sz;
  22.574 +  }
  22.575 +
  22.576 +  static size_t max_size() {
  22.577 +    return sizeof(u1) + sizeof(u2) + 3 * verification_type_info::max_size();
  22.578 +  }
  22.579 +
  22.580 +  size_t size() const { return calculate_size(number_of_types(), types()); }
  22.581 +  int offset_delta() const {
  22.582 +    return Bytes::get_Java_u2(offset_delta_addr()) + 1;
  22.583 +  }
  22.584 +
  22.585 +  void set_offset_delta(int offset_delta) {
  22.586 +    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);
  22.587 +  }
  22.588 +
  22.589 +  void set_appends(int appends) {
  22.590 +    assert(appends > 0 && appends < 4, "Bad number of appends");
  22.591 +    set_frame_type(appends_to_frame_type(appends));
  22.592 +  }
  22.593 +
  22.594 +  int number_of_types() const {
  22.595 +    int appends = frame_type_to_appends(frame_type());
  22.596 +    assert(appends > 0 && appends < 4, "Invalid number of appends in frame");
  22.597 +    return appends;
  22.598 +  }
  22.599 +  verification_type_info* types() const {
  22.600 +    return verification_type_info::at(types_addr());
  22.601 +  }
  22.602 +  bool is_valid_offset(int offset) const { return true; }
  22.603 +
  22.604 +  bool verify_subtype(address start, address end) const {
  22.605 +    verification_type_info* vti = types();
  22.606 +    if ((address)vti < end && vti->verify(start, end)) {
  22.607 +      int nof = number_of_types();
  22.608 +      vti = vti->next();
  22.609 +      if (nof < 2 || vti->verify(start, end)) {
  22.610 +        vti = vti->next();
  22.611 +        if (nof < 3 || vti->verify(start, end)) {
  22.612 +          return true;
  22.613 +        }
  22.614 +      }
  22.615 +    }
  22.616 +    return false;
  22.617 +  }
  22.618 +
  22.619 +#ifdef ASSERT
  22.620 +  void print_on(outputStream* st) const {
  22.621 +    st->print("append_frame(%d,", offset_delta());
  22.622 +    verification_type_info* vti = types();
  22.623 +    for (int i = 0; i < number_of_types(); ++i) {
  22.624 +      vti->print_on(st);
  22.625 +      if (i != number_of_types() - 1) {
  22.626 +        st->print(",");
  22.627 +      }
  22.628 +      vti = vti->next();
  22.629 +    }
  22.630 +    st->print(")");
  22.631 +  }
  22.632 +#endif
  22.633 +};
  22.634 +
  22.635 +class full_frame : public stack_map_frame {
  22.636 + private:
  22.637 +  address offset_delta_addr() const { return frame_type_addr() + sizeof(u1); }
  22.638 +  address num_locals_addr() const { return offset_delta_addr() + sizeof(u2); }
  22.639 +  address locals_addr() const { return num_locals_addr() + sizeof(u2); }
  22.640 +  address stack_slots_addr(address end_of_locals) const {
  22.641 +      return end_of_locals; }
  22.642 +  address stack_addr(address end_of_locals) const {
  22.643 +      return stack_slots_addr(end_of_locals) + sizeof(u2); }
  22.644 +
  22.645 +  enum { _frame_id = 255 };
  22.646 +
  22.647 + public:
  22.648 +  static bool is_frame_type(u1 tag) {
  22.649 +    return tag == _frame_id;
  22.650 +  }
  22.651 +
  22.652 +  static full_frame* at(address addr) {
  22.653 +    assert(is_frame_type(*addr), "Wrong frame id");
  22.654 +    return (full_frame*)addr;
  22.655 +  }
  22.656 +
  22.657 +  static full_frame* create_at(
  22.658 +      address addr, int offset_delta, int num_locals,
  22.659 +      verification_type_info* locals,
  22.660 +      int stack_slots, verification_type_info* stack) {
  22.661 +    full_frame* sm = (full_frame*)addr;
  22.662 +    sm->set_frame_type(_frame_id);
  22.663 +    sm->set_offset_delta(offset_delta);
  22.664 +    sm->set_num_locals(num_locals);
  22.665 +    if (locals != NULL) {
  22.666 +      verification_type_info* cur = sm->locals();
  22.667 +      for (int i = 0; i < num_locals; ++i) {
  22.668 +        cur->copy_from(locals);
  22.669 +        cur = cur->next();
  22.670 +        locals = locals->next();
  22.671 +      }
  22.672 +      address end_of_locals = (address)cur;
  22.673 +      sm->set_stack_slots(end_of_locals, stack_slots);
  22.674 +      cur = sm->stack(end_of_locals);
  22.675 +      for (int i = 0; i < stack_slots; ++i) {
  22.676 +        cur->copy_from(stack);
  22.677 +        cur = cur->next();
  22.678 +        stack = stack->next();
  22.679 +      }
  22.680 +    }
  22.681 +    return sm;
  22.682 +  }
  22.683 +
  22.684 +  static size_t calculate_size(
  22.685 +      int num_locals, verification_type_info* locals,
  22.686 +      int stack_slots, verification_type_info* stack) {
  22.687 +    size_t sz = sizeof(u1) + sizeof(u2) + sizeof(u2) + sizeof(u2);
  22.688 +    verification_type_info* vti = locals;
  22.689 +    for (int i = 0; i < num_locals; ++i) {
  22.690 +      sz += vti->size();
  22.691 +      vti = vti->next();
  22.692 +    }
  22.693 +    vti = stack;
  22.694 +    for (int i = 0; i < stack_slots; ++i) {
  22.695 +      sz += vti->size();
  22.696 +      vti = vti->next();
  22.697 +    }
  22.698 +    return sz;
  22.699 +  }
  22.700 +
  22.701 +  static size_t max_size(int locals, int stack) {
  22.702 +    return sizeof(u1) + 3 * sizeof(u2) +
  22.703 +        (locals + stack) * verification_type_info::max_size();
  22.704 +  }
  22.705 +
  22.706 +  size_t size() const {
  22.707 +    address eol = end_of_locals();
  22.708 +    return calculate_size(num_locals(), locals(), stack_slots(eol), stack(eol));
  22.709 +  }
  22.710 +
  22.711 +  int offset_delta() const {
  22.712 +    return Bytes::get_Java_u2(offset_delta_addr()) + 1;
  22.713 +  }
  22.714 +  int num_locals() const { return Bytes::get_Java_u2(num_locals_addr()); }
  22.715 +  verification_type_info* locals() const {
  22.716 +    return verification_type_info::at(locals_addr());
  22.717 +  }
  22.718 +  address end_of_locals() const {
  22.719 +    verification_type_info* vti = locals();
  22.720 +    for (int i = 0; i < num_locals(); ++i) {
  22.721 +      vti = vti->next();
  22.722 +    }
  22.723 +    return (address)vti;
  22.724 +  }
  22.725 +  int stack_slots(address end_of_locals) const {
  22.726 +    return Bytes::get_Java_u2(stack_slots_addr(end_of_locals));
  22.727 +  }
  22.728 +  verification_type_info* stack(address end_of_locals) const {
  22.729 +    return verification_type_info::at(stack_addr(end_of_locals));
  22.730 +  }
  22.731 +
  22.732 +  void set_offset_delta(int offset_delta) {
  22.733 +    Bytes::put_Java_u2(offset_delta_addr(), offset_delta - 1);
  22.734 +  }
  22.735 +  void set_num_locals(int num_locals) {
  22.736 +    Bytes::put_Java_u2(num_locals_addr(), num_locals);
  22.737 +  }
  22.738 +  void set_stack_slots(address end_of_locals, int stack_slots) {
  22.739 +    Bytes::put_Java_u2(stack_slots_addr(end_of_locals), stack_slots);
  22.740 +  }
  22.741 +
  22.742 +  // These return only the locals.  Extra processing is required for stack
  22.743 +  // types of full frames.
  22.744 +  int number_of_types() const { return num_locals(); }
  22.745 +  verification_type_info* types() const { return locals(); }
  22.746 +  bool is_valid_offset(int offset) { return true; }
  22.747 +
  22.748 +  bool verify_subtype(address start, address end) const {
  22.749 +    verification_type_info* vti = types();
  22.750 +    if ((address)vti >= end) {
  22.751 +      return false;
  22.752 +    }
  22.753 +    int count = number_of_types();
  22.754 +    for (int i = 0; i < count; ++i) {
  22.755 +      if (!vti->verify(start, end)) {
  22.756 +        return false;
  22.757 +      }
  22.758 +      vti = vti->next();
  22.759 +    }
  22.760 +    address eol = (address)vti;
  22.761 +    if (eol + sizeof(u2) > end) {
  22.762 +      return false;
  22.763 +    }
  22.764 +    count = stack_slots(eol);
  22.765 +    vti = stack(eol);
  22.766 +    for (int i = 0; i < stack_slots(eol); ++i) {
  22.767 +      if (!vti->verify(start, end)) {
  22.768 +        return false;
  22.769 +      }
  22.770 +      vti = vti->next();
  22.771 +    }
  22.772 +    return true;
  22.773 +  }
  22.774 +
  22.775 +#ifdef ASSERT
  22.776 +  void print_on(outputStream* st) const {
  22.777 +    st->print("full_frame(%d,{", offset_delta());
  22.778 +    verification_type_info* vti = locals();
  22.779 +    for (int i = 0; i < num_locals(); ++i) {
  22.780 +      vti->print_on(st);
  22.781 +      if (i != num_locals() - 1) {
  22.782 +        st->print(",");
  22.783 +      }
  22.784 +      vti = vti->next();
  22.785 +    }
  22.786 +    st->print("},{");
  22.787 +    address end_of_locals = (address)vti;
  22.788 +    vti = stack(end_of_locals);
  22.789 +    int ss = stack_slots(end_of_locals);
  22.790 +    for (int i = 0; i < ss; ++i) {
  22.791 +      vti->print_on(st);
  22.792 +      if (i != ss - 1) {
  22.793 +        st->print(",");
  22.794 +      }
  22.795 +      vti = vti->next();
  22.796 +    }
  22.797 +    st->print("})");
  22.798 +  }
  22.799 +#endif
  22.800 +};
  22.801 +
  22.802 +#define VIRTUAL_DISPATCH(stack_frame_type, func_name, args) \
  22.803 +  stack_frame_type* item_##stack_frame_type = as_##stack_frame_type(); \
  22.804 +  if (item_##stack_frame_type != NULL) { \
  22.805 +    return item_##stack_frame_type->func_name args;  \
  22.806 +  }
  22.807 +
  22.808 +#define VOID_VIRTUAL_DISPATCH(stack_frame_type, func_name, args) \
  22.809 +  stack_frame_type* item_##stack_frame_type = as_##stack_frame_type(); \
  22.810 +  if (item_##stack_frame_type != NULL) { \
  22.811 +    item_##stack_frame_type->func_name args;  \
  22.812 +    return; \
  22.813 +  }
  22.814 +
  22.815 +size_t stack_map_frame::size() const {
  22.816 +  FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, size, ());
  22.817 +  return 0;
  22.818 +}
  22.819 +
  22.820 +int stack_map_frame::offset_delta() const {
  22.821 +  FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, offset_delta, ());
  22.822 +  return 0;
  22.823 +}
  22.824 +
  22.825 +void stack_map_frame::set_offset_delta(int offset_delta) {
  22.826 +  FOR_EACH_STACKMAP_FRAME_TYPE(
  22.827 +      VOID_VIRTUAL_DISPATCH, set_offset_delta, (offset_delta));
  22.828 +}
  22.829 +
  22.830 +int stack_map_frame::number_of_types() const {
  22.831 +  FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, number_of_types, ());
  22.832 +  return 0;
  22.833 +}
  22.834 +
  22.835 +verification_type_info* stack_map_frame::types() const {
  22.836 +  FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, types, ());
  22.837 +  return NULL;
  22.838 +}
  22.839 +
  22.840 +bool stack_map_frame::is_valid_offset(int offset) const {
  22.841 +  FOR_EACH_STACKMAP_FRAME_TYPE(VIRTUAL_DISPATCH, is_valid_offset, (offset));
  22.842 +  return true;
  22.843 +}
  22.844 +
  22.845 +bool stack_map_frame::verify(address start, address end) const {
  22.846 +  if (frame_type_addr() >= start && frame_type_addr() < end) {
  22.847 +    FOR_EACH_STACKMAP_FRAME_TYPE(
  22.848 +       VIRTUAL_DISPATCH, verify_subtype, (start, end));
  22.849 +  }
  22.850 +  return false;
  22.851 +}
  22.852 +
  22.853 +#ifdef ASSERT
  22.854 +void stack_map_frame::print_on(outputStream* st) const {
  22.855 +  FOR_EACH_STACKMAP_FRAME_TYPE(VOID_VIRTUAL_DISPATCH, print_on, (st));
  22.856 +}
  22.857 +#endif
  22.858 +
  22.859 +#undef VIRTUAL_DISPATCH
  22.860 +#undef VOID_VIRTUAL_DISPATCH
  22.861 +
  22.862 +#define AS_SUBTYPE_DEF(stack_frame_type, arg1, arg2) \
  22.863 +stack_frame_type* stack_map_frame::as_##stack_frame_type() const { \
  22.864 +  if (stack_frame_type::is_frame_type(frame_type())) { \
  22.865 +    return (stack_frame_type*)this; \
  22.866 +  } else { \
  22.867 +    return NULL; \
  22.868 +  } \
  22.869 +}
  22.870 +
  22.871 +FOR_EACH_STACKMAP_FRAME_TYPE(AS_SUBTYPE_DEF, x, x)
  22.872 +#undef AS_SUBTYPE_DEF
  22.873 +
  22.874 +class stack_map_table_attribute {
  22.875 + private:
  22.876 +  address name_index_addr() const {
  22.877 +      return (address)this; }
  22.878 +  address attribute_length_addr() const {
  22.879 +      return name_index_addr() + sizeof(u2); }
  22.880 +  address number_of_entries_addr() const {
  22.881 +      return attribute_length_addr() + sizeof(u4); }
  22.882 +  address entries_addr() const {
  22.883 +      return number_of_entries_addr() + sizeof(u2); }
  22.884 +
  22.885 + protected:
  22.886 +  // No constructors  - should be 'private', but GCC issues a warning if it is
  22.887 +  stack_map_table_attribute() {}
  22.888 +  stack_map_table_attribute(const stack_map_table_attribute&) {}
  22.889 +
  22.890 + public:
  22.891 +
  22.892 +  static stack_map_table_attribute* at(address addr) {
  22.893 +    return (stack_map_table_attribute*)addr;
  22.894 +  }
  22.895 +
  22.896 +  u2 name_index() const {
  22.897 +       return Bytes::get_Java_u2(name_index_addr()); }
  22.898 +  u4 attribute_length() const {
  22.899 +      return Bytes::get_Java_u4(attribute_length_addr()); }
  22.900 +  u2 number_of_entries() const {
  22.901 +      return Bytes::get_Java_u2(number_of_entries_addr()); }
  22.902 +  stack_map_frame* entries() const {
  22.903 +    return stack_map_frame::at(entries_addr());
  22.904 +  }
  22.905 +
  22.906 +  static size_t header_size() {
  22.907 +      return sizeof(u2) + sizeof(u4);
  22.908 +  }
  22.909 +
  22.910 +  void set_name_index(u2 idx) {
  22.911 +    Bytes::put_Java_u2(name_index_addr(), idx);
  22.912 +  }
  22.913 +  void set_attribute_length(u4 len) {
  22.914 +    Bytes::put_Java_u4(attribute_length_addr(), len);
  22.915 +  }
  22.916 +  void set_number_of_entries(u2 num) {
  22.917 +    Bytes::put_Java_u2(number_of_entries_addr(), num);
  22.918 +  }
  22.919 +};

    23.1 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	Thu Nov 04 15:19:16 2010 -0700
    23.2 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	Thu Nov 04 16:17:54 2010 -0700
    23.3 @@ -354,12 +354,8 @@
    23.4  double CMSStats::time_until_cms_gen_full() const {
    23.5    size_t cms_free = _cms_gen->cmsSpace()->free();
    23.6    GenCollectedHeap* gch = GenCollectedHeap::heap();
    23.7 -  size_t expected_promotion = gch->get_gen(0)->capacity();
    23.8 -  if (HandlePromotionFailure) {
    23.9 -    expected_promotion = MIN2(
   23.10 -        (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average(),
   23.11 -        expected_promotion);
   23.12 -  }
   23.13 +  size_t expected_promotion = MIN2(gch->get_gen(0)->capacity(),
   23.14 +                                   (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average());
   23.15    if (cms_free > expected_promotion) {
   23.16      // Start a cms collection if there isn't enough space to promote
   23.17      // for the next minor collection.  Use the padded average as
   23.18 @@ -865,57 +861,18 @@
   23.19    return free() + _virtual_space.uncommitted_size();
   23.20  }
   23.21  
   23.22 -bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe(
   23.23 -    size_t max_promotion_in_bytes,
   23.24 -    bool younger_handles_promotion_failure) const {
   23.25 -
   23.26 -  // This is the most conservative test.  Full promotion is
   23.27 -  // guaranteed if this is used. The multiplicative factor is to
   23.28 -  // account for the worst case "dilatation".
   23.29 -  double adjusted_max_promo_bytes = _dilatation_factor * max_promotion_in_bytes;
   23.30 -  if (adjusted_max_promo_bytes > (double)max_uintx) { // larger than size_t
   23.31 -    adjusted_max_promo_bytes = (double)max_uintx;
   23.32 -  }
   23.33 -  bool result = (max_contiguous_available() >= (size_t)adjusted_max_promo_bytes);
   23.34 -
   23.35 -  if (younger_handles_promotion_failure && !result) {
   23.36 -    // Full promotion is not guaranteed because fragmentation
   23.37 -    // of the cms generation can prevent the full promotion.
   23.38 -    result = (max_available() >= (size_t)adjusted_max_promo_bytes);
   23.39 -
   23.40 -    if (!result) {
   23.41 -      // With promotion failure handling the test for the ability
   23.42 -      // to support the promotion does not have to be guaranteed.
   23.43 -      // Use an average of the amount promoted.
   23.44 -      result = max_available() >= (size_t)
   23.45 -        gc_stats()->avg_promoted()->padded_average();
   23.46 -      if (PrintGC && Verbose && result) {
   23.47 -        gclog_or_tty->print_cr(
   23.48 -          "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe"
   23.49 -          " max_available: " SIZE_FORMAT
   23.50 -          " avg_promoted: " SIZE_FORMAT,
   23.51 -          max_available(), (size_t)
   23.52 -          gc_stats()->avg_promoted()->padded_average());
   23.53 -      }
   23.54 -    } else {
   23.55 -      if (PrintGC && Verbose) {
   23.56 -        gclog_or_tty->print_cr(
   23.57 -          "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe"
   23.58 -          " max_available: " SIZE_FORMAT
   23.59 -          " adj_max_promo_bytes: " SIZE_FORMAT,
   23.60 -          max_available(), (size_t)adjusted_max_promo_bytes);
   23.61 -      }
   23.62 -    }
   23.63 -  } else {
   23.64 -    if (PrintGC && Verbose) {
   23.65 -      gclog_or_tty->print_cr(
   23.66 -        "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe"
   23.67 -        " contiguous_available: " SIZE_FORMAT
   23.68 -        " adj_max_promo_bytes: " SIZE_FORMAT,
   23.69 -        max_contiguous_available(), (size_t)adjusted_max_promo_bytes);
   23.70 -    }
   23.71 -  }
   23.72 -  return result;
   23.73 +bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
   23.74 +  size_t available = max_available();
   23.75 +  size_t av_promo  = (size_t)gc_stats()->avg_promoted()->padded_average();
   23.76 +  bool   res = (available >= av_promo) || (available >= max_promotion_in_bytes);
   23.77 +  if (PrintGC && Verbose) {
   23.78 +    gclog_or_tty->print_cr(
   23.79 +      "CMS: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT"),"
   23.80 +      "max_promo("SIZE_FORMAT")",
   23.81 +      res? "":" not", available, res? ">=":"<",
   23.82 +      av_promo, max_promotion_in_bytes);
   23.83 +  }
   23.84 +  return res;
   23.85  }
   23.86  
   23.87  // At a promotion failure dump information on block layout in heap
   23.88 @@ -6091,23 +6048,14 @@
   23.89    assert(_collectorState == Resizing, "Change of collector state to"
   23.90      " Resizing must be done under the freelistLocks (plural)");
   23.91  
   23.92 -  // Now that sweeping has been completed, if the GCH's
   23.93 -  // incremental_collection_will_fail flag is set, clear it,
   23.94 +  // Now that sweeping has been completed, we clear
   23.95 +  // the incremental_collection_failed flag,
   23.96    // thus inviting a younger gen collection to promote into
   23.97    // this generation. If such a promotion may still fail,
   23.98    // the flag will be set again when a young collection is
   23.99    // attempted.
  23.100 -  // I think the incremental_collection_will_fail flag's use
  23.101 -  // is specific to a 2 generation collection policy, so i'll
  23.102 -  // assert that that's the configuration we are operating within.
  23.103 -  // The use of the flag can and should be generalized appropriately
  23.104 -  // in the future to deal with a general n-generation system.
  23.105 -
  23.106    GenCollectedHeap* gch = GenCollectedHeap::heap();
  23.107 -  assert(gch->collector_policy()->is_two_generation_policy(),
  23.108 -         "Resetting of incremental_collection_will_fail flag"
  23.109 -         " may be incorrect otherwise");
  23.110 -  gch->clear_incremental_collection_will_fail();
  23.111 +  gch->clear_incremental_collection_failed();  // Worth retrying as fresh space may have been freed up
  23.112    gch->update_full_collections_completed(_collection_count_start);
  23.113  }
  23.114  

    24.1 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp	Thu Nov 04 15:19:16 2010 -0700
    24.2 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp	Thu Nov 04 16:17:54 2010 -0700
    24.3 @@ -1185,8 +1185,7 @@
    24.4    virtual void par_promote_alloc_done(int thread_num);
    24.5    virtual void par_oop_since_save_marks_iterate_done(int thread_num);
    24.6  
    24.7 -  virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes,
    24.8 -    bool younger_handles_promotion_failure) const;
    24.9 +  virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes) const;
   24.10  
   24.11    // Inform this (non-young) generation that a promotion failure was
   24.12    // encountered during a collection of a younger generation that

    25.1 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.cpp	Thu Nov 04 15:19:16 2010 -0700
    25.2 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.cpp	Thu Nov 04 16:17:54 2010 -0700
    25.3 @@ -1,5 +1,5 @@
    25.4  /*
    25.5 - * Copyright (c) 2001, 2006, Oracle and/or its affiliates. All rights reserved.
    25.6 + * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
    25.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    25.8   *
    25.9   * This code is free software; you can redistribute it and/or modify it
   25.10 @@ -272,12 +272,16 @@
   25.11    }
   25.12  }
   25.13  
   25.14 -// Wait until the next synchronous GC or a timeout, whichever is earlier.
   25.15 -void ConcurrentMarkSweepThread::wait_on_cms_lock(long t) {
   25.16 +// Wait until the next synchronous GC, a concurrent full gc request,
   25.17 +// or a timeout, whichever is earlier.
   25.18 +void ConcurrentMarkSweepThread::wait_on_cms_lock(long t_millis) {
   25.19    MutexLockerEx x(CGC_lock,
   25.20                    Mutex::_no_safepoint_check_flag);
   25.21 +  if (_should_terminate || _collector->_full_gc_requested) {
   25.22 +    return;
   25.23 +  }
   25.24    set_CMS_flag(CMS_cms_wants_token);   // to provoke notifies
   25.25 -  CGC_lock->wait(Mutex::_no_safepoint_check_flag, t);
   25.26 +  CGC_lock->wait(Mutex::_no_safepoint_check_flag, t_millis);
   25.27    clear_CMS_flag(CMS_cms_wants_token);
   25.28    assert(!CMS_flag_is_set(CMS_cms_has_token | CMS_cms_wants_token),
   25.29           "Should not be set");
   25.30 @@ -289,7 +293,8 @@
   25.31        icms_wait();
   25.32        return;
   25.33      } else {
   25.34 -      // Wait until the next synchronous GC or a timeout, whichever is earlier
   25.35 +      // Wait until the next synchronous GC, a concurrent full gc
   25.36 +      // request or a timeout, whichever is earlier.
   25.37        wait_on_cms_lock(CMSWaitDuration);
   25.38      }
   25.39      // Check if we should start a CMS collection cycle

    26.1 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp	Thu Nov 04 15:19:16 2010 -0700
    26.2 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp	Thu Nov 04 16:17:54 2010 -0700
    26.3 @@ -120,8 +120,10 @@
    26.4    }
    26.5  
    26.6    // Wait on CMS lock until the next synchronous GC
    26.7 -  // or given timeout, whichever is earlier.
    26.8 -  void    wait_on_cms_lock(long t); // milliseconds
    26.9 +  // or given timeout, whichever is earlier. A timeout value
   26.10 +  // of 0 indicates that there is no upper bound on the wait time.
   26.11 +  // A concurrent full gc request terminates the wait.
   26.12 +  void wait_on_cms_lock(long t_millis);
   26.13  
   26.14    // The CMS thread will yield during the work portion of its cycle
   26.15    // only when requested to.  Both synchronous and asychronous requests

    27.1 --- a/src/share/vm/gc_implementation/g1/concurrentMark.cpp	Thu Nov 04 15:19:16 2010 -0700
    27.2 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.cpp	Thu Nov 04 16:17:54 2010 -0700
    27.3 @@ -2418,6 +2418,8 @@
    27.4    for (int i = 0; i < (int)_max_task_num; ++i) {
    27.5      OopTaskQueue* queue = _task_queues->queue(i);
    27.6      queue->set_empty();
    27.7 +    // Clear any partial regions from the CMTasks
    27.8 +    _tasks[i]->clear_aborted_region();
    27.9    }
   27.10  }
   27.11  
   27.12 @@ -2706,7 +2708,6 @@
   27.13    clear_marking_state();
   27.14    for (int i = 0; i < (int)_max_task_num; ++i) {
   27.15      _tasks[i]->clear_region_fields();
   27.16 -    _tasks[i]->clear_aborted_region();
   27.17    }
   27.18    _has_aborted = true;
   27.19  
   27.20 @@ -2985,7 +2986,7 @@
   27.21  
   27.22    _nextMarkBitMap                = nextMarkBitMap;
   27.23    clear_region_fields();
   27.24 -  clear_aborted_region();
   27.25 +  assert(_aborted_region.is_empty(), "should have been cleared");
   27.26  
   27.27    _calls                         = 0;
   27.28    _elapsed_time_ms               = 0.0;

    28.1 --- a/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp	Thu Nov 04 15:19:16 2010 -0700
    28.2 +++ b/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp	Thu Nov 04 16:17:54 2010 -0700
    28.3 @@ -175,7 +175,7 @@
    28.4    }
    28.5    assert(start_card > _array->index_for(_bottom), "Cannot be first card");
    28.6    assert(_array->offset_array(start_card-1) <= N_words,
    28.7 -    "Offset card has an unexpected value");
    28.8 +         "Offset card has an unexpected value");
    28.9    size_t start_card_for_region = start_card;
   28.10    u_char offset = max_jubyte;
   28.11    for (int i = 0; i < BlockOffsetArray::N_powers; i++) {
   28.12 @@ -577,6 +577,16 @@
   28.13  #endif
   28.14  }
   28.15  
   28.16 +void
   28.17 +G1BlockOffsetArray::set_for_starts_humongous(HeapWord* new_end) {
   28.18 +  assert(_end ==  new_end, "_end should have already been updated");
   28.19 +
   28.20 +  // The first BOT entry should have offset 0.
   28.21 +  _array->set_offset_array(_array->index_for(_bottom), 0);
   28.22 +  // The rest should point to the first one.
   28.23 +  set_remainder_to_point_to_start(_bottom + N_words, new_end);
   28.24 +}
   28.25 +
   28.26  //////////////////////////////////////////////////////////////////////
   28.27  // G1BlockOffsetArrayContigSpace
   28.28  //////////////////////////////////////////////////////////////////////
   28.29 @@ -626,3 +636,12 @@
   28.30           "Precondition of call");
   28.31    _array->set_offset_array(bottom_index, 0);
   28.32  }
   28.33 +
   28.34 +void
   28.35 +G1BlockOffsetArrayContigSpace::set_for_starts_humongous(HeapWord* new_end) {
   28.36 +  G1BlockOffsetArray::set_for_starts_humongous(new_end);
   28.37 +
   28.38 +  // Make sure _next_offset_threshold and _next_offset_index point to new_end.
   28.39 +  _next_offset_threshold = new_end;
   28.40 +  _next_offset_index     = _array->index_for(new_end);
   28.41 +}

    29.1 --- a/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.hpp	Thu Nov 04 15:19:16 2010 -0700
    29.2 +++ b/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.hpp	Thu Nov 04 16:17:54 2010 -0700
    29.3 @@ -436,6 +436,8 @@
    29.4    }
    29.5  
    29.6    void check_all_cards(size_t left_card, size_t right_card) const;
    29.7 +
    29.8 +  virtual void set_for_starts_humongous(HeapWord* new_end);
    29.9  };
   29.10  
   29.11  // A subtype of BlockOffsetArray that takes advantage of the fact
   29.12 @@ -484,4 +486,6 @@
   29.13  
   29.14    HeapWord* block_start_unsafe(const void* addr);
   29.15    HeapWord* block_start_unsafe_const(const void* addr) const;
   29.16 +
   29.17 +  virtual void set_for_starts_humongous(HeapWord* new_end);
   29.18  };

    30.1 --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Thu Nov 04 15:19:16 2010 -0700
    30.2 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Thu Nov 04 16:17:54 2010 -0700
    30.3 @@ -791,7 +791,7 @@
    30.4    int                _worker_i;
    30.5  public:
    30.6    RebuildRSOutOfRegionClosure(G1CollectedHeap* g1, int worker_i = 0) :
    30.7 -    _cl(g1->g1_rem_set()->as_HRInto_G1RemSet(), worker_i),
    30.8 +    _cl(g1->g1_rem_set(), worker_i),
    30.9      _worker_i(worker_i),
   30.10      _g1h(g1)
   30.11    { }
   30.12 @@ -890,7 +890,7 @@
   30.13      abandon_cur_alloc_region();
   30.14      abandon_gc_alloc_regions();
   30.15      assert(_cur_alloc_region == NULL, "Invariant.");
   30.16 -    g1_rem_set()->as_HRInto_G1RemSet()->cleanupHRRS();
   30.17 +    g1_rem_set()->cleanupHRRS();
   30.18      tear_down_region_lists();
   30.19      set_used_regions_to_need_zero_fill();
   30.20  
   30.21 @@ -1506,15 +1506,11 @@
   30.22    }
   30.23  
   30.24    // Also create a G1 rem set.
   30.25 -  if (G1UseHRIntoRS) {
   30.26 -    if (mr_bs()->is_a(BarrierSet::CardTableModRef)) {
   30.27 -      _g1_rem_set = new HRInto_G1RemSet(this, (CardTableModRefBS*)mr_bs());
   30.28 -    } else {
   30.29 -      vm_exit_during_initialization("G1 requires a cardtable mod ref bs.");
   30.30 -      return JNI_ENOMEM;
   30.31 -    }
   30.32 +  if (mr_bs()->is_a(BarrierSet::CardTableModRef)) {
   30.33 +    _g1_rem_set = new G1RemSet(this, (CardTableModRefBS*)mr_bs());
   30.34    } else {
   30.35 -    _g1_rem_set = new StupidG1RemSet(this);
   30.36 +    vm_exit_during_initialization("G1 requires a cardtable mod ref bs.");
   30.37 +    return JNI_ENOMEM;
   30.38    }
   30.39  
   30.40    // Carve out the G1 part of the heap.
   30.41 @@ -2706,8 +2702,7 @@
   30.42  }
   30.43  
   30.44  size_t G1CollectedHeap::cards_scanned() {
   30.45 -  HRInto_G1RemSet* g1_rset = (HRInto_G1RemSet*) g1_rem_set();
   30.46 -  return g1_rset->cardsScanned();
   30.47 +  return g1_rem_set()->cardsScanned();
   30.48  }
   30.49  
   30.50  void
   30.51 @@ -3850,6 +3845,54 @@
   30.52                 undo_waste() * HeapWordSize / K);
   30.53  }
   30.54  
   30.55 +#ifdef ASSERT
   30.56 +bool G1ParScanThreadState::verify_ref(narrowOop* ref) const {
   30.57 +  assert(ref != NULL, "invariant");
   30.58 +  assert(UseCompressedOops, "sanity");
   30.59 +  assert(!has_partial_array_mask(ref), err_msg("ref=" PTR_FORMAT, ref));
   30.60 +  oop p = oopDesc::load_decode_heap_oop(ref);
   30.61 +  assert(_g1h->is_in_g1_reserved(p),
   30.62 +         err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p)));
   30.63 +  return true;
   30.64 +}
   30.65 +
   30.66 +bool G1ParScanThreadState::verify_ref(oop* ref) const {
   30.67 +  assert(ref != NULL, "invariant");
   30.68 +  if (has_partial_array_mask(ref)) {
   30.69 +    // Must be in the collection set--it's already been copied.
   30.70 +    oop p = clear_partial_array_mask(ref);
   30.71 +    assert(_g1h->obj_in_cs(p),
   30.72 +           err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p)));
   30.73 +  } else {
   30.74 +    oop p = oopDesc::load_decode_heap_oop(ref);
   30.75 +    assert(_g1h->is_in_g1_reserved(p),
   30.76 +           err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, ref, intptr_t(p)));
   30.77 +  }
   30.78 +  return true;
   30.79 +}
   30.80 +
   30.81 +bool G1ParScanThreadState::verify_task(StarTask ref) const {
   30.82 +  if (ref.is_narrow()) {
   30.83 +    return verify_ref((narrowOop*) ref);
   30.84 +  } else {
   30.85 +    return verify_ref((oop*) ref);
   30.86 +  }
   30.87 +}
   30.88 +#endif // ASSERT
   30.89 +
   30.90 +void G1ParScanThreadState::trim_queue() {
   30.91 +  StarTask ref;
   30.92 +  do {
   30.93 +    // Drain the overflow stack first, so other threads can steal.
   30.94 +    while (refs()->pop_overflow(ref)) {
   30.95 +      deal_with_reference(ref);
   30.96 +    }
   30.97 +    while (refs()->pop_local(ref)) {
   30.98 +      deal_with_reference(ref);
   30.99 +    }
  30.100 +  } while (!refs()->is_empty());
  30.101 +}
  30.102 +
  30.103  G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
  30.104    _g1(g1), _g1_rem(_g1->g1_rem_set()), _cm(_g1->concurrent_mark()),
  30.105    _par_scan_state(par_scan_state) { }
  30.106 @@ -4052,38 +4095,43 @@
  30.107      : _g1h(g1h), _par_scan_state(par_scan_state),
  30.108        _queues(queues), _terminator(terminator) {}
  30.109  
  30.110 -  void do_void() {
  30.111 -    G1ParScanThreadState* pss = par_scan_state();
  30.112 -    while (true) {
  30.113 +  void do_void();
  30.114 +
  30.115 +private:
  30.116 +  inline bool offer_termination();
  30.117 +};
  30.118 +
  30.119 +bool G1ParEvacuateFollowersClosure::offer_termination() {
  30.120 +  G1ParScanThreadState* const pss = par_scan_state();
  30.121 +  pss->start_term_time();
  30.122 +  const bool res = terminator()->offer_termination();
  30.123 +  pss->end_term_time();
  30.124 +  return res;
  30.125 +}
  30.126 +
  30.127 +void G1ParEvacuateFollowersClosure::do_void() {
  30.128 +  StarTask stolen_task;
  30.129 +  G1ParScanThreadState* const pss = par_scan_state();
  30.130 +  pss->trim_queue();
  30.131 +
  30.132 +  do {
  30.133 +    while (queues()->steal(pss->queue_num(), pss->hash_seed(), stolen_task)) {
  30.134 +      assert(pss->verify_task(stolen_task), "sanity");
  30.135 +      if (stolen_task.is_narrow()) {
  30.136 +        pss->deal_with_reference((narrowOop*) stolen_task);
  30.137 +      } else {
  30.138 +        pss->deal_with_reference((oop*) stolen_task);
  30.139 +      }
  30.140 +
  30.141 +      // We've just processed a reference and we might have made
  30.142 +      // available new entries on the queues. So we have to make sure
  30.143 +      // we drain the queues as necessary.
  30.144        pss->trim_queue();
  30.145 -
  30.146 -      StarTask stolen_task;
  30.147 -      if (queues()->steal(pss->queue_num(), pss->hash_seed(), stolen_task)) {
  30.148 -        // slightly paranoid tests; I'm trying to catch potential
  30.149 -        // problems before we go into push_on_queue to know where the
  30.150 -        // problem is coming from
  30.151 -        assert((oop*)stolen_task != NULL, "Error");
  30.152 -        if (stolen_task.is_narrow()) {
  30.153 -          assert(UseCompressedOops, "Error");
  30.154 -          narrowOop* p = (narrowOop*) stolen_task;
  30.155 -          assert(has_partial_array_mask(p) ||
  30.156 -                 _g1h->is_in_g1_reserved(oopDesc::load_decode_heap_oop(p)), "Error");
  30.157 -          pss->push_on_queue(p);
  30.158 -        } else {
  30.159 -          oop* p = (oop*) stolen_task;
  30.160 -          assert(has_partial_array_mask(p) || _g1h->is_in_g1_reserved(*p), "Error");
  30.161 -          pss->push_on_queue(p);
  30.162 -        }
  30.163 -        continue;
  30.164 -      }
  30.165 -      pss->start_term_time();
  30.166 -      if (terminator()->offer_termination()) break;
  30.167 -      pss->end_term_time();
  30.168      }
  30.169 -    pss->end_term_time();
  30.170 -    pss->retire_alloc_buffers();
  30.171 -  }
  30.172 -};
  30.173 +  } while (!offer_termination());
  30.174 +
  30.175 +  pss->retire_alloc_buffers();
  30.176 +}
  30.177  
  30.178  class G1ParTask : public AbstractGangTask {
  30.179  protected:
  30.180 @@ -4182,8 +4230,7 @@
  30.181        pss.print_termination_stats(i);
  30.182      }
  30.183  
  30.184 -    assert(pss.refs_to_scan() == 0, "Task queue should be empty");
  30.185 -    assert(pss.overflowed_refs_to_scan() == 0, "Overflow queue should be empty");
  30.186 +    assert(pss.refs()->is_empty(), "should be empty");
  30.187      double end_time_ms = os::elapsedTime() * 1000.0;
  30.188      _g1h->g1_policy()->record_gc_worker_end_time(i, end_time_ms);
  30.189    }

    31.1 --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp	Thu Nov 04 15:19:16 2010 -0700
    31.2 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp	Thu Nov 04 16:17:54 2010 -0700
    31.3 @@ -1651,49 +1651,17 @@
    31.4    size_t alloc_buffer_waste() const              { return _alloc_buffer_waste; }
    31.5    size_t undo_waste() const                      { return _undo_waste; }
    31.6  
    31.7 +#ifdef ASSERT
    31.8 +  bool verify_ref(narrowOop* ref) const;
    31.9 +  bool verify_ref(oop* ref) const;
   31.10 +  bool verify_task(StarTask ref) const;
   31.11 +#endif // ASSERT
   31.12 +
   31.13    template <class T> void push_on_queue(T* ref) {
   31.14 -    assert(ref != NULL, "invariant");
   31.15 -    assert(has_partial_array_mask(ref) ||
   31.16 -           _g1h->is_in_g1_reserved(oopDesc::load_decode_heap_oop(ref)), "invariant");
   31.17 -#ifdef ASSERT
   31.18 -    if (has_partial_array_mask(ref)) {
   31.19 -      oop p = clear_partial_array_mask(ref);
   31.20 -      // Verify that we point into the CS
   31.21 -      assert(_g1h->obj_in_cs(p), "Should be in CS");
   31.22 -    }
   31.23 -#endif
   31.24 +    assert(verify_ref(ref), "sanity");
   31.25      refs()->push(ref);
   31.26    }
   31.27  
   31.28 -  void pop_from_queue(StarTask& ref) {
   31.29 -    if (refs()->pop_local(ref)) {
   31.30 -      assert((oop*)ref != NULL, "pop_local() returned true");
   31.31 -      assert(UseCompressedOops || !ref.is_narrow(), "Error");
   31.32 -      assert(has_partial_array_mask((oop*)ref) ||
   31.33 -             _g1h->is_in_g1_reserved(ref.is_narrow() ? oopDesc::load_decode_heap_oop((narrowOop*)ref)
   31.34 -                                                     : oopDesc::load_decode_heap_oop((oop*)ref)),
   31.35 -              "invariant");
   31.36 -    } else {
   31.37 -      StarTask null_task;
   31.38 -      ref = null_task;
   31.39 -    }
   31.40 -  }
   31.41 -
   31.42 -  void pop_from_overflow_queue(StarTask& ref) {
   31.43 -    StarTask new_ref;
   31.44 -    refs()->pop_overflow(new_ref);
   31.45 -    assert((oop*)new_ref != NULL, "pop() from a local non-empty stack");
   31.46 -    assert(UseCompressedOops || !new_ref.is_narrow(), "Error");
   31.47 -    assert(has_partial_array_mask((oop*)new_ref) ||
   31.48 -           _g1h->is_in_g1_reserved(new_ref.is_narrow() ? oopDesc::load_decode_heap_oop((narrowOop*)new_ref)
   31.49 -                                                       : oopDesc::load_decode_heap_oop((oop*)new_ref)),
   31.50 -           "invariant");
   31.51 -    ref = new_ref;
   31.52 -  }
   31.53 -
   31.54 -  int refs_to_scan()            { return (int)refs()->size(); }
   31.55 -  int overflowed_refs_to_scan() { return (int)refs()->overflow_stack()->size(); }
   31.56 -
   31.57    template <class T> void update_rs(HeapRegion* from, T* p, int tid) {
   31.58      if (G1DeferredRSUpdate) {
   31.59        deferred_rs_update(from, p, tid);
   31.60 @@ -1804,7 +1772,6 @@
   31.61      }
   31.62    }
   31.63  
   31.64 -private:
   31.65    template <class T> void deal_with_reference(T* ref_to_scan) {
   31.66      if (has_partial_array_mask(ref_to_scan)) {
   31.67        _partial_scan_cl->do_oop_nv(ref_to_scan);
   31.68 @@ -1818,59 +1785,15 @@
   31.69      }
   31.70    }
   31.71  
   31.72 -public:
   31.73 -  void trim_queue() {
   31.74 -    // I've replicated the loop twice, first to drain the overflow
   31.75 -    // queue, second to drain the task queue. This is better than
   31.76 -    // having a single loop, which checks both conditions and, inside
   31.77 -    // it, either pops the overflow queue or the task queue, as each
   31.78 -    // loop is tighter. Also, the decision to drain the overflow queue
   31.79 -    // first is not arbitrary, as the overflow queue is not visible
   31.80 -    // to the other workers, whereas the task queue is. So, we want to
   31.81 -    // drain the "invisible" entries first, while allowing the other
   31.82 -    // workers to potentially steal the "visible" entries.
   31.83 -
   31.84 -    while (refs_to_scan() > 0 || overflowed_refs_to_scan() > 0) {
   31.85 -      while (overflowed_refs_to_scan() > 0) {
   31.86 -        StarTask ref_to_scan;
   31.87 -        assert((oop*)ref_to_scan == NULL, "Constructed above");
   31.88 -        pop_from_overflow_queue(ref_to_scan);
   31.89 -        // We shouldn't have pushed it on the queue if it was not
   31.90 -        // pointing into the CSet.
   31.91 -        assert((oop*)ref_to_scan != NULL, "Follows from inner loop invariant");
   31.92 -        if (ref_to_scan.is_narrow()) {
   31.93 -          assert(UseCompressedOops, "Error");
   31.94 -          narrowOop* p = (narrowOop*)ref_to_scan;
   31.95 -          assert(!has_partial_array_mask(p) &&
   31.96 -                 _g1h->is_in_g1_reserved(oopDesc::load_decode_heap_oop(p)), "sanity");
   31.97 -          deal_with_reference(p);
   31.98 -        } else {
   31.99 -          oop* p = (oop*)ref_to_scan;
  31.100 -          assert((has_partial_array_mask(p) && _g1h->is_in_g1_reserved(clear_partial_array_mask(p))) ||
  31.101 -                 _g1h->is_in_g1_reserved(oopDesc::load_decode_heap_oop(p)), "sanity");
  31.102 -          deal_with_reference(p);
  31.103 -        }
  31.104 -      }
  31.105 -
  31.106 -      while (refs_to_scan() > 0) {
  31.107 -        StarTask ref_to_scan;
  31.108 -        assert((oop*)ref_to_scan == NULL, "Constructed above");
  31.109 -        pop_from_queue(ref_to_scan);
  31.110 -        if ((oop*)ref_to_scan != NULL) {
  31.111 -          if (ref_to_scan.is_narrow()) {
  31.112 -            assert(UseCompressedOops, "Error");
  31.113 -            narrowOop* p = (narrowOop*)ref_to_scan;
  31.114 -            assert(!has_partial_array_mask(p) &&
  31.115 -                    _g1h->is_in_g1_reserved(oopDesc::load_decode_heap_oop(p)), "sanity");
  31.116 -            deal_with_reference(p);
  31.117 -          } else {
  31.118 -            oop* p = (oop*)ref_to_scan;
  31.119 -            assert((has_partial_array_mask(p) && _g1h->obj_in_cs(clear_partial_array_mask(p))) ||
  31.120 -                   _g1h->is_in_g1_reserved(oopDesc::load_decode_heap_oop(p)), "sanity");
  31.121 -            deal_with_reference(p);
  31.122 -          }
  31.123 -        }
  31.124 -      }
  31.125 +  void deal_with_reference(StarTask ref) {
  31.126 +    assert(verify_task(ref), "sanity");
  31.127 +    if (ref.is_narrow()) {
  31.128 +      deal_with_reference((narrowOop*)ref);
  31.129 +    } else {
  31.130 +      deal_with_reference((oop*)ref);
  31.131      }
  31.132    }
  31.133 +
  31.134 +public:
  31.135 +  void trim_queue();
  31.136  };

    32.1 --- a/src/share/vm/gc_implementation/g1/g1OopClosures.hpp	Thu Nov 04 15:19:16 2010 -0700
    32.2 +++ b/src/share/vm/gc_implementation/g1/g1OopClosures.hpp	Thu Nov 04 16:17:54 2010 -0700
    32.3 @@ -25,8 +25,6 @@
    32.4  class HeapRegion;
    32.5  class G1CollectedHeap;
    32.6  class G1RemSet;
    32.7 -class HRInto_G1RemSet;
    32.8 -class G1RemSet;
    32.9  class ConcurrentMark;
   32.10  class DirtyCardToOopClosure;
   32.11  class CMBitMap;

    33.1 --- a/src/share/vm/gc_implementation/g1/g1RemSet.cpp	Thu Nov 04 15:19:16 2010 -0700
    33.2 +++ b/src/share/vm/gc_implementation/g1/g1RemSet.cpp	Thu Nov 04 16:17:54 2010 -0700
    33.3 @@ -97,13 +97,6 @@
    33.4    }
    33.5  };
    33.6  
    33.7 -void
    33.8 -StupidG1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc,
    33.9 -                                            int worker_i) {
   33.10 -  IntoCSRegionClosure rc(_g1, oc);
   33.11 -  _g1->heap_region_iterate(&rc);
   33.12 -}
   33.13 -
   33.14  class VerifyRSCleanCardOopClosure: public OopClosure {
   33.15    G1CollectedHeap* _g1;
   33.16  public:
   33.17 @@ -119,8 +112,9 @@
   33.18    }
   33.19  };
   33.20  
   33.21 -HRInto_G1RemSet::HRInto_G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs)
   33.22 -  : G1RemSet(g1), _ct_bs(ct_bs), _g1p(_g1->g1_policy()),
   33.23 +G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs)
   33.24 +  : _g1(g1), _conc_refine_cards(0),
   33.25 +    _ct_bs(ct_bs), _g1p(_g1->g1_policy()),
   33.26      _cg1r(g1->concurrent_g1_refine()),
   33.27      _traversal_in_progress(false),
   33.28      _cset_rs_update_cl(NULL),
   33.29 @@ -134,7 +128,7 @@
   33.30    }
   33.31  }
   33.32  
   33.33 -HRInto_G1RemSet::~HRInto_G1RemSet() {
   33.34 +G1RemSet::~G1RemSet() {
   33.35    delete _seq_task;
   33.36    for (uint i = 0; i < n_workers(); i++) {
   33.37      assert(_cset_rs_update_cl[i] == NULL, "it should be");
   33.38 @@ -277,7 +271,7 @@
   33.39  //          p threads
   33.40  // Then thread t will start at region t * floor (n/p)
   33.41  
   33.42 -HeapRegion* HRInto_G1RemSet::calculateStartRegion(int worker_i) {
   33.43 +HeapRegion* G1RemSet::calculateStartRegion(int worker_i) {
   33.44    HeapRegion* result = _g1p->collection_set();
   33.45    if (ParallelGCThreads > 0) {
   33.46      size_t cs_size = _g1p->collection_set_size();
   33.47 @@ -290,7 +284,7 @@
   33.48    return result;
   33.49  }
   33.50  
   33.51 -void HRInto_G1RemSet::scanRS(OopsInHeapRegionClosure* oc, int worker_i) {
   33.52 +void G1RemSet::scanRS(OopsInHeapRegionClosure* oc, int worker_i) {
   33.53    double rs_time_start = os::elapsedTime();
   33.54    HeapRegion *startRegion = calculateStartRegion(worker_i);
   33.55  
   33.56 @@ -340,7 +334,7 @@
   33.57    }
   33.58  };
   33.59  
   33.60 -void HRInto_G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, int worker_i) {
   33.61 +void G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, int worker_i) {
   33.62    double start = os::elapsedTime();
   33.63    // Apply the given closure to all remaining log entries.
   33.64    RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq);
   33.65 @@ -439,12 +433,11 @@
   33.66    }
   33.67  };
   33.68  
   33.69 -void HRInto_G1RemSet::cleanupHRRS() {
   33.70 +void G1RemSet::cleanupHRRS() {
   33.71    HeapRegionRemSet::cleanup();
   33.72  }
   33.73  
   33.74 -void
   33.75 -HRInto_G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc,
   33.76 +void G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc,
   33.77                                               int worker_i) {
   33.78  #if CARD_REPEAT_HISTO
   33.79    ct_freq_update_histo_and_reset();
   33.80 @@ -508,8 +501,7 @@
   33.81    _cset_rs_update_cl[worker_i] = NULL;
   33.82  }
   33.83  
   33.84 -void HRInto_G1RemSet::
   33.85 -prepare_for_oops_into_collection_set_do() {
   33.86 +void G1RemSet::prepare_for_oops_into_collection_set_do() {
   33.87  #if G1_REM_SET_LOGGING
   33.88    PrintRSClosure cl;
   33.89    _g1->collection_set_iterate(&cl);
   33.90 @@ -581,7 +573,7 @@
   33.91      //   RSet updating,
   33.92      // * the post-write barrier shouldn't be logging updates to young
   33.93      //   regions (but there is a situation where this can happen - see
   33.94 -    //   the comment in HRInto_G1RemSet::concurrentRefineOneCard below -
   33.95 +    //   the comment in G1RemSet::concurrentRefineOneCard below -
   33.96      //   that should not be applicable here), and
   33.97      // * during actual RSet updating, the filtering of cards in young
   33.98      //   regions in HeapRegion::oops_on_card_seq_iterate_careful is
   33.99 @@ -601,7 +593,7 @@
  33.100    }
  33.101  };
  33.102  
  33.103 -void HRInto_G1RemSet::cleanup_after_oops_into_collection_set_do() {
  33.104 +void G1RemSet::cleanup_after_oops_into_collection_set_do() {
  33.105    guarantee( _cards_scanned != NULL, "invariant" );
  33.106    _total_cards_scanned = 0;
  33.107    for (uint i = 0; i < n_workers(); ++i)
  33.108 @@ -692,12 +684,12 @@
  33.109    }
  33.110  };
  33.111  
  33.112 -void HRInto_G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) {
  33.113 +void G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) {
  33.114    ScrubRSClosure scrub_cl(region_bm, card_bm);
  33.115    _g1->heap_region_iterate(&scrub_cl);
  33.116  }
  33.117  
  33.118 -void HRInto_G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm,
  33.119 +void G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm,
  33.120                                  int worker_num, int claim_val) {
  33.121    ScrubRSClosure scrub_cl(region_bm, card_bm);
  33.122    _g1->heap_region_par_iterate_chunked(&scrub_cl, worker_num, claim_val);
  33.123 @@ -741,7 +733,7 @@
  33.124    virtual void do_oop(narrowOop* p)  { do_oop_nv(p); }
  33.125  };
  33.126  
  33.127 -bool HRInto_G1RemSet::concurrentRefineOneCard_impl(jbyte* card_ptr, int worker_i,
  33.128 +bool G1RemSet::concurrentRefineOneCard_impl(jbyte* card_ptr, int worker_i,
  33.129                                                     bool check_for_refs_into_cset) {
  33.130    // Construct the region representing the card.
  33.131    HeapWord* start = _ct_bs->addr_for(card_ptr);
  33.132 @@ -820,7 +812,7 @@
  33.133    return trigger_cl.value();
  33.134  }
  33.135  
  33.136 -bool HRInto_G1RemSet::concurrentRefineOneCard(jbyte* card_ptr, int worker_i,
  33.137 +bool G1RemSet::concurrentRefineOneCard(jbyte* card_ptr, int worker_i,
  33.138                                                bool check_for_refs_into_cset) {
  33.139    // If the card is no longer dirty, nothing to do.
  33.140    if (*card_ptr != CardTableModRefBS::dirty_card_val()) {
  33.141 @@ -995,7 +987,7 @@
  33.142    }
  33.143  };
  33.144  
  33.145 -void HRInto_G1RemSet::print_summary_info() {
  33.146 +void G1RemSet::print_summary_info() {
  33.147    G1CollectedHeap* g1 = G1CollectedHeap::heap();
  33.148  
  33.149  #if CARD_REPEAT_HISTO
  33.150 @@ -1029,30 +1021,26 @@
  33.151    g1->concurrent_g1_refine()->threads_do(&p);
  33.152    gclog_or_tty->print_cr("");
  33.153  
  33.154 -  if (G1UseHRIntoRS) {
  33.155 -    HRRSStatsIter blk;
  33.156 -    g1->heap_region_iterate(&blk);
  33.157 -    gclog_or_tty->print_cr("  Total heap region rem set sizes = " SIZE_FORMAT "K."
  33.158 -                           "  Max = " SIZE_FORMAT "K.",
  33.159 -                           blk.total_mem_sz()/K, blk.max_mem_sz()/K);
  33.160 -    gclog_or_tty->print_cr("  Static structures = " SIZE_FORMAT "K,"
  33.161 -                           " free_lists = " SIZE_FORMAT "K.",
  33.162 -                           HeapRegionRemSet::static_mem_size()/K,
  33.163 -                           HeapRegionRemSet::fl_mem_size()/K);
  33.164 -    gclog_or_tty->print_cr("    %d occupied cards represented.",
  33.165 -                           blk.occupied());
  33.166 -    gclog_or_tty->print_cr("    Max sz region = [" PTR_FORMAT ", " PTR_FORMAT " )"
  33.167 -                           ", cap = " SIZE_FORMAT "K, occ = " SIZE_FORMAT "K.",
  33.168 -                           blk.max_mem_sz_region()->bottom(), blk.max_mem_sz_region()->end(),
  33.169 -                           (blk.max_mem_sz_region()->rem_set()->mem_size() + K - 1)/K,
  33.170 -                           (blk.max_mem_sz_region()->rem_set()->occupied() + K - 1)/K);
  33.171 -    gclog_or_tty->print_cr("    Did %d coarsenings.",
  33.172 -                  HeapRegionRemSet::n_coarsenings());
  33.173 -
  33.174 -  }
  33.175 +  HRRSStatsIter blk;
  33.176 +  g1->heap_region_iterate(&blk);
  33.177 +  gclog_or_tty->print_cr("  Total heap region rem set sizes = " SIZE_FORMAT "K."
  33.178 +                         "  Max = " SIZE_FORMAT "K.",
  33.179 +                         blk.total_mem_sz()/K, blk.max_mem_sz()/K);
  33.180 +  gclog_or_tty->print_cr("  Static structures = " SIZE_FORMAT "K,"
  33.181 +                         " free_lists = " SIZE_FORMAT "K.",
  33.182 +                         HeapRegionRemSet::static_mem_size()/K,
  33.183 +                         HeapRegionRemSet::fl_mem_size()/K);
  33.184 +  gclog_or_tty->print_cr("    %d occupied cards represented.",
  33.185 +                         blk.occupied());
  33.186 +  gclog_or_tty->print_cr("    Max sz region = [" PTR_FORMAT ", " PTR_FORMAT " )"
  33.187 +                         ", cap = " SIZE_FORMAT "K, occ = " SIZE_FORMAT "K.",
  33.188 +                         blk.max_mem_sz_region()->bottom(), blk.max_mem_sz_region()->end(),
  33.189 +                         (blk.max_mem_sz_region()->rem_set()->mem_size() + K - 1)/K,
  33.190 +                         (blk.max_mem_sz_region()->rem_set()->occupied() + K - 1)/K);
  33.191 +  gclog_or_tty->print_cr("    Did %d coarsenings.", HeapRegionRemSet::n_coarsenings());
  33.192  }
  33.193  
  33.194 -void HRInto_G1RemSet::prepare_for_verify() {
  33.195 +void G1RemSet::prepare_for_verify() {
  33.196    if (G1HRRSFlushLogBuffersOnVerify &&
  33.197        (VerifyBeforeGC || VerifyAfterGC)
  33.198        &&  !_g1->full_collection()) {

    34.1 --- a/src/share/vm/gc_implementation/g1/g1RemSet.hpp	Thu Nov 04 15:19:16 2010 -0700
    34.2 +++ b/src/share/vm/gc_implementation/g1/g1RemSet.hpp	Thu Nov 04 16:17:54 2010 -0700
    34.3 @@ -27,107 +27,18 @@
    34.4  
    34.5  class G1CollectedHeap;
    34.6  class CardTableModRefBarrierSet;
    34.7 -class HRInto_G1RemSet;
    34.8  class ConcurrentG1Refine;
    34.9  
   34.10 +// A G1RemSet in which each heap region has a rem set that records the
   34.11 +// external heap references into it.  Uses a mod ref bs to track updates,
   34.12 +// so that they can be used to update the individual region remsets.
   34.13 +
   34.14  class G1RemSet: public CHeapObj {
   34.15  protected:
   34.16    G1CollectedHeap* _g1;
   34.17    unsigned _conc_refine_cards;
   34.18    size_t n_workers();
   34.19  
   34.20 -public:
   34.21 -  G1RemSet(G1CollectedHeap* g1) :
   34.22 -    _g1(g1), _conc_refine_cards(0)
   34.23 -  {}
   34.24 -
   34.25 -  // Invoke "blk->do_oop" on all pointers into the CS in object in regions
   34.26 -  // outside the CS (having invoked "blk->set_region" to set the "from"
   34.27 -  // region correctly beforehand.) The "worker_i" param is for the
   34.28 -  // parallel case where the number of the worker thread calling this
   34.29 -  // function can be helpful in partitioning the work to be done. It
   34.30 -  // should be the same as the "i" passed to the calling thread's
   34.31 -  // work(i) function. In the sequential case this param will be ingored.
   34.32 -  virtual void oops_into_collection_set_do(OopsInHeapRegionClosure* blk,
   34.33 -                                           int worker_i) = 0;
   34.34 -
   34.35 -  // Prepare for and cleanup after an oops_into_collection_set_do
   34.36 -  // call.  Must call each of these once before and after (in sequential
   34.37 -  // code) any threads call oops into collection set do.  (This offers an
   34.38 -  // opportunity to sequential setup and teardown of structures needed by a
   34.39 -  // parallel iteration over the CS's RS.)
   34.40 -  virtual void prepare_for_oops_into_collection_set_do() = 0;
   34.41 -  virtual void cleanup_after_oops_into_collection_set_do() = 0;
   34.42 -
   34.43 -  // If "this" is of the given subtype, return "this", else "NULL".
   34.44 -  virtual HRInto_G1RemSet* as_HRInto_G1RemSet() { return NULL; }
   34.45 -
   34.46 -  // Record, if necessary, the fact that *p (where "p" is in region "from",
   34.47 -  // and is, a fortiori, required to be non-NULL) has changed to its new value.
   34.48 -  virtual void write_ref(HeapRegion* from, oop* p) = 0;
   34.49 -  virtual void write_ref(HeapRegion* from, narrowOop* p) = 0;
   34.50 -  virtual void par_write_ref(HeapRegion* from, oop* p, int tid) = 0;
   34.51 -  virtual void par_write_ref(HeapRegion* from, narrowOop* p, int tid) = 0;
   34.52 -
   34.53 -  // Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
   34.54 -  // or card, respectively, such that a region or card with a corresponding
   34.55 -  // 0 bit contains no part of any live object.  Eliminates any remembered
   34.56 -  // set entries that correspond to dead heap ranges.
   34.57 -  virtual void scrub(BitMap* region_bm, BitMap* card_bm) = 0;
   34.58 -  // Like the above, but assumes is called in parallel: "worker_num" is the
   34.59 -  // parallel thread id of the current thread, and "claim_val" is the
   34.60 -  // value that should be used to claim heap regions.
   34.61 -  virtual void scrub_par(BitMap* region_bm, BitMap* card_bm,
   34.62 -                         int worker_num, int claim_val) = 0;
   34.63 -
   34.64 -  // Refine the card corresponding to "card_ptr".  If "sts" is non-NULL,
   34.65 -  // join and leave around parts that must be atomic wrt GC.  (NULL means
   34.66 -  // being done at a safepoint.)
   34.67 -  // With some implementations of this routine, when check_for_refs_into_cset
   34.68 -  // is true, a true result may be returned if the given card contains oops
   34.69 -  // that have references into the current collection set.
   34.70 -  virtual bool concurrentRefineOneCard(jbyte* card_ptr, int worker_i,
   34.71 -                                       bool check_for_refs_into_cset) {
   34.72 -    return false;
   34.73 -  }
   34.74 -
   34.75 -  // Print any relevant summary info.
   34.76 -  virtual void print_summary_info() {}
   34.77 -
   34.78 -  // Prepare remebered set for verification.
   34.79 -  virtual void prepare_for_verify() {};
   34.80 -};
   34.81 -
   34.82 -
   34.83 -// The simplest possible G1RemSet: iterates over all objects in non-CS
   34.84 -// regions, searching for pointers into the CS.
   34.85 -class StupidG1RemSet: public G1RemSet {
   34.86 -public:
   34.87 -  StupidG1RemSet(G1CollectedHeap* g1) : G1RemSet(g1) {}
   34.88 -
   34.89 -  void oops_into_collection_set_do(OopsInHeapRegionClosure* blk,
   34.90 -                                   int worker_i);
   34.91 -
   34.92 -  void prepare_for_oops_into_collection_set_do() {}
   34.93 -  void cleanup_after_oops_into_collection_set_do() {}
   34.94 -
   34.95 -  // Nothing is necessary in the version below.
   34.96 -  void write_ref(HeapRegion* from, oop* p) {}
   34.97 -  void write_ref(HeapRegion* from, narrowOop* p) {}
   34.98 -  void par_write_ref(HeapRegion* from, oop* p, int tid) {}
   34.99 -  void par_write_ref(HeapRegion* from, narrowOop* p, int tid) {}
  34.100 -
  34.101 -  void scrub(BitMap* region_bm, BitMap* card_bm) {}
  34.102 -  void scrub_par(BitMap* region_bm, BitMap* card_bm,
  34.103 -                 int worker_num, int claim_val) {}
  34.104 -
  34.105 -};
  34.106 -
  34.107 -// A G1RemSet in which each heap region has a rem set that records the
  34.108 -// external heap references into it.  Uses a mod ref bs to track updates,
  34.109 -// so that they can be used to update the individual region remsets.
  34.110 -
  34.111 -class HRInto_G1RemSet: public G1RemSet {
  34.112  protected:
  34.113    enum SomePrivateConstants {
  34.114      UpdateRStoMergeSync  = 0,
  34.115 @@ -175,28 +86,32 @@
  34.116    // scanned.
  34.117    void cleanupHRRS();
  34.118  
  34.119 -  HRInto_G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs);
  34.120 -  ~HRInto_G1RemSet();
  34.121 +  G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs);
  34.122 +  ~G1RemSet();
  34.123  
  34.124 +  // Invoke "blk->do_oop" on all pointers into the CS in objects in regions
  34.125 +  // outside the CS (having invoked "blk->set_region" to set the "from"
  34.126 +  // region correctly beforehand.) The "worker_i" param is for the
  34.127 +  // parallel case where the number of the worker thread calling this
  34.128 +  // function can be helpful in partitioning the work to be done. It
  34.129 +  // should be the same as the "i" passed to the calling thread's
  34.130 +  // work(i) function. In the sequential case this param will be ingored.
  34.131    void oops_into_collection_set_do(OopsInHeapRegionClosure* blk,
  34.132                                     int worker_i);
  34.133  
  34.134 +  // Prepare for and cleanup after an oops_into_collection_set_do
  34.135 +  // call.  Must call each of these once before and after (in sequential
  34.136 +  // code) any threads call oops_into_collection_set_do.  (This offers an
  34.137 +  // opportunity to sequential setup and teardown of structures needed by a
  34.138 +  // parallel iteration over the CS's RS.)
  34.139    void prepare_for_oops_into_collection_set_do();
  34.140    void cleanup_after_oops_into_collection_set_do();
  34.141 +
  34.142    void scanRS(OopsInHeapRegionClosure* oc, int worker_i);
  34.143 -  template <class T> void scanNewRefsRS_work(OopsInHeapRegionClosure* oc, int worker_i);
  34.144 -  void scanNewRefsRS(OopsInHeapRegionClosure* oc, int worker_i) {
  34.145 -    if (UseCompressedOops) {
  34.146 -      scanNewRefsRS_work<narrowOop>(oc, worker_i);
  34.147 -    } else {
  34.148 -      scanNewRefsRS_work<oop>(oc, worker_i);
  34.149 -    }
  34.150 -  }
  34.151    void updateRS(DirtyCardQueue* into_cset_dcq, int worker_i);
  34.152 +
  34.153    HeapRegion* calculateStartRegion(int i);
  34.154  
  34.155 -  HRInto_G1RemSet* as_HRInto_G1RemSet() { return this; }
  34.156 -
  34.157    CardTableModRefBS* ct_bs() { return _ct_bs; }
  34.158    size_t cardsScanned() { return _total_cards_scanned; }
  34.159  
  34.160 @@ -219,17 +134,31 @@
  34.161  
  34.162    bool self_forwarded(oop obj);
  34.163  
  34.164 +  // Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
  34.165 +  // or card, respectively, such that a region or card with a corresponding
  34.166 +  // 0 bit contains no part of any live object.  Eliminates any remembered
  34.167 +  // set entries that correspond to dead heap ranges.
  34.168    void scrub(BitMap* region_bm, BitMap* card_bm);
  34.169 +
  34.170 +  // Like the above, but assumes is called in parallel: "worker_num" is the
  34.171 +  // parallel thread id of the current thread, and "claim_val" is the
  34.172 +  // value that should be used to claim heap regions.
  34.173    void scrub_par(BitMap* region_bm, BitMap* card_bm,
  34.174                   int worker_num, int claim_val);
  34.175  
  34.176 -  // If check_for_refs_into_cset is true then a true result is returned
  34.177 -  // if the card contains oops that have references into the current
  34.178 -  // collection set.
  34.179 +  // Refine the card corresponding to "card_ptr".  If "sts" is non-NULL,
  34.180 +  // join and leave around parts that must be atomic wrt GC.  (NULL means
  34.181 +  // being done at a safepoint.)
  34.182 +  // If check_for_refs_into_cset is true, a true result is returned
  34.183 +  // if the given card contains oops that have references into the
  34.184 +  // current collection set.
  34.185    virtual bool concurrentRefineOneCard(jbyte* card_ptr, int worker_i,
  34.186                                         bool check_for_refs_into_cset);
  34.187  
  34.188 +  // Print any relevant summary info.
  34.189    virtual void print_summary_info();
  34.190 +
  34.191 +  // Prepare remembered set for verification.
  34.192    virtual void prepare_for_verify();
  34.193  };
  34.194  
  34.195 @@ -250,13 +179,13 @@
  34.196  
  34.197  class UpdateRSOopClosure: public OopClosure {
  34.198    HeapRegion* _from;
  34.199 -  HRInto_G1RemSet* _rs;
  34.200 +  G1RemSet* _rs;
  34.201    int _worker_i;
  34.202  
  34.203    template <class T> void do_oop_work(T* p);
  34.204  
  34.205  public:
  34.206 -  UpdateRSOopClosure(HRInto_G1RemSet* rs, int worker_i = 0) :
  34.207 +  UpdateRSOopClosure(G1RemSet* rs, int worker_i = 0) :
  34.208      _from(NULL), _rs(rs), _worker_i(worker_i) {
  34.209      guarantee(_rs != NULL, "Requires an HRIntoG1RemSet");
  34.210    }

    35.1 --- a/src/share/vm/gc_implementation/g1/g1RemSet.inline.hpp	Thu Nov 04 15:19:16 2010 -0700
    35.2 +++ b/src/share/vm/gc_implementation/g1/g1RemSet.inline.hpp	Thu Nov 04 16:17:54 2010 -0700
    35.3 @@ -30,16 +30,18 @@
    35.4    }
    35.5  }
    35.6  
    35.7 -template <class T> inline void HRInto_G1RemSet::write_ref_nv(HeapRegion* from, T* p) {
    35.8 +template <class T>
    35.9 +inline void G1RemSet::write_ref_nv(HeapRegion* from, T* p) {
   35.10    par_write_ref_nv(from, p, 0);
   35.11  }
   35.12  
   35.13 -inline bool HRInto_G1RemSet::self_forwarded(oop obj) {
   35.14 +inline bool G1RemSet::self_forwarded(oop obj) {
   35.15    bool result =  (obj->is_forwarded() && (obj->forwardee()== obj));
   35.16    return result;
   35.17  }
   35.18  
   35.19 -template <class T> inline void HRInto_G1RemSet::par_write_ref_nv(HeapRegion* from, T* p, int tid) {
   35.20 +template <class T>
   35.21 +inline void G1RemSet::par_write_ref_nv(HeapRegion* from, T* p, int tid) {
   35.22    oop obj = oopDesc::load_decode_heap_oop(p);
   35.23  #ifdef ASSERT
   35.24    // can't do because of races
   35.25 @@ -77,7 +79,7 @@
   35.26        // Deferred updates to the CSet are either discarded (in the normal case),
   35.27        // or processed (if an evacuation failure occurs) at the end
   35.28        // of the collection.
   35.29 -      // See HRInto_G1RemSet::cleanup_after_oops_into_collection_set_do().
   35.30 +      // See G1RemSet::cleanup_after_oops_into_collection_set_do().
   35.31      } else {
   35.32  #if G1_REM_SET_LOGGING
   35.33        gclog_or_tty->print_cr("Adding " PTR_FORMAT " (" PTR_FORMAT ") to RS"
   35.34 @@ -91,12 +93,14 @@
   35.35    }
   35.36  }
   35.37  
   35.38 -template <class T> inline void UpdateRSOopClosure::do_oop_work(T* p) {
   35.39 +template <class T>
   35.40 +inline void UpdateRSOopClosure::do_oop_work(T* p) {
   35.41    assert(_from != NULL, "from region must be non-NULL");
   35.42    _rs->par_write_ref(_from, p, _worker_i);
   35.43  }
   35.44  
   35.45 -template <class T> inline void UpdateRSetImmediate::do_oop_work(T* p) {
   35.46 +template <class T>
   35.47 +inline void UpdateRSetImmediate::do_oop_work(T* p) {
   35.48    assert(_from->is_in_reserved(p), "paranoia");
   35.49    T heap_oop = oopDesc::load_heap_oop(p);
   35.50    if (!oopDesc::is_null(heap_oop) && !_from->is_survivor()) {

    36.1 --- a/src/share/vm/gc_implementation/g1/g1_globals.hpp	Thu Nov 04 15:19:16 2010 -0700
    36.2 +++ b/src/share/vm/gc_implementation/g1/g1_globals.hpp	Thu Nov 04 16:17:54 2010 -0700
    36.3 @@ -40,9 +40,6 @@
    36.4    develop(intx, G1PolicyVerbose, 0,                                         \
    36.5            "The verbosity level on G1 policy decisions")                     \
    36.6                                                                              \
    36.7 -  develop(bool, G1UseHRIntoRS, true,                                        \
    36.8 -          "Determines whether the 'advanced' HR Into rem set is used.")     \
    36.9 -                                                                            \
   36.10    develop(intx, G1MarkingVerboseLevel, 0,                                   \
   36.11            "Level (0-4) of verboseness of the marking code")                 \
   36.12                                                                              \

    37.1 --- a/src/share/vm/gc_implementation/g1/heapRegion.cpp	Thu Nov 04 15:19:16 2010 -0700
    37.2 +++ b/src/share/vm/gc_implementation/g1/heapRegion.cpp	Thu Nov 04 16:17:54 2010 -0700
    37.3 @@ -377,10 +377,26 @@
    37.4  }
    37.5  // </PREDICTION>
    37.6  
    37.7 -void HeapRegion::set_startsHumongous() {
    37.8 +void HeapRegion::set_startsHumongous(HeapWord* new_end) {
    37.9 +  assert(end() == _orig_end,
   37.10 +         "Should be normal before the humongous object allocation");
   37.11 +  assert(top() == bottom(), "should be empty");
   37.12 +
   37.13    _humongous_type = StartsHumongous;
   37.14    _humongous_start_region = this;
   37.15 -  assert(end() == _orig_end, "Should be normal before alloc.");
   37.16 +
   37.17 +  set_end(new_end);
   37.18 +  _offsets.set_for_starts_humongous(new_end);
   37.19 +}
   37.20 +
   37.21 +void HeapRegion::set_continuesHumongous(HeapRegion* start) {
   37.22 +  assert(end() == _orig_end,
   37.23 +         "Should be normal before the humongous object allocation");
   37.24 +  assert(top() == bottom(), "should be empty");
   37.25 +  assert(start->startsHumongous(), "pre-condition");
   37.26 +
   37.27 +  _humongous_type = ContinuesHumongous;
   37.28 +  _humongous_start_region = start;
   37.29  }
   37.30  
   37.31  bool HeapRegion::claimHeapRegion(jint claimValue) {
   37.32 @@ -500,23 +516,6 @@
   37.33    return blk.result();
   37.34  }
   37.35  
   37.36 -void HeapRegion::set_continuesHumongous(HeapRegion* start) {
   37.37 -  // The order is important here.
   37.38 -  start->add_continuingHumongousRegion(this);
   37.39 -  _humongous_type = ContinuesHumongous;
   37.40 -  _humongous_start_region = start;
   37.41 -}
   37.42 -
   37.43 -void HeapRegion::add_continuingHumongousRegion(HeapRegion* cont) {
   37.44 -  // Must join the blocks of the current H region seq with the block of the
   37.45 -  // added region.
   37.46 -  offsets()->join_blocks(bottom(), cont->bottom());
   37.47 -  arrayOop obj = (arrayOop)(bottom());
   37.48 -  obj->set_length((int) (obj->length() + cont->capacity()/jintSize));
   37.49 -  set_end(cont->end());
   37.50 -  set_top(cont->end());
   37.51 -}
   37.52 -
   37.53  void HeapRegion::save_marks() {
   37.54    set_saved_mark();
   37.55  }

    38.1 --- a/src/share/vm/gc_implementation/g1/heapRegion.hpp	Thu Nov 04 15:19:16 2010 -0700
    38.2 +++ b/src/share/vm/gc_implementation/g1/heapRegion.hpp	Thu Nov 04 16:17:54 2010 -0700
    38.3 @@ -395,14 +395,12 @@
    38.4  
    38.5    // Causes the current region to represent a humongous object spanning "n"
    38.6    // regions.
    38.7 -  virtual void set_startsHumongous();
    38.8 +  void set_startsHumongous(HeapWord* new_end);
    38.9  
   38.10    // The regions that continue a humongous sequence should be added using
   38.11    // this method, in increasing address order.
   38.12    void set_continuesHumongous(HeapRegion* start);
   38.13  
   38.14 -  void add_continuingHumongousRegion(HeapRegion* cont);
   38.15 -
   38.16    // If the region has a remembered set, return a pointer to it.
   38.17    HeapRegionRemSet* rem_set() const {
   38.18      return _rem_set;
   38.19 @@ -733,13 +731,6 @@
   38.20                                     FilterOutOfRegionClosure* cl,
   38.21                                     bool filter_young);
   38.22  
   38.23 -  // The region "mr" is entirely in "this", and starts and ends at block
   38.24 -  // boundaries. The caller declares that all the contained blocks are
   38.25 -  // coalesced into one.
   38.26 -  void declare_filled_region_to_BOT(MemRegion mr) {
   38.27 -    _offsets.single_block(mr.start(), mr.end());
   38.28 -  }
   38.29 -
   38.30    // A version of block start that is guaranteed to find *some* block
   38.31    // boundary at or before "p", but does not object iteration, and may
   38.32    // therefore be used safely when the heap is unparseable.

    39.1 --- a/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp	Thu Nov 04 15:19:16 2010 -0700
    39.2 +++ b/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp	Thu Nov 04 16:17:54 2010 -0700
    39.3 @@ -1159,9 +1159,7 @@
    39.4    _hrrs(NULL),
    39.5    _g1h(G1CollectedHeap::heap()),
    39.6    _bosa(NULL),
    39.7 -  _sparse_iter(size_t(G1CollectedHeap::heap()->reserved_region().start())
    39.8 -               >> CardTableModRefBS::card_shift)
    39.9 -{}
   39.10 +  _sparse_iter() { }
   39.11  
   39.12  void HeapRegionRemSetIterator::initialize(const HeapRegionRemSet* hrrs) {
   39.13    _hrrs = hrrs;

    40.1 --- a/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp	Thu Nov 04 15:19:16 2010 -0700
    40.2 +++ b/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp	Thu Nov 04 16:17:54 2010 -0700
    40.3 @@ -91,34 +91,118 @@
    40.4    }
    40.5    if (sumSizes >= word_size) {
    40.6      _alloc_search_start = cur;
    40.7 -    // Mark the allocated regions as allocated.
    40.8 +
    40.9 +    // We need to initialize the region(s) we just discovered. This is
   40.10 +    // a bit tricky given that it can happen concurrently with
   40.11 +    // refinement threads refining cards on these regions and
   40.12 +    // potentially wanting to refine the BOT as they are scanning
   40.13 +    // those cards (this can happen shortly after a cleanup; see CR
   40.14 +    // 6991377). So we have to set up the region(s) carefully and in
   40.15 +    // a specific order.
   40.16 +
   40.17 +    // Currently, allocs_are_zero_filled() returns false. The zero
   40.18 +    // filling infrastructure will be going away soon (see CR 6977804).
   40.19 +    // So no need to do anything else here.
   40.20      bool zf = G1CollectedHeap::heap()->allocs_are_zero_filled();
   40.21 +    assert(!zf, "not supported");
   40.22 +
   40.23 +    // This will be the "starts humongous" region.
   40.24      HeapRegion* first_hr = _regions.at(first);
   40.25 -    for (int i = first; i < cur; i++) {
   40.26 -      HeapRegion* hr = _regions.at(i);
   40.27 -      if (zf)
   40.28 -        hr->ensure_zero_filled();
   40.29 +    {
   40.30 +      MutexLockerEx x(ZF_mon, Mutex::_no_safepoint_check_flag);
   40.31 +      first_hr->set_zero_fill_allocated();
   40.32 +    }
   40.33 +    // The header of the new object will be placed at the bottom of
   40.34 +    // the first region.
   40.35 +    HeapWord* new_obj = first_hr->bottom();
   40.36 +    // This will be the new end of the first region in the series that
   40.37 +    // should also match the end of the last region in the seriers.
   40.38 +    // (Note: sumSizes = "region size" x "number of regions we found").
   40.39 +    HeapWord* new_end = new_obj + sumSizes;
   40.40 +    // This will be the new top of the first region that will reflect
   40.41 +    // this allocation.
   40.42 +    HeapWord* new_top = new_obj + word_size;
   40.43 +
   40.44 +    // First, we need to zero the header of the space that we will be
   40.45 +    // allocating. When we update top further down, some refinement
   40.46 +    // threads might try to scan the region. By zeroing the header we
   40.47 +    // ensure that any thread that will try to scan the region will
   40.48 +    // come across the zero klass word and bail out.
   40.49 +    //
   40.50 +    // NOTE: It would not have been correct to have used
   40.51 +    // CollectedHeap::fill_with_object() and make the space look like
   40.52 +    // an int array. The thread that is doing the allocation will
   40.53 +    // later update the object header to a potentially different array
   40.54 +    // type and, for a very short period of time, the klass and length
   40.55 +    // fields will be inconsistent. This could cause a refinement
   40.56 +    // thread to calculate the object size incorrectly.
   40.57 +    Copy::fill_to_words(new_obj, oopDesc::header_size(), 0);
   40.58 +
   40.59 +    // We will set up the first region as "starts humongous". This
   40.60 +    // will also update the BOT covering all the regions to reflect
   40.61 +    // that there is a single object that starts at the bottom of the
   40.62 +    // first region.
   40.63 +    first_hr->set_startsHumongous(new_end);
   40.64 +
   40.65 +    // Then, if there are any, we will set up the "continues
   40.66 +    // humongous" regions.
   40.67 +    HeapRegion* hr = NULL;
   40.68 +    for (int i = first + 1; i < cur; ++i) {
   40.69 +      hr = _regions.at(i);
   40.70        {
   40.71          MutexLockerEx x(ZF_mon, Mutex::_no_safepoint_check_flag);
   40.72          hr->set_zero_fill_allocated();
   40.73        }
   40.74 -      size_t sz = hr->capacity() / HeapWordSize;
   40.75 -      HeapWord* tmp = hr->allocate(sz);
   40.76 -      assert(tmp != NULL, "Humongous allocation failure");
   40.77 -      MemRegion mr = MemRegion(tmp, sz);
   40.78 -      CollectedHeap::fill_with_object(mr);
   40.79 -      hr->declare_filled_region_to_BOT(mr);
   40.80 -      if (i == first) {
   40.81 -        first_hr->set_startsHumongous();
   40.82 +      hr->set_continuesHumongous(first_hr);
   40.83 +    }
   40.84 +    // If we have "continues humongous" regions (hr != NULL), then the
   40.85 +    // end of the last one should match new_end.
   40.86 +    assert(hr == NULL || hr->end() == new_end, "sanity");
   40.87 +
   40.88 +    // Up to this point no concurrent thread would have been able to
   40.89 +    // do any scanning on any region in this series. All the top
   40.90 +    // fields still point to bottom, so the intersection between
   40.91 +    // [bottom,top] and [card_start,card_end] will be empty. Before we
   40.92 +    // update the top fields, we'll do a storestore to make sure that
   40.93 +    // no thread sees the update to top before the zeroing of the
   40.94 +    // object header and the BOT initialization.
   40.95 +    OrderAccess::storestore();
   40.96 +
   40.97 +    // Now that the BOT and the object header have been initialized,
   40.98 +    // we can update top of the "starts humongous" region.
   40.99 +    assert(first_hr->bottom() < new_top && new_top <= first_hr->end(),
  40.100 +           "new_top should be in this region");
  40.101 +    first_hr->set_top(new_top);
  40.102 +
  40.103 +    // Now, we will update the top fields of the "continues humongous"
  40.104 +    // regions. The reason we need to do this is that, otherwise,
  40.105 +    // these regions would look empty and this will confuse parts of
  40.106 +    // G1. For example, the code that looks for a consecutive number
  40.107 +    // of empty regions will consider them empty and try to
  40.108 +    // re-allocate them. We can extend is_empty() to also include
  40.109 +    // !continuesHumongous(), but it is easier to just update the top
  40.110 +    // fields here.
  40.111 +    hr = NULL;
  40.112 +    for (int i = first + 1; i < cur; ++i) {
  40.113 +      hr = _regions.at(i);
  40.114 +      if ((i + 1) == cur) {
  40.115 +        // last continues humongous region
  40.116 +        assert(hr->bottom() < new_top && new_top <= hr->end(),
  40.117 +               "new_top should fall on this region");
  40.118 +        hr->set_top(new_top);
  40.119        } else {
  40.120 -        assert(i > first, "sanity");
  40.121 -        hr->set_continuesHumongous(first_hr);
  40.122 +        // not last one
  40.123 +        assert(new_top > hr->end(), "new_top should be above this region");
  40.124 +        hr->set_top(hr->end());
  40.125        }
  40.126      }
  40.127 -    HeapWord* first_hr_bot = first_hr->bottom();
  40.128 -    HeapWord* obj_end = first_hr_bot + word_size;
  40.129 -    first_hr->set_top(obj_end);
  40.130 -    return first_hr_bot;
  40.131 +    // If we have continues humongous regions (hr != NULL), then the
  40.132 +    // end of the last one should match new_end and its top should
  40.133 +    // match new_top.
  40.134 +    assert(hr == NULL ||
  40.135 +           (hr->end() == new_end && hr->top() == new_top), "sanity");
  40.136 +
  40.137 +    return new_obj;
  40.138    } else {
  40.139      // If we started from the beginning, we want to know why we can't alloc.
  40.140      return NULL;

    41.1 --- a/src/share/vm/gc_implementation/g1/sparsePRT.cpp	Thu Nov 04 15:19:16 2010 -0700
    41.2 +++ b/src/share/vm/gc_implementation/g1/sparsePRT.cpp	Thu Nov 04 16:17:54 2010 -0700
    41.3 @@ -308,7 +308,7 @@
    41.4    assert(e2->num_valid_cards() > 0, "Postcondition.");
    41.5  }
    41.6  
    41.7 -CardIdx_t /* RSHashTable:: */ RSHashTableIter::find_first_card_in_list() {
    41.8 +CardIdx_t RSHashTableIter::find_first_card_in_list() {
    41.9    CardIdx_t res;
   41.10    while (_bl_ind != RSHashTable::NullEntry) {
   41.11      res = _rsht->entry(_bl_ind)->card(0);
   41.12 @@ -322,14 +322,11 @@
   41.13    return SparsePRTEntry::NullEntry;
   41.14  }
   41.15  
   41.16 -size_t /* RSHashTable:: */ RSHashTableIter::compute_card_ind(CardIdx_t ci) {
   41.17 -  return
   41.18 -    _heap_bot_card_ind
   41.19 -    + (_rsht->entry(_bl_ind)->r_ind() * HeapRegion::CardsPerRegion)
   41.20 -    + ci;
   41.21 +size_t RSHashTableIter::compute_card_ind(CardIdx_t ci) {
   41.22 +  return (_rsht->entry(_bl_ind)->r_ind() * HeapRegion::CardsPerRegion) + ci;
   41.23  }
   41.24  
   41.25 -bool /* RSHashTable:: */ RSHashTableIter::has_next(size_t& card_index) {
   41.26 +bool RSHashTableIter::has_next(size_t& card_index) {
   41.27    _card_ind++;
   41.28    CardIdx_t ci;
   41.29    if (_card_ind < SparsePRTEntry::cards_num() &&

    42.1 --- a/src/share/vm/gc_implementation/g1/sparsePRT.hpp	Thu Nov 04 15:19:16 2010 -0700
    42.2 +++ b/src/share/vm/gc_implementation/g1/sparsePRT.hpp	Thu Nov 04 16:17:54 2010 -0700
    42.3 @@ -169,7 +169,6 @@
    42.4    int _bl_ind;          // [-1, 0.._rsht->_capacity)
    42.5    short _card_ind;      // [0..SparsePRTEntry::cards_num())
    42.6    RSHashTable* _rsht;
    42.7 -  size_t _heap_bot_card_ind;
    42.8  
    42.9    // If the bucket list pointed to by _bl_ind contains a card, sets
   42.10    // _bl_ind to the index of that entry, and returns the card.
   42.11 @@ -183,13 +182,11 @@
   42.12    size_t compute_card_ind(CardIdx_t ci);
   42.13  
   42.14  public:
   42.15 -  RSHashTableIter(size_t heap_bot_card_ind) :
   42.16 +  RSHashTableIter() :
   42.17      _tbl_ind(RSHashTable::NullEntry),
   42.18      _bl_ind(RSHashTable::NullEntry),
   42.19      _card_ind((SparsePRTEntry::cards_num() - 1)),
   42.20 -    _rsht(NULL),
   42.21 -    _heap_bot_card_ind(heap_bot_card_ind)
   42.22 -  {}
   42.23 +    _rsht(NULL) {}
   42.24  
   42.25    void init(RSHashTable* rsht) {
   42.26      _rsht = rsht;
   42.27 @@ -280,20 +277,11 @@
   42.28    bool contains_card(RegionIdx_t region_id, CardIdx_t card_index) const {
   42.29      return _next->contains_card(region_id, card_index);
   42.30    }
   42.31 -
   42.32 -#if 0
   42.33 -  void verify_is_cleared();
   42.34 -  void print();
   42.35 -#endif
   42.36  };
   42.37  
   42.38  
   42.39 -class SparsePRTIter: public /* RSHashTable:: */RSHashTableIter {
   42.40 +class SparsePRTIter: public RSHashTableIter {
   42.41  public:
   42.42 -  SparsePRTIter(size_t heap_bot_card_ind) :
   42.43 -    /* RSHashTable:: */RSHashTableIter(heap_bot_card_ind)
   42.44 -  {}
   42.45 -
   42.46    void init(const SparsePRT* sprt) {
   42.47      RSHashTableIter::init(sprt->cur());
   42.48    }

    43.1 --- a/src/share/vm/gc_implementation/includeDB_gc_g1	Thu Nov 04 15:19:16 2010 -0700
    43.2 +++ b/src/share/vm/gc_implementation/includeDB_gc_g1	Thu Nov 04 16:17:54 2010 -0700
    43.3 @@ -310,10 +310,16 @@
    43.4  
    43.5  heapRegionSeq.inline.hpp                heapRegionSeq.hpp
    43.6  
    43.7 +instanceKlass.cpp                       g1RemSet.inline.hpp
    43.8 +
    43.9 +instanceRefKlass.cpp                    g1RemSet.inline.hpp
   43.10 +
   43.11  klass.hpp				g1OopClosures.hpp
   43.12  
   43.13  memoryService.cpp                       g1MemoryPool.hpp
   43.14  
   43.15 +objArrayKlass.cpp                       g1RemSet.inline.hpp
   43.16 +
   43.17  ptrQueue.cpp                            allocation.hpp
   43.18  ptrQueue.cpp                            allocation.inline.hpp
   43.19  ptrQueue.cpp                            mutex.hpp

    44.1 --- a/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp	Thu Nov 04 15:19:16 2010 -0700
    44.2 +++ b/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp	Thu Nov 04 16:17:54 2010 -0700
    44.3 @@ -846,7 +846,7 @@
    44.4    // from this generation, pass on collection; let the next generation
    44.5    // do it.
    44.6    if (!collection_attempt_is_safe()) {
    44.7 -    gch->set_incremental_collection_will_fail();
    44.8 +    gch->set_incremental_collection_failed();  // slight lie, in that we did not even attempt one
    44.9      return;
   44.10    }
   44.11    assert(to()->is_empty(), "Else not collection_attempt_is_safe");
   44.12 @@ -935,8 +935,6 @@
   44.13  
   44.14      assert(to()->is_empty(), "to space should be empty now");
   44.15    } else {
   44.16 -    assert(HandlePromotionFailure,
   44.17 -      "Should only be here if promotion failure handling is on");
   44.18      assert(_promo_failure_scan_stack.is_empty(), "post condition");
   44.19      _promo_failure_scan_stack.clear(true); // Clear cached segments.
   44.20  
   44.21 @@ -947,7 +945,7 @@
   44.22      // All the spaces are in play for mark-sweep.
   44.23      swap_spaces();  // Make life simpler for CMS || rescan; see 6483690.
   44.24      from()->set_next_compaction_space(to());
   44.25 -    gch->set_incremental_collection_will_fail();
   44.26 +    gch->set_incremental_collection_failed();
   44.27      // Inform the next generation that a promotion failure occurred.
   44.28      _next_gen->promotion_failure_occurred();
   44.29  
   44.30 @@ -1092,11 +1090,6 @@
   44.31                                         old, m, sz);
   44.32  
   44.33      if (new_obj == NULL) {
   44.34 -      if (!HandlePromotionFailure) {
   44.35 -        // A failed promotion likely means the MaxLiveObjectEvacuationRatio flag
   44.36 -        // is incorrectly set. In any case, its seriously wrong to be here!
   44.37 -        vm_exit_out_of_memory(sz*wordSize, "promotion");
   44.38 -      }
   44.39        // promotion failed, forward to self
   44.40        _promotion_failed = true;
   44.41        new_obj = old;
   44.42 @@ -1206,12 +1199,6 @@
   44.43                                         old, m, sz);
   44.44  
   44.45      if (new_obj == NULL) {
   44.46 -      if (!HandlePromotionFailure) {
   44.47 -        // A failed promotion likely means the MaxLiveObjectEvacuationRatio
   44.48 -        // flag is incorrectly set. In any case, its seriously wrong to be
   44.49 -        // here!
   44.50 -        vm_exit_out_of_memory(sz*wordSize, "promotion");
   44.51 -      }
   44.52        // promotion failed, forward to self
   44.53        forward_ptr = old->forward_to_atomic(old);
   44.54        new_obj = old;

    45.1 --- a/src/share/vm/includeDB_compiler1	Thu Nov 04 15:19:16 2010 -0700
    45.2 +++ b/src/share/vm/includeDB_compiler1	Thu Nov 04 16:17:54 2010 -0700
    45.3 @@ -301,6 +301,7 @@
    45.4  c1_MacroAssembler.hpp                   assembler_<arch>.inline.hpp
    45.5  
    45.6  c1_MacroAssembler_<arch>.cpp            arrayOop.hpp
    45.7 +c1_MacroAssembler_<arch>.cpp            basicLock.hpp
    45.8  c1_MacroAssembler_<arch>.cpp            biasedLocking.hpp
    45.9  c1_MacroAssembler_<arch>.cpp            c1_MacroAssembler.hpp
   45.10  c1_MacroAssembler_<arch>.cpp            c1_Runtime1.hpp
   45.11 @@ -309,7 +310,6 @@
   45.12  c1_MacroAssembler_<arch>.cpp            markOop.hpp
   45.13  c1_MacroAssembler_<arch>.cpp            os.hpp
   45.14  c1_MacroAssembler_<arch>.cpp            stubRoutines.hpp
   45.15 -c1_MacroAssembler_<arch>.cpp            synchronizer.hpp
   45.16  c1_MacroAssembler_<arch>.cpp            systemDictionary.hpp
   45.17  
   45.18  c1_MacroAssembler_<arch>.hpp            generate_platform_dependent_include

    46.1 --- a/src/share/vm/includeDB_core	Thu Nov 04 15:19:16 2010 -0700
    46.2 +++ b/src/share/vm/includeDB_core	Thu Nov 04 16:17:54 2010 -0700
    46.3 @@ -300,10 +300,17 @@
    46.4  barrierSet.inline.hpp                   barrierSet.hpp
    46.5  barrierSet.inline.hpp                   cardTableModRefBS.hpp
    46.6  
    46.7 +basicLock.cpp                           basicLock.hpp
    46.8 +basicLock.cpp                           synchronizer.hpp
    46.9 +
   46.10 +basicLock.hpp                           handles.hpp
   46.11 +basicLock.hpp                           markOop.hpp
   46.12 +basicLock.hpp                           top.hpp
   46.13 +
   46.14 +biasedLocking.cpp                       basicLock.hpp
   46.15  biasedLocking.cpp                       biasedLocking.hpp
   46.16  biasedLocking.cpp                       klass.inline.hpp
   46.17  biasedLocking.cpp                       markOop.hpp
   46.18 -biasedLocking.cpp                       synchronizer.hpp
   46.19  biasedLocking.cpp                       task.hpp
   46.20  biasedLocking.cpp                       vframe.hpp
   46.21  biasedLocking.cpp                       vmThread.hpp
   46.22 @@ -404,13 +411,13 @@
   46.23  bytecodeInterpreterWithChecks.cpp       bytecodeInterpreter.cpp
   46.24  
   46.25  bytecodeInterpreter.hpp                 allocation.hpp
   46.26 +bytecodeInterpreter.hpp                 basicLock.hpp
   46.27  bytecodeInterpreter.hpp                 bytes_<arch>.hpp
   46.28  bytecodeInterpreter.hpp                 frame.hpp
   46.29  bytecodeInterpreter.hpp                 globalDefinitions.hpp
   46.30  bytecodeInterpreter.hpp                 globals.hpp
   46.31  bytecodeInterpreter.hpp                 methodDataOop.hpp
   46.32  bytecodeInterpreter.hpp                 methodOop.hpp
   46.33 -bytecodeInterpreter.hpp                 synchronizer.hpp
   46.34  
   46.35  bytecodeInterpreter.inline.hpp          bytecodeInterpreter.hpp
   46.36  bytecodeInterpreter.inline.hpp          stubRoutines.hpp
   46.37 @@ -1667,10 +1674,10 @@
   46.38  frame.cpp                               universe.inline.hpp
   46.39  
   46.40  frame.hpp                               assembler.hpp
   46.41 +frame.hpp                               basicLock.hpp
   46.42  frame.hpp                               methodOop.hpp
   46.43  frame.hpp                               monitorChunk.hpp
   46.44  frame.hpp                               registerMap.hpp
   46.45 -frame.hpp                               synchronizer.hpp
   46.46  frame.hpp                               top.hpp
   46.47  
   46.48  frame.inline.hpp                        bytecodeInterpreter.hpp
   46.49 @@ -2120,6 +2127,7 @@
   46.50  interfaceSupport_<os_family>.hpp        generate_platform_dependent_include
   46.51  
   46.52  interp_masm_<arch_model>.cpp            arrayOop.hpp
   46.53 +interp_masm_<arch_model>.cpp            basicLock.hpp
   46.54  interp_masm_<arch_model>.cpp            biasedLocking.hpp
   46.55  interp_masm_<arch_model>.cpp            interp_masm_<arch_model>.hpp
   46.56  interp_masm_<arch_model>.cpp            interpreterRuntime.hpp
   46.57 @@ -2131,7 +2139,6 @@
   46.58  interp_masm_<arch_model>.cpp            methodDataOop.hpp
   46.59  interp_masm_<arch_model>.cpp            methodOop.hpp
   46.60  interp_masm_<arch_model>.cpp            sharedRuntime.hpp
   46.61 -interp_masm_<arch_model>.cpp            synchronizer.hpp
   46.62  interp_masm_<arch_model>.cpp            thread_<os_family>.inline.hpp
   46.63  
   46.64  interp_masm_<arch_model>.hpp            assembler_<arch>.inline.hpp
   46.65 @@ -3094,25 +3101,26 @@
   46.66  
   46.67  objArrayOop.hpp                         arrayOop.hpp
   46.68  
   46.69 +objectMonitor.cpp                       dtrace.hpp
   46.70 +objectMonitor.cpp                       handles.inline.hpp
   46.71 +objectMonitor.cpp                       interfaceSupport.hpp
   46.72 +objectMonitor.cpp                       markOop.hpp
   46.73 +objectMonitor.cpp                       mutexLocker.hpp
   46.74 +objectMonitor.cpp                       objectMonitor.hpp
   46.75 +objectMonitor.cpp                       objectMonitor.inline.hpp
   46.76 +objectMonitor.cpp                       oop.inline.hpp
   46.77 +objectMonitor.cpp                       osThread.hpp
   46.78 +objectMonitor.cpp                       os_<os_family>.inline.hpp
   46.79 +objectMonitor.cpp                       preserveException.hpp
   46.80 +objectMonitor.cpp                       resourceArea.hpp
   46.81 +objectMonitor.cpp                       stubRoutines.hpp
   46.82 +objectMonitor.cpp                       thread.hpp
   46.83 +objectMonitor.cpp                       thread_<os_family>.inline.hpp
   46.84 +objectMonitor.cpp                       threadService.hpp
   46.85 +objectMonitor.cpp                       vmSymbols.hpp
   46.86 +
   46.87  objectMonitor.hpp                       os.hpp
   46.88 -
   46.89 -objectMonitor_<os_family>.cpp           dtrace.hpp
   46.90 -objectMonitor_<os_family>.cpp           interfaceSupport.hpp
   46.91 -objectMonitor_<os_family>.cpp           objectMonitor.hpp
   46.92 -objectMonitor_<os_family>.cpp           objectMonitor.inline.hpp
   46.93 -objectMonitor_<os_family>.cpp           oop.inline.hpp
   46.94 -objectMonitor_<os_family>.cpp           osThread.hpp
   46.95 -objectMonitor_<os_family>.cpp           os_<os_family>.inline.hpp
   46.96 -objectMonitor_<os_family>.cpp           threadService.hpp
   46.97 -objectMonitor_<os_family>.cpp           thread_<os_family>.inline.hpp
   46.98 -objectMonitor_<os_family>.cpp           vmSymbols.hpp
   46.99 -
  46.100 -objectMonitor_<os_family>.hpp           generate_platform_dependent_include
  46.101 -objectMonitor_<os_family>.hpp           os_<os_family>.inline.hpp
  46.102 -objectMonitor_<os_family>.hpp           thread_<os_family>.inline.hpp
  46.103 -objectMonitor_<os_family>.hpp           top.hpp
  46.104 -
  46.105 -objectMonitor_<os_family>.inline.hpp    generate_platform_dependent_include
  46.106 +objectMonitor.hpp                       perfData.hpp
  46.107  
  46.108  oop.cpp                                 copy.hpp
  46.109  oop.cpp                                 handles.inline.hpp
  46.110 @@ -3231,6 +3239,7 @@
  46.111  orderAccess.hpp                         os.hpp
  46.112  
  46.113  orderAccess_<os_arch>.inline.hpp        orderAccess.hpp
  46.114 +orderAccess_<os_arch>.inline.hpp        vm_version_<arch>.hpp
  46.115  
  46.116  os.cpp                                  allocation.inline.hpp
  46.117  os.cpp                                  arguments.hpp
  46.118 @@ -3328,7 +3337,6 @@
  46.119  os_<os_family>.cpp                      nativeInst_<arch>.hpp
  46.120  os_<os_family>.cpp                      no_precompiled_headers
  46.121  os_<os_family>.cpp                      objectMonitor.hpp
  46.122 -os_<os_family>.cpp                      objectMonitor.inline.hpp
  46.123  os_<os_family>.cpp                      oop.inline.hpp
  46.124  os_<os_family>.cpp                      osThread.hpp
  46.125  os_<os_family>.cpp                      os_share_<os_family>.hpp
  46.126 @@ -3388,6 +3396,12 @@
  46.127  ostream.hpp                             allocation.hpp
  46.128  ostream.hpp                             timer.hpp
  46.129  
  46.130 +// include thread.hpp to prevent cyclic includes
  46.131 +park.cpp                                thread.hpp
  46.132 +
  46.133 +park.hpp                                debug.hpp
  46.134 +park.hpp                                globalDefinitions.hpp
  46.135 +
  46.136  pcDesc.cpp                              debugInfoRec.hpp
  46.137  pcDesc.cpp                              nmethod.hpp
  46.138  pcDesc.cpp                              pcDesc.hpp
  46.139 @@ -3600,7 +3614,9 @@
  46.140  relocator.cpp                           bytecodes.hpp
  46.141  relocator.cpp                           handles.inline.hpp
  46.142  relocator.cpp                           oop.inline.hpp
  46.143 +relocator.cpp                           oopFactory.hpp
  46.144  relocator.cpp                           relocator.hpp
  46.145 +relocator.cpp                           stackMapTableFormat.hpp
  46.146  relocator.cpp                           universe.inline.hpp
  46.147  
  46.148  relocator.hpp                           bytecodes.hpp
  46.149 @@ -3907,6 +3923,8 @@
  46.150  stackMapTable.hpp                       methodOop.hpp
  46.151  stackMapTable.hpp                       stackMapFrame.hpp
  46.152  
  46.153 +stackMapTableFormat.hpp                 verificationType.hpp
  46.154 +
  46.155  stackValue.cpp                          debugInfo.hpp
  46.156  stackValue.cpp                          frame.inline.hpp
  46.157  stackValue.cpp                          handles.inline.hpp
  46.158 @@ -4062,10 +4080,10 @@
  46.159  synchronizer.cpp                        resourceArea.hpp
  46.160  synchronizer.cpp                        stubRoutines.hpp
  46.161  synchronizer.cpp                        synchronizer.hpp
  46.162 -synchronizer.cpp                        threadService.hpp
  46.163  synchronizer.cpp                        thread_<os_family>.inline.hpp
  46.164  synchronizer.cpp                        vmSymbols.hpp
  46.165  
  46.166 +synchronizer.hpp                        basicLock.hpp
  46.167  synchronizer.hpp                        handles.hpp
  46.168  synchronizer.hpp                        markOop.hpp
  46.169  synchronizer.hpp                        perfData.hpp
  46.170 @@ -4237,7 +4255,6 @@
  46.171  thread.cpp                              mutexLocker.hpp
  46.172  thread.cpp                              objArrayOop.hpp
  46.173  thread.cpp                              objectMonitor.hpp
  46.174 -thread.cpp                              objectMonitor.inline.hpp
  46.175  thread.cpp                              oop.inline.hpp
  46.176  thread.cpp                              oopFactory.hpp
  46.177  thread.cpp                              osThread.hpp
  46.178 @@ -4275,6 +4292,7 @@
  46.179  thread.hpp                              oop.hpp
  46.180  thread.hpp                              os.hpp
  46.181  thread.hpp                              osThread.hpp
  46.182 +thread.hpp                              park.hpp
  46.183  thread.hpp                              safepoint.hpp
  46.184  thread.hpp                              stubRoutines.hpp
  46.185  thread.hpp                              threadLocalAllocBuffer.hpp
  46.186 @@ -4586,6 +4604,7 @@
  46.187  vframeArray.hpp                         growableArray.hpp
  46.188  vframeArray.hpp                         monitorChunk.hpp
  46.189  
  46.190 +vframe_hp.cpp                           basicLock.hpp
  46.191  vframe_hp.cpp                           codeCache.hpp
  46.192  vframe_hp.cpp                           debugInfoRec.hpp
  46.193  vframe_hp.cpp                           handles.inline.hpp
  46.194 @@ -4599,7 +4618,6 @@
  46.195  vframe_hp.cpp                           scopeDesc.hpp
  46.196  vframe_hp.cpp                           signature.hpp
  46.197  vframe_hp.cpp                           stubRoutines.hpp
  46.198 -vframe_hp.cpp                           synchronizer.hpp
  46.199  vframe_hp.cpp                           vframeArray.hpp
  46.200  vframe_hp.cpp                           vframe_hp.hpp
  46.201  
  46.202 @@ -4751,6 +4769,7 @@
  46.203  workgroup.cpp                           workgroup.hpp
  46.204  
  46.205  workgroup.hpp                           taskqueue.hpp
  46.206 +
  46.207  workgroup.hpp                           thread_<os_family>.inline.hpp
  46.208  
  46.209  xmlstream.cpp                           allocation.hpp

    47.1 --- a/src/share/vm/includeDB_features	Thu Nov 04 15:19:16 2010 -0700
    47.2 +++ b/src/share/vm/includeDB_features	Thu Nov 04 16:17:54 2010 -0700
    47.3 @@ -184,6 +184,13 @@
    47.4  jvmtiImpl.hpp                           systemDictionary.hpp
    47.5  jvmtiImpl.hpp                           vm_operations.hpp
    47.6  
    47.7 +jvmtiRawMonitor.cpp                     interfaceSupport.hpp
    47.8 +jvmtiRawMonitor.cpp                     jvmtiRawMonitor.hpp
    47.9 +jvmtiRawMonitor.cpp                     thread.hpp
   47.10 +
   47.11 +jvmtiRawMonitor.hpp                     growableArray.hpp
   47.12 +jvmtiRawMonitor.hpp                     objectMonitor.hpp
   47.13 +
   47.14  jvmtiTagMap.cpp                         biasedLocking.hpp
   47.15  jvmtiTagMap.cpp                         javaCalls.hpp
   47.16  jvmtiTagMap.cpp                         jniHandles.hpp

    48.1 --- a/src/share/vm/includeDB_jvmti	Thu Nov 04 15:19:16 2010 -0700
    48.2 +++ b/src/share/vm/includeDB_jvmti	Thu Nov 04 16:17:54 2010 -0700
    48.3 @@ -35,6 +35,7 @@
    48.4  // jvmtiCodeBlobEvents is jck optional, please put deps in includeDB_features
    48.5  
    48.6  jvmtiEnter.cpp                          jvmtiEnter.hpp
    48.7 +jvmtiEnter.cpp                          jvmtiRawMonitor.hpp
    48.8  jvmtiEnter.cpp                          jvmtiUtil.hpp
    48.9  
   48.10  jvmtiEnter.hpp                          interfaceSupport.hpp
   48.11 @@ -44,6 +45,7 @@
   48.12  jvmtiEnter.hpp                          systemDictionary.hpp
   48.13  
   48.14  jvmtiEnterTrace.cpp                     jvmtiEnter.hpp
   48.15 +jvmtiEnterTrace.cpp                     jvmtiRawMonitor.hpp
   48.16  jvmtiEnterTrace.cpp                     jvmtiUtil.hpp
   48.17  
   48.18  jvmtiEnv.cpp                            arguments.hpp
   48.19 @@ -66,11 +68,11 @@
   48.20  jvmtiEnv.cpp                            jvmtiGetLoadedClasses.hpp
   48.21  jvmtiEnv.cpp                            jvmtiImpl.hpp
   48.22  jvmtiEnv.cpp                            jvmtiManageCapabilities.hpp
   48.23 +jvmtiEnv.cpp                            jvmtiRawMonitor.hpp
   48.24  jvmtiEnv.cpp                            jvmtiRedefineClasses.hpp
   48.25  jvmtiEnv.cpp                            jvmtiTagMap.hpp
   48.26  jvmtiEnv.cpp                            jvmtiThreadState.inline.hpp
   48.27  jvmtiEnv.cpp                            jvmtiUtil.hpp
   48.28 -jvmtiEnv.cpp                            objectMonitor.inline.hpp
   48.29  jvmtiEnv.cpp                            osThread.hpp
   48.30  jvmtiEnv.cpp                            preserveException.hpp
   48.31  jvmtiEnv.cpp                            reflectionUtils.hpp
   48.32 @@ -178,11 +180,13 @@
   48.33  jvmtiExport.cpp                         jvmtiExport.hpp
   48.34  jvmtiExport.cpp                         jvmtiImpl.hpp
   48.35  jvmtiExport.cpp                         jvmtiManageCapabilities.hpp
   48.36 +jvmtiExport.cpp                         jvmtiRawMonitor.hpp
   48.37  jvmtiExport.cpp                         jvmtiTagMap.hpp
   48.38  jvmtiExport.cpp                         jvmtiThreadState.inline.hpp
   48.39  jvmtiExport.cpp                         nmethod.hpp
   48.40  jvmtiExport.cpp                         objArrayKlass.hpp
   48.41  jvmtiExport.cpp                         objArrayOop.hpp
   48.42 +jvmtiExport.cpp                         objectMonitor.hpp
   48.43  jvmtiExport.cpp                         objectMonitor.inline.hpp
   48.44  jvmtiExport.cpp                         pcDesc.hpp
   48.45  jvmtiExport.cpp                         resourceArea.hpp
   48.46 @@ -210,6 +214,8 @@
   48.47  jvmtiManageCapabilities.hpp             allocation.hpp
   48.48  jvmtiManageCapabilities.hpp             jvmti.h
   48.49  
   48.50 +// jvmtiRawMonitor is jck optional, please put deps in includeDB_features
   48.51 +
   48.52  jvmtiRedefineClasses.cpp                bitMap.inline.hpp
   48.53  jvmtiRedefineClasses.cpp                codeCache.hpp
   48.54  jvmtiRedefineClasses.cpp                deoptimization.hpp

    49.1 --- a/src/share/vm/memory/collectorPolicy.cpp	Thu Nov 04 15:19:16 2010 -0700
    49.2 +++ b/src/share/vm/memory/collectorPolicy.cpp	Thu Nov 04 16:17:54 2010 -0700
    49.3 @@ -659,9 +659,6 @@
    49.4      }
    49.5      return result;   // could be null if we are out of space
    49.6    } else if (!gch->incremental_collection_will_fail()) {
    49.7 -    // The gc_prologues have not executed yet.  The value
    49.8 -    // for incremental_collection_will_fail() is the remanent
    49.9 -    // of the last collection.
   49.10      // Do an incremental collection.
   49.11      gch->do_collection(false            /* full */,
   49.12                         false            /* clear_all_soft_refs */,
   49.13 @@ -739,9 +736,8 @@
   49.14    GenCollectedHeap* gch = GenCollectedHeap::heap();
   49.15    size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
   49.16    return    (word_size > heap_word_size(gen0_capacity))
   49.17 -         || (GC_locker::is_active_and_needs_gc())
   49.18 -         || (   gch->last_incremental_collection_failed()
   49.19 -             && gch->incremental_collection_will_fail());
   49.20 +         || GC_locker::is_active_and_needs_gc()
   49.21 +         || gch->incremental_collection_failed();
   49.22  }
   49.23  
   49.24  

    50.1 --- a/src/share/vm/memory/defNewGeneration.cpp	Thu Nov 04 15:19:16 2010 -0700
    50.2 +++ b/src/share/vm/memory/defNewGeneration.cpp	Thu Nov 04 16:17:54 2010 -0700
    50.3 @@ -510,7 +510,7 @@
    50.4    // from this generation, pass on collection; let the next generation
    50.5    // do it.
    50.6    if (!collection_attempt_is_safe()) {
    50.7 -    gch->set_incremental_collection_will_fail();
    50.8 +    gch->set_incremental_collection_failed(); // Slight lie: we did not even attempt one
    50.9      return;
   50.10    }
   50.11    assert(to()->is_empty(), "Else not collection_attempt_is_safe");
   50.12 @@ -596,9 +596,8 @@
   50.13      if (PrintGC && !PrintGCDetails) {
   50.14        gch->print_heap_change(gch_prev_used);
   50.15      }
   50.16 +    assert(!gch->incremental_collection_failed(), "Should be clear");
   50.17    } else {
   50.18 -    assert(HandlePromotionFailure,
   50.19 -      "Should not be here unless promotion failure handling is on");
   50.20      assert(_promo_failure_scan_stack.is_empty(), "post condition");
   50.21      _promo_failure_scan_stack.clear(true); // Clear cached segments.
   50.22  
   50.23 @@ -613,7 +612,7 @@
   50.24      // and from-space.
   50.25      swap_spaces();   // For uniformity wrt ParNewGeneration.
   50.26      from()->set_next_compaction_space(to());
   50.27 -    gch->set_incremental_collection_will_fail();
   50.28 +    gch->set_incremental_collection_failed();
   50.29  
   50.30      // Inform the next generation that a promotion failure occurred.
   50.31      _next_gen->promotion_failure_occurred();
   50.32 @@ -700,12 +699,6 @@
   50.33    if (obj == NULL) {
   50.34      obj = _next_gen->promote(old, s);
   50.35      if (obj == NULL) {
   50.36 -      if (!HandlePromotionFailure) {
   50.37 -        // A failed promotion likely means the MaxLiveObjectEvacuationRatio flag
   50.38 -        // is incorrectly set. In any case, its seriously wrong to be here!
   50.39 -        vm_exit_out_of_memory(s*wordSize, "promotion");
   50.40 -      }
   50.41 -
   50.42        handle_promotion_failure(old);
   50.43        return old;
   50.44      }
   50.45 @@ -812,47 +805,43 @@
   50.46      assert(_next_gen != NULL,
   50.47             "This must be the youngest gen, and not the only gen");
   50.48    }
   50.49 -
   50.50 -  // Decide if there's enough room for a full promotion
   50.51 -  // When using extremely large edens, we effectively lose a
   50.52 -  // large amount of old space.  Use the "MaxLiveObjectEvacuationRatio"
   50.53 -  // flag to reduce the minimum evacuation space requirements. If
   50.54 -  // there is not enough space to evacuate eden during a scavenge,
   50.55 -  // the VM will immediately exit with an out of memory error.
   50.56 -  // This flag has not been tested
   50.57 -  // with collectors other than simple mark & sweep.
   50.58 -  //
   50.59 -  // Note that with the addition of promotion failure handling, the
   50.60 -  // VM will not immediately exit but will undo the young generation
   50.61 -  // collection.  The parameter is left here for compatibility.
   50.62 -  const double evacuation_ratio = MaxLiveObjectEvacuationRatio / 100.0;
   50.63 -
   50.64 -  // worst_case_evacuation is based on "used()".  For the case where this
   50.65 -  // method is called after a collection, this is still appropriate because
   50.66 -  // the case that needs to be detected is one in which a full collection
   50.67 -  // has been done and has overflowed into the young generation.  In that
   50.68 -  // case a minor collection will fail (the overflow of the full collection
   50.69 -  // means there is no space in the old generation for any promotion).
   50.70 -  size_t worst_case_evacuation = (size_t)(used() * evacuation_ratio);
   50.71 -
   50.72 -  return _next_gen->promotion_attempt_is_safe(worst_case_evacuation,
   50.73 -                                              HandlePromotionFailure);
   50.74 +  return _next_gen->promotion_attempt_is_safe(used());
   50.75  }
   50.76  
   50.77  void DefNewGeneration::gc_epilogue(bool full) {
   50.78 +  DEBUG_ONLY(static bool seen_incremental_collection_failed = false;)
   50.79 +
   50.80 +  assert(!GC_locker::is_active(), "We should not be executing here");
   50.81    // Check if the heap is approaching full after a collection has
   50.82    // been done.  Generally the young generation is empty at
   50.83    // a minimum at the end of a collection.  If it is not, then
   50.84    // the heap is approaching full.
   50.85    GenCollectedHeap* gch = GenCollectedHeap::heap();
   50.86 -  clear_should_allocate_from_space();
   50.87 -  if (collection_attempt_is_safe()) {
   50.88 -    gch->clear_incremental_collection_will_fail();
   50.89 +  if (full) {
   50.90 +    DEBUG_ONLY(seen_incremental_collection_failed = false;)
   50.91 +    if (!collection_attempt_is_safe()) {
   50.92 +      gch->set_incremental_collection_failed(); // Slight lie: a full gc left us in that state
   50.93 +      set_should_allocate_from_space(); // we seem to be running out of space
   50.94 +    } else {
   50.95 +      gch->clear_incremental_collection_failed(); // We just did a full collection
   50.96 +      clear_should_allocate_from_space(); // if set
   50.97 +    }
   50.98    } else {
   50.99 -    gch->set_incremental_collection_will_fail();
  50.100 -    if (full) { // we seem to be running out of space
  50.101 -      set_should_allocate_from_space();
  50.102 +#ifdef ASSERT
  50.103 +    // It is possible that incremental_collection_failed() == true
  50.104 +    // here, because an attempted scavenge did not succeed. The policy
  50.105 +    // is normally expected to cause a full collection which should
  50.106 +    // clear that condition, so we should not be here twice in a row
  50.107 +    // with incremental_collection_failed() == true without having done
  50.108 +    // a full collection in between.
  50.109 +    if (!seen_incremental_collection_failed &&
  50.110 +        gch->incremental_collection_failed()) {
  50.111 +      seen_incremental_collection_failed = true;
  50.112 +    } else if (seen_incremental_collection_failed) {
  50.113 +      assert(!gch->incremental_collection_failed(), "Twice in a row");
  50.114 +      seen_incremental_collection_failed = false;
  50.115      }
  50.116 +#endif // ASSERT
  50.117    }
  50.118  
  50.119    if (ZapUnusedHeapArea) {

    51.1 --- a/src/share/vm/memory/defNewGeneration.hpp	Thu Nov 04 15:19:16 2010 -0700
    51.2 +++ b/src/share/vm/memory/defNewGeneration.hpp	Thu Nov 04 16:17:54 2010 -0700
    51.3 @@ -82,12 +82,6 @@
    51.4    Stack<oop>     _objs_with_preserved_marks;
    51.5    Stack<markOop> _preserved_marks_of_objs;
    51.6  
    51.7 -  // Returns true if the collection can be safely attempted.
    51.8 -  // If this method returns false, a collection is not
    51.9 -  // guaranteed to fail but the system may not be able
   51.10 -  // to recover from the failure.
   51.11 -  bool collection_attempt_is_safe();
   51.12 -
   51.13    // Promotion failure handling
   51.14    OopClosure *_promo_failure_scan_stack_closure;
   51.15    void set_promo_failure_scan_stack_closure(OopClosure *scan_stack_closure) {
   51.16 @@ -304,6 +298,14 @@
   51.17  
   51.18    // GC support
   51.19    virtual void compute_new_size();
   51.20 +
   51.21 +  // Returns true if the collection is likely to be safely
   51.22 +  // completed. Even if this method returns true, a collection
   51.23 +  // may not be guaranteed to succeed, and the system should be
   51.24 +  // able to safely unwind and recover from that failure, albeit
   51.25 +  // at some additional cost. Override superclass's implementation.
   51.26 +  virtual bool collection_attempt_is_safe();
   51.27 +
   51.28    virtual void collect(bool   full,
   51.29                         bool   clear_all_soft_refs,
   51.30                         size_t size,

    52.1 --- a/src/share/vm/memory/genCollectedHeap.cpp	Thu Nov 04 15:19:16 2010 -0700
    52.2 +++ b/src/share/vm/memory/genCollectedHeap.cpp	Thu Nov 04 16:17:54 2010 -0700
    52.3 @@ -142,8 +142,7 @@
    52.4    }
    52.5    _perm_gen = perm_gen_spec->init(heap_rs, PermSize, rem_set());
    52.6  
    52.7 -  clear_incremental_collection_will_fail();
    52.8 -  clear_last_incremental_collection_failed();
    52.9 +  clear_incremental_collection_failed();
   52.10  
   52.11  #ifndef SERIALGC
   52.12    // If we are running CMS, create the collector responsible
   52.13 @@ -1347,17 +1346,6 @@
   52.14  };
   52.15  
   52.16  void GenCollectedHeap::gc_epilogue(bool full) {
   52.17 -  // Remember if a partial collection of the heap failed, and
   52.18 -  // we did a complete collection.
   52.19 -  if (full && incremental_collection_will_fail()) {
   52.20 -    set_last_incremental_collection_failed();
   52.21 -  } else {
   52.22 -    clear_last_incremental_collection_failed();
   52.23 -  }
   52.24 -  // Clear the flag, if set; the generation gc_epilogues will set the
   52.25 -  // flag again if the condition persists despite the collection.
   52.26 -  clear_incremental_collection_will_fail();
   52.27 -
   52.28  #ifdef COMPILER2
   52.29    assert(DerivedPointerTable::is_empty(), "derived pointer present");
   52.30    size_t actual_gap = pointer_delta((HeapWord*) (max_uintx-3), *(end_addr()));

    53.1 --- a/src/share/vm/memory/genCollectedHeap.hpp	Thu Nov 04 15:19:16 2010 -0700
    53.2 +++ b/src/share/vm/memory/genCollectedHeap.hpp	Thu Nov 04 16:17:54 2010 -0700
    53.3 @@ -62,11 +62,10 @@
    53.4    // The generational collector policy.
    53.5    GenCollectorPolicy* _gen_policy;
    53.6  
    53.7 -  // If a generation would bail out of an incremental collection,
    53.8 -  // it sets this flag.  If the flag is set, satisfy_failed_allocation
    53.9 -  // will attempt allocating in all generations before doing a full GC.
   53.10 -  bool _incremental_collection_will_fail;
   53.11 -  bool _last_incremental_collection_failed;
   53.12 +  // Indicates that the most recent previous incremental collection failed.
   53.13 +  // The flag is cleared when an action is taken that might clear the
   53.14 +  // condition that caused that incremental collection to fail.
   53.15 +  bool _incremental_collection_failed;
   53.16  
   53.17    // In support of ExplicitGCInvokesConcurrent functionality
   53.18    unsigned int _full_collections_completed;
   53.19 @@ -469,26 +468,26 @@
   53.20    // call to "save_marks".
   53.21    bool no_allocs_since_save_marks(int level);
   53.22  
   53.23 +  // Returns true if an incremental collection is likely to fail.
   53.24 +  bool incremental_collection_will_fail() {
   53.25 +    // Assumes a 2-generation system; the first disjunct remembers if an
   53.26 +    // incremental collection failed, even when we thought (second disjunct)
   53.27 +    // that it would not.
   53.28 +    assert(heap()->collector_policy()->is_two_generation_policy(),
   53.29 +           "the following definition may not be suitable for an n(>2)-generation system");
   53.30 +    return incremental_collection_failed() || !get_gen(0)->collection_attempt_is_safe();
   53.31 +  }
   53.32 +
   53.33    // If a generation bails out of an incremental collection,
   53.34    // it sets this flag.
   53.35 -  bool incremental_collection_will_fail() {
   53.36 -    return _incremental_collection_will_fail;
   53.37 +  bool incremental_collection_failed() const {
   53.38 +    return _incremental_collection_failed;
   53.39    }
   53.40 -  void set_incremental_collection_will_fail() {
   53.41 -    _incremental_collection_will_fail = true;
   53.42 +  void set_incremental_collection_failed() {
   53.43 +    _incremental_collection_failed = true;
   53.44    }
   53.45 -  void clear_incremental_collection_will_fail() {
   53.46 -    _incremental_collection_will_fail = false;
   53.47 -  }
   53.48 -
   53.49 -  bool last_incremental_collection_failed() const {
   53.50 -    return _last_incremental_collection_failed;
   53.51 -  }
   53.52 -  void set_last_incremental_collection_failed() {
   53.53 -    _last_incremental_collection_failed = true;
   53.54 -  }
   53.55 -  void clear_last_incremental_collection_failed() {
   53.56 -    _last_incremental_collection_failed = false;
   53.57 +  void clear_incremental_collection_failed() {
   53.58 +    _incremental_collection_failed = false;
   53.59    }
   53.60  
   53.61    // Promotion of obj into gen failed.  Try to promote obj to higher non-perm

    54.1 --- a/src/share/vm/memory/generation.cpp	Thu Nov 04 15:19:16 2010 -0700
    54.2 +++ b/src/share/vm/memory/generation.cpp	Thu Nov 04 16:17:54 2010 -0700
    54.3 @@ -165,15 +165,16 @@
    54.4    return max;
    54.5  }
    54.6  
    54.7 -bool Generation::promotion_attempt_is_safe(size_t promotion_in_bytes,
    54.8 -                                           bool not_used) const {
    54.9 +bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
   54.10 +  size_t available = max_contiguous_available();
   54.11 +  bool   res = (available >= max_promotion_in_bytes);
   54.12    if (PrintGC && Verbose) {
   54.13 -    gclog_or_tty->print_cr("Generation::promotion_attempt_is_safe"
   54.14 -                " contiguous_available: " SIZE_FORMAT
   54.15 -                " promotion_in_bytes: " SIZE_FORMAT,
   54.16 -                max_contiguous_available(), promotion_in_bytes);
   54.17 +    gclog_or_tty->print_cr(
   54.18 +      "Generation: promo attempt is%s safe: available("SIZE_FORMAT") %s max_promo("SIZE_FORMAT")",
   54.19 +      res? "":" not", available, res? ">=":"<",
   54.20 +      max_promotion_in_bytes);
   54.21    }
   54.22 -  return max_contiguous_available() >= promotion_in_bytes;
   54.23 +  return res;
   54.24  }
   54.25  
   54.26  // Ignores "ref" and calls allocate().

    55.1 --- a/src/share/vm/memory/generation.hpp	Thu Nov 04 15:19:16 2010 -0700
    55.2 +++ b/src/share/vm/memory/generation.hpp	Thu Nov 04 16:17:54 2010 -0700
    55.3 @@ -173,15 +173,11 @@
    55.4    // The largest number of contiguous free bytes in this or any higher generation.
    55.5    virtual size_t max_contiguous_available() const;
    55.6  
    55.7 -  // Returns true if promotions of the specified amount can
    55.8 -  // be attempted safely (without a vm failure).
    55.9 +  // Returns true if promotions of the specified amount are
   55.10 +  // likely to succeed without a promotion failure.
   55.11    // Promotion of the full amount is not guaranteed but
   55.12 -  // can be attempted.
   55.13 -  //   younger_handles_promotion_failure
   55.14 -  // is true if the younger generation handles a promotion
   55.15 -  // failure.
   55.16 -  virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes,
   55.17 -    bool younger_handles_promotion_failure) const;
   55.18 +  // might be attempted in the worst case.
   55.19 +  virtual bool promotion_attempt_is_safe(size_t max_promotion_in_bytes) const;
   55.20  
   55.21    // For a non-young generation, this interface can be used to inform a
   55.22    // generation that a promotion attempt into that generation failed.
   55.23 @@ -358,6 +354,16 @@
   55.24      return (full || should_allocate(word_size, is_tlab));
   55.25    }
   55.26  
   55.27 +  // Returns true if the collection is likely to be safely
   55.28 +  // completed. Even if this method returns true, a collection
   55.29 +  // may not be guaranteed to succeed, and the system should be
   55.30 +  // able to safely unwind and recover from that failure, albeit
   55.31 +  // at some additional cost.
   55.32 +  virtual bool collection_attempt_is_safe() {
   55.33 +    guarantee(false, "Are you sure you want to call this method?");
   55.34 +    return true;
   55.35 +  }
   55.36 +
   55.37    // Perform a garbage collection.
   55.38    // If full is true attempt a full garbage collection of this generation.
   55.39    // Otherwise, attempting to (at least) free enough space to support an

    56.1 --- a/src/share/vm/memory/tenuredGeneration.cpp	Thu Nov 04 15:19:16 2010 -0700
    56.2 +++ b/src/share/vm/memory/tenuredGeneration.cpp	Thu Nov 04 16:17:54 2010 -0700
    56.3 @@ -419,29 +419,16 @@
    56.4  void TenuredGeneration::verify_alloc_buffers_clean() {}
    56.5  #endif // SERIALGC
    56.6  
    56.7 -bool TenuredGeneration::promotion_attempt_is_safe(
    56.8 -    size_t max_promotion_in_bytes,
    56.9 -    bool younger_handles_promotion_failure) const {
   56.10 -
   56.11 -  bool result = max_contiguous_available() >= max_promotion_in_bytes;
   56.12 -
   56.13 -  if (younger_handles_promotion_failure && !result) {
   56.14 -    result = max_contiguous_available() >=
   56.15 -      (size_t) gc_stats()->avg_promoted()->padded_average();
   56.16 -    if (PrintGC && Verbose && result) {
   56.17 -      gclog_or_tty->print_cr("TenuredGeneration::promotion_attempt_is_safe"
   56.18 -                  " contiguous_available: " SIZE_FORMAT
   56.19 -                  " avg_promoted: " SIZE_FORMAT,
   56.20 -                  max_contiguous_available(),
   56.21 -                  gc_stats()->avg_promoted()->padded_average());
   56.22 -    }
   56.23 -  } else {
   56.24 -    if (PrintGC && Verbose) {
   56.25 -      gclog_or_tty->print_cr("TenuredGeneration::promotion_attempt_is_safe"
   56.26 -                  " contiguous_available: " SIZE_FORMAT
   56.27 -                  " promotion_in_bytes: " SIZE_FORMAT,
   56.28 -                  max_contiguous_available(), max_promotion_in_bytes);
   56.29 -    }
   56.30 +bool TenuredGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
   56.31 +  size_t available = max_contiguous_available();
   56.32 +  size_t av_promo  = (size_t)gc_stats()->avg_promoted()->padded_average();
   56.33 +  bool   res = (available >= av_promo) || (available >= max_promotion_in_bytes);
   56.34 +  if (PrintGC && Verbose) {
   56.35 +    gclog_or_tty->print_cr(
   56.36 +      "Tenured: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT"),"
   56.37 +      "max_promo("SIZE_FORMAT")",
   56.38 +      res? "":" not", available, res? ">=":"<",
   56.39 +      av_promo, max_promotion_in_bytes);
   56.40    }
   56.41 -  return result;
   56.42 +  return res;
   56.43  }

    57.1 --- a/src/share/vm/memory/tenuredGeneration.hpp	Thu Nov 04 15:19:16 2010 -0700
    57.2 +++ b/src/share/vm/memory/tenuredGeneration.hpp	Thu Nov 04 16:17:54 2010 -0700
    57.3 @@ -101,8 +101,7 @@
    57.4  
    57.5    virtual void update_gc_stats(int level, bool full);
    57.6  
    57.7 -  virtual bool promotion_attempt_is_safe(size_t max_promoted_in_bytes,
    57.8 -    bool younger_handles_promotion_failure) const;
    57.9 +  virtual bool promotion_attempt_is_safe(size_t max_promoted_in_bytes) const;
   57.10  
   57.11    void verify_alloc_buffers_clean();
   57.12  };

    58.1 --- a/src/share/vm/oops/methodOop.hpp	Thu Nov 04 15:19:16 2010 -0700
    58.2 +++ b/src/share/vm/oops/methodOop.hpp	Thu Nov 04 16:17:54 2010 -0700
    58.3 @@ -247,6 +247,10 @@
    58.4      return constMethod()->stackmap_data();
    58.5    }
    58.6  
    58.7 +  void set_stackmap_data(typeArrayOop sd) {
    58.8 +    constMethod()->set_stackmap_data(sd);
    58.9 +  }
   58.10 +
   58.11    // exception handler table
   58.12    typeArrayOop exception_table() const
   58.13                                     { return constMethod()->exception_table(); }

    59.1 --- a/src/share/vm/prims/jvmtiImpl.cpp	Thu Nov 04 15:19:16 2010 -0700
    59.2 +++ b/src/share/vm/prims/jvmtiImpl.cpp	Thu Nov 04 16:17:54 2010 -0700
    59.3 @@ -25,26 +25,6 @@
    59.4  # include "incls/_precompiled.incl"
    59.5  # include "incls/_jvmtiImpl.cpp.incl"
    59.6  
    59.7 -GrowableArray<JvmtiRawMonitor*> *JvmtiPendingMonitors::_monitors = new (ResourceObj::C_HEAP) GrowableArray<JvmtiRawMonitor*>(1,true);
    59.8 -
    59.9 -void JvmtiPendingMonitors::transition_raw_monitors() {
   59.10 -  assert((Threads::number_of_threads()==1),
   59.11 -         "Java thread has not created yet or more than one java thread \
   59.12 -is running. Raw monitor transition will not work");
   59.13 -  JavaThread *current_java_thread = JavaThread::current();
   59.14 -  assert(current_java_thread->thread_state() == _thread_in_vm, "Must be in vm");
   59.15 -  {
   59.16 -    ThreadBlockInVM __tbivm(current_java_thread);
   59.17 -    for(int i=0; i< count(); i++) {
   59.18 -      JvmtiRawMonitor *rmonitor = monitors()->at(i);
   59.19 -      int r = rmonitor->raw_enter(current_java_thread);
   59.20 -      assert(r == ObjectMonitor::OM_OK, "raw_enter should have worked");
   59.21 -    }
   59.22 -  }
   59.23 -  // pending monitors are converted to real monitor so delete them all.
   59.24 -  dispose();
   59.25 -}
   59.26 -
   59.27  //
   59.28  // class JvmtiAgentThread
   59.29  //
   59.30 @@ -216,57 +196,6 @@
   59.31    }
   59.32  }
   59.33  
   59.34 -
   59.35 -//
   59.36 -// class JvmtiRawMonitor
   59.37 -//
   59.38 -
   59.39 -JvmtiRawMonitor::JvmtiRawMonitor(const char *name) {
   59.40 -#ifdef ASSERT
   59.41 -  _name = strcpy(NEW_C_HEAP_ARRAY(char, strlen(name) + 1), name);
   59.42 -#else
   59.43 -  _name = NULL;
   59.44 -#endif
   59.45 -  _magic = JVMTI_RM_MAGIC;
   59.46 -}
   59.47 -
   59.48 -JvmtiRawMonitor::~JvmtiRawMonitor() {
   59.49 -#ifdef ASSERT
   59.50 -  FreeHeap(_name);
   59.51 -#endif
   59.52 -  _magic = 0;
   59.53 -}
   59.54 -
   59.55 -
   59.56 -bool
   59.57 -JvmtiRawMonitor::is_valid() {
   59.58 -  int value = 0;
   59.59 -
   59.60 -  // This object might not be a JvmtiRawMonitor so we can't assume
   59.61 -  // the _magic field is properly aligned. Get the value in a safe
   59.62 -  // way and then check against JVMTI_RM_MAGIC.
   59.63 -
   59.64 -  switch (sizeof(_magic)) {
   59.65 -  case 2:
   59.66 -    value = Bytes::get_native_u2((address)&_magic);
   59.67 -    break;
   59.68 -
   59.69 -  case 4:
   59.70 -    value = Bytes::get_native_u4((address)&_magic);
   59.71 -    break;
   59.72 -
   59.73 -  case 8:
   59.74 -    value = Bytes::get_native_u8((address)&_magic);
   59.75 -    break;
   59.76 -
   59.77 -  default:
   59.78 -    guarantee(false, "_magic field is an unexpected size");
   59.79 -  }
   59.80 -
   59.81 -  return value == JVMTI_RM_MAGIC;
   59.82 -}
   59.83 -
   59.84 -
   59.85  //
   59.86  // class JvmtiBreakpoint
   59.87  //

    60.1 --- a/src/share/vm/prims/jvmtiImpl.hpp	Thu Nov 04 15:19:16 2010 -0700
    60.2 +++ b/src/share/vm/prims/jvmtiImpl.hpp	Thu Nov 04 16:17:54 2010 -0700
    60.3 @@ -26,7 +26,6 @@
    60.4  // Forward Declarations
    60.5  //
    60.6  
    60.7 -class JvmtiRawMonitor;
    60.8  class JvmtiBreakpoint;
    60.9  class JvmtiBreakpoints;
   60.10  
   60.11 @@ -327,76 +326,6 @@
   60.12      return false;
   60.13  }
   60.14  
   60.15 -
   60.16 -///////////////////////////////////////////////////////////////
   60.17 -//
   60.18 -// class JvmtiRawMonitor
   60.19 -//
   60.20 -// Used by JVMTI methods: All RawMonitor methods (CreateRawMonitor, EnterRawMonitor, etc.)
   60.21 -//
   60.22 -// Wrapper for ObjectMonitor class that saves the Monitor's name
   60.23 -//
   60.24 -
   60.25 -class JvmtiRawMonitor : public ObjectMonitor  {
   60.26 -private:
   60.27 -  int           _magic;
   60.28 -  char *        _name;
   60.29 -  // JVMTI_RM_MAGIC is set in contructor and unset in destructor.
   60.30 -  enum { JVMTI_RM_MAGIC = (int)(('T' << 24) | ('I' << 16) | ('R' << 8) | 'M') };
   60.31 -
   60.32 -public:
   60.33 -  JvmtiRawMonitor(const char *name);
   60.34 -  ~JvmtiRawMonitor();
   60.35 -  int            magic()   { return _magic;  }
   60.36 -  const char *get_name()   { return _name; }
   60.37 -  bool        is_valid();
   60.38 -};
   60.39 -
   60.40 -// Onload pending raw monitors
   60.41 -// Class is used to cache onload or onstart monitor enter
   60.42 -// which will transition into real monitor when
   60.43 -// VM is fully initialized.
   60.44 -class JvmtiPendingMonitors : public AllStatic {
   60.45 -
   60.46 -private:
   60.47 -  static GrowableArray<JvmtiRawMonitor*> *_monitors; // Cache raw monitor enter
   60.48 -
   60.49 -  inline static GrowableArray<JvmtiRawMonitor*>* monitors() { return _monitors; }
   60.50 -
   60.51 -  static void dispose() {
   60.52 -    delete monitors();
   60.53 -  }
   60.54 -
   60.55 -public:
   60.56 -  static void enter(JvmtiRawMonitor *monitor) {
   60.57 -    monitors()->append(monitor);
   60.58 -  }
   60.59 -
   60.60 -  static int count() {
   60.61 -    return monitors()->length();
   60.62 -  }
   60.63 -
   60.64 -  static void destroy(JvmtiRawMonitor *monitor) {
   60.65 -    while (monitors()->contains(monitor)) {
   60.66 -      monitors()->remove(monitor);
   60.67 -    }
   60.68 -  }
   60.69 -
   60.70 -  // Return false if monitor is not found in the list.
   60.71 -  static bool exit(JvmtiRawMonitor *monitor) {
   60.72 -    if (monitors()->contains(monitor)) {
   60.73 -      monitors()->remove(monitor);
   60.74 -      return true;
   60.75 -    } else {
   60.76 -      return false;
   60.77 -    }
   60.78 -  }
   60.79 -
   60.80 -  static void transition_raw_monitors();
   60.81 -};
   60.82 -
   60.83 -
   60.84 -
   60.85  ///////////////////////////////////////////////////////////////
   60.86  // The get/set local operations must only be done by the VM thread
   60.87  // because the interpreter version needs to access oop maps, which can

    61.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    61.2 +++ b/src/share/vm/prims/jvmtiRawMonitor.cpp	Thu Nov 04 16:17:54 2010 -0700
    61.3 @@ -0,0 +1,420 @@
    61.4 +/*
    61.5 + * Copyright (c) 2003, 2007, Oracle and/or its affiliates. All rights reserved.
    61.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    61.7 + *
    61.8 + * This code is free software; you can redistribute it and/or modify it
    61.9 + * under the terms of the GNU General Public License version 2 only, as
   61.10 + * published by the Free Software Foundation.
   61.11 + *
   61.12 + * This code is distributed in the hope that it will be useful, but WITHOUT
   61.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   61.14 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   61.15 + * version 2 for more details (a copy is included in the LICENSE file that
   61.16 + * accompanied this code).
   61.17 + *
   61.18 + * You should have received a copy of the GNU General Public License version
   61.19 + * 2 along with this work; if not, write to the Free Software Foundation,
   61.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   61.21 + *
   61.22 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   61.23 + * or visit www.oracle.com if you need additional information or have any
   61.24 + * questions.
   61.25 + *
   61.26 + */
   61.27 +
   61.28 +# include "incls/_precompiled.incl"
   61.29 +# include "incls/_jvmtiRawMonitor.cpp.incl"
   61.30 +
   61.31 +GrowableArray<JvmtiRawMonitor*> *JvmtiPendingMonitors::_monitors = new (ResourceObj::C_HEAP) GrowableArray<JvmtiRawMonitor*>(1,true);
   61.32 +
   61.33 +void JvmtiPendingMonitors::transition_raw_monitors() {
   61.34 +  assert((Threads::number_of_threads()==1),
   61.35 +         "Java thread has not created yet or more than one java thread \
   61.36 +is running. Raw monitor transition will not work");
   61.37 +  JavaThread *current_java_thread = JavaThread::current();
   61.38 +  assert(current_java_thread->thread_state() == _thread_in_vm, "Must be in vm");
   61.39 +  {
   61.40 +    ThreadBlockInVM __tbivm(current_java_thread);
   61.41 +    for(int i=0; i< count(); i++) {
   61.42 +      JvmtiRawMonitor *rmonitor = monitors()->at(i);
   61.43 +      int r = rmonitor->raw_enter(current_java_thread);
   61.44 +      assert(r == ObjectMonitor::OM_OK, "raw_enter should have worked");
   61.45 +    }
   61.46 +  }
   61.47 +  // pending monitors are converted to real monitor so delete them all.
   61.48 +  dispose();
   61.49 +}
   61.50 +
   61.51 +//
   61.52 +// class JvmtiRawMonitor
   61.53 +//
   61.54 +
   61.55 +JvmtiRawMonitor::JvmtiRawMonitor(const char *name) {
   61.56 +#ifdef ASSERT
   61.57 +  _name = strcpy(NEW_C_HEAP_ARRAY(char, strlen(name) + 1), name);
   61.58 +#else
   61.59 +  _name = NULL;
   61.60 +#endif
   61.61 +  _magic = JVMTI_RM_MAGIC;
   61.62 +}
   61.63 +
   61.64 +JvmtiRawMonitor::~JvmtiRawMonitor() {
   61.65 +#ifdef ASSERT
   61.66 +  FreeHeap(_name);
   61.67 +#endif
   61.68 +  _magic = 0;
   61.69 +}
   61.70 +
   61.71 +
   61.72 +bool
   61.73 +JvmtiRawMonitor::is_valid() {
   61.74 +  int value = 0;
   61.75 +
   61.76 +  // This object might not be a JvmtiRawMonitor so we can't assume
   61.77 +  // the _magic field is properly aligned. Get the value in a safe
   61.78 +  // way and then check against JVMTI_RM_MAGIC.
   61.79 +
   61.80 +  switch (sizeof(_magic)) {
   61.81 +  case 2:
   61.82 +    value = Bytes::get_native_u2((address)&_magic);
   61.83 +    break;
   61.84 +
   61.85 +  case 4:
   61.86 +    value = Bytes::get_native_u4((address)&_magic);
   61.87 +    break;
   61.88 +
   61.89 +  case 8:
   61.90 +    value = Bytes::get_native_u8((address)&_magic);
   61.91 +    break;
   61.92 +
   61.93 +  default:
   61.94 +    guarantee(false, "_magic field is an unexpected size");
   61.95 +  }
   61.96 +
   61.97 +  return value == JVMTI_RM_MAGIC;
   61.98 +}
   61.99 +
  61.100 +// -------------------------------------------------------------------------
  61.101 +// The raw monitor subsystem is entirely distinct from normal
  61.102 +// java-synchronization or jni-synchronization.  raw monitors are not
  61.103 +// associated with objects.  They can be implemented in any manner
  61.104 +// that makes sense.  The original implementors decided to piggy-back
  61.105 +// the raw-monitor implementation on the existing Java objectMonitor mechanism.
  61.106 +// This flaw needs to fixed.  We should reimplement raw monitors as sui-generis.
  61.107 +// Specifically, we should not implement raw monitors via java monitors.
  61.108 +// Time permitting, we should disentangle and deconvolve the two implementations
  61.109 +// and move the resulting raw monitor implementation over to the JVMTI directories.
  61.110 +// Ideally, the raw monitor implementation would be built on top of
  61.111 +// park-unpark and nothing else.
  61.112 +//
  61.113 +// raw monitors are used mainly by JVMTI
  61.114 +// The raw monitor implementation borrows the ObjectMonitor structure,
  61.115 +// but the operators are degenerate and extremely simple.
  61.116 +//
  61.117 +// Mixed use of a single objectMonitor instance -- as both a raw monitor
  61.118 +// and a normal java monitor -- is not permissible.
  61.119 +//
  61.120 +// Note that we use the single RawMonitor_lock to protect queue operations for
  61.121 +// _all_ raw monitors.  This is a scalability impediment, but since raw monitor usage
  61.122 +// is deprecated and rare, this is not of concern.  The RawMonitor_lock can not
  61.123 +// be held indefinitely.  The critical sections must be short and bounded.
  61.124 +//
  61.125 +// -------------------------------------------------------------------------
  61.126 +
  61.127 +int JvmtiRawMonitor::SimpleEnter (Thread * Self) {
  61.128 +  for (;;) {
  61.129 +    if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
  61.130 +       return OS_OK ;
  61.131 +    }
  61.132 +
  61.133 +    ObjectWaiter Node (Self) ;
  61.134 +    Self->_ParkEvent->reset() ;     // strictly optional
  61.135 +    Node.TState = ObjectWaiter::TS_ENTER ;
  61.136 +
  61.137 +    RawMonitor_lock->lock_without_safepoint_check() ;
  61.138 +    Node._next  = _EntryList ;
  61.139 +    _EntryList  = &Node ;
  61.140 +    OrderAccess::fence() ;
  61.141 +    if (_owner == NULL && Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
  61.142 +        _EntryList = Node._next ;
  61.143 +        RawMonitor_lock->unlock() ;
  61.144 +        return OS_OK ;
  61.145 +    }
  61.146 +    RawMonitor_lock->unlock() ;
  61.147 +    while (Node.TState == ObjectWaiter::TS_ENTER) {
  61.148 +       Self->_ParkEvent->park() ;
  61.149 +    }
  61.150 +  }
  61.151 +}
  61.152 +
  61.153 +int JvmtiRawMonitor::SimpleExit (Thread * Self) {
  61.154 +  guarantee (_owner == Self, "invariant") ;
  61.155 +  OrderAccess::release_store_ptr (&_owner, NULL) ;
  61.156 +  OrderAccess::fence() ;
  61.157 +  if (_EntryList == NULL) return OS_OK ;
  61.158 +  ObjectWaiter * w ;
  61.159 +
  61.160 +  RawMonitor_lock->lock_without_safepoint_check() ;
  61.161 +  w = _EntryList ;
  61.162 +  if (w != NULL) {
  61.163 +      _EntryList = w->_next ;
  61.164 +  }
  61.165 +  RawMonitor_lock->unlock() ;
  61.166 +  if (w != NULL) {
  61.167 +      guarantee (w ->TState == ObjectWaiter::TS_ENTER, "invariant") ;
  61.168 +      ParkEvent * ev = w->_event ;
  61.169 +      w->TState = ObjectWaiter::TS_RUN ;
  61.170 +      OrderAccess::fence() ;
  61.171 +      ev->unpark() ;
  61.172 +  }
  61.173 +  return OS_OK ;
  61.174 +}
  61.175 +
  61.176 +int JvmtiRawMonitor::SimpleWait (Thread * Self, jlong millis) {
  61.177 +  guarantee (_owner == Self  , "invariant") ;
  61.178 +  guarantee (_recursions == 0, "invariant") ;
  61.179 +
  61.180 +  ObjectWaiter Node (Self) ;
  61.181 +  Node._notified = 0 ;
  61.182 +  Node.TState    = ObjectWaiter::TS_WAIT ;
  61.183 +
  61.184 +  RawMonitor_lock->lock_without_safepoint_check() ;
  61.185 +  Node._next     = _WaitSet ;
  61.186 +  _WaitSet       = &Node ;
  61.187 +  RawMonitor_lock->unlock() ;
  61.188 +
  61.189 +  SimpleExit (Self) ;
  61.190 +  guarantee (_owner != Self, "invariant") ;
  61.191 +
  61.192 +  int ret = OS_OK ;
  61.193 +  if (millis <= 0) {
  61.194 +    Self->_ParkEvent->park();
  61.195 +  } else {
  61.196 +    ret = Self->_ParkEvent->park(millis);
  61.197 +  }
  61.198 +
  61.199 +  // If thread still resides on the waitset then unlink it.
  61.200 +  // Double-checked locking -- the usage is safe in this context
  61.201 +  // as we TState is volatile and the lock-unlock operators are
  61.202 +  // serializing (barrier-equivalent).
  61.203 +
  61.204 +  if (Node.TState == ObjectWaiter::TS_WAIT) {
  61.205 +    RawMonitor_lock->lock_without_safepoint_check() ;
  61.206 +    if (Node.TState == ObjectWaiter::TS_WAIT) {
  61.207 +      // Simple O(n) unlink, but performance isn't critical here.
  61.208 +      ObjectWaiter * p ;
  61.209 +      ObjectWaiter * q = NULL ;
  61.210 +      for (p = _WaitSet ; p != &Node; p = p->_next) {
  61.211 +         q = p ;
  61.212 +      }
  61.213 +      guarantee (p == &Node, "invariant") ;
  61.214 +      if (q == NULL) {
  61.215 +        guarantee (p == _WaitSet, "invariant") ;
  61.216 +        _WaitSet = p->_next ;
  61.217 +      } else {
  61.218 +        guarantee (p == q->_next, "invariant") ;
  61.219 +        q->_next = p->_next ;
  61.220 +      }
  61.221 +      Node.TState = ObjectWaiter::TS_RUN ;
  61.222 +    }
  61.223 +    RawMonitor_lock->unlock() ;
  61.224 +  }
  61.225 +
  61.226 +  guarantee (Node.TState == ObjectWaiter::TS_RUN, "invariant") ;
  61.227 +  SimpleEnter (Self) ;
  61.228 +
  61.229 +  guarantee (_owner == Self, "invariant") ;
  61.230 +  guarantee (_recursions == 0, "invariant") ;
  61.231 +  return ret ;
  61.232 +}
  61.233 +
  61.234 +int JvmtiRawMonitor::SimpleNotify (Thread * Self, bool All) {
  61.235 +  guarantee (_owner == Self, "invariant") ;
  61.236 +  if (_WaitSet == NULL) return OS_OK ;
  61.237 +
  61.238 +  // We have two options:
  61.239 +  // A. Transfer the threads from the WaitSet to the EntryList
  61.240 +  // B. Remove the thread from the WaitSet and unpark() it.
  61.241 +  //
  61.242 +  // We use (B), which is crude and results in lots of futile
  61.243 +  // context switching.  In particular (B) induces lots of contention.
  61.244 +
  61.245 +  ParkEvent * ev = NULL ;       // consider using a small auto array ...
  61.246 +  RawMonitor_lock->lock_without_safepoint_check() ;
  61.247 +  for (;;) {
  61.248 +      ObjectWaiter * w = _WaitSet ;
  61.249 +      if (w == NULL) break ;
  61.250 +      _WaitSet = w->_next ;
  61.251 +      if (ev != NULL) { ev->unpark(); ev = NULL; }
  61.252 +      ev = w->_event ;
  61.253 +      OrderAccess::loadstore() ;
  61.254 +      w->TState = ObjectWaiter::TS_RUN ;
  61.255 +      OrderAccess::storeload();
  61.256 +      if (!All) break ;
  61.257 +  }
  61.258 +  RawMonitor_lock->unlock() ;
  61.259 +  if (ev != NULL) ev->unpark();
  61.260 +  return OS_OK ;
  61.261 +}
  61.262 +
  61.263 +// Any JavaThread will enter here with state _thread_blocked
  61.264 +int JvmtiRawMonitor::raw_enter(TRAPS) {
  61.265 +  TEVENT (raw_enter) ;
  61.266 +  void * Contended ;
  61.267 +
  61.268 +  // don't enter raw monitor if thread is being externally suspended, it will
  61.269 +  // surprise the suspender if a "suspended" thread can still enter monitor
  61.270 +  JavaThread * jt = (JavaThread *)THREAD;
  61.271 +  if (THREAD->is_Java_thread()) {
  61.272 +    jt->SR_lock()->lock_without_safepoint_check();
  61.273 +    while (jt->is_external_suspend()) {
  61.274 +      jt->SR_lock()->unlock();
  61.275 +      jt->java_suspend_self();
  61.276 +      jt->SR_lock()->lock_without_safepoint_check();
  61.277 +    }
  61.278 +    // guarded by SR_lock to avoid racing with new external suspend requests.
  61.279 +    Contended = Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) ;
  61.280 +    jt->SR_lock()->unlock();
  61.281 +  } else {
  61.282 +    Contended = Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) ;
  61.283 +  }
  61.284 +
  61.285 +  if (Contended == THREAD) {
  61.286 +     _recursions ++ ;
  61.287 +     return OM_OK ;
  61.288 +  }
  61.289 +
  61.290 +  if (Contended == NULL) {
  61.291 +     guarantee (_owner == THREAD, "invariant") ;
  61.292 +     guarantee (_recursions == 0, "invariant") ;
  61.293 +     return OM_OK ;
  61.294 +  }
  61.295 +
  61.296 +  THREAD->set_current_pending_monitor(this);
  61.297 +
  61.298 +  if (!THREAD->is_Java_thread()) {
  61.299 +     // No other non-Java threads besides VM thread would acquire
  61.300 +     // a raw monitor.
  61.301 +     assert(THREAD->is_VM_thread(), "must be VM thread");
  61.302 +     SimpleEnter (THREAD) ;
  61.303 +   } else {
  61.304 +     guarantee (jt->thread_state() == _thread_blocked, "invariant") ;
  61.305 +     for (;;) {
  61.306 +       jt->set_suspend_equivalent();
  61.307 +       // cleared by handle_special_suspend_equivalent_condition() or
  61.308 +       // java_suspend_self()
  61.309 +       SimpleEnter (THREAD) ;
  61.310 +
  61.311 +       // were we externally suspended while we were waiting?
  61.312 +       if (!jt->handle_special_suspend_equivalent_condition()) break ;
  61.313 +
  61.314 +       // This thread was externally suspended
  61.315 +       //
  61.316 +       // This logic isn't needed for JVMTI raw monitors,
  61.317 +       // but doesn't hurt just in case the suspend rules change. This
  61.318 +           // logic is needed for the JvmtiRawMonitor.wait() reentry phase.
  61.319 +           // We have reentered the contended monitor, but while we were
  61.320 +           // waiting another thread suspended us. We don't want to reenter
  61.321 +           // the monitor while suspended because that would surprise the
  61.322 +           // thread that suspended us.
  61.323 +           //
  61.324 +           // Drop the lock -
  61.325 +       SimpleExit (THREAD) ;
  61.326 +
  61.327 +           jt->java_suspend_self();
  61.328 +         }
  61.329 +
  61.330 +     assert(_owner == THREAD, "Fatal error with monitor owner!");
  61.331 +     assert(_recursions == 0, "Fatal error with monitor recursions!");
  61.332 +  }
  61.333 +
  61.334 +  THREAD->set_current_pending_monitor(NULL);
  61.335 +  guarantee (_recursions == 0, "invariant") ;
  61.336 +  return OM_OK;
  61.337 +}
  61.338 +
  61.339 +// Used mainly for JVMTI raw monitor implementation
  61.340 +// Also used for JvmtiRawMonitor::wait().
  61.341 +int JvmtiRawMonitor::raw_exit(TRAPS) {
  61.342 +  TEVENT (raw_exit) ;
  61.343 +  if (THREAD != _owner) {
  61.344 +    return OM_ILLEGAL_MONITOR_STATE;
  61.345 +  }
  61.346 +  if (_recursions > 0) {
  61.347 +    --_recursions ;
  61.348 +    return OM_OK ;
  61.349 +  }
  61.350 +
  61.351 +  void * List = _EntryList ;
  61.352 +  SimpleExit (THREAD) ;
  61.353 +
  61.354 +  return OM_OK;
  61.355 +}
  61.356 +
  61.357 +// Used for JVMTI raw monitor implementation.
  61.358 +// All JavaThreads will enter here with state _thread_blocked
  61.359 +
  61.360 +int JvmtiRawMonitor::raw_wait(jlong millis, bool interruptible, TRAPS) {
  61.361 +  TEVENT (raw_wait) ;
  61.362 +  if (THREAD != _owner) {
  61.363 +    return OM_ILLEGAL_MONITOR_STATE;
  61.364 +  }
  61.365 +
  61.366 +  // To avoid spurious wakeups we reset the parkevent -- This is strictly optional.
  61.367 +  // The caller must be able to tolerate spurious returns from raw_wait().
  61.368 +  THREAD->_ParkEvent->reset() ;
  61.369 +  OrderAccess::fence() ;
  61.370 +
  61.371 +  // check interrupt event
  61.372 +  if (interruptible && Thread::is_interrupted(THREAD, true)) {
  61.373 +    return OM_INTERRUPTED;
  61.374 +  }
  61.375 +
  61.376 +  intptr_t save = _recursions ;
  61.377 +  _recursions = 0 ;
  61.378 +  _waiters ++ ;
  61.379 +  if (THREAD->is_Java_thread()) {
  61.380 +    guarantee (((JavaThread *) THREAD)->thread_state() == _thread_blocked, "invariant") ;
  61.381 +    ((JavaThread *)THREAD)->set_suspend_equivalent();
  61.382 +  }
  61.383 +  int rv = SimpleWait (THREAD, millis) ;
  61.384 +  _recursions = save ;
  61.385 +  _waiters -- ;
  61.386 +
  61.387 +  guarantee (THREAD == _owner, "invariant") ;
  61.388 +  if (THREAD->is_Java_thread()) {
  61.389 +     JavaThread * jSelf = (JavaThread *) THREAD ;
  61.390 +     for (;;) {
  61.391 +        if (!jSelf->handle_special_suspend_equivalent_condition()) break ;
  61.392 +        SimpleExit (THREAD) ;
  61.393 +        jSelf->java_suspend_self();
  61.394 +        SimpleEnter (THREAD) ;
  61.395 +        jSelf->set_suspend_equivalent() ;
  61.396 +     }
  61.397 +  }
  61.398 +  guarantee (THREAD == _owner, "invariant") ;
  61.399 +
  61.400 +  if (interruptible && Thread::is_interrupted(THREAD, true)) {
  61.401 +    return OM_INTERRUPTED;
  61.402 +  }
  61.403 +  return OM_OK ;
  61.404 +}
  61.405 +
  61.406 +int JvmtiRawMonitor::raw_notify(TRAPS) {
  61.407 +  TEVENT (raw_notify) ;
  61.408 +  if (THREAD != _owner) {
  61.409 +    return OM_ILLEGAL_MONITOR_STATE;
  61.410 +  }
  61.411 +  SimpleNotify (THREAD, false) ;
  61.412 +  return OM_OK;
  61.413 +}
  61.414 +
  61.415 +int JvmtiRawMonitor::raw_notifyAll(TRAPS) {
  61.416 +  TEVENT (raw_notifyAll) ;
  61.417 +  if (THREAD != _owner) {
  61.418 +    return OM_ILLEGAL_MONITOR_STATE;
  61.419 +  }
  61.420 +  SimpleNotify (THREAD, true) ;
  61.421 +  return OM_OK;
  61.422 +}
  61.423 +