Mercurial > hg > truffle
changeset 6156:6d2c830e025d
Merge
| author | asaha |
|---|---|
| date | Tue, 08 May 2012 11:29:21 -0700 |
| parents | 5142b5110214 (diff) d558e01a72c0 (current diff) |
| children | 84e198dc2474 |
| files | |
| diffstat | 153 files changed, 2751 insertions(+), 3415 deletions(-) [+] |
line wrap: on
line diff
--- a/.hgtags Thu May 03 15:37:46 2012 -0400 +++ b/.hgtags Tue May 08 11:29:21 2012 -0700 @@ -237,3 +237,8 @@ 25410a347ebb0bef166c4338a90d9dea82463a20 jdk8-b32 cd47da9383cd932cb2b659064057feafa2a91134 hs24-b06 785bcf415ead2eaa5f6677aaf528481008140bac jdk8-b33 +7c6aba65acd2c334f1c3512b574f9038cddac24b hs24-b07 +f284b08835584517c1ca3dd67341f569e763841f jdk8-b34 +f621660a297baa48fab9dca28e99d318826e8304 jdk8-b35 +dff6e3459210f8dd0430b9b03ccc99280560da30 hs24-b08 +50b4400ca1ecb2ac2fde35f5e53ec8f04b86be7f jdk8-b36
--- a/agent/src/os/linux/ps_core.c Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/os/linux/ps_core.c Tue May 08 11:29:21 2012 -0700 @@ -440,7 +440,7 @@ int j = 0; print_debug("---- sorted virtual address map ----\n"); for (j = 0; j < ph->core->num_maps; j++) { - print_debug("base = 0x%lx\tsize = %d\n", ph->core->map_array[j]->vaddr, + print_debug("base = 0x%lx\tsize = %zd\n", ph->core->map_array[j]->vaddr, ph->core->map_array[j]->memsz); } }
--- a/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -42,7 +42,7 @@ public class HeapRegionSeq extends VMObject { // HeapRegion** _regions; static private AddressField regionsField; - // size_t _length; + // uint _length; static private CIntegerField lengthField; static {
--- a/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSetBase.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSetBase.java Tue May 08 11:29:21 2012 -0700 @@ -40,9 +40,9 @@ // Mirror class for HeapRegionSetBase. Represents a group of regions. public class HeapRegionSetBase extends VMObject { - // size_t _length; + // uint _length; static private CIntegerField lengthField; - // size_t _region_num; + // uint _region_num; static private CIntegerField regionNumField; // size_t _total_used_bytes; static private CIntegerField totalUsedBytesField;
--- a/agent/src/share/classes/sun/jvm/hotspot/jdi/VirtualMachineImpl.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/jdi/VirtualMachineImpl.java Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -889,15 +889,9 @@ Klass kls = ((ReferenceTypeImpl)type).ref(); if (kls instanceof InstanceKlass) { InstanceKlass ik = (InstanceKlass) kls; - if (ik.isInterface()) { - if (ik.nofImplementors() == 0L) { - return new ArrayList(0); - } - } else { - // if the Klass is final or if there are no subklasses loaded yet - if (ik.getAccessFlagsObj().isFinal() || ik.getSubklassKlass() == null) { - includeSubtypes = false; - } + // if the Klass is final or if there are no subklasses loaded yet + if (ik.getAccessFlagsObj().isFinal() || ik.getSubklassKlass() == null) { + includeSubtypes = false; } } else { // no subtypes for primitive array types
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayData.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayData.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/BranchData.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/BranchData.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/CounterData.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/CounterData.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/DataLayout.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/DataLayout.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -52,7 +52,6 @@ private static int HIGH_OFFSET; private static int GENERIC_SIGNATURE_INDEX_OFFSET; private static int FIELD_SLOTS; - public static int IMPLEMENTORS_LIMIT; // ClassState constants private static int CLASS_STATE_UNPARSABLE_BY_GC; @@ -70,13 +69,6 @@ methodOrdering = new OopField(type.getOopField("_method_ordering"), Oop.getHeaderSize()); localInterfaces = new OopField(type.getOopField("_local_interfaces"), Oop.getHeaderSize()); transitiveInterfaces = new OopField(type.getOopField("_transitive_interfaces"), Oop.getHeaderSize()); - nofImplementors = new CIntField(type.getCIntegerField("_nof_implementors"), Oop.getHeaderSize()); - IMPLEMENTORS_LIMIT = db.lookupIntConstant("instanceKlass::implementors_limit").intValue(); - implementors = new OopField[IMPLEMENTORS_LIMIT]; - for (int i = 0; i < IMPLEMENTORS_LIMIT; i++) { - long arrayOffset = Oop.getHeaderSize() + (i * db.getAddressSize()); - implementors[i] = new OopField(type.getOopField("_implementors[0]"), arrayOffset); - } fields = new OopField(type.getOopField("_fields"), Oop.getHeaderSize()); javaFieldsCount = new CIntField(type.getCIntegerField("_java_fields_count"), Oop.getHeaderSize()); constants = new OopField(type.getOopField("_constants"), Oop.getHeaderSize()); @@ -136,8 +128,6 @@ private static OopField methodOrdering; private static OopField localInterfaces; private static OopField transitiveInterfaces; - private static CIntField nofImplementors; - private static OopField[] implementors; private static OopField fields; private static CIntField javaFieldsCount; private static OopField constants; @@ -317,9 +307,6 @@ public TypeArray getMethodOrdering() { return (TypeArray) methodOrdering.getValue(this); } public ObjArray getLocalInterfaces() { return (ObjArray) localInterfaces.getValue(this); } public ObjArray getTransitiveInterfaces() { return (ObjArray) transitiveInterfaces.getValue(this); } - public long nofImplementors() { return nofImplementors.getValue(this); } - public Klass getImplementor() { return (Klass) implementors[0].getValue(this); } - public Klass getImplementor(int i) { return (Klass) implementors[i].getValue(this); } public TypeArray getFields() { return (TypeArray) fields.getValue(this); } public int getJavaFieldsCount() { return (int) javaFieldsCount.getValue(this); } public int getAllFieldsCount() { return (int)getFields().getLength() / FIELD_SLOTS; } @@ -527,9 +514,6 @@ visitor.doOop(methodOrdering, true); visitor.doOop(localInterfaces, true); visitor.doOop(transitiveInterfaces, true); - visitor.doCInt(nofImplementors, true); - for (int i = 0; i < IMPLEMENTORS_LIMIT; i++) - visitor.doOop(implementors[i], true); visitor.doOop(fields, true); visitor.doOop(constants, true); visitor.doOop(classLoader, true);
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/JumpData.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/JumpData.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/MultiBranchData.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/MultiBranchData.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ReceiverTypeData.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ReceiverTypeData.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/VirtualCallData.java Thu May 03 15:37:46 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/VirtualCallData.java Tue May 08 11:29:21 2012 -0700 @@ -1,24 +1,24 @@ /* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * - * - * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * - * - * - * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. * - * - * - * - * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). * - * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * - * - * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. * */
--- a/make/bsd/makefiles/wb.make Thu May 03 15:37:46 2012 -0400 +++ b/make/bsd/makefiles/wb.make Tue May 08 11:29:21 2012 -0700 @@ -36,7 +36,7 @@ $(patsubst %.java,%.class,$(WB_JAVA_SRCS))) $(WB_JAVA_CLASSDIR)/%.class: $(WBSRCDIR)/%.java $(WB_JAVA_CLASSDIR) - $(REMOTE) $(COMPILE.JAVAC) -nowarn -d $(WB_JAVA_CLASSDIR) $< + $(REMOTE) $(COMPILE.JAVAC) -sourcepath $(WBSRCDIR) -nowarn -d $(WB_JAVA_CLASSDIR) $< $(WB_JAR): $(WB_JAVA_CLASSES) $(QUIETLY) $(REMOTE) $(RUN.JAR) cf $@ -C $(WB_JAVA_CLASSDIR)/ .
--- a/make/hotspot_version Thu May 03 15:37:46 2012 -0400 +++ b/make/hotspot_version Tue May 08 11:29:21 2012 -0700 @@ -35,7 +35,7 @@ HS_MAJOR_VER=24 HS_MINOR_VER=0 -HS_BUILD_NUMBER=06 +HS_BUILD_NUMBER=08 JDK_MAJOR_VER=1 JDK_MINOR_VER=8
--- a/make/linux/makefiles/wb.make Thu May 03 15:37:46 2012 -0400 +++ b/make/linux/makefiles/wb.make Tue May 08 11:29:21 2012 -0700 @@ -36,7 +36,7 @@ $(patsubst %.java,%.class,$(WB_JAVA_SRCS))) $(WB_JAVA_CLASSDIR)/%.class: $(WBSRCDIR)/%.java $(WB_JAVA_CLASSDIR) - $(REMOTE) $(COMPILE.JAVAC) -nowarn -d $(WB_JAVA_CLASSDIR) $< + $(REMOTE) $(COMPILE.JAVAC) -sourcepath $(WBSRCDIR) -nowarn -d $(WB_JAVA_CLASSDIR) $< $(WB_JAR): $(WB_JAVA_CLASSES) $(QUIETLY) $(REMOTE) $(RUN.JAR) cf $@ -C $(WB_JAVA_CLASSDIR)/ .
--- a/make/solaris/makefiles/wb.make Thu May 03 15:37:46 2012 -0400 +++ b/make/solaris/makefiles/wb.make Tue May 08 11:29:21 2012 -0700 @@ -36,7 +36,7 @@ $(patsubst %.java,%.class,$(WB_JAVA_SRCS))) $(WB_JAVA_CLASSDIR)/%.class: $(WBSRCDIR)/%.java $(WB_JAVA_CLASSDIR) - $(REMOTE) $(COMPILE.JAVAC) -nowarn -d $(WB_JAVA_CLASSDIR) $< + $(REMOTE) $(COMPILE.JAVAC) -sourcepath $(WBSRCDIR) -nowarn -d $(WB_JAVA_CLASSDIR) $< $(WB_JAR): $(WB_JAVA_CLASSES) $(QUIETLY) $(REMOTE) $(RUN.JAR) cf $@ -C $(WB_JAVA_CLASSDIR)/ .
--- a/make/windows/create_obj_files.sh Thu May 03 15:37:46 2012 -0400 +++ b/make/windows/create_obj_files.sh Tue May 08 11:29:21 2012 -0700 @@ -80,6 +80,8 @@ BASE_PATHS="${BASE_PATHS} ${ALTSRC}/share/vm/jfr" fi +BASE_PATHS="${BASE_PATHS} ${COMMONSRC}/share/vm/prims/wbtestmethods" + CORE_PATHS="${BASE_PATHS}" # shared is already in BASE_PATHS. Should add vm/memory but that one is also in BASE_PATHS. if [ -d "${ALTSRC}/share/vm/gc_implementation" ]; then
--- a/make/windows/makefiles/projectcreator.make Thu May 03 15:37:46 2012 -0400 +++ b/make/windows/makefiles/projectcreator.make Tue May 08 11:29:21 2012 -0700 @@ -51,6 +51,7 @@ -relativeInclude src\closed\cpu\$(Platform_arch)\vm \ -relativeInclude src\share\vm \ -relativeInclude src\share\vm\precompiled \ + -relativeInclude src\share\vm\prims\wbtestmethods \ -relativeInclude src\share\vm\prims \ -relativeInclude src\os\windows\vm \ -relativeInclude src\os_cpu\windows_$(Platform_arch)\vm \
--- a/make/windows/makefiles/vm.make Thu May 03 15:37:46 2012 -0400 +++ b/make/windows/makefiles/vm.make Tue May 08 11:29:21 2012 -0700 @@ -172,6 +172,7 @@ VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/memory VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/oops VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/prims +VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/prims/wbtestmethods VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/runtime VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/services VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/trace @@ -269,6 +270,9 @@ {$(COMMONSRC)\share\vm\prims}.cpp.obj:: $(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $< +{$(COMMONSRC)\share\vm\prims\wbtestmethods}.cpp.obj:: + $(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $< + {$(COMMONSRC)\share\vm\runtime}.cpp.obj:: $(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $< @@ -349,6 +353,9 @@ {$(ALTSRC)\share\vm\prims}.cpp.obj:: $(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $< +{$(ALTSRC)\share\vm\prims\wbtestmethods}.cpp.obj:: + $(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $< + {$(ALTSRC)\share\vm\runtime}.cpp.obj:: $(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $<
--- a/make/windows/makefiles/wb.make Thu May 03 15:37:46 2012 -0400 +++ b/make/windows/makefiles/wb.make Tue May 08 11:29:21 2012 -0700 @@ -40,7 +40,7 @@ {$(WorkSpace)\src\share\tools\whitebox\sun\hotspot}.java.class:: - $(COMPILE_JAVAC) -d $(WB_CLASSES) $< + $(COMPILE_JAVAC) -sourcepath $(WBSRCDIR) -d $(WB_CLASSES) $< $(WB_JAR): wb_java_srcs $(RUN_JAR) cf $@ -C $(WB_CLASSES) .
--- a/src/cpu/x86/vm/assembler_x86.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/cpu/x86/vm/assembler_x86.cpp Tue May 08 11:29:21 2012 -0700 @@ -528,10 +528,12 @@ if (which == end_pc_operand) return ip + (is_64bit ? 8 : 4); // these asserts are somewhat nonsensical #ifndef _LP64 - assert(which == imm_operand || which == disp32_operand, ""); + assert(which == imm_operand || which == disp32_operand, + err_msg("which %d is_64_bit %d ip " INTPTR_FORMAT, which, is_64bit, ip)); #else assert((which == call32_operand || which == imm_operand) && is_64bit || - which == narrow_oop_operand && !is_64bit, ""); + which == narrow_oop_operand && !is_64bit, + err_msg("which %d is_64_bit %d ip " INTPTR_FORMAT, which, is_64bit, ip)); #endif // _LP64 return ip;
--- a/src/cpu/x86/vm/templateTable_x86_32.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/cpu/x86/vm/templateTable_x86_32.cpp Tue May 08 11:29:21 2012 -0700 @@ -2651,56 +2651,49 @@ // Check to see if a field modification watch has been set before we take // the time to call into the VM. Label L2; - __ mov32(rcx, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr())); - __ testl(rcx,rcx); - __ jcc(Assembler::zero, L2); - __ pop_ptr(rbx); // copy the object pointer from tos - __ verify_oop(rbx); - __ push_ptr(rbx); // put the object pointer back on tos - __ subptr(rsp, sizeof(jvalue)); // add space for a jvalue object - __ mov(rcx, rsp); - __ push_ptr(rbx); // save object pointer so we can steal rbx, - __ xorptr(rbx, rbx); - const Address lo_value(rcx, rbx, Address::times_1, 0*wordSize); - const Address hi_value(rcx, rbx, Address::times_1, 1*wordSize); - switch (bytecode()) { // load values into the jvalue object - case Bytecodes::_fast_bputfield: __ movb(lo_value, rax); break; - case Bytecodes::_fast_sputfield: __ movw(lo_value, rax); break; - case Bytecodes::_fast_cputfield: __ movw(lo_value, rax); break; - case Bytecodes::_fast_iputfield: __ movl(lo_value, rax); break; - case Bytecodes::_fast_lputfield: - NOT_LP64(__ movptr(hi_value, rdx)); - __ movptr(lo_value, rax); - break; - - // need to call fld_s() after fstp_s() to restore the value for below - case Bytecodes::_fast_fputfield: __ fstp_s(lo_value); __ fld_s(lo_value); break; - - // need to call fld_d() after fstp_d() to restore the value for below - case Bytecodes::_fast_dputfield: __ fstp_d(lo_value); __ fld_d(lo_value); break; - - // since rcx is not an object we don't call store_check() here - case Bytecodes::_fast_aputfield: __ movptr(lo_value, rax); break; - - default: ShouldNotReachHere(); - } - __ pop_ptr(rbx); // restore copy of object pointer - - // Save rax, and sometimes rdx because call_VM() will clobber them, - // then use them for JVM/DI purposes - __ push(rax); - if (bytecode() == Bytecodes::_fast_lputfield) __ push(rdx); - // access constant pool cache entry - __ get_cache_entry_pointer_at_bcp(rax, rdx, 1); - __ verify_oop(rbx); - // rbx,: object pointer copied above - // rax,: cache entry pointer - // rcx: jvalue object on the stack - __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), rbx, rax, rcx); - if (bytecode() == Bytecodes::_fast_lputfield) __ pop(rdx); // restore high value - __ pop(rax); // restore lower value - __ addptr(rsp, sizeof(jvalue)); // release jvalue object space - __ bind(L2); + __ mov32(rcx, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr())); + __ testl(rcx,rcx); + __ jcc(Assembler::zero, L2); + __ pop_ptr(rbx); // copy the object pointer from tos + __ verify_oop(rbx); + __ push_ptr(rbx); // put the object pointer back on tos + + // Save tos values before call_VM() clobbers them. Since we have + // to do it for every data type, we use the saved values as the + // jvalue object. + switch (bytecode()) { // load values into the jvalue object + case Bytecodes::_fast_aputfield: __ push_ptr(rax); break; + case Bytecodes::_fast_bputfield: // fall through + case Bytecodes::_fast_sputfield: // fall through + case Bytecodes::_fast_cputfield: // fall through + case Bytecodes::_fast_iputfield: __ push_i(rax); break; + case Bytecodes::_fast_dputfield: __ push_d(); break; + case Bytecodes::_fast_fputfield: __ push_f(); break; + case Bytecodes::_fast_lputfield: __ push_l(rax); break; + + default: + ShouldNotReachHere(); + } + __ mov(rcx, rsp); // points to jvalue on the stack + // access constant pool cache entry + __ get_cache_entry_pointer_at_bcp(rax, rdx, 1); + __ verify_oop(rbx); + // rbx,: object pointer copied above + // rax,: cache entry pointer + // rcx: jvalue object on the stack + __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), rbx, rax, rcx); + + switch (bytecode()) { // restore tos values + case Bytecodes::_fast_aputfield: __ pop_ptr(rax); break; + case Bytecodes::_fast_bputfield: // fall through + case Bytecodes::_fast_sputfield: // fall through + case Bytecodes::_fast_cputfield: // fall through + case Bytecodes::_fast_iputfield: __ pop_i(rax); break; + case Bytecodes::_fast_dputfield: __ pop_d(); break; + case Bytecodes::_fast_fputfield: __ pop_f(); break; + case Bytecodes::_fast_lputfield: __ pop_l(rax); break; + } + __ bind(L2); } }
--- a/src/cpu/x86/vm/templateTable_x86_64.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/cpu/x86/vm/templateTable_x86_64.cpp Tue May 08 11:29:21 2012 -0700 @@ -2685,26 +2685,23 @@ __ pop_ptr(rbx); // copy the object pointer from tos __ verify_oop(rbx); __ push_ptr(rbx); // put the object pointer back on tos - __ subptr(rsp, sizeof(jvalue)); // add space for a jvalue object - __ mov(c_rarg3, rsp); - const Address field(c_rarg3, 0); - + // Save tos values before call_VM() clobbers them. Since we have + // to do it for every data type, we use the saved values as the + // jvalue object. switch (bytecode()) { // load values into the jvalue object - case Bytecodes::_fast_aputfield: __ movq(field, rax); break; - case Bytecodes::_fast_lputfield: __ movq(field, rax); break; - case Bytecodes::_fast_iputfield: __ movl(field, rax); break; - case Bytecodes::_fast_bputfield: __ movb(field, rax); break; + case Bytecodes::_fast_aputfield: __ push_ptr(rax); break; + case Bytecodes::_fast_bputfield: // fall through case Bytecodes::_fast_sputfield: // fall through - case Bytecodes::_fast_cputfield: __ movw(field, rax); break; - case Bytecodes::_fast_fputfield: __ movflt(field, xmm0); break; - case Bytecodes::_fast_dputfield: __ movdbl(field, xmm0); break; + case Bytecodes::_fast_cputfield: // fall through + case Bytecodes::_fast_iputfield: __ push_i(rax); break; + case Bytecodes::_fast_dputfield: __ push_d(); break; + case Bytecodes::_fast_fputfield: __ push_f(); break; + case Bytecodes::_fast_lputfield: __ push_l(rax); break; + default: ShouldNotReachHere(); } - - // Save rax because call_VM() will clobber it, then use it for - // JVMTI purposes - __ push(rax); + __ mov(c_rarg3, rsp); // points to jvalue on the stack // access constant pool cache entry __ get_cache_entry_pointer_at_bcp(c_rarg2, rax, 1); __ verify_oop(rbx); @@ -2715,8 +2712,17 @@ CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), rbx, c_rarg2, c_rarg3); - __ pop(rax); // restore lower value - __ addptr(rsp, sizeof(jvalue)); // release jvalue object space + + switch (bytecode()) { // restore tos values + case Bytecodes::_fast_aputfield: __ pop_ptr(rax); break; + case Bytecodes::_fast_bputfield: // fall through + case Bytecodes::_fast_sputfield: // fall through + case Bytecodes::_fast_cputfield: // fall through + case Bytecodes::_fast_iputfield: __ pop_i(rax); break; + case Bytecodes::_fast_dputfield: __ pop_d(); break; + case Bytecodes::_fast_fputfield: __ pop_f(); break; + case Bytecodes::_fast_lputfield: __ pop_l(rax); break; + } __ bind(L2); } }
--- a/src/cpu/x86/vm/x86_64.ad Thu May 03 15:37:46 2012 -0400 +++ b/src/cpu/x86/vm/x86_64.ad Tue May 08 11:29:21 2012 -0700 @@ -3369,15 +3369,6 @@ interface(CONST_INTER); %} -operand immP_poll() %{ - predicate(n->get_ptr() != 0 && n->get_ptr() == (intptr_t)os::get_polling_page()); - match(ConP); - - // formats are generated automatically for constants and base registers - format %{ %} - interface(CONST_INTER); -%} - // Pointer Immediate operand immN() %{ match(ConN); @@ -5726,16 +5717,6 @@ ins_pipe(ialu_reg); %} -instruct loadConP_poll(rRegP dst, immP_poll src) %{ - match(Set dst src); - format %{ "movq $dst, $src\t!ptr" %} - ins_encode %{ - AddressLiteral polling_page(os::get_polling_page(), relocInfo::poll_type); - __ lea($dst$$Register, polling_page); - %} - ins_pipe(ialu_reg_fat); -%} - instruct loadConP31(rRegP dst, immP31 src, rFlagsReg cr) %{ match(Set dst src);
--- a/src/os/bsd/vm/osThread_bsd.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/os/bsd/vm/osThread_bsd.hpp Tue May 08 11:29:21 2012 -0700 @@ -72,15 +72,18 @@ #ifdef _ALLBSD_SOURCE #ifdef __APPLE__ + static size_t thread_id_size() { return sizeof(thread_t); } thread_t thread_id() const { return _thread_id; } #else + static size_t thread_id_size() { return sizeof(pthread_t); } pthread_t thread_id() const { return _thread_id; } #endif #else + static size_t thread_id_size() { return sizeof(pid_t); } pid_t thread_id() const { return _thread_id; }
--- a/src/os/linux/vm/osThread_linux.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/os/linux/vm/osThread_linux.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -56,6 +56,8 @@ sigset_t caller_sigmask() const { return _caller_sigmask; } void set_caller_sigmask(sigset_t sigmask) { _caller_sigmask = sigmask; } + static size_t thread_id_size() { return sizeof(pid_t); } + pid_t thread_id() const { return _thread_id; }
--- a/src/os/solaris/vm/osThread_solaris.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/os/solaris/vm/osThread_solaris.hpp Tue May 08 11:29:21 2012 -0700 @@ -36,6 +36,7 @@ bool _vm_created_thread; // true if the VM created this thread, // false if primary thread or attached thread public: + static size_t thread_id_size() { return sizeof(thread_t); } thread_t thread_id() const { return _thread_id; } uint lwp_id() const { return _lwp_id; } int native_priority() const { return _native_priority; }
--- a/src/os/windows/vm/osThread_windows.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/os/windows/vm/osThread_windows.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -42,6 +42,8 @@ HANDLE interrupt_event() const { return _interrupt_event; } void set_interrupt_event(HANDLE interrupt_event) { _interrupt_event = interrupt_event; } + + static size_t thread_id_size() { return sizeof(unsigned long); } unsigned long thread_id() const { return _thread_id; } #ifndef PRODUCT // Used for debugging, return a unique integer for each thread.
--- a/src/share/tools/whitebox/sun/hotspot/WhiteBox.java Thu May 03 15:37:46 2012 -0400 +++ b/src/share/tools/whitebox/sun/hotspot/WhiteBox.java Tue May 08 11:29:21 2012 -0700 @@ -24,6 +24,7 @@ package sun.hotspot; import java.security.BasicPermission; +import sun.hotspot.parser.DiagnosticCommand; public class WhiteBox { @@ -67,4 +68,5 @@ public native boolean g1IsHumongous(Object o); public native long g1NumFreeRegions(); public native int g1RegionSize(); + public native Object[] parseCommandLine(String commandline, DiagnosticCommand[] args); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/whitebox/sun/hotspot/parser/DiagnosticCommand.java Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,43 @@ +package sun.hotspot.parser; + +public class DiagnosticCommand { + + public enum DiagnosticArgumentType { + JLONG, BOOLEAN, STRING, NANOTIME, STRINGARRAY, MEMORYSIZE + } + + private String name; + private String desc; + private DiagnosticArgumentType type; + private boolean mandatory; + private String defaultValue; + + public DiagnosticCommand(String name, String desc, DiagnosticArgumentType type, + boolean mandatory, String defaultValue) { + this.name = name; + this.desc = desc; + this.type = type; + this.mandatory = mandatory; + this.defaultValue = defaultValue; + } + + public String getName() { + return name; + } + + public String getDesc() { + return desc; + } + + public DiagnosticArgumentType getType() { + return type; + } + + public boolean isMandatory() { + return mandatory; + } + + public String getDefaultValue() { + return defaultValue; + } +}
--- a/src/share/vm/c1/c1_GraphBuilder.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/c1/c1_GraphBuilder.cpp Tue May 08 11:29:21 2012 -0700 @@ -1694,7 +1694,9 @@ // they are roughly equivalent to Object. ciInstanceKlass* singleton = NULL; if (target->holder()->nof_implementors() == 1) { - singleton = target->holder()->implementor(0); + singleton = target->holder()->implementor(); + assert(singleton != NULL && singleton != target->holder(), + "just checking"); assert(holder->is_interface(), "invokeinterface to non interface?"); ciInstanceKlass* decl_interface = (ciInstanceKlass*)holder; @@ -3130,10 +3132,23 @@ bool cantrap = true; vmIntrinsics::ID id = callee->intrinsic_id(); switch (id) { - case vmIntrinsics::_arraycopy : + case vmIntrinsics::_arraycopy: if (!InlineArrayCopy) return false; break; +#ifdef TRACE_HAVE_INTRINSICS + case vmIntrinsics::_classID: + case vmIntrinsics::_threadID: + preserves_state = true; + cantrap = true; + break; + + case vmIntrinsics::_counterTime: + preserves_state = true; + cantrap = false; + break; +#endif + case vmIntrinsics::_currentTimeMillis: case vmIntrinsics::_nanoTime: preserves_state = true;
--- a/src/share/vm/c1/c1_LIRGenerator.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -2879,6 +2879,50 @@ __ cmove(lir_cond(x->cond()), t_val.result(), f_val.result(), reg, as_BasicType(x->x()->type())); } +void LIRGenerator::do_RuntimeCall(address routine, int expected_arguments, Intrinsic* x) { + assert(x->number_of_arguments() == expected_arguments, "wrong type"); + LIR_Opr reg = result_register_for(x->type()); + __ call_runtime_leaf(routine, getThreadTemp(), + reg, new LIR_OprList()); + LIR_Opr result = rlock_result(x); + __ move(reg, result); +} + +#ifdef TRACE_HAVE_INTRINSICS +void LIRGenerator::do_ThreadIDIntrinsic(Intrinsic* x) { + LIR_Opr thread = getThreadPointer(); + LIR_Opr osthread = new_pointer_register(); + __ move(new LIR_Address(thread, in_bytes(JavaThread::osthread_offset()), osthread->type()), osthread); + size_t thread_id_size = OSThread::thread_id_size(); + if (thread_id_size == (size_t) BytesPerLong) { + LIR_Opr id = new_register(T_LONG); + __ move(new LIR_Address(osthread, in_bytes(OSThread::thread_id_offset()), T_LONG), id); + __ convert(Bytecodes::_l2i, id, rlock_result(x)); + } else if (thread_id_size == (size_t) BytesPerInt) { + __ move(new LIR_Address(osthread, in_bytes(OSThread::thread_id_offset()), T_INT), rlock_result(x)); + } else { + ShouldNotReachHere(); + } +} + +void LIRGenerator::do_ClassIDIntrinsic(Intrinsic* x) { + CodeEmitInfo* info = state_for(x); + CodeEmitInfo* info2 = new CodeEmitInfo(info); // Clone for the second null check + assert(info != NULL, "must have info"); + LIRItem arg(x->argument_at(1), this); + arg.load_item(); + LIR_Opr klass = new_register(T_OBJECT); + __ move(new LIR_Address(arg.result(), java_lang_Class::klass_offset_in_bytes(), T_OBJECT), klass, info); + LIR_Opr id = new_register(T_LONG); + ByteSize offset = TRACE_ID_OFFSET; + LIR_Address* trace_id_addr = new LIR_Address(klass, in_bytes(offset), T_LONG); + __ move(trace_id_addr, id); + __ logical_or(id, LIR_OprFact::longConst(0x01l), id); + __ store(id, trace_id_addr); + __ logical_and(id, LIR_OprFact::longConst(~0x3l), id); + __ move(id, rlock_result(x)); +} +#endif void LIRGenerator::do_Intrinsic(Intrinsic* x) { switch (x->id()) { @@ -2890,25 +2934,21 @@ break; } - case vmIntrinsics::_currentTimeMillis: { - assert(x->number_of_arguments() == 0, "wrong type"); - LIR_Opr reg = result_register_for(x->type()); - __ call_runtime_leaf(CAST_FROM_FN_PTR(address, os::javaTimeMillis), getThreadTemp(), - reg, new LIR_OprList()); - LIR_Opr result = rlock_result(x); - __ move(reg, result); +#ifdef TRACE_HAVE_INTRINSICS + case vmIntrinsics::_threadID: do_ThreadIDIntrinsic(x); break; + case vmIntrinsics::_classID: do_ClassIDIntrinsic(x); break; + case vmIntrinsics::_counterTime: + do_RuntimeCall(CAST_FROM_FN_PTR(address, TRACE_TIME_METHOD), 0, x); break; - } - - case vmIntrinsics::_nanoTime: { - assert(x->number_of_arguments() == 0, "wrong type"); - LIR_Opr reg = result_register_for(x->type()); - __ call_runtime_leaf(CAST_FROM_FN_PTR(address, os::javaTimeNanos), getThreadTemp(), - reg, new LIR_OprList()); - LIR_Opr result = rlock_result(x); - __ move(reg, result); +#endif + + case vmIntrinsics::_currentTimeMillis: + do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeMillis), 0, x); break; - } + + case vmIntrinsics::_nanoTime: + do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeNanos), 0, x); + break; case vmIntrinsics::_Object_init: do_RegisterFinalizer(x); break; case vmIntrinsics::_getClass: do_getClass(x); break;
--- a/src/share/vm/c1/c1_LIRGenerator.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/c1/c1_LIRGenerator.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -426,6 +426,12 @@ SwitchRangeArray* create_lookup_ranges(LookupSwitch* x); void do_SwitchRanges(SwitchRangeArray* x, LIR_Opr value, BlockBegin* default_sux); + void do_RuntimeCall(address routine, int expected_arguments, Intrinsic* x); +#ifdef TRACE_HAVE_INTRINSICS + void do_ThreadIDIntrinsic(Intrinsic* x); + void do_ClassIDIntrinsic(Intrinsic* x); +#endif + public: Compilation* compilation() const { return _compilation; } FrameMap* frame_map() const { return _compilation->frame_map(); }
--- a/src/share/vm/c1/c1_Runtime1.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/c1/c1_Runtime1.cpp Tue May 08 11:29:21 2012 -0700 @@ -295,6 +295,9 @@ FUNCTION_CASE(entry, SharedRuntime::dtrace_method_entry); FUNCTION_CASE(entry, SharedRuntime::dtrace_method_exit); FUNCTION_CASE(entry, trace_block_entry); +#ifdef TRACE_HAVE_INTRINSICS + FUNCTION_CASE(entry, TRACE_TIME_METHOD); +#endif #undef FUNCTION_CASE
--- a/src/share/vm/ci/ciInstanceKlass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/ci/ciInstanceKlass.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -59,10 +59,7 @@ _has_nonstatic_fields = ik->has_nonstatic_fields(); _nonstatic_fields = NULL; // initialized lazily by compute_nonstatic_fields: - _nof_implementors = ik->nof_implementors(); - for (int i = 0; i < implementors_limit; i++) { - _implementors[i] = NULL; // we will fill these lazily - } + _implementor = NULL; // we will fill these lazily Thread *thread = Thread::current(); if (ciObjectFactory::is_initialized()) { @@ -102,7 +99,6 @@ _nonstatic_field_size = -1; _has_nonstatic_fields = false; _nonstatic_fields = NULL; - _nof_implementors = -1; _loader = loader; _protection_domain = protection_domain; _is_shared = false; @@ -133,17 +129,6 @@ } // ------------------------------------------------------------------ -// ciInstanceKlass::compute_shared_nof_implementors -int ciInstanceKlass::compute_shared_nof_implementors() { - // We requery this property, since it is a very old ciObject. - GUARDED_VM_ENTRY( - instanceKlass* ik = get_instanceKlass(); - _nof_implementors = ik->nof_implementors(); - return _nof_implementors; - ) -} - -// ------------------------------------------------------------------ // ciInstanceKlass::loader oop ciInstanceKlass::loader() { ASSERT_IN_VM; @@ -540,7 +525,7 @@ if (is_shared()) { return is_final(); // approximately correct } else { - return !_has_subklass && (_nof_implementors == 0); + return !_has_subklass && (nof_implementors() == 0); } } @@ -548,35 +533,31 @@ // ciInstanceKlass::implementor // // Report an implementor of this interface. -// Returns NULL if exact information is not available. // Note that there are various races here, since my copy // of _nof_implementors might be out of date with respect // to results returned by instanceKlass::implementor. // This is OK, since any dependencies we decide to assert // will be checked later under the Compile_lock. -ciInstanceKlass* ciInstanceKlass::implementor(int n) { - if (n >= implementors_limit) { - return NULL; - } - ciInstanceKlass* impl = _implementors[n]; +ciInstanceKlass* ciInstanceKlass::implementor() { + ciInstanceKlass* impl = _implementor; if (impl == NULL) { - if (_nof_implementors > implementors_limit) { - return NULL; - } // Go into the VM to fetch the implementor. { VM_ENTRY_MARK; - klassOop k = get_instanceKlass()->implementor(n); + klassOop k = get_instanceKlass()->implementor(); if (k != NULL) { - impl = CURRENT_THREAD_ENV->get_object(k)->as_instance_klass(); + if (k == get_instanceKlass()->as_klassOop()) { + // More than one implementors. Use 'this' in this case. + impl = this; + } else { + impl = CURRENT_THREAD_ENV->get_object(k)->as_instance_klass(); + } } } // Memoize this result. if (!is_shared()) { - _implementors[n] = (impl == NULL)? this: impl; + _implementor = impl; } - } else if (impl == this) { - impl = NULL; // memoized null result from a VM query } return impl; }
--- a/src/share/vm/ci/ciInstanceKlass.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/ci/ciInstanceKlass.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -65,9 +65,11 @@ ciConstantPoolCache* _field_cache; // cached map index->field GrowableArray<ciField*>* _nonstatic_fields; - enum { implementors_limit = instanceKlass::implementors_limit }; - ciInstanceKlass* _implementors[implementors_limit]; - jint _nof_implementors; + // The possible values of the _implementor fall into following three cases: + // NULL: no implementor. + // A ciInstanceKlass that's not itself: one implementor. + // Itsef: more than one implementors. + ciInstanceKlass* _implementor; GrowableArray<ciField*>* _non_static_fields; @@ -97,7 +99,6 @@ void compute_shared_init_state(); bool compute_shared_has_subklass(); - int compute_shared_nof_implementors(); int compute_nonstatic_fields(); GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields); @@ -158,10 +159,17 @@ assert(is_loaded(), "must be loaded"); return _nonstatic_oop_map_size; } ciInstanceKlass* super(); - jint nof_implementors() { + jint nof_implementors() { + ciInstanceKlass* impl; assert(is_loaded(), "must be loaded"); - if (_is_shared) return compute_shared_nof_implementors(); - return _nof_implementors; + impl = implementor(); + if (impl == NULL) { + return 0; + } else if (impl != this) { + return 1; + } else { + return 2; + } } ciInstanceKlass* get_canonical_holder(int offset); @@ -207,7 +215,7 @@ // but consider adding to vmSymbols.hpp instead. bool is_leaf_type(); - ciInstanceKlass* implementor(int n); + ciInstanceKlass* implementor(); // Is the defining class loader of this class the default loader? bool uses_default_loader();
--- a/src/share/vm/classfile/classFileParser.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/classfile/classFileParser.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -81,7 +81,7 @@ #define JAVA_7_VERSION 51 -void ClassFileParser::parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS) { +void ClassFileParser::parse_constant_pool_entries(Handle class_loader, constantPoolHandle cp, int length, TRAPS) { // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize // this function (_current can be allocated in a register, with scalar // replacement of aggregates). The _current pointer is copied back to @@ -272,7 +272,7 @@ indices[names_count] = index; hashValues[names_count++] = hash; if (names_count == SymbolTable::symbol_alloc_batch_size) { - SymbolTable::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK); + SymbolTable::new_symbols(class_loader, cp, names_count, names, lengths, indices, hashValues, CHECK); names_count = 0; } } else { @@ -289,7 +289,7 @@ // Allocate the remaining symbols if (names_count > 0) { - SymbolTable::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK); + SymbolTable::new_symbols(class_loader, cp, names_count, names, lengths, indices, hashValues, CHECK); } // Copy _current pointer of local copy back to stream(). @@ -318,7 +318,7 @@ bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); } -constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) { +constantPoolHandle ClassFileParser::parse_constant_pool(Handle class_loader, TRAPS) { ClassFileStream* cfs = stream(); constantPoolHandle nullHandle; @@ -337,7 +337,7 @@ ConstantPoolCleaner cp_in_error(cp); // set constant pool to be cleaned up. // parsing constant pool entries - parse_constant_pool_entries(cp, length, CHECK_(nullHandle)); + parse_constant_pool_entries(class_loader, cp, length, CHECK_(nullHandle)); int index = 1; // declared outside of loops for portability @@ -2803,7 +2803,7 @@ _relax_verify = Verifier::relax_verify_for(class_loader()); // Constant pool - constantPoolHandle cp = parse_constant_pool(CHECK_(nullHandle)); + constantPoolHandle cp = parse_constant_pool(class_loader, CHECK_(nullHandle)); ConstantPoolCleaner error_handler(cp); // set constant pool to be cleaned up. int cp_size = cp->length(); @@ -3354,6 +3354,7 @@ klassOop ik = oopFactory::new_instanceKlass(name, vtable_size, itable_size, static_field_size, total_oop_map_count, + access_flags, rt, CHECK_(nullHandle)); instanceKlassHandle this_klass (THREAD, ik); @@ -3362,7 +3363,6 @@ "sanity"); // Fill in information already parsed - this_klass->set_access_flags(access_flags); this_klass->set_should_verify_class(verify); jint lh = Klass::instance_layout_helper(instance_size, false); this_klass->set_layout_helper(lh);
--- a/src/share/vm/classfile/classFileParser.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/classfile/classFileParser.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -68,9 +68,10 @@ void set_stream(ClassFileStream* st) { _stream = st; } // Constant pool parsing - void parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS); + void parse_constant_pool_entries(Handle class_loader, + constantPoolHandle cp, int length, TRAPS); - constantPoolHandle parse_constant_pool(TRAPS); + constantPoolHandle parse_constant_pool(Handle class_loader, TRAPS); // Interface parsing objArrayHandle parse_interfaces(constantPoolHandle cp,
--- a/src/share/vm/classfile/symbolTable.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/classfile/symbolTable.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,6 +27,7 @@ #include "classfile/symbolTable.hpp" #include "classfile/systemDictionary.hpp" #include "gc_interface/collectedHeap.inline.hpp" +#include "memory/allocation.inline.hpp" #include "memory/filemap.hpp" #include "memory/gcLocker.inline.hpp" #include "oops/oop.inline.hpp" @@ -37,34 +38,35 @@ // -------------------------------------------------------------------------- SymbolTable* SymbolTable::_the_table = NULL; +// Static arena for symbols that are not deallocated +Arena* SymbolTable::_arena = NULL; -Symbol* SymbolTable::allocate_symbol(const u1* name, int len, TRAPS) { +Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) { // Don't allow symbols to be created which cannot fit in a Symbol*. if (len > Symbol::max_length()) { THROW_MSG_0(vmSymbols::java_lang_InternalError(), "name is too long to represent"); } - Symbol* sym = new (len) Symbol(name, len); + Symbol* sym; + // Allocate symbols in the C heap when dumping shared spaces in case there + // are temporary symbols we can remove. + if (c_heap || DumpSharedSpaces) { + // refcount starts as 1 + sym = new (len, THREAD) Symbol(name, len, 1); + } else { + sym = new (len, arena(), THREAD) Symbol(name, len, -1); + } assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted"); return sym; } -bool SymbolTable::allocate_symbols(int names_count, const u1** names, - int* lengths, Symbol** syms, TRAPS) { - for (int i = 0; i< names_count; i++) { - if (lengths[i] > Symbol::max_length()) { - THROW_MSG_0(vmSymbols::java_lang_InternalError(), - "name is too long to represent"); - } +void SymbolTable::initialize_symbols(int arena_alloc_size) { + // Initialize the arena for global symbols, size passed in depends on CDS. + if (arena_alloc_size == 0) { + _arena = new Arena(); + } else { + _arena = new Arena(arena_alloc_size); } - - for (int i = 0; i< names_count; i++) { - int len = lengths[i]; - syms[i] = new (len) Symbol(names[i], len); - assert(syms[i] != NULL, "new should call vm_exit_out_of_memory if " - "C_HEAP is exhausted"); - } - return true; } // Call function for all symbols in the symbol table. @@ -83,8 +85,7 @@ int SymbolTable::symbols_counted = 0; // Remove unreferenced symbols from the symbol table -// This is done late during GC. This doesn't use the hash table unlink because -// it assumes that the literals are oops. +// This is done late during GC. void SymbolTable::unlink() { int removed = 0; int total = 0; @@ -156,7 +157,7 @@ if (s != NULL) return s; // Otherwise, add to symbol to table - return the_table()->basic_add(index, (u1*)name, len, hashValue, CHECK_NULL); + return the_table()->basic_add(index, (u1*)name, len, hashValue, true, CHECK_NULL); } Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) { @@ -192,7 +193,7 @@ // We can't include the code in No_Safepoint_Verifier because of the // ResourceMark. - return the_table()->basic_add(index, (u1*)buffer, len, hashValue, CHECK_NULL); + return the_table()->basic_add(index, (u1*)buffer, len, hashValue, true, CHECK_NULL); } Symbol* SymbolTable::lookup_only(const char* name, int len, @@ -256,71 +257,81 @@ } } -void SymbolTable::add(constantPoolHandle cp, int names_count, +void SymbolTable::add(Handle class_loader, constantPoolHandle cp, + int names_count, const char** names, int* lengths, int* cp_indices, unsigned int* hashValues, TRAPS) { SymbolTable* table = the_table(); - bool added = table->basic_add(cp, names_count, names, lengths, + bool added = table->basic_add(class_loader, cp, names_count, names, lengths, cp_indices, hashValues, CHECK); if (!added) { // do it the hard way for (int i=0; i<names_count; i++) { int index = table->hash_to_index(hashValues[i]); - Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], - hashValues[i], CHECK); + bool c_heap = class_loader() != NULL; + Symbol* sym = table->basic_add(index, (u1*)names[i], lengths[i], hashValues[i], c_heap, CHECK); cp->symbol_at_put(cp_indices[i], sym); } } } +Symbol* SymbolTable::new_permanent_symbol(const char* name, TRAPS) { + unsigned int hash; + Symbol* result = SymbolTable::lookup_only((char*)name, (int)strlen(name), hash); + if (result != NULL) { + return result; + } + SymbolTable* table = the_table(); + int index = table->hash_to_index(hash); + return table->basic_add(index, (u1*)name, (int)strlen(name), hash, false, THREAD); +} + Symbol* SymbolTable::basic_add(int index, u1 *name, int len, - unsigned int hashValue, TRAPS) { + unsigned int hashValue, bool c_heap, TRAPS) { assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), "proposed name of symbol must be stable"); - // We assume that lookup() has been called already, that it failed, - // and symbol was not found. We create the symbol here. - Symbol* sym = allocate_symbol(name, len, CHECK_NULL); - - // Allocation must be done before grabbing the SymbolTable_lock lock + // Grab SymbolTable_lock first. MutexLocker ml(SymbolTable_lock, THREAD); - assert(sym->equals((char*)name, len), "symbol must be properly initialized"); - // Since look-up was done lock-free, we need to check if another // thread beat us in the race to insert the symbol. - Symbol* test = lookup(index, (char*)name, len, hashValue); if (test != NULL) { - // A race occurred and another thread introduced the symbol, this one - // will be dropped and collected. - delete sym; + // A race occurred and another thread introduced the symbol. assert(test->refcount() != 0, "lookup should have incremented the count"); return test; } + // Create a new symbol. + Symbol* sym = allocate_symbol(name, len, c_heap, CHECK_NULL); + assert(sym->equals((char*)name, len), "symbol must be properly initialized"); + HashtableEntry<Symbol*>* entry = new_entry(hashValue, sym); - sym->increment_refcount(); add_entry(index, entry); return sym; } -bool SymbolTable::basic_add(constantPoolHandle cp, int names_count, +// This version of basic_add adds symbols in batch from the constant pool +// parsing. +bool SymbolTable::basic_add(Handle class_loader, constantPoolHandle cp, + int names_count, const char** names, int* lengths, int* cp_indices, unsigned int* hashValues, TRAPS) { - Symbol* syms[symbol_alloc_batch_size]; - bool allocated = allocate_symbols(names_count, (const u1**)names, lengths, - syms, CHECK_false); - if (!allocated) { - return false; + + // Check symbol names are not too long. If any are too long, don't add any. + for (int i = 0; i< names_count; i++) { + if (lengths[i] > Symbol::max_length()) { + THROW_MSG_0(vmSymbols::java_lang_InternalError(), + "name is too long to represent"); + } } - // Allocation must be done before grabbing the SymbolTable_lock lock + // Hold SymbolTable_lock through the symbol creation MutexLocker ml(SymbolTable_lock, THREAD); for (int i=0; i<names_count; i++) { - assert(syms[i]->equals(names[i], lengths[i]), "symbol must be properly initialized"); // Since look-up was done lock-free, we need to check if another // thread beat us in the race to insert the symbol. int index = hash_to_index(hashValues[i]); @@ -330,16 +341,17 @@ // will be dropped and collected. Use test instead. cp->symbol_at_put(cp_indices[i], test); assert(test->refcount() != 0, "lookup should have incremented the count"); - delete syms[i]; } else { - Symbol* sym = syms[i]; + // Create a new symbol. The null class loader is never unloaded so these + // are allocated specially in a permanent arena. + bool c_heap = class_loader() != NULL; + Symbol* sym = allocate_symbol((const u1*)names[i], lengths[i], c_heap, CHECK_(false)); + assert(sym->equals(names[i], lengths[i]), "symbol must be properly initialized"); // why wouldn't it be??? HashtableEntry<Symbol*>* entry = new_entry(hashValues[i], sym); - sym->increment_refcount(); // increment refcount in external hashtable add_entry(index, entry); cp->symbol_at_put(cp_indices[i], sym); } } - return true; } @@ -406,6 +418,8 @@ ((float)symbols_removed/(float)symbols_counted)* 100); } tty->print_cr("Reference counts %5d", Symbol::_total_count); + tty->print_cr("Symbol arena size %5d used %5d", + arena()->size_in_bytes(), arena()->used()); tty->print_cr("Histogram of symbol length:"); tty->print_cr("%8s %5d", "Total ", total); tty->print_cr("%8s %5d", "Maximum", max_symbols);
--- a/src/share/vm/classfile/symbolTable.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/classfile/symbolTable.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -82,24 +82,24 @@ static int symbols_removed; static int symbols_counted; - Symbol* allocate_symbol(const u1* name, int len, TRAPS); // Assumes no characters larger than 0x7F - bool allocate_symbols(int names_count, const u1** names, int* lengths, Symbol** syms, TRAPS); + Symbol* allocate_symbol(const u1* name, int len, bool c_heap, TRAPS); // Assumes no characters larger than 0x7F // Adding elements - Symbol* basic_add(int index, u1* name, int len, - unsigned int hashValue, TRAPS); - bool basic_add(constantPoolHandle cp, int names_count, + Symbol* basic_add(int index, u1* name, int len, unsigned int hashValue, + bool c_heap, TRAPS); + + bool basic_add(Handle class_loader, constantPoolHandle cp, int names_count, const char** names, int* lengths, int* cp_indices, unsigned int* hashValues, TRAPS); - static void new_symbols(constantPoolHandle cp, int names_count, + static void new_symbols(Handle class_loader, constantPoolHandle cp, + int names_count, const char** name, int* lengths, int* cp_indices, unsigned int* hashValues, TRAPS) { - add(cp, names_count, name, lengths, cp_indices, hashValues, THREAD); + add(class_loader, cp, names_count, name, lengths, cp_indices, hashValues, THREAD); } - // Table size enum { symbol_table_size = 20011 @@ -114,10 +114,16 @@ : Hashtable<Symbol*>(symbol_table_size, sizeof (HashtableEntry<Symbol*>), t, number_of_entries) {} + // Arena for permanent symbols (null class loader) that are never unloaded + static Arena* _arena; + static Arena* arena() { return _arena; } // called for statistics + static void initialize_symbols(int arena_alloc_size = 0); public: enum { - symbol_alloc_batch_size = 8 + symbol_alloc_batch_size = 8, + // Pick initial size based on java -version size measurements + symbol_alloc_arena_size = 360*K }; // The symbol table @@ -126,6 +132,7 @@ static void create_table() { assert(_the_table == NULL, "One symbol table allowed."); _the_table = new SymbolTable(); + initialize_symbols(symbol_alloc_arena_size); } static void create_table(HashtableBucket* t, int length, @@ -134,6 +141,9 @@ assert(length == symbol_table_size * sizeof(HashtableBucket), "bad shared symbol size."); _the_table = new SymbolTable(t, number_of_entries); + // if CDS give symbol table a default arena size since most symbols + // are already allocated in the shared misc section. + initialize_symbols(); } static Symbol* lookup(const char* name, int len, TRAPS); @@ -151,7 +161,7 @@ static Symbol* lookup_unicode(const jchar* name, int len, TRAPS); static Symbol* lookup_only_unicode(const jchar* name, int len, unsigned int& hash); - static void add(constantPoolHandle cp, int names_count, + static void add(Handle class_loader, constantPoolHandle cp, int names_count, const char** names, int* lengths, int* cp_indices, unsigned int* hashValues, TRAPS); @@ -174,6 +184,9 @@ return lookup(sym, begin, end, THREAD); } + // Create a symbol in the arena for symbols that are not deleted + static Symbol* new_permanent_symbol(const char* name, TRAPS); + // Symbol lookup static Symbol* lookup(int index, const char* name, int len, TRAPS);
--- a/src/share/vm/classfile/vmSymbols.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/classfile/vmSymbols.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -79,7 +79,7 @@ if (!UseSharedSpaces) { const char* string = &vm_symbol_bodies[0]; for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) { - Symbol* sym = SymbolTable::new_symbol(string, CHECK); + Symbol* sym = SymbolTable::new_permanent_symbol(string, CHECK); _symbols[index] = sym; string += strlen(string); // skip string body string += 1; // skip trailing null @@ -128,7 +128,7 @@ // Spot-check correspondence between strings, symbols, and enums: assert(_symbols[NO_SID] == NULL, "must be"); const char* str = "java/lang/Object"; - TempNewSymbol jlo = SymbolTable::new_symbol(str, CHECK); + TempNewSymbol jlo = SymbolTable::new_permanent_symbol(str, CHECK); assert(strncmp(str, (char*)jlo->base(), jlo->utf8_length()) == 0, ""); assert(jlo == java_lang_Object(), ""); SID sid = VM_SYMBOL_ENUM_NAME(java_lang_Object); @@ -147,7 +147,7 @@ // The string "format" happens (at the moment) not to be a vmSymbol, // though it is a method name in java.lang.String. str = "format"; - TempNewSymbol fmt = SymbolTable::new_symbol(str, CHECK); + TempNewSymbol fmt = SymbolTable::new_permanent_symbol(str, CHECK); sid = find_sid(fmt); assert(sid == NO_SID, "symbol index works (negative test)"); }
--- a/src/share/vm/classfile/vmSymbols.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/classfile/vmSymbols.hpp Tue May 08 11:29:21 2012 -0700 @@ -27,6 +27,7 @@ #include "oops/symbol.hpp" #include "memory/iterator.hpp" +#include "trace/traceMacros.hpp" // The class vmSymbols is a name space for fast lookup of // symbols commonly used in the VM. @@ -424,6 +425,7 @@ template(throwable_throwable_signature, "(Ljava/lang/Throwable;)Ljava/lang/Throwable;") \ template(class_void_signature, "(Ljava/lang/Class;)V") \ template(class_int_signature, "(Ljava/lang/Class;)I") \ + template(class_long_signature, "(Ljava/lang/Class;)J") \ template(class_boolean_signature, "(Ljava/lang/Class;)Z") \ template(throwable_string_void_signature, "(Ljava/lang/Throwable;Ljava/lang/String;)V") \ template(string_array_void_signature, "([Ljava/lang/String;)V") \ @@ -539,10 +541,12 @@ template(serializePropertiesToByteArray_signature, "()[B") \ template(serializeAgentPropertiesToByteArray_name, "serializeAgentPropertiesToByteArray") \ template(classRedefinedCount_name, "classRedefinedCount") \ + \ + /* trace signatures */ \ + TRACE_TEMPLATES(template) \ + \ /*end*/ - - // Here are all the intrinsics known to the runtime and the CI. // Each intrinsic consists of a public enum name (like _hashCode), // followed by a specification of its klass, name, and signature: @@ -648,6 +652,8 @@ do_intrinsic(_nanoTime, java_lang_System, nanoTime_name, void_long_signature, F_S) \ do_name( nanoTime_name, "nanoTime") \ \ + TRACE_INTRINSICS(do_intrinsic, do_class, do_name, do_signature, do_alias) \ + \ do_intrinsic(_arraycopy, java_lang_System, arraycopy_name, arraycopy_signature, F_S) \ do_name( arraycopy_name, "arraycopy") \ do_signature(arraycopy_signature, "(Ljava/lang/Object;ILjava/lang/Object;II)V") \
--- a/src/share/vm/code/dependencies.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/code/dependencies.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1033,21 +1033,25 @@ // (Old CHA had the same limitation.) return context_type; } - for (int i = 0; i < nof_impls; i++) { - klassOop impl = instanceKlass::cast(context_type)->implementor(i); - if (impl == NULL) { - // implementors array overflowed => no exact info. + if (nof_impls > 0) { + klassOop impl = instanceKlass::cast(context_type)->implementor(); + assert(impl != NULL, "just checking"); + // If impl is the same as the context_type, then more than one + // implementor has seen. No exact info in this case. + if (impl == context_type) { return context_type; // report an inexact witness to this sad affair } if (do_counts) { NOT_PRODUCT(deps_find_witness_steps++); } if (is_participant(impl)) { - if (participants_hide_witnesses) continue; - // else fall through to process this guy's subclasses + if (!participants_hide_witnesses) { + ADD_SUBCLASS_CHAIN(impl); + } } else if (is_witness(impl) && !ignore_witness(impl)) { return impl; + } else { + ADD_SUBCLASS_CHAIN(impl); } - ADD_SUBCLASS_CHAIN(impl); } // Recursively process each non-trivial sibling chain. @@ -1174,8 +1178,9 @@ } else if (ctx->nof_implementors() != 0) { // if it is an interface, it must be unimplemented // (if it is not an interface, nof_implementors is always zero) - klassOop impl = ctx->implementor(0); - return (impl != NULL)? impl: ctxk; + klassOop impl = ctx->implementor(); + assert(impl != NULL, "must be set"); + return impl; } else { return NULL; }
--- a/src/share/vm/code/nmethod.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/code/nmethod.hpp Tue May 08 11:29:21 2012 -0700 @@ -553,7 +553,7 @@ static void oops_do_marking_prologue(); static void oops_do_marking_epilogue(); static bool oops_do_marking_is_active() { return _oops_do_mark_nmethods != NULL; } - DEBUG_ONLY(bool test_oops_do_mark() { return _oops_do_mark_link != NULL; }) + bool test_oops_do_mark() { return _oops_do_mark_link != NULL; } // ScopeDesc for an instruction ScopeDesc* scope_desc_at(address pc);
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -2444,7 +2444,7 @@ virtual void do_oop(narrowOop* p) { VerifyAllOopsClosure::do_oop_work(p); } }; -void CompactibleFreeListSpace::verify(bool ignored) const { +void CompactibleFreeListSpace::verify() const { assert_lock_strong(&_freelistLock); verify_objects_initialized(); MemRegion span = _collector->_span;
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -492,7 +492,7 @@ void print() const; void print_on(outputStream* st) const; void prepare_for_verify(); - void verify(bool allow_dirty) const; + void verify() const; void verifyFreeLists() const PRODUCT_RETURN; void verifyIndexedFreeLists() const; void verifyIndexedFreeList(size_t size) const;
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Tue May 08 11:29:21 2012 -0700 @@ -3109,21 +3109,21 @@ } void -ConcurrentMarkSweepGeneration::verify(bool allow_dirty /* ignored */) { +ConcurrentMarkSweepGeneration::verify() { // Locks are normally acquired/released in gc_prologue/gc_epilogue, but those // are not called when the heap is verified during universe initialization and // at vm shutdown. if (freelistLock()->owned_by_self()) { - cmsSpace()->verify(false /* ignored */); + cmsSpace()->verify(); } else { MutexLockerEx fll(freelistLock(), Mutex::_no_safepoint_check_flag); - cmsSpace()->verify(false /* ignored */); - } -} - -void CMSCollector::verify(bool allow_dirty /* ignored */) { - _cmsGen->verify(allow_dirty); - _permGen->verify(allow_dirty); + cmsSpace()->verify(); + } +} + +void CMSCollector::verify() { + _cmsGen->verify(); + _permGen->verify(); } #ifndef PRODUCT
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -988,7 +988,7 @@ CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters(); // debugging - void verify(bool); + void verify(); bool verify_after_remark(); void verify_ok_to_terminate() const PRODUCT_RETURN; void verify_work_stacks_empty() const PRODUCT_RETURN; @@ -1279,7 +1279,7 @@ // Debugging void prepare_for_verify(); - void verify(bool allow_dirty); + void verify(); void print_statistics() PRODUCT_RETURN; // Performance Counters support
--- a/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp Tue May 08 11:29:21 2012 -0700 @@ -29,102 +29,6 @@ #include "gc_implementation/g1/g1ErgoVerbose.hpp" #include "memory/space.inline.hpp" -CSetChooserCache::CSetChooserCache() { - for (int i = 0; i < CacheLength; ++i) - _cache[i] = NULL; - clear(); -} - -void CSetChooserCache::clear() { - _occupancy = 0; - _first = 0; - for (int i = 0; i < CacheLength; ++i) { - HeapRegion *hr = _cache[i]; - if (hr != NULL) - hr->set_sort_index(-1); - _cache[i] = NULL; - } -} - -#ifndef PRODUCT -bool CSetChooserCache::verify() { - guarantee(false, "CSetChooserCache::verify(): don't call this any more"); - - int index = _first; - HeapRegion *prev = NULL; - for (int i = 0; i < _occupancy; ++i) { - guarantee(_cache[index] != NULL, "cache entry should not be empty"); - HeapRegion *hr = _cache[index]; - guarantee(!hr->is_young(), "should not be young!"); - if (prev != NULL) { - guarantee(prev->gc_efficiency() >= hr->gc_efficiency(), - "cache should be correctly ordered"); - } - guarantee(hr->sort_index() == get_sort_index(index), - "sort index should be correct"); - index = trim_index(index + 1); - prev = hr; - } - - for (int i = 0; i < (CacheLength - _occupancy); ++i) { - guarantee(_cache[index] == NULL, "cache entry should be empty"); - index = trim_index(index + 1); - } - - guarantee(index == _first, "we should have reached where we started from"); - return true; -} -#endif // PRODUCT - -void CSetChooserCache::insert(HeapRegion *hr) { - guarantee(false, "CSetChooserCache::insert(): don't call this any more"); - - assert(!is_full(), "cache should not be empty"); - hr->calc_gc_efficiency(); - - int empty_index; - if (_occupancy == 0) { - empty_index = _first; - } else { - empty_index = trim_index(_first + _occupancy); - assert(_cache[empty_index] == NULL, "last slot should be empty"); - int last_index = trim_index(empty_index - 1); - HeapRegion *last = _cache[last_index]; - assert(last != NULL,"as the cache is not empty, last should not be empty"); - while (empty_index != _first && - last->gc_efficiency() < hr->gc_efficiency()) { - _cache[empty_index] = last; - last->set_sort_index(get_sort_index(empty_index)); - empty_index = last_index; - last_index = trim_index(last_index - 1); - last = _cache[last_index]; - } - } - _cache[empty_index] = hr; - hr->set_sort_index(get_sort_index(empty_index)); - - ++_occupancy; - assert(verify(), "cache should be consistent"); -} - -HeapRegion *CSetChooserCache::remove_first() { - guarantee(false, "CSetChooserCache::remove_first(): " - "don't call this any more"); - - if (_occupancy > 0) { - assert(_cache[_first] != NULL, "cache should have at least one region"); - HeapRegion *ret = _cache[_first]; - _cache[_first] = NULL; - ret->set_sort_index(-1); - --_occupancy; - _first = trim_index(_first + 1); - assert(verify(), "cache should be consistent"); - return ret; - } else { - return NULL; - } -} - // Even though we don't use the GC efficiency in our heuristics as // much as we used to, we still order according to GC efficiency. This // will cause regions with a lot of live objects and large RSets to @@ -134,7 +38,7 @@ // the ones we'll skip are ones with both large RSets and a lot of // live objects, not the ones with just a lot of live objects if we // ordered according to the amount of reclaimable bytes per region. -static int orderRegions(HeapRegion* hr1, HeapRegion* hr2) { +static int order_regions(HeapRegion* hr1, HeapRegion* hr2) { if (hr1 == NULL) { if (hr2 == NULL) { return 0; @@ -156,8 +60,8 @@ } } -static int orderRegions(HeapRegion** hr1p, HeapRegion** hr2p) { - return orderRegions(*hr1p, *hr2p); +static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) { + return order_regions(*hr1p, *hr2p); } CollectionSetChooser::CollectionSetChooser() : @@ -175,105 +79,74 @@ // // Note: containing object is allocated on C heap since it is CHeapObj. // - _markedRegions((ResourceObj::set_allocation_type((address)&_markedRegions, + _regions((ResourceObj::set_allocation_type((address) &_regions, ResourceObj::C_HEAP), 100), true /* C_Heap */), - _curr_index(0), _length(0), - _regionLiveThresholdBytes(0), _remainingReclaimableBytes(0), - _first_par_unreserved_idx(0) { - _regionLiveThresholdBytes = + _curr_index(0), _length(0), _first_par_unreserved_idx(0), + _region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) { + _region_live_threshold_bytes = HeapRegion::GrainBytes * (size_t) G1OldCSetRegionLiveThresholdPercent / 100; } #ifndef PRODUCT -bool CollectionSetChooser::verify() { - guarantee(_length >= 0, err_msg("_length: %d", _length)); - guarantee(0 <= _curr_index && _curr_index <= _length, - err_msg("_curr_index: %d _length: %d", _curr_index, _length)); - int index = 0; +void CollectionSetChooser::verify() { + guarantee(_length <= regions_length(), + err_msg("_length: %u regions length: %u", _length, regions_length())); + guarantee(_curr_index <= _length, + err_msg("_curr_index: %u _length: %u", _curr_index, _length)); + uint index = 0; size_t sum_of_reclaimable_bytes = 0; while (index < _curr_index) { - guarantee(_markedRegions.at(index) == NULL, + guarantee(regions_at(index) == NULL, "all entries before _curr_index should be NULL"); index += 1; } HeapRegion *prev = NULL; while (index < _length) { - HeapRegion *curr = _markedRegions.at(index++); - guarantee(curr != NULL, "Regions in _markedRegions array cannot be NULL"); - int si = curr->sort_index(); + HeapRegion *curr = regions_at(index++); + guarantee(curr != NULL, "Regions in _regions array cannot be NULL"); guarantee(!curr->is_young(), "should not be young!"); guarantee(!curr->isHumongous(), "should not be humongous!"); - guarantee(si > -1 && si == (index-1), "sort index invariant"); if (prev != NULL) { - guarantee(orderRegions(prev, curr) != 1, + guarantee(order_regions(prev, curr) != 1, err_msg("GC eff prev: %1.4f GC eff curr: %1.4f", prev->gc_efficiency(), curr->gc_efficiency())); } sum_of_reclaimable_bytes += curr->reclaimable_bytes(); prev = curr; } - guarantee(sum_of_reclaimable_bytes == _remainingReclaimableBytes, + guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes, err_msg("reclaimable bytes inconsistent, " "remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT, - _remainingReclaimableBytes, sum_of_reclaimable_bytes)); - return true; + _remaining_reclaimable_bytes, sum_of_reclaimable_bytes)); } -#endif - -void CollectionSetChooser::fillCache() { - guarantee(false, "fillCache: don't call this any more"); +#endif // !PRODUCT - while (!_cache.is_full() && (_curr_index < _length)) { - HeapRegion* hr = _markedRegions.at(_curr_index); - assert(hr != NULL, - err_msg("Unexpected NULL hr in _markedRegions at index %d", - _curr_index)); - _curr_index += 1; - assert(!hr->is_young(), "should not be young!"); - assert(hr->sort_index() == _curr_index-1, "sort_index invariant"); - _markedRegions.at_put(hr->sort_index(), NULL); - _cache.insert(hr); - assert(!_cache.is_empty(), "cache should not be empty"); - } - assert(verify(), "cache should be consistent"); -} - -void CollectionSetChooser::sortMarkedHeapRegions() { +void CollectionSetChooser::sort_regions() { // First trim any unused portion of the top in the parallel case. if (_first_par_unreserved_idx > 0) { - if (G1PrintParCleanupStats) { - gclog_or_tty->print(" Truncating _markedRegions from %d to %d.\n", - _markedRegions.length(), _first_par_unreserved_idx); - } - assert(_first_par_unreserved_idx <= _markedRegions.length(), + assert(_first_par_unreserved_idx <= regions_length(), "Or we didn't reserved enough length"); - _markedRegions.trunc_to(_first_par_unreserved_idx); + regions_trunc_to(_first_par_unreserved_idx); } - _markedRegions.sort(orderRegions); - assert(_length <= _markedRegions.length(), "Requirement"); - assert(_length == 0 || _markedRegions.at(_length - 1) != NULL, - "Testing _length"); - assert(_length == _markedRegions.length() || - _markedRegions.at(_length) == NULL, "Testing _length"); - if (G1PrintParCleanupStats) { - gclog_or_tty->print_cr(" Sorted %d marked regions.", _length); + _regions.sort(order_regions); + assert(_length <= regions_length(), "Requirement"); +#ifdef ASSERT + for (uint i = 0; i < _length; i++) { + assert(regions_at(i) != NULL, "Should be true by sorting!"); } - for (int i = 0; i < _length; i++) { - assert(_markedRegions.at(i) != NULL, "Should be true by sorting!"); - _markedRegions.at(i)->set_sort_index(i); - } +#endif // ASSERT if (G1PrintRegionLivenessInfo) { G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting"); - for (int i = 0; i < _length; ++i) { - HeapRegion* r = _markedRegions.at(i); + for (uint i = 0; i < _length; ++i) { + HeapRegion* r = regions_at(i); cl.doHeapRegion(r); } } - assert(verify(), "CSet chooser verification"); + verify(); } -size_t CollectionSetChooser::calcMinOldCSetLength() { +uint CollectionSetChooser::calc_min_old_cset_length() { // The min old CSet region bound is based on the maximum desired // number of mixed GCs after a cycle. I.e., even if some old regions // look expensive, we should add them to the CSet anyway to make @@ -291,10 +164,10 @@ if (result * gc_num < region_num) { result += 1; } - return result; + return (uint) result; } -size_t CollectionSetChooser::calcMaxOldCSetLength() { +uint CollectionSetChooser::calc_max_old_cset_length() { // The max old CSet region bound is based on the threshold expressed // as a percentage of the heap size. I.e., it should bound the // number of old regions added to the CSet irrespective of how many @@ -308,23 +181,23 @@ if (100 * result < region_num * perc) { result += 1; } - return result; + return (uint) result; } -void CollectionSetChooser::addMarkedHeapRegion(HeapRegion* hr) { +void CollectionSetChooser::add_region(HeapRegion* hr) { assert(!hr->isHumongous(), "Humongous regions shouldn't be added to the collection set"); assert(!hr->is_young(), "should not be young!"); - _markedRegions.append(hr); + _regions.append(hr); _length++; - _remainingReclaimableBytes += hr->reclaimable_bytes(); + _remaining_reclaimable_bytes += hr->reclaimable_bytes(); hr->calc_gc_efficiency(); } -void CollectionSetChooser::prepareForAddMarkedHeapRegionsPar(size_t n_regions, - size_t chunkSize) { +void CollectionSetChooser::prepare_for_par_region_addition(uint n_regions, + uint chunk_size) { _first_par_unreserved_idx = 0; - int n_threads = ParallelGCThreads; + uint n_threads = (uint) ParallelGCThreads; if (UseDynamicNumberOfGCThreads) { assert(G1CollectedHeap::heap()->workers()->active_workers() > 0, "Should have been set earlier"); @@ -335,57 +208,46 @@ n_threads = MAX2(G1CollectedHeap::heap()->workers()->active_workers(), 1U); } - size_t max_waste = n_threads * chunkSize; - // it should be aligned with respect to chunkSize - size_t aligned_n_regions = - (n_regions + (chunkSize - 1)) / chunkSize * chunkSize; - assert( aligned_n_regions % chunkSize == 0, "should be aligned" ); - _markedRegions.at_put_grow((int)(aligned_n_regions + max_waste - 1), NULL); + uint max_waste = n_threads * chunk_size; + // it should be aligned with respect to chunk_size + uint aligned_n_regions = (n_regions + chunk_size - 1) / chunk_size * chunk_size; + assert(aligned_n_regions % chunk_size == 0, "should be aligned"); + regions_at_put_grow(aligned_n_regions + max_waste - 1, NULL); } -jint CollectionSetChooser::getParMarkedHeapRegionChunk(jint n_regions) { - // Don't do this assert because this can be called at a point - // where the loop up stream will not execute again but might - // try to claim more chunks (loop test has not been done yet). - // assert(_markedRegions.length() > _first_par_unreserved_idx, - // "Striding beyond the marked regions"); - jint res = Atomic::add(n_regions, &_first_par_unreserved_idx); - assert(_markedRegions.length() > res + n_regions - 1, +uint CollectionSetChooser::claim_array_chunk(uint chunk_size) { + uint res = (uint) Atomic::add((jint) chunk_size, + (volatile jint*) &_first_par_unreserved_idx); + assert(regions_length() > res + chunk_size - 1, "Should already have been expanded"); - return res - n_regions; + return res - chunk_size; } -void CollectionSetChooser::setMarkedHeapRegion(jint index, HeapRegion* hr) { - assert(_markedRegions.at(index) == NULL, "precondition"); +void CollectionSetChooser::set_region(uint index, HeapRegion* hr) { + assert(regions_at(index) == NULL, "precondition"); assert(!hr->is_young(), "should not be young!"); - _markedRegions.at_put(index, hr); + regions_at_put(index, hr); hr->calc_gc_efficiency(); } -void CollectionSetChooser::updateTotals(jint region_num, - size_t reclaimable_bytes) { +void CollectionSetChooser::update_totals(uint region_num, + size_t reclaimable_bytes) { // Only take the lock if we actually need to update the totals. if (region_num > 0) { assert(reclaimable_bytes > 0, "invariant"); // We could have just used atomics instead of taking the // lock. However, we currently don't have an atomic add for size_t. MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); - _length += (int) region_num; - _remainingReclaimableBytes += reclaimable_bytes; + _length += region_num; + _remaining_reclaimable_bytes += reclaimable_bytes; } else { assert(reclaimable_bytes == 0, "invariant"); } } -void CollectionSetChooser::clearMarkedHeapRegions() { - for (int i = 0; i < _markedRegions.length(); i++) { - HeapRegion* r = _markedRegions.at(i); - if (r != NULL) { - r->set_sort_index(-1); - } - } - _markedRegions.clear(); +void CollectionSetChooser::clear() { + _regions.clear(); _curr_index = 0; _length = 0; - _remainingReclaimableBytes = 0; + _remaining_reclaimable_bytes = 0; };
--- a/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp Tue May 08 11:29:21 2012 -0700 @@ -28,77 +28,42 @@ #include "gc_implementation/g1/heapRegion.hpp" #include "utilities/growableArray.hpp" -class CSetChooserCache VALUE_OBJ_CLASS_SPEC { -private: - enum { - CacheLength = 16 - } PrivateConstants; - - HeapRegion* _cache[CacheLength]; - int _occupancy; // number of regions in cache - int _first; // (index of) "first" region in the cache - - // adding CacheLength to deal with negative values - inline int trim_index(int index) { - return (index + CacheLength) % CacheLength; - } - - inline int get_sort_index(int index) { - return -index-2; - } - inline int get_index(int sort_index) { - return -sort_index-2; - } - -public: - CSetChooserCache(void); - - inline int occupancy(void) { return _occupancy; } - inline bool is_full() { return _occupancy == CacheLength; } - inline bool is_empty() { return _occupancy == 0; } - - void clear(void); - void insert(HeapRegion *hr); - HeapRegion *remove_first(void); - inline HeapRegion *get_first(void) { - return _cache[_first]; - } - -#ifndef PRODUCT - bool verify (void); - bool region_in_cache(HeapRegion *hr) { - int sort_index = hr->sort_index(); - if (sort_index < -1) { - int index = get_index(sort_index); - guarantee(index < CacheLength, "should be within bounds"); - return _cache[index] == hr; - } else - return 0; - } -#endif // PRODUCT -}; - class CollectionSetChooser: public CHeapObj { - GrowableArray<HeapRegion*> _markedRegions; + GrowableArray<HeapRegion*> _regions; + + // Unfortunately, GrowableArray uses ints for length and indexes. To + // avoid excessive casting in the rest of the class the following + // wrapper methods are provided that use uints. + + uint regions_length() { return (uint) _regions.length(); } + HeapRegion* regions_at(uint i) { return _regions.at((int) i); } + void regions_at_put(uint i, HeapRegion* hr) { + _regions.at_put((int) i, hr); + } + void regions_at_put_grow(uint i, HeapRegion* hr) { + _regions.at_put_grow((int) i, hr); + } + void regions_trunc_to(uint i) { _regions.trunc_to((uint) i); } // The index of the next candidate old region to be considered for // addition to the CSet. - int _curr_index; + uint _curr_index; // The number of candidate old regions added to the CSet chooser. - int _length; + uint _length; - CSetChooserCache _cache; - jint _first_par_unreserved_idx; + // Keeps track of the start of the next array chunk to be claimed by + // parallel GC workers. + uint _first_par_unreserved_idx; // If a region has more live bytes than this threshold, it will not // be added to the CSet chooser and will not be a candidate for // collection. - size_t _regionLiveThresholdBytes; + size_t _region_live_threshold_bytes; // The sum of reclaimable bytes over all the regions in the CSet chooser. - size_t _remainingReclaimableBytes; + size_t _remaining_reclaimable_bytes; public: @@ -107,9 +72,9 @@ HeapRegion* peek() { HeapRegion* res = NULL; if (_curr_index < _length) { - res = _markedRegions.at(_curr_index); + res = regions_at(_curr_index); assert(res != NULL, - err_msg("Unexpected NULL hr in _markedRegions at index %d", + err_msg("Unexpected NULL hr in _regions at index %u", _curr_index)); } return res; @@ -121,90 +86,71 @@ void remove_and_move_to_next(HeapRegion* hr) { assert(hr != NULL, "pre-condition"); assert(_curr_index < _length, "pre-condition"); - assert(_markedRegions.at(_curr_index) == hr, "pre-condition"); - hr->set_sort_index(-1); - _markedRegions.at_put(_curr_index, NULL); - assert(hr->reclaimable_bytes() <= _remainingReclaimableBytes, + assert(regions_at(_curr_index) == hr, "pre-condition"); + regions_at_put(_curr_index, NULL); + assert(hr->reclaimable_bytes() <= _remaining_reclaimable_bytes, err_msg("remaining reclaimable bytes inconsistent " "from region: "SIZE_FORMAT" remaining: "SIZE_FORMAT, - hr->reclaimable_bytes(), _remainingReclaimableBytes)); - _remainingReclaimableBytes -= hr->reclaimable_bytes(); + hr->reclaimable_bytes(), _remaining_reclaimable_bytes)); + _remaining_reclaimable_bytes -= hr->reclaimable_bytes(); _curr_index += 1; } CollectionSetChooser(); - void sortMarkedHeapRegions(); - void fillCache(); + void sort_regions(); // Determine whether to add the given region to the CSet chooser or // not. Currently, we skip humongous regions (we never add them to // the CSet, we only reclaim them during cleanup) and regions whose // live bytes are over the threshold. - bool shouldAdd(HeapRegion* hr) { + bool should_add(HeapRegion* hr) { assert(hr->is_marked(), "pre-condition"); assert(!hr->is_young(), "should never consider young regions"); return !hr->isHumongous() && - hr->live_bytes() < _regionLiveThresholdBytes; + hr->live_bytes() < _region_live_threshold_bytes; } // Calculate the minimum number of old regions we'll add to the CSet // during a mixed GC. - size_t calcMinOldCSetLength(); + uint calc_min_old_cset_length(); // Calculate the maximum number of old regions we'll add to the CSet // during a mixed GC. - size_t calcMaxOldCSetLength(); + uint calc_max_old_cset_length(); // Serial version. - void addMarkedHeapRegion(HeapRegion *hr); + void add_region(HeapRegion *hr); - // Must be called before calls to getParMarkedHeapRegionChunk. - // "n_regions" is the number of regions, "chunkSize" the chunk size. - void prepareForAddMarkedHeapRegionsPar(size_t n_regions, size_t chunkSize); - // Returns the first index in a contiguous chunk of "n_regions" indexes + // Must be called before calls to claim_array_chunk(). + // n_regions is the number of regions, chunk_size the chunk size. + void prepare_for_par_region_addition(uint n_regions, uint chunk_size); + // Returns the first index in a contiguous chunk of chunk_size indexes // that the calling thread has reserved. These must be set by the - // calling thread using "setMarkedHeapRegion" (to NULL if necessary). - jint getParMarkedHeapRegionChunk(jint n_regions); + // calling thread using set_region() (to NULL if necessary). + uint claim_array_chunk(uint chunk_size); // Set the marked array entry at index to hr. Careful to claim the index // first if in parallel. - void setMarkedHeapRegion(jint index, HeapRegion* hr); + void set_region(uint index, HeapRegion* hr); // Atomically increment the number of added regions by region_num // and the amount of reclaimable bytes by reclaimable_bytes. - void updateTotals(jint region_num, size_t reclaimable_bytes); + void update_totals(uint region_num, size_t reclaimable_bytes); - void clearMarkedHeapRegions(); + void clear(); // Return the number of candidate regions that remain to be collected. - size_t remainingRegions() { return _length - _curr_index; } + uint remaining_regions() { return _length - _curr_index; } // Determine whether the CSet chooser has more candidate regions or not. - bool isEmpty() { return remainingRegions() == 0; } + bool is_empty() { return remaining_regions() == 0; } // Return the reclaimable bytes that remain to be collected on // all the candidate regions in the CSet chooser. - size_t remainingReclaimableBytes () { return _remainingReclaimableBytes; } + size_t remaining_reclaimable_bytes() { return _remaining_reclaimable_bytes; } - // Returns true if the used portion of "_markedRegions" is properly + // Returns true if the used portion of "_regions" is properly // sorted, otherwise asserts false. -#ifndef PRODUCT - bool verify(void); - bool regionProperlyOrdered(HeapRegion* r) { - int si = r->sort_index(); - if (si > -1) { - guarantee(_curr_index <= si && si < _length, - err_msg("curr: %d sort index: %d: length: %d", - _curr_index, si, _length)); - guarantee(_markedRegions.at(si) == r, - err_msg("sort index: %d at: "PTR_FORMAT" r: "PTR_FORMAT, - si, _markedRegions.at(si), r)); - } else { - guarantee(si == -1, err_msg("sort index: %d", si)); - } - return true; - } -#endif - + void verify() PRODUCT_RETURN; }; #endif // SHARE_VM_GC_IMPLEMENTATION_G1_COLLECTIONSETCHOOSER_HPP
--- a/src/share/vm/gc_implementation/g1/concurrentMark.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.cpp Tue May 08 11:29:21 2012 -0700 @@ -29,6 +29,7 @@ #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1CollectorPolicy.hpp" #include "gc_implementation/g1/g1ErgoVerbose.hpp" +#include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/g1OopClosures.inline.hpp" #include "gc_implementation/g1/g1RemSet.hpp" #include "gc_implementation/g1/heapRegion.inline.hpp" @@ -103,16 +104,6 @@ return (int) (diff >> _shifter); } -void CMBitMapRO::mostly_disjoint_range_union(BitMap* from_bitmap, - size_t from_start_index, - HeapWord* to_start_word, - size_t word_num) { - _bm.mostly_disjoint_range_union(from_bitmap, - from_start_index, - heapWordToOffset(to_start_word), - word_num); -} - #ifndef PRODUCT bool CMBitMapRO::covers(ReservedSpace rs) const { // assert(_bm.map() == _virtual_space.low(), "map inconsistency"); @@ -271,140 +262,6 @@ } } -CMRegionStack::CMRegionStack() : _base(NULL) {} - -void CMRegionStack::allocate(size_t size) { - _base = NEW_C_HEAP_ARRAY(MemRegion, size); - if (_base == NULL) { - vm_exit_during_initialization("Failed to allocate CM region mark stack"); - } - _index = 0; - _capacity = (jint) size; -} - -CMRegionStack::~CMRegionStack() { - if (_base != NULL) { - FREE_C_HEAP_ARRAY(oop, _base); - } -} - -void CMRegionStack::push_lock_free(MemRegion mr) { - guarantee(false, "push_lock_free(): don't call this any more"); - - assert(mr.word_size() > 0, "Precondition"); - while (true) { - jint index = _index; - - if (index >= _capacity) { - _overflow = true; - return; - } - // Otherwise... - jint next_index = index+1; - jint res = Atomic::cmpxchg(next_index, &_index, index); - if (res == index) { - _base[index] = mr; - return; - } - // Otherwise, we need to try again. - } -} - -// Lock-free pop of the region stack. Called during the concurrent -// marking / remark phases. Should only be called in tandem with -// other lock-free pops. -MemRegion CMRegionStack::pop_lock_free() { - guarantee(false, "pop_lock_free(): don't call this any more"); - - while (true) { - jint index = _index; - - if (index == 0) { - return MemRegion(); - } - // Otherwise... - jint next_index = index-1; - jint res = Atomic::cmpxchg(next_index, &_index, index); - if (res == index) { - MemRegion mr = _base[next_index]; - if (mr.start() != NULL) { - assert(mr.end() != NULL, "invariant"); - assert(mr.word_size() > 0, "invariant"); - return mr; - } else { - // that entry was invalidated... let's skip it - assert(mr.end() == NULL, "invariant"); - } - } - // Otherwise, we need to try again. - } -} - -#if 0 -// The routines that manipulate the region stack with a lock are -// not currently used. They should be retained, however, as a -// diagnostic aid. - -void CMRegionStack::push_with_lock(MemRegion mr) { - assert(mr.word_size() > 0, "Precondition"); - MutexLockerEx x(CMRegionStack_lock, Mutex::_no_safepoint_check_flag); - - if (isFull()) { - _overflow = true; - return; - } - - _base[_index] = mr; - _index += 1; -} - -MemRegion CMRegionStack::pop_with_lock() { - MutexLockerEx x(CMRegionStack_lock, Mutex::_no_safepoint_check_flag); - - while (true) { - if (_index == 0) { - return MemRegion(); - } - _index -= 1; - - MemRegion mr = _base[_index]; - if (mr.start() != NULL) { - assert(mr.end() != NULL, "invariant"); - assert(mr.word_size() > 0, "invariant"); - return mr; - } else { - // that entry was invalidated... let's skip it - assert(mr.end() == NULL, "invariant"); - } - } -} -#endif - -bool CMRegionStack::invalidate_entries_into_cset() { - guarantee(false, "invalidate_entries_into_cset(): don't call this any more"); - - bool result = false; - G1CollectedHeap* g1h = G1CollectedHeap::heap(); - for (int i = 0; i < _oops_do_bound; ++i) { - MemRegion mr = _base[i]; - if (mr.start() != NULL) { - assert(mr.end() != NULL, "invariant"); - assert(mr.word_size() > 0, "invariant"); - HeapRegion* hr = g1h->heap_region_containing(mr.start()); - assert(hr != NULL, "invariant"); - if (hr->in_collection_set()) { - // The region points into the collection set - _base[i] = MemRegion(); - result = true; - } - } else { - // that entry was invalidated... let's skip it - assert(mr.end() == NULL, "invariant"); - } - } - return result; -} - template<class OopClosureClass> bool CMMarkStack::drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after) { assert(!_drain_in_progress || !_drain_in_progress_yields || yield_after @@ -546,8 +403,7 @@ return MAX2((n_par_threads + 2) / 4, 1U); } -ConcurrentMark::ConcurrentMark(ReservedSpace rs, - int max_regions) : +ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : _markBitMap1(rs, MinObjAlignment - 1), _markBitMap2(rs, MinObjAlignment - 1), @@ -558,17 +414,15 @@ _cleanup_sleep_factor(0.0), _cleanup_task_overhead(1.0), _cleanup_list("Cleanup List"), - _region_bm(max_regions, false /* in_resource_area*/), + _region_bm((BitMap::idx_t) max_regions, false /* in_resource_area*/), _card_bm((rs.size() + CardTableModRefBS::card_size - 1) >> CardTableModRefBS::card_shift, false /* in_resource_area*/), _prevMarkBitMap(&_markBitMap1), _nextMarkBitMap(&_markBitMap2), - _at_least_one_mark_complete(false), _markStack(this), - _regionStack(), // _finger set in set_non_marking_state _max_task_num(MAX2((uint)ParallelGCThreads, 1U)), @@ -582,7 +436,6 @@ _has_aborted(false), _restart_for_overflow(false), _concurrent_marking_in_progress(false), - _should_gray_objects(false), // _verbose_level set below @@ -611,7 +464,6 @@ } _markStack.allocate(MarkStackSize); - _regionStack.allocate(G1MarkRegionStackSize); // Create & start a ConcurrentMark thread. _cmThread = new ConcurrentMarkThread(this); @@ -644,7 +496,7 @@ _task_queues->register_queue(i, task_queue); _count_card_bitmaps[i] = BitMap(card_bm_size, false); - _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, max_regions); + _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, (size_t) max_regions); _tasks[i] = new CMTask(i, this, _count_marked_bytes[i], @@ -744,15 +596,7 @@ void ConcurrentMark::update_g1_committed(bool force) { // If concurrent marking is not in progress, then we do not need to - // update _heap_end. This has a subtle and important - // side-effect. Imagine that two evacuation pauses happen between - // marking completion and remark. The first one can grow the - // heap (hence now the finger is below the heap end). Then, the - // second one could unnecessarily push regions on the region - // stack. This causes the invariant that the region stack is empty - // at the beginning of remark to be false. By ensuring that we do - // not observe heap expansions after marking is complete, then we do - // not have this problem. + // update _heap_end. if (!concurrent_marking_in_progress() && !force) return; MemRegion committed = _g1h->g1_committed(); @@ -1002,7 +846,7 @@ clear_marking_state(concurrent() /* clear_overflow */); force_overflow()->update(); - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-mark-reset-for-overflow]"); @@ -1058,86 +902,6 @@ } #endif // !PRODUCT -void ConcurrentMark::grayRegionIfNecessary(MemRegion mr) { - guarantee(false, "grayRegionIfNecessary(): don't call this any more"); - - // The objects on the region have already been marked "in bulk" by - // the caller. We only need to decide whether to push the region on - // the region stack or not. - - if (!concurrent_marking_in_progress() || !_should_gray_objects) { - // We're done with marking and waiting for remark. We do not need to - // push anything else on the region stack. - return; - } - - HeapWord* finger = _finger; - - if (verbose_low()) { - gclog_or_tty->print_cr("[global] attempting to push " - "region ["PTR_FORMAT", "PTR_FORMAT"), finger is at " - PTR_FORMAT, mr.start(), mr.end(), finger); - } - - if (mr.start() < finger) { - // The finger is always heap region aligned and it is not possible - // for mr to span heap regions. - assert(mr.end() <= finger, "invariant"); - - // Separated the asserts so that we know which one fires. - assert(mr.start() <= mr.end(), - "region boundaries should fall within the committed space"); - assert(_heap_start <= mr.start(), - "region boundaries should fall within the committed space"); - assert(mr.end() <= _heap_end, - "region boundaries should fall within the committed space"); - if (verbose_low()) { - gclog_or_tty->print_cr("[global] region ["PTR_FORMAT", "PTR_FORMAT") " - "below the finger, pushing it", - mr.start(), mr.end()); - } - - if (!region_stack_push_lock_free(mr)) { - if (verbose_low()) { - gclog_or_tty->print_cr("[global] region stack has overflown."); - } - } - } -} - -void ConcurrentMark::markAndGrayObjectIfNecessary(oop p) { - guarantee(false, "markAndGrayObjectIfNecessary(): don't call this any more"); - - // The object is not marked by the caller. We need to at least mark - // it and maybe push in on the stack. - - HeapWord* addr = (HeapWord*)p; - if (!_nextMarkBitMap->isMarked(addr)) { - // We definitely need to mark it, irrespective whether we bail out - // because we're done with marking. - if (_nextMarkBitMap->parMark(addr)) { - if (!concurrent_marking_in_progress() || !_should_gray_objects) { - // If we're done with concurrent marking and we're waiting for - // remark, then we're not pushing anything on the stack. - return; - } - - // No OrderAccess:store_load() is needed. It is implicit in the - // CAS done in parMark(addr) above - HeapWord* finger = _finger; - - if (addr < finger) { - if (!mark_stack_push(oop(addr))) { - if (verbose_low()) { - gclog_or_tty->print_cr("[global] global stack overflow " - "during parMark"); - } - } - } - } - } -} - class CMConcurrentMarkingTask: public AbstractGangTask { private: ConcurrentMark* _cm; @@ -1355,8 +1119,7 @@ HandleMark hm; // handle scope gclog_or_tty->print(" VerifyDuringGC:(before)"); Universe::heap()->prepare_for_verify(); - Universe::verify(/* allow dirty */ true, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UsePrevMarking); } @@ -1395,8 +1158,7 @@ HandleMark hm; // handle scope gclog_or_tty->print(" VerifyDuringGC:(after)"); Universe::heap()->prepare_for_verify(); - Universe::verify(/* allow dirty */ true, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UseNextMarking); } assert(!restart_for_overflow(), "sanity"); @@ -1430,11 +1192,6 @@ BitMap* _region_bm; BitMap* _card_bm; - // Debugging - size_t _tot_words_done; - size_t _tot_live; - size_t _tot_used; - size_t _region_marked_bytes; intptr_t _bottom_card_num; @@ -1453,9 +1210,7 @@ CalcLiveObjectsClosure(CMBitMapRO *bm, ConcurrentMark *cm, BitMap* region_bm, BitMap* card_bm) : _bm(bm), _cm(cm), _region_bm(region_bm), _card_bm(card_bm), - _region_marked_bytes(0), _tot_words_done(0), - _tot_live(0), _tot_used(0), - _bottom_card_num(cm->heap_bottom_card_num()) { } + _region_marked_bytes(0), _bottom_card_num(cm->heap_bottom_card_num()) { } // It takes a region that's not empty (i.e., it has at least one // live object in it and sets its corresponding bit on the region @@ -1465,18 +1220,17 @@ void set_bit_for_region(HeapRegion* hr) { assert(!hr->continuesHumongous(), "should have filtered those out"); - size_t index = hr->hrs_index(); + BitMap::idx_t index = (BitMap::idx_t) hr->hrs_index(); if (!hr->startsHumongous()) { // Normal (non-humongous) case: just set the bit. - _region_bm->par_at_put((BitMap::idx_t) index, true); + _region_bm->par_at_put(index, true); } else { // Starts humongous case: calculate how many regions are part of // this humongous region and then set the bit range. G1CollectedHeap* g1h = G1CollectedHeap::heap(); HeapRegion *last_hr = g1h->heap_region_containing_raw(hr->end() - 1); - size_t end_index = last_hr->hrs_index() + 1; - _region_bm->par_at_put_range((BitMap::idx_t) index, - (BitMap::idx_t) end_index, true); + BitMap::idx_t end_index = (BitMap::idx_t) last_hr->hrs_index() + 1; + _region_bm->par_at_put_range(index, end_index, true); } } @@ -1501,9 +1255,6 @@ "start: "PTR_FORMAT", nextTop: "PTR_FORMAT", end: "PTR_FORMAT, start, nextTop, hr->end())); - // Record the number of word's we'll examine. - size_t words_done = (nextTop - start); - // Find the first marked object at or after "start". start = _bm->getNextMarkedWordAddress(start, nextTop); @@ -1582,19 +1333,10 @@ // it can be queried by a calling verificiation routine _region_marked_bytes = marked_bytes; - _tot_live += hr->next_live_bytes(); - _tot_used += hr->used(); - _tot_words_done = words_done; - return false; } size_t region_marked_bytes() const { return _region_marked_bytes; } - - // Debugging - size_t tot_words_done() const { return _tot_words_done; } - size_t tot_live() const { return _tot_live; } - size_t tot_used() const { return _tot_used; } }; // Heap region closure used for verifying the counting data @@ -1655,7 +1397,7 @@ // Verify that _top_at_conc_count == ntams if (hr->top_at_conc_mark_count() != hr->next_top_at_mark_start()) { if (_verbose) { - gclog_or_tty->print_cr("Region " SIZE_FORMAT ": top at conc count incorrect: " + gclog_or_tty->print_cr("Region %u: top at conc count incorrect: " "expected " PTR_FORMAT ", actual: " PTR_FORMAT, hr->hrs_index(), hr->next_top_at_mark_start(), hr->top_at_conc_mark_count()); @@ -1671,7 +1413,7 @@ // we have missed accounting some objects during the actual marking. if (exp_marked_bytes > act_marked_bytes) { if (_verbose) { - gclog_or_tty->print_cr("Region " SIZE_FORMAT ": marked bytes mismatch: " + gclog_or_tty->print_cr("Region %u: marked bytes mismatch: " "expected: " SIZE_FORMAT ", actual: " SIZE_FORMAT, hr->hrs_index(), exp_marked_bytes, act_marked_bytes); } @@ -1682,15 +1424,16 @@ // (which was just calculated) region bit maps. // We're not OK if the bit in the calculated expected region // bitmap is set and the bit in the actual region bitmap is not. - BitMap::idx_t index = (BitMap::idx_t)hr->hrs_index(); + BitMap::idx_t index = (BitMap::idx_t) hr->hrs_index(); bool expected = _exp_region_bm->at(index); bool actual = _region_bm->at(index); if (expected && !actual) { if (_verbose) { - gclog_or_tty->print_cr("Region " SIZE_FORMAT ": region bitmap mismatch: " - "expected: %d, actual: %d", - hr->hrs_index(), expected, actual); + gclog_or_tty->print_cr("Region %u: region bitmap mismatch: " + "expected: %s, actual: %s", + hr->hrs_index(), + BOOL_TO_STR(expected), BOOL_TO_STR(actual)); } failures += 1; } @@ -1708,9 +1451,10 @@ if (expected && !actual) { if (_verbose) { - gclog_or_tty->print_cr("Region " SIZE_FORMAT ": card bitmap mismatch at " SIZE_FORMAT ": " - "expected: %d, actual: %d", - hr->hrs_index(), i, expected, actual); + gclog_or_tty->print_cr("Region %u: card bitmap mismatch at " SIZE_FORMAT ": " + "expected: %s, actual: %s", + hr->hrs_index(), i, + BOOL_TO_STR(expected), BOOL_TO_STR(actual)); } failures += 1; } @@ -1811,10 +1555,6 @@ BitMap* _region_bm; BitMap* _card_bm; - size_t _total_live_bytes; - size_t _total_used_bytes; - size_t _total_words_done; - void set_card_bitmap_range(BitMap::idx_t start_idx, BitMap::idx_t last_idx) { assert(start_idx <= last_idx, "sanity"); @@ -1840,18 +1580,17 @@ void set_bit_for_region(HeapRegion* hr) { assert(!hr->continuesHumongous(), "should have filtered those out"); - size_t index = hr->hrs_index(); + BitMap::idx_t index = (BitMap::idx_t) hr->hrs_index(); if (!hr->startsHumongous()) { // Normal (non-humongous) case: just set the bit. - _region_bm->par_set_bit((BitMap::idx_t) index); + _region_bm->par_set_bit(index); } else { // Starts humongous case: calculate how many regions are part of // this humongous region and then set the bit range. G1CollectedHeap* g1h = G1CollectedHeap::heap(); HeapRegion *last_hr = g1h->heap_region_containing_raw(hr->end() - 1); - size_t end_index = last_hr->hrs_index() + 1; - _region_bm->par_at_put_range((BitMap::idx_t) index, - (BitMap::idx_t) end_index, true); + BitMap::idx_t end_index = (BitMap::idx_t) last_hr->hrs_index() + 1; + _region_bm->par_at_put_range(index, end_index, true); } } @@ -1859,8 +1598,7 @@ FinalCountDataUpdateClosure(ConcurrentMark* cm, BitMap* region_bm, BitMap* card_bm) : - _cm(cm), _region_bm(region_bm), _card_bm(card_bm), - _total_words_done(0), _total_live_bytes(0), _total_used_bytes(0) { } + _cm(cm), _region_bm(region_bm), _card_bm(card_bm) { } bool doHeapRegion(HeapRegion* hr) { @@ -1882,8 +1620,6 @@ assert(hr->bottom() <= start && start <= hr->end() && hr->bottom() <= ntams && ntams <= hr->end(), "Preconditions."); - size_t words_done = ntams - hr->bottom(); - if (start < ntams) { // Region was changed between remark and cleanup pauses // We need to add (ntams - start) to the marked bytes @@ -1914,16 +1650,8 @@ set_bit_for_region(hr); } - _total_words_done += words_done; - _total_used_bytes += hr->used(); - _total_live_bytes += hr->next_marked_bytes(); - return false; } - - size_t total_words_done() const { return _total_words_done; } - size_t total_live_bytes() const { return _total_live_bytes; } - size_t total_used_bytes() const { return _total_used_bytes; } }; class G1ParFinalCountTask: public AbstractGangTask { @@ -1935,9 +1663,6 @@ uint _n_workers; - size_t *_live_bytes; - size_t *_used_bytes; - public: G1ParFinalCountTask(G1CollectedHeap* g1h, BitMap* region_bm, BitMap* card_bm) : AbstractGangTask("G1 final counting"), @@ -1945,8 +1670,7 @@ _actual_region_bm(region_bm), _actual_card_bm(card_bm), _n_workers(0) { // Use the value already set as the number of active threads - // in the call to run_task(). Needed for the allocation of - // _live_bytes and _used_bytes. + // in the call to run_task(). if (G1CollectedHeap::use_parallel_gc_threads()) { assert( _g1h->workers()->active_workers() > 0, "Should have been previously set"); @@ -1954,14 +1678,6 @@ } else { _n_workers = 1; } - - _live_bytes = NEW_C_HEAP_ARRAY(size_t, _n_workers); - _used_bytes = NEW_C_HEAP_ARRAY(size_t, _n_workers); - } - - ~G1ParFinalCountTask() { - FREE_C_HEAP_ARRAY(size_t, _live_bytes); - FREE_C_HEAP_ARRAY(size_t, _used_bytes); } void work(uint worker_id) { @@ -1979,23 +1695,6 @@ } else { _g1h->heap_region_iterate(&final_update_cl); } - - _live_bytes[worker_id] = final_update_cl.total_live_bytes(); - _used_bytes[worker_id] = final_update_cl.total_used_bytes(); - } - - size_t live_bytes() { - size_t live_bytes = 0; - for (uint i = 0; i < _n_workers; ++i) - live_bytes += _live_bytes[i]; - return live_bytes; - } - - size_t used_bytes() { - size_t used_bytes = 0; - for (uint i = 0; i < _n_workers; ++i) - used_bytes += _used_bytes[i]; - return used_bytes; } }; @@ -2005,7 +1704,7 @@ G1CollectedHeap* _g1; int _worker_num; size_t _max_live_bytes; - size_t _regions_claimed; + uint _regions_claimed; size_t _freed_bytes; FreeRegionList* _local_cleanup_list; OldRegionSet* _old_proxy_set; @@ -2058,7 +1757,7 @@ } size_t max_live_bytes() { return _max_live_bytes; } - size_t regions_claimed() { return _regions_claimed; } + uint regions_claimed() { return _regions_claimed; } double claimed_region_time_sec() { return _claimed_region_time; } double max_region_time_sec() { return _max_region_time; } }; @@ -2130,15 +1829,6 @@ HeapRegionRemSet::finish_cleanup_task(&hrrs_cleanup_task); } - double end = os::elapsedTime(); - if (G1PrintParCleanupStats) { - gclog_or_tty->print(" Worker thread %d [%8.3f..%8.3f = %8.3f ms] " - "claimed %u regions (tot = %8.3f ms, max = %8.3f ms).\n", - worker_id, start, end, (end-start)*1000.0, - g1_note_end.regions_claimed(), - g1_note_end.claimed_region_time_sec()*1000.0, - g1_note_end.max_region_time_sec()*1000.0); - } } size_t max_live_bytes() { return _max_live_bytes; } size_t freed_bytes() { return _freed_bytes; } @@ -2185,8 +1875,7 @@ HandleMark hm; // handle scope gclog_or_tty->print(" VerifyDuringGC:(before)"); Universe::heap()->prepare_for_verify(); - Universe::verify(/* allow dirty */ true, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UsePrevMarking); } @@ -2250,30 +1939,11 @@ guarantee(g1_par_verify_task.failures() == 0, "Unexpected accounting failures"); } - size_t known_garbage_bytes = - g1_par_count_task.used_bytes() - g1_par_count_task.live_bytes(); - g1p->set_known_garbage_bytes(known_garbage_bytes); - size_t start_used_bytes = g1h->used(); - _at_least_one_mark_complete = true; g1h->set_marking_complete(); - ergo_verbose4(ErgoConcCycles, - "finish cleanup", - ergo_format_byte("occupancy") - ergo_format_byte("capacity") - ergo_format_byte_perc("known garbage"), - start_used_bytes, g1h->capacity(), - known_garbage_bytes, - ((double) known_garbage_bytes / (double) g1h->capacity()) * 100.0); - double count_end = os::elapsedTime(); double this_final_counting_time = (count_end - start); - if (G1PrintParCleanupStats) { - gclog_or_tty->print_cr("Cleanup:"); - gclog_or_tty->print_cr(" Finalize counting: %8.3f ms", - this_final_counting_time*1000.0); - } _total_counting_time += this_final_counting_time; if (G1PrintRegionLivenessInfo) { @@ -2287,7 +1957,6 @@ g1h->reset_gc_time_stamp(); // Note end of marking in all heap regions. - double note_end_start = os::elapsedTime(); G1ParNoteEndTask g1_par_note_end_task(g1h, &_cleanup_list); if (G1CollectedHeap::use_parallel_gc_threads()) { g1h->set_par_threads((int)n_workers); @@ -2306,11 +1975,6 @@ // regions that there will be more free regions coming soon. g1h->set_free_regions_coming(); } - double note_end_end = os::elapsedTime(); - if (G1PrintParCleanupStats) { - gclog_or_tty->print_cr(" note end of marking: %8.3f ms.", - (note_end_end - note_end_start)*1000.0); - } // call below, since it affects the metric by which we sort the heap // regions. @@ -2342,16 +2006,13 @@ double end = os::elapsedTime(); _cleanup_times.add((end - start) * 1000.0); - if (PrintGC || PrintGCDetails) { + if (G1Log::fine()) { g1h->print_size_transition(gclog_or_tty, start_used_bytes, g1h->used(), g1h->capacity()); } - size_t cleaned_up_bytes = start_used_bytes - g1h->used(); - g1p->decrease_known_garbage_bytes(cleaned_up_bytes); - // Clean up will have freed any regions completely full of garbage. // Update the soft reference policy with the new heap occupancy. Universe::update_heap_info_at_gc(); @@ -2368,8 +2029,7 @@ HandleMark hm; // handle scope gclog_or_tty->print(" VerifyDuringGC:(after)"); Universe::heap()->prepare_for_verify(); - Universe::verify(/* allow dirty */ true, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UsePrevMarking); } @@ -2386,7 +2046,7 @@ if (G1ConcRegionFreeingVerbose) { gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : " - "cleanup list has "SIZE_FORMAT" entries", + "cleanup list has %u entries", _cleanup_list.length()); } @@ -2408,9 +2068,8 @@ _cleanup_list.is_empty()) { if (G1ConcRegionFreeingVerbose) { gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : " - "appending "SIZE_FORMAT" entries to the " - "secondary_free_list, clean list still has " - SIZE_FORMAT" entries", + "appending %u entries to the secondary_free_list, " + "cleanup list still has %u entries", tmp_free_list.length(), _cleanup_list.length()); } @@ -2683,11 +2342,10 @@ // Inner scope to exclude the cleaning of the string and symbol // tables from the displayed time. { - bool verbose = PrintGC && PrintGCDetails; - if (verbose) { + if (G1Log::finer()) { gclog_or_tty->put(' '); } - TraceTime t("GC ref-proc", verbose, false, gclog_or_tty); + TraceTime t("GC ref-proc", G1Log::finer(), false, gclog_or_tty); ReferenceProcessor* rp = g1h->ref_processor_cm(); @@ -3066,89 +2724,6 @@ #endif // PRODUCT -// This note is for drainAllSATBBuffers and the code in between. -// In the future we could reuse a task to do this work during an -// evacuation pause (since now tasks are not active and can be claimed -// during an evacuation pause). This was a late change to the code and -// is currently not being taken advantage of. - -void ConcurrentMark::deal_with_reference(oop obj) { - if (verbose_high()) { - gclog_or_tty->print_cr("[global] we're dealing with reference "PTR_FORMAT, - (void*) obj); - } - - HeapWord* objAddr = (HeapWord*) obj; - assert(obj->is_oop_or_null(true /* ignore mark word */), "Error"); - if (_g1h->is_in_g1_reserved(objAddr)) { - assert(obj != NULL, "null check is implicit"); - if (!_nextMarkBitMap->isMarked(objAddr)) { - // Only get the containing region if the object is not marked on the - // bitmap (otherwise, it's a waste of time since we won't do - // anything with it). - HeapRegion* hr = _g1h->heap_region_containing_raw(obj); - if (!hr->obj_allocated_since_next_marking(obj)) { - if (verbose_high()) { - gclog_or_tty->print_cr("[global] "PTR_FORMAT" is not considered " - "marked", (void*) obj); - } - - // we need to mark it first - if (_nextMarkBitMap->parMark(objAddr)) { - // No OrderAccess:store_load() is needed. It is implicit in the - // CAS done in parMark(objAddr) above - HeapWord* finger = _finger; - if (objAddr < finger) { - if (verbose_high()) { - gclog_or_tty->print_cr("[global] below the global finger " - "("PTR_FORMAT"), pushing it", finger); - } - if (!mark_stack_push(obj)) { - if (verbose_low()) { - gclog_or_tty->print_cr("[global] global stack overflow during " - "deal_with_reference"); - } - } - } - } - } - } - } -} - -class CMGlobalObjectClosure : public ObjectClosure { -private: - ConcurrentMark* _cm; - -public: - void do_object(oop obj) { - _cm->deal_with_reference(obj); - } - - CMGlobalObjectClosure(ConcurrentMark* cm) : _cm(cm) { } -}; - -void ConcurrentMark::drainAllSATBBuffers() { - guarantee(false, "drainAllSATBBuffers(): don't call this any more"); - - CMGlobalObjectClosure oc(this); - SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set(); - satb_mq_set.set_closure(&oc); - - while (satb_mq_set.apply_closure_to_completed_buffer()) { - if (verbose_medium()) { - gclog_or_tty->print_cr("[global] processed an SATB buffer"); - } - } - - // no need to check whether we should do this, as this is only - // called during an evacuation pause - satb_mq_set.iterate_closure_all_threads(); - - satb_mq_set.set_closure(NULL); - assert(satb_mq_set.completed_buffers_num() == 0, "invariant"); -} - void ConcurrentMark::clearRangePrevBitmap(MemRegion mr) { // Note we are overriding the read-only view of the prev map here, via // the cast. @@ -3257,63 +2832,6 @@ return NULL; } -bool ConcurrentMark::invalidate_aborted_regions_in_cset() { - guarantee(false, "invalidate_aborted_regions_in_cset(): " - "don't call this any more"); - - bool result = false; - for (int i = 0; i < (int)_max_task_num; ++i) { - CMTask* the_task = _tasks[i]; - MemRegion mr = the_task->aborted_region(); - if (mr.start() != NULL) { - assert(mr.end() != NULL, "invariant"); - assert(mr.word_size() > 0, "invariant"); - HeapRegion* hr = _g1h->heap_region_containing(mr.start()); - assert(hr != NULL, "invariant"); - if (hr->in_collection_set()) { - // The region points into the collection set - the_task->set_aborted_region(MemRegion()); - result = true; - } - } - } - return result; -} - -bool ConcurrentMark::has_aborted_regions() { - for (int i = 0; i < (int)_max_task_num; ++i) { - CMTask* the_task = _tasks[i]; - MemRegion mr = the_task->aborted_region(); - if (mr.start() != NULL) { - assert(mr.end() != NULL, "invariant"); - assert(mr.word_size() > 0, "invariant"); - return true; - } - } - return false; -} - -void ConcurrentMark::oops_do(OopClosure* cl) { - if (_markStack.size() > 0 && verbose_low()) { - gclog_or_tty->print_cr("[global] scanning the global marking stack, " - "size = %d", _markStack.size()); - } - // we first iterate over the contents of the mark stack... - _markStack.oops_do(cl); - - for (int i = 0; i < (int)_max_task_num; ++i) { - OopTaskQueue* queue = _task_queues->queue((int)i); - - if (queue->size() > 0 && verbose_low()) { - gclog_or_tty->print_cr("[global] scanning task queue of task %d, " - "size = %d", i, queue->size()); - } - - // ...then over the contents of the all the task queues. - queue->oops_do(cl); - } -} - #ifndef PRODUCT enum VerifyNoCSetOopsPhase { VerifyNoCSetOopsStack, @@ -3445,8 +2963,6 @@ void ConcurrentMark::clear_marking_state(bool clear_overflow) { _markStack.setEmpty(); _markStack.clear_overflow(); - _regionStack.setEmpty(); - _regionStack.clear_overflow(); if (clear_overflow) { clear_has_overflown(); } else { @@ -3457,8 +2973,6 @@ for (int i = 0; i < (int)_max_task_num; ++i) { OopTaskQueue* queue = _task_queues->queue(i); queue->set_empty(); - // Clear any partial regions from the CMTasks - _tasks[i]->clear_aborted_region(); } } @@ -3525,7 +3039,7 @@ assert(limit_idx <= end_idx, "or else use atomics"); // Aggregate the "stripe" in the count data associated with hr. - size_t hrs_index = hr->hrs_index(); + uint hrs_index = hr->hrs_index(); size_t marked_bytes = 0; for (int i = 0; (size_t)i < _max_task_num; i += 1) { @@ -3633,7 +3147,7 @@ // of the final counting task. _region_bm.clear(); - size_t max_regions = _g1h->max_regions(); + uint max_regions = _g1h->max_regions(); assert(_max_task_num != 0, "unitialized"); for (int i = 0; (size_t) i < _max_task_num; i += 1) { @@ -3643,7 +3157,7 @@ assert(task_card_bm->size() == _card_bm.size(), "size mismatch"); assert(marked_bytes_array != NULL, "uninitialized"); - memset(marked_bytes_array, 0, (max_regions * sizeof(size_t))); + memset(marked_bytes_array, 0, (size_t) max_regions * sizeof(size_t)); task_card_bm->clear(); } } @@ -3658,327 +3172,6 @@ } } -// Closures used by ConcurrentMark::complete_marking_in_collection_set(). - -class CSetMarkOopClosure: public OopClosure { - friend class CSetMarkBitMapClosure; - - G1CollectedHeap* _g1h; - CMBitMap* _bm; - ConcurrentMark* _cm; - oop* _ms; - jint* _array_ind_stack; - int _ms_size; - int _ms_ind; - int _array_increment; - uint _worker_id; - - bool push(oop obj, int arr_ind = 0) { - if (_ms_ind == _ms_size) { - gclog_or_tty->print_cr("Mark stack is full."); - return false; - } - _ms[_ms_ind] = obj; - if (obj->is_objArray()) { - _array_ind_stack[_ms_ind] = arr_ind; - } - _ms_ind++; - return true; - } - - oop pop() { - if (_ms_ind == 0) { - return NULL; - } else { - _ms_ind--; - return _ms[_ms_ind]; - } - } - - template <class T> bool drain() { - while (_ms_ind > 0) { - oop obj = pop(); - assert(obj != NULL, "Since index was non-zero."); - if (obj->is_objArray()) { - jint arr_ind = _array_ind_stack[_ms_ind]; - objArrayOop aobj = objArrayOop(obj); - jint len = aobj->length(); - jint next_arr_ind = arr_ind + _array_increment; - if (next_arr_ind < len) { - push(obj, next_arr_ind); - } - // Now process this portion of this one. - int lim = MIN2(next_arr_ind, len); - for (int j = arr_ind; j < lim; j++) { - do_oop(aobj->objArrayOopDesc::obj_at_addr<T>(j)); - } - } else { - obj->oop_iterate(this); - } - if (abort()) return false; - } - return true; - } - -public: - CSetMarkOopClosure(ConcurrentMark* cm, int ms_size, uint worker_id) : - _g1h(G1CollectedHeap::heap()), - _cm(cm), - _bm(cm->nextMarkBitMap()), - _ms_size(ms_size), _ms_ind(0), - _ms(NEW_C_HEAP_ARRAY(oop, ms_size)), - _array_ind_stack(NEW_C_HEAP_ARRAY(jint, ms_size)), - _array_increment(MAX2(ms_size/8, 16)), - _worker_id(worker_id) { } - - ~CSetMarkOopClosure() { - FREE_C_HEAP_ARRAY(oop, _ms); - FREE_C_HEAP_ARRAY(jint, _array_ind_stack); - } - - virtual void do_oop(narrowOop* p) { do_oop_work(p); } - virtual void do_oop( oop* p) { do_oop_work(p); } - - template <class T> void do_oop_work(T* p) { - T heap_oop = oopDesc::load_heap_oop(p); - if (oopDesc::is_null(heap_oop)) return; - oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); - if (obj->is_forwarded()) { - // If the object has already been forwarded, we have to make sure - // that it's marked. So follow the forwarding pointer. Note that - // this does the right thing for self-forwarding pointers in the - // evacuation failure case. - obj = obj->forwardee(); - } - HeapRegion* hr = _g1h->heap_region_containing(obj); - if (hr != NULL) { - if (hr->in_collection_set()) { - if (_g1h->is_obj_ill(obj)) { - if (_bm->parMark((HeapWord*)obj)) { - if (!push(obj)) { - gclog_or_tty->print_cr("Setting abort in CSetMarkOopClosure because push failed."); - set_abort(); - } - } - } - } else { - // Outside the collection set; we need to gray it - _cm->deal_with_reference(obj); - } - } - } -}; - -class CSetMarkBitMapClosure: public BitMapClosure { - G1CollectedHeap* _g1h; - CMBitMap* _bitMap; - ConcurrentMark* _cm; - CSetMarkOopClosure _oop_cl; - uint _worker_id; - -public: - CSetMarkBitMapClosure(ConcurrentMark* cm, int ms_size, int worker_id) : - _g1h(G1CollectedHeap::heap()), - _bitMap(cm->nextMarkBitMap()), - _oop_cl(cm, ms_size, worker_id), - _worker_id(worker_id) { } - - bool do_bit(size_t offset) { - // convert offset into a HeapWord* - HeapWord* addr = _bitMap->offsetToHeapWord(offset); - assert(_bitMap->endWord() && addr < _bitMap->endWord(), - "address out of range"); - assert(_bitMap->isMarked(addr), "tautology"); - oop obj = oop(addr); - if (!obj->is_forwarded()) { - if (!_oop_cl.push(obj)) return false; - if (UseCompressedOops) { - if (!_oop_cl.drain<narrowOop>()) return false; - } else { - if (!_oop_cl.drain<oop>()) return false; - } - } - // Otherwise... - return true; - } -}; - -class CompleteMarkingInCSetHRClosure: public HeapRegionClosure { - CMBitMap* _bm; - CSetMarkBitMapClosure _bit_cl; - uint _worker_id; - - enum SomePrivateConstants { - MSSize = 1000 - }; - -public: - CompleteMarkingInCSetHRClosure(ConcurrentMark* cm, int worker_id) : - _bm(cm->nextMarkBitMap()), - _bit_cl(cm, MSSize, worker_id), - _worker_id(worker_id) { } - - bool doHeapRegion(HeapRegion* hr) { - if (hr->claimHeapRegion(HeapRegion::CompleteMarkCSetClaimValue)) { - // The current worker has successfully claimed the region. - if (!hr->evacuation_failed()) { - MemRegion mr = MemRegion(hr->bottom(), hr->next_top_at_mark_start()); - if (!mr.is_empty()) { - bool done = false; - while (!done) { - done = _bm->iterate(&_bit_cl, mr); - } - } - } - } - return false; - } -}; - -class G1ParCompleteMarkInCSetTask: public AbstractGangTask { -protected: - G1CollectedHeap* _g1h; - ConcurrentMark* _cm; - -public: - G1ParCompleteMarkInCSetTask(G1CollectedHeap* g1h, - ConcurrentMark* cm) : - AbstractGangTask("Complete Mark in CSet"), - _g1h(g1h), _cm(cm) { } - - void work(uint worker_id) { - CompleteMarkingInCSetHRClosure cmplt(_cm, worker_id); - HeapRegion* hr = _g1h->start_cset_region_for_worker(worker_id); - _g1h->collection_set_iterate_from(hr, &cmplt); - } -}; - -void ConcurrentMark::complete_marking_in_collection_set() { - guarantee(false, "complete_marking_in_collection_set(): " - "don't call this any more"); - - G1CollectedHeap* g1h = G1CollectedHeap::heap(); - - if (!g1h->mark_in_progress()) { - g1h->g1_policy()->record_mark_closure_time(0.0); - return; - } - - double start = os::elapsedTime(); - G1ParCompleteMarkInCSetTask complete_mark_task(g1h, this); - - assert(g1h->check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); - - if (G1CollectedHeap::use_parallel_gc_threads()) { - int n_workers = g1h->workers()->active_workers(); - g1h->set_par_threads(n_workers); - g1h->workers()->run_task(&complete_mark_task); - g1h->set_par_threads(0); - } else { - complete_mark_task.work(0); - } - - assert(g1h->check_cset_heap_region_claim_values(HeapRegion::CompleteMarkCSetClaimValue), "sanity"); - - // Reset the claim values in the regions in the collection set. - g1h->reset_cset_heap_region_claim_values(); - - assert(g1h->check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); - - double end_time = os::elapsedTime(); - double elapsed_time_ms = (end_time - start) * 1000.0; - g1h->g1_policy()->record_mark_closure_time(elapsed_time_ms); -} - -// The next two methods deal with the following optimisation. Some -// objects are gray by being marked and located above the finger. If -// they are copied, during an evacuation pause, below the finger then -// the need to be pushed on the stack. The observation is that, if -// there are no regions in the collection set located above the -// finger, then the above cannot happen, hence we do not need to -// explicitly gray any objects when copying them to below the -// finger. The global stack will be scanned to ensure that, if it -// points to objects being copied, it will update their -// location. There is a tricky situation with the gray objects in -// region stack that are being coped, however. See the comment in -// newCSet(). - -void ConcurrentMark::newCSet() { - guarantee(false, "newCSet(): don't call this any more"); - - if (!concurrent_marking_in_progress()) { - // nothing to do if marking is not in progress - return; - } - - // find what the lowest finger is among the global and local fingers - _min_finger = _finger; - for (int i = 0; i < (int)_max_task_num; ++i) { - CMTask* task = _tasks[i]; - HeapWord* task_finger = task->finger(); - if (task_finger != NULL && task_finger < _min_finger) { - _min_finger = task_finger; - } - } - - _should_gray_objects = false; - - // This fixes a very subtle and fustrating bug. It might be the case - // that, during en evacuation pause, heap regions that contain - // objects that are gray (by being in regions contained in the - // region stack) are included in the collection set. Since such gray - // objects will be moved, and because it's not easy to redirect - // region stack entries to point to a new location (because objects - // in one region might be scattered to multiple regions after they - // are copied), one option is to ensure that all marked objects - // copied during a pause are pushed on the stack. Notice, however, - // that this problem can only happen when the region stack is not - // empty during an evacuation pause. So, we make the fix a bit less - // conservative and ensure that regions are pushed on the stack, - // irrespective whether all collection set regions are below the - // finger, if the region stack is not empty. This is expected to be - // a rare case, so I don't think it's necessary to be smarted about it. - if (!region_stack_empty() || has_aborted_regions()) { - _should_gray_objects = true; - } -} - -void ConcurrentMark::registerCSetRegion(HeapRegion* hr) { - guarantee(false, "registerCSetRegion(): don't call this any more"); - - if (!concurrent_marking_in_progress()) return; - - HeapWord* region_end = hr->end(); - if (region_end > _min_finger) { - _should_gray_objects = true; - } -} - -// Resets the region fields of active CMTasks whose values point -// into the collection set. -void ConcurrentMark::reset_active_task_region_fields_in_cset() { - guarantee(false, "reset_active_task_region_fields_in_cset(): " - "don't call this any more"); - - assert(SafepointSynchronize::is_at_safepoint(), "should be in STW"); - assert(parallel_marking_threads() <= _max_task_num, "sanity"); - - for (int i = 0; i < (int)parallel_marking_threads(); i += 1) { - CMTask* task = _tasks[i]; - HeapWord* task_finger = task->finger(); - if (task_finger != NULL) { - assert(_g1h->is_in_g1_reserved(task_finger), "not in heap"); - HeapRegion* finger_region = _g1h->heap_region_containing(task_finger); - if (finger_region->in_collection_set()) { - // The task's current region is in the collection set. - // This region will be evacuated in the current GC and - // the region fields in the task will be stale. - task->giveup_current_region(); - } - } - } -} - // abandon current marking iteration due to a Full GC void ConcurrentMark::abort() { // Clear all marks to force marking thread to do nothing @@ -4112,36 +3305,21 @@ CMBitMap* _nextMarkBitMap; ConcurrentMark* _cm; CMTask* _task; - // true if we're scanning a heap region claimed by the task (so that - // we move the finger along), false if we're not, i.e. currently when - // scanning a heap region popped from the region stack (so that we - // do not move the task finger along; it'd be a mistake if we did so). - bool _scanning_heap_region; public: - CMBitMapClosure(CMTask *task, - ConcurrentMark* cm, - CMBitMap* nextMarkBitMap) - : _task(task), _cm(cm), _nextMarkBitMap(nextMarkBitMap) { } - - void set_scanning_heap_region(bool scanning_heap_region) { - _scanning_heap_region = scanning_heap_region; - } + CMBitMapClosure(CMTask *task, ConcurrentMark* cm, CMBitMap* nextMarkBitMap) : + _task(task), _cm(cm), _nextMarkBitMap(nextMarkBitMap) { } bool do_bit(size_t offset) { HeapWord* addr = _nextMarkBitMap->offsetToHeapWord(offset); assert(_nextMarkBitMap->isMarked(addr), "invariant"); assert( addr < _cm->finger(), "invariant"); - if (_scanning_heap_region) { - statsOnly( _task->increase_objs_found_on_bitmap() ); - assert(addr >= _task->finger(), "invariant"); - // We move that task's local finger along. - _task->move_finger_to(addr); - } else { - // We move the task's region finger along. - _task->move_region_finger_to(addr); - } + statsOnly( _task->increase_objs_found_on_bitmap() ); + assert(addr >= _task->finger(), "invariant"); + + // We move that task's local finger along. + _task->move_finger_to(addr); _task->scan_object(oop(addr)); // we only partially drain the local queue and global stack @@ -4249,8 +3427,6 @@ _curr_region = NULL; _finger = NULL; _region_limit = NULL; - - _region_finger = NULL; } void CMTask::set_cm_oop_closure(G1CMOopClosure* cm_oop_closure) { @@ -4271,7 +3447,6 @@ _nextMarkBitMap = nextMarkBitMap; clear_region_fields(); - assert(_aborted_region.is_empty(), "should have been cleared"); _calls = 0; _elapsed_time_ms = 0.0; @@ -4288,7 +3463,6 @@ _global_max_size = 0; _global_transfers_to = 0; _global_transfers_from = 0; - _region_stack_pops = 0; _regions_claimed = 0; _objs_found_on_bitmap = 0; _satb_buffers_processed = 0; @@ -4663,110 +3837,6 @@ decrease_limits(); } -void CMTask::drain_region_stack(BitMapClosure* bc) { - assert(_cm->region_stack_empty(), "region stack should be empty"); - assert(_aborted_region.is_empty(), "aborted region should be empty"); - return; - - if (has_aborted()) return; - - assert(_region_finger == NULL, - "it should be NULL when we're not scanning a region"); - - if (!_cm->region_stack_empty() || !_aborted_region.is_empty()) { - if (_cm->verbose_low()) { - gclog_or_tty->print_cr("[%d] draining region stack, size = %d", - _task_id, _cm->region_stack_size()); - } - - MemRegion mr; - - if (!_aborted_region.is_empty()) { - mr = _aborted_region; - _aborted_region = MemRegion(); - - if (_cm->verbose_low()) { - gclog_or_tty->print_cr("[%d] scanning aborted region " - "[ " PTR_FORMAT ", " PTR_FORMAT " )", - _task_id, mr.start(), mr.end()); - } - } else { - mr = _cm->region_stack_pop_lock_free(); - // it returns MemRegion() if the pop fails - statsOnly(if (mr.start() != NULL) ++_region_stack_pops ); - } - - while (mr.start() != NULL) { - if (_cm->verbose_medium()) { - gclog_or_tty->print_cr("[%d] we are scanning region " - "["PTR_FORMAT", "PTR_FORMAT")", - _task_id, mr.start(), mr.end()); - } - - assert(mr.end() <= _cm->finger(), - "otherwise the region shouldn't be on the stack"); - assert(!mr.is_empty(), "Only non-empty regions live on the region stack"); - if (_nextMarkBitMap->iterate(bc, mr)) { - assert(!has_aborted(), - "cannot abort the task without aborting the bitmap iteration"); - - // We finished iterating over the region without aborting. - regular_clock_call(); - if (has_aborted()) { - mr = MemRegion(); - } else { - mr = _cm->region_stack_pop_lock_free(); - // it returns MemRegion() if the pop fails - statsOnly(if (mr.start() != NULL) ++_region_stack_pops ); - } - } else { - assert(has_aborted(), "currently the only way to do so"); - - // The only way to abort the bitmap iteration is to return - // false from the do_bit() method. However, inside the - // do_bit() method we move the _region_finger to point to the - // object currently being looked at. So, if we bail out, we - // have definitely set _region_finger to something non-null. - assert(_region_finger != NULL, "invariant"); - - // Make sure that any previously aborted region has been - // cleared. - assert(_aborted_region.is_empty(), "aborted region not cleared"); - - // The iteration was actually aborted. So now _region_finger - // points to the address of the object we last scanned. If we - // leave it there, when we restart this task, we will rescan - // the object. It is easy to avoid this. We move the finger by - // enough to point to the next possible object header (the - // bitmap knows by how much we need to move it as it knows its - // granularity). - MemRegion newRegion = - MemRegion(_nextMarkBitMap->nextWord(_region_finger), mr.end()); - - if (!newRegion.is_empty()) { - if (_cm->verbose_low()) { - gclog_or_tty->print_cr("[%d] recording unscanned region" - "[" PTR_FORMAT "," PTR_FORMAT ") in CMTask", - _task_id, - newRegion.start(), newRegion.end()); - } - // Now record the part of the region we didn't scan to - // make sure this task scans it later. - _aborted_region = newRegion; - } - // break from while - mr = MemRegion(); - } - _region_finger = NULL; - } - - if (_cm->verbose_low()) { - gclog_or_tty->print_cr("[%d] drained region stack, size = %d", - _task_id, _cm->region_stack_size()); - } - } -} - void CMTask::print_stats() { gclog_or_tty->print_cr("Marking Stats, task = %d, calls = %d", _task_id, _calls); @@ -4795,8 +3865,7 @@ _global_pushes, _global_pops, _global_max_size); gclog_or_tty->print_cr(" transfers to = %d, transfers from = %d", _global_transfers_to,_global_transfers_from); - gclog_or_tty->print_cr(" Regions: claimed = %d, Region Stack: pops = %d", - _regions_claimed, _region_stack_pops); + gclog_or_tty->print_cr(" Regions: claimed = %d", _regions_claimed); gclog_or_tty->print_cr(" SATB buffers: processed = %d", _satb_buffers_processed); gclog_or_tty->print_cr(" Steals: attempts = %d, successes = %d", _steal_attempts, _steals); @@ -4855,15 +3924,7 @@ popping by other tasks. Only when there is no more work, tasks will totally drain the global mark stack. - (4) Global Region Stack. Entries on it correspond to areas of - the bitmap that need to be scanned since they contain gray - objects. Pushes on the region stack only happen during - evacuation pauses and typically correspond to areas covered by - GC LABS. If it overflows, then the marking phase should restart - and iterate over the bitmap to identify gray objects. Tasks will - try to totally drain the region stack as soon as possible. - - (5) SATB Buffer Queue. This is where completed SATB buffers are + (4) SATB Buffer Queue. This is where completed SATB buffers are made available. Buffers are regularly removed from this queue and scanned for roots, so that the queue doesn't get too long. During remark, all completed buffers are processed, as @@ -4875,12 +3936,12 @@ (1) When the marking phase has been aborted (after a Full GC). - (2) When a global overflow (either on the global stack or the - region stack) has been triggered. Before the task aborts, it - will actually sync up with the other tasks to ensure that all - the marking data structures (local queues, stacks, fingers etc.) - are re-initialised so that when do_marking_step() completes, - the marking phase can immediately restart. + (2) When a global overflow (on the global stack) has been + triggered. Before the task aborts, it will actually sync up with + the other tasks to ensure that all the marking data structures + (local queues, stacks, fingers etc.) are re-initialised so that + when do_marking_step() completes, the marking phase can + immediately restart. (3) When enough completed SATB buffers are available. The do_marking_step() method only tries to drain SATB buffers right @@ -4923,13 +3984,6 @@ assert(time_target_ms >= 1.0, "minimum granularity is 1ms"); assert(concurrent() == _cm->concurrent(), "they should be the same"); - assert(concurrent() || _cm->region_stack_empty(), - "the region stack should have been cleared before remark"); - assert(concurrent() || !_cm->has_aborted_regions(), - "aborted regions should have been cleared before remark"); - assert(_region_finger == NULL, - "this should be non-null only when a region is being scanned"); - G1CollectorPolicy* g1_policy = _g1h->g1_policy(); assert(_task_queues != NULL, "invariant"); assert(_task_queue != NULL, "invariant"); @@ -4978,10 +4032,10 @@ set_cm_oop_closure(&cm_oop_closure); if (_cm->has_overflown()) { - // This can happen if the region stack or the mark stack overflows - // during a GC pause and this task, after a yield point, - // restarts. We have to abort as we need to get into the overflow - // protocol which happens right at the end of this task. + // This can happen if the mark stack overflows during a GC pause + // and this task, after a yield point, restarts. We have to abort + // as we need to get into the overflow protocol which happens + // right at the end of this task. set_has_aborted(); } @@ -4994,17 +4048,6 @@ drain_local_queue(true); drain_global_stack(true); - // Then totally drain the region stack. We will not look at - // it again before the next invocation of this method. Entries on - // the region stack are only added during evacuation pauses, for - // which we have to yield. When we do, we abort the task anyway so - // it will look at the region stack again when it restarts. - bitmap_closure.set_scanning_heap_region(false); - drain_region_stack(&bitmap_closure); - // ...then partially drain the local queue and the global stack - drain_local_queue(true); - drain_global_stack(true); - do { if (!has_aborted() && _curr_region != NULL) { // This means that we're already holding on to a region. @@ -5034,9 +4077,7 @@ // Let's iterate over the bitmap of the part of the // region that is left. - bitmap_closure.set_scanning_heap_region(true); - if (mr.is_empty() || - _nextMarkBitMap->iterate(&bitmap_closure, mr)) { + if (mr.is_empty() || _nextMarkBitMap->iterate(&bitmap_closure, mr)) { // We successfully completed iterating over the region. Now, // let's give up the region. giveup_current_region(); @@ -5061,9 +4102,9 @@ HeapWord* new_finger = _nextMarkBitMap->nextWord(_finger); // Check if bitmap iteration was aborted while scanning the last object if (new_finger >= _region_limit) { - giveup_current_region(); + giveup_current_region(); } else { - move_finger_to(new_finger); + move_finger_to(new_finger); } } } @@ -5119,9 +4160,7 @@ if (!has_aborted()) { // We cannot check whether the global stack is empty, since other - // tasks might be pushing objects to it concurrently. We also cannot - // check if the region stack is empty because if a thread is aborting - // it can push a partially done region back. + // tasks might be pushing objects to it concurrently. assert(_cm->out_of_regions(), "at this point we should be out of regions"); @@ -5145,9 +4184,7 @@ // we could. Let's try to do some stealing... // We cannot check whether the global stack is empty, since other - // tasks might be pushing objects to it concurrently. We also cannot - // check if the region stack is empty because if a thread is aborting - // it can push a partially done region back. + // tasks might be pushing objects to it concurrently. assert(_cm->out_of_regions() && _task_queue->size() == 0, "only way to reach here"); @@ -5194,9 +4231,7 @@ // termination protocol. if (do_termination && !has_aborted()) { // We cannot check whether the global stack is empty, since other - // tasks might be concurrently pushing objects on it. We also cannot - // check if the region stack is empty because if a thread is aborting - // it can push a partially done region back. + // tasks might be concurrently pushing objects on it. // Separated the asserts so that we know which one fires. assert(_cm->out_of_regions(), "only way to reach here"); assert(_task_queue->size() == 0, "only way to reach here"); @@ -5233,13 +4268,10 @@ // that, if a condition is false, we can immediately find out // which one. guarantee(_cm->out_of_regions(), "only way to reach here"); - guarantee(_aborted_region.is_empty(), "only way to reach here"); - guarantee(_cm->region_stack_empty(), "only way to reach here"); guarantee(_cm->mark_stack_empty(), "only way to reach here"); guarantee(_task_queue->size() == 0, "only way to reach here"); guarantee(!_cm->has_overflown(), "only way to reach here"); guarantee(!_cm->mark_stack_overflow(), "only way to reach here"); - guarantee(!_cm->region_stack_overflow(), "only way to reach here"); if (_cm->verbose_low()) { gclog_or_tty->print_cr("[%d] all tasks terminated", _task_id); @@ -5342,7 +4374,6 @@ _task_queue(task_queue), _task_queues(task_queues), _cm_oop_closure(NULL), - _aborted_region(MemRegion()), _marked_bytes_array(marked_bytes), _card_bm(card_bm) { guarantee(task_queue != NULL, "invariant");
--- a/src/share/vm/gc_implementation/g1/concurrentMark.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.hpp Tue May 08 11:29:21 2012 -0700 @@ -42,9 +42,7 @@ class G1CMIsAliveClosure: public BoolObjectClosure { G1CollectedHeap* _g1; public: - G1CMIsAliveClosure(G1CollectedHeap* g1) : - _g1(g1) - {} + G1CMIsAliveClosure(G1CollectedHeap* g1) : _g1(g1) { } void do_object(oop obj) { ShouldNotCallThis(); @@ -111,11 +109,6 @@ return offsetToHeapWord(heapWordToOffset(addr) + 1); } - void mostly_disjoint_range_union(BitMap* from_bitmap, - size_t from_start_index, - HeapWord* to_start_word, - size_t word_num); - // debugging NOT_PRODUCT(bool covers(ReservedSpace rs) const;) }; @@ -258,60 +251,6 @@ void oops_do(OopClosure* f); }; -class CMRegionStack VALUE_OBJ_CLASS_SPEC { - MemRegion* _base; - jint _capacity; - jint _index; - jint _oops_do_bound; - bool _overflow; -public: - CMRegionStack(); - ~CMRegionStack(); - void allocate(size_t size); - - // This is lock-free; assumes that it will only be called in parallel - // with other "push" operations (no pops). - void push_lock_free(MemRegion mr); - - // Lock-free; assumes that it will only be called in parallel - // with other "pop" operations (no pushes). - MemRegion pop_lock_free(); - -#if 0 - // The routines that manipulate the region stack with a lock are - // not currently used. They should be retained, however, as a - // diagnostic aid. - - // These two are the implementations that use a lock. They can be - // called concurrently with each other but they should not be called - // concurrently with the lock-free versions (push() / pop()). - void push_with_lock(MemRegion mr); - MemRegion pop_with_lock(); -#endif - - bool isEmpty() { return _index == 0; } - bool isFull() { return _index == _capacity; } - - bool overflow() { return _overflow; } - void clear_overflow() { _overflow = false; } - - int size() { return _index; } - - // It iterates over the entries in the region stack and it - // invalidates (i.e. assigns MemRegion()) the ones that point to - // regions in the collection set. - bool invalidate_entries_into_cset(); - - // This gives an upper bound up to which the iteration in - // invalidate_entries_into_cset() will reach. This prevents - // newly-added entries to be unnecessarily scanned. - void set_oops_do_bound() { - _oops_do_bound = _index; - } - - void setEmpty() { _index = 0; clear_overflow(); } -}; - class ForceOverflowSettings VALUE_OBJ_CLASS_SPEC { private: #ifndef PRODUCT @@ -408,7 +347,6 @@ friend class ConcurrentMarkThread; friend class CMTask; friend class CMBitMapClosure; - friend class CSetMarkOopClosure; friend class CMGlobalObjectClosure; friend class CMRemarkTask; friend class CMConcurrentMarkingTask; @@ -443,7 +381,6 @@ CMBitMap _markBitMap2; CMBitMapRO* _prevMarkBitMap; // completed mark bitmap CMBitMap* _nextMarkBitMap; // under-construction mark bitmap - bool _at_least_one_mark_complete; BitMap _region_bm; BitMap _card_bm; @@ -457,7 +394,6 @@ // For gray objects CMMarkStack _markStack; // Grey objects behind global finger. - CMRegionStack _regionStack; // Grey regions behind global finger. HeapWord* volatile _finger; // the global finger, region aligned, // always points to the end of the // last claimed region @@ -502,18 +438,6 @@ // verbose level CMVerboseLevel _verbose_level; - // These two fields are used to implement the optimisation that - // avoids pushing objects on the global/region stack if there are - // no collection set regions above the lowest finger. - - // This is the lowest finger (among the global and local fingers), - // which is calculated before a new collection set is chosen. - HeapWord* _min_finger; - // If this flag is true, objects/regions that are marked below the - // finger should be pushed on the stack(s). If this is flag is - // false, it is safe not to push them on the stack(s). - bool _should_gray_objects; - // All of these times are in ms. NumberSeq _init_times; NumberSeq _remark_times; @@ -604,7 +528,7 @@ CMTaskQueueSet* task_queues() { return _task_queues; } // Access / manipulation of the overflow flag which is set to - // indicate that the global stack or region stack has overflown + // indicate that the global stack has overflown bool has_overflown() { return _has_overflown; } void set_has_overflown() { _has_overflown = true; } void clear_has_overflown() { _has_overflown = false; } @@ -684,68 +608,6 @@ bool mark_stack_overflow() { return _markStack.overflow(); } bool mark_stack_empty() { return _markStack.isEmpty(); } - // (Lock-free) Manipulation of the region stack - bool region_stack_push_lock_free(MemRegion mr) { - // Currently we only call the lock-free version during evacuation - // pauses. - assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped"); - - _regionStack.push_lock_free(mr); - if (_regionStack.overflow()) { - set_has_overflown(); - return false; - } - return true; - } - - // Lock-free version of region-stack pop. Should only be - // called in tandem with other lock-free pops. - MemRegion region_stack_pop_lock_free() { - return _regionStack.pop_lock_free(); - } - -#if 0 - // The routines that manipulate the region stack with a lock are - // not currently used. They should be retained, however, as a - // diagnostic aid. - - bool region_stack_push_with_lock(MemRegion mr) { - // Currently we only call the lock-based version during either - // concurrent marking or remark. - assert(!SafepointSynchronize::is_at_safepoint() || !concurrent(), - "if we are at a safepoint it should be the remark safepoint"); - - _regionStack.push_with_lock(mr); - if (_regionStack.overflow()) { - set_has_overflown(); - return false; - } - return true; - } - - MemRegion region_stack_pop_with_lock() { - // Currently we only call the lock-based version during either - // concurrent marking or remark. - assert(!SafepointSynchronize::is_at_safepoint() || !concurrent(), - "if we are at a safepoint it should be the remark safepoint"); - - return _regionStack.pop_with_lock(); - } -#endif - - int region_stack_size() { return _regionStack.size(); } - bool region_stack_overflow() { return _regionStack.overflow(); } - bool region_stack_empty() { return _regionStack.isEmpty(); } - - // Iterate over any regions that were aborted while draining the - // region stack (any such regions are saved in the corresponding - // CMTask) and invalidate (i.e. assign to the empty MemRegion()) - // any regions that point into the collection set. - bool invalidate_aborted_regions_in_cset(); - - // Returns true if there are any aborted memory regions. - bool has_aborted_regions(); - CMRootRegions* root_regions() { return &_root_regions; } bool concurrent_marking_in_progress() { @@ -774,11 +636,7 @@ return _task_queues->steal(task_num, hash_seed, obj); } - // It grays an object by first marking it. Then, if it's behind the - // global finger, it also pushes it on the global stack. - void deal_with_reference(oop obj); - - ConcurrentMark(ReservedSpace rs, int max_regions); + ConcurrentMark(ReservedSpace rs, uint max_regions); ~ConcurrentMark(); ConcurrentMarkThread* cmThread() { return _cmThread; } @@ -810,22 +668,6 @@ inline void grayRoot(oop obj, size_t word_size, uint worker_id, HeapRegion* hr = NULL); - // It's used during evacuation pauses to gray a region, if - // necessary, and it's MT-safe. It assumes that the caller has - // marked any objects on that region. If _should_gray_objects is - // true and we're still doing concurrent marking, the region is - // pushed on the region stack, if it is located below the global - // finger, otherwise we do nothing. - void grayRegionIfNecessary(MemRegion mr); - - // It's used during evacuation pauses to mark and, if necessary, - // gray a single object and it's MT-safe. It assumes the caller did - // not mark the object. If _should_gray_objects is true and we're - // still doing concurrent marking, the objects is pushed on the - // global stack, if it is located below the global finger, otherwise - // we do nothing. - void markAndGrayObjectIfNecessary(oop p); - // It iterates over the heap and for each object it comes across it // will dump the contents of its reference fields, as well as // liveness information for the object and its referents. The dump @@ -869,10 +711,6 @@ // Do concurrent phase of marking, to a tentative transitive closure. void markFromRoots(); - // Process all unprocessed SATB buffers. It is called at the - // beginning of an evacuation pause. - void drainAllSATBBuffers(); - void checkpointRootsFinal(bool clear_all_soft_refs); void checkpointRootsFinalWork(); void cleanup(); @@ -899,10 +737,6 @@ _markStack.note_end_of_gc(); } - // Iterate over the oops in the mark stack and all local queues. It - // also calls invalidate_entries_into_cset() on the region stack. - void oops_do(OopClosure* f); - // Verify that there are no CSet oops on the stacks (taskqueues / // global mark stack), enqueued SATB buffers, per-thread SATB // buffers, and fingers (global / per-task). The boolean parameters @@ -919,40 +753,6 @@ // unless the force parameter is true. void update_g1_committed(bool force = false); - void complete_marking_in_collection_set(); - - // It indicates that a new collection set is being chosen. - void newCSet(); - - // It registers a collection set heap region with CM. This is used - // to determine whether any heap regions are located above the finger. - void registerCSetRegion(HeapRegion* hr); - - // Resets the region fields of any active CMTask whose region fields - // are in the collection set (i.e. the region currently claimed by - // the CMTask will be evacuated and may be used, subsequently, as - // an alloc region). When this happens the region fields in the CMTask - // are stale and, hence, should be cleared causing the worker thread - // to claim a new region. - void reset_active_task_region_fields_in_cset(); - - // Registers the maximum region-end associated with a set of - // regions with CM. Again this is used to determine whether any - // heap regions are located above the finger. - void register_collection_set_finger(HeapWord* max_finger) { - // max_finger is the highest heap region end of the regions currently - // contained in the collection set. If this value is larger than - // _min_finger then we need to gray objects. - // This routine is like registerCSetRegion but for an entire - // collection of regions. - if (max_finger > _min_finger) { - _should_gray_objects = true; - } - } - - // Returns "true" if at least one mark has been completed. - bool at_least_one_mark_complete() { return _at_least_one_mark_complete; } - bool isMarked(oop p) const { assert(p != NULL && p->is_oop(), "expected an oop"); HeapWord* addr = (HeapWord*)p; @@ -1164,23 +964,6 @@ // limit of the region this task is scanning, NULL if we're not scanning one HeapWord* _region_limit; - // This is used only when we scan regions popped from the region - // stack. It records what the last object on such a region we - // scanned was. It is used to ensure that, if we abort region - // iteration, we do not rescan the first part of the region. This - // should be NULL when we're not scanning a region from the region - // stack. - HeapWord* _region_finger; - - // If we abort while scanning a region we record the remaining - // unscanned portion and check this field when marking restarts. - // This avoids having to push on the region stack while other - // marking threads may still be popping regions. - // If we were to push the unscanned portion directly to the - // region stack then we would need to using locking versions - // of the push and pop operations. - MemRegion _aborted_region; - // the number of words this task has scanned size_t _words_scanned; // When _words_scanned reaches this limit, the regular clock is @@ -1268,8 +1051,6 @@ int _global_transfers_to; int _global_transfers_from; - int _region_stack_pops; - int _regions_claimed; int _objs_found_on_bitmap; @@ -1347,15 +1128,6 @@ bool has_timed_out() { return _has_timed_out; } bool claimed() { return _claimed; } - // Support routines for the partially scanned region that may be - // recorded as a result of aborting while draining the CMRegionStack - MemRegion aborted_region() { return _aborted_region; } - void set_aborted_region(MemRegion mr) - { _aborted_region = mr; } - - // Clears any recorded partially scanned region - void clear_aborted_region() { set_aborted_region(MemRegion()); } - void set_cm_oop_closure(G1CMOopClosure* cm_oop_closure); // It grays the object by marking it and, if necessary, pushing it @@ -1385,22 +1157,12 @@ // buffers are available. void drain_satb_buffers(); - // It keeps popping regions from the region stack and processing - // them until the region stack is empty. - void drain_region_stack(BitMapClosure* closure); - // moves the local finger to a new location inline void move_finger_to(HeapWord* new_finger) { assert(new_finger >= _finger && new_finger < _region_limit, "invariant"); _finger = new_finger; } - // moves the region finger to a new location - inline void move_region_finger_to(HeapWord* new_finger) { - assert(new_finger < _cm->finger(), "invariant"); - _region_finger = new_finger; - } - CMTask(int task_num, ConcurrentMark *cm, size_t* marked_bytes, BitMap* card_bm, CMTaskQueue* task_queue, CMTaskQueueSet* task_queues);
--- a/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp Tue May 08 11:29:21 2012 -0700 @@ -49,7 +49,7 @@ HeapWord* start = mr.start(); HeapWord* last = mr.last(); size_t region_size_bytes = mr.byte_size(); - size_t index = hr->hrs_index(); + uint index = hr->hrs_index(); assert(!hr->continuesHumongous(), "should not be HC region"); assert(hr == g1h->heap_region_containing(start), "sanity");
--- a/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Tue May 08 11:29:21 2012 -0700 @@ -26,6 +26,7 @@ #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1CollectorPolicy.hpp" +#include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/g1MMUTracker.hpp" #include "gc_implementation/g1/vm_operations_g1.hpp" #include "memory/resourceArea.hpp" @@ -104,7 +105,7 @@ double scan_start = os::elapsedTime(); if (!cm()->has_aborted()) { - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-root-region-scan-start]"); @@ -113,7 +114,7 @@ _cm->scanRootRegions(); double scan_end = os::elapsedTime(); - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-root-region-scan-end, %1.7lf]", @@ -122,7 +123,7 @@ } double mark_start_sec = os::elapsedTime(); - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-mark-start]"); @@ -146,7 +147,7 @@ os::sleep(current_thread, sleep_time_ms, false); } - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf sec]", @@ -165,7 +166,7 @@ } if (cm()->restart_for_overflow()) { - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-mark-restart-for-overflow]"); @@ -211,7 +212,7 @@ // reclaimed by cleanup. double cleanup_start_sec = os::elapsedTime(); - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-cleanup-start]"); @@ -232,7 +233,7 @@ g1h->reset_free_regions_coming(); double cleanup_end_sec = os::elapsedTime(); - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf]", @@ -273,7 +274,7 @@ _sts.leave(); if (cm()->has_aborted()) { - if (PrintGC) { + if (G1Log::fine()) { gclog_or_tty->date_stamp(PrintGCDateStamps); gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print_cr("[GC concurrent-mark-abort]");
--- a/src/share/vm/gc_implementation/g1/g1AllocRegion.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1AllocRegion.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -140,7 +140,7 @@ } void G1AllocRegion::fill_in_ext_msg(ar_ext_msg* msg, const char* message) { - msg->append("[%s] %s c: "SIZE_FORMAT" b: %s r: "PTR_FORMAT" u: "SIZE_FORMAT, + msg->append("[%s] %s c: %u b: %s r: "PTR_FORMAT" u: "SIZE_FORMAT, _name, message, _count, BOOL_TO_STR(_bot_updates), _alloc_region, _used_bytes_before); } @@ -215,7 +215,7 @@ jio_snprintf(rest_buffer, buffer_length, ""); } - tty->print_cr("[%s] "SIZE_FORMAT" %s : %s %s", + tty->print_cr("[%s] %u %s : %s %s", _name, _count, hr_buffer, str, rest_buffer); } }
--- a/src/share/vm/gc_implementation/g1/g1AllocRegion.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1AllocRegion.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -64,7 +64,7 @@ // the region that is re-used using the set() method. This count can // be used in any heuristics that might want to bound how many // distinct regions this object can used during an active interval. - size_t _count; + uint _count; // When we set up a new active region we save its used bytes in this // field so that, when we retire it, we can calculate how much space @@ -136,7 +136,7 @@ return (_alloc_region == _dummy_region) ? NULL : _alloc_region; } - size_t count() { return _count; } + uint count() { return _count; } // The following two are the building blocks for the allocation method.
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Tue May 08 11:29:21 2012 -0700 @@ -33,6 +33,7 @@ #include "gc_implementation/g1/g1CollectorPolicy.hpp" #include "gc_implementation/g1/g1ErgoVerbose.hpp" #include "gc_implementation/g1/g1EvacFailure.hpp" +#include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/g1MarkSweep.hpp" #include "gc_implementation/g1/g1OopClosures.inline.hpp" #include "gc_implementation/g1/g1RemSet.inline.hpp" @@ -233,7 +234,7 @@ bool YoungList::check_list_well_formed() { bool ret = true; - size_t length = 0; + uint length = 0; HeapRegion* curr = _head; HeapRegion* last = NULL; while (curr != NULL) { @@ -252,7 +253,7 @@ if (!ret) { gclog_or_tty->print_cr("### YOUNG LIST seems not well formed!"); - gclog_or_tty->print_cr("### list has %d entries, _length is %d", + gclog_or_tty->print_cr("### list has %u entries, _length is %u", length, _length); } @@ -263,7 +264,7 @@ bool ret = true; if (_length != 0) { - gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %d", + gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %u", _length); ret = false; } @@ -336,8 +337,7 @@ _g1h->g1_policy()->add_region_to_incremental_cset_rhs(curr); young_index_in_cset += 1; } - assert((size_t) young_index_in_cset == _survivor_length, - "post-condition"); + assert((uint) young_index_in_cset == _survivor_length, "post-condition"); _g1h->g1_policy()->note_stop_adding_survivor_regions(); _head = _survivor_head; @@ -532,7 +532,7 @@ if (!_secondary_free_list.is_empty()) { if (G1ConcRegionFreeingVerbose) { gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " - "secondary_free_list has "SIZE_FORMAT" entries", + "secondary_free_list has %u entries", _secondary_free_list.length()); } // It looks as if there are free regions available on the @@ -618,12 +618,12 @@ return res; } -size_t G1CollectedHeap::humongous_obj_allocate_find_first(size_t num_regions, - size_t word_size) { +uint G1CollectedHeap::humongous_obj_allocate_find_first(uint num_regions, + size_t word_size) { assert(isHumongous(word_size), "word_size should be humongous"); assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); - size_t first = G1_NULL_HRS_INDEX; + uint first = G1_NULL_HRS_INDEX; if (num_regions == 1) { // Only one region to allocate, no need to go through the slower // path. The caller will attempt the expasion if this fails, so @@ -649,7 +649,7 @@ if (free_regions() >= num_regions) { first = _hrs.find_contiguous(num_regions); if (first != G1_NULL_HRS_INDEX) { - for (size_t i = first; i < first + num_regions; ++i) { + for (uint i = first; i < first + num_regions; ++i) { HeapRegion* hr = region_at(i); assert(hr->is_empty(), "sanity"); assert(is_on_master_free_list(hr), "sanity"); @@ -663,15 +663,15 @@ } HeapWord* -G1CollectedHeap::humongous_obj_allocate_initialize_regions(size_t first, - size_t num_regions, +G1CollectedHeap::humongous_obj_allocate_initialize_regions(uint first, + uint num_regions, size_t word_size) { assert(first != G1_NULL_HRS_INDEX, "pre-condition"); assert(isHumongous(word_size), "word_size should be humongous"); assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); // Index of last region in the series + 1. - size_t last = first + num_regions; + uint last = first + num_regions; // We need to initialize the region(s) we just discovered. This is // a bit tricky given that it can happen concurrently with @@ -682,7 +682,7 @@ // a specific order. // The word size sum of all the regions we will allocate. - size_t word_size_sum = num_regions * HeapRegion::GrainWords; + size_t word_size_sum = (size_t) num_regions * HeapRegion::GrainWords; assert(word_size <= word_size_sum, "sanity"); // This will be the "starts humongous" region. @@ -721,7 +721,7 @@ // Then, if there are any, we will set up the "continues // humongous" regions. HeapRegion* hr = NULL; - for (size_t i = first + 1; i < last; ++i) { + for (uint i = first + 1; i < last; ++i) { hr = region_at(i); hr->set_continuesHumongous(first_hr); } @@ -767,7 +767,7 @@ // last one) is actually used when we will free up the humongous // region in free_humongous_region(). hr = NULL; - for (size_t i = first + 1; i < last; ++i) { + for (uint i = first + 1; i < last; ++i) { hr = region_at(i); if ((i + 1) == last) { // last continues humongous region @@ -803,14 +803,14 @@ verify_region_sets_optional(); - size_t num_regions = - round_to(word_size, HeapRegion::GrainWords) / HeapRegion::GrainWords; - size_t x_size = expansion_regions(); - size_t fs = _hrs.free_suffix(); - size_t first = humongous_obj_allocate_find_first(num_regions, word_size); + size_t word_size_rounded = round_to(word_size, HeapRegion::GrainWords); + uint num_regions = (uint) (word_size_rounded / HeapRegion::GrainWords); + uint x_num = expansion_regions(); + uint fs = _hrs.free_suffix(); + uint first = humongous_obj_allocate_find_first(num_regions, word_size); if (first == G1_NULL_HRS_INDEX) { // The only thing we can do now is attempt expansion. - if (fs + x_size >= num_regions) { + if (fs + x_num >= num_regions) { // If the number of regions we're trying to allocate for this // object is at most the number of regions in the free suffix, // then the call to humongous_obj_allocate_find_first() above @@ -1255,10 +1255,10 @@ // Timing bool system_gc = (gc_cause() == GCCause::_java_lang_system_gc); assert(!system_gc || explicit_gc, "invariant"); - gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); + gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); + TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); TraceTime t(system_gc ? "Full GC (System.gc())" : "Full GC", - PrintGC, true, gclog_or_tty); + G1Log::fine(), true, gclog_or_tty); TraceCollectorStats tcs(g1mm()->full_collection_counters()); TraceMemoryManagerStats tms(true /* fullGC */, gc_cause()); @@ -1290,8 +1290,7 @@ HandleMark hm; // Discard invalid handles created during verification gclog_or_tty->print(" VerifyBeforeGC:"); prepare_for_verify(); - Universe::verify(/* allow dirty */ true, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UsePrevMarking); } @@ -1365,8 +1364,7 @@ HandleMark hm; // Discard invalid handles created during verification gclog_or_tty->print(" VerifyAfterGC:"); prepare_for_verify(); - Universe::verify(/* allow dirty */ false, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UsePrevMarking); } @@ -1444,7 +1442,7 @@ heap_region_iterate(&rebuild_rs); } - if (PrintGC) { + if (G1Log::fine()) { print_size_transition(gclog_or_tty, g1h_prev_used, used(), capacity()); } @@ -1782,7 +1780,7 @@ ReservedSpace::page_align_size_down(shrink_bytes); aligned_shrink_bytes = align_size_down(aligned_shrink_bytes, HeapRegion::GrainBytes); - size_t num_regions_deleted = 0; + uint num_regions_deleted = 0; MemRegion mr = _hrs.shrink_by(aligned_shrink_bytes, &num_regions_deleted); HeapWord* old_end = (HeapWord*) _g1_storage.high(); assert(mr.end() == old_end, "post-condition"); @@ -1917,6 +1915,8 @@ CollectedHeap::pre_initialize(); os::enable_vtime(); + G1Log::init(); + // Necessary to satisfy locking discipline assertions. MutexLocker x(Heap_lock); @@ -2003,7 +2003,7 @@ _reserved.set_start((HeapWord*)heap_rs.base()); _reserved.set_end((HeapWord*)(heap_rs.base() + heap_rs.size())); - _expansion_regions = max_byte_size/HeapRegion::GrainBytes; + _expansion_regions = (uint) (max_byte_size / HeapRegion::GrainBytes); // Create the gen rem set (and barrier set) for the entire reserved region. _rem_set = collector_policy()->create_rem_set(_reserved, 2); @@ -2040,7 +2040,7 @@ // 6843694 - ensure that the maximum region index can fit // in the remembered set structures. - const size_t max_region_idx = ((size_t)1 << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1; + const uint max_region_idx = (1U << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1; guarantee((max_regions() - 1) <= max_region_idx, "too many regions"); size_t max_cards_per_region = ((size_t)1 << (sizeof(CardIdx_t)*BitsPerByte-1)) - 1; @@ -2056,13 +2056,14 @@ _g1h = this; _in_cset_fast_test_length = max_regions(); - _in_cset_fast_test_base = NEW_C_HEAP_ARRAY(bool, _in_cset_fast_test_length); + _in_cset_fast_test_base = + NEW_C_HEAP_ARRAY(bool, (size_t) _in_cset_fast_test_length); // We're biasing _in_cset_fast_test to avoid subtracting the // beginning of the heap every time we want to index; basically // it's the same with what we do with the card table. _in_cset_fast_test = _in_cset_fast_test_base - - ((size_t) _g1_reserved.start() >> HeapRegion::LogOfHRGrainBytes); + ((uintx) _g1_reserved.start() >> HeapRegion::LogOfHRGrainBytes); // Clear the _cset_fast_test bitmap in anticipation of adding // regions to the incremental collection set for the first @@ -2071,7 +2072,7 @@ // Create the ConcurrentMark data structure and thread. // (Must do this late, so that "max_regions" is defined.) - _cm = new ConcurrentMark(heap_rs, (int) max_regions()); + _cm = new ConcurrentMark(heap_rs, max_regions()); _cmThread = _cm->cmThread(); // Initialize the from_card cache structure of HeapRegionRemSet. @@ -2580,7 +2581,7 @@ uint worker, uint no_of_par_workers, jint claim_value) { - const size_t regions = n_regions(); + const uint regions = n_regions(); const uint max_workers = (G1CollectedHeap::use_parallel_gc_threads() ? no_of_par_workers : 1); @@ -2588,11 +2589,11 @@ no_of_par_workers == workers()->total_workers(), "Non dynamic should use fixed number of workers"); // try to spread out the starting points of the workers - const size_t start_index = regions / max_workers * (size_t) worker; + const uint start_index = regions / max_workers * worker; // each worker will actually look at all regions - for (size_t count = 0; count < regions; ++count) { - const size_t index = (start_index + count) % regions; + for (uint count = 0; count < regions; ++count) { + const uint index = (start_index + count) % regions; assert(0 <= index && index < regions, "sanity"); HeapRegion* r = region_at(index); // we'll ignore "continues humongous" regions (we'll process them @@ -2614,7 +2615,7 @@ // result, we might end up processing them twice. So, we'll do // them first (notice: most closures will ignore them anyway) and // then we'll do the "starts humongous" region. - for (size_t ch_index = index + 1; ch_index < regions; ++ch_index) { + for (uint ch_index = index + 1; ch_index < regions; ++ch_index) { HeapRegion* chr = region_at(ch_index); // if the region has already been claimed or it's not @@ -2682,8 +2683,9 @@ class CheckClaimValuesClosure : public HeapRegionClosure { private: jint _claim_value; - size_t _failures; + uint _failures; HeapRegion* _sh_region; + public: CheckClaimValuesClosure(jint claim_value) : _claim_value(claim_value), _failures(0), _sh_region(NULL) { } @@ -2711,9 +2713,7 @@ } return false; } - size_t failures() { - return _failures; - } + uint failures() { return _failures; } }; bool G1CollectedHeap::check_heap_region_claim_values(jint claim_value) { @@ -2723,17 +2723,15 @@ } class CheckClaimValuesInCSetHRClosure: public HeapRegionClosure { - jint _claim_value; - size_t _failures; +private: + jint _claim_value; + uint _failures; public: CheckClaimValuesInCSetHRClosure(jint claim_value) : - _claim_value(claim_value), - _failures(0) { } - - size_t failures() { - return _failures; - } + _claim_value(claim_value), _failures(0) { } + + uint failures() { return _failures; } bool doHeapRegion(HeapRegion* hr) { assert(hr->in_collection_set(), "how?"); @@ -2800,14 +2798,14 @@ result = g1_policy()->collection_set(); if (G1CollectedHeap::use_parallel_gc_threads()) { - size_t cs_size = g1_policy()->cset_region_length(); + uint cs_size = g1_policy()->cset_region_length(); uint active_workers = workers()->active_workers(); assert(UseDynamicNumberOfGCThreads || active_workers == workers()->total_workers(), "Unless dynamic should use total workers"); - size_t end_ind = (cs_size * worker_i) / active_workers; - size_t start_ind = 0; + uint end_ind = (cs_size * worker_i) / active_workers; + uint start_ind = 0; if (worker_i > 0 && _worker_cset_start_region_time_stamp[worker_i - 1] == gc_time_stamp) { @@ -2817,7 +2815,7 @@ result = _worker_cset_start_region[worker_i - 1]; } - for (size_t i = start_ind; i < end_ind; i++) { + for (uint i = start_ind; i < end_ind; i++) { result = result->next_in_collection_set(); } } @@ -3033,7 +3031,6 @@ class VerifyRegionClosure: public HeapRegionClosure { private: - bool _allow_dirty; bool _par; VerifyOption _vo; bool _failures; @@ -3041,9 +3038,8 @@ // _vo == UsePrevMarking -> use "prev" marking information, // _vo == UseNextMarking -> use "next" marking information, // _vo == UseMarkWord -> use mark word from object header. - VerifyRegionClosure(bool allow_dirty, bool par, VerifyOption vo) - : _allow_dirty(allow_dirty), - _par(par), + VerifyRegionClosure(bool par, VerifyOption vo) + : _par(par), _vo(vo), _failures(false) {} @@ -3056,7 +3052,7 @@ "Should be unclaimed at verify points."); if (!r->continuesHumongous()) { bool failures = false; - r->verify(_allow_dirty, _vo, &failures); + r->verify(_vo, &failures); if (failures) { _failures = true; } else { @@ -3124,7 +3120,6 @@ class G1ParVerifyTask: public AbstractGangTask { private: G1CollectedHeap* _g1h; - bool _allow_dirty; VerifyOption _vo; bool _failures; @@ -3132,10 +3127,9 @@ // _vo == UsePrevMarking -> use "prev" marking information, // _vo == UseNextMarking -> use "next" marking information, // _vo == UseMarkWord -> use mark word from object header. - G1ParVerifyTask(G1CollectedHeap* g1h, bool allow_dirty, VerifyOption vo) : + G1ParVerifyTask(G1CollectedHeap* g1h, VerifyOption vo) : AbstractGangTask("Parallel verify task"), _g1h(g1h), - _allow_dirty(allow_dirty), _vo(vo), _failures(false) { } @@ -3145,7 +3139,7 @@ void work(uint worker_id) { HandleMark hm; - VerifyRegionClosure blk(_allow_dirty, true, _vo); + VerifyRegionClosure blk(true, _vo); _g1h->heap_region_par_iterate_chunked(&blk, worker_id, _g1h->workers()->active_workers(), HeapRegion::ParVerifyClaimValue); @@ -3155,12 +3149,11 @@ } }; -void G1CollectedHeap::verify(bool allow_dirty, bool silent) { - verify(allow_dirty, silent, VerifyOption_G1UsePrevMarking); -} - -void G1CollectedHeap::verify(bool allow_dirty, - bool silent, +void G1CollectedHeap::verify(bool silent) { + verify(silent, VerifyOption_G1UsePrevMarking); +} + +void G1CollectedHeap::verify(bool silent, VerifyOption vo) { if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { if (!silent) { gclog_or_tty->print("Roots (excluding permgen) "); } @@ -3212,7 +3205,7 @@ assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity check"); - G1ParVerifyTask task(this, allow_dirty, vo); + G1ParVerifyTask task(this, vo); assert(UseDynamicNumberOfGCThreads || workers()->active_workers() == workers()->total_workers(), "If not dynamic should be using all the workers"); @@ -3234,7 +3227,7 @@ assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity check"); } else { - VerifyRegionClosure blk(allow_dirty, false, vo); + VerifyRegionClosure blk(false, vo); heap_region_iterate(&blk); if (blk.failures()) { failures = true; @@ -3284,12 +3277,12 @@ _g1_storage.high_boundary()); st->cr(); st->print(" region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K); - size_t young_regions = _young_list->length(); - st->print(SIZE_FORMAT " young (" SIZE_FORMAT "K), ", - young_regions, young_regions * HeapRegion::GrainBytes / K); - size_t survivor_regions = g1_policy()->recorded_survivor_regions(); - st->print(SIZE_FORMAT " survivors (" SIZE_FORMAT "K)", - survivor_regions, survivor_regions * HeapRegion::GrainBytes / K); + uint young_regions = _young_list->length(); + st->print("%u young (" SIZE_FORMAT "K), ", young_regions, + (size_t) young_regions * HeapRegion::GrainBytes / K); + uint survivor_regions = g1_policy()->recorded_survivor_regions(); + st->print("%u survivors (" SIZE_FORMAT "K)", survivor_regions, + (size_t) survivor_regions * HeapRegion::GrainBytes / K); st->cr(); perm()->as_gen()->print_on(st); } @@ -3299,7 +3292,11 @@ // Print the per-region information. st->cr(); - st->print_cr("Heap Regions: (Y=young(eden), SU=young(survivor), HS=humongous(starts), HC=humongous(continues), CS=collection set, F=free, TS=gc time stamp, PTAMS=previous top-at-mark-start, NTAMS=next top-at-mark-start)"); + st->print_cr("Heap Regions: (Y=young(eden), SU=young(survivor), " + "HS=humongous(starts), HC=humongous(continues), " + "CS=collection set, F=free, TS=gc time stamp, " + "PTAMS=previous top-at-mark-start, " + "NTAMS=next top-at-mark-start)"); PrintRegionClosure blk(st); heap_region_iterate(&blk); } @@ -3477,16 +3474,16 @@ void G1CollectedHeap::setup_surviving_young_words() { - guarantee( _surviving_young_words == NULL, "pre-condition" ); - size_t array_length = g1_policy()->young_cset_region_length(); - _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, array_length); + assert(_surviving_young_words == NULL, "pre-condition"); + uint array_length = g1_policy()->young_cset_region_length(); + _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, (size_t) array_length); if (_surviving_young_words == NULL) { vm_exit_out_of_memory(sizeof(size_t) * array_length, "Not enough space for young surv words summary."); } - memset(_surviving_young_words, 0, array_length * sizeof(size_t)); + memset(_surviving_young_words, 0, (size_t) array_length * sizeof(size_t)); #ifdef ASSERT - for (size_t i = 0; i < array_length; ++i) { + for (uint i = 0; i < array_length; ++i) { assert( _surviving_young_words[i] == 0, "memset above" ); } #endif // !ASSERT @@ -3495,9 +3492,10 @@ void G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); - size_t array_length = g1_policy()->young_cset_region_length(); - for (size_t i = 0; i < array_length; ++i) + uint array_length = g1_policy()->young_cset_region_length(); + for (uint i = 0; i < array_length; ++i) { _surviving_young_words[i] += surv_young_words[i]; + } } void @@ -3609,12 +3607,12 @@ increment_total_full_collections(); } - // if PrintGCDetails is on, we'll print long statistics information + // if the log level is "finer" is on, we'll print long statistics information // in the collector policy code, so let's not print this as the output // is messy if we do. - gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - TraceTime t(verbose_str, PrintGC && !PrintGCDetails, true, gclog_or_tty); + gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); + TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); + TraceTime t(verbose_str, G1Log::fine() && !G1Log::finer(), true, gclog_or_tty); TraceCollectorStats tcs(g1mm()->incremental_collection_counters()); TraceMemoryManagerStats tms(false /* fullGC */, gc_cause()); @@ -3647,8 +3645,7 @@ HandleMark hm; // Discard invalid handles created during verification gclog_or_tty->print(" VerifyBeforeGC:"); prepare_for_verify(); - Universe::verify(/* allow dirty */ false, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UsePrevMarking); } @@ -3892,8 +3889,7 @@ HandleMark hm; // Discard invalid handles created during verification gclog_or_tty->print(" VerifyAfterGC:"); prepare_for_verify(); - Universe::verify(/* allow dirty */ true, - /* silent */ false, + Universe::verify(/* silent */ false, /* option */ VerifyOption_G1UsePrevMarking); } @@ -3931,8 +3927,8 @@ } // The closing of the inner scope, immediately above, will complete - // the PrintGC logging output. The record_collection_pause_end() call - // above will complete the logging output of PrintGCDetails. + // logging at the "fine" level. The record_collection_pause_end() call + // above will complete logging at the "finer" level. // // It is not yet to safe, however, to tell the concurrent mark to // start as we have some optional output below. We don't want the @@ -4068,7 +4064,6 @@ void G1CollectedHeap::remove_self_forwarding_pointers() { assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); - assert(g1_policy()->assertMarkedBytesDataOK(), "Should be!"); G1ParRemoveSelfForwardPtrsTask rsfp_task(this); @@ -4086,7 +4081,6 @@ reset_cset_heap_region_claim_values(); assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); - assert(g1_policy()->assertMarkedBytesDataOK(), "Should be!"); // Now restore saved marks, if any. if (_objs_with_preserved_marks != NULL) { @@ -4248,16 +4242,16 @@ // non-young regions (where the age is -1) // We also add a few elements at the beginning and at the end in // an attempt to eliminate cache contention - size_t real_length = 1 + _g1h->g1_policy()->young_cset_region_length(); - size_t array_length = PADDING_ELEM_NUM + - real_length + - PADDING_ELEM_NUM; + uint real_length = 1 + _g1h->g1_policy()->young_cset_region_length(); + uint array_length = PADDING_ELEM_NUM + + real_length + + PADDING_ELEM_NUM; _surviving_young_words_base = NEW_C_HEAP_ARRAY(size_t, array_length); if (_surviving_young_words_base == NULL) vm_exit_out_of_memory(array_length * sizeof(size_t), "Not enough space for young surv histo."); _surviving_young_words = _surviving_young_words_base + PADDING_ELEM_NUM; - memset(_surviving_young_words, 0, real_length * sizeof(size_t)); + memset(_surviving_young_words, 0, (size_t) real_length * sizeof(size_t)); _alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer; _alloc_buffers[GCAllocForTenured] = &_tenured_alloc_buffer; @@ -4355,7 +4349,8 @@ _during_initial_mark(_g1->g1_policy()->during_initial_mark_pause()), _mark_in_progress(_g1->mark_in_progress()) { } -void G1ParCopyHelper::mark_object(oop obj) { +template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> +void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object>::mark_object(oop obj) { #ifdef ASSERT HeapRegion* hr = _g1->heap_region_containing(obj); assert(hr != NULL, "sanity"); @@ -4366,7 +4361,9 @@ _cm->grayRoot(obj, (size_t) obj->size(), _worker_id); } -void G1ParCopyHelper::mark_forwarded_object(oop from_obj, oop to_obj) { +template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> +void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object> + ::mark_forwarded_object(oop from_obj, oop to_obj) { #ifdef ASSERT assert(from_obj->is_forwarded(), "from obj should be forwarded"); assert(from_obj->forwardee() == to_obj, "to obj should be the forwardee"); @@ -4388,8 +4385,10 @@ _cm->grayRoot(to_obj, (size_t) from_obj->size(), _worker_id); } -oop G1ParCopyHelper::copy_to_survivor_space(oop old) { - size_t word_sz = old->size(); +template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> +oop G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object> + ::copy_to_survivor_space(oop old) { + size_t word_sz = old->size(); HeapRegion* from_region = _g1->heap_region_containing_raw(old); // +1 to make the -1 indexes valid... int young_index = from_region->young_index_in_cset()+1; @@ -4457,8 +4456,8 @@ } else { // No point in using the slower heap_region_containing() method, // given that we know obj is in the heap. - _scanner->set_region(_g1->heap_region_containing_raw(obj)); - obj->oop_iterate_backwards(_scanner); + _scanner.set_region(_g1->heap_region_containing_raw(obj)); + obj->oop_iterate_backwards(&_scanner); } } else { _par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz); @@ -4675,67 +4674,74 @@ double start_time_ms = os::elapsedTime() * 1000.0; _g1h->g1_policy()->record_gc_worker_start_time(worker_id, start_time_ms); - ResourceMark rm; - HandleMark hm; - - ReferenceProcessor* rp = _g1h->ref_processor_stw(); - - G1ParScanThreadState pss(_g1h, worker_id); - G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, rp); - G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp); - G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, rp); - - pss.set_evac_closure(&scan_evac_cl); - pss.set_evac_failure_closure(&evac_failure_cl); - pss.set_partial_scan_closure(&partial_scan_cl); - - G1ParScanExtRootClosure only_scan_root_cl(_g1h, &pss, rp); - G1ParScanPermClosure only_scan_perm_cl(_g1h, &pss, rp); - - G1ParScanAndMarkExtRootClosure scan_mark_root_cl(_g1h, &pss, rp); - G1ParScanAndMarkPermClosure scan_mark_perm_cl(_g1h, &pss, rp); - - OopClosure* scan_root_cl = &only_scan_root_cl; - OopsInHeapRegionClosure* scan_perm_cl = &only_scan_perm_cl; - - if (_g1h->g1_policy()->during_initial_mark_pause()) { - // We also need to mark copied objects. - scan_root_cl = &scan_mark_root_cl; - scan_perm_cl = &scan_mark_perm_cl; + { + ResourceMark rm; + HandleMark hm; + + ReferenceProcessor* rp = _g1h->ref_processor_stw(); + + G1ParScanThreadState pss(_g1h, worker_id); + G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, rp); + G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp); + G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, rp); + + pss.set_evac_closure(&scan_evac_cl); + pss.set_evac_failure_closure(&evac_failure_cl); + pss.set_partial_scan_closure(&partial_scan_cl); + + G1ParScanExtRootClosure only_scan_root_cl(_g1h, &pss, rp); + G1ParScanPermClosure only_scan_perm_cl(_g1h, &pss, rp); + + G1ParScanAndMarkExtRootClosure scan_mark_root_cl(_g1h, &pss, rp); + G1ParScanAndMarkPermClosure scan_mark_perm_cl(_g1h, &pss, rp); + + OopClosure* scan_root_cl = &only_scan_root_cl; + OopsInHeapRegionClosure* scan_perm_cl = &only_scan_perm_cl; + + if (_g1h->g1_policy()->during_initial_mark_pause()) { + // We also need to mark copied objects. + scan_root_cl = &scan_mark_root_cl; + scan_perm_cl = &scan_mark_perm_cl; + } + + G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss); + + pss.start_strong_roots(); + _g1h->g1_process_strong_roots(/* not collecting perm */ false, + SharedHeap::SO_AllClasses, + scan_root_cl, + &push_heap_rs_cl, + scan_perm_cl, + worker_id); + pss.end_strong_roots(); + + { + double start = os::elapsedTime(); + G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator); + evac.do_void(); + double elapsed_ms = (os::elapsedTime()-start)*1000.0; + double term_ms = pss.term_time()*1000.0; + _g1h->g1_policy()->record_obj_copy_time(worker_id, elapsed_ms-term_ms); + _g1h->g1_policy()->record_termination(worker_id, term_ms, pss.term_attempts()); + } + _g1h->g1_policy()->record_thread_age_table(pss.age_table()); + _g1h->update_surviving_young_words(pss.surviving_young_words()+1); + + // Clean up any par-expanded rem sets. + HeapRegionRemSet::par_cleanup(); + + if (ParallelGCVerbose) { + MutexLocker x(stats_lock()); + pss.print_termination_stats(worker_id); + } + + assert(pss.refs()->is_empty(), "should be empty"); + + // Close the inner scope so that the ResourceMark and HandleMark + // destructors are executed here and are included as part of the + // "GC Worker Time". } - G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss); - - pss.start_strong_roots(); - _g1h->g1_process_strong_roots(/* not collecting perm */ false, - SharedHeap::SO_AllClasses, - scan_root_cl, - &push_heap_rs_cl, - scan_perm_cl, - worker_id); - pss.end_strong_roots(); - - { - double start = os::elapsedTime(); - G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator); - evac.do_void(); - double elapsed_ms = (os::elapsedTime()-start)*1000.0; - double term_ms = pss.term_time()*1000.0; - _g1h->g1_policy()->record_obj_copy_time(worker_id, elapsed_ms-term_ms); - _g1h->g1_policy()->record_termination(worker_id, term_ms, pss.term_attempts()); - } - _g1h->g1_policy()->record_thread_age_table(pss.age_table()); - _g1h->update_surviving_young_words(pss.surviving_young_words()+1); - - // Clean up any par-expanded rem sets. - HeapRegionRemSet::par_cleanup(); - - if (ParallelGCVerbose) { - MutexLocker x(stats_lock()); - pss.print_termination_stats(worker_id); - } - - assert(pss.refs()->is_empty(), "should be empty"); double end_time_ms = os::elapsedTime() * 1000.0; _g1h->g1_policy()->record_gc_worker_end_time(worker_id, end_time_ms); } @@ -4743,6 +4749,67 @@ // *** Common G1 Evacuation Stuff +// Closures that support the filtering of CodeBlobs scanned during +// external root scanning. + +// Closure applied to reference fields in code blobs (specifically nmethods) +// to determine whether an nmethod contains references that point into +// the collection set. Used as a predicate when walking code roots so +// that only nmethods that point into the collection set are added to the +// 'marked' list. + +class G1FilteredCodeBlobToOopClosure : public CodeBlobToOopClosure { + + class G1PointsIntoCSOopClosure : public OopClosure { + G1CollectedHeap* _g1; + bool _points_into_cs; + public: + G1PointsIntoCSOopClosure(G1CollectedHeap* g1) : + _g1(g1), _points_into_cs(false) { } + + bool points_into_cs() const { return _points_into_cs; } + + template <class T> + void do_oop_nv(T* p) { + if (!_points_into_cs) { + T heap_oop = oopDesc::load_heap_oop(p); + if (!oopDesc::is_null(heap_oop) && + _g1->in_cset_fast_test(oopDesc::decode_heap_oop_not_null(heap_oop))) { + _points_into_cs = true; + } + } + } + + virtual void do_oop(oop* p) { do_oop_nv(p); } + virtual void do_oop(narrowOop* p) { do_oop_nv(p); } + }; + + G1CollectedHeap* _g1; + +public: + G1FilteredCodeBlobToOopClosure(G1CollectedHeap* g1, OopClosure* cl) : + CodeBlobToOopClosure(cl, true), _g1(g1) { } + + virtual void do_code_blob(CodeBlob* cb) { + nmethod* nm = cb->as_nmethod_or_null(); + if (nm != NULL && !(nm->test_oops_do_mark())) { + G1PointsIntoCSOopClosure predicate_cl(_g1); + nm->oops_do(&predicate_cl); + + if (predicate_cl.points_into_cs()) { + // At least one of the reference fields or the oop relocations + // in the nmethod points into the collection set. We have to + // 'mark' this nmethod. + // Note: Revisit the following if CodeBlobToOopClosure::do_code_blob() + // or MarkingCodeBlobClosure::do_code_blob() change. + if (!nm->test_set_oops_do_mark()) { + do_newly_marked_nmethod(nm); + } + } + } + } +}; + // This method is run in a GC worker. void @@ -4764,7 +4831,7 @@ // Walk the code cache w/o buffering, because StarTask cannot handle // unaligned oop locations. - CodeBlobToOopClosure eager_scan_code_roots(scan_non_heap_roots, /*do_marking=*/ true); + G1FilteredCodeBlobToOopClosure eager_scan_code_roots(this, scan_non_heap_roots); process_strong_roots(false, // no scoping; this is parallel code collecting_perm_gen, so, @@ -5378,25 +5445,39 @@ rem_set()->prepare_for_younger_refs_iterate(true); assert(dirty_card_queue_set().completed_buffers_num() == 0, "Should be empty"); - double start_par = os::elapsedTime(); - - if (G1CollectedHeap::use_parallel_gc_threads()) { - // The individual threads will set their evac-failure closures. + double start_par_time_sec = os::elapsedTime(); + double end_par_time_sec; + + { StrongRootsScope srs(this); - if (ParallelGCVerbose) G1ParScanThreadState::print_termination_stats_hdr(); - // These tasks use ShareHeap::_process_strong_tasks - assert(UseDynamicNumberOfGCThreads || - workers()->active_workers() == workers()->total_workers(), - "If not dynamic should be using all the workers"); - workers()->run_task(&g1_par_task); - } else { - StrongRootsScope srs(this); - g1_par_task.set_for_termination(n_workers); - g1_par_task.work(0); - } - - double par_time = (os::elapsedTime() - start_par) * 1000.0; - g1_policy()->record_par_time(par_time); + + if (G1CollectedHeap::use_parallel_gc_threads()) { + // The individual threads will set their evac-failure closures. + if (ParallelGCVerbose) G1ParScanThreadState::print_termination_stats_hdr(); + // These tasks use ShareHeap::_process_strong_tasks + assert(UseDynamicNumberOfGCThreads || + workers()->active_workers() == workers()->total_workers(), + "If not dynamic should be using all the workers"); + workers()->run_task(&g1_par_task); + } else { + g1_par_task.set_for_termination(n_workers); + g1_par_task.work(0); + } + end_par_time_sec = os::elapsedTime(); + + // Closing the inner scope will execute the destructor + // for the StrongRootsScope object. We record the current + // elapsed time before closing the scope so that time + // taken for the SRS destructor is NOT included in the + // reported parallel time. + } + + double par_time_ms = (end_par_time_sec - start_par_time_sec) * 1000.0; + g1_policy()->record_par_time(par_time_ms); + + double code_root_fixup_time_ms = + (os::elapsedTime() - end_par_time_sec) * 1000.0; + g1_policy()->record_code_root_fixup_time(code_root_fixup_time_ms); set_par_threads(0); @@ -5427,9 +5508,9 @@ if (evacuation_failed()) { remove_self_forwarding_pointers(); - if (PrintGCDetails) { + if (G1Log::finer()) { gclog_or_tty->print(" (to-space overflow)"); - } else if (PrintGC) { + } else if (G1Log::fine()) { gclog_or_tty->print("--"); } } @@ -5504,8 +5585,8 @@ hr->set_notHumongous(); free_region(hr, &hr_pre_used, free_list, par); - size_t i = hr->hrs_index() + 1; - size_t num = 1; + uint i = hr->hrs_index() + 1; + uint num = 1; while (i < n_regions()) { HeapRegion* curr_hr = region_at(i); if (!curr_hr->continuesHumongous()) { @@ -5714,7 +5795,7 @@ if (cur->is_young()) { int index = cur->young_index_in_cset(); assert(index != -1, "invariant"); - assert((size_t) index < policy->young_cset_region_length(), "invariant"); + assert((uint) index < policy->young_cset_region_length(), "invariant"); size_t words_survived = _surviving_young_words[index]; cur->record_surv_words_in_group(words_survived); @@ -6054,7 +6135,7 @@ // Methods for the GC alloc regions HeapRegion* G1CollectedHeap::new_gc_alloc_region(size_t word_size, - size_t count, + uint count, GCAllocPurpose ap) { assert(FreeList_lock->owned_by_self(), "pre-condition"); @@ -6126,7 +6207,7 @@ FreeRegionList* _free_list; OldRegionSet* _old_set; HumongousRegionSet* _humongous_set; - size_t _region_count; + uint _region_count; public: VerifyRegionListsClosure(OldRegionSet* old_set, @@ -6135,7 +6216,7 @@ _old_set(old_set), _humongous_set(humongous_set), _free_list(free_list), _region_count(0) { } - size_t region_count() { return _region_count; } + uint region_count() { return _region_count; } bool doHeapRegion(HeapRegion* hr) { _region_count += 1; @@ -6157,7 +6238,7 @@ } }; -HeapRegion* G1CollectedHeap::new_heap_region(size_t hrs_index, +HeapRegion* G1CollectedHeap::new_heap_region(uint hrs_index, HeapWord* bottom) { HeapWord* end = bottom + HeapRegion::GrainWords; MemRegion mr(bottom, end);
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Tue May 08 11:29:21 2012 -0700 @@ -85,8 +85,8 @@ HeapRegion* _curr; - size_t _length; - size_t _survivor_length; + uint _length; + uint _survivor_length; size_t _last_sampled_rs_lengths; size_t _sampled_rs_lengths; @@ -101,8 +101,8 @@ void empty_list(); bool is_empty() { return _length == 0; } - size_t length() { return _length; } - size_t survivor_length() { return _survivor_length; } + uint length() { return _length; } + uint survivor_length() { return _survivor_length; } // Currently we do not keep track of the used byte sum for the // young list and the survivors and it'd be quite a lot of work to @@ -111,10 +111,10 @@ // we'll report the more accurate information then. size_t eden_used_bytes() { assert(length() >= survivor_length(), "invariant"); - return (length() - survivor_length()) * HeapRegion::GrainBytes; + return (size_t) (length() - survivor_length()) * HeapRegion::GrainBytes; } size_t survivor_used_bytes() { - return survivor_length() * HeapRegion::GrainBytes; + return (size_t) survivor_length() * HeapRegion::GrainBytes; } void rs_length_sampling_init(); @@ -199,7 +199,8 @@ friend class OldGCAllocRegion; // Closures used in implementation. - friend class G1ParCopyHelper; + template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> + friend class G1ParCopyClosure; friend class G1IsAliveClosure; friend class G1EvacuateFollowersClosure; friend class G1ParScanThreadState; @@ -246,7 +247,7 @@ MasterHumongousRegionSet _humongous_set; // The number of regions we could create by expansion. - size_t _expansion_regions; + uint _expansion_regions; // The block offset table for the G1 heap. G1BlockOffsetSharedArray* _bot_shared; @@ -338,7 +339,7 @@ bool* _in_cset_fast_test_base; // The length of the _in_cset_fast_test_base array. - size_t _in_cset_fast_test_length; + uint _in_cset_fast_test_length; volatile unsigned _gc_time_stamp; @@ -457,14 +458,14 @@ // length and remove them from the master free list. Return the // index of the first region or G1_NULL_HRS_INDEX if the search // was unsuccessful. - size_t humongous_obj_allocate_find_first(size_t num_regions, - size_t word_size); + uint humongous_obj_allocate_find_first(uint num_regions, + size_t word_size); // Initialize a contiguous set of free regions of length num_regions // and starting at index first so that they appear as a single // humongous region. - HeapWord* humongous_obj_allocate_initialize_regions(size_t first, - size_t num_regions, + HeapWord* humongous_obj_allocate_initialize_regions(uint first, + uint num_regions, size_t word_size); // Attempt to allocate a humongous object of the given size. Return @@ -573,7 +574,7 @@ size_t allocated_bytes); // For GC alloc regions. - HeapRegion* new_gc_alloc_region(size_t word_size, size_t count, + HeapRegion* new_gc_alloc_region(size_t word_size, uint count, GCAllocPurpose ap); void retire_gc_alloc_region(HeapRegion* alloc_region, size_t allocated_bytes, GCAllocPurpose ap); @@ -640,7 +641,7 @@ void register_region_with_in_cset_fast_test(HeapRegion* r) { assert(_in_cset_fast_test_base != NULL, "sanity"); assert(r->in_collection_set(), "invariant"); - size_t index = r->hrs_index(); + uint index = r->hrs_index(); assert(index < _in_cset_fast_test_length, "invariant"); assert(!_in_cset_fast_test_base[index], "invariant"); _in_cset_fast_test_base[index] = true; @@ -654,7 +655,7 @@ if (_g1_committed.contains((HeapWord*) obj)) { // no need to subtract the bottom of the heap from obj, // _in_cset_fast_test is biased - size_t index = ((size_t) obj) >> HeapRegion::LogOfHRGrainBytes; + uintx index = (uintx) obj >> HeapRegion::LogOfHRGrainBytes; bool ret = _in_cset_fast_test[index]; // let's make sure the result is consistent with what the slower // test returns @@ -669,7 +670,7 @@ void clear_cset_fast_test() { assert(_in_cset_fast_test_base != NULL, "sanity"); memset(_in_cset_fast_test_base, false, - _in_cset_fast_test_length * sizeof(bool)); + (size_t) _in_cset_fast_test_length * sizeof(bool)); } // This is called at the end of either a concurrent cycle or a Full @@ -1100,23 +1101,23 @@ } // The total number of regions in the heap. - size_t n_regions() { return _hrs.length(); } + uint n_regions() { return _hrs.length(); } // The max number of regions in the heap. - size_t max_regions() { return _hrs.max_length(); } + uint max_regions() { return _hrs.max_length(); } // The number of regions that are completely free. - size_t free_regions() { return _free_list.length(); } + uint free_regions() { return _free_list.length(); } // The number of regions that are not completely free. - size_t used_regions() { return n_regions() - free_regions(); } + uint used_regions() { return n_regions() - free_regions(); } // The number of regions available for "regular" expansion. - size_t expansion_regions() { return _expansion_regions; } + uint expansion_regions() { return _expansion_regions; } // Factory method for HeapRegion instances. It will return NULL if // the allocation fails. - HeapRegion* new_heap_region(size_t hrs_index, HeapWord* bottom); + HeapRegion* new_heap_region(uint hrs_index, HeapWord* bottom); void verify_not_dirty_region(HeapRegion* hr) PRODUCT_RETURN; void verify_dirty_region(HeapRegion* hr) PRODUCT_RETURN; @@ -1300,7 +1301,7 @@ void heap_region_iterate_from(HeapRegion* r, HeapRegionClosure* blk) const; // Return the region with the given index. It assumes the index is valid. - HeapRegion* region_at(size_t index) const { return _hrs.at(index); } + HeapRegion* region_at(uint index) const { return _hrs.at(index); } // Divide the heap region sequence into "chunks" of some size (the number // of regions divided by the number of parallel threads times some @@ -1503,10 +1504,10 @@ // Currently there is only one place where this is called with // vo == UseMarkWord, which is to verify the marking during a // full GC. - void verify(bool allow_dirty, bool silent, VerifyOption vo); + void verify(bool silent, VerifyOption vo); // Override; it uses the "prev" marking information - virtual void verify(bool allow_dirty, bool silent); + virtual void verify(bool silent); virtual void print_on(outputStream* st) const; virtual void print_extended_on(outputStream* st) const; @@ -1676,202 +1677,6 @@ size_t _max_heap_capacity; }; -#define use_local_bitmaps 1 -#define verify_local_bitmaps 0 -#define oop_buffer_length 256 - -#ifndef PRODUCT -class GCLabBitMap; -class GCLabBitMapClosure: public BitMapClosure { -private: - ConcurrentMark* _cm; - GCLabBitMap* _bitmap; - -public: - GCLabBitMapClosure(ConcurrentMark* cm, - GCLabBitMap* bitmap) { - _cm = cm; - _bitmap = bitmap; - } - - virtual bool do_bit(size_t offset); -}; -#endif // !PRODUCT - -class GCLabBitMap: public BitMap { -private: - ConcurrentMark* _cm; - - int _shifter; - size_t _bitmap_word_covers_words; - - // beginning of the heap - HeapWord* _heap_start; - - // this is the actual start of the GCLab - HeapWord* _real_start_word; - - // this is the actual end of the GCLab - HeapWord* _real_end_word; - - // this is the first word, possibly located before the actual start - // of the GCLab, that corresponds to the first bit of the bitmap - HeapWord* _start_word; - - // size of a GCLab in words - size_t _gclab_word_size; - - static int shifter() { - return MinObjAlignment - 1; - } - - // how many heap words does a single bitmap word corresponds to? - static size_t bitmap_word_covers_words() { - return BitsPerWord << shifter(); - } - - size_t gclab_word_size() const { - return _gclab_word_size; - } - - // Calculates actual GCLab size in words - size_t gclab_real_word_size() const { - return bitmap_size_in_bits(pointer_delta(_real_end_word, _start_word)) - / BitsPerWord; - } - - static size_t bitmap_size_in_bits(size_t gclab_word_size) { - size_t bits_in_bitmap = gclab_word_size >> shifter(); - // We are going to ensure that the beginning of a word in this - // bitmap also corresponds to the beginning of a word in the - // global marking bitmap. To handle the case where a GCLab - // starts from the middle of the bitmap, we need to add enough - // space (i.e. up to a bitmap word) to ensure that we have - // enough bits in the bitmap. - return bits_in_bitmap + BitsPerWord - 1; - } -public: - GCLabBitMap(HeapWord* heap_start, size_t gclab_word_size) - : BitMap(bitmap_size_in_bits(gclab_word_size)), - _cm(G1CollectedHeap::heap()->concurrent_mark()), - _shifter(shifter()), - _bitmap_word_covers_words(bitmap_word_covers_words()), - _heap_start(heap_start), - _gclab_word_size(gclab_word_size), - _real_start_word(NULL), - _real_end_word(NULL), - _start_word(NULL) { - guarantee(false, "GCLabBitMap::GCLabBitmap(): don't call this any more"); - } - - inline unsigned heapWordToOffset(HeapWord* addr) { - unsigned offset = (unsigned) pointer_delta(addr, _start_word) >> _shifter; - assert(offset < size(), "offset should be within bounds"); - return offset; - } - - inline HeapWord* offsetToHeapWord(size_t offset) { - HeapWord* addr = _start_word + (offset << _shifter); - assert(_real_start_word <= addr && addr < _real_end_word, "invariant"); - return addr; - } - - bool fields_well_formed() { - bool ret1 = (_real_start_word == NULL) && - (_real_end_word == NULL) && - (_start_word == NULL); - if (ret1) - return true; - - bool ret2 = _real_start_word >= _start_word && - _start_word < _real_end_word && - (_real_start_word + _gclab_word_size) == _real_end_word && - (_start_word + _gclab_word_size + _bitmap_word_covers_words) - > _real_end_word; - return ret2; - } - - inline bool mark(HeapWord* addr) { - guarantee(use_local_bitmaps, "invariant"); - assert(fields_well_formed(), "invariant"); - - if (addr >= _real_start_word && addr < _real_end_word) { - assert(!isMarked(addr), "should not have already been marked"); - - // first mark it on the bitmap - at_put(heapWordToOffset(addr), true); - - return true; - } else { - return false; - } - } - - inline bool isMarked(HeapWord* addr) { - guarantee(use_local_bitmaps, "invariant"); - assert(fields_well_formed(), "invariant"); - - return at(heapWordToOffset(addr)); - } - - void set_buffer(HeapWord* start) { - guarantee(false, "set_buffer(): don't call this any more"); - - guarantee(use_local_bitmaps, "invariant"); - clear(); - - assert(start != NULL, "invariant"); - _real_start_word = start; - _real_end_word = start + _gclab_word_size; - - size_t diff = - pointer_delta(start, _heap_start) % _bitmap_word_covers_words; - _start_word = start - diff; - - assert(fields_well_formed(), "invariant"); - } - -#ifndef PRODUCT - void verify() { - // verify that the marks have been propagated - GCLabBitMapClosure cl(_cm, this); - iterate(&cl); - } -#endif // PRODUCT - - void retire() { - guarantee(false, "retire(): don't call this any more"); - - guarantee(use_local_bitmaps, "invariant"); - assert(fields_well_formed(), "invariant"); - - if (_start_word != NULL) { - CMBitMap* mark_bitmap = _cm->nextMarkBitMap(); - - // this means that the bitmap was set up for the GCLab - assert(_real_start_word != NULL && _real_end_word != NULL, "invariant"); - - mark_bitmap->mostly_disjoint_range_union(this, - 0, // always start from the start of the bitmap - _start_word, - gclab_real_word_size()); - _cm->grayRegionIfNecessary(MemRegion(_real_start_word, _real_end_word)); - -#ifndef PRODUCT - if (use_local_bitmaps && verify_local_bitmaps) - verify(); -#endif // PRODUCT - } else { - assert(_real_start_word == NULL && _real_end_word == NULL, "invariant"); - } - } - - size_t bitmap_size_in_words() const { - return (bitmap_size_in_bits(gclab_word_size()) + BitsPerWord - 1) / BitsPerWord; - } - -}; - class G1ParGCAllocBuffer: public ParGCAllocBuffer { private: bool _retired;
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Tue May 08 11:29:21 2012 -0700 @@ -29,6 +29,7 @@ #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1CollectorPolicy.hpp" #include "gc_implementation/g1/g1ErgoVerbose.hpp" +#include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/heapRegionRemSet.hpp" #include "gc_implementation/shared/gcPolicyCounters.hpp" #include "runtime/arguments.hpp" @@ -140,7 +141,6 @@ _summary(new Summary()), _cur_clear_ct_time_ms(0.0), - _mark_closure_time_ms(0.0), _root_region_scan_wait_time_ms(0.0), _cur_ref_proc_time_ms(0.0), @@ -192,11 +192,6 @@ _in_marking_window(false), _in_marking_window_im(false), - _known_garbage_ratio(0.0), - _known_garbage_bytes(0), - - _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)), - _recent_prev_end_times_for_all_gcs_sec( new TruncatedSeq(NumPrevPausesForHeuristics)), @@ -431,31 +426,36 @@ } if (FLAG_IS_CMDLINE(NewSize)) { - _min_desired_young_length = MAX2((size_t) 1, NewSize / HeapRegion::GrainBytes); + _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes), + 1U); if (FLAG_IS_CMDLINE(MaxNewSize)) { - _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes); + _max_desired_young_length = + MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), + 1U); _sizer_kind = SizerMaxAndNewSize; _adaptive_size = _min_desired_young_length == _max_desired_young_length; } else { _sizer_kind = SizerNewSizeOnly; } } else if (FLAG_IS_CMDLINE(MaxNewSize)) { - _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes); + _max_desired_young_length = + MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), + 1U); _sizer_kind = SizerMaxNewSizeOnly; } } -size_t G1YoungGenSizer::calculate_default_min_length(size_t new_number_of_heap_regions) { - size_t default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100; - return MAX2((size_t)1, default_value); +uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) { + uint default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100; + return MAX2(1U, default_value); } -size_t G1YoungGenSizer::calculate_default_max_length(size_t new_number_of_heap_regions) { - size_t default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100; - return MAX2((size_t)1, default_value); +uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) { + uint default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100; + return MAX2(1U, default_value); } -void G1YoungGenSizer::heap_size_changed(size_t new_number_of_heap_regions) { +void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) { assert(new_number_of_heap_regions > 0, "Heap must be initialized"); switch (_sizer_kind) { @@ -512,16 +512,16 @@ _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3); } -bool G1CollectorPolicy::predict_will_fit(size_t young_length, +bool G1CollectorPolicy::predict_will_fit(uint young_length, double base_time_ms, - size_t base_free_regions, + uint base_free_regions, double target_pause_time_ms) { if (young_length >= base_free_regions) { // end condition 1: not enough space for the young regions return false; } - double accum_surv_rate = accum_yg_surv_rate_pred((int)(young_length - 1)); + double accum_surv_rate = accum_yg_surv_rate_pred((int) young_length - 1); size_t bytes_to_copy = (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy); @@ -533,7 +533,7 @@ } size_t free_bytes = - (base_free_regions - young_length) * HeapRegion::GrainBytes; + (base_free_regions - young_length) * HeapRegion::GrainBytes; if ((2.0 * sigma()) * (double) bytes_to_copy > (double) free_bytes) { // end condition 3: out-of-space (conservatively!) return false; @@ -543,25 +543,25 @@ return true; } -void G1CollectorPolicy::record_new_heap_size(size_t new_number_of_regions) { +void G1CollectorPolicy::record_new_heap_size(uint new_number_of_regions) { // re-calculate the necessary reserve double reserve_regions_d = (double) new_number_of_regions * _reserve_factor; // We use ceiling so that if reserve_regions_d is > 0.0 (but // smaller than 1.0) we'll get 1. - _reserve_regions = (size_t) ceil(reserve_regions_d); + _reserve_regions = (uint) ceil(reserve_regions_d); _young_gen_sizer->heap_size_changed(new_number_of_regions); } -size_t G1CollectorPolicy::calculate_young_list_desired_min_length( - size_t base_min_length) { - size_t desired_min_length = 0; +uint G1CollectorPolicy::calculate_young_list_desired_min_length( + uint base_min_length) { + uint desired_min_length = 0; if (adaptive_young_list_length()) { if (_alloc_rate_ms_seq->num() > 3) { double now_sec = os::elapsedTime(); double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0; double alloc_rate_ms = predict_alloc_rate_ms(); - desired_min_length = (size_t) ceil(alloc_rate_ms * when_ms); + desired_min_length = (uint) ceil(alloc_rate_ms * when_ms); } else { // otherwise we don't have enough info to make the prediction } @@ -571,7 +571,7 @@ return MAX2(_young_gen_sizer->min_desired_young_length(), desired_min_length); } -size_t G1CollectorPolicy::calculate_young_list_desired_max_length() { +uint G1CollectorPolicy::calculate_young_list_desired_max_length() { // Here, we might want to also take into account any additional // constraints (i.e., user-defined minimum bound). Currently, we // effectively don't set this bound. @@ -588,11 +588,11 @@ // Calculate the absolute and desired min bounds. // This is how many young regions we already have (currently: the survivors). - size_t base_min_length = recorded_survivor_regions(); + uint base_min_length = recorded_survivor_regions(); // This is the absolute minimum young length, which ensures that we // can allocate one eden region in the worst-case. - size_t absolute_min_length = base_min_length + 1; - size_t desired_min_length = + uint absolute_min_length = base_min_length + 1; + uint desired_min_length = calculate_young_list_desired_min_length(base_min_length); if (desired_min_length < absolute_min_length) { desired_min_length = absolute_min_length; @@ -601,16 +601,16 @@ // Calculate the absolute and desired max bounds. // We will try our best not to "eat" into the reserve. - size_t absolute_max_length = 0; + uint absolute_max_length = 0; if (_free_regions_at_end_of_collection > _reserve_regions) { absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions; } - size_t desired_max_length = calculate_young_list_desired_max_length(); + uint desired_max_length = calculate_young_list_desired_max_length(); if (desired_max_length > absolute_max_length) { desired_max_length = absolute_max_length; } - size_t young_list_target_length = 0; + uint young_list_target_length = 0; if (adaptive_young_list_length()) { if (gcs_are_young()) { young_list_target_length = @@ -648,11 +648,11 @@ update_max_gc_locker_expansion(); } -size_t +uint G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths, - size_t base_min_length, - size_t desired_min_length, - size_t desired_max_length) { + uint base_min_length, + uint desired_min_length, + uint desired_max_length) { assert(adaptive_young_list_length(), "pre-condition"); assert(gcs_are_young(), "only call this for young GCs"); @@ -667,9 +667,9 @@ // will be reflected in the predictions by the // survivor_regions_evac_time prediction. assert(desired_min_length > base_min_length, "invariant"); - size_t min_young_length = desired_min_length - base_min_length; + uint min_young_length = desired_min_length - base_min_length; assert(desired_max_length > base_min_length, "invariant"); - size_t max_young_length = desired_max_length - base_min_length; + uint max_young_length = desired_max_length - base_min_length; double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0; double survivor_regions_evac_time = predict_survivor_regions_evac_time(); @@ -679,8 +679,8 @@ double base_time_ms = predict_base_elapsed_time_ms(pending_cards, scanned_cards) + survivor_regions_evac_time; - size_t available_free_regions = _free_regions_at_end_of_collection; - size_t base_free_regions = 0; + uint available_free_regions = _free_regions_at_end_of_collection; + uint base_free_regions = 0; if (available_free_regions > _reserve_regions) { base_free_regions = available_free_regions - _reserve_regions; } @@ -717,9 +717,9 @@ // the new max. This way we maintain the loop invariants. assert(min_young_length < max_young_length, "invariant"); - size_t diff = (max_young_length - min_young_length) / 2; + uint diff = (max_young_length - min_young_length) / 2; while (diff > 0) { - size_t young_length = min_young_length + diff; + uint young_length = min_young_length + diff; if (predict_will_fit(young_length, base_time_ms, base_free_regions, target_pause_time_ms)) { min_young_length = young_length; @@ -863,8 +863,6 @@ _last_young_gc = false; clear_initiate_conc_mark_if_possible(); clear_during_initial_mark_pause(); - _known_garbage_bytes = 0; - _known_garbage_ratio = 0.0; _in_marking_window = false; _in_marking_window_im = false; @@ -877,7 +875,7 @@ // Reset survivors SurvRateGroup. _survivor_surv_rate_group->reset(); update_young_list_target_length(); - _collectionSetChooser->clearMarkedHeapRegions(); + _collectionSetChooser->clear(); } void G1CollectorPolicy::record_stop_world_start() { @@ -886,7 +884,7 @@ void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, size_t start_used) { - if (PrintGCDetails) { + if (G1Log::finer()) { gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print("[GC pause"); gclog_or_tty->print(" (%s)", gcs_are_young() ? "young" : "mixed"); @@ -944,9 +942,6 @@ _cur_aux_times_set[i] = false; } - // This is initialized to zero here and is set during - // the evacuation pause if marking is in progress. - _cur_satb_drain_time_ms = 0.0; // This is initialized to zero here and is set during the evacuation // pause if we actually waited for the root region scanning to finish. _root_region_scan_wait_time_ms = 0.0; @@ -1026,11 +1021,16 @@ if (val > max) max = val; total += val; - buf.append(" %3.1lf", val); + if (G1Log::finest()) { + buf.append(" %.1lf", val); + } } - buf.append_and_print_cr(""); + + if (G1Log::finest()) { + buf.append_and_print_cr(""); + } double avg = total / (double) no_of_gc_threads(); - buf.append_and_print_cr(" Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf, Diff: %5.1lf]", + buf.append_and_print_cr(" Avg: %.1lf Min: %.1lf Max: %.1lf Diff: %.1lf]", avg, min, max, max - min); } @@ -1227,7 +1227,7 @@ // These values are used to update the summary information that is // displayed when TraceGen0Time is enabled, and are output as part - // of the PrintGCDetails output, in the non-parallel case. + // of the "finer" output, in the non-parallel case. double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms); double satb_filtering_time = avg_value(_par_last_satb_filtering_times_ms); @@ -1246,11 +1246,6 @@ double other_time_ms = elapsed_ms; - // Subtract the SATB drain time. It's initialized to zero at the - // start of the pause and is updated during the pause if marking - // is in progress. - other_time_ms -= _cur_satb_drain_time_ms; - // Subtract the root region scanning wait time. It's initialized to // zero at the start of the pause. other_time_ms -= _root_region_scan_wait_time_ms; @@ -1261,15 +1256,13 @@ other_time_ms -= known_time; } + // Now subtract the time taken to fix up roots in generated code + other_time_ms -= _cur_collection_code_root_fixup_time_ms; + // Subtract the time taken to clean the card table from the // current value of "other time" other_time_ms -= _cur_clear_ct_time_ms; - // Subtract the time spent completing marking in the collection - // set. Note if marking is not in progress during the pause - // the value of _mark_closure_time_ms will be zero. - other_time_ms -= _mark_closure_time_ms; - // TraceGen0Time and TraceGen1Time summary info updating. _all_pause_times_ms->add(elapsed_ms); @@ -1280,16 +1273,8 @@ MainBodySummary* body_summary = _summary->main_body_summary(); assert(body_summary != NULL, "should not be null!"); - // This will be non-zero iff marking is currently in progress (i.e. - // _g1->mark_in_progress() == true) and the currrent pause was not - // an initial mark pause. Since the body_summary items are NumberSeqs, - // however, they have to be consistent and updated in lock-step with - // each other. Therefore we unconditionally record the SATB drain - // time - even if it's zero. - body_summary->record_satb_drain_time_ms(_cur_satb_drain_time_ms); body_summary->record_root_region_scan_wait_time_ms( _root_region_scan_wait_time_ms); - body_summary->record_ext_root_scan_time_ms(ext_root_scan_time); body_summary->record_satb_filtering_time_ms(satb_filtering_time); body_summary->record_update_rs_time_ms(update_rs_time); @@ -1305,7 +1290,6 @@ body_summary->record_parallel_other_time_ms(parallel_other_time); } - body_summary->record_mark_closure_time_ms(_mark_closure_time_ms); body_summary->record_clear_ct_time_ms(_cur_clear_ct_time_ms); // We exempt parallel collection from this check because Alloc Buffer @@ -1336,7 +1320,7 @@ // given that humongous object allocations do not really affect // either the pause's duration nor when the next pause will take // place we can safely ignore them here. - size_t regions_allocated = eden_cset_region_length(); + uint regions_allocated = eden_cset_region_length(); double alloc_rate_ms = (double) regions_allocated / app_time_ms; _alloc_rate_ms_seq->add(alloc_rate_ms); @@ -1376,8 +1360,7 @@ } } - // PrintGCDetails output - if (PrintGCDetails) { + if (G1Log::finer()) { bool print_marking_info = _g1->mark_in_progress() && !last_pause_included_initial_mark; @@ -1396,15 +1379,19 @@ print_par_stats(2, "SATB Filtering", _par_last_satb_filtering_times_ms); } print_par_stats(2, "Update RS", _par_last_update_rs_times_ms); - print_par_sizes(3, "Processed Buffers", _par_last_update_rs_processed_buffers); + if (G1Log::finest()) { + print_par_sizes(3, "Processed Buffers", _par_last_update_rs_processed_buffers); + } print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms); print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms); print_par_stats(2, "Termination", _par_last_termination_times_ms); - print_par_sizes(3, "Termination Attempts", _par_last_termination_attempts); - print_par_stats(2, "GC Worker End", _par_last_gc_worker_end_times_ms); + if (G1Log::finest()) { + print_par_sizes(3, "Termination Attempts", _par_last_termination_attempts); + } for (int i = 0; i < _parallel_gc_threads; i++) { - _par_last_gc_worker_times_ms[i] = _par_last_gc_worker_end_times_ms[i] - _par_last_gc_worker_start_times_ms[i]; + _par_last_gc_worker_times_ms[i] = _par_last_gc_worker_end_times_ms[i] - + _par_last_gc_worker_start_times_ms[i]; double worker_known_time = _par_last_ext_root_scan_times_ms[i] + _par_last_satb_filtering_times_ms[i] + @@ -1413,23 +1400,26 @@ _par_last_obj_copy_times_ms[i] + _par_last_termination_times_ms[i]; - _par_last_gc_worker_other_times_ms[i] = _cur_collection_par_time_ms - worker_known_time; + _par_last_gc_worker_other_times_ms[i] = _par_last_gc_worker_times_ms[i] - + worker_known_time; } - print_par_stats(2, "GC Worker", _par_last_gc_worker_times_ms); + print_par_stats(2, "GC Worker Other", _par_last_gc_worker_other_times_ms); + print_par_stats(2, "GC Worker Total", _par_last_gc_worker_times_ms); + print_par_stats(2, "GC Worker End", _par_last_gc_worker_end_times_ms); } else { print_stats(1, "Ext Root Scanning", ext_root_scan_time); if (print_marking_info) { print_stats(1, "SATB Filtering", satb_filtering_time); } print_stats(1, "Update RS", update_rs_time); - print_stats(2, "Processed Buffers", (int)update_rs_processed_buffers); + if (G1Log::finest()) { + print_stats(2, "Processed Buffers", (int)update_rs_processed_buffers); + } print_stats(1, "Scan RS", scan_rs_time); print_stats(1, "Object Copying", obj_copy_time); } - if (print_marking_info) { - print_stats(1, "Complete CSet Marking", _mark_closure_time_ms); - } + print_stats(1, "Code Root Fixup", _cur_collection_code_root_fixup_time_ms); print_stats(1, "Clear CT", _cur_clear_ct_time_ms); #ifndef PRODUCT print_stats(1, "Cur Clear CC", _cur_clear_cc_time_ms); @@ -1459,16 +1449,6 @@ } } - // Update the efficiency-since-mark vars. - double proc_ms = elapsed_ms * (double) _parallel_gc_threads; - if (elapsed_ms < MIN_TIMER_GRANULARITY) { - // This usually happens due to the timer not having the required - // granularity. Some Linuxes are the usual culprits. - // We'll just set it to something (arbitrarily) small. - proc_ms = 1.0; - } - double cur_efficiency = (double) freed_bytes / proc_ms; - bool new_in_marking_window = _in_marking_window; bool new_in_marking_window_im = false; if (during_initial_mark_pause()) { @@ -1503,10 +1483,6 @@ } } - if (_last_gc_was_young && !_during_marking) { - _young_gc_eff_seq->add(cur_efficiency); - } - _short_lived_surv_rate_group->start_adding_regions(); // do that for any other surv rate groupsx @@ -1514,8 +1490,9 @@ double pause_time_ms = elapsed_ms; size_t diff = 0; - if (_max_pending_cards >= _pending_cards) + if (_max_pending_cards >= _pending_cards) { diff = _max_pending_cards - _pending_cards; + } _pending_card_diff_seq->add((double) diff); double cost_per_card_ms = 0.0; @@ -1577,8 +1554,7 @@ } double all_other_time_ms = pause_time_ms - - (update_rs_time + scan_rs_time + obj_copy_time + - _mark_closure_time_ms + termination_time); + (update_rs_time + scan_rs_time + obj_copy_time + termination_time); double young_other_time_ms = 0.0; if (young_cset_region_length() > 0) { @@ -1621,7 +1597,7 @@ double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms); - assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end."); + _collectionSetChooser->verify(); } #define EXT_SIZE_FORMAT "%d%s" @@ -1630,7 +1606,7 @@ proper_unit_for_byte_size((bytes)) void G1CollectorPolicy::print_heap_transition() { - if (PrintGCDetails) { + if (G1Log::finer()) { YoungList* young_list = _g1->young_list(); size_t eden_bytes = young_list->eden_used_bytes(); size_t survivor_bytes = young_list->survivor_used_bytes(); @@ -1657,7 +1633,7 @@ EXT_SIZE_PARAMS(capacity)); _prev_eden_capacity = eden_capacity; - } else if (PrintGC) { + } else if (G1Log::fine()) { _g1->print_size_transition(gclog_or_tty, _cur_collection_pause_used_at_start_bytes, _g1->used(), _g1->capacity()); @@ -1706,41 +1682,6 @@ } double -G1CollectorPolicy:: -predict_young_collection_elapsed_time_ms(size_t adjustment) { - guarantee( adjustment == 0 || adjustment == 1, "invariant" ); - - G1CollectedHeap* g1h = G1CollectedHeap::heap(); - size_t young_num = g1h->young_list()->length(); - if (young_num == 0) - return 0.0; - - young_num += adjustment; - size_t pending_cards = predict_pending_cards(); - size_t rs_lengths = g1h->young_list()->sampled_rs_lengths() + - predict_rs_length_diff(); - size_t card_num; - if (gcs_are_young()) { - card_num = predict_young_card_num(rs_lengths); - } else { - card_num = predict_non_young_card_num(rs_lengths); - } - size_t young_byte_size = young_num * HeapRegion::GrainBytes; - double accum_yg_surv_rate = - _short_lived_surv_rate_group->accum_surv_rate(adjustment); - - size_t bytes_to_copy = - (size_t) (accum_yg_surv_rate * (double) HeapRegion::GrainBytes); - - return - predict_rs_update_time_ms(pending_cards) + - predict_rs_scan_time_ms(card_num) + - predict_object_copy_time_ms(bytes_to_copy) + - predict_young_other_time_ms(young_num) + - predict_constant_other_time_ms(); -} - -double G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) { size_t rs_length = predict_rs_length_diff(); size_t card_num; @@ -1785,8 +1726,7 @@ return region_elapsed_time_ms; } -size_t -G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { +size_t G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { size_t bytes_to_copy; if (hr->is_marked()) bytes_to_copy = hr->max_live_bytes(); @@ -1800,8 +1740,8 @@ } void -G1CollectorPolicy::init_cset_region_lengths(size_t eden_cset_region_length, - size_t survivor_cset_region_length) { +G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length, + uint survivor_cset_region_length) { _eden_cset_region_length = eden_cset_region_length; _survivor_cset_region_length = survivor_cset_region_length; _old_cset_region_length = 0; @@ -1973,7 +1913,6 @@ print_summary(1, "Object Copy", body_summary->get_obj_copy_seq()); } } - print_summary(1, "Mark Closure", body_summary->get_mark_closure_seq()); print_summary(1, "Clear CT", body_summary->get_clear_ct_seq()); print_summary(1, "Other", summary->get_other_seq()); { @@ -1982,17 +1921,15 @@ if (parallel) { // parallel NumberSeq* other_parts[] = { - body_summary->get_satb_drain_seq(), body_summary->get_root_region_scan_wait_seq(), body_summary->get_parallel_seq(), body_summary->get_clear_ct_seq() }; calc_other_times_ms = NumberSeq(summary->get_total_seq(), - 4, other_parts); + 3, other_parts); } else { // serial NumberSeq* other_parts[] = { - body_summary->get_satb_drain_seq(), body_summary->get_root_region_scan_wait_seq(), body_summary->get_update_rs_seq(), body_summary->get_ext_root_scan_seq(), @@ -2001,7 +1938,7 @@ body_summary->get_obj_copy_seq() }; calc_other_times_ms = NumberSeq(summary->get_total_seq(), - 7, other_parts); + 6, other_parts); } check_other_times(1, summary->get_other_seq(), &calc_other_times_ms); } @@ -2068,7 +2005,7 @@ } #endif // PRODUCT -size_t G1CollectorPolicy::max_regions(int purpose) { +uint G1CollectorPolicy::max_regions(int purpose) { switch (purpose) { case GCAllocForSurvived: return _max_survivor_regions; @@ -2081,13 +2018,13 @@ } void G1CollectorPolicy::update_max_gc_locker_expansion() { - size_t expansion_region_num = 0; + uint expansion_region_num = 0; if (GCLockerEdenExpansionPercent > 0) { double perc = (double) GCLockerEdenExpansionPercent / 100.0; double expansion_region_num_d = perc * (double) _young_list_target_length; // We use ceiling so that if expansion_region_num_d is > 0.0 (but // less than 1.0) we'll get 1. - expansion_region_num = (size_t) ceil(expansion_region_num_d); + expansion_region_num = (uint) ceil(expansion_region_num_d); } else { assert(expansion_region_num == 0, "sanity"); } @@ -2101,34 +2038,12 @@ (double) _young_list_target_length / (double) SurvivorRatio; // We use ceiling so that if max_survivor_regions_d is > 0.0 (but // smaller than 1.0) we'll get 1. - _max_survivor_regions = (size_t) ceil(max_survivor_regions_d); + _max_survivor_regions = (uint) ceil(max_survivor_regions_d); _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( HeapRegion::GrainWords * _max_survivor_regions); } -#ifndef PRODUCT -class HRSortIndexIsOKClosure: public HeapRegionClosure { - CollectionSetChooser* _chooser; -public: - HRSortIndexIsOKClosure(CollectionSetChooser* chooser) : - _chooser(chooser) {} - - bool doHeapRegion(HeapRegion* r) { - if (!r->continuesHumongous()) { - assert(_chooser->regionProperlyOrdered(r), "Ought to be."); - } - return false; - } -}; - -bool G1CollectorPolicy::assertMarkedBytesDataOK() { - HRSortIndexIsOKClosure cl(_collectionSetChooser); - _g1->heap_region_iterate(&cl); - return true; -} -#endif - bool G1CollectorPolicy::force_initial_mark_if_outside_cycle( GCCause::Cause gc_cause) { bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); @@ -2226,8 +2141,8 @@ // We will skip any region that's currently used as an old GC // alloc region (we should not consider those for collection // before we fill them up). - if (_hrSorted->shouldAdd(r) && !_g1h->is_old_gc_alloc_region(r)) { - _hrSorted->addMarkedHeapRegion(r); + if (_hrSorted->should_add(r) && !_g1h->is_old_gc_alloc_region(r)) { + _hrSorted->add_region(r); } } return false; @@ -2237,16 +2152,14 @@ class ParKnownGarbageHRClosure: public HeapRegionClosure { G1CollectedHeap* _g1h; CollectionSetChooser* _hrSorted; - jint _marked_regions_added; + uint _marked_regions_added; size_t _reclaimable_bytes_added; - jint _chunk_size; - jint _cur_chunk_idx; - jint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end) - int _worker; - int _invokes; + uint _chunk_size; + uint _cur_chunk_idx; + uint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end) void get_new_chunk() { - _cur_chunk_idx = _hrSorted->getParMarkedHeapRegionChunk(_chunk_size); + _cur_chunk_idx = _hrSorted->claim_array_chunk(_chunk_size); _cur_chunk_end = _cur_chunk_idx + _chunk_size; } void add_region(HeapRegion* r) { @@ -2254,7 +2167,7 @@ get_new_chunk(); } assert(_cur_chunk_idx < _cur_chunk_end, "postcondition"); - _hrSorted->setMarkedHeapRegion(_cur_chunk_idx, r); + _hrSorted->set_region(_cur_chunk_idx, r); _marked_regions_added++; _reclaimable_bytes_added += r->reclaimable_bytes(); _cur_chunk_idx++; @@ -2262,104 +2175,79 @@ public: ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, - jint chunk_size, - int worker) : + uint chunk_size) : _g1h(G1CollectedHeap::heap()), - _hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker), + _hrSorted(hrSorted), _chunk_size(chunk_size), _marked_regions_added(0), _reclaimable_bytes_added(0), - _cur_chunk_idx(0), _cur_chunk_end(0), _invokes(0) { } + _cur_chunk_idx(0), _cur_chunk_end(0) { } bool doHeapRegion(HeapRegion* r) { - // We only include humongous regions in collection - // sets when concurrent mark shows that their contained object is - // unreachable. - _invokes++; - // Do we have any marking information for this region? if (r->is_marked()) { // We will skip any region that's currently used as an old GC // alloc region (we should not consider those for collection // before we fill them up). - if (_hrSorted->shouldAdd(r) && !_g1h->is_old_gc_alloc_region(r)) { + if (_hrSorted->should_add(r) && !_g1h->is_old_gc_alloc_region(r)) { add_region(r); } } return false; } - jint marked_regions_added() { return _marked_regions_added; } + uint marked_regions_added() { return _marked_regions_added; } size_t reclaimable_bytes_added() { return _reclaimable_bytes_added; } - int invokes() { return _invokes; } }; class ParKnownGarbageTask: public AbstractGangTask { CollectionSetChooser* _hrSorted; - jint _chunk_size; + uint _chunk_size; G1CollectedHeap* _g1; public: - ParKnownGarbageTask(CollectionSetChooser* hrSorted, jint chunk_size) : + ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size) : AbstractGangTask("ParKnownGarbageTask"), _hrSorted(hrSorted), _chunk_size(chunk_size), _g1(G1CollectedHeap::heap()) { } void work(uint worker_id) { - ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, - _chunk_size, - worker_id); + ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size); + // Back to zero for the claim value. _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, worker_id, _g1->workers()->active_workers(), HeapRegion::InitialClaimValue); - jint regions_added = parKnownGarbageCl.marked_regions_added(); + uint regions_added = parKnownGarbageCl.marked_regions_added(); size_t reclaimable_bytes_added = parKnownGarbageCl.reclaimable_bytes_added(); - _hrSorted->updateTotals(regions_added, reclaimable_bytes_added); - if (G1PrintParCleanupStats) { - gclog_or_tty->print_cr(" Thread %d called %d times, added %d regions to list.", - worker_id, parKnownGarbageCl.invokes(), regions_added); - } + _hrSorted->update_totals(regions_added, reclaimable_bytes_added); } }; void G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) { - double start_sec; - if (G1PrintParCleanupStats) { - start_sec = os::elapsedTime(); - } + _collectionSetChooser->clear(); - _collectionSetChooser->clearMarkedHeapRegions(); - double clear_marked_end_sec; - if (G1PrintParCleanupStats) { - clear_marked_end_sec = os::elapsedTime(); - gclog_or_tty->print_cr(" clear marked regions: %8.3f ms.", - (clear_marked_end_sec - start_sec) * 1000.0); - } - + uint region_num = _g1->n_regions(); if (G1CollectedHeap::use_parallel_gc_threads()) { - const size_t OverpartitionFactor = 4; - size_t WorkUnit; + const uint OverpartitionFactor = 4; + uint WorkUnit; // The use of MinChunkSize = 8 in the original code // causes some assertion failures when the total number of // region is less than 8. The code here tries to fix that. // Should the original code also be fixed? if (no_of_gc_threads > 0) { - const size_t MinWorkUnit = - MAX2(_g1->n_regions() / no_of_gc_threads, (size_t) 1U); - WorkUnit = - MAX2(_g1->n_regions() / (no_of_gc_threads * OverpartitionFactor), - MinWorkUnit); + const uint MinWorkUnit = MAX2(region_num / no_of_gc_threads, 1U); + WorkUnit = MAX2(region_num / (no_of_gc_threads * OverpartitionFactor), + MinWorkUnit); } else { assert(no_of_gc_threads > 0, "The active gc workers should be greater than 0"); // In a product build do something reasonable to avoid a crash. - const size_t MinWorkUnit = - MAX2(_g1->n_regions() / ParallelGCThreads, (size_t) 1U); + const uint MinWorkUnit = MAX2(region_num / (uint) ParallelGCThreads, 1U); WorkUnit = - MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor), + MAX2(region_num / (uint) (ParallelGCThreads * OverpartitionFactor), MinWorkUnit); } - _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(), - WorkUnit); + _collectionSetChooser->prepare_for_par_region_addition(_g1->n_regions(), + WorkUnit); ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser, (int) WorkUnit); _g1->workers()->run_task(&parKnownGarbageTask); @@ -2370,20 +2258,10 @@ KnownGarbageClosure knownGarbagecl(_collectionSetChooser); _g1->heap_region_iterate(&knownGarbagecl); } - double known_garbage_end_sec; - if (G1PrintParCleanupStats) { - known_garbage_end_sec = os::elapsedTime(); - gclog_or_tty->print_cr(" compute known garbage: %8.3f ms.", - (known_garbage_end_sec - clear_marked_end_sec) * 1000.0); - } - _collectionSetChooser->sortMarkedHeapRegions(); + _collectionSetChooser->sort_regions(); + double end_sec = os::elapsedTime(); - if (G1PrintParCleanupStats) { - gclog_or_tty->print_cr(" sorting: %8.3f ms.", - (end_sec - known_garbage_end_sec) * 1000.0); - } - double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0; _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); _cur_mark_stop_world_time_ms += elapsed_time_ms; @@ -2599,13 +2477,13 @@ bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str, const char* false_action_str) { CollectionSetChooser* cset_chooser = _collectionSetChooser; - if (cset_chooser->isEmpty()) { + if (cset_chooser->is_empty()) { ergo_verbose0(ErgoMixedGCs, false_action_str, ergo_format_reason("candidate old regions not available")); return false; } - size_t reclaimable_bytes = cset_chooser->remainingReclaimableBytes(); + size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes(); size_t capacity_bytes = _g1->capacity(); double perc = (double) reclaimable_bytes * 100.0 / (double) capacity_bytes; double threshold = (double) G1HeapWastePercent; @@ -2616,7 +2494,7 @@ ergo_format_region("candidate old regions") ergo_format_byte_perc("reclaimable") ergo_format_perc("threshold"), - cset_chooser->remainingRegions(), + cset_chooser->remaining_regions(), reclaimable_bytes, perc, threshold); return false; } @@ -2627,7 +2505,7 @@ ergo_format_region("candidate old regions") ergo_format_byte_perc("reclaimable") ergo_format_perc("threshold"), - cset_chooser->remainingRegions(), + cset_chooser->remaining_regions(), reclaimable_bytes, perc, threshold); return true; } @@ -2671,8 +2549,8 @@ // pause are appended to the RHS of the young list, i.e. // [Newly Young Regions ++ Survivors from last pause]. - size_t survivor_region_length = young_list->survivor_length(); - size_t eden_region_length = young_list->length() - survivor_region_length; + uint survivor_region_length = young_list->survivor_length(); + uint eden_region_length = young_list->length() - survivor_region_length; init_cset_region_lengths(eden_region_length, survivor_region_length); hr = young_list->first_survivor_region(); while (hr != NULL) { @@ -2710,11 +2588,11 @@ if (!gcs_are_young()) { CollectionSetChooser* cset_chooser = _collectionSetChooser; - assert(cset_chooser->verify(), "CSet Chooser verification - pre"); - const size_t min_old_cset_length = cset_chooser->calcMinOldCSetLength(); - const size_t max_old_cset_length = cset_chooser->calcMaxOldCSetLength(); + cset_chooser->verify(); + const uint min_old_cset_length = cset_chooser->calc_min_old_cset_length(); + const uint max_old_cset_length = cset_chooser->calc_max_old_cset_length(); - size_t expensive_region_num = 0; + uint expensive_region_num = 0; bool check_time_remaining = adaptive_young_list_length(); HeapRegion* hr = cset_chooser->peek(); while (hr != NULL) { @@ -2799,7 +2677,7 @@ time_remaining_ms); } - assert(cset_chooser->verify(), "CSet Chooser verification - post"); + cset_chooser->verify(); } stop_incremental_cset_building();
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Tue May 08 11:29:21 2012 -0700 @@ -64,7 +64,6 @@ }; class MainBodySummary: public CHeapObj { - define_num_seq(satb_drain) // optional define_num_seq(root_region_scan_wait) define_num_seq(parallel) // parallel only define_num_seq(ext_root_scan) @@ -74,7 +73,6 @@ define_num_seq(obj_copy) define_num_seq(termination) // parallel only define_num_seq(parallel_other) // parallel only - define_num_seq(mark_closure) define_num_seq(clear_ct) }; @@ -130,19 +128,19 @@ SizerNewRatio }; SizerKind _sizer_kind; - size_t _min_desired_young_length; - size_t _max_desired_young_length; + uint _min_desired_young_length; + uint _max_desired_young_length; bool _adaptive_size; - size_t calculate_default_min_length(size_t new_number_of_heap_regions); - size_t calculate_default_max_length(size_t new_number_of_heap_regions); + uint calculate_default_min_length(uint new_number_of_heap_regions); + uint calculate_default_max_length(uint new_number_of_heap_regions); public: G1YoungGenSizer(); - void heap_size_changed(size_t new_number_of_heap_regions); - size_t min_desired_young_length() { + void heap_size_changed(uint new_number_of_heap_regions); + uint min_desired_young_length() { return _min_desired_young_length; } - size_t max_desired_young_length() { + uint max_desired_young_length() { return _max_desired_young_length; } bool adaptive_young_list_length() { @@ -177,9 +175,11 @@ double _cur_collection_start_sec; size_t _cur_collection_pause_used_at_start_bytes; - size_t _cur_collection_pause_used_regions_at_start; + uint _cur_collection_pause_used_regions_at_start; double _cur_collection_par_time_ms; - double _cur_satb_drain_time_ms; + + double _cur_collection_code_root_fixup_time_ms; + double _cur_clear_ct_time_ms; double _cur_ref_proc_time_ms; double _cur_ref_enq_time_ms; @@ -226,20 +226,20 @@ double* _par_last_gc_worker_times_ms; // Each workers 'other' time i.e. the elapsed time of the parallel - // phase of the pause minus the sum of the individual sub-phase - // times for a given worker thread. + // code executed by a worker minus the sum of the individual sub-phase + // times for that worker thread. double* _par_last_gc_worker_other_times_ms; // indicates whether we are in young or mixed GC mode bool _gcs_are_young; - size_t _young_list_target_length; - size_t _young_list_fixed_length; + uint _young_list_target_length; + uint _young_list_fixed_length; size_t _prev_eden_capacity; // used for logging // The max number of regions we can extend the eden by while the GC // locker is active. This should be >= _young_list_target_length; - size_t _young_list_max_length; + uint _young_list_max_length; bool _last_gc_was_young; @@ -257,7 +257,7 @@ double _gc_overhead_perc; double _reserve_factor; - size_t _reserve_regions; + uint _reserve_regions; bool during_marking() { return _during_marking; @@ -288,22 +288,20 @@ TruncatedSeq* _cost_per_byte_ms_during_cm_seq; - TruncatedSeq* _young_gc_eff_seq; - G1YoungGenSizer* _young_gen_sizer; - size_t _eden_cset_region_length; - size_t _survivor_cset_region_length; - size_t _old_cset_region_length; + uint _eden_cset_region_length; + uint _survivor_cset_region_length; + uint _old_cset_region_length; - void init_cset_region_lengths(size_t eden_cset_region_length, - size_t survivor_cset_region_length); + void init_cset_region_lengths(uint eden_cset_region_length, + uint survivor_cset_region_length); - size_t eden_cset_region_length() { return _eden_cset_region_length; } - size_t survivor_cset_region_length() { return _survivor_cset_region_length; } - size_t old_cset_region_length() { return _old_cset_region_length; } + uint eden_cset_region_length() { return _eden_cset_region_length; } + uint survivor_cset_region_length() { return _survivor_cset_region_length; } + uint old_cset_region_length() { return _old_cset_region_length; } - size_t _free_regions_at_end_of_collection; + uint _free_regions_at_end_of_collection; size_t _recorded_rs_lengths; size_t _max_rs_lengths; @@ -315,9 +313,6 @@ size_t _rs_lengths_prediction; - size_t _known_garbage_bytes; - double _known_garbage_ratio; - double sigma() { return _sigma; } // A function that prevents us putting too much stock in small sample @@ -488,7 +483,6 @@ get_new_prediction(_non_young_other_cost_per_region_ms_seq); } - double predict_young_collection_elapsed_time_ms(size_t adjustment); double predict_base_elapsed_time_ms(size_t pending_cards); double predict_base_elapsed_time_ms(size_t pending_cards, size_t scanned_cards); @@ -497,10 +491,10 @@ void set_recorded_rs_lengths(size_t rs_lengths); - size_t cset_region_length() { return young_cset_region_length() + - old_cset_region_length(); } - size_t young_cset_region_length() { return eden_cset_region_length() + - survivor_cset_region_length(); } + uint cset_region_length() { return young_cset_region_length() + + old_cset_region_length(); } + uint young_cset_region_length() { return eden_cset_region_length() + + survivor_cset_region_length(); } void record_young_free_cset_time_ms(double time_ms) { _recorded_young_free_cset_time_ms = time_ms; @@ -510,10 +504,6 @@ _recorded_non_young_free_cset_time_ms = time_ms; } - double predict_young_gc_eff() { - return get_new_neg_prediction(_young_gc_eff_seq); - } - double predict_survivor_regions_evac_time(); void cset_regions_freed() { @@ -523,20 +513,6 @@ // also call it on any more surv rate groups } - void set_known_garbage_bytes(size_t known_garbage_bytes) { - _known_garbage_bytes = known_garbage_bytes; - size_t heap_bytes = _g1->capacity(); - _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes; - } - - void decrease_known_garbage_bytes(size_t known_garbage_bytes) { - guarantee( _known_garbage_bytes >= known_garbage_bytes, "invariant" ); - - _known_garbage_bytes -= known_garbage_bytes; - size_t heap_bytes = _g1->capacity(); - _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes; - } - G1MMUTracker* mmu_tracker() { return _mmu_tracker; } @@ -709,7 +685,6 @@ double _cur_mark_stop_world_time_ms; double _mark_remark_start_sec; double _mark_cleanup_start_sec; - double _mark_closure_time_ms; double _root_region_scan_wait_time_ms; // Update the young list target length either by setting it to the @@ -722,12 +697,12 @@ // Calculate and return the minimum desired young list target // length. This is the minimum desired young list length according // to the user's inputs. - size_t calculate_young_list_desired_min_length(size_t base_min_length); + uint calculate_young_list_desired_min_length(uint base_min_length); // Calculate and return the maximum desired young list target // length. This is the maximum desired young list length according // to the user's inputs. - size_t calculate_young_list_desired_max_length(); + uint calculate_young_list_desired_max_length(); // Calculate and return the maximum young list target length that // can fit into the pause time goal. The parameters are: rs_lengths @@ -735,18 +710,18 @@ // be, base_min_length is the alreay existing number of regions in // the young list, min_length and max_length are the desired min and // max young list length according to the user's inputs. - size_t calculate_young_list_target_length(size_t rs_lengths, - size_t base_min_length, - size_t desired_min_length, - size_t desired_max_length); + uint calculate_young_list_target_length(size_t rs_lengths, + uint base_min_length, + uint desired_min_length, + uint desired_max_length); // Check whether a given young length (young_length) fits into the // given target pause time and whether the prediction for the amount // of objects to be copied for the given length will fit into the // given free space (expressed by base_free_regions). It is used by // calculate_young_list_target_length(). - bool predict_will_fit(size_t young_length, double base_time_ms, - size_t base_free_regions, double target_pause_time_ms); + bool predict_will_fit(uint young_length, double base_time_ms, + uint base_free_regions, double target_pause_time_ms); // Count the number of bytes used in the CS. void count_CS_bytes_used(); @@ -775,7 +750,7 @@ } // This should be called after the heap is resized. - void record_new_heap_size(size_t new_number_of_regions); + void record_new_heap_size(uint new_number_of_regions); void init(); @@ -809,10 +784,6 @@ void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms); - void record_mark_closure_time(double mark_closure_time_ms) { - _mark_closure_time_ms = mark_closure_time_ms; - } - void record_root_region_scan_wait_time(double time_ms) { _root_region_scan_wait_time_ms = time_ms; } @@ -846,11 +817,6 @@ _par_last_satb_filtering_times_ms[worker_i] = ms; } - void record_satb_drain_time(double ms) { - assert(_g1->mark_in_progress(), "shouldn't be here otherwise"); - _cur_satb_drain_time_ms = ms; - } - void record_update_rs_time(int thread, double ms) { _par_last_update_rs_times_ms[thread] = ms; } @@ -897,6 +863,10 @@ _cur_collection_par_time_ms = ms; } + void record_code_root_fixup_time(double ms) { + _cur_collection_code_root_fixup_time_ms = ms; + } + void record_aux_start_time(int i) { guarantee(i < _aux_num, "should be within range"); _cur_aux_start_times_ms[i] = os::elapsedTime() * 1000.0; @@ -1033,12 +1003,6 @@ // exceeded the desired limit, return an amount to expand by. size_t expansion_amount(); -#ifndef PRODUCT - // Check any appropriate marked bytes info, asserting false if - // something's wrong, else returning "true". - bool assertMarkedBytesDataOK(); -#endif - // Print tracing information. void print_tracing_info() const; @@ -1055,18 +1019,18 @@ } bool is_young_list_full() { - size_t young_list_length = _g1->young_list()->length(); - size_t young_list_target_length = _young_list_target_length; + uint young_list_length = _g1->young_list()->length(); + uint young_list_target_length = _young_list_target_length; return young_list_length >= young_list_target_length; } bool can_expand_young_list() { - size_t young_list_length = _g1->young_list()->length(); - size_t young_list_max_length = _young_list_max_length; + uint young_list_length = _g1->young_list()->length(); + uint young_list_max_length = _young_list_max_length; return young_list_length < young_list_max_length; } - size_t young_list_max_length() { + uint young_list_max_length() { return _young_list_max_length; } @@ -1081,19 +1045,6 @@ return _young_gen_sizer->adaptive_young_list_length(); } - inline double get_gc_eff_factor() { - double ratio = _known_garbage_ratio; - - double square = ratio * ratio; - // square = square * square; - double ret = square * 9.0 + 1.0; -#if 0 - gclog_or_tty->print_cr("ratio = %1.2lf, ret = %1.2lf", ratio, ret); -#endif // 0 - guarantee(0.0 <= ret && ret < 10.0, "invariant!"); - return ret; - } - private: // // Survivor regions policy. @@ -1104,7 +1055,7 @@ int _tenuring_threshold; // The limit on the number of regions allocated for survivors. - size_t _max_survivor_regions; + uint _max_survivor_regions; // For reporting purposes. size_t _eden_bytes_before_gc; @@ -1112,7 +1063,7 @@ size_t _capacity_before_gc; // The amount of survor regions after a collection. - size_t _recorded_survivor_regions; + uint _recorded_survivor_regions; // List of survivor regions. HeapRegion* _recorded_survivor_head; HeapRegion* _recorded_survivor_tail; @@ -1134,9 +1085,9 @@ return purpose == GCAllocForSurvived; } - static const size_t REGIONS_UNLIMITED = ~(size_t)0; + static const uint REGIONS_UNLIMITED = (uint) -1; - size_t max_regions(int purpose); + uint max_regions(int purpose); // The limit on regions for a particular purpose is reached. void note_alloc_region_limit_reached(int purpose) { @@ -1153,7 +1104,7 @@ _survivor_surv_rate_group->stop_adding_regions(); } - void record_survivor_regions(size_t regions, + void record_survivor_regions(uint regions, HeapRegion* head, HeapRegion* tail) { _recorded_survivor_regions = regions; @@ -1161,12 +1112,11 @@ _recorded_survivor_tail = tail; } - size_t recorded_survivor_regions() { + uint recorded_survivor_regions() { return _recorded_survivor_regions; } - void record_thread_age_table(ageTable* age_table) - { + void record_thread_age_table(ageTable* age_table) { _survivors_age_table.merge_par(age_table); }
--- a/src/share/vm/gc_implementation/g1/g1ErgoVerbose.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1ErgoVerbose.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -120,7 +120,7 @@ // Single parameter format strings #define ergo_format_str(_name_) ", " _name_ ": %s" -#define ergo_format_region(_name_) ", " _name_ ": "SIZE_FORMAT" regions" +#define ergo_format_region(_name_) ", " _name_ ": %u regions" #define ergo_format_byte(_name_) ", " _name_ ": "SIZE_FORMAT" bytes" #define ergo_format_double(_name_) ", " _name_ ": %1.2f" #define ergo_format_perc(_name_) ", " _name_ ": %1.2f %%"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc_implementation/g1/g1Log.cpp Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "gc_implementation/g1/g1_globals.hpp" +#include "gc_implementation/g1/g1Log.hpp" +#include "runtime/globals.hpp" + +G1Log::LogLevel G1Log::_level = G1Log::LevelNone; + +// If G1LogLevel has not been set up we will use the values of PrintGC +// and PrintGCDetails for the logging level. +// - PrintGC maps to "fine". +// - PrintGCDetails maps to "finer". +void G1Log::init() { + if (G1LogLevel != NULL && G1LogLevel[0] != '\0') { + if (strncmp("none", G1LogLevel, 4) == 0 && G1LogLevel[4] == '\0') { + _level = LevelNone; + } else if (strncmp("fine", G1LogLevel, 4) == 0 && G1LogLevel[4] == '\0') { + _level = LevelFine; + } else if (strncmp("finer", G1LogLevel, 5) == 0 && G1LogLevel[5] == '\0') { + _level = LevelFiner; + } else if (strncmp("finest", G1LogLevel, 6) == 0 && G1LogLevel[6] == '\0') { + _level = LevelFinest; + } else { + warning("Unknown logging level '%s', should be one of 'fine', 'finer' or 'finest'.", G1LogLevel); + } + } else { + if (PrintGCDetails) { + _level = LevelFiner; + } else if (PrintGC) { + _level = LevelFine; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc_implementation/g1/g1Log.hpp Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1LOG_HPP +#define SHARE_VM_GC_IMPLEMENTATION_G1_G1LOG_HPP + +#include "memory/allocation.hpp" + +class G1Log : public AllStatic { + typedef enum { + LevelNone, + LevelFine, + LevelFiner, + LevelFinest + } LogLevel; + + static LogLevel _level; + + public: + inline static bool fine() { + return _level >= LevelFine; + } + + inline static bool finer() { + return _level >= LevelFiner; + } + + inline static bool finest() { + return _level == LevelFinest; + } + + static void init(); +}; + +#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1LOG_HPP
--- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Tue May 08 11:29:21 2012 -0700 @@ -29,6 +29,7 @@ #include "classfile/vmSymbols.hpp" #include "code/codeCache.hpp" #include "code/icBuffer.hpp" +#include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/g1MarkSweep.hpp" #include "memory/gcLocker.hpp" #include "memory/genCollectedHeap.hpp" @@ -126,7 +127,7 @@ void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading, bool clear_all_softrefs) { // Recursively traverse all live objects and mark them - TraceTime tm("phase 1", PrintGC && Verbose, true, gclog_or_tty); + TraceTime tm("phase 1", G1Log::fine() && Verbose, true, gclog_or_tty); GenMarkSweep::trace(" 1"); SharedHeap* sh = SharedHeap::heap(); @@ -192,8 +193,7 @@ // fail. At the end of the GC, the orginal mark word values // (including hash values) are restored to the appropriate // objects. - Universe::heap()->verify(/* allow dirty */ true, - /* silent */ false, + Universe::heap()->verify(/* silent */ false, /* option */ VerifyOption_G1UseMarkWord); G1CollectedHeap* g1h = G1CollectedHeap::heap(); @@ -291,7 +291,7 @@ G1CollectedHeap* g1h = G1CollectedHeap::heap(); Generation* pg = g1h->perm_gen(); - TraceTime tm("phase 2", PrintGC && Verbose, true, gclog_or_tty); + TraceTime tm("phase 2", G1Log::fine() && Verbose, true, gclog_or_tty); GenMarkSweep::trace("2"); FindFirstRegionClosure cl; @@ -335,7 +335,7 @@ Generation* pg = g1h->perm_gen(); // Adjust the pointers to reflect the new locations - TraceTime tm("phase 3", PrintGC && Verbose, true, gclog_or_tty); + TraceTime tm("phase 3", G1Log::fine() && Verbose, true, gclog_or_tty); GenMarkSweep::trace("3"); SharedHeap* sh = SharedHeap::heap(); @@ -399,7 +399,7 @@ G1CollectedHeap* g1h = G1CollectedHeap::heap(); Generation* pg = g1h->perm_gen(); - TraceTime tm("phase 4", PrintGC && Verbose, true, gclog_or_tty); + TraceTime tm("phase 4", G1Log::fine() && Verbose, true, gclog_or_tty); GenMarkSweep::trace("4"); pg->compact();
--- a/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2012 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -177,19 +177,19 @@ // values we read here are possible (i.e., at a STW phase at the end // of a GC). - size_t young_list_length = g1->young_list()->length(); - size_t survivor_list_length = g1->g1_policy()->recorded_survivor_regions(); + uint young_list_length = g1->young_list()->length(); + uint survivor_list_length = g1->g1_policy()->recorded_survivor_regions(); assert(young_list_length >= survivor_list_length, "invariant"); - size_t eden_list_length = young_list_length - survivor_list_length; + uint eden_list_length = young_list_length - survivor_list_length; // Max length includes any potential extensions to the young gen // we'll do when the GC locker is active. - size_t young_list_max_length = g1->g1_policy()->young_list_max_length(); + uint young_list_max_length = g1->g1_policy()->young_list_max_length(); assert(young_list_max_length >= survivor_list_length, "invariant"); - size_t eden_list_max_length = young_list_max_length - survivor_list_length; + uint eden_list_max_length = young_list_max_length - survivor_list_length; _overall_used = g1->used_unlocked(); - _eden_used = eden_list_length * HeapRegion::GrainBytes; - _survivor_used = survivor_list_length * HeapRegion::GrainBytes; + _eden_used = (size_t) eden_list_length * HeapRegion::GrainBytes; + _survivor_used = (size_t) survivor_list_length * HeapRegion::GrainBytes; _young_region_num = young_list_length; _old_used = subtract_up_to_zero(_overall_used, _eden_used + _survivor_used); @@ -207,7 +207,7 @@ committed -= _survivor_committed + _old_committed; // Next, calculate and remove the committed size for the eden. - _eden_committed = eden_list_max_length * HeapRegion::GrainBytes; + _eden_committed = (size_t) eden_list_max_length * HeapRegion::GrainBytes; // Somewhat defensive: be robust in case there are inaccuracies in // the calculations _eden_committed = MIN2(_eden_committed, committed); @@ -237,10 +237,10 @@ // When a new eden region is allocated, only the eden_used size is // affected (since we have recalculated everything else at the last GC). - size_t young_region_num = g1h()->young_list()->length(); + uint young_region_num = g1h()->young_list()->length(); if (young_region_num > _young_region_num) { - size_t diff = young_region_num - _young_region_num; - _eden_used += diff * HeapRegion::GrainBytes; + uint diff = young_region_num - _young_region_num; + _eden_used += (size_t) diff * HeapRegion::GrainBytes; // Somewhat defensive: cap the eden used size to make sure it // never exceeds the committed size. _eden_used = MIN2(_eden_used, _eden_committed);
--- a/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -147,7 +147,7 @@ size_t _overall_committed; size_t _overall_used; - size_t _young_region_num; + uint _young_region_num; size_t _young_gen_committed; size_t _eden_committed; size_t _eden_used;
--- a/src/share/vm/gc_implementation/g1/g1OopClosures.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1OopClosures.hpp Tue May 08 11:29:21 2012 -0700 @@ -118,9 +118,11 @@ virtual void do_oop(narrowOop* p) { do_oop_nv(p); } }; +template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> +class G1ParCopyClosure : public G1ParClosureSuper { + G1ParScanClosure _scanner; + template <class T> void do_oop_work(T* p); -class G1ParCopyHelper : public G1ParClosureSuper { - G1ParScanClosure *_scanner; protected: // Mark the object if it's not already marked. This is used to mark // objects pointed to by roots that are guaranteed not to move @@ -135,22 +137,10 @@ oop copy_to_survivor_space(oop obj); public: - G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, - G1ParScanClosure *scanner) : - G1ParClosureSuper(g1, par_scan_state), _scanner(scanner) { } -}; - -template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> -class G1ParCopyClosure : public G1ParCopyHelper { - G1ParScanClosure _scanner; - - template <class T> void do_oop_work(T* p); - -public: G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : _scanner(g1, par_scan_state, rp), - G1ParCopyHelper(g1, par_scan_state, &_scanner) { + G1ParClosureSuper(g1, par_scan_state) { assert(_ref_processor == NULL, "sanity"); }
--- a/src/share/vm/gc_implementation/g1/g1_globals.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/g1_globals.hpp Tue May 08 11:29:21 2012 -0700 @@ -26,7 +26,6 @@ #define SHARE_VM_GC_IMPLEMENTATION_G1_G1_GLOBALS_HPP #include "runtime/globals.hpp" - // // Defines all globals flags used by the garbage-first compiler. // @@ -69,9 +68,6 @@ diagnostic(bool, G1TraceConcRefinement, false, \ "Trace G1 concurrent refinement") \ \ - product(intx, G1MarkRegionStackSize, 1024 * 1024, \ - "Size of the region stack for concurrent marking.") \ - \ product(double, G1ConcMarkStepDurationMillis, 10.0, \ "Target duration of individual concurrent marking steps " \ "in milliseconds.") \ @@ -131,9 +127,6 @@ "Prints the liveness information for all regions in the heap " \ "at the end of a marking cycle.") \ \ - develop(bool, G1PrintParCleanupStats, false, \ - "When true, print extra stats about parallel cleanup.") \ - \ product(intx, G1UpdateBufferSize, 256, \ "Size of an update buffer") \ \ @@ -312,7 +305,10 @@ \ develop(uintx, G1OldCSetRegionThresholdPercent, 10, \ "An upper bound for the number of old CSet regions expressed " \ - "as a percentage of the heap size.") + "as a percentage of the heap size.") \ + \ + experimental(ccstr, G1LogLevel, NULL, \ + "Log level for G1 logging: fine, finer, finest") G1_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG)
--- a/src/share/vm/gc_implementation/g1/heapRegion.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegion.cpp Tue May 08 11:29:21 2012 -0700 @@ -334,7 +334,7 @@ guarantee(GrainWords == 0, "we should only set it once"); GrainWords = GrainBytes >> LogHeapWordSize; - guarantee((size_t)(1 << LogOfHRGrainWords) == GrainWords, "sanity"); + guarantee((size_t) 1 << LogOfHRGrainWords == GrainWords, "sanity"); guarantee(CardsPerRegion == 0, "we should only set it once"); CardsPerRegion = GrainBytes >> CardTableModRefBS::card_shift; @@ -370,7 +370,6 @@ _claimed = InitialClaimValue; } zero_marked_bytes(); - set_sort_index(-1); _offsets.resize(HeapRegion::GrainWords); init_top_at_mark_start(); @@ -482,17 +481,16 @@ #endif // _MSC_VER -HeapRegion:: -HeapRegion(size_t hrs_index, G1BlockOffsetSharedArray* sharedOffsetArray, - MemRegion mr, bool is_zeroed) - : G1OffsetTableContigSpace(sharedOffsetArray, mr, is_zeroed), +HeapRegion::HeapRegion(uint hrs_index, + G1BlockOffsetSharedArray* sharedOffsetArray, + MemRegion mr, bool is_zeroed) : + G1OffsetTableContigSpace(sharedOffsetArray, mr, is_zeroed), _hrs_index(hrs_index), _humongous_type(NotHumongous), _humongous_start_region(NULL), _in_collection_set(false), _next_in_special_set(NULL), _orig_end(NULL), _claimed(InitialClaimValue), _evacuation_failed(false), - _prev_marked_bytes(0), _next_marked_bytes(0), _sort_index(-1), - _gc_efficiency(0.0), + _prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0), _young_type(NotYoung), _next_young_region(NULL), _next_dirty_cards_region(NULL), _next(NULL), _pending_removal(false), #ifdef ASSERT @@ -779,16 +777,15 @@ G1OffsetTableContigSpace::print_on(st); } -void HeapRegion::verify(bool allow_dirty) const { +void HeapRegion::verify() const { bool dummy = false; - verify(allow_dirty, VerifyOption_G1UsePrevMarking, /* failures */ &dummy); + verify(VerifyOption_G1UsePrevMarking, /* failures */ &dummy); } // This really ought to be commoned up into OffsetTableContigSpace somehow. // We would need a mechanism to make that code skip dead objects. -void HeapRegion::verify(bool allow_dirty, - VerifyOption vo, +void HeapRegion::verify(VerifyOption vo, bool* failures) const { G1CollectedHeap* g1 = G1CollectedHeap::heap(); *failures = false;
--- a/src/share/vm/gc_implementation/g1/heapRegion.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegion.hpp Tue May 08 11:29:21 2012 -0700 @@ -52,12 +52,15 @@ class HeapRegion; class HeapRegionSetBase; -#define HR_FORMAT SIZE_FORMAT":(%s)["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]" +#define HR_FORMAT "%u:(%s)["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]" #define HR_FORMAT_PARAMS(_hr_) \ (_hr_)->hrs_index(), \ (_hr_)->is_survivor() ? "S" : (_hr_)->is_young() ? "E" : "-", \ (_hr_)->bottom(), (_hr_)->top(), (_hr_)->end() +// sentinel value for hrs_index +#define G1_NULL_HRS_INDEX ((uint) -1) + // A dirty card to oop closure for heap regions. It // knows how to get the G1 heap and how to use the bitmap // in the concurrent marker used by G1 to filter remembered @@ -235,7 +238,7 @@ protected: // The index of this region in the heap region sequence. - size_t _hrs_index; + uint _hrs_index; HumongousType _humongous_type; // For a humongous region, region in which it starts. @@ -278,12 +281,8 @@ size_t _prev_marked_bytes; // Bytes known to be live via last completed marking. size_t _next_marked_bytes; // Bytes known to be live via in-progress marking. - // See "sort_index" method. -1 means is not in the array. - int _sort_index; - - // <PREDICTION> + // The calculated GC efficiency of the region. double _gc_efficiency; - // </PREDICTION> enum YoungType { NotYoung, // a region is not young @@ -342,7 +341,7 @@ public: // If "is_zeroed" is "true", the region "mr" can be assumed to contain zeros. - HeapRegion(size_t hrs_index, + HeapRegion(uint hrs_index, G1BlockOffsetSharedArray* sharedOffsetArray, MemRegion mr, bool is_zeroed); @@ -373,10 +372,9 @@ ScrubRemSetClaimValue = 3, ParVerifyClaimValue = 4, RebuildRSClaimValue = 5, - CompleteMarkCSetClaimValue = 6, - ParEvacFailureClaimValue = 7, - AggregateCountClaimValue = 8, - VerifyCountClaimValue = 9 + ParEvacFailureClaimValue = 6, + AggregateCountClaimValue = 7, + VerifyCountClaimValue = 8 }; inline HeapWord* par_allocate_no_bot_updates(size_t word_size) { @@ -390,7 +388,7 @@ // If this region is a member of a HeapRegionSeq, the index in that // sequence, otherwise -1. - size_t hrs_index() const { return _hrs_index; } + uint hrs_index() const { return _hrs_index; } // The number of bytes marked live in the region in the last marking phase. size_t marked_bytes() { return _prev_marked_bytes; } @@ -627,16 +625,6 @@ // last mark phase ended. bool is_marked() { return _prev_top_at_mark_start != bottom(); } - // If "is_marked()" is true, then this is the index of the region in - // an array constructed at the end of marking of the regions in a - // "desirability" order. - int sort_index() { - return _sort_index; - } - void set_sort_index(int i) { - _sort_index = i; - } - void init_top_at_conc_mark_count() { _top_at_conc_mark_count = bottom(); } @@ -824,10 +812,10 @@ // Currently there is only one place where this is called with // vo == UseMarkWord, which is to verify the marking during a // full GC. - void verify(bool allow_dirty, VerifyOption vo, bool *failures) const; + void verify(VerifyOption vo, bool *failures) const; // Override; it uses the "prev" marking information - virtual void verify(bool allow_dirty) const; + virtual void verify() const; }; // HeapRegionClosure is used for iterating over regions.
--- a/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -577,7 +577,7 @@ #endif void OtherRegionsTable::add_reference(OopOrNarrowOopStar from, int tid) { - size_t cur_hrs_ind = hr()->hrs_index(); + size_t cur_hrs_ind = (size_t) hr()->hrs_index(); #if HRRS_VERBOSE gclog_or_tty->print_cr("ORT::add_reference_work(" PTR_FORMAT "->" PTR_FORMAT ").", @@ -841,7 +841,7 @@ #endif // Set the corresponding coarse bit. - size_t max_hrs_index = max->hr()->hrs_index(); + size_t max_hrs_index = (size_t) max->hr()->hrs_index(); if (!_coarse_map.at(max_hrs_index)) { _coarse_map.at_put(max_hrs_index, true); _n_coarse_entries++; @@ -866,17 +866,20 @@ void OtherRegionsTable::scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm) { // First eliminated garbage regions from the coarse map. - if (G1RSScrubVerbose) - gclog_or_tty->print_cr("Scrubbing region "SIZE_FORMAT":", - hr()->hrs_index()); + if (G1RSScrubVerbose) { + gclog_or_tty->print_cr("Scrubbing region %u:", hr()->hrs_index()); + } assert(_coarse_map.size() == region_bm->size(), "Precondition"); - if (G1RSScrubVerbose) - gclog_or_tty->print(" Coarse map: before = %d...", _n_coarse_entries); + if (G1RSScrubVerbose) { + gclog_or_tty->print(" Coarse map: before = "SIZE_FORMAT"...", + _n_coarse_entries); + } _coarse_map.set_intersection(*region_bm); _n_coarse_entries = _coarse_map.count_one_bits(); - if (G1RSScrubVerbose) - gclog_or_tty->print_cr(" after = %d.", _n_coarse_entries); + if (G1RSScrubVerbose) { + gclog_or_tty->print_cr(" after = "SIZE_FORMAT".", _n_coarse_entries); + } // Now do the fine-grained maps. for (size_t i = 0; i < _max_fine_entries; i++) { @@ -885,23 +888,27 @@ while (cur != NULL) { PosParPRT* nxt = cur->next(); // If the entire region is dead, eliminate. - if (G1RSScrubVerbose) - gclog_or_tty->print_cr(" For other region "SIZE_FORMAT":", + if (G1RSScrubVerbose) { + gclog_or_tty->print_cr(" For other region %u:", cur->hr()->hrs_index()); - if (!region_bm->at(cur->hr()->hrs_index())) { + } + if (!region_bm->at((size_t) cur->hr()->hrs_index())) { *prev = nxt; cur->set_next(NULL); _n_fine_entries--; - if (G1RSScrubVerbose) + if (G1RSScrubVerbose) { gclog_or_tty->print_cr(" deleted via region map."); + } PosParPRT::free(cur); } else { // Do fine-grain elimination. - if (G1RSScrubVerbose) + if (G1RSScrubVerbose) { gclog_or_tty->print(" occ: before = %4d.", cur->occupied()); + } cur->scrub(ctbs, card_bm); - if (G1RSScrubVerbose) + if (G1RSScrubVerbose) { gclog_or_tty->print_cr(" after = %4d.", cur->occupied()); + } // Did that empty the table completely? if (cur->occupied() == 0) { *prev = nxt; @@ -1003,7 +1010,7 @@ void OtherRegionsTable::clear_incoming_entry(HeapRegion* from_hr) { MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag); - size_t hrs_ind = from_hr->hrs_index(); + size_t hrs_ind = (size_t) from_hr->hrs_index(); size_t ind = hrs_ind & _mod_max_fine_entries_mask; if (del_single_region_table(ind, from_hr)) { assert(!_coarse_map.at(hrs_ind), "Inv"); @@ -1011,7 +1018,7 @@ _coarse_map.par_at_put(hrs_ind, 0); } // Check to see if any of the fcc entries come from here. - size_t hr_ind = hr()->hrs_index(); + size_t hr_ind = (size_t) hr()->hrs_index(); for (int tid = 0; tid < HeapRegionRemSet::num_par_rem_sets(); tid++) { int fcc_ent = _from_card_cache[tid][hr_ind]; if (fcc_ent != -1) { @@ -1223,7 +1230,7 @@ if ((size_t)_coarse_cur_region_index < _coarse_map->size()) { _coarse_cur_region_cur_card = 0; HeapWord* r_bot = - _g1h->region_at(_coarse_cur_region_index)->bottom(); + _g1h->region_at((uint) _coarse_cur_region_index)->bottom(); _cur_region_card_offset = _bosa->index_for(r_bot); } else { return false;
--- a/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp Tue May 08 11:29:21 2012 -0700 @@ -329,13 +329,13 @@ // Declare the heap size (in # of regions) to the HeapRegionRemSet(s). // (Uses it to initialize from_card_cache). - static void init_heap(size_t max_regions) { - OtherRegionsTable::init_from_card_cache(max_regions); + static void init_heap(uint max_regions) { + OtherRegionsTable::init_from_card_cache((size_t) max_regions); } // Declares that only regions i s.t. 0 <= i < new_n_regs are in use. - static void shrink_heap(size_t new_n_regs) { - OtherRegionsTable::shrink_from_card_cache(new_n_regs); + static void shrink_heap(uint new_n_regs) { + OtherRegionsTable::shrink_from_card_cache((size_t) new_n_regs); } #ifndef PRODUCT
--- a/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -31,16 +31,15 @@ // Private -size_t HeapRegionSeq::find_contiguous_from(size_t from, size_t num) { - size_t len = length(); +uint HeapRegionSeq::find_contiguous_from(uint from, uint num) { + uint len = length(); assert(num > 1, "use this only for sequences of length 2 or greater"); assert(from <= len, - err_msg("from: "SIZE_FORMAT" should be valid and <= than "SIZE_FORMAT, - from, len)); + err_msg("from: %u should be valid and <= than %u", from, len)); - size_t curr = from; - size_t first = G1_NULL_HRS_INDEX; - size_t num_so_far = 0; + uint curr = from; + uint first = G1_NULL_HRS_INDEX; + uint num_so_far = 0; while (curr < len && num_so_far < num) { if (at(curr)->is_empty()) { if (first == G1_NULL_HRS_INDEX) { @@ -60,7 +59,7 @@ // we found enough space for the humongous object assert(from <= first && first < len, "post-condition"); assert(first < curr && (curr - first) == num, "post-condition"); - for (size_t i = first; i < first + num; ++i) { + for (uint i = first; i < first + num; ++i) { assert(at(i)->is_empty(), "post-condition"); } return first; @@ -73,10 +72,10 @@ // Public void HeapRegionSeq::initialize(HeapWord* bottom, HeapWord* end, - size_t max_length) { - assert((size_t) bottom % HeapRegion::GrainBytes == 0, + uint max_length) { + assert((uintptr_t) bottom % HeapRegion::GrainBytes == 0, "bottom should be heap region aligned"); - assert((size_t) end % HeapRegion::GrainBytes == 0, + assert((uintptr_t) end % HeapRegion::GrainBytes == 0, "end should be heap region aligned"); _length = 0; @@ -88,8 +87,8 @@ _max_length = max_length; _regions = NEW_C_HEAP_ARRAY(HeapRegion*, max_length); - memset(_regions, 0, max_length * sizeof(HeapRegion*)); - _regions_biased = _regions - ((size_t) bottom >> _region_shift); + memset(_regions, 0, (size_t) max_length * sizeof(HeapRegion*)); + _regions_biased = _regions - ((uintx) bottom >> _region_shift); assert(&_regions[0] == &_regions_biased[addr_to_index_biased(bottom)], "bottom should be included in the region with index 0"); @@ -105,7 +104,7 @@ assert(_heap_bottom <= next_bottom, "invariant"); while (next_bottom < new_end) { assert(next_bottom < _heap_end, "invariant"); - size_t index = length(); + uint index = length(); assert(index < _max_length, "otherwise we cannot expand further"); if (index == 0) { @@ -139,9 +138,9 @@ return MemRegion(old_end, next_bottom); } -size_t HeapRegionSeq::free_suffix() { - size_t res = 0; - size_t index = length(); +uint HeapRegionSeq::free_suffix() { + uint res = 0; + uint index = length(); while (index > 0) { index -= 1; if (!at(index)->is_empty()) { @@ -152,27 +151,24 @@ return res; } -size_t HeapRegionSeq::find_contiguous(size_t num) { +uint HeapRegionSeq::find_contiguous(uint num) { assert(num > 1, "use this only for sequences of length 2 or greater"); assert(_next_search_index <= length(), - err_msg("_next_search_indeex: "SIZE_FORMAT" " - "should be valid and <= than "SIZE_FORMAT, + err_msg("_next_search_index: %u should be valid and <= than %u", _next_search_index, length())); - size_t start = _next_search_index; - size_t res = find_contiguous_from(start, num); + uint start = _next_search_index; + uint res = find_contiguous_from(start, num); if (res == G1_NULL_HRS_INDEX && start > 0) { // Try starting from the beginning. If _next_search_index was 0, // no point in doing this again. res = find_contiguous_from(0, num); } if (res != G1_NULL_HRS_INDEX) { - assert(res < length(), - err_msg("res: "SIZE_FORMAT" should be valid", res)); + assert(res < length(), err_msg("res: %u should be valid", res)); _next_search_index = res + num; assert(_next_search_index <= length(), - err_msg("_next_search_indeex: "SIZE_FORMAT" " - "should be valid and <= than "SIZE_FORMAT, + err_msg("_next_search_index: %u should be valid and <= than %u", _next_search_index, length())); } return res; @@ -183,20 +179,20 @@ } void HeapRegionSeq::iterate_from(HeapRegion* hr, HeapRegionClosure* blk) const { - size_t hr_index = 0; + uint hr_index = 0; if (hr != NULL) { - hr_index = (size_t) hr->hrs_index(); + hr_index = hr->hrs_index(); } - size_t len = length(); - for (size_t i = hr_index; i < len; i += 1) { + uint len = length(); + for (uint i = hr_index; i < len; i += 1) { bool res = blk->doHeapRegion(at(i)); if (res) { blk->incomplete(); return; } } - for (size_t i = 0; i < hr_index; i += 1) { + for (uint i = 0; i < hr_index; i += 1) { bool res = blk->doHeapRegion(at(i)); if (res) { blk->incomplete(); @@ -206,7 +202,7 @@ } MemRegion HeapRegionSeq::shrink_by(size_t shrink_bytes, - size_t* num_regions_deleted) { + uint* num_regions_deleted) { // Reset this in case it's currently pointing into the regions that // we just removed. _next_search_index = 0; @@ -218,7 +214,7 @@ assert(_allocated_length > 0, "we should have at least one region committed"); // around the loop, i will be the next region to be removed - size_t i = length() - 1; + uint i = length() - 1; assert(i > 0, "we should never remove all regions"); // [last_start, end) is the MemRegion that covers the regions we will remove. HeapWord* end = at(i)->end(); @@ -249,29 +245,24 @@ #ifndef PRODUCT void HeapRegionSeq::verify_optional() { guarantee(_length <= _allocated_length, - err_msg("invariant: _length: "SIZE_FORMAT" " - "_allocated_length: "SIZE_FORMAT, + err_msg("invariant: _length: %u _allocated_length: %u", _length, _allocated_length)); guarantee(_allocated_length <= _max_length, - err_msg("invariant: _allocated_length: "SIZE_FORMAT" " - "_max_length: "SIZE_FORMAT, + err_msg("invariant: _allocated_length: %u _max_length: %u", _allocated_length, _max_length)); guarantee(_next_search_index <= _length, - err_msg("invariant: _next_search_index: "SIZE_FORMAT" " - "_length: "SIZE_FORMAT, + err_msg("invariant: _next_search_index: %u _length: %u", _next_search_index, _length)); HeapWord* prev_end = _heap_bottom; - for (size_t i = 0; i < _allocated_length; i += 1) { + for (uint i = 0; i < _allocated_length; i += 1) { HeapRegion* hr = _regions[i]; - guarantee(hr != NULL, err_msg("invariant: i: "SIZE_FORMAT, i)); + guarantee(hr != NULL, err_msg("invariant: i: %u", i)); guarantee(hr->bottom() == prev_end, - err_msg("invariant i: "SIZE_FORMAT" "HR_FORMAT" " - "prev_end: "PTR_FORMAT, + err_msg("invariant i: %u "HR_FORMAT" prev_end: "PTR_FORMAT, i, HR_FORMAT_PARAMS(hr), prev_end)); guarantee(hr->hrs_index() == i, - err_msg("invariant: i: "SIZE_FORMAT" hrs_index(): "SIZE_FORMAT, - i, hr->hrs_index())); + err_msg("invariant: i: %u hrs_index(): %u", i, hr->hrs_index())); if (i < _length) { // Asserts will fire if i is >= _length HeapWord* addr = hr->bottom(); @@ -290,8 +281,8 @@ prev_end = hr->end(); } } - for (size_t i = _allocated_length; i < _max_length; i += 1) { - guarantee(_regions[i] == NULL, err_msg("invariant i: "SIZE_FORMAT, i)); + for (uint i = _allocated_length; i < _max_length; i += 1) { + guarantee(_regions[i] == NULL, err_msg("invariant i: %u", i)); } } #endif // PRODUCT
--- a/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -29,8 +29,6 @@ class HeapRegionClosure; class FreeRegionList; -#define G1_NULL_HRS_INDEX ((size_t) -1) - // This class keeps track of the region metadata (i.e., HeapRegion // instances). They are kept in the _regions array in address // order. A region's index in the array corresponds to its index in @@ -65,7 +63,7 @@ HeapRegion** _regions_biased; // The number of regions committed in the heap. - size_t _length; + uint _length; // The address of the first reserved word in the heap. HeapWord* _heap_bottom; @@ -74,32 +72,32 @@ HeapWord* _heap_end; // The log of the region byte size. - size_t _region_shift; + uint _region_shift; // A hint for which index to start searching from for humongous // allocations. - size_t _next_search_index; + uint _next_search_index; // The number of regions for which we have allocated HeapRegions for. - size_t _allocated_length; + uint _allocated_length; // The maximum number of regions in the heap. - size_t _max_length; + uint _max_length; // Find a contiguous set of empty regions of length num, starting // from the given index. - size_t find_contiguous_from(size_t from, size_t num); + uint find_contiguous_from(uint from, uint num); // Map a heap address to a biased region index. Assume that the // address is valid. - inline size_t addr_to_index_biased(HeapWord* addr) const; + inline uintx addr_to_index_biased(HeapWord* addr) const; - void increment_length(size_t* length) { + void increment_length(uint* length) { assert(*length < _max_length, "pre-condition"); *length += 1; } - void decrement_length(size_t* length) { + void decrement_length(uint* length) { assert(*length > 0, "pre-condition"); *length -= 1; } @@ -108,11 +106,11 @@ // Empty contructor, we'll initialize it with the initialize() method. HeapRegionSeq() { } - void initialize(HeapWord* bottom, HeapWord* end, size_t max_length); + void initialize(HeapWord* bottom, HeapWord* end, uint max_length); // Return the HeapRegion at the given index. Assume that the index // is valid. - inline HeapRegion* at(size_t index) const; + inline HeapRegion* at(uint index) const; // If addr is within the committed space return its corresponding // HeapRegion, otherwise return NULL. @@ -123,10 +121,10 @@ inline HeapRegion* addr_to_region_unsafe(HeapWord* addr) const; // Return the number of regions that have been committed in the heap. - size_t length() const { return _length; } + uint length() const { return _length; } // Return the maximum number of regions in the heap. - size_t max_length() const { return _max_length; } + uint max_length() const { return _max_length; } // Expand the sequence to reflect that the heap has grown from // old_end to new_end. Either create new HeapRegions, or re-use @@ -139,12 +137,12 @@ // Return the number of contiguous regions at the end of the sequence // that are available for allocation. - size_t free_suffix(); + uint free_suffix(); // Find a contiguous set of empty regions of length num and return // the index of the first region or G1_NULL_HRS_INDEX if the // search was unsuccessful. - size_t find_contiguous(size_t num); + uint find_contiguous(uint num); // Apply blk->doHeapRegion() on all committed regions in address order, // terminating the iteration early if doHeapRegion() returns true. @@ -159,7 +157,7 @@ // sequence. Return a MemRegion that corresponds to the address // range of the uncommitted regions. Assume shrink_bytes is page and // heap region aligned. - MemRegion shrink_by(size_t shrink_bytes, size_t* num_regions_deleted); + MemRegion shrink_by(size_t shrink_bytes, uint* num_regions_deleted); // Do some sanity checking. void verify_optional() PRODUCT_RETURN;
--- a/src/share/vm/gc_implementation/g1/heapRegionSeq.inline.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionSeq.inline.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,11 +28,11 @@ #include "gc_implementation/g1/heapRegion.hpp" #include "gc_implementation/g1/heapRegionSeq.hpp" -inline size_t HeapRegionSeq::addr_to_index_biased(HeapWord* addr) const { +inline uintx HeapRegionSeq::addr_to_index_biased(HeapWord* addr) const { assert(_heap_bottom <= addr && addr < _heap_end, err_msg("addr: "PTR_FORMAT" bottom: "PTR_FORMAT" end: "PTR_FORMAT, addr, _heap_bottom, _heap_end)); - size_t index = (size_t) addr >> _region_shift; + uintx index = (uintx) addr >> _region_shift; return index; } @@ -40,7 +40,7 @@ assert(_heap_bottom <= addr && addr < _heap_end, err_msg("addr: "PTR_FORMAT" bottom: "PTR_FORMAT" end: "PTR_FORMAT, addr, _heap_bottom, _heap_end)); - size_t index_biased = addr_to_index_biased(addr); + uintx index_biased = addr_to_index_biased(addr); HeapRegion* hr = _regions_biased[index_biased]; assert(hr != NULL, "invariant"); return hr; @@ -55,7 +55,7 @@ return NULL; } -inline HeapRegion* HeapRegionSeq::at(size_t index) const { +inline HeapRegion* HeapRegionSeq::at(uint index) const { assert(index < length(), "pre-condition"); HeapRegion* hr = _regions[index]; assert(hr != NULL, "sanity");
--- a/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,28 +25,26 @@ #include "precompiled.hpp" #include "gc_implementation/g1/heapRegionSet.inline.hpp" -size_t HeapRegionSetBase::_unrealistically_long_length = 0; +uint HeapRegionSetBase::_unrealistically_long_length = 0; HRSPhase HeapRegionSetBase::_phase = HRSPhaseNone; //////////////////// HeapRegionSetBase //////////////////// -void HeapRegionSetBase::set_unrealistically_long_length(size_t len) { +void HeapRegionSetBase::set_unrealistically_long_length(uint len) { guarantee(_unrealistically_long_length == 0, "should only be set once"); _unrealistically_long_length = len; } -size_t HeapRegionSetBase::calculate_region_num(HeapRegion* hr) { +uint HeapRegionSetBase::calculate_region_num(HeapRegion* hr) { assert(hr->startsHumongous(), "pre-condition"); assert(hr->capacity() % HeapRegion::GrainBytes == 0, "invariant"); - size_t region_num = hr->capacity() >> HeapRegion::LogOfHRGrainBytes; + uint region_num = (uint) (hr->capacity() >> HeapRegion::LogOfHRGrainBytes); assert(region_num > 0, "sanity"); return region_num; } void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) { - msg->append("[%s] %s " - "ln: "SIZE_FORMAT" rn: "SIZE_FORMAT" " - "cy: "SIZE_FORMAT" ud: "SIZE_FORMAT, + msg->append("[%s] %s ln: %u rn: %u cy: "SIZE_FORMAT" ud: "SIZE_FORMAT, name(), message, length(), region_num(), total_capacity_bytes(), total_used_bytes()); fill_in_ext_msg_extra(msg); @@ -170,13 +168,11 @@ hrs_ext_msg(this, "verification should be in progress")); guarantee(length() == _calc_length, - hrs_err_msg("[%s] length: "SIZE_FORMAT" should be == " - "calc length: "SIZE_FORMAT, + hrs_err_msg("[%s] length: %u should be == calc length: %u", name(), length(), _calc_length)); guarantee(region_num() == _calc_region_num, - hrs_err_msg("[%s] region num: "SIZE_FORMAT" should be == " - "calc region num: "SIZE_FORMAT, + hrs_err_msg("[%s] region num: %u should be == calc region num: %u", name(), region_num(), _calc_region_num)); guarantee(total_capacity_bytes() == _calc_total_capacity_bytes, @@ -211,8 +207,8 @@ out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous())); out->print_cr(" empty : %s", BOOL_TO_STR(regions_empty())); out->print_cr(" Attributes"); - out->print_cr(" length : "SIZE_FORMAT_W(14), length()); - out->print_cr(" region num : "SIZE_FORMAT_W(14), region_num()); + out->print_cr(" length : %14u", length()); + out->print_cr(" region num : %14u", region_num()); out->print_cr(" total capacity : "SIZE_FORMAT_W(14)" bytes", total_capacity_bytes()); out->print_cr(" total used : "SIZE_FORMAT_W(14)" bytes", @@ -243,14 +239,12 @@ if (proxy_set->is_empty()) return; assert(proxy_set->length() <= _length, - hrs_err_msg("[%s] proxy set length: "SIZE_FORMAT" " - "should be <= length: "SIZE_FORMAT, + hrs_err_msg("[%s] proxy set length: %u should be <= length: %u", name(), proxy_set->length(), _length)); _length -= proxy_set->length(); assert(proxy_set->region_num() <= _region_num, - hrs_err_msg("[%s] proxy set region num: "SIZE_FORMAT" " - "should be <= region num: "SIZE_FORMAT, + hrs_err_msg("[%s] proxy set region num: %u should be <= region num: %u", name(), proxy_set->region_num(), _region_num)); _region_num -= proxy_set->region_num(); @@ -369,17 +363,17 @@ verify_optional(); } -void HeapRegionLinkedList::remove_all_pending(size_t target_count) { +void HeapRegionLinkedList::remove_all_pending(uint target_count) { hrs_assert_mt_safety_ok(this); assert(target_count > 1, hrs_ext_msg(this, "pre-condition")); assert(!is_empty(), hrs_ext_msg(this, "pre-condition")); verify_optional(); - DEBUG_ONLY(size_t old_length = length();) + DEBUG_ONLY(uint old_length = length();) HeapRegion* curr = _head; HeapRegion* prev = NULL; - size_t count = 0; + uint count = 0; while (curr != NULL) { hrs_assert_region_ok(this, curr, this); HeapRegion* next = curr->next(); @@ -387,7 +381,7 @@ if (curr->pending_removal()) { assert(count < target_count, hrs_err_msg("[%s] should not come across more regions " - "pending for removal than target_count: "SIZE_FORMAT, + "pending for removal than target_count: %u", name(), target_count)); if (prev == NULL) { @@ -422,12 +416,11 @@ } assert(count == target_count, - hrs_err_msg("[%s] count: "SIZE_FORMAT" should be == " - "target_count: "SIZE_FORMAT, name(), count, target_count)); + hrs_err_msg("[%s] count: %u should be == target_count: %u", + name(), count, target_count)); assert(length() + target_count == old_length, hrs_err_msg("[%s] new length should be consistent " - "new length: "SIZE_FORMAT" old length: "SIZE_FORMAT" " - "target_count: "SIZE_FORMAT, + "new length: %u old length: %u target_count: %u", name(), length(), old_length, target_count)); verify_optional(); @@ -444,16 +437,16 @@ HeapRegion* curr = _head; HeapRegion* prev1 = NULL; HeapRegion* prev0 = NULL; - size_t count = 0; + uint count = 0; while (curr != NULL) { verify_next_region(curr); count += 1; guarantee(count < _unrealistically_long_length, - hrs_err_msg("[%s] the calculated length: "SIZE_FORMAT" " + hrs_err_msg("[%s] the calculated length: %u " "seems very long, is there maybe a cycle? " "curr: "PTR_FORMAT" prev0: "PTR_FORMAT" " - "prev1: "PTR_FORMAT" length: "SIZE_FORMAT, + "prev1: "PTR_FORMAT" length: %u", name(), count, curr, prev0, prev1, length())); prev1 = prev0;
--- a/src/share/vm/gc_implementation/g1/heapRegionSet.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionSet.hpp Tue May 08 11:29:21 2012 -0700 @@ -62,20 +62,20 @@ friend class VMStructs; protected: - static size_t calculate_region_num(HeapRegion* hr); + static uint calculate_region_num(HeapRegion* hr); - static size_t _unrealistically_long_length; + static uint _unrealistically_long_length; // The number of regions added to the set. If the set contains // only humongous regions, this reflects only 'starts humongous' // regions and does not include 'continues humongous' ones. - size_t _length; + uint _length; // The total number of regions represented by the set. If the set // does not contain humongous regions, this should be the same as // _length. If the set contains only humongous regions, this will // include the 'continues humongous' regions. - size_t _region_num; + uint _region_num; // We don't keep track of the total capacity explicitly, we instead // recalculate it based on _region_num and the heap region size. @@ -86,8 +86,8 @@ const char* _name; bool _verify_in_progress; - size_t _calc_length; - size_t _calc_region_num; + uint _calc_length; + uint _calc_region_num; size_t _calc_total_capacity_bytes; size_t _calc_total_used_bytes; @@ -153,18 +153,18 @@ HeapRegionSetBase(const char* name); public: - static void set_unrealistically_long_length(size_t len); + static void set_unrealistically_long_length(uint len); const char* name() { return _name; } - size_t length() { return _length; } + uint length() { return _length; } bool is_empty() { return _length == 0; } - size_t region_num() { return _region_num; } + uint region_num() { return _region_num; } size_t total_capacity_bytes() { - return region_num() << HeapRegion::LogOfHRGrainBytes; + return (size_t) region_num() << HeapRegion::LogOfHRGrainBytes; } size_t total_used_bytes() { return _total_used_bytes; } @@ -341,7 +341,7 @@ // of regions that are pending for removal in the list, and // target_count should be > 1 (currently, we never need to remove a // single region using this). - void remove_all_pending(size_t target_count); + void remove_all_pending(uint target_count); virtual void verify();
--- a/src/share/vm/gc_implementation/g1/heapRegionSet.inline.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/heapRegionSet.inline.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -54,15 +54,15 @@ assert(_length > 0, hrs_ext_msg(this, "pre-condition")); _length -= 1; - size_t region_num_diff; + uint region_num_diff; if (!hr->isHumongous()) { region_num_diff = 1; } else { region_num_diff = calculate_region_num(hr); } assert(region_num_diff <= _region_num, - hrs_err_msg("[%s] region's region num: "SIZE_FORMAT" " - "should be <= region num: "SIZE_FORMAT, + hrs_err_msg("[%s] region's region num: %u " + "should be <= region num: %u", name(), region_num_diff, _region_num)); _region_num -= region_num_diff;
--- a/src/share/vm/gc_implementation/g1/sparsePRT.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/sparsePRT.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -481,8 +481,7 @@ bool SparsePRT::add_card(RegionIdx_t region_id, CardIdx_t card_index) { #if SPARSE_PRT_VERBOSE - gclog_or_tty->print_cr(" Adding card %d from region %d to region " - SIZE_FORMAT" sparse.", + gclog_or_tty->print_cr(" Adding card %d from region %d to region %u sparse.", card_index, region_id, _hr->hrs_index()); #endif if (_next->occupied_entries() * 2 > _next->capacity()) { @@ -534,7 +533,7 @@ _next = new RSHashTable(last->capacity() * 2); #if SPARSE_PRT_VERBOSE - gclog_or_tty->print_cr(" Expanded sparse table for "SIZE_FORMAT" to %d.", + gclog_or_tty->print_cr(" Expanded sparse table for %u to %d.", _hr->hrs_index(), _next->capacity()); #endif for (size_t i = 0; i < last->capacity(); i++) {
--- a/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp Tue May 08 11:29:21 2012 -0700 @@ -34,7 +34,7 @@ static_field(HeapRegion, GrainBytes, size_t) \ \ nonstatic_field(HeapRegionSeq, _regions, HeapRegion**) \ - nonstatic_field(HeapRegionSeq, _length, size_t) \ + nonstatic_field(HeapRegionSeq, _length, uint) \ \ nonstatic_field(G1CollectedHeap, _hrs, HeapRegionSeq) \ nonstatic_field(G1CollectedHeap, _g1_committed, MemRegion) \ @@ -50,8 +50,8 @@ nonstatic_field(G1MonitoringSupport, _old_committed, size_t) \ nonstatic_field(G1MonitoringSupport, _old_used, size_t) \ \ - nonstatic_field(HeapRegionSetBase, _length, size_t) \ - nonstatic_field(HeapRegionSetBase, _region_num, size_t) \ + nonstatic_field(HeapRegionSetBase, _length, uint) \ + nonstatic_field(HeapRegionSetBase, _region_num, uint) \ nonstatic_field(HeapRegionSetBase, _total_used_bytes, size_t) \
--- a/src/share/vm/gc_implementation/g1/vm_operations_g1.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/g1/vm_operations_g1.cpp Tue May 08 11:29:21 2012 -0700 @@ -26,6 +26,7 @@ #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1CollectorPolicy.hpp" +#include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/vm_operations_g1.hpp" #include "gc_implementation/shared/isGCActiveMark.hpp" #include "gc_implementation/g1/vm_operations_g1.hpp" @@ -223,9 +224,9 @@ } void VM_CGC_Operation::doit() { - gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - TraceTime t(_printGCMessage, PrintGC, true, gclog_or_tty); + gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); + TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); + TraceTime t(_printGCMessage, G1Log::fine(), true, gclog_or_tty); SharedHeap* sh = SharedHeap::heap(); // This could go away if CollectedHeap gave access to _gc_is_active... if (sh != NULL) {
--- a/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Tue May 08 11:29:21 2012 -0700 @@ -42,7 +42,7 @@ protected: template <class T> void do_oop_work(T* p) { - oop obj = oopDesc::load_decode_heap_oop_not_null(p); + oop obj = oopDesc::load_decode_heap_oop(p); if (_young_gen->is_in_reserved(obj) && !_card_table->addr_is_marked_imprecise(p)) { // Don't overwrite the first missing card mark
--- a/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Tue May 08 11:29:21 2012 -0700 @@ -911,23 +911,23 @@ } -void ParallelScavengeHeap::verify(bool allow_dirty, bool silent, VerifyOption option /* ignored */) { +void ParallelScavengeHeap::verify(bool silent, VerifyOption option /* ignored */) { // Why do we need the total_collections()-filter below? if (total_collections() > 0) { if (!silent) { gclog_or_tty->print("permanent "); } - perm_gen()->verify(allow_dirty); + perm_gen()->verify(); if (!silent) { gclog_or_tty->print("tenured "); } - old_gen()->verify(allow_dirty); + old_gen()->verify(); if (!silent) { gclog_or_tty->print("eden "); } - young_gen()->verify(allow_dirty); + young_gen()->verify(); } }
--- a/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp Tue May 08 11:29:21 2012 -0700 @@ -257,7 +257,7 @@ virtual void gc_threads_do(ThreadClosure* tc) const; virtual void print_tracing_info() const; - void verify(bool allow_dirty, bool silent, VerifyOption option /* ignored */); + void verify(bool silent, VerifyOption option /* ignored */); void print_heap_change(size_t prev_used);
--- a/src/share/vm/gc_implementation/parallelScavenge/psOldGen.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/psOldGen.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -477,8 +477,8 @@ } #endif -void PSOldGen::verify(bool allow_dirty) { - object_space()->verify(allow_dirty); +void PSOldGen::verify() { + object_space()->verify(); } class VerifyObjectStartArrayClosure : public ObjectClosure { PSOldGen* _gen;
--- a/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -174,7 +174,7 @@ virtual void print_on(outputStream* st) const; void print_used_change(size_t prev_used) const; - void verify(bool allow_dirty); + void verify(); void verify_object_start_array(); // These should not used
--- a/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -937,10 +937,10 @@ } } -void PSYoungGen::verify(bool allow_dirty) { - eden_space()->verify(allow_dirty); - from_space()->verify(allow_dirty); - to_space()->verify(allow_dirty); +void PSYoungGen::verify() { + eden_space()->verify(); + from_space()->verify(); + to_space()->verify(); } #ifndef PRODUCT
--- a/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -181,7 +181,7 @@ void print_used_change(size_t prev_used) const; virtual const char* name() const { return "PSYoungGen"; } - void verify(bool allow_dirty); + void verify(); // Space boundary invariant checker void space_invariants() PRODUCT_RETURN;
--- a/src/share/vm/gc_implementation/shared/immutableSpace.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/immutableSpace.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -70,7 +70,7 @@ #endif -void ImmutableSpace::verify(bool allow_dirty) { +void ImmutableSpace::verify() { HeapWord* p = bottom(); HeapWord* t = end(); HeapWord* prev_p = NULL;
--- a/src/share/vm/gc_implementation/shared/immutableSpace.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/immutableSpace.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -65,7 +65,7 @@ // Debugging virtual void print() const PRODUCT_RETURN; virtual void print_short() const PRODUCT_RETURN; - virtual void verify(bool allow_dirty); + virtual void verify(); }; #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_IMMUTABLESPACE_HPP
--- a/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Tue May 08 11:29:21 2012 -0700 @@ -891,12 +891,12 @@ } } -void MutableNUMASpace::verify(bool allow_dirty) { +void MutableNUMASpace::verify() { // This can be called after setting an arbitary value to the space's top, // so an object can cross the chunk boundary. We ensure the parsablity // of the space and just walk the objects in linear fashion. ensure_parsability(); - MutableSpace::verify(allow_dirty); + MutableSpace::verify(); } // Scan pages and gather stats about page placement and size.
--- a/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -225,7 +225,7 @@ // Debugging virtual void print_on(outputStream* st) const; virtual void print_short_on(outputStream* st) const; - virtual void verify(bool allow_dirty); + virtual void verify(); virtual void set_top(HeapWord* value); };
--- a/src/share/vm/gc_implementation/shared/mutableSpace.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/mutableSpace.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -246,7 +246,7 @@ bottom(), top(), end()); } -void MutableSpace::verify(bool allow_dirty) { +void MutableSpace::verify() { HeapWord* p = bottom(); HeapWord* t = top(); HeapWord* prev_p = NULL;
--- a/src/share/vm/gc_implementation/shared/mutableSpace.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/mutableSpace.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -141,7 +141,7 @@ virtual void print_on(outputStream* st) const; virtual void print_short() const; virtual void print_short_on(outputStream* st) const; - virtual void verify(bool allow_dirty); + virtual void verify(); }; #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_MUTABLESPACE_HPP
--- a/src/share/vm/gc_interface/collectedHeap.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/gc_interface/collectedHeap.hpp Tue May 08 11:29:21 2012 -0700 @@ -659,7 +659,7 @@ } // Heap verification - virtual void verify(bool allow_dirty, bool silent, VerifyOption option) = 0; + virtual void verify(bool silent, VerifyOption option) = 0; // Non product verification and debugging. #ifndef PRODUCT
--- a/src/share/vm/memory/barrierSet.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/barrierSet.hpp Tue May 08 11:29:21 2012 -0700 @@ -181,6 +181,8 @@ // within the heap, this function tells whether they are met. virtual bool is_aligned(HeapWord* addr) = 0; + // Print a description of the memory for the barrier set + virtual void print_on(outputStream* st) const = 0; }; #endif // SHARE_VM_MEMORY_BARRIERSET_HPP
--- a/src/share/vm/memory/cardTableModRefBS.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/cardTableModRefBS.cpp Tue May 08 11:29:21 2012 -0700 @@ -711,6 +711,11 @@ } #endif +void CardTableModRefBS::print_on(outputStream* st) const { + st->print_cr("Card table byte_map: [" INTPTR_FORMAT "," INTPTR_FORMAT "] byte_map_base: " INTPTR_FORMAT, + _byte_map, _byte_map + _byte_map_size, byte_map_base); +} + bool CardTableModRefBSForCTRS::card_will_be_scanned(jbyte cv) { return CardTableModRefBS::card_will_be_scanned(cv) ||
--- a/src/share/vm/memory/cardTableModRefBS.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/cardTableModRefBS.hpp Tue May 08 11:29:21 2012 -0700 @@ -472,6 +472,9 @@ return _byte_map + card_index; } + // Print a description of the memory for the barrier set + virtual void print_on(outputStream* st) const; + void verify(); void verify_guard();
--- a/src/share/vm/memory/compactingPermGenGen.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/compactingPermGenGen.cpp Tue May 08 11:29:21 2012 -0700 @@ -444,11 +444,11 @@ } -void CompactingPermGenGen::verify(bool allow_dirty) { - the_space()->verify(allow_dirty); +void CompactingPermGenGen::verify() { + the_space()->verify(); if (!SharedSkipVerify && spec()->enable_shared_spaces()) { - ro_space()->verify(allow_dirty); - rw_space()->verify(allow_dirty); + ro_space()->verify(); + rw_space()->verify(); } }
--- a/src/share/vm/memory/compactingPermGenGen.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/compactingPermGenGen.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -230,7 +230,7 @@ void* new_vtable_start, void* obj); - void verify(bool allow_dirty); + void verify(); // Serialization static void initialize_oops() KERNEL_RETURN;
--- a/src/share/vm/memory/defNewGeneration.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/defNewGeneration.cpp Tue May 08 11:29:21 2012 -0700 @@ -939,10 +939,10 @@ } } -void DefNewGeneration::verify(bool allow_dirty) { - eden()->verify(allow_dirty); - from()->verify(allow_dirty); - to()->verify(allow_dirty); +void DefNewGeneration::verify() { + eden()->verify(); + from()->verify(); + to()->verify(); } void DefNewGeneration::print_on(outputStream* st) const {
--- a/src/share/vm/memory/defNewGeneration.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/defNewGeneration.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -340,7 +340,7 @@ // PrintHeapAtGC support. void print_on(outputStream* st) const; - void verify(bool allow_dirty); + void verify(); bool promo_failure_scan_is_complete() const { return _promo_failure_scan_stack.is_empty();
--- a/src/share/vm/memory/dump.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/dump.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1488,12 +1488,11 @@ // sun.io.Converters static const char obj_array_sig[] = "[[Ljava/lang/Object;"; - SymbolTable::lookup(obj_array_sig, (int)strlen(obj_array_sig), THREAD); + (void)SymbolTable::new_permanent_symbol(obj_array_sig, THREAD); // java.util.HashMap static const char map_entry_array_sig[] = "[Ljava/util/Map$Entry;"; - SymbolTable::lookup(map_entry_array_sig, (int)strlen(map_entry_array_sig), - THREAD); + (void)SymbolTable::new_permanent_symbol(map_entry_array_sig, THREAD); tty->print("Loading classes to share ... "); while ((fgets(class_name, sizeof class_name, file)) != NULL) { @@ -1512,7 +1511,7 @@ computed_jsum = jsum(computed_jsum, class_name, (const int)name_len - 1); // Got a class name - load it. - TempNewSymbol class_name_symbol = SymbolTable::new_symbol(class_name, THREAD); + Symbol* class_name_symbol = SymbolTable::new_permanent_symbol(class_name, THREAD); guarantee(!HAS_PENDING_EXCEPTION, "Exception creating a symbol."); klassOop klass = SystemDictionary::resolve_or_null(class_name_symbol, THREAD);
--- a/src/share/vm/memory/genCollectedHeap.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/genCollectedHeap.cpp Tue May 08 11:29:21 2012 -0700 @@ -1247,18 +1247,18 @@ return _gens[level]->gc_stats(); } -void GenCollectedHeap::verify(bool allow_dirty, bool silent, VerifyOption option /* ignored */) { +void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) { if (!silent) { gclog_or_tty->print("permgen "); } - perm_gen()->verify(allow_dirty); + perm_gen()->verify(); for (int i = _n_gens-1; i >= 0; i--) { Generation* g = _gens[i]; if (!silent) { gclog_or_tty->print(g->name()); gclog_or_tty->print(" "); } - g->verify(allow_dirty); + g->verify(); } if (!silent) { gclog_or_tty->print("remset ");
--- a/src/share/vm/memory/genCollectedHeap.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/genCollectedHeap.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -357,7 +357,7 @@ void prepare_for_verify(); // Override. - void verify(bool allow_dirty, bool silent, VerifyOption option); + void verify(bool silent, VerifyOption option); // Override. virtual void print_on(outputStream* st) const;
--- a/src/share/vm/memory/generation.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/generation.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -696,8 +696,8 @@ the_space()->set_top_for_allocations(); } -void OneContigSpaceCardGeneration::verify(bool allow_dirty) { - the_space()->verify(allow_dirty); +void OneContigSpaceCardGeneration::verify() { + the_space()->verify(); } void OneContigSpaceCardGeneration::print_on(outputStream* st) const {
--- a/src/share/vm/memory/generation.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/generation.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -599,7 +599,7 @@ virtual void print() const; virtual void print_on(outputStream* st) const; - virtual void verify(bool allow_dirty) = 0; + virtual void verify() = 0; struct StatRecord { int invocations; @@ -753,7 +753,7 @@ virtual void record_spaces_top(); - virtual void verify(bool allow_dirty); + virtual void verify(); virtual void print_on(outputStream* st) const; };
--- a/src/share/vm/memory/oopFactory.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/oopFactory.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -127,9 +127,12 @@ klassOop oopFactory::new_instanceKlass(Symbol* name, int vtable_len, int itable_len, int static_field_size, unsigned int nonstatic_oop_map_count, + AccessFlags access_flags, ReferenceType rt, TRAPS) { instanceKlassKlass* ikk = instanceKlassKlass::cast(Universe::instanceKlassKlassObj()); - return ikk->allocate_instance_klass(name, vtable_len, itable_len, static_field_size, nonstatic_oop_map_count, rt, CHECK_NULL); + return ikk->allocate_instance_klass(name, vtable_len, itable_len, + static_field_size, nonstatic_oop_map_count, + access_flags, rt, CHECK_NULL); }
--- a/src/share/vm/memory/oopFactory.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/oopFactory.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -77,6 +77,7 @@ int vtable_len, int itable_len, int static_field_size, unsigned int nonstatic_oop_map_count, + AccessFlags access_flags, ReferenceType rt, TRAPS); // Methods
--- a/src/share/vm/memory/space.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/space.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -531,7 +531,7 @@ bottom(), top(), _offsets.threshold(), end()); } -void ContiguousSpace::verify(bool allow_dirty) const { +void ContiguousSpace::verify() const { HeapWord* p = bottom(); HeapWord* t = top(); HeapWord* prev_p = NULL; @@ -965,27 +965,12 @@ initialize(mr, SpaceDecorator::Clear, SpaceDecorator::Mangle); } - -class VerifyOldOopClosure : public OopClosure { - public: - oop _the_obj; - bool _allow_dirty; - void do_oop(oop* p) { - _the_obj->verify_old_oop(p, _allow_dirty); - } - void do_oop(narrowOop* p) { - _the_obj->verify_old_oop(p, _allow_dirty); - } -}; - #define OBJ_SAMPLE_INTERVAL 0 #define BLOCK_SAMPLE_INTERVAL 100 -void OffsetTableContigSpace::verify(bool allow_dirty) const { +void OffsetTableContigSpace::verify() const { HeapWord* p = bottom(); HeapWord* prev_p = NULL; - VerifyOldOopClosure blk; // Does this do anything? - blk._allow_dirty = allow_dirty; int objs = 0; int blocks = 0; @@ -1007,8 +992,6 @@ if (objs == OBJ_SAMPLE_INTERVAL) { oop(p)->verify(); - blk._the_obj = oop(p); - oop(p)->oop_iterate(&blk); objs = 0; } else { objs++;
--- a/src/share/vm/memory/space.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/space.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -306,7 +306,7 @@ } // Debugging - virtual void verify(bool allow_dirty) const = 0; + virtual void verify() const = 0; }; // A MemRegionClosure (ResourceObj) whose "do_MemRegion" function applies an @@ -948,7 +948,7 @@ } // Debugging - virtual void verify(bool allow_dirty) const; + virtual void verify() const; // Used to increase collection frequency. "factor" of 0 means entire // space. @@ -1100,7 +1100,7 @@ virtual void print_on(outputStream* st) const; // Debugging - void verify(bool allow_dirty) const; + void verify() const; // Shared space support void serialize_block_offset_array_offsets(SerializeOopClosure* soc);
--- a/src/share/vm/memory/universe.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/universe.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1326,7 +1326,7 @@ st->print_cr("}"); } -void Universe::verify(bool allow_dirty, bool silent, VerifyOption option) { +void Universe::verify(bool silent, VerifyOption option) { if (SharedSkipVerify) { return; } @@ -1350,7 +1350,7 @@ if (!silent) gclog_or_tty->print("[Verifying "); if (!silent) gclog_or_tty->print("threads "); Threads::verify(); - heap()->verify(allow_dirty, silent, option); + heap()->verify(silent, option); if (!silent) gclog_or_tty->print("syms "); SymbolTable::verify();
--- a/src/share/vm/memory/universe.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/memory/universe.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -412,7 +412,7 @@ // Debugging static bool verify_in_progress() { return _verify_in_progress; } - static void verify(bool allow_dirty = true, bool silent = false, + static void verify(bool silent = false, VerifyOption option = VerifyOption_Default ); static int verify_count() { return _verify_count; } // The default behavior is to call print_on() on gclog_or_tty.
--- a/src/share/vm/oops/instanceKlass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/instanceKlass.cpp Tue May 08 11:29:21 2012 -0700 @@ -567,8 +567,18 @@ ol.notify_all(CHECK); } +// The embedded _implementor field can only record one implementor. +// When there are more than one implementors, the _implementor field +// is set to the interface klassOop itself. Following are the possible +// values for the _implementor field: +// NULL - no implementor +// implementor klassOop - one implementor +// self - more than one implementor +// +// The _implementor field only exists for interfaces. void instanceKlass::add_implementor(klassOop k) { assert(Compile_lock->owned_by_self(), ""); + assert(is_interface(), "not interface"); // Filter out my subinterfaces. // (Note: Interfaces are never on the subklass list.) if (instanceKlass::cast(k)->is_interface()) return; @@ -583,17 +593,13 @@ // Any supers of the super have the same (or fewer) transitive_interfaces. return; - // Update number of implementors - int i = _nof_implementors++; - - // Record this implementor, if there are not too many already - if (i < implementors_limit) { - assert(_implementors[i] == NULL, "should be exactly one implementor"); - oop_store_without_check((oop*)&_implementors[i], k); - } else if (i == implementors_limit) { - // clear out the list on first overflow - for (int i2 = 0; i2 < implementors_limit; i2++) - oop_store_without_check((oop*)&_implementors[i2], NULL); + klassOop ik = implementor(); + if (ik == NULL) { + set_implementor(k); + } else if (ik != this->as_klassOop()) { + // There is already an implementor. Use itself as an indicator of + // more than one implementors. + set_implementor(this->as_klassOop()); } // The implementor also implements the transitive_interfaces @@ -603,9 +609,9 @@ } void instanceKlass::init_implementor() { - for (int i = 0; i < implementors_limit; i++) - oop_store_without_check((oop*)&_implementors[i], NULL); - _nof_implementors = 0; + if (is_interface()) { + set_implementor(NULL); + } } @@ -1849,24 +1855,22 @@ void instanceKlass::follow_weak_klass_links( BoolObjectClosure* is_alive, OopClosure* keep_alive) { assert(is_alive->do_object_b(as_klassOop()), "this oop should be live"); - if (ClassUnloading) { - for (int i = 0; i < implementors_limit; i++) { - klassOop impl = _implementors[i]; - if (impl == NULL) break; // no more in the list - if (!is_alive->do_object_b(impl)) { - // remove this guy from the list by overwriting him with the tail - int lasti = --_nof_implementors; - assert(lasti >= i && lasti < implementors_limit, "just checking"); - _implementors[i] = _implementors[lasti]; - _implementors[lasti] = NULL; - --i; // rerun the loop at this index + + if (is_interface()) { + if (ClassUnloading) { + klassOop impl = implementor(); + if (impl != NULL) { + if (!is_alive->do_object_b(impl)) { + // remove this guy + *start_of_implementor() = NULL; + } } - } - } else { - for (int i = 0; i < implementors_limit; i++) { - keep_alive->do_oop(&adr_implementors()[i]); + } else { + assert(adr_implementor() != NULL, "just checking"); + keep_alive->do_oop(adr_implementor()); } } + Klass::follow_weak_klass_links(is_alive, keep_alive); }
--- a/src/share/vm/oops/instanceKlass.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/instanceKlass.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -56,8 +56,6 @@ // [methods ] // [local interfaces ] // [transitive interfaces ] -// [number of implementors ] -// [implementors ] klassOop[2] // [fields ] // [constants ] // [class loader ] @@ -77,9 +75,9 @@ // [oop map cache (stack maps) ] // [EMBEDDED Java vtable ] size in words = vtable_len // [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size -// -// The embedded nonstatic oop-map blocks are short pairs (offset, length) indicating -// where oops are located in instances of this klass. +// The embedded nonstatic oop-map blocks are short pairs (offset, length) +// indicating where oops are located in instances of this klass. +// [EMBEDDED implementor of the interface] only exist for interface // forward declaration for class -- see below for definition @@ -153,10 +151,6 @@ oop* oop_block_beg() const { return adr_array_klasses(); } oop* oop_block_end() const { return adr_methods_default_annotations() + 1; } - enum { - implementors_limit = 2 // how many implems can we track? - }; - protected: // // The oop block. See comment in klass.hpp before making changes. @@ -200,8 +194,6 @@ // and EnclosingMethod attributes the _inner_classes array length is // number_of_inner_classes * 4 + enclosing_method_attribute_size. typeArrayOop _inner_classes; - // Implementors of this interface (not valid if it overflows) - klassOop _implementors[implementors_limit]; // Annotations for this class, or null if none. typeArrayOop _class_annotations; // Annotation objects (byte arrays) for fields, or null if no annotations. @@ -257,7 +249,6 @@ nmethodBucket* _dependencies; // list of dependent nmethods nmethod* _osr_nmethods_head; // Head of list of on-stack replacement nmethods for this class BreakpointInfo* _breakpoints; // bpt lists, managed by methodOop - int _nof_implementors; // No of implementors of this interface (zero if not an interface) // Array of interesting part(s) of the previous version(s) of this // instanceKlass. See PreviousVersionWalker below. GrowableArray<PreviousVersionNode *>* _previous_versions; @@ -278,6 +269,13 @@ // embedded Java itables follows here // embedded static fields follows here // embedded nonstatic oop-map blocks follows here + // embedded implementor of this interface follows here + // The embedded implementor only exists if the current klass is an + // iterface. The possible values of the implementor fall into following + // three cases: + // NULL: no implementor. + // A klassOop that's not itself: one implementor. + // Itsef: more than one implementors. friend class instanceKlassKlass; friend class SystemDictionary; @@ -644,19 +642,40 @@ // support for stub routines static ByteSize init_state_offset() { return in_ByteSize(sizeof(klassOopDesc) + offset_of(instanceKlass, _init_state)); } + TRACE_DEFINE_OFFSET; static ByteSize init_thread_offset() { return in_ByteSize(sizeof(klassOopDesc) + offset_of(instanceKlass, _init_thread)); } // subclass/subinterface checks bool implements_interface(klassOop k) const; - // Access to implementors of an interface. We only store the count - // of implementors, and in case, there are only a few - // implementors, we store them in a short list. - // This accessor returns NULL if we walk off the end of the list. - klassOop implementor(int i) const { - return (i < implementors_limit)? _implementors[i]: (klassOop) NULL; + // Access to the implementor of an interface. + klassOop implementor() const + { + klassOop* k = start_of_implementor(); + if (k == NULL) { + return NULL; + } else { + return *k; + } } - int nof_implementors() const { return _nof_implementors; } + + void set_implementor(klassOop k) { + assert(is_interface(), "not interface"); + oop* addr = (oop*)start_of_implementor(); + oop_store_without_check(addr, k); + } + + int nof_implementors() const { + klassOop k = implementor(); + if (k == NULL) { + return 0; + } else if (k != this->as_klassOop()) { + return 1; + } else { + return 2; + } + } + void add_implementor(klassOop k); // k is a new class that implements this interface void init_implementor(); // initialize @@ -693,7 +712,15 @@ // Sizing (in words) static int header_size() { return align_object_offset(oopDesc::header_size() + sizeof(instanceKlass)/HeapWordSize); } - int object_size() const { return object_size(align_object_offset(vtable_length()) + align_object_offset(itable_length()) + nonstatic_oop_map_size()); } + + int object_size() const + { + return object_size(align_object_offset(vtable_length()) + + align_object_offset(itable_length()) + + (is_interface() ? + (align_object_offset(nonstatic_oop_map_size()) + (int)sizeof(klassOop)/HeapWordSize) : + nonstatic_oop_map_size())); + } static int vtable_start_offset() { return header_size(); } static int vtable_length_offset() { return oopDesc::header_size() + offset_of(instanceKlass, _vtable_len) / HeapWordSize; } static int object_size(int extra) { return align_object_size(header_size() + extra); } @@ -710,6 +737,15 @@ return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length())); } + klassOop* start_of_implementor() const { + if (is_interface()) { + return (klassOop*)(start_of_nonstatic_oop_maps() + + nonstatic_oop_map_count()); + } else { + return NULL; + } + }; + // Allocation profiling support juint alloc_size() const { return _alloc_count * size_helper(); } void set_alloc_size(juint n) {} @@ -819,7 +855,7 @@ oop* adr_host_klass() const { return (oop*)&this->_host_klass;} oop* adr_signers() const { return (oop*)&this->_signers;} oop* adr_inner_classes() const { return (oop*)&this->_inner_classes;} - oop* adr_implementors() const { return (oop*)&this->_implementors[0];} + oop* adr_implementor() const { return (oop*)start_of_implementor(); } oop* adr_methods_jmethod_ids() const { return (oop*)&this->_methods_jmethod_ids;} oop* adr_methods_cached_itable_indices() const { return (oop*)&this->_methods_cached_itable_indices;} oop* adr_class_annotations() const { return (oop*)&this->_class_annotations;}
--- a/src/share/vm/oops/instanceKlassKlass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/instanceKlassKlass.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -111,7 +111,7 @@ MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations()); MarkSweep::mark_and_push(ik->adr_methods_default_annotations()); - // We do not follow adr_implementors() here. It is followed later + // We do not follow adr_implementor() here. It is followed later // in instanceKlass::follow_weak_klass_links() klassKlass::oop_follow_contents(obj); @@ -180,8 +180,8 @@ blk->do_oop(ik->adr_host_klass()); blk->do_oop(ik->adr_signers()); blk->do_oop(ik->adr_inner_classes()); - for (int i = 0; i < instanceKlass::implementors_limit; i++) { - blk->do_oop(&ik->adr_implementors()[i]); + if (ik->is_interface()) { + blk->do_oop(ik->adr_implementor()); } blk->do_oop(ik->adr_class_annotations()); blk->do_oop(ik->adr_fields_annotations()); @@ -232,9 +232,9 @@ if (mr.contains(adr)) blk->do_oop(adr); adr = ik->adr_inner_classes(); if (mr.contains(adr)) blk->do_oop(adr); - adr = ik->adr_implementors(); - for (int i = 0; i < instanceKlass::implementors_limit; i++) { - if (mr.contains(&adr[i])) blk->do_oop(&adr[i]); + if (ik->is_interface()) { + adr = ik->adr_implementor(); + if (mr.contains(adr)) blk->do_oop(adr); } adr = ik->adr_class_annotations(); if (mr.contains(adr)) blk->do_oop(adr); @@ -273,8 +273,8 @@ MarkSweep::adjust_pointer(ik->adr_host_klass()); MarkSweep::adjust_pointer(ik->adr_signers()); MarkSweep::adjust_pointer(ik->adr_inner_classes()); - for (int i = 0; i < instanceKlass::implementors_limit; i++) { - MarkSweep::adjust_pointer(&ik->adr_implementors()[i]); + if (ik->is_interface()) { + MarkSweep::adjust_pointer(ik->adr_implementor()); } MarkSweep::adjust_pointer(ik->adr_class_annotations()); MarkSweep::adjust_pointer(ik->adr_fields_annotations()); @@ -328,6 +328,9 @@ for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { PSParallelCompact::adjust_pointer(cur_oop); } + if (ik->is_interface()) { + PSParallelCompact::adjust_pointer(ik->adr_implementor()); + } OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure(); iterate_c_heap_oops(ik, closure); @@ -342,11 +345,18 @@ instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int itable_len, int static_field_size, unsigned nonstatic_oop_map_count, + AccessFlags access_flags, ReferenceType rt, TRAPS) { const int nonstatic_oop_map_size = instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count); - int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + nonstatic_oop_map_size); + int size = align_object_offset(vtable_len) + align_object_offset(itable_len); + if (access_flags.is_interface()) { + size += align_object_offset(nonstatic_oop_map_size) + (int)sizeof(klassOop)/HeapWordSize; + } else { + size += nonstatic_oop_map_size; + } + size = instanceKlass::object_size(size); // Allocation KlassHandle h_this_klass(THREAD, as_klassOop()); @@ -378,6 +388,7 @@ ik->set_itable_length(itable_len); ik->set_static_field_size(static_field_size); ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size); + ik->set_access_flags(access_flags); assert(k()->size() == size, "wrong size for object"); ik->set_array_klasses(NULL); @@ -470,16 +481,12 @@ if (ik->is_interface()) { st->print_cr(BULLET"nof implementors: %d", ik->nof_implementors()); - int print_impl = 0; - for (int i = 0; i < instanceKlass::implementors_limit; i++) { - if (ik->implementor(i) != NULL) { - if (++print_impl == 1) - st->print_cr(BULLET"implementor: "); - st->print(" "); - ik->implementor(i)->print_value_on(st); - } + if (ik->nof_implementors() == 1) { + st->print_cr(BULLET"implementor: "); + st->print(" "); + ik->implementor()->print_value_on(st); + st->cr(); } - if (print_impl > 0) st->cr(); } st->print(BULLET"arrays: "); ik->array_klasses()->print_value_on(st); st->cr(); @@ -640,16 +647,12 @@ } // Verify implementor fields - bool saw_null_impl = false; - for (int i = 0; i < instanceKlass::implementors_limit; i++) { - klassOop im = ik->implementor(i); - if (im == NULL) { saw_null_impl = true; continue; } - guarantee(!saw_null_impl, "non-nulls must preceded all nulls"); + klassOop im = ik->implementor(); + if (im != NULL) { guarantee(ik->is_interface(), "only interfaces should have implementor set"); - guarantee(i < ik->nof_implementors(), "should only have one implementor"); guarantee(im->is_perm(), "should be in permspace"); guarantee(im->is_klass(), "should be klass"); - guarantee(!Klass::cast(klassOop(im))->is_interface(), "implementors cannot be interfaces"); + guarantee(!Klass::cast(klassOop(im))->is_interface() || im == ik->as_klassOop(), "implementors cannot be interfaces"); } // Verify local interfaces
--- a/src/share/vm/oops/instanceKlassKlass.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/instanceKlassKlass.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -46,6 +46,7 @@ int itable_len, int static_field_size, unsigned int nonstatic_oop_map_count, + AccessFlags access_flags, ReferenceType rt, TRAPS);
--- a/src/share/vm/oops/instanceRefKlass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/instanceRefKlass.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -497,36 +497,12 @@ if (referent != NULL) { guarantee(referent->is_oop(), "referent field heap failed"); - if (gch != NULL && !gch->is_in_young(obj)) { - // We do a specific remembered set check here since the referent - // field is not part of the oop mask and therefore skipped by the - // regular verify code. - if (UseCompressedOops) { - narrowOop* referent_addr = (narrowOop*)java_lang_ref_Reference::referent_addr(obj); - obj->verify_old_oop(referent_addr, true); - } else { - oop* referent_addr = (oop*)java_lang_ref_Reference::referent_addr(obj); - obj->verify_old_oop(referent_addr, true); - } - } } // Verify next field oop next = java_lang_ref_Reference::next(obj); if (next != NULL) { guarantee(next->is_oop(), "next field verify failed"); guarantee(next->is_instanceRef(), "next field verify failed"); - if (gch != NULL && !gch->is_in_young(obj)) { - // We do a specific remembered set check here since the next field is - // not part of the oop mask and therefore skipped by the regular - // verify code. - if (UseCompressedOops) { - narrowOop* next_addr = (narrowOop*)java_lang_ref_Reference::next_addr(obj); - obj->verify_old_oop(next_addr, true); - } else { - oop* next_addr = (oop*)java_lang_ref_Reference::next_addr(obj); - obj->verify_old_oop(next_addr, true); - } - } } }
--- a/src/share/vm/oops/klass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/klass.cpp Tue May 08 11:29:21 2012 -0700 @@ -581,14 +581,6 @@ guarantee(obj->klass()->is_klass(), "klass field is not a klass"); } - -void Klass::oop_verify_old_oop(oop obj, oop* p, bool allow_dirty) { - /* $$$ I think this functionality should be handled by verification of - RememberedSet::verify_old_oop(obj, p, allow_dirty, false); - the card table. */ -} -void Klass::oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty) { } - #ifndef PRODUCT void Klass::verify_vtable_index(int i) {
--- a/src/share/vm/oops/klass.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/klass.hpp Tue May 08 11:29:21 2012 -0700 @@ -805,8 +805,6 @@ // Verification virtual const char* internal_name() const = 0; virtual void oop_verify_on(oop obj, outputStream* st); - virtual void oop_verify_old_oop(oop obj, oop* p, bool allow_dirty); - virtual void oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty); // tells whether obj is partially constructed (gc during class loading) virtual bool oop_partially_loaded(oop obj) const { return false; } virtual void oop_set_partially_loaded(oop obj) {};
--- a/src/share/vm/oops/objArrayKlass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/objArrayKlass.cpp Tue May 08 11:29:21 2012 -0700 @@ -545,10 +545,3 @@ guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop"); } } - -void objArrayKlass::oop_verify_old_oop(oop obj, oop* p, bool allow_dirty) { - /* $$$ move into remembered set verification? - RememberedSet::verify_old_oop(obj, p, allow_dirty, true); - */ -} -void objArrayKlass::oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty) {}
--- a/src/share/vm/oops/objArrayKlass.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/objArrayKlass.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -144,8 +144,6 @@ // Verification const char* internal_name() const; void oop_verify_on(oop obj, outputStream* st); - void oop_verify_old_oop(oop obj, oop* p, bool allow_dirty); - void oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty); }; #endif // SHARE_VM_OOPS_OBJARRAYKLASS_HPP
--- a/src/share/vm/oops/objArrayKlassKlass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/objArrayKlassKlass.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -137,7 +137,7 @@ new_str[idx++] = ';'; } new_str[idx++] = '\0'; - name = SymbolTable::new_symbol(new_str, CHECK_0); + name = SymbolTable::new_permanent_symbol(new_str, CHECK_0); if (element_klass->oop_is_instance()) { instanceKlass* ik = instanceKlass::cast(element_klass()); ik->set_array_name(name);
--- a/src/share/vm/oops/oop.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/oop.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -107,16 +107,6 @@ verify_on(tty); } - -// XXX verify_old_oop doesn't do anything (should we remove?) -void oopDesc::verify_old_oop(oop* p, bool allow_dirty) { - blueprint()->oop_verify_old_oop(this, p, allow_dirty); -} - -void oopDesc::verify_old_oop(narrowOop* p, bool allow_dirty) { - blueprint()->oop_verify_old_oop(this, p, allow_dirty); -} - bool oopDesc::partially_loaded() { return blueprint()->oop_partially_loaded(this); }
--- a/src/share/vm/oops/oop.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/oop.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -293,8 +293,6 @@ // verification operations void verify_on(outputStream* st); void verify(); - void verify_old_oop(oop* p, bool allow_dirty); - void verify_old_oop(narrowOop* p, bool allow_dirty); // tells whether this oop is partially constructed (gc during class loading) bool partially_loaded();
--- a/src/share/vm/oops/symbol.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/symbol.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -29,15 +29,25 @@ #include "runtime/os.hpp" #include "memory/allocation.inline.hpp" -Symbol::Symbol(const u1* name, int length) : _refcount(0), _length(length) { +Symbol::Symbol(const u1* name, int length, int refcount) : _refcount(refcount), _length(length) { _identity_hash = os::random(); for (int i = 0; i < _length; i++) { byte_at_put(i, name[i]); } } -void* Symbol::operator new(size_t size, int len) { - return (void *) AllocateHeap(object_size(len) * HeapWordSize, "symbol"); +void* Symbol::operator new(size_t sz, int len, TRAPS) { + int alloc_size = object_size(len)*HeapWordSize; + address res = (address) AllocateHeap(alloc_size, "symbol"); + DEBUG_ONLY(set_allocation_type(res, ResourceObj::C_HEAP);) + return res; +} + +void* Symbol::operator new(size_t sz, int len, Arena* arena, TRAPS) { + int alloc_size = object_size(len)*HeapWordSize; + address res = (address)arena->Amalloc(alloc_size); + DEBUG_ONLY(set_allocation_type(res, ResourceObj::ARENA);) + return res; } // ------------------------------------------------------------------ @@ -206,26 +216,5 @@ } } -void Symbol::increment_refcount() { - // Only increment the refcount if positive. If negative either - // overflow has occurred or it is a permanent symbol in a read only - // shared archive. - if (_refcount >= 0) { - Atomic::inc(&_refcount); - NOT_PRODUCT(Atomic::inc(&_total_count);) - } -} - -void Symbol::decrement_refcount() { - if (_refcount >= 0) { - Atomic::dec(&_refcount); -#ifdef ASSERT - if (_refcount < 0) { - print(); - assert(false, "reference count underflow for symbol"); - } -#endif - } -} - +// SymbolTable prints this in its statistics NOT_PRODUCT(int Symbol::_total_count = 0;)
--- a/src/share/vm/oops/symbol.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/symbol.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,6 +27,7 @@ #include "utilities/utf8.hpp" #include "memory/allocation.hpp" +#include "runtime/atomic.hpp" // A Symbol is a canonicalized string. // All Symbols reside in global SymbolTable and are reference counted. @@ -95,7 +96,7 @@ // TempNewSymbol (passed in as a parameter) so the reference count on its symbol // will be decremented when it goes out of scope. -class Symbol : public CHeapObj { +class Symbol : public ResourceObj { friend class VMStructs; friend class SymbolTable; friend class MoveSymbols; @@ -111,7 +112,7 @@ }; static int object_size(int length) { - size_t size = heap_word_size(sizeof(Symbol) + length); + size_t size = heap_word_size(sizeof(Symbol) + (length > 0 ? length - 1 : 0)); return align_object_size(size); } @@ -120,28 +121,25 @@ _body[index] = value; } - Symbol(const u1* name, int length); - void* operator new(size_t size, int len); + Symbol(const u1* name, int length, int refcount); + void* operator new(size_t size, int len, TRAPS); + void* operator new(size_t size, int len, Arena* arena, TRAPS); public: // Low-level access (used with care, since not GC-safe) const jbyte* base() const { return &_body[0]; } - int object_size() { return object_size(utf8_length()); } + int object_size() { return object_size(utf8_length()); } // Returns the largest size symbol we can safely hold. - static int max_length() { - return max_symbol_length; - } + static int max_length() { return max_symbol_length; } - int identity_hash() { - return _identity_hash; - } + int identity_hash() { return _identity_hash; } // Reference counting. See comments above this class for when to use. - int refcount() const { return _refcount; } - void increment_refcount(); - void decrement_refcount(); + int refcount() const { return _refcount; } + inline void increment_refcount(); + inline void decrement_refcount(); int byte_at(int index) const { assert(index >=0 && index < _length, "symbol index overflow"); @@ -220,4 +218,26 @@ return (((uintptr_t)this < (uintptr_t)other) ? -1 : ((uintptr_t)this == (uintptr_t) other) ? 0 : 1); } + +inline void Symbol::increment_refcount() { + // Only increment the refcount if positive. If negative either + // overflow has occurred or it is a permanent symbol in a read only + // shared archive. + if (_refcount >= 0) { + Atomic::inc(&_refcount); + NOT_PRODUCT(Atomic::inc(&_total_count);) + } +} + +inline void Symbol::decrement_refcount() { + if (_refcount >= 0) { + Atomic::dec(&_refcount); +#ifdef ASSERT + if (_refcount < 0) { + print(); + assert(false, "reference count underflow for symbol"); + } +#endif + } +} #endif // SHARE_VM_OOPS_SYMBOL_HPP
--- a/src/share/vm/oops/typeArrayKlass.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/oops/typeArrayKlass.cpp Tue May 08 11:29:21 2012 -0700 @@ -55,7 +55,7 @@ Symbol* sym = NULL; if (name_str != NULL) { - sym = SymbolTable::new_symbol(name_str, CHECK_NULL); + sym = SymbolTable::new_permanent_symbol(name_str, CHECK_NULL); } KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj());
--- a/src/share/vm/opto/library_call.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/opto/library_call.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -175,7 +175,11 @@ bool inline_unsafe_allocate(); bool inline_unsafe_copyMemory(); bool inline_native_currentThread(); - bool inline_native_time_funcs(bool isNano); +#ifdef TRACE_HAVE_INTRINSICS + bool inline_native_classID(); + bool inline_native_threadID(); +#endif + bool inline_native_time_funcs(address method, const char* funcName); bool inline_native_isInterrupted(); bool inline_native_Class_query(vmIntrinsics::ID id); bool inline_native_subtype_check(); @@ -638,10 +642,18 @@ case vmIntrinsics::_isInterrupted: return inline_native_isInterrupted(); +#ifdef TRACE_HAVE_INTRINSICS + case vmIntrinsics::_classID: + return inline_native_classID(); + case vmIntrinsics::_threadID: + return inline_native_threadID(); + case vmIntrinsics::_counterTime: + return inline_native_time_funcs(CAST_FROM_FN_PTR(address, TRACE_TIME_METHOD), "counterTime"); +#endif case vmIntrinsics::_currentTimeMillis: - return inline_native_time_funcs(false); + return inline_native_time_funcs(CAST_FROM_FN_PTR(address, os::javaTimeMillis), "currentTimeMillis"); case vmIntrinsics::_nanoTime: - return inline_native_time_funcs(true); + return inline_native_time_funcs(CAST_FROM_FN_PTR(address, os::javaTimeNanos), "nanoTime"); case vmIntrinsics::_allocateInstance: return inline_unsafe_allocate(); case vmIntrinsics::_copyMemory: @@ -2840,14 +2852,63 @@ return true; } +#ifdef TRACE_HAVE_INTRINSICS +/* + * oop -> myklass + * myklass->trace_id |= USED + * return myklass->trace_id & ~0x3 + */ +bool LibraryCallKit::inline_native_classID() { + int nargs = 1 + 1; + null_check_receiver(callee()); // check then ignore argument(0) + _sp += nargs; + Node* cls = do_null_check(argument(1), T_OBJECT); + _sp -= nargs; + Node* kls = load_klass_from_mirror(cls, false, nargs, NULL, 0); + _sp += nargs; + kls = do_null_check(kls, T_OBJECT); + _sp -= nargs; + ByteSize offset = TRACE_ID_OFFSET; + Node* insp = basic_plus_adr(kls, in_bytes(offset)); + Node* tvalue = make_load(NULL, insp, TypeLong::LONG, T_LONG); + Node* bits = longcon(~0x03l); // ignore bit 0 & 1 + Node* andl = _gvn.transform(new (C, 3) AndLNode(tvalue, bits)); + Node* clsused = longcon(0x01l); // set the class bit + Node* orl = _gvn.transform(new (C, 3) OrLNode(tvalue, clsused)); + + const TypePtr *adr_type = _gvn.type(insp)->isa_ptr(); + store_to_memory(control(), insp, orl, T_LONG, adr_type); + push_pair(andl); + return true; +} + +bool LibraryCallKit::inline_native_threadID() { + Node* tls_ptr = NULL; + Node* cur_thr = generate_current_thread(tls_ptr); + Node* p = basic_plus_adr(top()/*!oop*/, tls_ptr, in_bytes(JavaThread::osthread_offset())); + Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS); + p = basic_plus_adr(top()/*!oop*/, osthread, in_bytes(OSThread::thread_id_offset())); + + Node* threadid = NULL; + size_t thread_id_size = OSThread::thread_id_size(); + if (thread_id_size == (size_t) BytesPerLong) { + threadid = ConvL2I(make_load(control(), p, TypeLong::LONG, T_LONG)); + push(threadid); + } else if (thread_id_size == (size_t) BytesPerInt) { + threadid = make_load(control(), p, TypeInt::INT, T_INT); + push(threadid); + } else { + ShouldNotReachHere(); + } + return true; +} +#endif + //------------------------inline_native_time_funcs-------------- // inline code for System.currentTimeMillis() and System.nanoTime() // these have the same type and signature -bool LibraryCallKit::inline_native_time_funcs(bool isNano) { - address funcAddr = isNano ? CAST_FROM_FN_PTR(address, os::javaTimeNanos) : - CAST_FROM_FN_PTR(address, os::javaTimeMillis); - const char * funcName = isNano ? "nanoTime" : "currentTimeMillis"; - const TypeFunc *tf = OptoRuntime::current_time_millis_Type(); +bool LibraryCallKit::inline_native_time_funcs(address funcAddr, const char* funcName) { + const TypeFunc *tf = OptoRuntime::void_long_Type(); const TypePtr* no_memory_effects = NULL; Node* time = make_runtime_call(RC_LEAF, tf, funcAddr, funcName, no_memory_effects); Node* value = _gvn.transform(new (C, 1) ProjNode(time, TypeFunc::Parms+0));
--- a/src/share/vm/opto/runtime.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/opto/runtime.cpp Tue May 08 11:29:21 2012 -0700 @@ -709,9 +709,9 @@ return TypeFunc::make(domain, range); } -//-------------- currentTimeMillis +//-------------- currentTimeMillis, currentTimeNanos, etc -const TypeFunc* OptoRuntime::current_time_millis_Type() { +const TypeFunc* OptoRuntime::void_long_Type() { // create input type (domain) const Type **fields = TypeTuple::fields(0); const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+0, fields);
--- a/src/share/vm/opto/runtime.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/opto/runtime.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -268,7 +268,7 @@ static const TypeFunc* Math_DD_D_Type(); // mod,pow & friends static const TypeFunc* modf_Type(); static const TypeFunc* l2f_Type(); - static const TypeFunc* current_time_millis_Type(); + static const TypeFunc* void_long_Type(); static const TypeFunc* flush_windows_Type();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/prims/wbtestmethods/parserTests.cpp Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" + +#include "classfile/symbolTable.hpp" + +#include "prims/jni.h" +#include "prims/whitebox.hpp" +#include "prims/wbtestmethods/parserTests.hpp" +#include "runtime/interfaceSupport.hpp" + +#include "memory/oopFactory.hpp" + +#include "services/diagnosticArgument.hpp" +#include "services/diagnosticFramework.hpp" + +//There's no way of beforeahnd knowing an upper size +//Of the length of a string representation of +//the value of an argument. +#define VALUE_MAXLEN 256 + +// DiagnosticFramework test utility methods + +/* + * The DiagnosticArgumentType class contains an enum that says which type + * this argument represents. (JLONG, BOOLEAN etc). + * This method Returns a char* representation of that enum value. + */ +static const char* lookup_diagnosticArgumentEnum(const char* field_name, oop object) { + Thread* THREAD = Thread::current(); + const char* enum_sig = "Lsun/hotspot/parser/DiagnosticCommand$DiagnosticArgumentType;"; + TempNewSymbol enumSigSymbol = SymbolTable::lookup(enum_sig, (int) strlen(enum_sig), THREAD); + int offset = WhiteBox::offset_for_field(field_name, object, enumSigSymbol); + oop enumOop = object->obj_field(offset); + + const char* ret = WhiteBox::lookup_jstring("name", enumOop); + return ret; +} + +/* + * Takes an oop to a DiagnosticArgumentType-instance and + * reads the fields from it. Fills an native DCmdParser with + * this info. + */ +static void fill_in_parser(DCmdParser* parser, oop argument) +{ + const char* name = WhiteBox::lookup_jstring("name", argument); + const char* desc = WhiteBox::lookup_jstring("desc", argument); + const char* default_value = WhiteBox::lookup_jstring("defaultValue", argument); + bool mandatory = WhiteBox::lookup_bool("mandatory", argument); + const char* type = lookup_diagnosticArgumentEnum("type", argument); + + if (strcmp(type, "STRING") == 0) { + DCmdArgument<char*>* argument = new DCmdArgument<char*>( + name, desc, + "STRING", mandatory, default_value); + parser->add_dcmd_option(argument); + } else if (strcmp(type, "NANOTIME") == 0) { + DCmdArgument<NanoTimeArgument>* argument = new DCmdArgument<NanoTimeArgument>( + name, desc, + "NANOTIME", mandatory, default_value); + parser->add_dcmd_option(argument); + } else if (strcmp(type, "JLONG") == 0) { + DCmdArgument<jlong>* argument = new DCmdArgument<jlong>( + name, desc, + "JLONG", mandatory, default_value); + parser->add_dcmd_option(argument); + } else if (strcmp(type, "BOOLEAN") == 0) { + DCmdArgument<bool>* argument = new DCmdArgument<bool>( + name, desc, + "BOOLEAN", mandatory, default_value); + parser->add_dcmd_option(argument); + } else if (strcmp(type, "MEMORYSIZE") == 0) { + DCmdArgument<MemorySizeArgument>* argument = new DCmdArgument<MemorySizeArgument>( + name, desc, + "MEMORY SIZE", mandatory, default_value); + parser->add_dcmd_option(argument); + } else if (strcmp(type, "STRINGARRAY") == 0) { + DCmdArgument<StringArrayArgument*>* argument = new DCmdArgument<StringArrayArgument*>( + name, desc, + "STRING SET", mandatory); + parser->add_dcmd_option(argument); + } +} + +/* + * Will Fill in a java object array with alternating names of parsed command line options and + * the value that has been parsed for it: + * { name, value, name, value ... } + * This can then be checked from java. + */ +WB_ENTRY(jobjectArray, WB_ParseCommandLine(JNIEnv* env, jobject o, jstring j_cmdline, jobjectArray arguments)) + ResourceMark rm; + DCmdParser parser; + + const char* c_cmdline = java_lang_String::as_utf8_string(JNIHandles::resolve(j_cmdline)); + objArrayOop argumentArray = objArrayOop(JNIHandles::resolve_non_null(arguments)); + + int length = argumentArray->length(); + + for (int i = 0; i < length; i++) { + oop argument_oop = argumentArray->obj_at(i); + fill_in_parser(&parser, argument_oop); + } + + CmdLine cmdline(c_cmdline, strlen(c_cmdline), true); + parser.parse(&cmdline,',',CHECK_NULL); + + klassOop k = SystemDictionary::Object_klass(); + objArrayOop returnvalue_array = oopFactory::new_objArray(k, parser.num_arguments() * 2, CHECK_NULL); + + GrowableArray<const char *>*parsedArgNames = parser.argument_name_array(); + + for (int i = 0; i < parser.num_arguments(); i++) { + oop parsedName = java_lang_String::create_oop_from_str(parsedArgNames->at(i), CHECK_NULL); + returnvalue_array->obj_at_put(i*2, parsedName); + GenDCmdArgument* arg = parser.lookup_dcmd_option(parsedArgNames->at(i), strlen(parsedArgNames->at(i))); + char buf[VALUE_MAXLEN]; + arg->value_as_str(buf, sizeof(buf)); + oop parsedValue = java_lang_String::create_oop_from_str(buf, CHECK_NULL); + returnvalue_array->obj_at_put(i*2+1, parsedValue); + } + + return (jobjectArray) JNIHandles::make_local(returnvalue_array); + +WB_END
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/prims/wbtestmethods/parserTests.hpp Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#ifndef SHARE_VM_PRIMS_WBTESTMETHODS_PARSERTESTS_H +#define SHARE_VM_PRIMS_WBTESTMETHODS_PARSERTESTS_H + +#include "prims/jni.h" +#include "prims/whitebox.hpp" + +WB_METHOD_DECLARE WB_ParseCommandLine(JNIEnv* env, jobject o, jstring args, jobjectArray arguments); + +#endif //SHARE_VM_PRIMS_WBTESTMETHODS_PARSERTESTS_H
--- a/src/share/vm/prims/whitebox.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/prims/whitebox.cpp Tue May 08 11:29:21 2012 -0700 @@ -24,11 +24,14 @@ #include "precompiled.hpp" -#include "jni.h" - #include "memory/universe.hpp" #include "oops/oop.inline.hpp" + +#include "classfile/symbolTable.hpp" + #include "prims/whitebox.hpp" +#include "prims/wbtestmethods/parserTests.hpp" + #include "runtime/interfaceSupport.hpp" #include "runtime/os.hpp" #include "utilities/debug.hpp" @@ -41,13 +44,6 @@ bool WhiteBox::_used = false; -// Entry macro to transition from JNI to VM state. - -#define WB_ENTRY(result_type, header) JNI_ENTRY(result_type, header) -#define WB_END JNI_END - -// Definitions of functions exposed via Whitebox API - WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj)) return (jlong)(void*)JNIHandles::resolve(obj); WB_END @@ -81,11 +77,63 @@ WB_END #endif // !SERIALGC +//Some convenience methods to deal with objects from java +int WhiteBox::offset_for_field(const char* field_name, oop object, + Symbol* signature_symbol) { + assert(field_name != NULL && strlen(field_name) > 0, "Field name not valid"); + Thread* THREAD = Thread::current(); + + //Get the class of our object + klassOop arg_klass = object->klass(); + //Turn it into an instance-klass + instanceKlass* ik = instanceKlass::cast(arg_klass); + + //Create symbols to look for in the class + TempNewSymbol name_symbol = SymbolTable::lookup(field_name, (int) strlen(field_name), + THREAD); + + //To be filled in with an offset of the field we're looking for + fieldDescriptor fd; + + klassOop res = ik->find_field(name_symbol, signature_symbol, &fd); + if (res == NULL) { + tty->print_cr("Invalid layout of %s at %s", ik->external_name(), + name_symbol->as_C_string()); + fatal("Invalid layout of preloaded class"); + } + + //fetch the field at the offset we've found + int dest_offset = fd.offset(); + + return dest_offset; +} + + +const char* WhiteBox::lookup_jstring(const char* field_name, oop object) { + int offset = offset_for_field(field_name, object, + vmSymbols::string_signature()); + oop string = object->obj_field(offset); + const char* ret = java_lang_String::as_utf8_string(string); + return ret; +} + +bool WhiteBox::lookup_bool(const char* field_name, oop object) { + int offset = + offset_for_field(field_name, object, vmSymbols::bool_signature()); + bool ret = (object->bool_field(offset) == JNI_TRUE); + return ret; +} + + #define CC (char*) static JNINativeMethod methods[] = { {CC"getObjectAddress", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress }, {CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize }, + {CC "parseCommandLine", + CC "(Ljava/lang/String;[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;", + (void*) &WB_ParseCommandLine + }, #ifndef SERIALGC {CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark}, {CC"g1IsHumongous", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous },
--- a/src/share/vm/prims/whitebox.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/prims/whitebox.hpp Tue May 08 11:29:21 2012 -0700 @@ -25,12 +25,29 @@ #ifndef SHARE_VM_PRIMS_WHITEBOX_HPP #define SHARE_VM_PRIMS_WHITEBOX_HPP +#include "prims/jni.h" + +#include "memory/allocation.hpp" +#include "oops/oopsHierarchy.hpp" + +// Entry macro to transition from JNI to VM state. + +#define WB_ENTRY(result_type, header) JNI_ENTRY(result_type, header) +#define WB_END JNI_END +#define WB_METHOD_DECLARE extern "C" jobjectArray JNICALL + class WhiteBox : public AllStatic { private: static bool _used; public: static bool used() { return _used; } static void set_used() { _used = true; } + static int offset_for_field(const char* field_name, oop object, + Symbol* signature_symbol); + static const char* lookup_jstring(const char* field_name, oop object); + static bool lookup_bool(const char* field_name, oop object); }; + + #endif // SHARE_VM_PRIMS_WHITEBOX_HPP
--- a/src/share/vm/runtime/globals.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/runtime/globals.hpp Tue May 08 11:29:21 2012 -0700 @@ -3807,7 +3807,7 @@ product(uintx, SharedReadOnlySize, 10*M, \ "Size of read-only space in permanent generation (in bytes)") \ \ - product(uintx, SharedMiscDataSize, NOT_LP64(4*M) LP64_ONLY(5*M), \ + product(uintx, SharedMiscDataSize, NOT_LP64(4*M) LP64_ONLY(5*M) NOT_PRODUCT(+1*M), \ "Size of the shared data area adjacent to the heap (in bytes)") \ \ product(uintx, SharedMiscCodeSize, 4*M, \
--- a/src/share/vm/runtime/osThread.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/runtime/osThread.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -98,6 +98,7 @@ // For java intrinsics: static ByteSize interrupted_offset() { return byte_offset_of(OSThread, _interrupted); } + static ByteSize thread_id_offset() { return byte_offset_of(OSThread, _thread_id); } // Platform dependent stuff #ifdef TARGET_OS_FAMILY_linux
--- a/src/share/vm/runtime/thread.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/runtime/thread.cpp Tue May 08 11:29:21 2012 -0700 @@ -3468,13 +3468,13 @@ create_vm_init_libraries(); } + // Notify JVMTI agents that VM initialization is complete - nop if no agents. + JvmtiExport::post_vm_initialized(); + if (!TRACE_START()) { vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION)); } - // Notify JVMTI agents that VM initialization is complete - nop if no agents. - JvmtiExport::post_vm_initialized(); - if (CleanChunkPoolAsync) { Chunk::start_chunk_pool_cleaner_task(); }
--- a/src/share/vm/runtime/vmStructs.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/runtime/vmStructs.cpp Tue May 08 11:29:21 2012 -0700 @@ -292,8 +292,6 @@ nonstatic_field(instanceKlass, _method_ordering, typeArrayOop) \ nonstatic_field(instanceKlass, _local_interfaces, objArrayOop) \ nonstatic_field(instanceKlass, _transitive_interfaces, objArrayOop) \ - nonstatic_field(instanceKlass, _nof_implementors, int) \ - nonstatic_field(instanceKlass, _implementors[0], klassOop) \ nonstatic_field(instanceKlass, _fields, typeArrayOop) \ nonstatic_field(instanceKlass, _java_fields_count, u2) \ nonstatic_field(instanceKlass, _constants, constantPoolOop) \ @@ -2343,7 +2341,6 @@ /* instanceKlass enum */ \ /*************************************/ \ \ - declare_constant(instanceKlass::implementors_limit) \ \ /*************************************/ \ /* FieldInfo FieldOffset enum */ \
--- a/src/share/vm/runtime/vmThread.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/runtime/vmThread.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -304,7 +304,7 @@ os::check_heap(); // Silent verification so as not to pollute normal output, // unless we really asked for it. - Universe::verify(true, !(PrintGCDetails || Verbose)); + Universe::verify(!(PrintGCDetails || Verbose)); } CompileBroker::set_should_block();
--- a/src/share/vm/services/diagnosticArgument.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/services/diagnosticArgument.cpp Tue May 08 11:29:21 2012 -0700 @@ -43,6 +43,47 @@ set_is_set(true); } +void GenDCmdArgument::to_string(jlong l, char* buf, size_t len) { + jio_snprintf(buf, len, INT64_FORMAT, l); +} + +void GenDCmdArgument::to_string(bool b, char* buf, size_t len) { + jio_snprintf(buf, len, b ? "true" : "false"); +} + +void GenDCmdArgument::to_string(NanoTimeArgument n, char* buf, size_t len) { + jio_snprintf(buf, len, INT64_FORMAT, n._nanotime); +} + +void GenDCmdArgument::to_string(MemorySizeArgument m, char* buf, size_t len) { + jio_snprintf(buf, len, INT64_FORMAT, m._size); +} + +void GenDCmdArgument::to_string(char* c, char* buf, size_t len) { + jio_snprintf(buf, len, "%s", c); +} + +void GenDCmdArgument::to_string(StringArrayArgument* f, char* buf, size_t len) { + int length = f->array()->length(); + size_t written = 0; + buf[0] = 0; + for (int i = 0; i < length; i++) { + char* next_str = f->array()->at(i); + size_t next_size = strlen(next_str); + //Check if there's room left to write next element + if (written + next_size > len) { + return; + } + //Actually write element + strcat(buf, next_str); + written += next_size; + //Check if there's room left for the comma + if (i < length-1 && len - written > 0) { + strcat(buf, ","); + } + } +} + template <> void DCmdArgument<jlong>::parse_value(const char* str, size_t len, TRAPS) { if (str == NULL || sscanf(str, INT64_FORMAT, &_value) != 1) {
--- a/src/share/vm/services/diagnosticArgument.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/services/diagnosticArgument.hpp Tue May 08 11:29:21 2012 -0700 @@ -110,12 +110,20 @@ virtual void init_value(TRAPS) = 0; virtual void reset(TRAPS) = 0; virtual void cleanup() = 0; + virtual void value_as_str(char* buf, size_t len) = 0; void set_next(GenDCmdArgument* arg) { _next = arg; } GenDCmdArgument* next() { return _next; } + + void to_string(jlong l, char* buf, size_t len); + void to_string(bool b, char* buf, size_t len); + void to_string(char* c, char* buf, size_t len); + void to_string(NanoTimeArgument n, char* buf, size_t len); + void to_string(MemorySizeArgument f, char* buf, size_t len); + void to_string(StringArrayArgument* s, char* buf, size_t len); }; template <class ArgType> class DCmdArgument: public GenDCmdArgument { @@ -143,6 +151,7 @@ void parse_value(const char* str, size_t len, TRAPS); void init_value(TRAPS); void destroy_value(); + void value_as_str(char *buf, size_t len) { return to_string(_value, buf, len);} }; #endif /* SHARE_VM_SERVICES_DIAGNOSTICARGUMENT_HPP */
--- a/src/share/vm/services/gcNotifier.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/services/gcNotifier.cpp Tue May 08 11:29:21 2012 -0700 @@ -163,8 +163,8 @@ constructor_args.push_oop(gcInfo_instance); constructor_args.push_oop(getGcInfoBuilder(gcManager,THREAD)); constructor_args.push_long(gcStatInfo->gc_index()); - constructor_args.push_long(gcStatInfo->start_time()); - constructor_args.push_long(gcStatInfo->end_time()); + constructor_args.push_long(Management::ticks_to_ms(gcStatInfo->start_time())); + constructor_args.push_long(Management::ticks_to_ms(gcStatInfo->end_time())); constructor_args.push_oop(usage_before_gc_ah); constructor_args.push_oop(usage_after_gc_ah); constructor_args.push_oop(extra_array);
--- a/src/share/vm/trace/traceMacros.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/trace/traceMacros.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -43,5 +43,9 @@ #define TRACE_SET_KLASS_TRACE_ID(x1, x2) do { } while (0) #define TRACE_DEFINE_KLASS_METHODS typedef int ___IGNORED_hs_trace_type1 #define TRACE_DEFINE_KLASS_TRACE_ID typedef int ___IGNORED_hs_trace_type2 +#define TRACE_DEFINE_OFFSET typedef int ___IGNORED_hs_trace_type3 +#define TRACE_ID_OFFSET in_ByteSize(0); ShouldNotReachHere() +#define TRACE_TEMPLATES(template) +#define TRACE_INTRINSICS(do_intrinsic, do_class, do_name, do_signature, do_alias) #endif
--- a/src/share/vm/utilities/bitMap.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/utilities/bitMap.cpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -179,64 +179,6 @@ clear_range_within_word(bit_index(end_full_word), end); } -void BitMap::mostly_disjoint_range_union(BitMap* from_bitmap, - idx_t from_start_index, - idx_t to_start_index, - size_t word_num) { - // Ensure that the parameters are correct. - // These shouldn't be that expensive to check, hence I left them as - // guarantees. - guarantee(from_bitmap->bit_in_word(from_start_index) == 0, - "it should be aligned on a word boundary"); - guarantee(bit_in_word(to_start_index) == 0, - "it should be aligned on a word boundary"); - guarantee(word_num >= 2, "word_num should be at least 2"); - - intptr_t* from = (intptr_t*) from_bitmap->word_addr(from_start_index); - intptr_t* to = (intptr_t*) word_addr(to_start_index); - - if (*from != 0) { - // if it's 0, then there's no point in doing the CAS - while (true) { - intptr_t old_value = *to; - intptr_t new_value = old_value | *from; - intptr_t res = Atomic::cmpxchg_ptr(new_value, to, old_value); - if (res == old_value) break; - } - } - ++from; - ++to; - - for (size_t i = 0; i < word_num - 2; ++i) { - if (*from != 0) { - // if it's 0, then there's no point in doing the CAS - assert(*to == 0, "nobody else should be writing here"); - intptr_t new_value = *from; - *to = new_value; - } - - ++from; - ++to; - } - - if (*from != 0) { - // if it's 0, then there's no point in doing the CAS - while (true) { - intptr_t old_value = *to; - intptr_t new_value = old_value | *from; - intptr_t res = Atomic::cmpxchg_ptr(new_value, to, old_value); - if (res == old_value) break; - } - } - - // the -1 is because we didn't advance them after the final CAS - assert(from == - (intptr_t*) from_bitmap->word_addr(from_start_index) + word_num - 1, - "invariant"); - assert(to == (intptr_t*) word_addr(to_start_index) + word_num - 1, - "invariant"); -} - void BitMap::at_put(idx_t offset, bool value) { if (value) { set_bit(offset);
--- a/src/share/vm/utilities/bitMap.hpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/utilities/bitMap.hpp Tue May 08 11:29:21 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -192,31 +192,6 @@ void par_set_range(idx_t beg, idx_t end, RangeSizeHint hint); void par_clear_range (idx_t beg, idx_t end, RangeSizeHint hint); - // It performs the union operation between subsets of equal length - // of two bitmaps (the target bitmap of the method and the - // from_bitmap) and stores the result to the target bitmap. The - // from_start_index represents the first bit index of the subrange - // of the from_bitmap. The to_start_index is the equivalent of the - // target bitmap. Both indexes should be word-aligned, i.e. they - // should correspond to the first bit on a bitmap word (it's up to - // the caller to ensure this; the method does check it). The length - // of the subset is specified with word_num and it is in number of - // bitmap words. The caller should ensure that this is at least 2 - // (smaller ranges are not support to save extra checks). Again, - // this is checked in the method. - // - // Atomicity concerns: it is assumed that any contention on the - // target bitmap with other threads will happen on the first and - // last words; the ones in between will be "owned" exclusively by - // the calling thread and, in fact, they will already be 0. So, the - // method performs a CAS on the first word, copies the next - // word_num-2 words, and finally performs a CAS on the last word. - void mostly_disjoint_range_union(BitMap* from_bitmap, - idx_t from_start_index, - idx_t to_start_index, - size_t word_num); - - // Clearing void clear_large(); inline void clear();
--- a/src/share/vm/utilities/vmError.cpp Thu May 03 15:37:46 2012 -0400 +++ b/src/share/vm/utilities/vmError.cpp Tue May 08 11:29:21 2012 -0700 @@ -685,6 +685,12 @@ // extended (i.e., more detailed) version. Universe::print_on(st, true /* extended */); st->cr(); + + Universe::heap()->barrier_set()->print_on(st); + st->cr(); + + st->print_cr("Polling page: " INTPTR_FORMAT, os::get_polling_page()); + st->cr(); } STEP(195, "(printing code cache information)" )
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/runtime/7158988/FieldMonitor.java Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,249 @@ +/* + * Copyright 2012 SAP AG. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test FieldMonitor.java + * @bug 7158988 + * @summary verify jvm does not crash while debugging + * @run shell TestFieldMonitor.sh + * @author axel.siebenborn@sap.com + */ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.Reader; +import java.io.Writer; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import com.sun.jdi.Bootstrap; +import com.sun.jdi.Field; +import com.sun.jdi.ReferenceType; +import com.sun.jdi.VirtualMachine; +import com.sun.jdi.connect.Connector; +import com.sun.jdi.connect.IllegalConnectorArgumentsException; +import com.sun.jdi.connect.LaunchingConnector; +import com.sun.jdi.connect.VMStartException; +import com.sun.jdi.event.ClassPrepareEvent; +import com.sun.jdi.event.Event; +import com.sun.jdi.event.EventQueue; +import com.sun.jdi.event.EventSet; +import com.sun.jdi.event.ModificationWatchpointEvent; +import com.sun.jdi.event.VMDeathEvent; +import com.sun.jdi.event.VMDisconnectEvent; +import com.sun.jdi.request.ClassPrepareRequest; +import com.sun.jdi.request.EventRequest; +import com.sun.jdi.request.EventRequestManager; +import com.sun.jdi.request.ModificationWatchpointRequest; + +public class FieldMonitor { + + public static final String CLASS_NAME = "TestPostFieldModification"; + public static final String FIELD_NAME = "value"; + public static final String ARGUMENTS = "-Xshare:off -XX:+PrintGC"; + + public static void main(String[] args) + throws IOException, InterruptedException { + + StringBuffer sb = new StringBuffer(); + + for (int i=0; i < args.length; i++) { + sb.append(' '); + sb.append(args[i]); + } + //VirtualMachine vm = launchTarget(sb.toString()); + VirtualMachine vm = launchTarget(CLASS_NAME); + + System.out.println("Vm launched"); + // set watch field on already loaded classes + List<ReferenceType> referenceTypes = vm + .classesByName(CLASS_NAME); + for (ReferenceType refType : referenceTypes) { + addFieldWatch(vm, refType); + } + // watch for loaded classes + addClassWatch(vm); + + // process events + EventQueue eventQueue = vm.eventQueue(); + // resume the vm + + Process process = vm.process(); + + + // Copy target's output and error to our output and error. + Thread outThread = new StreamRedirectThread("out reader", process.getInputStream()); + Thread errThread = new StreamRedirectThread("error reader", process.getErrorStream()); + + errThread.start(); + outThread.start(); + + + vm.resume(); + boolean connected = true; + while (connected) { + EventSet eventSet = eventQueue.remove(); + for (Event event : eventSet) { + if (event instanceof VMDeathEvent + || event instanceof VMDisconnectEvent) { + // exit + connected = false; + } else if (event instanceof ClassPrepareEvent) { + // watch field on loaded class + System.out.println("ClassPrepareEvent"); + ClassPrepareEvent classPrepEvent = (ClassPrepareEvent) event; + ReferenceType refType = classPrepEvent + .referenceType(); + addFieldWatch(vm, refType); + } else if (event instanceof ModificationWatchpointEvent) { + System.out.println("sleep for 500 ms"); + Thread.sleep(500); + System.out.println("resume..."); + + ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event; + System.out.println("old=" + + modEvent.valueCurrent()); + System.out.println("new=" + modEvent.valueToBe()); + System.out.println(); + } + } + eventSet.resume(); + } + // Shutdown begins when event thread terminates + try { + errThread.join(); // Make sure output is forwarded + outThread.join(); + } catch (InterruptedException exc) { + // we don't interrupt + } + } + + /** + * Find a com.sun.jdi.CommandLineLaunch connector + */ + static LaunchingConnector findLaunchingConnector() { + List <Connector> connectors = Bootstrap.virtualMachineManager().allConnectors(); + Iterator <Connector> iter = connectors.iterator(); + while (iter.hasNext()) { + Connector connector = iter.next(); + if (connector.name().equals("com.sun.jdi.CommandLineLaunch")) { + return (LaunchingConnector)connector; + } + } + throw new Error("No launching connector"); + } + /** + * Return the launching connector's arguments. + */ + static Map <String,Connector.Argument> connectorArguments(LaunchingConnector connector, String mainArgs) { + Map<String,Connector.Argument> arguments = connector.defaultArguments(); + for (String key : arguments.keySet()) { + System.out.println(key); + } + + Connector.Argument mainArg = (Connector.Argument)arguments.get("main"); + if (mainArg == null) { + throw new Error("Bad launching connector"); + } + mainArg.setValue(mainArgs); + + Connector.Argument optionsArg = (Connector.Argument)arguments.get("options"); + if (optionsArg == null) { + throw new Error("Bad launching connector"); + } + optionsArg.setValue(ARGUMENTS); + return arguments; + } + + static VirtualMachine launchTarget(String mainArgs) { + LaunchingConnector connector = findLaunchingConnector(); + Map arguments = connectorArguments(connector, mainArgs); + try { + return (VirtualMachine) connector.launch(arguments); + } catch (IOException exc) { + throw new Error("Unable to launch target VM: " + exc); + } catch (IllegalConnectorArgumentsException exc) { + throw new Error("Internal error: " + exc); + } catch (VMStartException exc) { + throw new Error("Target VM failed to initialize: " + + exc.getMessage()); + } +} + + + private static void addClassWatch(VirtualMachine vm) { + EventRequestManager erm = vm.eventRequestManager(); + ClassPrepareRequest classPrepareRequest = erm + .createClassPrepareRequest(); + classPrepareRequest.addClassFilter(CLASS_NAME); + classPrepareRequest.setEnabled(true); + } + + + private static void addFieldWatch(VirtualMachine vm, + ReferenceType refType) { + EventRequestManager erm = vm.eventRequestManager(); + Field field = refType.fieldByName(FIELD_NAME); + ModificationWatchpointRequest modificationWatchpointRequest = erm + .createModificationWatchpointRequest(field); + modificationWatchpointRequest.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD); + modificationWatchpointRequest.setEnabled(true); + } +} + +class StreamRedirectThread extends Thread { + + private final BufferedReader in; + + private static final int BUFFER_SIZE = 2048; + + /** + * Set up for copy. + * @param name Name of the thread + * @param in Stream to copy from + * @param out Stream to copy to + */ + StreamRedirectThread(String name, InputStream in) { + super(name); + this.in = new BufferedReader(new InputStreamReader(in)); + } + + /** + * Copy. + */ + public void run() { + try { + String line; + while ((line = in.readLine ()) != null) { + System.out.println ("testvm: " + line); + } + System.out.flush(); + } catch(IOException exc) { + System.err.println("Child I/O Transfer - " + exc); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/runtime/7158988/TestFieldMonitor.sh Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,94 @@ +#!/bin/sh + +if [ "${TESTSRC}" = "" ] +then TESTSRC=. +fi + +if [ "${TESTJAVA}" = "" ] +then + PARENT=`dirname \`which java\`` + TESTJAVA=`dirname ${PARENT}` + echo "TESTJAVA not set, selecting " ${TESTJAVA} + echo "If this is incorrect, try setting the variable manually." +fi + +if [ "${TESTCLASSES}" = "" ] +then + echo "TESTCLASSES not set. Test cannot execute. Failed." + exit 1 +fi + +BIT_FLAG="" + +# set platform-dependent variables +OS=`uname -s` +case "$OS" in + SunOS | Linux ) + NULL=/dev/null + PS=":" + FS="/" + ## for solaris, linux it's HOME + FILE_LOCATION=$HOME + if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" -a `uname -p`='sparc' ] + then + BIT_FLAG="-d64" + fi + ;; + Windows_95 | Windows_98 | Windows_ME ) + NULL=NUL + PS=";" + FS="\\" + echo "Test skipped, only for WinNT" + exit 0 + ;; + Windows_NT ) + NULL=NUL + PS=";" + FS="\\" + ;; + * ) + echo "Unrecognized system!" + exit 1; + ;; +esac + +#CLASSPATH=.${PS}${TESTCLASSES} ; export CLASSPATH + +cp ${TESTSRC}${FS}*.java . + +${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -fullversion + +${TESTJAVA}${FS}bin${FS}javac -classpath .${PS}$TESTJAVA${FS}lib${FS}tools.jar *.java + +${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -classpath .${PS}$TESTJAVA${FS}lib${FS}tools.jar FieldMonitor > test.out 2>&1 & + +P_PID=$! + +sleep 60 +STATUS=0 + +case "$OS" in + SunOS | Linux ) + ps -ef | grep $P_PID | grep -v grep > ${NULL} + if [ $? = 0 ]; then + kill -9 $P_PID + STATUS=1 + fi + ;; + * ) + ps | grep -i "FieldMonitor" | grep -v grep > ${NULL} + if [ $? = 0 ]; then + C_PID=`ps | grep -i "FieldMonitor" | awk '{print $1}'` + kill -s 9 $C_PID + STATUS=1 + fi + ;; +esac + +grep "A fatal error has been detected" test.out > ${NULL} +if [ $? = 0 ]; then + cat test.out + STATUS=1 +fi + +exit $STATUS
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/runtime/7158988/TestPostFieldModification.java Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,58 @@ +/* + * Copyright 2012 SAP AG. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +public class TestPostFieldModification { + + public String value; // watch modification of value + + public static void main(String[] args){ + + System.out.println("Start threads"); + // this thread modifies the field 'value' + new Thread() { + TestPostFieldModification test = new TestPostFieldModification(); + public void run() { + test.value="test"; + for(int i = 0; i < 10; i++) { + test.value += new String("_test"); + } + } + }.start(); + + // this thread is used to trigger a gc + Thread d = new Thread() { + public void run() { + while(true) { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + + } + System.gc(); + } + } + }; + d.setDaemon(true); + d.start(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/serviceability/ParserTest.java Tue May 08 11:29:21 2012 -0700 @@ -0,0 +1,152 @@ +/* + * @test ParserTest + * @summary verify that whitebox functions can be linked and executed + * @run compile -J-XX:+UnlockDiagnosticVMOptions -J-XX:+WhiteBoxAPI ParserTest.java + * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ParserTest + */ + +import java.math.BigInteger; + +import sun.hotspot.parser.DiagnosticCommand; +import sun.hotspot.parser.DiagnosticCommand.DiagnosticArgumentType; +import sun.hotspot.WhiteBox; + +public class ParserTest { + WhiteBox wb; + + public ParserTest() throws Exception { + wb = WhiteBox.getWhiteBox(); + + testNanoTime(); + testJLong(); + testBool(); + testMemorySize(); + } + + public static void main(String... args) throws Exception { + new ParserTest(); + } + + public void testNanoTime() throws Exception { + String name = "name"; + DiagnosticCommand arg = new DiagnosticCommand(name, + "desc", DiagnosticArgumentType.NANOTIME, + false, "0"); + DiagnosticCommand[] args = {arg}; + + BigInteger bi = new BigInteger("7"); + //These should work + parse(name, bi.toString(), name + "=7ns", args); + + bi = bi.multiply(BigInteger.valueOf(1000)); + parse(name, bi.toString(), name + "=7us", args); + + bi = bi.multiply(BigInteger.valueOf(1000)); + parse(name, bi.toString(), name + "=7ms", args); + + bi = bi.multiply(BigInteger.valueOf(1000)); + parse(name, bi.toString(), name + "=7s", args); + + bi = bi.multiply(BigInteger.valueOf(60)); + parse(name, bi.toString() , name + "=7m", args); + + bi = bi.multiply(BigInteger.valueOf(60)); + parse(name, bi.toString() , name + "=7h", args); + + bi = bi.multiply(BigInteger.valueOf(24)); + parse(name, bi.toString() , name + "=7d", args); + + parse(name, "0", name + "=0", args); + + shouldFail(name + "=7xs", args); + shouldFail(name + "=7mms", args); + shouldFail(name + "=7f", args); + //Currently, only value 0 is allowed without unit + shouldFail(name + "=7", args); + } + + public void testJLong() throws Exception { + String name = "name"; + DiagnosticCommand arg = new DiagnosticCommand(name, + "desc", DiagnosticArgumentType.JLONG, + false, "0"); + DiagnosticCommand[] args = {arg}; + + wb.parseCommandLine(name + "=10", args); + parse(name, "10", name + "=10", args); + parse(name, "-5", name + "=-5", args); + + //shouldFail(name + "=12m", args); <-- should fail, doesn't + } + + public void testBool() throws Exception { + String name = "name"; + DiagnosticCommand arg = new DiagnosticCommand(name, + "desc", DiagnosticArgumentType.BOOLEAN, + false, "false"); + DiagnosticCommand[] args = {arg}; + + parse(name, "true", name + "=true", args); + parse(name, "false", name + "=false", args); + parse(name, "true", name, args); + + //Empty commandline to parse, tests default value + //of the parameter "name" + parse(name, "false", "", args); + } + + public void testMemorySize() throws Exception { + String name = "name"; + String defaultValue = "1024"; + DiagnosticCommand arg = new DiagnosticCommand(name, + "desc", DiagnosticArgumentType.MEMORYSIZE, + false, defaultValue); + DiagnosticCommand[] args = {arg}; + + BigInteger bi = new BigInteger("7"); + parse(name, bi.toString(), name + "=7b", args); + + bi = bi.multiply(BigInteger.valueOf(1024)); + parse(name, bi.toString(), name + "=7k", args); + + bi = bi.multiply(BigInteger.valueOf(1024)); + parse(name, bi.toString(), name + "=7m", args); + + bi = bi.multiply(BigInteger.valueOf(1024)); + parse(name, bi.toString(), name + "=7g", args); + parse(name, defaultValue, "", args); + + //shouldFail(name + "=7gg", args); <---- should fail, doesn't + //shouldFail(name + "=7t", args); <----- should fail, doesn't + } + + public void parse(String searchName, String expectedValue, + String cmdLine, DiagnosticCommand[] argumentTypes) throws Exception { + //parseCommandLine will return an object array that looks like + //{<name of parsed object>, <of parsed object> ... } + Object[] res = wb.parseCommandLine(cmdLine, argumentTypes); + for (int i = 0; i < res.length-1; i+=2) { + String parsedName = (String) res[i]; + if (searchName.equals(parsedName)) { + String parsedValue = (String) res[i+1]; + if (expectedValue.equals(parsedValue)) { + return; + } else { + throw new Exception("Parsing of cmdline '" + cmdLine + "' failed!\n" + + searchName + " parsed as " + parsedValue + + "! Expected: " + expectedValue); + } + } + } + throw new Exception(searchName + " not found as a parsed Argument!"); + } + + private void shouldFail(String argument, DiagnosticCommand[] argumentTypes) throws Exception { + try { + wb.parseCommandLine(argument, argumentTypes); + throw new Exception("Parser accepted argument: " + argument); + } catch (IllegalArgumentException e) { + //expected + } + } +}