OpenJDK / jdk7u / jdk7u / hotspot
changeset 993:54b3b351d6f9
Merge
line wrap: on
line diff
--- a/make/jprt.properties Fri Sep 18 09:57:47 2009 -0700 +++ b/make/jprt.properties Wed Sep 23 23:56:15 2009 -0700 @@ -40,6 +40,10 @@ jprt.tools.default.release=${jprt.submit.release} +# Disable syncing the source after builds and tests are done. + +jprt.sync.push=false + # Define the Solaris platforms we want for the various releases jprt.my.solaris.sparc.jdk7=solaris_sparc_5.10
--- a/make/linux/makefiles/jvmti.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/linux/makefiles/jvmti.make Wed Sep 23 23:56:15 2009 -0700 @@ -70,10 +70,10 @@ both = $(JvmtiGenClass) $(JvmtiSrcDir)/jvmti.xml $(JvmtiSrcDir)/jvmtiLib.xsl $(JvmtiGenClass): $(JvmtiGenSource) - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiGenSource) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiGenSource) $(JvmtiEnvFillClass): $(JvmtiEnvFillSource) - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiEnvFillSource) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiEnvFillSource) $(JvmtiOutDir)/jvmtiEnter.cpp: $(both) $(JvmtiSrcDir)/jvmtiEnter.xsl @echo Generating $@
--- a/make/linux/makefiles/mapfile-vers-debug Fri Sep 18 09:57:47 2009 -0700 +++ b/make/linux/makefiles/mapfile-vers-debug Wed Sep 23 23:56:15 2009 -0700 @@ -74,6 +74,7 @@ JVM_CurrentTimeMillis; JVM_DefineClass; JVM_DefineClassWithSource; + JVM_DefineClassWithSourceCond; JVM_DesiredAssertionStatus; JVM_DisableCompiler; JVM_DoPrivileged;
--- a/make/linux/makefiles/mapfile-vers-product Fri Sep 18 09:57:47 2009 -0700 +++ b/make/linux/makefiles/mapfile-vers-product Wed Sep 23 23:56:15 2009 -0700 @@ -74,6 +74,7 @@ JVM_CurrentTimeMillis; JVM_DefineClass; JVM_DefineClassWithSource; + JVM_DefineClassWithSourceCond; JVM_DesiredAssertionStatus; JVM_DisableCompiler; JVM_DoPrivileged;
--- a/make/linux/makefiles/rules.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/linux/makefiles/rules.make Wed Sep 23 23:56:15 2009 -0700 @@ -122,12 +122,20 @@ endif endif +COMPILE.JAVAC += $(BOOTSTRAP_JAVAC_FLAGS) + SUM = /usr/bin/sum # 'gmake MAKE_VERBOSE=y' gives all the gory details. QUIETLY$(MAKE_VERBOSE) = @ RUN.JAR$(MAKE_VERBOSE) += >/dev/null +# Settings for javac +BOOT_SOURCE_LANGUAGE_VERSION = 6 +BOOT_TARGET_CLASS_VERSION = 6 +JAVAC_FLAGS = -g -encoding ascii +BOOTSTRAP_JAVAC_FLAGS = $(JAVAC_FLAGS) -source $(BOOT_SOURCE_LANGUAGE_VERSION) -target $(BOOT_TARGET_CLASS_VERSION) + # With parallel makes, print a message at the end of compilation. ifeq ($(findstring j,$(MFLAGS)),j) COMPILE_DONE = && { echo Done with $<; }
--- a/make/linux/makefiles/sa.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/linux/makefiles/sa.make Wed Sep 23 23:56:15 2009 -0700 @@ -74,8 +74,8 @@ mkdir -p $(SA_CLASSDIR); \ fi - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES1) - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES2) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES1) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES2) $(QUIETLY) $(REMOTE) $(COMPILE.RMIC) -classpath $(SA_CLASSDIR) -d $(SA_CLASSDIR) sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer $(QUIETLY) echo "$(SA_BUILD_VERSION_PROP)" > $(SA_PROPERTIES)
--- a/make/linux/makefiles/top.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/linux/makefiles/top.make Wed Sep 23 23:56:15 2009 -0700 @@ -24,7 +24,7 @@ # top.make is included in the Makefile in the build directories. # It DOES NOT include the vm dependency info in order to be faster. -# It's main job is to implement the incremental form of make lists. +# Its main job is to implement the incremental form of make lists. # It also: # -builds and runs adlc via adlc.make # -generates JVMTI source and docs via jvmti.make (JSR-163) @@ -114,7 +114,7 @@ # make makeDeps: (and zap the cached db files to force a nonincremental run) $(GENERATED)/$(MakeDepsClass): $(MakeDepsSources) - @$(REMOTE) $(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -g -d $(GENERATED) $(MakeDepsSources) + @$(REMOTE) $(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -d $(GENERATED) $(MakeDepsSources) @echo Removing $(Incremental_Lists) to force regeneration. @rm -f $(Incremental_Lists) @$(CDG) echo >$(Cached_plat)
--- a/make/solaris/makefiles/jvmti.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/solaris/makefiles/jvmti.make Wed Sep 23 23:56:15 2009 -0700 @@ -69,10 +69,10 @@ both = $(JvmtiGenClass) $(JvmtiSrcDir)/jvmti.xml $(JvmtiSrcDir)/jvmtiLib.xsl $(JvmtiGenClass): $(JvmtiGenSource) - $(QUIETLY) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiGenSource) + $(QUIETLY) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiGenSource) $(JvmtiEnvFillClass): $(JvmtiEnvFillSource) - $(QUIETLY) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiEnvFillSource) + $(QUIETLY) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiEnvFillSource) $(JvmtiOutDir)/jvmtiEnter.cpp: $(both) $(JvmtiSrcDir)/jvmtiEnter.xsl @echo Generating $@
--- a/make/solaris/makefiles/mapfile-vers Fri Sep 18 09:57:47 2009 -0700 +++ b/make/solaris/makefiles/mapfile-vers Wed Sep 23 23:56:15 2009 -0700 @@ -74,6 +74,7 @@ JVM_CurrentTimeMillis; JVM_DefineClass; JVM_DefineClassWithSource; + JVM_DefineClassWithSourceCond; JVM_DesiredAssertionStatus; JVM_DisableCompiler; JVM_DoPrivileged;
--- a/make/solaris/makefiles/rules.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/solaris/makefiles/rules.make Wed Sep 23 23:56:15 2009 -0700 @@ -122,12 +122,20 @@ endif endif +COMPILE.JAVAC += $(BOOTSTRAP_JAVAC_FLAGS) + SUM = /usr/bin/sum # 'gmake MAKE_VERBOSE=y' gives all the gory details. QUIETLY$(MAKE_VERBOSE) = @ RUN.JAR$(MAKE_VERBOSE) += >/dev/null +# Settings for javac +BOOT_SOURCE_LANGUAGE_VERSION = 6 +BOOT_TARGET_CLASS_VERSION = 6 +JAVAC_FLAGS = -g -encoding ascii +BOOTSTRAP_JAVAC_FLAGS = $(JAVAC_FLAGS) -source $(BOOT_SOURCE_LANGUAGE_VERSION) -target $(BOOT_TARGET_CLASS_VERSION) + # With parallel makes, print a message at the end of compilation. ifeq ($(findstring j,$(MFLAGS)),j) COMPILE_DONE = && { echo Done with $<; }
--- a/make/solaris/makefiles/sa.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/solaris/makefiles/sa.make Wed Sep 23 23:56:15 2009 -0700 @@ -67,8 +67,8 @@ $(QUIETLY) if [ ! -d $(SA_CLASSDIR) ] ; then \ mkdir -p $(SA_CLASSDIR); \ fi - $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES1) - $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES2) + $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES1) + $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES2) $(QUIETLY) $(COMPILE.RMIC) -classpath $(SA_CLASSDIR) -d $(SA_CLASSDIR) sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer $(QUIETLY) echo "$(SA_BUILD_VERSION_PROP)" > $(SA_PROPERTIES)
--- a/make/solaris/makefiles/top.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/solaris/makefiles/top.make Wed Sep 23 23:56:15 2009 -0700 @@ -24,7 +24,7 @@ # top.make is included in the Makefile in the build directories. # It DOES NOT include the vm dependency info in order to be faster. -# It's main job is to implement the incremental form of make lists. +# Its main job is to implement the incremental form of make lists. # It also: # -builds and runs adlc via adlc.make # -generates JVMTI source and docs via jvmti.make (JSR-163) @@ -112,7 +112,7 @@ # make makeDeps: (and zap the cached db files to force a nonincremental run) $(GENERATED)/$(MakeDepsClass): $(MakeDepsSources) - @$(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -g -d $(GENERATED) $(MakeDepsSources) + @$(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -d $(GENERATED) $(MakeDepsSources) @echo Removing $(Incremental_Lists) to force regeneration. @rm -f $(Incremental_Lists) @$(CDG) echo >$(Cached_plat)
--- a/make/windows/makefiles/generated.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/windows/makefiles/generated.make Wed Sep 23 23:56:15 2009 -0700 @@ -91,7 +91,7 @@ classes/MakeDeps.class: $(MakeDepsSources) if exist classes rmdir /s /q classes mkdir classes - $(COMPILE_JAVAC) -classpath $(WorkSpace)\src\share\tools\MakeDeps -g -d classes $(MakeDepsSources) + $(COMPILE_JAVAC) -classpath $(WorkSpace)\src\share\tools\MakeDeps -d classes $(MakeDepsSources) !if ("$(Variant)" == "compiler2") || ("$(Variant)" == "tiered")
--- a/make/windows/makefiles/jvmti.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/windows/makefiles/jvmti.make Wed Sep 23 23:56:15 2009 -0700 @@ -68,10 +68,10 @@ @if not exist $(JvmtiOutDir) mkdir $(JvmtiOutDir) $(JvmtiGenClass): $(JvmtiGenSource) - $(COMPILE_JAVAC) -g -d $(JvmtiOutDir) $(JvmtiGenSource) + $(COMPILE_JAVAC) -d $(JvmtiOutDir) $(JvmtiGenSource) $(JvmtiEnvFillClass): $(JvmtiEnvFillSource) - @$(COMPILE_JAVAC) -g -d $(JvmtiOutDir) $(JvmtiEnvFillSource) + @$(COMPILE_JAVAC) -d $(JvmtiOutDir) $(JvmtiEnvFillSource) $(JvmtiOutDir)/jvmtiEnter.cpp: $(both) $(JvmtiSrcDir)/jvmtiEnter.xsl @echo Generating $@
--- a/make/windows/makefiles/rules.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/windows/makefiles/rules.make Wed Sep 23 23:56:15 2009 -0700 @@ -29,7 +29,7 @@ RUN_JAVAP=$(BootStrapDir)\bin\javap RUN_JAVAH=$(BootStrapDir)\bin\javah RUN_JAR=$(BootStrapDir)\bin\jar -COMPILE_JAVAC=$(BootStrapDir)\bin\javac +COMPILE_JAVAC=$(BootStrapDir)\bin\javac $(BOOTSTRAP_JAVAC_FLAGS) COMPILE_RMIC=$(BootStrapDir)\bin\rmic BOOT_JAVA_HOME=$(BootStrapDir) !else @@ -37,11 +37,17 @@ RUN_JAVAP=javap RUN_JAVAH=javah RUN_JAR=jar -COMPILE_JAVAC=javac +COMPILE_JAVAC=javac $(BOOTSTRAP_JAVAC_FLAGS) COMPILE_RMIC=rmic BOOT_JAVA_HOME= !endif +# Settings for javac +BOOT_SOURCE_LANGUAGE_VERSION=6 +BOOT_TARGET_CLASS_VERSION=6 +JAVAC_FLAGS=-g -encoding ascii +BOOTSTRAP_JAVAC_FLAGS=$(JAVAC_FLAGS) -source $(BOOT_SOURCE_LANGUAGE_VERSION) -target $(BOOT_TARGET_CLASS_VERSION) + ProjectFile=vm.vcproj !if "$(MSC_VER)" == "1200"
--- a/make/windows/makefiles/sa.make Fri Sep 18 09:57:47 2009 -0700 +++ b/make/windows/makefiles/sa.make Wed Sep 23 23:56:15 2009 -0700 @@ -55,9 +55,9 @@ $(GENERATED)\sa-jdi.jar: $(AGENT_FILES1:/=\) $(AGENT_FILES2:/=\) @if not exist $(SA_CLASSDIR) mkdir $(SA_CLASSDIR) @echo ...Building sa-jdi.jar - @echo ...$(COMPILE_JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -g -d $(SA_CLASSDIR) .... - @$(COMPILE_JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES1:/=\) - @$(COMPILE_JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES2:/=\) + @echo ...$(COMPILE_JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -d $(SA_CLASSDIR) .... + @$(COMPILE_JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES1:/=\) + @$(COMPILE_JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES2:/=\) $(COMPILE_RMIC) -classpath $(SA_CLASSDIR) -d $(SA_CLASSDIR) sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer $(QUIETLY) echo $(SA_BUILD_VERSION_PROP)> $(SA_PROPERTIES) $(QUIETLY) rm -f $(SA_CLASSDIR)/sun/jvm/hotspot/utilities/soql/sa.js
--- a/make/windows/projectfiles/common/Makefile Fri Sep 18 09:57:47 2009 -0700 +++ b/make/windows/projectfiles/common/Makefile Wed Sep 23 23:56:15 2009 -0700 @@ -179,6 +179,6 @@ $(HOTSPOTBUILDSPACE)/classes/MakeDeps.class: $(MakeDepsSources) @if exist $(HOTSPOTBUILDSPACE)\classes rmdir /s /q $(HOTSPOTBUILDSPACE)\classes @mkdir $(HOTSPOTBUILDSPACE)\classes - @$(COMPILE_JAVAC) -classpath $(HOTSPOTWORKSPACE)\src\share\tools\MakeDeps -g -d $(HOTSPOTBUILDSPACE)/classes $(MakeDepsSources) + @$(COMPILE_JAVAC) -classpath $(HOTSPOTWORKSPACE)\src\share\tools\MakeDeps -d $(HOTSPOTBUILDSPACE)/classes $(MakeDepsSources) FORCE:
--- a/src/cpu/sparc/vm/interp_masm_sparc.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/cpu/sparc/vm/interp_masm_sparc.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1696,6 +1696,9 @@ void InterpreterMacroAssembler::record_klass_in_profile_helper( Register receiver, Register scratch, int start_row, Label& done) { + if (TypeProfileWidth == 0) + return; + int last_row = VirtualCallData::row_limit() - 1; assert(start_row <= last_row, "must be work left to do"); // Test this row for both the receiver and for null.
--- a/src/cpu/x86/vm/interp_masm_x86_32.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/cpu/x86/vm/interp_masm_x86_32.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1262,6 +1262,9 @@ Register receiver, Register mdp, Register reg2, int start_row, Label& done) { + if (TypeProfileWidth == 0) + return; + int last_row = VirtualCallData::row_limit() - 1; assert(start_row <= last_row, "must be work left to do"); // Test this row for both the receiver and for null.
--- a/src/cpu/x86/vm/interp_masm_x86_64.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/cpu/x86/vm/interp_masm_x86_64.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1272,6 +1272,9 @@ Register receiver, Register mdp, Register reg2, int start_row, Label& done) { + if (TypeProfileWidth == 0) + return; + int last_row = VirtualCallData::row_limit() - 1; assert(start_row <= last_row, "must be work left to do"); // Test this row for both the receiver and for null.
--- a/src/os/windows/vm/os_windows.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/os/windows/vm/os_windows.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1526,7 +1526,8 @@ case 5000: st->print(" Windows 2000"); break; case 5001: st->print(" Windows XP"); break; case 5002: - case 6000: { + case 6000: + case 6001: { // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could // find out whether we are running on 64 bit processor or not. SYSTEM_INFO si; @@ -1549,13 +1550,27 @@ st->print(" Windows XP x64 Edition"); else st->print(" Windows Server 2003 family"); - } else { // os_vers == 6000 + } else if (os_vers == 6000) { if (osvi.wProductType == VER_NT_WORKSTATION) st->print(" Windows Vista"); else st->print(" Windows Server 2008"); if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) st->print(" , 64 bit"); + } else if (os_vers == 6001) { + if (osvi.wProductType == VER_NT_WORKSTATION) { + st->print(" Windows 7"); + } else { + // Unrecognized windows, print out its major and minor versions + st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); + } + if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) + st->print(" , 64 bit"); + } else { // future os + // Unrecognized windows, print out its major and minor versions + st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); + if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) + st->print(" , 64 bit"); } break; }
--- a/src/share/vm/adlc/archDesc.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/adlc/archDesc.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1031,7 +1031,8 @@ //---------------------------addSUNcopyright------------------------------- // output SUN copyright info void ArchDesc::addSunCopyright(char* legal, int size, FILE *fp) { - fwrite(legal, size, 1, fp); + size_t count = fwrite(legal, 1, size, fp); + assert(count == (size_t) size, "copyright info truncated"); fprintf(fp,"\n"); fprintf(fp,"// Machine Generated File. Do Not Edit!\n"); fprintf(fp,"\n");
--- a/src/share/vm/classfile/classFileParser.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/classfile/classFileParser.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -766,16 +766,16 @@ struct FieldAllocationCount { - int static_oop_count; - int static_byte_count; - int static_short_count; - int static_word_count; - int static_double_count; - int nonstatic_oop_count; - int nonstatic_byte_count; - int nonstatic_short_count; - int nonstatic_word_count; - int nonstatic_double_count; + unsigned int static_oop_count; + unsigned int static_byte_count; + unsigned int static_short_count; + unsigned int static_word_count; + unsigned int static_double_count; + unsigned int nonstatic_oop_count; + unsigned int nonstatic_byte_count; + unsigned int nonstatic_short_count; + unsigned int nonstatic_word_count; + unsigned int nonstatic_double_count; }; typeArrayHandle ClassFileParser::parse_fields(constantPoolHandle cp, bool is_interface, @@ -2547,6 +2547,7 @@ KlassHandle host_klass, GrowableArray<Handle>* cp_patches, symbolHandle& parsed_name, + bool verify, TRAPS) { // So that JVMTI can cache class file in the state before retransformable agents // have modified it @@ -2591,7 +2592,7 @@ instanceKlassHandle nullHandle; // Figure out whether we can skip format checking (matching classic VM behavior) - _need_verify = Verifier::should_verify_for(class_loader()); + _need_verify = Verifier::should_verify_for(class_loader(), verify); // Set the verify flag in stream cfs->set_verify(_need_verify); @@ -2908,11 +2909,11 @@ } // end of "discovered" field compactibility fix - int nonstatic_double_count = fac.nonstatic_double_count; - int nonstatic_word_count = fac.nonstatic_word_count; - int nonstatic_short_count = fac.nonstatic_short_count; - int nonstatic_byte_count = fac.nonstatic_byte_count; - int nonstatic_oop_count = fac.nonstatic_oop_count; + unsigned int nonstatic_double_count = fac.nonstatic_double_count; + unsigned int nonstatic_word_count = fac.nonstatic_word_count; + unsigned int nonstatic_short_count = fac.nonstatic_short_count; + unsigned int nonstatic_byte_count = fac.nonstatic_byte_count; + unsigned int nonstatic_oop_count = fac.nonstatic_oop_count; bool super_has_nonstatic_fields = (super_klass() != NULL && super_klass->has_nonstatic_fields()); @@ -2922,26 +2923,26 @@ nonstatic_oop_count) != 0); - // Prepare list of oops for oop maps generation. - u2* nonstatic_oop_offsets; - u2* nonstatic_oop_length; - int nonstatic_oop_map_count = 0; + // Prepare list of oops for oop map generation. + int* nonstatic_oop_offsets; + unsigned int* nonstatic_oop_counts; + unsigned int nonstatic_oop_map_count = 0; nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD( - THREAD, u2, nonstatic_oop_count+1); - nonstatic_oop_length = NEW_RESOURCE_ARRAY_IN_THREAD( - THREAD, u2, nonstatic_oop_count+1); + THREAD, int, nonstatic_oop_count + 1); + nonstatic_oop_counts = NEW_RESOURCE_ARRAY_IN_THREAD( + THREAD, unsigned int, nonstatic_oop_count + 1); // Add fake fields for java.lang.Class instances (also see above). // FieldsAllocationStyle and CompactFields values will be reset to default. if(class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) { java_lang_Class_fix_post(&next_nonstatic_field_offset); - nonstatic_oop_offsets[0] = (u2)first_nonstatic_field_offset; - int fake_oop_count = (( next_nonstatic_field_offset - - first_nonstatic_field_offset ) / heapOopSize); - nonstatic_oop_length [0] = (u2)fake_oop_count; - nonstatic_oop_map_count = 1; - nonstatic_oop_count -= fake_oop_count; + nonstatic_oop_offsets[0] = first_nonstatic_field_offset; + const uint fake_oop_count = (next_nonstatic_field_offset - + first_nonstatic_field_offset) / heapOopSize; + nonstatic_oop_counts[0] = fake_oop_count; + nonstatic_oop_map_count = 1; + nonstatic_oop_count -= fake_oop_count; first_nonstatic_oop_offset = first_nonstatic_field_offset; } else { first_nonstatic_oop_offset = 0; // will be set for first oop field @@ -3119,13 +3120,15 @@ // Update oop maps if( nonstatic_oop_map_count > 0 && nonstatic_oop_offsets[nonstatic_oop_map_count - 1] == - (u2)(real_offset - nonstatic_oop_length[nonstatic_oop_map_count - 1] * heapOopSize) ) { + real_offset - + int(nonstatic_oop_counts[nonstatic_oop_map_count - 1]) * + heapOopSize ) { // Extend current oop map - nonstatic_oop_length[nonstatic_oop_map_count - 1] += 1; + nonstatic_oop_counts[nonstatic_oop_map_count - 1] += 1; } else { // Create new oop map - nonstatic_oop_offsets[nonstatic_oop_map_count] = (u2)real_offset; - nonstatic_oop_length [nonstatic_oop_map_count] = 1; + nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset; + nonstatic_oop_counts [nonstatic_oop_map_count] = 1; nonstatic_oop_map_count += 1; if( first_nonstatic_oop_offset == 0 ) { // Undefined first_nonstatic_oop_offset = real_offset; @@ -3182,8 +3185,10 @@ assert(instance_size == align_object_size(align_size_up((instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize), wordSize) / wordSize), "consistent layout helper value"); - // Size of non-static oop map blocks (in words) allocated at end of klass - int nonstatic_oop_map_size = compute_oop_map_size(super_klass, nonstatic_oop_map_count, first_nonstatic_oop_offset); + // Number of non-static oop map blocks allocated at end of klass. + const unsigned int total_oop_map_count = + compute_oop_map_count(super_klass, nonstatic_oop_map_count, + first_nonstatic_oop_offset); // Compute reference type ReferenceType rt; @@ -3194,17 +3199,19 @@ } // We can now create the basic klassOop for this klass - klassOop ik = oopFactory::new_instanceKlass( - vtable_size, itable_size, - static_field_size, nonstatic_oop_map_size, - rt, CHECK_(nullHandle)); + klassOop ik = oopFactory::new_instanceKlass(vtable_size, itable_size, + static_field_size, + total_oop_map_count, + rt, CHECK_(nullHandle)); instanceKlassHandle this_klass (THREAD, ik); - assert(this_klass->static_field_size() == static_field_size && - this_klass->nonstatic_oop_map_size() == nonstatic_oop_map_size, "sanity check"); + assert(this_klass->static_field_size() == static_field_size, "sanity"); + assert(this_klass->nonstatic_oop_map_count() == total_oop_map_count, + "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); assert(this_klass->oop_is_instance(), "layout is correct"); @@ -3282,7 +3289,7 @@ klassItable::setup_itable_offset_table(this_klass); // Do final class setup - fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_length); + fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_counts); set_precomputed_flags(this_klass); @@ -3375,66 +3382,73 @@ } -int ClassFileParser::compute_oop_map_size(instanceKlassHandle super, int nonstatic_oop_map_count, int first_nonstatic_oop_offset) { - int map_size = super.is_null() ? 0 : super->nonstatic_oop_map_size(); +unsigned int +ClassFileParser::compute_oop_map_count(instanceKlassHandle super, + unsigned int nonstatic_oop_map_count, + int first_nonstatic_oop_offset) { + unsigned int map_count = + super.is_null() ? 0 : super->nonstatic_oop_map_count(); if (nonstatic_oop_map_count > 0) { // We have oops to add to map - if (map_size == 0) { - map_size = nonstatic_oop_map_count; + if (map_count == 0) { + map_count = nonstatic_oop_map_count; } else { - // Check whether we should add a new map block or whether the last one can be extended - OopMapBlock* first_map = super->start_of_nonstatic_oop_maps(); - OopMapBlock* last_map = first_map + map_size - 1; - - int next_offset = last_map->offset() + (last_map->length() * heapOopSize); + // Check whether we should add a new map block or whether the last one can + // be extended + OopMapBlock* const first_map = super->start_of_nonstatic_oop_maps(); + OopMapBlock* const last_map = first_map + map_count - 1; + + int next_offset = last_map->offset() + last_map->count() * heapOopSize; if (next_offset == first_nonstatic_oop_offset) { // There is no gap bettwen superklass's last oop field and first // local oop field, merge maps. nonstatic_oop_map_count -= 1; } else { // Superklass didn't end with a oop field, add extra maps - assert(next_offset<first_nonstatic_oop_offset, "just checking"); + assert(next_offset < first_nonstatic_oop_offset, "just checking"); } - map_size += nonstatic_oop_map_count; + map_count += nonstatic_oop_map_count; } } - return map_size; + return map_count; } void ClassFileParser::fill_oop_maps(instanceKlassHandle k, - int nonstatic_oop_map_count, - u2* nonstatic_oop_offsets, u2* nonstatic_oop_length) { + unsigned int nonstatic_oop_map_count, + int* nonstatic_oop_offsets, + unsigned int* nonstatic_oop_counts) { OopMapBlock* this_oop_map = k->start_of_nonstatic_oop_maps(); - OopMapBlock* last_oop_map = this_oop_map + k->nonstatic_oop_map_size(); - instanceKlass* super = k->superklass(); - if (super != NULL) { - int super_oop_map_size = super->nonstatic_oop_map_size(); + const instanceKlass* const super = k->superklass(); + const unsigned int super_count = super ? super->nonstatic_oop_map_count() : 0; + if (super_count > 0) { + // Copy maps from superklass OopMapBlock* super_oop_map = super->start_of_nonstatic_oop_maps(); - // Copy maps from superklass - while (super_oop_map_size-- > 0) { + for (unsigned int i = 0; i < super_count; ++i) { *this_oop_map++ = *super_oop_map++; } } + if (nonstatic_oop_map_count > 0) { - if (this_oop_map + nonstatic_oop_map_count > last_oop_map) { - // Calculated in compute_oop_map_size() number of oop maps is less then - // collected oop maps since there is no gap between superklass's last oop - // field and first local oop field. Extend the last oop map copied + if (super_count + nonstatic_oop_map_count > k->nonstatic_oop_map_count()) { + // The counts differ because there is no gap between superklass's last oop + // field and the first local oop field. Extend the last oop map copied // from the superklass instead of creating new one. nonstatic_oop_map_count--; nonstatic_oop_offsets++; this_oop_map--; - this_oop_map->set_length(this_oop_map->length() + *nonstatic_oop_length++); + this_oop_map->set_count(this_oop_map->count() + *nonstatic_oop_counts++); this_oop_map++; } - assert((this_oop_map + nonstatic_oop_map_count) == last_oop_map, "just checking"); + // Add new map blocks, fill them while (nonstatic_oop_map_count-- > 0) { this_oop_map->set_offset(*nonstatic_oop_offsets++); - this_oop_map->set_length(*nonstatic_oop_length++); + this_oop_map->set_count(*nonstatic_oop_counts++); this_oop_map++; } + assert(k->start_of_nonstatic_oop_maps() + k->nonstatic_oop_map_count() == + this_oop_map, "sanity"); } }
--- a/src/share/vm/classfile/classFileParser.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/classfile/classFileParser.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -125,10 +125,13 @@ int runtime_invisible_annotations_length, TRAPS); // Final setup - int compute_oop_map_size(instanceKlassHandle super, int nonstatic_oop_count, - int first_nonstatic_oop_offset); - void fill_oop_maps(instanceKlassHandle k, int nonstatic_oop_map_count, - u2* nonstatic_oop_offsets, u2* nonstatic_oop_length); + unsigned int compute_oop_map_count(instanceKlassHandle super, + unsigned int nonstatic_oop_count, + int first_nonstatic_oop_offset); + void fill_oop_maps(instanceKlassHandle k, + unsigned int nonstatic_oop_map_count, + int* nonstatic_oop_offsets, + unsigned int* nonstatic_oop_counts); void set_precomputed_flags(instanceKlassHandle k); objArrayHandle compute_transitive_interfaces(instanceKlassHandle super, objArrayHandle local_ifs, TRAPS); @@ -257,9 +260,10 @@ Handle class_loader, Handle protection_domain, symbolHandle& parsed_name, + bool verify, TRAPS) { KlassHandle no_host_klass; - return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, THREAD); + return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD); } instanceKlassHandle parseClassFile(symbolHandle name, Handle class_loader, @@ -267,6 +271,7 @@ KlassHandle host_klass, GrowableArray<Handle>* cp_patches, symbolHandle& parsed_name, + bool verify, TRAPS); // Verifier checks
--- a/src/share/vm/classfile/classLoader.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/classfile/classLoader.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -874,6 +874,7 @@ class_loader, protection_domain, parsed_name, + false, CHECK_(h)); // add to package table
--- a/src/share/vm/classfile/systemDictionary.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/classfile/systemDictionary.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -970,6 +970,7 @@ host_klass, cp_patches, parsed_name, + true, THREAD); @@ -1025,6 +1026,7 @@ Handle class_loader, Handle protection_domain, ClassFileStream* st, + bool verify, TRAPS) { // Classloaders that support parallelism, e.g. bootstrap classloader, @@ -1055,6 +1057,7 @@ class_loader, protection_domain, parsed_name, + verify, THREAD); const char* pkg = "java/";
--- a/src/share/vm/classfile/systemDictionary.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/classfile/systemDictionary.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -259,7 +259,9 @@ TRAPS); // Resolve from stream (called by jni_DefineClass and JVM_DefineClass) - static klassOop resolve_from_stream(symbolHandle class_name, Handle class_loader, Handle protection_domain, ClassFileStream* st, TRAPS); + static klassOop resolve_from_stream(symbolHandle class_name, Handle class_loader, + Handle protection_domain, + ClassFileStream* st, bool verify, TRAPS); // Lookup an already loaded class. If not found NULL is returned. static klassOop find(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS);
--- a/src/share/vm/classfile/verifier.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/classfile/verifier.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -53,8 +53,8 @@ // Methods in Verifier -bool Verifier::should_verify_for(oop class_loader) { - return class_loader == NULL ? +bool Verifier::should_verify_for(oop class_loader, bool should_verify_class) { + return (class_loader == NULL || !should_verify_class) ? BytecodeVerificationLocal : BytecodeVerificationRemote; } @@ -68,7 +68,7 @@ return !need_verify; } -bool Verifier::verify(instanceKlassHandle klass, Verifier::Mode mode, TRAPS) { +bool Verifier::verify(instanceKlassHandle klass, Verifier::Mode mode, bool should_verify_class, TRAPS) { ResourceMark rm(THREAD); HandleMark hm; @@ -81,7 +81,7 @@ // If the class should be verified, first see if we can use the split // verifier. If not, or if verification fails and FailOverToOldVerifier // is set, then call the inference verifier. - if (is_eligible_for_verification(klass)) { + if (is_eligible_for_verification(klass, should_verify_class)) { if (TraceClassInitialization) { tty->print_cr("Start class verification for: %s", klassName); } @@ -141,12 +141,13 @@ } } -bool Verifier::is_eligible_for_verification(instanceKlassHandle klass) { +bool Verifier::is_eligible_for_verification(instanceKlassHandle klass, bool should_verify_class) { symbolOop name = klass->name(); klassOop refl_magic_klass = SystemDictionary::reflect_magic_klass(); - return (should_verify_for(klass->class_loader()) && + return (should_verify_for(klass->class_loader(), should_verify_class) && // return if the class is a bootstrapping class + // or defineClass specified not to verify by default (flags override passed arg) // We need to skip the following four for bootstraping name != vmSymbols::java_lang_Object() && name != vmSymbols::java_lang_Class() &&
--- a/src/share/vm/classfile/verifier.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/classfile/verifier.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -34,16 +34,18 @@ * Otherwise, no exception is thrown and the return indicates the * error. */ - static bool verify(instanceKlassHandle klass, Mode mode, TRAPS); + static bool verify(instanceKlassHandle klass, Mode mode, bool should_verify_class, TRAPS); - // Return false if the class is loaded by the bootstrap loader. - static bool should_verify_for(oop class_loader); + // Return false if the class is loaded by the bootstrap loader, + // or if defineClass was called requesting skipping verification + // -Xverify:all/none override this value + static bool should_verify_for(oop class_loader, bool should_verify_class); // Relax certain verifier checks to enable some broken 1.1 apps to run on 1.2. static bool relax_verify_for(oop class_loader); private: - static bool is_eligible_for_verification(instanceKlassHandle klass); + static bool is_eligible_for_verification(instanceKlassHandle klass, bool should_verify_class); static symbolHandle inference_verify( instanceKlassHandle klass, char* msg, size_t msg_len, TRAPS); };
--- a/src/share/vm/code/nmethod.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/code/nmethod.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1100,6 +1100,10 @@ if (!Universe::heap()->is_gc_active()) cause->klass()->print(); } + // Unlink the osr method, so we do not look this up again + if (is_osr_method()) { + invalidate_osr_method(); + } // If _method is already NULL the methodOop is about to be unloaded, // so we don't have to break the cycle. Note that it is possible to // have the methodOop live here, in case we unload the nmethod because @@ -1170,7 +1174,7 @@ // will never be used anymore. That the nmethods only gets removed when class unloading // happens, make life much simpler, since the nmethods are not just going to disappear // out of the blue. - if (is_osr_only_method()) { + if (is_osr_method()) { if (osr_entry_bci() != InvalidOSREntryBci) { // only log this once log_state_change(state); @@ -1549,6 +1553,17 @@ #endif // !PRODUCT } +// This method is called twice during GC -- once while +// tracing the "active" nmethods on thread stacks during +// the (strong) marking phase, and then again when walking +// the code cache contents during the weak roots processing +// phase. The two uses are distinguished by means of the +// do_nmethods() method in the closure "f" below -- which +// answers "yes" in the first case, and "no" in the second +// case. We want to walk the weak roots in the nmethod +// only in the second case. The weak roots in the nmethod +// are the oops in the ExceptionCache and the InlineCache +// oops. void nmethod::oops_do(OopClosure* f) { // make sure the oops ready to receive visitors assert(!is_zombie() && !is_unloaded(), @@ -1567,19 +1582,25 @@ // Compiled code f->do_oop((oop*) &_method); - ExceptionCache* ec = exception_cache(); - while(ec != NULL) { - f->do_oop((oop*)ec->exception_type_addr()); - ec = ec->next(); - } + if (!f->do_nmethods()) { + // weak roots processing phase -- update ExceptionCache oops + ExceptionCache* ec = exception_cache(); + while(ec != NULL) { + f->do_oop((oop*)ec->exception_type_addr()); + ec = ec->next(); + } + } // Else strong roots phase -- skip oops in ExceptionCache RelocIterator iter(this, low_boundary); + while (iter.next()) { if (iter.type() == relocInfo::oop_type ) { oop_Relocation* r = iter.oop_reloc(); // In this loop, we must only follow those oops directly embedded in // the code. Other oops (oop_index>0) are seen as part of scopes_oops. - assert(1 == (r->oop_is_immediate()) + (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()), "oop must be found in exactly one place"); + assert(1 == (r->oop_is_immediate()) + + (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()), + "oop must be found in exactly one place"); if (r->oop_is_immediate() && r->oop_value() != NULL) { f->do_oop(r->oop_addr()); }
--- a/src/share/vm/code/nmethod.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/code/nmethod.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -321,7 +321,6 @@ bool is_java_method() const { return !method()->is_native(); } bool is_native_method() const { return method()->is_native(); } bool is_osr_method() const { return _entry_bci != InvocationEntryBci; } - bool is_osr_only_method() const { return is_osr_method(); } bool is_compiled_by_c1() const; bool is_compiled_by_c2() const;
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -88,17 +88,50 @@ } }; +// KlassRememberingOopClosure is used when marking of the permanent generation +// is being done. It adds fields to support revisiting of klasses +// for class unloading. _should_remember_klasses should be set to +// indicate if klasses should be remembered. Currently that is whenever +// CMS class unloading is turned on. The _revisit_stack is used +// to save the klasses for later processing. +class KlassRememberingOopClosure : public OopClosure { + protected: + CMSCollector* _collector; + CMSMarkStack* _revisit_stack; + bool const _should_remember_klasses; + public: + void check_remember_klasses() const PRODUCT_RETURN; + virtual const bool should_remember_klasses() const { + check_remember_klasses(); + return _should_remember_klasses; + } + virtual void remember_klass(Klass* k); + + KlassRememberingOopClosure(CMSCollector* collector, + ReferenceProcessor* rp, + CMSMarkStack* revisit_stack); +}; + +// Similar to KlassRememberingOopClosure for use when multiple +// GC threads will execute the closure. + +class Par_KlassRememberingOopClosure : public KlassRememberingOopClosure { + public: + Par_KlassRememberingOopClosure(CMSCollector* collector, + ReferenceProcessor* rp, + CMSMarkStack* revisit_stack): + KlassRememberingOopClosure(collector, rp, revisit_stack) {} + virtual void remember_klass(Klass* k); +}; + // The non-parallel version (the parallel version appears further below). -class PushAndMarkClosure: public OopClosure { +class PushAndMarkClosure: public KlassRememberingOopClosure { private: - CMSCollector* _collector; MemRegion _span; CMSBitMap* _bit_map; CMSBitMap* _mod_union_table; CMSMarkStack* _mark_stack; - CMSMarkStack* _revisit_stack; bool _concurrent_precleaning; - bool const _should_remember_klasses; protected: DO_OOP_WORK_DEFN public: @@ -118,10 +151,12 @@ Prefetch::style prefetch_style() { return Prefetch::do_read; } - virtual const bool should_remember_klasses() const { - return _should_remember_klasses; + // In support of class unloading + virtual const bool should_remember_mdo() const { + return false; + // return _should_remember_klasses; } - virtual void remember_klass(Klass* k); + virtual void remember_mdo(DataLayout* v); }; // In the parallel case, the revisit stack, the bit map and the @@ -130,14 +165,11 @@ // synchronization (for instance, via CAS). The marking stack // used in the non-parallel case above is here replaced with // an OopTaskQueue structure to allow efficient work stealing. -class Par_PushAndMarkClosure: public OopClosure { +class Par_PushAndMarkClosure: public Par_KlassRememberingOopClosure { private: - CMSCollector* _collector; MemRegion _span; CMSBitMap* _bit_map; OopTaskQueue* _work_queue; - CMSMarkStack* _revisit_stack; - bool const _should_remember_klasses; protected: DO_OOP_WORK_DEFN public: @@ -155,10 +187,12 @@ Prefetch::style prefetch_style() { return Prefetch::do_read; } - virtual const bool should_remember_klasses() const { - return _should_remember_klasses; + // In support of class unloading + virtual const bool should_remember_mdo() const { + return false; + // return _should_remember_klasses; } - virtual void remember_klass(Klass* k); + virtual void remember_mdo(DataLayout* v); }; // The non-parallel version (the parallel version appears further below). @@ -196,6 +230,12 @@ void set_freelistLock(Mutex* m) { _freelistLock = m; } + virtual const bool should_remember_klasses() const { + return _pushAndMarkClosure.should_remember_klasses(); + } + virtual void remember_klass(Klass* k) { + _pushAndMarkClosure.remember_klass(k); + } private: inline void do_yield_check(); @@ -229,6 +269,16 @@ inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } bool do_header() { return true; } virtual const bool do_nmethods() const { return true; } + // When ScanMarkedObjectsAgainClosure is used, + // it passes [Par_]MarkRefsIntoAndScanClosure to oop_oop_iterate(), + // and this delegation is used. + virtual const bool should_remember_klasses() const { + return _par_pushAndMarkClosure.should_remember_klasses(); + } + // See comment on should_remember_klasses() above. + virtual void remember_klass(Klass* k) { + _par_pushAndMarkClosure.remember_klass(k); + } Prefetch::style prefetch_style() { return Prefetch::do_read; } @@ -238,17 +288,14 @@ // This closure is used during the concurrent marking phase // following the first checkpoint. Its use is buried in // the closure MarkFromRootsClosure. -class PushOrMarkClosure: public OopClosure { +class PushOrMarkClosure: public KlassRememberingOopClosure { private: - CMSCollector* _collector; MemRegion _span; CMSBitMap* _bitMap; CMSMarkStack* _markStack; - CMSMarkStack* _revisitStack; HeapWord* const _finger; MarkFromRootsClosure* const _parent; - bool const _should_remember_klasses; protected: DO_OOP_WORK_DEFN public: @@ -263,10 +310,13 @@ virtual void do_oop(narrowOop* p); inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); } inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); } - virtual const bool should_remember_klasses() const { - return _should_remember_klasses; + // In support of class unloading + virtual const bool should_remember_mdo() const { + return false; + // return _should_remember_klasses; } - virtual void remember_klass(Klass* k); + virtual void remember_mdo(DataLayout* v); + // Deal with a stack overflow condition void handle_stack_overflow(HeapWord* lost); private: @@ -277,20 +327,17 @@ // This closure is used during the concurrent marking phase // following the first checkpoint. Its use is buried in // the closure Par_MarkFromRootsClosure. -class Par_PushOrMarkClosure: public OopClosure { +class Par_PushOrMarkClosure: public Par_KlassRememberingOopClosure { private: - CMSCollector* _collector; MemRegion _whole_span; MemRegion _span; // local chunk CMSBitMap* _bit_map; OopTaskQueue* _work_queue; CMSMarkStack* _overflow_stack; - CMSMarkStack* _revisit_stack; HeapWord* const _finger; HeapWord** const _global_finger_addr; Par_MarkFromRootsClosure* const _parent; - bool const _should_remember_klasses; protected: DO_OOP_WORK_DEFN public: @@ -307,10 +354,13 @@ virtual void do_oop(narrowOop* p); inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } - virtual const bool should_remember_klasses() const { - return _should_remember_klasses; + // In support of class unloading + virtual const bool should_remember_mdo() const { + return false; + // return _should_remember_klasses; } - virtual void remember_klass(Klass* k); + virtual void remember_mdo(DataLayout* v); + // Deal with a stack overflow condition void handle_stack_overflow(HeapWord* lost); private: @@ -323,9 +373,8 @@ // processing phase of the CMS final checkpoint step, as // well as during the concurrent precleaning of the discovered // reference lists. -class CMSKeepAliveClosure: public OopClosure { +class CMSKeepAliveClosure: public KlassRememberingOopClosure { private: - CMSCollector* _collector; const MemRegion _span; CMSMarkStack* _mark_stack; CMSBitMap* _bit_map; @@ -335,14 +384,7 @@ public: CMSKeepAliveClosure(CMSCollector* collector, MemRegion span, CMSBitMap* bit_map, CMSMarkStack* mark_stack, - bool cpc): - _collector(collector), - _span(span), - _bit_map(bit_map), - _mark_stack(mark_stack), - _concurrent_precleaning(cpc) { - assert(!_span.is_empty(), "Empty span could spell trouble"); - } + CMSMarkStack* revisit_stack, bool cpc); bool concurrent_precleaning() const { return _concurrent_precleaning; } virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); @@ -350,9 +392,8 @@ inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); } }; -class CMSInnerParMarkAndPushClosure: public OopClosure { +class CMSInnerParMarkAndPushClosure: public Par_KlassRememberingOopClosure { private: - CMSCollector* _collector; MemRegion _span; OopTaskQueue* _work_queue; CMSBitMap* _bit_map; @@ -361,11 +402,8 @@ public: CMSInnerParMarkAndPushClosure(CMSCollector* collector, MemRegion span, CMSBitMap* bit_map, - OopTaskQueue* work_queue): - _collector(collector), - _span(span), - _bit_map(bit_map), - _work_queue(work_queue) { } + CMSMarkStack* revisit_stack, + OopTaskQueue* work_queue); virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } @@ -375,9 +413,8 @@ // A parallel (MT) version of the above, used when // reference processing is parallel; the only difference // is in the do_oop method. -class CMSParKeepAliveClosure: public OopClosure { +class CMSParKeepAliveClosure: public Par_KlassRememberingOopClosure { private: - CMSCollector* _collector; MemRegion _span; OopTaskQueue* _work_queue; CMSBitMap* _bit_map; @@ -389,7 +426,8 @@ DO_OOP_WORK_DEFN public: CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span, - CMSBitMap* bit_map, OopTaskQueue* work_queue); + CMSBitMap* bit_map, CMSMarkStack* revisit_stack, + OopTaskQueue* work_queue); virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -37,16 +37,34 @@ } } -inline void PushOrMarkClosure::remember_klass(Klass* k) { - if (!_revisitStack->push(oop(k))) { +#ifndef PRODUCT +void KlassRememberingOopClosure::check_remember_klasses() const { + assert(_should_remember_klasses == must_remember_klasses(), + "Should remember klasses in this context."); +} +#endif + +void KlassRememberingOopClosure::remember_klass(Klass* k) { + if (!_revisit_stack->push(oop(k))) { fatal("Revisit stack overflow in PushOrMarkClosure"); } + check_remember_klasses(); } -inline void Par_PushOrMarkClosure::remember_klass(Klass* k) { +inline void PushOrMarkClosure::remember_mdo(DataLayout* v) { + // TBD +} + + +void Par_KlassRememberingOopClosure::remember_klass(Klass* k) { if (!_revisit_stack->par_push(oop(k))) { - fatal("Revisit stack overflow in PushOrMarkClosure"); + fatal("Revisit stack overflow in Par_KlassRememberingOopClosure"); } + check_remember_klasses(); +} + +inline void Par_PushOrMarkClosure::remember_mdo(DataLayout* v) { + // TBD } inline void PushOrMarkClosure::do_yield_check() {
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -2276,7 +2276,7 @@ VM_CMS_Final_Remark final_remark_op(this); VMThread::execute(&final_remark_op); - } + } assert(_foregroundGCShouldWait, "block post-condition"); break; case Sweeping: @@ -3505,6 +3505,7 @@ ref_processor()->set_enqueuing_is_done(false); { + // This is not needed. DEBUG_ONLY(RememberKlassesChecker imx(true);) COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. gch->gen_process_strong_roots(_cmsGen->level(), @@ -3632,6 +3633,8 @@ verify_overflow_empty(); assert(_revisitStack.isEmpty(), "tabula rasa"); + DEBUG_ONLY(RememberKlassesChecker cmx(CMSClassUnloadingEnabled);) + bool result = false; if (CMSConcurrentMTEnabled && ParallelCMSThreads > 0) { result = do_marking_mt(asynch); @@ -3967,24 +3970,24 @@ pst->all_tasks_completed(); } -class Par_ConcMarkingClosure: public OopClosure { +class Par_ConcMarkingClosure: public Par_KlassRememberingOopClosure { private: - CMSCollector* _collector; MemRegion _span; CMSBitMap* _bit_map; CMSMarkStack* _overflow_stack; - CMSMarkStack* _revisit_stack; // XXXXXX Check proper use OopTaskQueue* _work_queue; protected: DO_OOP_WORK_DEFN public: Par_ConcMarkingClosure(CMSCollector* collector, OopTaskQueue* work_queue, - CMSBitMap* bit_map, CMSMarkStack* overflow_stack): - _collector(collector), + CMSBitMap* bit_map, CMSMarkStack* overflow_stack, + CMSMarkStack* revisit_stack): + Par_KlassRememberingOopClosure(collector, NULL, revisit_stack), _span(_collector->_span), _work_queue(work_queue), _bit_map(bit_map), - _overflow_stack(overflow_stack) { } // need to initialize revisit stack etc. + _overflow_stack(overflow_stack) + { } virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); void trim_queue(size_t max); @@ -4072,8 +4075,9 @@ oop obj_to_scan; CMSBitMap* bm = &(_collector->_markBitMap); CMSMarkStack* ovflw = &(_collector->_markStack); + CMSMarkStack* revisit = &(_collector->_revisitStack); int* seed = _collector->hash_seed(i); - Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw); + Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw, revisit); while (true) { cl.trim_queue(0); assert(work_q->size() == 0, "Should have been emptied above"); @@ -4098,6 +4102,7 @@ assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), "CMS thread should hold CMS token"); + DEBUG_ONLY(RememberKlassesChecker mux(false);) // First give up the locks, then yield, then re-lock // We should probably use a constructor/destructor idiom to // do this unlock/lock or modify the MutexUnlocker class to @@ -4174,6 +4179,8 @@ // multi-threaded marking phase. ReferenceProcessorMTMutator mt(ref_processor(), num_workers > 1); + DEBUG_ONLY(RememberKlassesChecker cmx(CMSClassUnloadingEnabled);) + conc_workers()->start_task(&tsk); while (tsk.yielded()) { tsk.coordinator_yield(); @@ -4413,7 +4420,8 @@ CMSPrecleanRefsYieldClosure yield_cl(this); assert(rp->span().equals(_span), "Spans should be equal"); CMSKeepAliveClosure keep_alive(this, _span, &_markBitMap, - &_markStack, true /* preclean */); + &_markStack, &_revisitStack, + true /* preclean */); CMSDrainMarkingStackClosure complete_trace(this, _span, &_markBitMap, &_markStack, &keep_alive, true /* preclean */); @@ -4433,6 +4441,7 @@ bitMapLock()); startTimer(); sample_eden(); + // The following will yield to allow foreground // collection to proceed promptly. XXX YSR: // The code in this method may need further @@ -4462,6 +4471,7 @@ SurvivorSpacePrecleanClosure sss_cl(this, _span, &_markBitMap, &_markStack, &pam_cl, before_count, CMSYield); + DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);) dng->from()->object_iterate_careful(&sss_cl); dng->to()->object_iterate_careful(&sss_cl); } @@ -4563,6 +4573,13 @@ verify_work_stacks_empty(); verify_overflow_empty(); + // Turn off checking for this method but turn it back on + // selectively. There are yield points in this method + // but it is difficult to turn the checking off just around + // the yield points. It is simpler to selectively turn + // it on. + DEBUG_ONLY(RememberKlassesChecker mux(false);) + // strategy: starting with the first card, accumulate contiguous // ranges of dirty cards; clear these cards, then scan the region // covered by these cards. @@ -4591,6 +4608,7 @@ MemRegion dirtyRegion; { stopTimer(); + // Potential yield point CMSTokenSync ts(true); startTimer(); sample_eden(); @@ -4616,6 +4634,7 @@ assert(numDirtyCards > 0, "consistency check"); HeapWord* stop_point = NULL; stopTimer(); + // Potential yield point CMSTokenSyncWithLocks ts(true, gen->freelistLock(), bitMapLock()); startTimer(); @@ -4623,6 +4642,7 @@ verify_work_stacks_empty(); verify_overflow_empty(); sample_eden(); + DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);) stop_point = gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); } @@ -4710,6 +4730,7 @@ sample_eden(); verify_work_stacks_empty(); verify_overflow_empty(); + DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);) HeapWord* stop_point = gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); if (stop_point != NULL) { @@ -4809,6 +4830,7 @@ assert(haveFreelistLocks(), "must have free list locks"); assert_lock_strong(bitMapLock()); + DEBUG_ONLY(RememberKlassesChecker fmx(CMSClassUnloadingEnabled);) if (!init_mark_was_synchronous) { // We might assume that we need not fill TLAB's when // CMSScavengeBeforeRemark is set, because we may have just done @@ -4912,6 +4934,9 @@ _markStack._hit_limit = 0; _markStack._failed_double = 0; + // Check that all the klasses have been checked + assert(_revisitStack.isEmpty(), "Not all klasses revisited"); + if ((VerifyAfterGC || VerifyDuringGC) && GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { verify_after_remark(); @@ -5597,9 +5622,13 @@ void CMSRefProcTaskProxy::work(int i) { assert(_collector->_span.equals(_span), "Inconsistency in _span"); CMSParKeepAliveClosure par_keep_alive(_collector, _span, - _mark_bit_map, work_queue(i)); + _mark_bit_map, + &_collector->_revisitStack, + work_queue(i)); CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span, - _mark_bit_map, work_queue(i)); + _mark_bit_map, + &_collector->_revisitStack, + work_queue(i)); CMSIsAliveClosure is_alive_closure(_span, _mark_bit_map); _task.work(i, is_alive_closure, par_keep_alive, par_drain_stack); if (_task.marks_oops_alive()) { @@ -5627,12 +5656,13 @@ }; CMSParKeepAliveClosure::CMSParKeepAliveClosure(CMSCollector* collector, - MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue): - _collector(collector), + MemRegion span, CMSBitMap* bit_map, CMSMarkStack* revisit_stack, + OopTaskQueue* work_queue): + Par_KlassRememberingOopClosure(collector, NULL, revisit_stack), _span(span), _bit_map(bit_map), _work_queue(work_queue), - _mark_and_push(collector, span, bit_map, work_queue), + _mark_and_push(collector, span, bit_map, revisit_stack, work_queue), _low_water_mark(MIN2((uint)(work_queue->max_elems()/4), (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads))) { } @@ -5719,7 +5749,8 @@ verify_work_stacks_empty(); CMSKeepAliveClosure cmsKeepAliveClosure(this, _span, &_markBitMap, - &_markStack, false /* !preclean */); + &_markStack, &_revisitStack, + false /* !preclean */); CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this, _span, &_markBitMap, &_markStack, &cmsKeepAliveClosure, false /* !preclean */); @@ -6554,6 +6585,7 @@ assert_lock_strong(_freelistLock); assert_lock_strong(_bit_map->lock()); // relinquish the free_list_lock and bitMaplock() + DEBUG_ONLY(RememberKlassesChecker mux(false);) _bit_map->lock()->unlock(); _freelistLock->unlock(); ConcurrentMarkSweepThread::desynchronize(true); @@ -6726,6 +6758,7 @@ "CMS thread should hold CMS token"); assert_lock_strong(_freelistLock); assert_lock_strong(_bitMap->lock()); + DEBUG_ONLY(RememberKlassesChecker mux(false);) // relinquish the free_list_lock and bitMaplock() _bitMap->lock()->unlock(); _freelistLock->unlock(); @@ -6802,6 +6835,7 @@ assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), "CMS thread should hold CMS token"); assert_lock_strong(_bit_map->lock()); + DEBUG_ONLY(RememberKlassesChecker smx(false);) // Relinquish the bit map lock _bit_map->lock()->unlock(); ConcurrentMarkSweepThread::desynchronize(true); @@ -6964,6 +6998,7 @@ assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), "CMS thread should hold CMS token"); assert_lock_strong(_bitMap->lock()); + DEBUG_ONLY(RememberKlassesChecker mux(false);) _bitMap->lock()->unlock(); ConcurrentMarkSweepThread::desynchronize(true); ConcurrentMarkSweepThread::acknowledge_yield_request(); @@ -7318,15 +7353,12 @@ CMSBitMap* bitMap, CMSMarkStack* markStack, CMSMarkStack* revisitStack, HeapWord* finger, MarkFromRootsClosure* parent) : - OopClosure(collector->ref_processor()), - _collector(collector), + KlassRememberingOopClosure(collector, collector->ref_processor(), revisitStack), _span(span), _bitMap(bitMap), _markStack(markStack), - _revisitStack(revisitStack), _finger(finger), - _parent(parent), - _should_remember_klasses(collector->should_unload_classes()) + _parent(parent) { } Par_PushOrMarkClosure::Par_PushOrMarkClosure(CMSCollector* collector, @@ -7338,18 +7370,17 @@ HeapWord* finger, HeapWord** global_finger_addr, Par_MarkFromRootsClosure* parent) : - OopClosure(collector->ref_processor()), - _collector(collector), + Par_KlassRememberingOopClosure(collector, + collector->ref_processor(), + revisit_stack), _whole_span(collector->_span), _span(span), _bit_map(bit_map), _work_queue(work_queue), _overflow_stack(overflow_stack), - _revisit_stack(revisit_stack), _finger(finger), _global_finger_addr(global_finger_addr), - _parent(parent), - _should_remember_klasses(collector->should_unload_classes()) + _parent(parent) { } // Assumes thread-safe access by callers, who are @@ -7479,6 +7510,14 @@ void Par_PushOrMarkClosure::do_oop(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } +KlassRememberingOopClosure::KlassRememberingOopClosure(CMSCollector* collector, + ReferenceProcessor* rp, + CMSMarkStack* revisit_stack) : + OopClosure(rp), + _collector(collector), + _revisit_stack(revisit_stack), + _should_remember_klasses(collector->should_unload_classes()) {} + PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector, MemRegion span, ReferenceProcessor* rp, @@ -7487,15 +7526,12 @@ CMSMarkStack* mark_stack, CMSMarkStack* revisit_stack, bool concurrent_precleaning): - OopClosure(rp), - _collector(collector), + KlassRememberingOopClosure(collector, rp, revisit_stack), _span(span), _bit_map(bit_map), _mod_union_table(mod_union_table), _mark_stack(mark_stack), - _revisit_stack(revisit_stack), - _concurrent_precleaning(concurrent_precleaning), - _should_remember_klasses(collector->should_unload_classes()) + _concurrent_precleaning(concurrent_precleaning) { assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); } @@ -7563,13 +7599,10 @@ CMSBitMap* bit_map, OopTaskQueue* work_queue, CMSMarkStack* revisit_stack): - OopClosure(rp), - _collector(collector), + Par_KlassRememberingOopClosure(collector, rp, revisit_stack), _span(span), _bit_map(bit_map), - _work_queue(work_queue), - _revisit_stack(revisit_stack), - _should_remember_klasses(collector->should_unload_classes()) + _work_queue(work_queue) { assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL"); } @@ -7622,19 +7655,16 @@ void Par_PushAndMarkClosure::do_oop(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); } void Par_PushAndMarkClosure::do_oop(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); } -void PushAndMarkClosure::remember_klass(Klass* k) { - if (!_revisit_stack->push(oop(k))) { - fatal("Revisit stack overflowed in PushAndMarkClosure"); - } -} - -void Par_PushAndMarkClosure::remember_klass(Klass* k) { - if (!_revisit_stack->par_push(oop(k))) { - fatal("Revist stack overflowed in Par_PushAndMarkClosure"); - } +void PushAndMarkClosure::remember_mdo(DataLayout* v) { + // TBD +} + +void Par_PushAndMarkClosure::remember_mdo(DataLayout* v) { + // TBD } void CMSPrecleanRefsYieldClosure::do_yield_work() { + DEBUG_ONLY(RememberKlassesChecker mux(false);) Mutex* bml = _collector->bitMapLock(); assert_lock_strong(bml); assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), @@ -8325,6 +8355,19 @@ (!_span.contains(addr) || _bit_map->isMarked(addr)); } +CMSKeepAliveClosure::CMSKeepAliveClosure( CMSCollector* collector, + MemRegion span, + CMSBitMap* bit_map, CMSMarkStack* mark_stack, + CMSMarkStack* revisit_stack, bool cpc): + KlassRememberingOopClosure(collector, NULL, revisit_stack), + _span(span), + _bit_map(bit_map), + _mark_stack(mark_stack), + _concurrent_precleaning(cpc) { + assert(!_span.is_empty(), "Empty span could spell trouble"); +} + + // CMSKeepAliveClosure: the serial version void CMSKeepAliveClosure::do_oop(oop obj) { HeapWord* addr = (HeapWord*)obj; @@ -8408,6 +8451,16 @@ } } +CMSInnerParMarkAndPushClosure::CMSInnerParMarkAndPushClosure( + CMSCollector* collector, + MemRegion span, CMSBitMap* bit_map, + CMSMarkStack* revisit_stack, + OopTaskQueue* work_queue): + Par_KlassRememberingOopClosure(collector, NULL, revisit_stack), + _span(span), + _bit_map(bit_map), + _work_queue(work_queue) { } + void CMSInnerParMarkAndPushClosure::do_oop(oop obj) { HeapWord* addr = (HeapWord*)obj; if (_span.contains(addr) &&
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -1790,12 +1790,13 @@ public: CMSParDrainMarkingStackClosure(CMSCollector* collector, MemRegion span, CMSBitMap* bit_map, + CMSMarkStack* revisit_stack, OopTaskQueue* work_queue): _collector(collector), _span(span), _bit_map(bit_map), _work_queue(work_queue), - _mark_and_push(collector, span, bit_map, work_queue) { } + _mark_and_push(collector, span, bit_map, revisit_stack, work_queue) { } public: void trim_queue(uint max);
--- a/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -39,7 +39,6 @@ _next(next), _cg1r(cg1r), _vtime_accum(0.0), - _co_tracker(G1CRGroup), _interval_ms(5.0) { create_and_start(); @@ -76,9 +75,6 @@ _vtime_start = os::elapsedVTime(); wait_for_universe_init(); - _co_tracker.enable(); - _co_tracker.start(); - while (!_should_terminate) { DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); // Wait for completed log buffers to exist. @@ -147,7 +143,6 @@ } break; } - _co_tracker.update(false); // Check if we need to activate the next thread. if (curr_buffer_num > next_threshold && _next != NULL && !_next->is_active()) { @@ -168,7 +163,6 @@ } n_logs++; } - _co_tracker.update(false); _sts.leave(); if (os::supports_vtime()) { @@ -177,9 +171,6 @@ _vtime_accum = 0.0; } } - _sts.join(); - _co_tracker.update(true); - _sts.leave(); assert(_should_terminate, "just checking"); terminate();
--- a/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -51,7 +51,6 @@ private: ConcurrentG1Refine* _cg1r; - COTracker _co_tracker; double _interval_ms; void decreaseInterval(int processing_time_ms) {
--- a/src/share/vm/gc_implementation/g1/concurrentMark.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -433,8 +433,7 @@ _total_counting_time(0.0), _total_rs_scrub_time(0.0), - _parallel_workers(NULL), - _cleanup_co_tracker(G1CLGroup) + _parallel_workers(NULL) { CMVerboseLevel verbose_level = (CMVerboseLevel) G1MarkingVerboseLevel; @@ -824,18 +823,6 @@ // when marking is on. So, it's also called at the end of the // initial-mark pause to update the heap end, if the heap expands // during it. No need to call it here. - - guarantee( !_cleanup_co_tracker.enabled(), "invariant" ); - - size_t max_marking_threads = - MAX2((size_t) 1, parallel_marking_threads()); - for (int i = 0; i < (int)_max_task_num; ++i) { - _tasks[i]->enable_co_tracker(); - if (i < (int) max_marking_threads) - _tasks[i]->reset_co_tracker(marking_task_overhead()); - else - _tasks[i]->reset_co_tracker(0.0); - } } // Checkpoint the roots into this generation from outside @@ -846,7 +833,6 @@ G1CollectedHeap* g1h = G1CollectedHeap::heap(); double start = os::elapsedTime(); - GCOverheadReporter::recordSTWStart(start); G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy(); g1p->record_concurrent_mark_init_start(); @@ -879,7 +865,6 @@ // Statistics. double end = os::elapsedTime(); _init_times.add((end - start) * 1000.0); - GCOverheadReporter::recordSTWEnd(end); g1p->record_concurrent_mark_init_end(); } @@ -1038,7 +1023,6 @@ guarantee( (size_t)worker_i < _cm->active_tasks(), "invariant" ); CMTask* the_task = _cm->task(worker_i); - the_task->start_co_tracker(); the_task->record_start_time(); if (!_cm->has_aborted()) { do { @@ -1064,8 +1048,6 @@ double end_time2_sec = os::elapsedTime(); double elapsed_time2_sec = end_time2_sec - start_time_sec; - the_task->update_co_tracker(); - #if 0 gclog_or_tty->print_cr("CM: elapsed %1.4lf ms, sleep %1.4lf ms, " "overhead %1.4lf", @@ -1082,7 +1064,6 @@ ConcurrentGCThread::stsLeave(); double end_vtime = os::elapsedVTime(); - the_task->update_co_tracker(true); _cm->update_accum_task_vtime(worker_i, end_vtime - start_vtime); } @@ -1136,7 +1117,6 @@ g1p->record_concurrent_mark_remark_start(); double start = os::elapsedTime(); - GCOverheadReporter::recordSTWStart(start); checkpointRootsFinalWork(); @@ -1176,11 +1156,6 @@ _remark_weak_ref_times.add((now - mark_work_end) * 1000.0); _remark_times.add((now - start) * 1000.0); - GCOverheadReporter::recordSTWEnd(now); - for (int i = 0; i < (int)_max_task_num; ++i) - _tasks[i]->disable_co_tracker(); - _cleanup_co_tracker.enable(); - _cleanup_co_tracker.reset(cleanup_task_overhead()); g1p->record_concurrent_mark_remark_end(); } @@ -1191,7 +1166,6 @@ CMBitMapRO* _bm; ConcurrentMark* _cm; - COTracker* _co_tracker; bool _changed; bool _yield; size_t _words_done; @@ -1219,12 +1193,10 @@ public: CalcLiveObjectsClosure(bool final, CMBitMapRO *bm, ConcurrentMark *cm, - BitMap* region_bm, BitMap* card_bm, - COTracker* co_tracker) : + BitMap* region_bm, BitMap* card_bm) : _bm(bm), _cm(cm), _changed(false), _yield(true), _words_done(0), _tot_live(0), _tot_used(0), - _region_bm(region_bm), _card_bm(card_bm), - _final(final), _co_tracker(co_tracker), + _region_bm(region_bm), _card_bm(card_bm),_final(final), _regions_done(0), _start_vtime_sec(0.0) { _bottom_card_num = @@ -1268,9 +1240,6 @@ } bool doHeapRegion(HeapRegion* hr) { - if (_co_tracker != NULL) - _co_tracker->update(); - if (!_final && _regions_done == 0) _start_vtime_sec = os::elapsedVTime(); @@ -1399,12 +1368,6 @@ if (elapsed_vtime_sec > (10.0 / 1000.0)) { jlong sleep_time_ms = (jlong) (elapsed_vtime_sec * _cm->cleanup_sleep_factor() * 1000.0); -#if 0 - gclog_or_tty->print_cr("CL: elapsed %1.4lf ms, sleep %1.4lf ms, " - "overhead %1.4lf", - elapsed_vtime_sec * 1000.0, (double) sleep_time_ms, - _co_tracker->concOverhead(os::elapsedTime())); -#endif os::sleep(Thread::current(), sleep_time_ms, false); _start_vtime_sec = end_vtime_sec; } @@ -1424,15 +1387,11 @@ void ConcurrentMark::calcDesiredRegions() { - guarantee( _cleanup_co_tracker.enabled(), "invariant" ); - _cleanup_co_tracker.start(); - _region_bm.clear(); _card_bm.clear(); CalcLiveObjectsClosure calccl(false /*final*/, nextMarkBitMap(), this, - &_region_bm, &_card_bm, - &_cleanup_co_tracker); + &_region_bm, &_card_bm); G1CollectedHeap *g1h = G1CollectedHeap::heap(); g1h->heap_region_iterate(&calccl); @@ -1440,8 +1399,6 @@ calccl.reset(); g1h->heap_region_iterate(&calccl); } while (calccl.changed()); - - _cleanup_co_tracker.update(true); } class G1ParFinalCountTask: public AbstractGangTask { @@ -1475,8 +1432,7 @@ void work(int i) { CalcLiveObjectsClosure calccl(true /*final*/, _bm, _g1h->concurrent_mark(), - _region_bm, _card_bm, - NULL /* CO tracker */); + _region_bm, _card_bm); calccl.no_yield(); if (ParallelGCThreads > 0) { _g1h->heap_region_par_iterate_chunked(&calccl, i, @@ -1666,13 +1622,10 @@ /* prev marking */ true); } - _cleanup_co_tracker.disable(); - G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy(); g1p->record_concurrent_mark_cleanup_start(); double start = os::elapsedTime(); - GCOverheadReporter::recordSTWStart(start); // Do counting once more with the world stopped for good measure. G1ParFinalCountTask g1_par_count_task(g1h, nextMarkBitMap(), @@ -1777,7 +1730,6 @@ // Statistics. double end = os::elapsedTime(); _cleanup_times.add((end - start) * 1000.0); - GCOverheadReporter::recordSTWEnd(end); // G1CollectedHeap::heap()->print(); // gclog_or_tty->print_cr("HEAP GC TIME STAMP : %d", @@ -2628,24 +2580,6 @@ _should_gray_objects = true; } -void ConcurrentMark::disable_co_trackers() { - if (has_aborted()) { - if (_cleanup_co_tracker.enabled()) - _cleanup_co_tracker.disable(); - for (int i = 0; i < (int)_max_task_num; ++i) { - CMTask* task = _tasks[i]; - if (task->co_tracker_enabled()) - task->disable_co_tracker(); - } - } else { - guarantee( !_cleanup_co_tracker.enabled(), "invariant" ); - for (int i = 0; i < (int)_max_task_num; ++i) { - CMTask* task = _tasks[i]; - guarantee( !task->co_tracker_enabled(), "invariant" ); - } - } -} - // abandon current marking iteration due to a Full GC void ConcurrentMark::abort() { // Clear all marks to force marking thread to do nothing @@ -4021,7 +3955,6 @@ CMTaskQueue* task_queue, CMTaskQueueSet* task_queues) : _g1h(G1CollectedHeap::heap()), - _co_tracker(G1CMGroup), _task_id(task_id), _cm(cm), _claimed(false), _nextMarkBitMap(NULL), _hash_seed(17),
--- a/src/share/vm/gc_implementation/g1/concurrentMark.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -407,8 +407,6 @@ // verbose level CMVerboseLevel _verbose_level; - COTracker _cleanup_co_tracker; - // 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. @@ -720,8 +718,6 @@ // Called to abort the marking cycle after a Full GC takes palce. void abort(); - void disable_co_trackers(); - // This prints the global/local fingers. It is used for debugging. NOT_PRODUCT(void print_finger();) @@ -773,9 +769,6 @@ // number of calls to this task int _calls; - // concurrent overhead over a single CPU for this task - COTracker _co_tracker; - // when the virtual timer reaches this time, the marking step should // exit double _time_target_ms; @@ -928,27 +921,6 @@ void set_concurrent(bool concurrent) { _concurrent = concurrent; } - void enable_co_tracker() { - guarantee( !_co_tracker.enabled(), "invariant" ); - _co_tracker.enable(); - } - void disable_co_tracker() { - guarantee( _co_tracker.enabled(), "invariant" ); - _co_tracker.disable(); - } - bool co_tracker_enabled() { - return _co_tracker.enabled(); - } - void reset_co_tracker(double starting_conc_overhead = 0.0) { - _co_tracker.reset(starting_conc_overhead); - } - void start_co_tracker() { - _co_tracker.start(); - } - void update_co_tracker(bool force_end = false) { - _co_tracker.update(force_end); - } - // The main method of this class which performs a marking step // trying not to exceed the given duration. However, it might exit // prematurely, according to some conditions (i.e. SATB buffers are
--- a/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -260,10 +260,6 @@ } } - _sts.join(); - _cm->disable_co_trackers(); - _sts.leave(); - // we now want to allow clearing of the marking bitmap to be // suspended by a collection pause. _sts.join();
--- a/src/share/vm/gc_implementation/g1/concurrentZFThread.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentZFThread.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -35,8 +35,7 @@ int ConcurrentZFThread::_regions_filled = 0; ConcurrentZFThread::ConcurrentZFThread() : - ConcurrentGCThread(), - _co_tracker(G1ZFGroup) + ConcurrentGCThread() { create_and_start(); } @@ -71,8 +70,6 @@ Thread* thr_self = Thread::current(); _vtime_start = os::elapsedVTime(); wait_for_universe_init(); - _co_tracker.enable(); - _co_tracker.start(); G1CollectedHeap* g1 = G1CollectedHeap::heap(); _sts.join(); @@ -135,10 +132,7 @@ } _vtime_accum = (os::elapsedVTime() - _vtime_start); _sts.join(); - - _co_tracker.update(); } - _co_tracker.update(false); _sts.leave(); assert(_should_terminate, "just checking");
--- a/src/share/vm/gc_implementation/g1/concurrentZFThread.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentZFThread.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -42,8 +42,6 @@ // Number of regions CFZ thread fills. static int _regions_filled; - COTracker _co_tracker; - double _vtime_start; // Initial virtual time. // These are static because the "print_summary_info" method is, and
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -25,6 +25,8 @@ #include "incls/_precompiled.incl" #include "incls/_g1CollectedHeap.cpp.incl" +size_t G1CollectedHeap::_humongous_object_threshold_in_words = 0; + // turn it on so that the contents of the young list (scan-only / // to-be-collected) are printed at "strategic" points before / during // / after the collection --- this is useful for debugging @@ -927,7 +929,6 @@ TraceTime t(full ? "Full GC (System.gc())" : "Full GC", PrintGC, true, gclog_or_tty); double start = os::elapsedTime(); - GCOverheadReporter::recordSTWStart(start); g1_policy()->record_full_collection_start(); gc_prologue(true); @@ -1049,7 +1050,6 @@ } double end = os::elapsedTime(); - GCOverheadReporter::recordSTWEnd(end); g1_policy()->record_full_collection_end(); #ifdef TRACESPINNING @@ -1396,6 +1396,9 @@ if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) { vm_exit_during_initialization("Failed necessary allocation."); } + + _humongous_object_threshold_in_words = HeapRegion::GrainWords / 2; + int n_queues = MAX2((int)ParallelGCThreads, 1); _task_queues = new RefToScanQueueSet(n_queues); @@ -1548,9 +1551,10 @@ const size_t max_region_idx = ((size_t)1 << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1; guarantee((max_regions() - 1) <= max_region_idx, "too many regions"); - const size_t cards_per_region = HeapRegion::GrainBytes >> CardTableModRefBS::card_shift; size_t max_cards_per_region = ((size_t)1 << (sizeof(CardIdx_t)*BitsPerByte-1)) - 1; - guarantee(cards_per_region < max_cards_per_region, "too many cards per region"); + guarantee(HeapRegion::CardsPerRegion > 0, "make sure it's initialized"); + guarantee((size_t) HeapRegion::CardsPerRegion < max_cards_per_region, + "too many cards per region"); _bot_shared = new G1BlockOffsetSharedArray(_reserved, heap_word_size(init_byte_size)); @@ -1610,9 +1614,6 @@ // Do later initialization work for concurrent refinement. _cg1r->init(); - const char* group_names[] = { "CR", "ZF", "CM", "CL" }; - GCOverheadReporter::initGCOverheadReporter(4, group_names); - return JNI_OK; } @@ -2434,8 +2435,6 @@ } g1_policy()->print_yg_surv_rate_info(); - GCOverheadReporter::printGCOverhead(); - SpecializationStats::print(); } @@ -2672,7 +2671,6 @@ // The elapsed time induced by the start time below deliberately elides // the possible verification above. double start_time_sec = os::elapsedTime(); - GCOverheadReporter::recordSTWStart(start_time_sec); size_t start_used_bytes = used(); g1_policy()->record_collection_pause_start(start_time_sec, @@ -2750,8 +2748,6 @@ _in_cset_fast_test = NULL; _in_cset_fast_test_base = NULL; - release_gc_alloc_regions(false /* totally */); - cleanup_surviving_young_words(); if (g1_policy()->in_young_gc_mode()) { @@ -2801,7 +2797,6 @@ double end_time_sec = os::elapsedTime(); double pause_time_ms = (end_time_sec - start_time_sec) * MILLIUNITS; g1_policy()->record_pause_time_ms(pause_time_ms); - GCOverheadReporter::recordSTWEnd(end_time_sec); g1_policy()->record_collection_pause_end(abandoned); assert(regions_accounted_for(), "Region leakage."); @@ -4152,6 +4147,7 @@ G1KeepAliveClosure keep_alive(this); JNIHandles::weak_oops_do(&is_alive, &keep_alive); } + release_gc_alloc_regions(false /* totally */); g1_rem_set()->cleanup_after_oops_into_collection_set_do(); concurrent_g1_refine()->clear_hot_cache(); @@ -4285,12 +4281,18 @@ class G1ParCleanupCTTask : public AbstractGangTask { CardTableModRefBS* _ct_bs; G1CollectedHeap* _g1h; + HeapRegion* volatile _so_head; + HeapRegion* volatile _su_head; public: G1ParCleanupCTTask(CardTableModRefBS* ct_bs, - G1CollectedHeap* g1h) : + G1CollectedHeap* g1h, + HeapRegion* scan_only_list, + HeapRegion* survivor_list) : AbstractGangTask("G1 Par Cleanup CT Task"), _ct_bs(ct_bs), - _g1h(g1h) + _g1h(g1h), + _so_head(scan_only_list), + _su_head(survivor_list) { } void work(int i) { @@ -4298,22 +4300,64 @@ while (r = _g1h->pop_dirty_cards_region()) { clear_cards(r); } - } + // Redirty the cards of the scan-only and survivor regions. + dirty_list(&this->_so_head); + dirty_list(&this->_su_head); + } + void clear_cards(HeapRegion* r) { // Cards for Survivor and Scan-Only regions will be dirtied later. if (!r->is_scan_only() && !r->is_survivor()) { _ct_bs->clear(MemRegion(r->bottom(), r->end())); } } + + void dirty_list(HeapRegion* volatile * head_ptr) { + HeapRegion* head; + do { + // Pop region off the list. + head = *head_ptr; + if (head != NULL) { + HeapRegion* r = (HeapRegion*) + Atomic::cmpxchg_ptr(head->get_next_young_region(), head_ptr, head); + if (r == head) { + assert(!r->isHumongous(), "Humongous regions shouldn't be on survivor list"); + _ct_bs->dirty(MemRegion(r->bottom(), r->end())); + } + } + } while (*head_ptr != NULL); + } }; +#ifndef PRODUCT +class G1VerifyCardTableCleanup: public HeapRegionClosure { + CardTableModRefBS* _ct_bs; +public: + G1VerifyCardTableCleanup(CardTableModRefBS* ct_bs) + : _ct_bs(ct_bs) + { } + virtual bool doHeapRegion(HeapRegion* r) + { + MemRegion mr(r->bottom(), r->end()); + if (r->is_scan_only() || r->is_survivor()) { + _ct_bs->verify_dirty_region(mr); + } else { + _ct_bs->verify_clean_region(mr); + } + return false; + } +}; +#endif + void G1CollectedHeap::cleanUpCardTable() { CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set()); double start = os::elapsedTime(); // Iterate over the dirty cards region list. - G1ParCleanupCTTask cleanup_task(ct_bs, this); + G1ParCleanupCTTask cleanup_task(ct_bs, this, + _young_list->first_scan_only_region(), + _young_list->first_survivor_region()); if (ParallelGCThreads > 0) { set_par_threads(workers()->total_workers()); workers()->run_task(&cleanup_task); @@ -4329,18 +4373,22 @@ } r->set_next_dirty_cards_region(NULL); } - } - // now, redirty the cards of the scan-only and survivor regions - // (it seemed faster to do it this way, instead of iterating over - // all regions and then clearing / dirtying as appropriate) - dirtyCardsForYoungRegions(ct_bs, _young_list->first_scan_only_region()); - dirtyCardsForYoungRegions(ct_bs, _young_list->first_survivor_region()); - + // now, redirty the cards of the scan-only and survivor regions + // (it seemed faster to do it this way, instead of iterating over + // all regions and then clearing / dirtying as appropriate) + dirtyCardsForYoungRegions(ct_bs, _young_list->first_scan_only_region()); + dirtyCardsForYoungRegions(ct_bs, _young_list->first_survivor_region()); + } double elapsed = os::elapsedTime() - start; g1_policy()->record_clear_ct_time( elapsed * 1000.0); +#ifndef PRODUCT + if (G1VerifyCTCleanup || VerifyAfterGC) { + G1VerifyCardTableCleanup cleanup_verifier(ct_bs); + heap_region_iterate(&cleanup_verifier); + } +#endif } - void G1CollectedHeap::do_collection_pause_if_appropriate(size_t word_size) { if (g1_policy()->should_do_collection_pause(word_size)) { do_collection_pause(); @@ -5033,7 +5081,7 @@ return hr->is_in(p); } } -#endif // PRODUCT +#endif // !PRODUCT void G1CollectedHeap::g1_unimplemented() { // Unimplemented();
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -167,16 +167,11 @@ friend class G1MarkSweep; private: - enum SomePrivateConstants { - VeryLargeInBytes = HeapRegion::GrainBytes/2, - VeryLargeInWords = VeryLargeInBytes/HeapWordSize, - MinHeapDeltaBytes = 10 * HeapRegion::GrainBytes, // FIXME - NumAPIs = HeapRegion::MaxAge - }; - // The one and only G1CollectedHeap, so static functions can find it. static G1CollectedHeap* _g1h; + static size_t _humongous_object_threshold_in_words; + // Storage for the G1 heap (excludes the permanent generation). VirtualSpace _g1_storage; MemRegion _g1_reserved; @@ -859,7 +854,7 @@ return _g1_committed; } - NOT_PRODUCT( bool is_in_closed_subset(const void* p) const; ) + NOT_PRODUCT(bool is_in_closed_subset(const void* p) const;) // Dirty card table entries covering a list of young regions. void dirtyCardsForYoungRegions(CardTableModRefBS* ct_bs, HeapRegion* list); @@ -1021,7 +1016,7 @@ // Returns "true" iff the given word_size is "very large". static bool isHumongous(size_t word_size) { - return word_size >= VeryLargeInWords; + return word_size >= _humongous_object_threshold_in_words; } // Update mod union table with the set of dirty cards.
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -201,6 +201,11 @@ _survivors_age_table(true) { + // Set up the region size and associated fields. Given that the + // policy is created before the heap, we have to set this up here, + // so it's done as soon as possible. + HeapRegion::setup_heap_region_size(Arguments::min_heap_size()); + _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; @@ -993,8 +998,6 @@ double full_gc_time_sec = end_sec - _cur_collection_start_sec; double full_gc_time_ms = full_gc_time_sec * 1000.0; - checkpoint_conc_overhead(); - _all_full_gc_times_ms->add(full_gc_time_ms); update_recent_gc_times(end_sec, full_gc_time_ms); @@ -1164,7 +1167,6 @@ double end_time_sec = os::elapsedTime(); double elapsed_time_ms = (end_time_sec - _mark_init_start_sec) * 1000.0; _concurrent_mark_init_times_ms->add(elapsed_time_ms); - checkpoint_conc_overhead(); record_concurrent_mark_init_end_pre(elapsed_time_ms); _mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true); @@ -1178,7 +1180,6 @@ void G1CollectorPolicy::record_concurrent_mark_remark_end() { double end_time_sec = os::elapsedTime(); double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; - checkpoint_conc_overhead(); _concurrent_mark_remark_times_ms->add(elapsed_time_ms); _cur_mark_stop_world_time_ms += elapsed_time_ms; _prev_collection_pause_end_ms += elapsed_time_ms; @@ -1210,7 +1211,6 @@ // The important thing about this is that it includes "os::elapsedTime". void G1CollectorPolicy::record_concurrent_mark_cleanup_end_work2() { - checkpoint_conc_overhead(); double end_time_sec = os::elapsedTime(); double elapsed_time_ms = (end_time_sec - _mark_cleanup_start_sec)*1000.0; _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); @@ -1425,8 +1425,6 @@ } #endif // PRODUCT - checkpoint_conc_overhead(); - if (in_young_gc_mode()) { last_pause_included_initial_mark = _should_initiate_conc_mark; if (last_pause_included_initial_mark) @@ -2525,19 +2523,6 @@ } #endif // PRODUCT -void -G1CollectorPolicy::checkpoint_conc_overhead() { - double conc_overhead = 0.0; - if (G1AccountConcurrentOverhead) - conc_overhead = COTracker::totalPredConcOverhead(); - _mmu_tracker->update_conc_overhead(conc_overhead); -#if 0 - gclog_or_tty->print(" CO %1.4lf TARGET %1.4lf", - conc_overhead, _mmu_tracker->max_gc_time()); -#endif -} - - size_t G1CollectorPolicy::max_regions(int purpose) { switch (purpose) { case GCAllocForSurvived:
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -92,9 +92,7 @@ int _parallel_gc_threads; enum SomePrivateConstants { - NumPrevPausesForHeuristics = 10, - NumPrevGCsForHeuristics = 10, - NumAPIs = HeapRegion::MaxAge + NumPrevPausesForHeuristics = 10 }; G1MMUTracker* _mmu_tracker; @@ -981,8 +979,6 @@ void set_should_initiate_conc_mark() { _should_initiate_conc_mark = true; } void unset_should_initiate_conc_mark(){ _should_initiate_conc_mark = false; } - void checkpoint_conc_overhead(); - // If an expansion would be appropriate, because recent GC overhead had // exceeded the desired limit, return an amount to expand by. virtual size_t expansion_amount();
--- a/src/share/vm/gc_implementation/g1/g1MMUTracker.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1MMUTracker.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -37,21 +37,7 @@ G1MMUTracker::G1MMUTracker(double time_slice, double max_gc_time) : _time_slice(time_slice), - _max_gc_time(max_gc_time), - _conc_overhead_time_sec(0.0) { } - -void -G1MMUTracker::update_conc_overhead(double conc_overhead) { - double conc_overhead_time_sec = _time_slice * conc_overhead; - if (conc_overhead_time_sec > 0.9 * _max_gc_time) { - // We are screwed, as we only seem to have <10% of the soft - // real-time goal available for pauses. Let's admit defeat and - // allow something more generous as a pause target. - conc_overhead_time_sec = 0.75 * _max_gc_time; - } - - _conc_overhead_time_sec = conc_overhead_time_sec; -} + _max_gc_time(max_gc_time) { } G1MMUTrackerQueue::G1MMUTrackerQueue(double time_slice, double max_gc_time) : G1MMUTracker(time_slice, max_gc_time), @@ -128,7 +114,7 @@ while( 1 ) { double gc_time = - calculate_gc_time(current_time + target_time) + _conc_overhead_time_sec; + calculate_gc_time(current_time + target_time); double diff = target_time + gc_time - _max_gc_time; if (!is_double_leq_0(diff)) { target_time -= diff;
--- a/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -33,19 +33,15 @@ double _time_slice; double _max_gc_time; // this is per time slice - double _conc_overhead_time_sec; - public: G1MMUTracker(double time_slice, double max_gc_time); - void update_conc_overhead(double conc_overhead); - virtual void add_pause(double start, double end, bool gc_thread) = 0; virtual double longest_pause(double current_time) = 0; virtual double when_sec(double current_time, double pause_time) = 0; double max_gc_time() { - return _max_gc_time - _conc_overhead_time_sec; + return _max_gc_time; } inline bool now_max_gc(double current_time) {
--- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -102,9 +102,14 @@ GenMarkSweep::_marking_stack = new (ResourceObj::C_HEAP) GrowableArray<oop>(4000, true); - size_t size = SystemDictionary::number_of_classes() * 2; + int size = SystemDictionary::number_of_classes() * 2; GenMarkSweep::_revisit_klass_stack = - new (ResourceObj::C_HEAP) GrowableArray<Klass*>((int)size, true); + new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true); + // (#klass/k)^2 for k ~ 10 appears a better fit, but this will have to do + // for now until we have a chance to work out a more optimal setting. + GenMarkSweep::_revisit_mdo_stack = + new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(size*2, true); + } void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading, @@ -141,13 +146,18 @@ CodeCache::do_unloading(&GenMarkSweep::is_alive, &GenMarkSweep::keep_alive, purged_class); - GenMarkSweep::follow_stack(); + GenMarkSweep::follow_stack(); // Update subklass/sibling/implementor links of live klasses GenMarkSweep::follow_weak_klass_links(); assert(GenMarkSweep::_marking_stack->is_empty(), "stack should be empty by now"); + // Visit memoized MDO's and clear any unmarked weak refs + GenMarkSweep::follow_mdo_weak_refs(); + assert(GenMarkSweep::_marking_stack->is_empty(), "just drained"); + + // Visit symbol and interned string tables and delete unmarked oops SymbolTable::unlink(&GenMarkSweep::is_alive); StringTable::unlink(&GenMarkSweep::is_alive);
--- a/src/share/vm/gc_implementation/g1/g1_globals.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/g1_globals.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -37,11 +37,7 @@ develop(intx, G1MarkingOverheadPercent, 0, \ "Overhead of concurrent marking") \ \ - develop(bool, G1AccountConcurrentOverhead, false, \ - "Whether soft real-time compliance in G1 will take into account" \ - "concurrent overhead") \ - \ - product(intx, G1YoungGenSize, 0, \ + product(uintx, G1YoungGenSize, 0, \ "Size of the G1 young generation, 0 is the adaptive policy") \ \ develop(bool, G1Gen, true, \ @@ -250,6 +246,9 @@ "If non-0 is the size of the G1 survivor space, " \ "otherwise SurvivorRatio is used to determine the size") \ \ + product(uintx, G1HeapRegionSize, 0, \ + "Size of the G1 regions.") \ + \ experimental(bool, G1ParallelRSetUpdatingEnabled, false, \ "Enables the parallelization of remembered set updating " \ "during evacuation pauses") \ @@ -264,6 +263,9 @@ \ develop(intx, G1CardCountCacheExpandThreshold, 16, \ "Expand the card count cache if the number of collisions for " \ - "a particular entry exceeds this value.") + "a particular entry exceeds this value.") \ + \ + develop(bool, G1VerifyCTCleanup, false, \ + "Verify card table cleanup.") 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 Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/heapRegion.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -25,6 +25,12 @@ #include "incls/_precompiled.incl" #include "incls/_heapRegion.cpp.incl" +int HeapRegion::LogOfHRGrainBytes = 0; +int HeapRegion::LogOfHRGrainWords = 0; +int HeapRegion::GrainBytes = 0; +int HeapRegion::GrainWords = 0; +int HeapRegion::CardsPerRegion = 0; + HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1, HeapRegion* hr, OopClosure* cl, CardTableModRefBS::PrecisionStyle precision, @@ -231,6 +237,73 @@ } } +// Minimum region size; we won't go lower than that. +// We might want to decrease this in the future, to deal with small +// heaps a bit more efficiently. +#define MIN_REGION_SIZE ( 1024 * 1024 ) + +// Maximum region size; we don't go higher than that. There's a good +// reason for having an upper bound. We don't want regions to get too +// large, otherwise cleanup's effectiveness would decrease as there +// will be fewer opportunities to find totally empty regions after +// marking. +#define MAX_REGION_SIZE ( 32 * 1024 * 1024 ) + +// The automatic region size calculation will try to have around this +// many regions in the heap (based on the min heap size). +#define TARGET_REGION_NUMBER 2048 + +void HeapRegion::setup_heap_region_size(uintx min_heap_size) { + // region_size in bytes + uintx region_size = G1HeapRegionSize; + if (FLAG_IS_DEFAULT(G1HeapRegionSize)) { + // We base the automatic calculation on the min heap size. This + // can be problematic if the spread between min and max is quite + // wide, imagine -Xms128m -Xmx32g. But, if we decided it based on + // the max size, the region size might be way too large for the + // min size. Either way, some users might have to set the region + // size manually for some -Xms / -Xmx combos. + + region_size = MAX2(min_heap_size / TARGET_REGION_NUMBER, + (uintx) MIN_REGION_SIZE); + } + + int region_size_log = log2_long((jlong) region_size); + // Recalculate the region size to make sure it's a power of + // 2. This means that region_size is the largest power of 2 that's + // <= what we've calculated so far. + region_size = 1 << region_size_log; + + // Now make sure that we don't go over or under our limits. + if (region_size < MIN_REGION_SIZE) { + region_size = MIN_REGION_SIZE; + } else if (region_size > MAX_REGION_SIZE) { + region_size = MAX_REGION_SIZE; + } + + // And recalculate the log. + region_size_log = log2_long((jlong) region_size); + + // Now, set up the globals. + guarantee(LogOfHRGrainBytes == 0, "we should only set it once"); + LogOfHRGrainBytes = region_size_log; + + guarantee(LogOfHRGrainWords == 0, "we should only set it once"); + LogOfHRGrainWords = LogOfHRGrainBytes - LogHeapWordSize; + + guarantee(GrainBytes == 0, "we should only set it once"); + // The cast to int is safe, given that we've bounded region_size by + // MIN_REGION_SIZE and MAX_REGION_SIZE. + GrainBytes = (int) region_size; + + guarantee(GrainWords == 0, "we should only set it once"); + GrainWords = GrainBytes >> LogHeapWordSize; + guarantee(1 << LogOfHRGrainWords == GrainWords, "sanity"); + + guarantee(CardsPerRegion == 0, "we should only set it once"); + CardsPerRegion = GrainBytes >> CardTableModRefBS::card_shift; +} + void HeapRegion::reset_after_compaction() { G1OffsetTableContigSpace::reset_after_compaction(); // After a compaction the mark bitmap is invalid, so we must
--- a/src/share/vm/gc_implementation/g1/heapRegion.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/heapRegion.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -297,15 +297,24 @@ HeapRegion(G1BlockOffsetSharedArray* sharedOffsetArray, MemRegion mr, bool is_zeroed); - enum SomePublicConstants { - // HeapRegions are GrainBytes-aligned - // and have sizes that are multiples of GrainBytes. - LogOfHRGrainBytes = 20, - LogOfHRGrainWords = LogOfHRGrainBytes - LogHeapWordSize, - GrainBytes = 1 << LogOfHRGrainBytes, - GrainWords = 1 <<LogOfHRGrainWords, - MaxAge = 2, NoOfAges = MaxAge+1 - }; + static int LogOfHRGrainBytes; + static int LogOfHRGrainWords; + // The normal type of these should be size_t. However, they used to + // be members of an enum before and they are assumed by the + // compilers to be ints. To avoid going and fixing all their uses, + // I'm declaring them as ints. I'm not anticipating heap region + // sizes to reach anywhere near 2g, so using an int here is safe. + static int GrainBytes; + static int GrainWords; + static int CardsPerRegion; + + // It sets up the heap region size (GrainBytes / GrainWords), as + // well as other related fields that are based on the heap region + // size (LogOfHRGrainBytes / LogOfHRGrainWords / + // CardsPerRegion). All those fields are considered constant + // throughout the JVM's execution, therefore they should only be set + // up once during initialization time. + static void setup_heap_region_size(uintx min_heap_size); enum ClaimValues { InitialClaimValue = 0,
--- a/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -57,10 +57,6 @@ #endif // _MSC_VER - enum SomePrivateConstants { - CardsPerRegion = HeapRegion::GrainBytes >> CardTableModRefBS::card_shift - }; - protected: // We need access in order to union things into the base table. BitMap* bm() { return &_bm; } @@ -76,7 +72,7 @@ #if PRT_COUNT_OCCUPIED _occupied(0), #endif - _bm(CardsPerRegion, false /* in-resource-area */) + _bm(HeapRegion::CardsPerRegion, false /* in-resource-area */) {} static void free(PerRegionTable* prt) { @@ -144,7 +140,8 @@ CardIdx_t from_card = (CardIdx_t) hw_offset >> (CardTableModRefBS::card_shift - LogHeapWordSize); - assert(0 <= from_card && from_card < CardsPerRegion, "Must be in range."); + assert(0 <= from_card && from_card < HeapRegion::CardsPerRegion, + "Must be in range."); add_card_work(from_card, par); } } @@ -631,7 +628,7 @@ uintptr_t(from_hr->bottom()) >> CardTableModRefBS::card_shift; CardIdx_t card_index = from_card - from_hr_bot_card_index; - assert(0 <= card_index && card_index < PosParPRT::CardsPerRegion, + assert(0 <= card_index && card_index < HeapRegion::CardsPerRegion, "Must be in range."); if (G1HRRSUseSparseTable && _sparse_table.add_card(from_hrs_ind, card_index)) { @@ -922,7 +919,7 @@ } size_t OtherRegionsTable::occ_coarse() const { - return (_n_coarse_entries * PosParPRT::CardsPerRegion); + return (_n_coarse_entries * HeapRegion::CardsPerRegion); } size_t OtherRegionsTable::occ_sparse() const { @@ -1049,7 +1046,8 @@ uintptr_t(hr->bottom()) >> CardTableModRefBS::card_shift; assert(from_card >= hr_bot_card_index, "Inv"); CardIdx_t card_index = from_card - hr_bot_card_index; - assert(0 <= card_index && card_index < PosParPRT::CardsPerRegion, "Must be in range."); + assert(0 <= card_index && card_index < HeapRegion::CardsPerRegion, + "Must be in range."); return _sparse_table.contains_card(hr_ind, card_index); } @@ -1176,7 +1174,7 @@ _is = Sparse; // Set these values so that we increment to the first region. _coarse_cur_region_index = -1; - _coarse_cur_region_cur_card = (PosParPRT::CardsPerRegion-1);; + _coarse_cur_region_cur_card = (HeapRegion::CardsPerRegion-1);; _cur_region_cur_card = 0; @@ -1195,7 +1193,7 @@ // Go to the next card. _coarse_cur_region_cur_card++; // Was the last the last card in the current region? - if (_coarse_cur_region_cur_card == PosParPRT::CardsPerRegion) { + if (_coarse_cur_region_cur_card == HeapRegion::CardsPerRegion) { // Yes: find the next region. This may leave _coarse_cur_region_index // Set to the last index, in which case there are no more coarse // regions. @@ -1232,7 +1230,7 @@ _fine_cur_prt->_bm.get_next_one_offset(_cur_region_cur_card + 1); } while (!fine_has_next()) { - if (_cur_region_cur_card == PosParPRT::CardsPerRegion) { + if (_cur_region_cur_card == (size_t) HeapRegion::CardsPerRegion) { _cur_region_cur_card = 0; _fine_cur_prt = _fine_cur_prt->next(); } @@ -1255,7 +1253,7 @@ bool HeapRegionRemSetIterator::fine_has_next() { return _fine_cur_prt != NULL && - _cur_region_cur_card < PosParPRT::CardsPerRegion; + _cur_region_cur_card < (size_t) HeapRegion::CardsPerRegion; } bool HeapRegionRemSetIterator::has_next(size_t& card_index) {
--- a/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -302,9 +302,9 @@ if (cur->isHumongous()) { return MemRegion(last_start, end); } - cur->reset_zero_fill(); assert(cur == _regions.top(), "Should be top"); if (!cur->is_empty()) break; + cur->reset_zero_fill(); shrink_bytes -= cur->capacity(); num_regions_deleted++; _regions.pop();
--- a/src/share/vm/gc_implementation/g1/sparsePRT.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/sparsePRT.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -347,7 +347,7 @@ size_t /* RSHashTable:: */ RSHashTableIter::compute_card_ind(CardIdx_t ci) { return _heap_bot_card_ind - + (_rsht->entry(_bl_ind)->r_ind() * CardsPerRegion) + + (_rsht->entry(_bl_ind)->r_ind() * HeapRegion::CardsPerRegion) + ci; }
--- a/src/share/vm/gc_implementation/g1/sparsePRT.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/g1/sparsePRT.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -172,10 +172,6 @@ RSHashTable* _rsht; size_t _heap_bot_card_ind; - enum SomePrivateConstants { - CardsPerRegion = HeapRegion::GrainBytes >> CardTableModRefBS::card_shift - }; - // If the bucket list pointed to by _bl_ind contains a card, sets // _bl_ind to the index of that entry, and returns the card. // Otherwise, returns SparseEntry::NullEntry.
--- a/src/share/vm/gc_implementation/includeDB_gc_concurrentMarkSweep Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/includeDB_gc_concurrentMarkSweep Wed Sep 23 23:56:15 2009 -0700 @@ -145,6 +145,7 @@ concurrentMarkSweepGeneration.cpp globals_extension.hpp concurrentMarkSweepGeneration.cpp handles.inline.hpp concurrentMarkSweepGeneration.cpp isGCActiveMark.hpp +concurrentMarkSweepGeneration.cpp iterator.hpp concurrentMarkSweepGeneration.cpp java.hpp concurrentMarkSweepGeneration.cpp jvmtiExport.hpp concurrentMarkSweepGeneration.cpp oop.inline.hpp
--- a/src/share/vm/gc_implementation/includeDB_gc_g1 Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/includeDB_gc_g1 Wed Sep 23 23:56:15 2009 -0700 @@ -64,14 +64,12 @@ concurrentG1RefineThread.cpp resourceArea.hpp concurrentG1RefineThread.hpp concurrentGCThread.hpp -concurrentG1RefineThread.hpp coTracker.hpp concurrentMark.cpp concurrentMark.hpp concurrentMark.cpp concurrentMarkThread.inline.hpp concurrentMark.cpp g1CollectedHeap.inline.hpp concurrentMark.cpp g1CollectorPolicy.hpp concurrentMark.cpp g1RemSet.hpp -concurrentMark.cpp gcOverheadReporter.hpp concurrentMark.cpp genOopClosures.inline.hpp concurrentMark.cpp heapRegionRemSet.hpp concurrentMark.cpp heapRegionSeq.inline.hpp @@ -82,7 +80,6 @@ concurrentMark.cpp resourceArea.hpp concurrentMark.cpp symbolTable.hpp -concurrentMark.hpp coTracker.hpp concurrentMark.hpp heapRegion.hpp concurrentMark.hpp taskqueue.hpp @@ -107,7 +104,6 @@ concurrentZFThread.cpp space.inline.hpp concurrentZFThread.hpp concurrentGCThread.hpp -concurrentZFThread.hpp coTracker.hpp dirtyCardQueue.cpp atomic.hpp dirtyCardQueue.cpp dirtyCardQueue.hpp @@ -147,7 +143,6 @@ g1CollectedHeap.cpp g1OopClosures.inline.hpp g1CollectedHeap.cpp genOopClosures.inline.hpp g1CollectedHeap.cpp gcLocker.inline.hpp -g1CollectedHeap.cpp gcOverheadReporter.hpp g1CollectedHeap.cpp generationSpec.hpp g1CollectedHeap.cpp heapRegionRemSet.hpp g1CollectedHeap.cpp heapRegionSeq.inline.hpp @@ -170,6 +165,7 @@ g1CollectedHeap.inline.hpp heapRegionSeq.hpp g1CollectedHeap.inline.hpp taskqueue.hpp +g1CollectorPolicy.cpp arguments.hpp g1CollectorPolicy.cpp concurrentG1Refine.hpp g1CollectorPolicy.cpp concurrentMark.hpp g1CollectorPolicy.cpp concurrentMarkThread.inline.hpp
--- a/src/share/vm/gc_implementation/includeDB_gc_parallelScavenge Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/includeDB_gc_parallelScavenge Wed Sep 23 23:56:15 2009 -0700 @@ -253,10 +253,11 @@ psParallelCompact.cpp gcLocker.inline.hpp psParallelCompact.cpp gcTaskManager.hpp psParallelCompact.cpp isGCActiveMark.hpp +psParallelCompact.cpp management.hpp +psParallelCompact.cpp memoryService.hpp +psParallelCompact.cpp methodDataOop.hpp psParallelCompact.cpp oop.inline.hpp psParallelCompact.cpp oop.pcgc.inline.hpp -psParallelCompact.cpp memoryService.hpp -psParallelCompact.cpp management.hpp psParallelCompact.cpp parallelScavengeHeap.inline.hpp psParallelCompact.cpp pcTasks.hpp psParallelCompact.cpp psMarkSweep.hpp
--- a/src/share/vm/gc_implementation/includeDB_gc_shared Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/includeDB_gc_shared Wed Sep 23 23:56:15 2009 -0700 @@ -35,12 +35,6 @@ concurrentGCThread.hpp thread.hpp -coTracker.hpp globalDefinitions.hpp -coTracker.hpp numberSeq.hpp - -coTracker.cpp coTracker.hpp -coTracker.cpp os.hpp - allocationStats.cpp allocationStats.hpp allocationStats.cpp ostream.hpp @@ -54,13 +48,6 @@ gcAdaptivePolicyCounters.cpp resourceArea.hpp gcAdaptivePolicyCounters.cpp gcAdaptivePolicyCounters.hpp -gcOverheadReporter.cpp allocation.inline.hpp -gcOverheadReporter.cpp concurrentGCThread.hpp -gcOverheadReporter.cpp coTracker.hpp -gcOverheadReporter.cpp gcOverheadReporter.hpp -gcOverheadReporter.cpp ostream.hpp -gcOverheadReporter.cpp thread_<os_family>.inline.hpp - gSpaceCounters.cpp generation.hpp gSpaceCounters.cpp resourceArea.hpp gSpaceCounters.cpp gSpaceCounters.hpp
--- a/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -59,9 +59,8 @@ PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(which); - // cm->allocate_stacks(); assert(cm->stacks_have_been_allocated(), - "Stack space has not been allocated"); + "Stack space has not been allocated"); PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm); switch (_root_type) { @@ -136,9 +135,8 @@ PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(which); - // cm->allocate_stacks(); assert(cm->stacks_have_been_allocated(), - "Stack space has not been allocated"); + "Stack space has not been allocated"); PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm); PSParallelCompact::FollowStackClosure follow_stack_closure(cm); _rp_task.work(_work_id, *PSParallelCompact::is_alive_closure(),
--- a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -61,12 +61,16 @@ int size = (SystemDictionary::number_of_classes() * 2) * 2 / ParallelGCThreads; _revisit_klass_stack = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true); + // From some experiments (#klass/k)^2 for k = 10 seems a better fit, but this will + // have to do for now until we are able to investigate a more optimal setting. + _revisit_mdo_stack = new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(size*2, true); } ParCompactionManager::~ParCompactionManager() { delete _overflow_stack; delete _revisit_klass_stack; + delete _revisit_mdo_stack; // _manager_array and _stack_array are statics // shared with all instances of ParCompactionManager // should not be deallocated. @@ -195,6 +199,7 @@ void ParCompactionManager::reset() { for(uint i=0; i<ParallelGCThreads+1; i++) { manager_array(i)->revisit_klass_stack()->clear(); + manager_array(i)->revisit_mdo_stack()->clear(); } } @@ -296,6 +301,7 @@ #ifdef ASSERT bool ParCompactionManager::stacks_have_been_allocated() { - return (revisit_klass_stack()->data_addr() != NULL); + return (revisit_klass_stack()->data_addr() != NULL && + revisit_mdo_stack()->data_addr() != NULL); } #endif
--- a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -93,6 +93,7 @@ #if 1 // does this happen enough to need a per thread stack? GrowableArray<Klass*>* _revisit_klass_stack; + GrowableArray<DataLayout*>* _revisit_mdo_stack; #endif static ParMarkBitMap* _mark_bitmap; @@ -154,6 +155,7 @@ #if 1 // Probably stays as a growable array GrowableArray<Klass*>* revisit_klass_stack() { return _revisit_klass_stack; } + GrowableArray<DataLayout*>* revisit_mdo_stack() { return _revisit_mdo_stack; } #endif // Save oop for later processing. Must not fail.
--- a/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -482,6 +482,9 @@ int size = SystemDictionary::number_of_classes() * 2; _revisit_klass_stack = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true); + // (#klass/k)^2, for k ~ 10 appears a better setting, but this will have to do for + // now until we investigate a more optimal setting. + _revisit_mdo_stack = new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(size*2, true); } @@ -495,6 +498,7 @@ delete _marking_stack; delete _revisit_klass_stack; + delete _revisit_mdo_stack; } void PSMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) { @@ -546,6 +550,10 @@ follow_weak_klass_links(); assert(_marking_stack->is_empty(), "just drained"); + // Visit memoized mdo's and clear unmarked weak refs + follow_mdo_weak_refs(); + assert(_marking_stack->is_empty(), "just drained"); + // Visit symbol and interned string tables and delete unmarked oops SymbolTable::unlink(is_alive_closure()); StringTable::unlink(is_alive_closure());
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -2380,7 +2380,10 @@ // Update subklass/sibling/implementor links of live klasses // revisit_klass_stack is used in follow_weak_klass_links(). - follow_weak_klass_links(cm); + follow_weak_klass_links(); + + // Revisit memoized MDO's and clear any unmarked weak refs + follow_mdo_weak_refs(); // Visit symbol and interned string tables and delete unmarked oops SymbolTable::unlink(is_alive_closure()); @@ -2723,17 +2726,25 @@ } void -PSParallelCompact::follow_weak_klass_links(ParCompactionManager* serial_cm) { +PSParallelCompact::follow_weak_klass_links() { // All klasses on the revisit stack are marked at this point. // Update and follow all subklass, sibling and implementor links. - for (uint i = 0; i < ParallelGCThreads+1; i++) { + if (PrintRevisitStats) { + gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes()); + } + for (uint i = 0; i < ParallelGCThreads + 1; i++) { ParCompactionManager* cm = ParCompactionManager::manager_array(i); KeepAliveClosure keep_alive_closure(cm); - for (int i = 0; i < cm->revisit_klass_stack()->length(); i++) { - cm->revisit_klass_stack()->at(i)->follow_weak_klass_links( + int length = cm->revisit_klass_stack()->length(); + if (PrintRevisitStats) { + gclog_or_tty->print_cr("Revisit klass stack[%d] length = %d", i, length); + } + for (int j = 0; j < length; j++) { + cm->revisit_klass_stack()->at(j)->follow_weak_klass_links( is_alive_closure(), &keep_alive_closure); } + // revisit_klass_stack is cleared in reset() follow_stack(cm); } } @@ -2743,6 +2754,35 @@ cm->revisit_klass_stack()->push(k); } +#if ( defined(COMPILER1) || defined(COMPILER2) ) +void PSParallelCompact::revisit_mdo(ParCompactionManager* cm, DataLayout* p) { + cm->revisit_mdo_stack()->push(p); +} + +void PSParallelCompact::follow_mdo_weak_refs() { + // All strongly reachable oops have been marked at this point; + // we can visit and clear any weak references from MDO's which + // we memoized during the strong marking phase. + if (PrintRevisitStats) { + gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes()); + } + for (uint i = 0; i < ParallelGCThreads + 1; i++) { + ParCompactionManager* cm = ParCompactionManager::manager_array(i); + GrowableArray<DataLayout*>* rms = cm->revisit_mdo_stack(); + int length = rms->length(); + if (PrintRevisitStats) { + gclog_or_tty->print_cr("Revisit MDO stack[%d] length = %d", i, length); + } + for (int j = 0; j < length; j++) { + rms->at(j)->follow_weak_refs(is_alive_closure()); + } + // revisit_mdo_stack is cleared in reset() + follow_stack(cm); + } +} +#endif // ( COMPILER1 || COMPILER2 ) + + #ifdef VALIDATE_MARK_SWEEP void PSParallelCompact::track_adjusted_pointer(void* p, bool isroot) {
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -902,7 +902,8 @@ static void marking_phase(ParCompactionManager* cm, bool maximum_heap_compaction); static void follow_stack(ParCompactionManager* cm); - static void follow_weak_klass_links(ParCompactionManager* cm); + static void follow_weak_klass_links(); + static void follow_mdo_weak_refs(); template <class T> static inline void adjust_pointer(T* p, bool is_root); static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); } @@ -1221,6 +1222,9 @@ // Update subklass/sibling/implementor links at end of marking. static void revisit_weak_klass_link(ParCompactionManager* cm, Klass* k); + // Clear unmarked oops in MDOs at the end of marking. + static void revisit_mdo(ParCompactionManager* cm, DataLayout* p); + #ifndef PRODUCT // Debugging support. static const char* space_names[last_space_id];
--- a/src/share/vm/gc_implementation/shared/coTracker.cpp Fri Sep 18 09:57:47 2009 -0700 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,189 +0,0 @@ -/* - * Copyright 2001-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. - * - */ - -# include "incls/_precompiled.incl" -# include "incls/_coTracker.cpp.incl" - -COTracker* COTracker::_head = NULL; -double COTracker::_cpu_number = -1.0; - -void -COTracker::resetPeriod(double now_sec, double vnow_sec) { - guarantee( _enabled, "invariant" ); - _period_start_time_sec = now_sec; - _period_start_vtime_sec = vnow_sec; -} - -void -COTracker::setConcOverhead(double time_stamp_sec, - double conc_overhead) { - guarantee( _enabled, "invariant" ); - _conc_overhead = conc_overhead; - _time_stamp_sec = time_stamp_sec; - if (conc_overhead > 0.001) - _conc_overhead_seq.add(conc_overhead); -} - -void -COTracker::reset(double starting_conc_overhead) { - guarantee( _enabled, "invariant" ); - double now_sec = os::elapsedTime(); - setConcOverhead(now_sec, starting_conc_overhead); -} - -void -COTracker::start() { - guarantee( _enabled, "invariant" ); - resetPeriod(os::elapsedTime(), os::elapsedVTime()); -} - -void -COTracker::update(bool force_end) { - assert( _enabled, "invariant" ); - double end_time_sec = os::elapsedTime(); - double elapsed_time_sec = end_time_sec - _period_start_time_sec; - if (force_end || elapsed_time_sec > _update_period_sec) { - // reached the end of the period - double end_vtime_sec = os::elapsedVTime(); - double elapsed_vtime_sec = end_vtime_sec - _period_start_vtime_sec; - - double conc_overhead = elapsed_vtime_sec / elapsed_time_sec; - - setConcOverhead(end_time_sec, conc_overhead); - resetPeriod(end_time_sec, end_vtime_sec); - } -} - -void -COTracker::updateForSTW(double start_sec, double end_sec) { - if (!_enabled) - return; - - // During a STW pause, no concurrent GC thread has done any - // work. So, we can safely adjust the start of the current period by - // adding the duration of the STW pause to it, so that the STW pause - // doesn't affect the reading of the concurrent overhead (it's - // basically like excluding the time of the STW pause from the - // concurrent overhead calculation). - - double stw_duration_sec = end_sec - start_sec; - guarantee( stw_duration_sec > 0.0, "invariant" ); - - if (outOfDate(start_sec)) - _conc_overhead = 0.0; - else - _time_stamp_sec = end_sec; - _period_start_time_sec += stw_duration_sec; - _conc_overhead_seq = NumberSeq(); - - guarantee( os::elapsedTime() > _period_start_time_sec, "invariant" ); -} - -double -COTracker::predConcOverhead() { - if (_enabled) { - // tty->print(" %1.2lf", _conc_overhead_seq.maximum()); - return _conc_overhead_seq.maximum(); - } else { - // tty->print(" DD"); - return 0.0; - } -} - -void -COTracker::resetPred() { - _conc_overhead_seq = NumberSeq(); -} - -COTracker::COTracker(int group) - : _enabled(false), - _group(group), - _period_start_time_sec(-1.0), - _period_start_vtime_sec(-1.0), - _conc_overhead(-1.0), - _time_stamp_sec(-1.0), - _next(NULL) { - // GCOverheadReportingPeriodMS indicates how frequently the - // concurrent overhead will be recorded by the GC Overhead - // Reporter. We want to take readings less often than that. If we - // took readings more often than some of them might be lost. - _update_period_sec = ((double) GCOverheadReportingPeriodMS) / 1000.0 * 1.25; - _next = _head; - _head = this; - - if (_cpu_number < 0.0) - _cpu_number = (double) os::processor_count(); -} - -// statics - -void -COTracker::updateAllForSTW(double start_sec, double end_sec) { - for (COTracker* curr = _head; curr != NULL; curr = curr->_next) { - curr->updateForSTW(start_sec, end_sec); - } -} - -double -COTracker::totalConcOverhead(double now_sec) { - double total_conc_overhead = 0.0; - - for (COTracker* curr = _head; curr != NULL; curr = curr->_next) { - double conc_overhead = curr->concOverhead(now_sec); - total_conc_overhead += conc_overhead; - } - - return total_conc_overhead; -} - -double -COTracker::totalConcOverhead(double now_sec, - size_t group_num, - double* co_per_group) { - double total_conc_overhead = 0.0; - - for (size_t i = 0; i < group_num; ++i) - co_per_group[i] = 0.0; - - for (COTracker* curr = _head; curr != NULL; curr = curr->_next) { - size_t group = curr->_group; - assert( 0 <= group && group < group_num, "invariant" ); - double conc_overhead = curr->concOverhead(now_sec); - - co_per_group[group] += conc_overhead; - total_conc_overhead += conc_overhead; - } - - return total_conc_overhead; -} - -double -COTracker::totalPredConcOverhead() { - double total_pred_conc_overhead = 0.0; - for (COTracker* curr = _head; curr != NULL; curr = curr->_next) { - total_pred_conc_overhead += curr->predConcOverhead(); - curr->resetPred(); - } - return total_pred_conc_overhead / _cpu_number; -}
--- a/src/share/vm/gc_implementation/shared/coTracker.hpp Fri Sep 18 09:57:47 2009 -0700 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,181 +0,0 @@ -/* - * Copyright 2001-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. - * - */ - -// COTracker keeps track of the concurrent overhead of a GC thread. - -// A thread that needs to be tracked must, itself, start up its -// tracker with the start() method and then call the update() method -// at regular intervals. What the tracker does is to calculate the -// concurrent overhead of a process at a given update period. The -// tracker starts and when is detects that it has exceeded the given -// period, it calculates the duration of the period in wall-clock time -// and the duration of the period in vtime (i.e. how much time the -// concurrent processes really took up during this period). The ratio -// of the latter over the former is the concurrent overhead of that -// process for that period over a single CPU. This overhead is stored -// on the tracker, "timestamped" with the wall-clock time of the end -// of the period. When the concurrent overhead of this process needs -// to be queried, this last "reading" provides a good approximation -// (we assume that the concurrent overhead of a particular thread -// stays largely constant over time). The timestamp is necessary to -// detect when the process has stopped working and the recorded -// reading hasn't been updated for some time. - -// Each concurrent GC thread is considered to be part of a "group" -// (i.e. any available concurrent marking threads are part of the -// "concurrent marking thread group"). A COTracker is associated with -// a single group at construction-time. It's up to each collector to -// decide how groups will be mapped to such an id (ids should start -// from 0 and be consecutive; there's a hardcoded max group num -// defined on the GCOverheadTracker class). The notion of a group has -// been introduced to be able to identify how much overhead was -// imposed by each group, instead of getting a single value that -// covers all concurrent overhead. - -class COTracker { -private: - // It indicates whether this tracker is enabled or not. When the - // tracker is disabled, then it returns 0.0 as the latest concurrent - // overhead and several methods (reset, start, and update) are not - // supposed to be called on it. This enabling / disabling facility - // is really provided to make a bit more explicit in the code when a - // particulary tracker of a processes that doesn't run all the time - // (e.g. concurrent marking) is supposed to be used and not it's not. - bool _enabled; - - // The ID of the group associated with this tracker. - int _group; - - // The update period of the tracker. A new value for the concurrent - // overhead of the associated process will be made at intervals no - // smaller than this. - double _update_period_sec; - - // The start times (both wall-block time and vtime) of the current - // interval. - double _period_start_time_sec; - double _period_start_vtime_sec; - - // Number seq of the concurrent overhead readings within a period - NumberSeq _conc_overhead_seq; - - // The latest reading of the concurrent overhead (over a single CPU) - // imposed by the associated concurrent thread, made available at - // the indicated wall-clock time. - double _conc_overhead; - double _time_stamp_sec; - - // The number of CPUs that the host machine has (for convenience - // really, as we'd have to keep translating it into a double) - static double _cpu_number; - - // Fields that keep a list of all trackers created. This is useful, - // since it allows us to sum up the concurrent overhead without - // having to write code for a specific collector to broadcast a - // request to all its concurrent processes. - COTracker* _next; - static COTracker* _head; - - // It indicates that a new period is starting by updating the - // _period_start_time_sec and _period_start_vtime_sec fields. - void resetPeriod(double now_sec, double vnow_sec); - // It updates the latest concurrent overhead reading, taken at a - // given wall-clock time. - void setConcOverhead(double time_stamp_sec, double conc_overhead); - - // It determines whether the time stamp of the latest concurrent - // overhead reading is out of date or not. - bool outOfDate(double now_sec) { - // The latest reading is considered out of date, if it was taken - // 1.2x the update period. - return (now_sec - _time_stamp_sec) > 1.2 * _update_period_sec; - } - -public: - // The constructor which associates the tracker with a group ID. - COTracker(int group); - - // Methods to enable / disable the tracker and query whether it is enabled. - void enable() { _enabled = true; } - void disable() { _enabled = false; } - bool enabled() { return _enabled; } - - // It resets the tracker and sets concurrent overhead reading to be - // the given parameter and the associated time stamp to be now. - void reset(double starting_conc_overhead = 0.0); - // The tracker starts tracking. IT should only be called from the - // concurrent thread that is tracked by this tracker. - void start(); - // It updates the tracker and, if the current period is longer than - // the update period, the concurrent overhead reading will be - // updated. force_end being true indicates that it's the last call - // to update() by this process before the tracker is disabled (the - // tracker can be re-enabled later if necessary). It should only be - // called from the concurrent thread that is tracked by this tracker - // and while the thread has joined the STS. - void update(bool force_end = false); - // It adjusts the contents of the tracker to take into account a STW - // pause. - void updateForSTW(double start_sec, double end_sec); - - // It returns the last concurrent overhead reading over a single - // CPU. If the reading is out of date, or the tracker is disabled, - // it returns 0.0. - double concCPUOverhead(double now_sec) { - if (!_enabled || outOfDate(now_sec)) - return 0.0; - else - return _conc_overhead; - } - - // It returns the last concurrent overhead reading over all CPUs - // that the host machine has. If the reading is out of date, or the - // tracker is disabled, it returns 0.0. - double concOverhead(double now_sec) { - return concCPUOverhead(now_sec) / _cpu_number; - } - - double predConcOverhead(); - - void resetPred(); - - // statics - - // It notifies all trackers about a STW pause. - static void updateAllForSTW(double start_sec, double end_sec); - - // It returns the sum of the concurrent overhead readings of all - // available (and enabled) trackers for the given time stamp. The - // overhead is over all the CPUs of the host machine. - - static double totalConcOverhead(double now_sec); - // Like the previous method, but it also sums up the overheads per - // group number. The length of the co_per_group array must be at - // least as large group_num - static double totalConcOverhead(double now_sec, - size_t group_num, - double* co_per_group); - - static double totalPredConcOverhead(); -};
--- a/src/share/vm/gc_implementation/shared/gcOverheadReporter.cpp Fri Sep 18 09:57:47 2009 -0700 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,179 +0,0 @@ -/* - * Copyright 2001-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. - * - */ - -# include "incls/_precompiled.incl" -# include "incls/_gcOverheadReporter.cpp.incl" - -class COReportingThread : public ConcurrentGCThread { -private: - GCOverheadReporter* _reporter; - -public: - COReportingThread(GCOverheadReporter* reporter) : _reporter(reporter) { - guarantee( _reporter != NULL, "precondition" ); - create_and_start(); - } - - virtual void run() { - initialize_in_thread(); - wait_for_universe_init(); - - int period_ms = GCOverheadReportingPeriodMS; - - while ( true ) { - os::sleep(Thread::current(), period_ms, false); - - _sts.join(); - double now_sec = os::elapsedTime(); - _reporter->collect_and_record_conc_overhead(now_sec); - _sts.leave(); - } - - terminate(); - } -}; - -GCOverheadReporter* GCOverheadReporter::_reporter = NULL; - -GCOverheadReporter::GCOverheadReporter(size_t group_num, - const char* group_names[], - size_t length) - : _group_num(group_num), _prev_end_sec(0.0) { - guarantee( 0 <= group_num && group_num <= MaxGCOverheadGroupNum, - "precondition" ); - - _base = NEW_C_HEAP_ARRAY(GCOverheadReporterEntry, length); - _top = _base + length; - _curr = _base; - - for (size_t i = 0; i < group_num; ++i) { - guarantee( group_names[i] != NULL, "precondition" ); - _group_names[i] = group_names[i]; - } -} - -void -GCOverheadReporter::add(double start_sec, double end_sec, - double* conc_overhead, - double stw_overhead) { - assert( _curr <= _top, "invariant" ); - - if (_curr == _top) { - guarantee( false, "trace full" ); - return; - } - - _curr->_start_sec = start_sec; - _curr->_end_sec = end_sec; - for (size_t i = 0; i < _group_num; ++i) { - _curr->_conc_overhead[i] = - (conc_overhead != NULL) ? conc_overhead[i] : 0.0; - } - _curr->_stw_overhead = stw_overhead; - - ++_curr; -} - -void -GCOverheadReporter::collect_and_record_conc_overhead(double end_sec) { - double start_sec = _prev_end_sec; - guarantee( end_sec > start_sec, "invariant" ); - - double conc_overhead[MaxGCOverheadGroupNum]; - COTracker::totalConcOverhead(end_sec, _group_num, conc_overhead); - add_conc_overhead(start_sec, end_sec, conc_overhead); - _prev_end_sec = end_sec; -} - -void -GCOverheadReporter::record_stw_start(double start_sec) { - guarantee( start_sec > _prev_end_sec, "invariant" ); - collect_and_record_conc_overhead(start_sec); -} - -void -GCOverheadReporter::record_stw_end(double end_sec) { - double start_sec = _prev_end_sec; - COTracker::updateAllForSTW(start_sec, end_sec); - add_stw_overhead(start_sec, end_sec, 1.0); - - _prev_end_sec = end_sec; -} - -void -GCOverheadReporter::print() const { - tty->print_cr(""); - tty->print_cr("GC Overhead (%d entries)", _curr - _base); - tty->print_cr(""); - GCOverheadReporterEntry* curr = _base; - while (curr < _curr) { - double total = curr->_stw_overhead; - for (size_t i = 0; i < _group_num; ++i) - total += curr->_conc_overhead[i]; - - tty->print("OVERHEAD %12.8lf %12.8lf ", - curr->_start_sec, curr->_end_sec); - - for (size_t i = 0; i < _group_num; ++i) - tty->print("%s %12.8lf ", _group_names[i], curr->_conc_overhead[i]); - - tty->print_cr("STW %12.8lf TOT %12.8lf", curr->_stw_overhead, total); - ++curr; - } - tty->print_cr(""); -} - -// statics - -void -GCOverheadReporter::initGCOverheadReporter(size_t group_num, - const char* group_names[]) { - guarantee( _reporter == NULL, "should only be called once" ); - guarantee( 0 <= group_num && group_num <= MaxGCOverheadGroupNum, - "precondition" ); - guarantee( group_names != NULL, "pre-condition" ); - - if (GCOverheadReporting) { - _reporter = new GCOverheadReporter(group_num, group_names); - new COReportingThread(_reporter); - } -} - -void -GCOverheadReporter::recordSTWStart(double start_sec) { - if (_reporter != NULL) - _reporter->record_stw_start(start_sec); -} - -void -GCOverheadReporter::recordSTWEnd(double end_sec) { - if (_reporter != NULL) - _reporter->record_stw_end(end_sec); -} - -void -GCOverheadReporter::printGCOverhead() { - if (_reporter != NULL) - _reporter->print(); -}
--- a/src/share/vm/gc_implementation/shared/gcOverheadReporter.hpp Fri Sep 18 09:57:47 2009 -0700 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,141 +0,0 @@ -/* - * Copyright 2001-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. - * - */ - -// Keeps track of the GC overhead (both concurrent and STW). It stores -// it in a large array and then prints it to tty at the end of the -// execution. - -// See coTracker.hpp for the explanation on what groups are. - -// Let's set a maximum number of concurrent overhead groups, to -// statically allocate any arrays we need and not to have to -// malloc/free them. This is just a bit more convenient. -enum { - MaxGCOverheadGroupNum = 4 -}; - -typedef struct { - double _start_sec; - double _end_sec; - - double _conc_overhead[MaxGCOverheadGroupNum]; - double _stw_overhead; -} GCOverheadReporterEntry; - -class GCOverheadReporter { - friend class COReportingThread; - -private: - enum PrivateConstants { - DefaultReporterLength = 128 * 1024 - }; - - // Reference to the single instance of this class. - static GCOverheadReporter* _reporter; - - // These three references point to the array that contains the GC - // overhead entries (_base is the base of the array, _top is the - // address passed the last entry of the array, _curr is the next - // entry to be used). - GCOverheadReporterEntry* _base; - GCOverheadReporterEntry* _top; - GCOverheadReporterEntry* _curr; - - // The number of concurrent overhead groups. - size_t _group_num; - - // The wall-clock time of the end of the last recorded period of GC - // overhead. - double _prev_end_sec; - - // Names for the concurrent overhead groups. - const char* _group_names[MaxGCOverheadGroupNum]; - - // Add a new entry to the large array. conc_overhead being NULL is - // equivalent to an array full of 0.0s. conc_overhead should have a - // length of at least _group_num. - void add(double start_sec, double end_sec, - double* conc_overhead, - double stw_overhead); - - // Add an entry that represents concurrent GC overhead. - // conc_overhead must be at least of length _group_num. - // conc_overhead being NULL is equivalent to an array full of 0.0s. - void add_conc_overhead(double start_sec, double end_sec, - double* conc_overhead) { - add(start_sec, end_sec, conc_overhead, 0.0); - } - - // Add an entry that represents STW GC overhead. - void add_stw_overhead(double start_sec, double end_sec, - double stw_overhead) { - add(start_sec, end_sec, NULL, stw_overhead); - } - - // It records the start of a STW pause (i.e. it records the - // concurrent overhead up to that point) - void record_stw_start(double start_sec); - - // It records the end of a STW pause (i.e. it records the overhead - // associated with the pause and adjusts all the trackers to reflect - // the pause) - void record_stw_end(double end_sec); - - // It queries all the trackers of their concurrent overhead and - // records it. - void collect_and_record_conc_overhead(double end_sec); - - // It prints the contents of the GC overhead array - void print() const; - - - // Constructor. The same preconditions for group_num and group_names - // from initGCOverheadReporter apply here too. - GCOverheadReporter(size_t group_num, - const char* group_names[], - size_t length = DefaultReporterLength); - -public: - - // statics - - // It initialises the GCOverheadReporter and launches the concurrent - // overhead reporting thread. Both actions happen only if the - // GCOverheadReporting parameter is set. The length of the - // group_names array should be >= group_num and group_num should be - // <= MaxGCOverheadGroupNum. Entries group_namnes[0..group_num-1] - // should not be NULL. - static void initGCOverheadReporter(size_t group_num, - const char* group_names[]); - - // The following three are provided for convenience and they are - // wrappers around record_stw_start(start_sec), record_stw_end(end_sec), - // and print(). Each of these checks whether GC overhead reporting - // is on (i.e. _reporter != NULL) and, if it is, calls the - // corresponding method. Saves from repeating this pattern again and - // again from the places where they need to be called. - static void recordSTWStart(double start_sec); - static void recordSTWEnd(double end_sec); - static void printGCOverhead(); -};
--- a/src/share/vm/gc_implementation/shared/markSweep.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/shared/markSweep.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -27,6 +27,7 @@ GrowableArray<oop>* MarkSweep::_marking_stack = NULL; GrowableArray<Klass*>* MarkSweep::_revisit_klass_stack = NULL; +GrowableArray<DataLayout*>* MarkSweep::_revisit_mdo_stack = NULL; GrowableArray<oop>* MarkSweep::_preserved_oop_stack = NULL; GrowableArray<markOop>* MarkSweep::_preserved_mark_stack= NULL; @@ -62,12 +63,37 @@ void MarkSweep::follow_weak_klass_links() { // All klasses on the revisit stack are marked at this point. // Update and follow all subklass, sibling and implementor links. + if (PrintRevisitStats) { + gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes()); + gclog_or_tty->print_cr("Revisit klass stack length = %d", _revisit_klass_stack->length()); + } for (int i = 0; i < _revisit_klass_stack->length(); i++) { _revisit_klass_stack->at(i)->follow_weak_klass_links(&is_alive,&keep_alive); } follow_stack(); } +#if ( defined(COMPILER1) || defined(COMPILER2) ) +void MarkSweep::revisit_mdo(DataLayout* p) { + _revisit_mdo_stack->push(p); +} + +void MarkSweep::follow_mdo_weak_refs() { + // All strongly reachable oops have been marked at this point; + // we can visit and clear any weak references from MDO's which + // we memoized during the strong marking phase. + assert(_marking_stack->is_empty(), "Marking stack should be empty"); + if (PrintRevisitStats) { + gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes()); + gclog_or_tty->print_cr("Revisit MDO stack length = %d", _revisit_mdo_stack->length()); + } + for (int i = 0; i < _revisit_mdo_stack->length(); i++) { + _revisit_mdo_stack->at(i)->follow_weak_refs(&is_alive); + } + follow_stack(); +} +#endif // ( COMPILER1 || COMPILER2 ) + MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; CodeBlobToOopClosure MarkSweep::follow_code_root_closure(&MarkSweep::follow_root_closure, /*do_marking=*/ true);
--- a/src/share/vm/gc_implementation/shared/markSweep.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_implementation/shared/markSweep.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -23,6 +23,7 @@ */ class ReferenceProcessor; +class DataLayout; // MarkSweep takes care of global mark-compact garbage collection for a // GenCollectedHeap using a four-phase pointer forwarding algorithm. All @@ -63,6 +64,9 @@ public: virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); + virtual const bool do_nmethods() const { return true; } + virtual const bool should_remember_mdo() const { return true; } + virtual void remember_mdo(DataLayout* p) { MarkSweep::revisit_mdo(p); } }; class FollowStackClosure: public VoidClosure { @@ -101,6 +105,7 @@ friend class KeepAliveClosure; friend class VM_MarkSweep; friend void marksweep_init(); + friend class DataLayout; // // Vars @@ -110,6 +115,8 @@ static GrowableArray<oop>* _marking_stack; // Stack for live klasses to revisit at end of marking phase static GrowableArray<Klass*>* _revisit_klass_stack; + // Set (stack) of MDO's to revisit at end of marking phase + static GrowableArray<DataLayout*>* _revisit_mdo_stack; // Space for storing/restoring mark word static GrowableArray<markOop>* _preserved_mark_stack; @@ -155,6 +162,10 @@ // Class unloading. Update subklass/sibling/implementor links at end of marking phase. static void follow_weak_klass_links(); + // Class unloading. Clear weak refs in MDO's (ProfileData) + // at the end of the marking phase. + static void follow_mdo_weak_refs(); + // Debugging static void trace(const char* msg) PRODUCT_RETURN; @@ -212,7 +223,10 @@ #endif // Call backs for class unloading - static void revisit_weak_klass_link(Klass* k); // Update subklass/sibling/implementor links at end of marking. + // Update subklass/sibling/implementor links at end of marking. + static void revisit_weak_klass_link(Klass* k); + // For weak refs clearing in MDO's + static void revisit_mdo(DataLayout* p); }; class PreservedMark VALUE_OBJ_CLASS_SPEC {
--- a/src/share/vm/gc_interface/collectedHeap.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/gc_interface/collectedHeap.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -239,6 +239,9 @@ return p == NULL || is_in_closed_subset(p); } + // XXX is_permanent() and is_in_permanent() should be better named + // to distinguish one from the other. + // Returns "TRUE" if "p" is allocated as "permanent" data. // If the heap does not use "permanent" data, returns the same // value is_in_reserved() would return. @@ -247,13 +250,17 @@ // space). If you need the more conservative answer use is_permanent(). virtual bool is_in_permanent(const void *p) const = 0; + bool is_in_permanent_or_null(const void *p) const { + return p == NULL || is_in_permanent(p); + } + // Returns "TRUE" if "p" is in the committed area of "permanent" data. // If the heap does not use "permanent" data, returns the same // value is_in() would return. virtual bool is_permanent(const void *p) const = 0; - bool is_in_permanent_or_null(const void *p) const { - return p == NULL || is_in_permanent(p); + bool is_permanent_or_null(const void *p) const { + return p == NULL || is_permanent(p); } // An object is scavengable if its location may move during a scavenge.
--- a/src/share/vm/includeDB_core Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/includeDB_core Wed Sep 23 23:56:15 2009 -0700 @@ -2684,6 +2684,7 @@ markOop.inline.hpp markOop.hpp markSweep.cpp compileBroker.hpp +markSweep.cpp methodDataOop.hpp markSweep.hpp collectedHeap.hpp
--- a/src/share/vm/interpreter/interpreterRuntime.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/interpreter/interpreterRuntime.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -849,8 +849,25 @@ } #endif // !PRODUCT +nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp) { + nmethod* nm = frequency_counter_overflow_inner(thread, branch_bcp); + assert(branch_bcp != NULL || nm == NULL, "always returns null for non OSR requests"); + if (branch_bcp != NULL && nm != NULL) { + // This was a successful request for an OSR nmethod. Because + // frequency_counter_overflow_inner ends with a safepoint check, + // nm could have been unloaded so look it up again. It's unsafe + // to examine nm directly since it might have been freed and used + // for something else. + frame fr = thread->last_frame(); + methodOop method = fr.interpreter_frame_method(); + int bci = method->bci_from(fr.interpreter_frame_bcp()); + nm = method->lookup_osr_nmethod_for(bci); + } + return nm; +} + IRT_ENTRY(nmethod*, - InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp)) + InterpreterRuntime::frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp)) // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized // flag, in case this method triggers classloading which will call into Java. UnlockFlagSaver fs(thread); @@ -923,7 +940,6 @@ } BiasedLocking::revoke(objects_to_revoke); } - return osr_nm; } }
--- a/src/share/vm/interpreter/interpreterRuntime.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/interpreter/interpreterRuntime.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -49,6 +49,9 @@ static ConstantPoolCacheEntry* cache_entry(JavaThread *thread) { return cache_entry_at(thread, Bytes::get_native_u2(bcp(thread) + 1)); } static void note_trap(JavaThread *thread, int reason, TRAPS); + // Inner work method for Interpreter's frequency counter overflow + static nmethod* frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp); + public: // Constants static void ldc (JavaThread* thread, bool wide);
--- a/src/share/vm/memory/cardTableModRefBS.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/cardTableModRefBS.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -660,6 +660,29 @@ GuaranteeNotModClosure blk(this); non_clean_card_iterate_work(mr, &blk, false); } + +// To verify a MemRegion is entirely dirty this closure is passed to +// dirty_card_iterate. If the region is dirty do_MemRegion will be +// invoked only once with a MemRegion equal to the one being +// verified. +class GuaranteeDirtyClosure: public MemRegionClosure { + CardTableModRefBS* _ct; + MemRegion _mr; + bool _result; +public: + GuaranteeDirtyClosure(CardTableModRefBS* ct, MemRegion mr) + : _ct(ct), _mr(mr), _result(false) {} + void do_MemRegion(MemRegion mr) { + _result = _mr.equals(mr); + } + bool result() const { return _result; } +}; + +void CardTableModRefBS::verify_dirty_region(MemRegion mr) { + GuaranteeDirtyClosure blk(this, mr); + dirty_card_iterate(mr, &blk); + guarantee(blk.result(), "Non-dirty cards in region that should be dirty"); +} #endif bool CardTableModRefBSForCTRS::card_will_be_scanned(jbyte cv) {
--- a/src/share/vm/memory/cardTableModRefBS.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/cardTableModRefBS.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -456,6 +456,7 @@ void verify_guard(); void verify_clean_region(MemRegion mr) PRODUCT_RETURN; + void verify_dirty_region(MemRegion mr) PRODUCT_RETURN; static size_t par_chunk_heapword_alignment() { return CardsPerStrideChunk * card_size_in_words;
--- a/src/share/vm/memory/genMarkSweep.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/genMarkSweep.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -162,6 +162,9 @@ int size = SystemDictionary::number_of_classes() * 2; _revisit_klass_stack = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true); + // (#klass/k)^2 for k ~ 10 appears to be a better fit, but this will have to do for + // now until we have had a chance to investigate a more optimal setting. + _revisit_mdo_stack = new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(2*size, true); #ifdef VALIDATE_MARK_SWEEP if (ValidateMarkSweep) { @@ -206,6 +209,7 @@ delete _marking_stack; delete _revisit_klass_stack; + delete _revisit_mdo_stack; #ifdef VALIDATE_MARK_SWEEP if (ValidateMarkSweep) { @@ -265,6 +269,10 @@ follow_weak_klass_links(); assert(_marking_stack->is_empty(), "just drained"); + // Visit memoized MDO's and clear any unmarked weak refs + follow_mdo_weak_refs(); + assert(_marking_stack->is_empty(), "just drained"); + // Visit symbol and interned string tables and delete unmarked oops SymbolTable::unlink(&is_alive); StringTable::unlink(&is_alive);
--- a/src/share/vm/memory/iterator.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/iterator.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -25,6 +25,10 @@ # include "incls/_precompiled.incl" # include "incls/_iterator.cpp.incl" +#ifdef ASSERT +bool OopClosure::_must_remember_klasses = false; +#endif + void ObjectToOopClosure::do_object(oop obj) { obj->oop_iterate(_cl); } @@ -33,6 +37,16 @@ ShouldNotCallThis(); } +#ifdef ASSERT +bool OopClosure::must_remember_klasses() { + return _must_remember_klasses; +} +void OopClosure::set_must_remember_klasses(bool v) { + _must_remember_klasses = v; +} +#endif + + MarkingCodeBlobClosure::MarkScope::MarkScope(bool activate) : _active(activate) {
--- a/src/share/vm/memory/iterator.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/iterator.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -26,6 +26,7 @@ class CodeBlob; class ReferenceProcessor; +class DataLayout; // Closure provides abortability. @@ -55,9 +56,23 @@ // In support of post-processing of weak links of KlassKlass objects; // see KlassKlass::oop_oop_iterate(). - virtual const bool should_remember_klasses() const { return false; } + + virtual const bool should_remember_klasses() const { + assert(!must_remember_klasses(), "Should have overriden this method."); + return false; + } + virtual void remember_klass(Klass* k) { /* do nothing */ } + // In support of post-processing of weak references in + // ProfileData (MethodDataOop) objects; see, for example, + // VirtualCallData::oop_iterate(). + virtual const bool should_remember_mdo() const { return false; } + virtual void remember_mdo(DataLayout* v) { /* do nothing */ } + + // If "true", invoke on nmethods (when scanning compiled frames). + virtual const bool do_nmethods() const { return false; } + // The methods below control how object iterations invoking this closure // should be performed: @@ -72,6 +87,12 @@ // location without an intervening "major reset" (like the end of a GC). virtual bool idempotent() { return false; } virtual bool apply_to_weak_ref_discovered_field() { return false; } + +#ifdef ASSERT + static bool _must_remember_klasses; + static bool must_remember_klasses(); + static void set_must_remember_klasses(bool v); +#endif }; // ObjectClosure is used for iterating through an object space @@ -262,3 +283,38 @@ // correct length. virtual void do_tag(int tag) = 0; }; + +#ifdef ASSERT +// This class is used to flag phases of a collection that +// can unload classes and which should override the +// should_remember_klasses() and remember_klass() of OopClosure. +// The _must_remember_klasses is set in the contructor and restored +// in the destructor. _must_remember_klasses is checked in assertions +// in the OopClosure implementations of should_remember_klasses() and +// remember_klass() and the expectation is that the OopClosure +// implementation should not be in use if _must_remember_klasses is set. +// Instances of RememberKlassesChecker can be place in +// marking phases of collections which can do class unloading. +// RememberKlassesChecker can be passed "false" to turn off checking. +// It is used by CMS when CMS yields to a different collector. +class RememberKlassesChecker: StackObj { + bool _state; + bool _skip; + public: + RememberKlassesChecker(bool checking_on) : _state(false), _skip(false) { + _skip = !(ClassUnloading && !UseConcMarkSweepGC || + CMSClassUnloadingEnabled && UseConcMarkSweepGC); + if (_skip) { + return; + } + _state = OopClosure::must_remember_klasses(); + OopClosure::set_must_remember_klasses(checking_on); + } + ~RememberKlassesChecker() { + if (_skip) { + return; + } + OopClosure::set_must_remember_klasses(_state); + } +}; +#endif // ASSERT
--- a/src/share/vm/memory/oopFactory.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/oopFactory.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -98,10 +98,12 @@ } -klassOop oopFactory::new_instanceKlass(int vtable_len, int itable_len, int static_field_size, - int nonstatic_oop_map_size, ReferenceType rt, TRAPS) { +klassOop oopFactory::new_instanceKlass(int vtable_len, int itable_len, + int static_field_size, + unsigned int nonstatic_oop_map_count, + ReferenceType rt, TRAPS) { instanceKlassKlass* ikk = instanceKlassKlass::cast(Universe::instanceKlassKlassObj()); - return ikk->allocate_instance_klass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, CHECK_NULL); + return ikk->allocate_instance_klass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_count, rt, CHECK_NULL); }
--- a/src/share/vm/memory/oopFactory.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/oopFactory.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -89,8 +89,10 @@ TRAPS); // Instance classes - static klassOop new_instanceKlass(int vtable_len, int itable_len, int static_field_size, - int nonstatic_oop_map_size, ReferenceType rt, TRAPS); + static klassOop new_instanceKlass(int vtable_len, int itable_len, + int static_field_size, + unsigned int nonstatic_oop_map_count, + ReferenceType rt, TRAPS); // Methods private:
--- a/src/share/vm/memory/referenceProcessor.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/memory/referenceProcessor.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1231,6 +1231,11 @@ NOT_PRODUCT(verify_ok_to_handle_reflists()); +#ifdef ASSERT + bool must_remember_klasses = ClassUnloading && !UseConcMarkSweepGC || + CMSClassUnloadingEnabled && UseConcMarkSweepGC; + RememberKlassesChecker mx(must_remember_klasses); +#endif // Soft references { TraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
--- a/src/share/vm/oops/instanceKlass.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/oops/instanceKlass.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -110,7 +110,7 @@ // 1) Verify the bytecodes Verifier::Mode mode = throw_verifyerror ? Verifier::ThrowException : Verifier::NoException; - return Verifier::verify(this_oop, mode, CHECK_false); + return Verifier::verify(this_oop, mode, this_oop->should_verify_class(), CHECK_false); } @@ -1085,6 +1085,7 @@ if (indices == NULL || (length = (size_t)indices[0]) <= idnum) { size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count()); int* new_indices = NEW_C_HEAP_ARRAY(int, size+1); + new_indices[0] =(int)size; // array size held in the first element // Copy the existing entries, if any size_t i; for (i = 0; i < length; i++) { @@ -1396,18 +1397,18 @@ /* Compute oopmap block range. The common case \ is nonstatic_oop_map_size == 1. */ \ OopMapBlock* map = start_of_nonstatic_oop_maps(); \ - OopMapBlock* const end_map = map + nonstatic_oop_map_size(); \ + OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \ if (UseCompressedOops) { \ while (map < end_map) { \ InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \ - obj->obj_field_addr<narrowOop>(map->offset()), map->length(), \ + obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \ do_oop, assert_fn) \ ++map; \ } \ } else { \ while (map < end_map) { \ InstanceKlass_SPECIALIZED_OOP_ITERATE(oop, \ - obj->obj_field_addr<oop>(map->offset()), map->length(), \ + obj->obj_field_addr<oop>(map->offset()), map->count(), \ do_oop, assert_fn) \ ++map; \ } \ @@ -1417,19 +1418,19 @@ #define InstanceKlass_OOP_MAP_REVERSE_ITERATE(obj, do_oop, assert_fn) \ { \ OopMapBlock* const start_map = start_of_nonstatic_oop_maps(); \ - OopMapBlock* map = start_map + nonstatic_oop_map_size(); \ + OopMapBlock* map = start_map + nonstatic_oop_map_count(); \ if (UseCompressedOops) { \ while (start_map < map) { \ --map; \ InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(narrowOop, \ - obj->obj_field_addr<narrowOop>(map->offset()), map->length(), \ + obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \ do_oop, assert_fn) \ } \ } else { \ while (start_map < map) { \ --map; \ InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(oop, \ - obj->obj_field_addr<oop>(map->offset()), map->length(), \ + obj->obj_field_addr<oop>(map->offset()), map->count(), \ do_oop, assert_fn) \ } \ } \ @@ -1443,11 +1444,11 @@ usually non-existent extra overhead of examining \ all the maps. */ \ OopMapBlock* map = start_of_nonstatic_oop_maps(); \ - OopMapBlock* const end_map = map + nonstatic_oop_map_size(); \ + OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \ if (UseCompressedOops) { \ while (map < end_map) { \ InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ - obj->obj_field_addr<narrowOop>(map->offset()), map->length(), \ + obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \ low, high, \ do_oop, assert_fn) \ ++map; \ @@ -1455,7 +1456,7 @@ } else { \ while (map < end_map) { \ InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ - obj->obj_field_addr<oop>(map->offset()), map->length(), \ + obj->obj_field_addr<oop>(map->offset()), map->count(), \ low, high, \ do_oop, assert_fn) \ ++map; \ @@ -2216,14 +2217,15 @@ first_time = false; const int extra = java_lang_Class::number_of_fake_oop_fields; guarantee(ik->nonstatic_field_size() == extra, "just checking"); - guarantee(ik->nonstatic_oop_map_size() == 1, "just checking"); + guarantee(ik->nonstatic_oop_map_count() == 1, "just checking"); guarantee(ik->size_helper() == align_object_size(instanceOopDesc::header_size() + extra), "just checking"); // Check that the map is (2,extra) int offset = java_lang_Class::klass_offset; OopMapBlock* map = ik->start_of_nonstatic_oop_maps(); - guarantee(map->offset() == offset && map->length() == extra, "just checking"); + guarantee(map->offset() == offset && map->count() == (unsigned int) extra, + "sanity"); } }
--- a/src/share/vm/oops/instanceKlass.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/oops/instanceKlass.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -71,7 +71,6 @@ // forward declaration for class -- see below for definition class SuperTypeClosure; -class OopMapBlock; class JNIid; class jniIdMapBase; class BreakpointInfo; @@ -99,6 +98,29 @@ }; #endif // !PRODUCT +// ValueObjs embedded in klass. Describes where oops are located in instances of +// this klass. +class OopMapBlock VALUE_OBJ_CLASS_SPEC { + public: + // Byte offset of the first oop mapped by this block. + int offset() const { return _offset; } + void set_offset(int offset) { _offset = offset; } + + // Number of oops in this block. + uint count() const { return _count; } + void set_count(uint count) { _count = count; } + + // sizeof(OopMapBlock) in HeapWords. + static const int size_in_words() { + return align_size_up(int(sizeof(OopMapBlock)), HeapWordSize) >> + LogHeapWordSize; + } + + private: + int _offset; + uint _count; +}; + class instanceKlass: public Klass { friend class VMStructs; public: @@ -191,10 +213,11 @@ int _nonstatic_field_size; int _static_field_size; // number words used by static fields (oop and non-oop) in this klass int _static_oop_field_size;// number of static oop fields in this klass - int _nonstatic_oop_map_size;// number of nonstatic oop-map blocks allocated at end of this klass + int _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks bool _is_marked_dependent; // used for marking during flushing and deoptimization bool _rewritten; // methods rewritten. bool _has_nonstatic_fields; // for sizing with UseCompressedOops + bool _should_verify_class; // allow caching of preverification u2 _minor_version; // minor version number of class file u2 _major_version; // major version number of class file ClassState _init_state; // state of class @@ -340,6 +363,10 @@ int get_init_state() { return _init_state; } // Useful for debugging bool is_rewritten() const { return _rewritten; } + // defineClass specified verification + bool should_verify_class() const { return _should_verify_class; } + void set_should_verify_class(bool value) { _should_verify_class = value; } + // marking bool is_marked_dependent() const { return _is_marked_dependent; } void set_is_marked_dependent(bool value) { _is_marked_dependent = value; } @@ -424,8 +451,16 @@ void set_source_debug_extension(symbolOop n){ oop_store_without_check((oop*) &_source_debug_extension, (oop) n); } // nonstatic oop-map blocks - int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; } - void set_nonstatic_oop_map_size(int size) { _nonstatic_oop_map_size = size; } + static int nonstatic_oop_map_size(unsigned int oop_map_count) { + return oop_map_count * OopMapBlock::size_in_words(); + } + unsigned int nonstatic_oop_map_count() const { + return _nonstatic_oop_map_size / OopMapBlock::size_in_words(); + } + int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; } + void set_nonstatic_oop_map_size(int words) { + _nonstatic_oop_map_size = words; + } // RedefineClasses() support for previous versions: void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods, @@ -839,21 +874,6 @@ } -// ValueObjs embedded in klass. Describes where oops are located in instances of this klass. - -class OopMapBlock VALUE_OBJ_CLASS_SPEC { - private: - jushort _offset; // Offset of first oop in oop-map block - jushort _length; // Length of oop-map block - public: - // Accessors - jushort offset() const { return _offset; } - void set_offset(jushort offset) { _offset = offset; } - - jushort length() const { return _length; } - void set_length(jushort length) { _length = length; } -}; - /* JNIid class for jfieldIDs only */ class JNIid: public CHeapObj { friend class VMStructs;
--- a/src/share/vm/oops/instanceKlassKlass.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/oops/instanceKlassKlass.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -402,9 +402,14 @@ } #endif // SERIALGC -klassOop instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len, int static_field_size, - int nonstatic_oop_map_size, ReferenceType rt, TRAPS) { +klassOop +instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len, + int static_field_size, + unsigned nonstatic_oop_map_count, + 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) + static_field_size + nonstatic_oop_map_size); // Allocation @@ -615,9 +620,9 @@ st->print(BULLET"non-static oop maps: "); OopMapBlock* map = ik->start_of_nonstatic_oop_maps(); - OopMapBlock* end_map = map + ik->nonstatic_oop_map_size(); + OopMapBlock* end_map = map + ik->nonstatic_oop_map_count(); while (map < end_map) { - st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->length() - 1)); + st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1)); map++; } st->cr();
--- a/src/share/vm/oops/instanceKlassKlass.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/oops/instanceKlassKlass.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -39,7 +39,7 @@ klassOop allocate_instance_klass(int vtable_len, int itable_len, int static_field_size, - int nonstatic_oop_map_size, + unsigned int nonstatic_oop_map_count, ReferenceType rt, TRAPS);
--- a/src/share/vm/oops/instanceRefKlass.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/oops/instanceRefKlass.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -400,26 +400,26 @@ assert(k == SystemDictionary::reference_klass() && first_time, "Invalid update of maps"); debug_only(first_time = false); - assert(ik->nonstatic_oop_map_size() == 1, "just checking"); + assert(ik->nonstatic_oop_map_count() == 1, "just checking"); OopMapBlock* map = ik->start_of_nonstatic_oop_maps(); // Check that the current map is (2,4) - currently points at field with // offset 2 (words) and has 4 map entries. debug_only(int offset = java_lang_ref_Reference::referent_offset); - debug_only(int length = ((java_lang_ref_Reference::discovered_offset - + debug_only(unsigned int count = ((java_lang_ref_Reference::discovered_offset - java_lang_ref_Reference::referent_offset)/heapOopSize) + 1); if (UseSharedSpaces) { assert(map->offset() == java_lang_ref_Reference::queue_offset && - map->length() == 1, "just checking"); + map->count() == 1, "just checking"); } else { - assert(map->offset() == offset && map->length() == length, + assert(map->offset() == offset && map->count() == count, "just checking"); // Update map to (3,1) - point to offset of 3 (words) with 1 map entry. map->set_offset(java_lang_ref_Reference::queue_offset); - map->set_length(1); + map->set_count(1); } }
--- a/src/share/vm/oops/methodDataOop.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/oops/methodDataOop.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -49,6 +49,12 @@ } } +void DataLayout::follow_weak_refs(BoolObjectClosure* cl) { + ResourceMark m; + data_in()->follow_weak_refs(cl); +} + + // ================================================================== // ProfileData // @@ -145,42 +151,92 @@ // which are used to store a type profile for the receiver of the check. void ReceiverTypeData::follow_contents() { - for (uint row = 0; row < row_limit(); row++) { - if (receiver(row) != NULL) { - MarkSweep::mark_and_push(adr_receiver(row)); - } - } + // This is a set of weak references that need + // to be followed at the end of the strong marking + // phase. Memoize this object so it can be visited + // in the weak roots processing phase. + MarkSweep::revisit_mdo(data()); } #ifndef SERIALGC void ReceiverTypeData::follow_contents(ParCompactionManager* cm) { - for (uint row = 0; row < row_limit(); row++) { - if (receiver(row) != NULL) { - PSParallelCompact::mark_and_push(cm, adr_receiver(row)); - } - } + // This is a set of weak references that need + // to be followed at the end of the strong marking + // phase. Memoize this object so it can be visited + // in the weak roots processing phase. + PSParallelCompact::revisit_mdo(cm, data()); } #endif // SERIALGC void ReceiverTypeData::oop_iterate(OopClosure* blk) { - for (uint row = 0; row < row_limit(); row++) { - if (receiver(row) != NULL) { - blk->do_oop(adr_receiver(row)); - } - } -} - -void ReceiverTypeData::oop_iterate_m(OopClosure* blk, MemRegion mr) { - for (uint row = 0; row < row_limit(); row++) { - if (receiver(row) != NULL) { - oop* adr = adr_receiver(row); - if (mr.contains(adr)) { + if (blk->should_remember_mdo()) { + // This is a set of weak references that need + // to be followed at the end of the strong marking + // phase. Memoize this object so it can be visited + // in the weak roots processing phase. + blk->remember_mdo(data()); + } else { // normal scan + for (uint row = 0; row < row_limit(); row++) { + if (receiver(row) != NULL) { + oop* adr = adr_receiver(row); blk->do_oop(adr); } } } } +void ReceiverTypeData::oop_iterate_m(OopClosure* blk, MemRegion mr) { + // Currently, this interface is called only during card-scanning for + // a young gen gc, in which case this object cannot contribute anything, + // since it does not contain any references that cross out of + // the perm gen. However, for future more general use we allow + // the possibility of calling for instance from more general + // iterators (for example, a future regionalized perm gen for G1, + // or the possibility of moving some references out of perm in + // the case of other collectors). In that case, you will need + // to relax or remove some of the assertions below. +#ifdef ASSERT + // Verify that none of the embedded oop references cross out of + // this generation. + for (uint row = 0; row < row_limit(); row++) { + if (receiver(row) != NULL) { + oop* adr = adr_receiver(row); + CollectedHeap* h = Universe::heap(); + assert(h->is_permanent(adr) && h->is_permanent_or_null(*adr), "Not intra-perm"); + } + } +#endif // ASSERT + assert(!blk->should_remember_mdo(), "Not expected to remember MDO"); + return; // Nothing to do, see comment above +#if 0 + if (blk->should_remember_mdo()) { + // This is a set of weak references that need + // to be followed at the end of the strong marking + // phase. Memoize this object so it can be visited + // in the weak roots processing phase. + blk->remember_mdo(data()); + } else { // normal scan + for (uint row = 0; row < row_limit(); row++) { + if (receiver(row) != NULL) { + oop* adr = adr_receiver(row); + if (mr.contains(adr)) { + blk->do_oop(adr); + } else if ((HeapWord*)adr >= mr.end()) { + // Test that the current cursor and the two ends of the range + // that we may have skipped iterating over are monotonically ordered; + // this is just a paranoid assertion, just in case represetations + // should change in the future rendering the short-circuit return + // here invalid. + assert((row+1 >= row_limit() || adr_receiver(row+1) > adr) && + (row+2 >= row_limit() || adr_receiver(row_limit()-1) > adr_receiver(row+1)), "Reducing?"); + break; // remaining should be outside this mr too + } + } + } + } +#endif +} + void ReceiverTypeData::adjust_pointers() { for (uint row = 0; row < row_limit(); row++) { if (receiver(row) != NULL) { @@ -189,6 +245,15 @@ } } +void ReceiverTypeData::follow_weak_refs(BoolObjectClosure* is_alive_cl) { + for (uint row = 0; row < row_limit(); row++) { + klassOop p = receiver(row); + if (p != NULL && !is_alive_cl->do_object_b(p)) { + clear_row(row); + } + } +} + #ifndef SERIALGC void ReceiverTypeData::update_pointers() { for (uint row = 0; row < row_limit(); row++) { @@ -625,30 +690,33 @@ return NULL; } DataLayout* data_layout = data_layout_at(data_index); + return data_layout->data_in(); +} - switch (data_layout->tag()) { +ProfileData* DataLayout::data_in() { + switch (tag()) { case DataLayout::no_tag: default: ShouldNotReachHere(); return NULL; case DataLayout::bit_data_tag: - return new BitData(data_layout); + return new BitData(this); case DataLayout::counter_data_tag: - return new CounterData(data_layout); + return new CounterData(this); case DataLayout::jump_data_tag: - return new JumpData(data_layout); + return new JumpData(this); case DataLayout::receiver_type_data_tag: - return new ReceiverTypeData(data_layout); + return new ReceiverTypeData(this); case DataLayout::virtual_call_data_tag: - return new VirtualCallData(data_layout); + return new VirtualCallData(this); case DataLayout::ret_data_tag: - return new RetData(data_layout); + return new RetData(this); case DataLayout::branch_data_tag: - return new BranchData(data_layout); + return new BranchData(this); case DataLayout::multi_branch_data_tag: - return new MultiBranchData(data_layout); + return new MultiBranchData(this); case DataLayout::arg_info_data_tag: - return new ArgInfoData(data_layout); + return new ArgInfoData(this); }; }
--- a/src/share/vm/oops/methodDataOop.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/oops/methodDataOop.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -55,6 +55,9 @@ // with invocation counter incrementation. None of these races harm correct // execution of the compiled code. +// forward decl +class ProfileData; + // DataLayout // // Overlay for generic profiling data. @@ -231,6 +234,10 @@ temp._header._struct._flags = byte_constant; return temp._header._bits; } + + // GC support + ProfileData* data_in(); + void follow_weak_refs(BoolObjectClosure* cl); }; @@ -430,6 +437,7 @@ virtual void oop_iterate(OopClosure* blk) {} virtual void oop_iterate_m(OopClosure* blk, MemRegion mr) {} virtual void adjust_pointers() {} + virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure) {} #ifndef SERIALGC // Parallel old support @@ -667,11 +675,27 @@ return recv; } + void set_receiver(uint row, oop p) { + assert((uint)row < row_limit(), "oob"); + set_oop_at(receiver_cell_index(row), p); + } + uint receiver_count(uint row) { assert(row < row_limit(), "oob"); return uint_at(receiver_count_cell_index(row)); } + void set_receiver_count(uint row, uint count) { + assert(row < row_limit(), "oob"); + set_uint_at(receiver_count_cell_index(row), count); + } + + void clear_row(uint row) { + assert(row < row_limit(), "oob"); + set_receiver(row, NULL); + set_receiver_count(row, 0); + } + // Code generation support static ByteSize receiver_offset(uint row) { return cell_offset(receiver_cell_index(row)); @@ -688,6 +712,7 @@ virtual void oop_iterate(OopClosure* blk); virtual void oop_iterate_m(OopClosure* blk, MemRegion mr); virtual void adjust_pointers(); + virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure); #ifndef SERIALGC // Parallel old support
--- a/src/share/vm/prims/jni.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/prims/jni.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -299,7 +299,8 @@ } } klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader, - Handle(), &st, CHECK_NULL); + Handle(), &st, true, + CHECK_NULL); if (TraceClassResolution && k != NULL) { trace_class_resolution(k);
--- a/src/share/vm/prims/jvm.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/prims/jvm.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -762,7 +762,11 @@ } // common code for JVM_DefineClass() and JVM_DefineClassWithSource() -static jclass jvm_define_class_common(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source, TRAPS) { +// and JVM_DefineClassWithSourceCond() +static jclass jvm_define_class_common(JNIEnv *env, const char *name, + jobject loader, const jbyte *buf, + jsize len, jobject pd, const char *source, + jboolean verify, TRAPS) { if (source == NULL) source = "__JVM_DefineClass__"; assert(THREAD->is_Java_thread(), "must be a JavaThread"); @@ -803,6 +807,7 @@ Handle protection_domain (THREAD, JNIHandles::resolve(pd)); klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader, protection_domain, &st, + verify != 0, CHECK_NULL); if (TraceClassResolution && k != NULL) { @@ -816,16 +821,24 @@ JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)) JVMWrapper2("JVM_DefineClass %s", name); - return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, THREAD); + return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, true, THREAD); JVM_END JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)) JVMWrapper2("JVM_DefineClassWithSource %s", name); - return jvm_define_class_common(env, name, loader, buf, len, pd, source, THREAD); -JVM_END - + return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD); +JVM_END + +JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, + jobject loader, const jbyte *buf, + jsize len, jobject pd, + const char *source, jboolean verify)) + JVMWrapper2("JVM_DefineClassWithSourceCond %s", name); + + return jvm_define_class_common(env, name, loader, buf, len, pd, source, verify, THREAD); +JVM_END JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)) JVMWrapper("JVM_FindLoadedClass");
--- a/src/share/vm/prims/jvm.h Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/prims/jvm.h Wed Sep 23 23:56:15 2009 -0700 @@ -417,6 +417,17 @@ const jbyte *buf, jsize len, jobject pd, const char *source); +/* Define a class with a source with conditional verification (added HSX 14) + * -Xverify:all will verify anyway, -Xverify:none will not verify, + * -Xverify:remote (default) will obey this conditional + * i.e. true = should_verify_class + */ +JNIEXPORT jclass JNICALL +JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, + jobject loader, const jbyte *buf, + jsize len, jobject pd, const char *source, + jboolean verify); + /* Define a class with a source (MLVM) */ JNIEXPORT jclass JNICALL JVM_DefineClassWithCP(JNIEnv *env, const char *name, jobject loader,
--- a/src/share/vm/prims/jvmtiRedefineClasses.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/prims/jvmtiRedefineClasses.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -933,7 +933,7 @@ // description. RedefineVerifyMark rvm(&the_class, &scratch_class, state); Verifier::verify( - scratch_class, Verifier::ThrowException, THREAD); + scratch_class, Verifier::ThrowException, true, THREAD); } if (HAS_PENDING_EXCEPTION) { @@ -959,7 +959,7 @@ // verify what we have done during constant pool merging { RedefineVerifyMark rvm(&the_class, &scratch_class, state); - Verifier::verify(scratch_class, Verifier::ThrowException, THREAD); + Verifier::verify(scratch_class, Verifier::ThrowException, true, THREAD); } if (HAS_PENDING_EXCEPTION) {
--- a/src/share/vm/runtime/arguments.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/runtime/arguments.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -1450,6 +1450,7 @@ FLAG_SET_DEFAULT(UseSerialGC, true); FLAG_SET_DEFAULT(UseParNewGC, false); FLAG_SET_DEFAULT(UseConcMarkSweepGC, false); + FLAG_SET_DEFAULT(CMSIncrementalMode, false); // special CMS suboption FLAG_SET_DEFAULT(UseParallelGC, false); FLAG_SET_DEFAULT(UseParallelOldGC, false); FLAG_SET_DEFAULT(UseG1GC, false); @@ -1457,7 +1458,7 @@ static bool verify_serial_gc_flags() { return (UseSerialGC && - !(UseParNewGC || UseConcMarkSweepGC || UseG1GC || + !(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC || UseParallelGC || UseParallelOldGC)); } @@ -1572,7 +1573,7 @@ status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit"); // Check user specified sharing option conflict with Parallel GC - bool cannot_share = (UseConcMarkSweepGC || UseG1GC || UseParNewGC || + bool cannot_share = ((UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC || UseParNewGC || UseParallelGC || UseParallelOldGC || SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages)); @@ -1580,9 +1581,17 @@ // Either force sharing on by forcing the other options off, or // force sharing off. if (DumpSharedSpaces || ForceSharedSpaces) { + jio_fprintf(defaultStream::error_stream(), + "Reverting to Serial GC because of %s \n", + ForceSharedSpaces ? " -Xshare:on" : "-Xshare:dump"); set_serial_gc_flags(); FLAG_SET_DEFAULT(SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages), false); } else { + if (UseSharedSpaces) { + jio_fprintf(defaultStream::error_stream(), + "Turning off use of shared archive because of " + "choice of garbage collector or large pages \n"); + } no_shared_spaces(); } }
--- a/src/share/vm/runtime/globals.hpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/runtime/globals.hpp Wed Sep 23 23:56:15 2009 -0700 @@ -1712,6 +1712,9 @@ product(bool, TLABStats, true, \ "Print various TLAB related information") \ \ + product(bool, PrintRevisitStats, false, \ + "Print revisit (klass and MDO) stack related information") \ + \ product_pd(bool, NeverActAsServerClassMachine, \ "Never act like a server-class machine") \ \
--- a/src/share/vm/runtime/sweeper.cpp Fri Sep 18 09:57:47 2009 -0700 +++ b/src/share/vm/runtime/sweeper.cpp Wed Sep 23 23:56:15 2009 -0700 @@ -136,8 +136,14 @@ // there are no inline caches that referes to it. if (nm->is_marked_for_reclamation()) { assert(!nm->is_locked_by_vm(), "must not flush locked nmethods"); + if (PrintMethodFlushing && Verbose) { + tty->print_cr("### Nmethod 0x%x (marked for reclamation) being flushed", nm); + } nm->flush(); } else { + if (PrintMethodFlushing && Verbose) { + tty->print_cr("### Nmethod 0x%x (zombie) being marked for reclamation", nm); + } nm->mark_for_reclamation(); _rescan = true; } @@ -145,6 +151,9 @@ // If there is no current activations of this method on the // stack we can safely convert it to a zombie method if (nm->can_not_entrant_be_converted()) { + if (PrintMethodFlushing && Verbose) { + tty->print_cr("### Nmethod 0x%x (not entrant) being made zombie", nm); + } nm->make_zombie(); _rescan = true; } else { @@ -157,7 +166,9 @@ } } else if (nm->is_unloaded()) { // Unloaded code, just make it a zombie - if (nm->is_osr_only_method()) { + if (PrintMethodFlushing && Verbose) + tty->print_cr("### Nmethod 0x%x (unloaded) being made zombie", nm); + if (nm->is_osr_method()) { // No inline caches will ever point to osr methods, so we can just remove it nm->flush(); } else {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/6845368/bigobj.java Wed Sep 23 23:56:15 2009 -0700 @@ -0,0 +1,65563 @@ +/* + @test + @bug 6845368 + @summary ensure gc updates references > 64K bytes from the start of the obj + @author John Coomes + @run main/othervm -Xmx64m bigobj +*/ + +// Allocate an object with a block of reference fields that starts more +// than 64K bytes from the start of the object. This is done with +// inheritance because VMs typically rearrange the order fields appear in +// memory, and group fields of the same type together within an object (i.e., +// in a single object, all reference fields could be put into a block near the +// start of the object). +// +// A block of reference fields > 64K bytes from the start of the object would +// cause HotSpot's OopMapBlock _offset field to overflow, so any references in +// that block would not be updated properly after GC. +// +// After allocating the big object, set a reference field within the +// block to a known object, provoke GC, then make sure the field was +// updated properly. + +public class bigobj extends bigparent { + public static void main(String argv[]) { + bigobj c = new bigobj(); + Object o = c.o = new Object(); + + // Provoke GC so o is moved (if this is a moving collector). + for (int i = 0; i < 64 * 1024 * 1024; i++) new Object(); + + if (o != c.o) { + System.out.println("failed: o=" + o + " != c.o=" + c.o); + throw new RuntimeException("failed - c.o was not updated"); + } + } + + Object o; +} + +class bigparent { + public long l00001; + public long l00002; + public long l00003; + public long l00004; + public long l00005; + public long l00006; + public long l00007; + public long l00008; + public long l00009; + public long l00010; + public long l00011; + public long l00012; + public long l00013; + public long l00014; + public long l00015; + public long l00016; + public long l00017; + public long l00018; + public long l00019; + public long l00020; + public long l00021; + public long l00022; + public long l00023; + public long l00024; + public long l00025; + public long l00026; + public long l00027; + public long l00028; + public long l00029; + public long l00030; + public long l00031; + public long l00032; + public long l00033; + public long l00034; + public long l00035; + public long l00036; + public long l00037; + public long l00038; + public long l00039; + public long l00040; + public long l00041; + public long l00042; + public long l00043; + public long l00044; + public long l00045; + public long l00046; + public long l00047; + public long l00048; + public long l00049; + public long l00050; + public long l00051; + public long l00052; + public long l00053; + public long l00054; + public long l00055; + public long l00056; + public long l00057; + public long l00058; + public long l00059; + public long l00060; + public long l00061; + public long l00062; + public long l00063; + public long l00064; + public long l00065; + public long l00066; + public long l00067; + public long l00068; + public long l00069; + public long l00070; + public long l00071; + public long l00072; + public long l00073; + public long l00074; + public long l00075; + public long l00076; + public long l00077; + public long l00078; + public long l00079; + public long l00080; + public long l00081; + public long l00082; + public long l00083; + public long l00084; + public long l00085; + public long l00086; + public long l00087; + public long l00088; + public long l00089; + public long l00090; + public long l00091; + public long l00092; + public long l00093; + public long l00094; + public long l00095; + public long l00096; + public long l00097; + public long l00098; + public long l00099; + public long l00100; + public long l00101; + public long l00102; + public long l00103; + public long l00104; + public long l00105; + public long l00106; + public long l00107; + public long l00108; + public long l00109; + public long l00110; + public long l00111; + public long l00112; + public long l00113; + public long l00114; + public long l00115; + public long l00116; + public long l00117; + public long l00118; + public long l00119; + public long l00120; + public long l00121; + public long l00122; + public long l00123; + public long l00124; + public long l00125; + public long l00126; + public long l00127; + public long l00128; + public long l00129; + public long l00130; + public long l00131; + public long l00132; + public long l00133; + public long l00134; + public long l00135; + public long l00136; + public long l00137; + public long l00138; + public long l00139; + public long l00140; + public long l00141; + public long l00142; + public long l00143; + public long l00144; + public long l00145; + public long l00146; + public long l00147; + public long l00148; + public long l00149; + public long l00150; + public long l00151; + public long l00152; + public long l00153; + public long l00154; + public long l00155; + public long l00156; + public long l00157; + public long l00158; + public long l00159; + public long l00160; + public long l00161; + public long l00162; + public long l00163; + public long l00164; + public long l00165; + public long l00166; + public long l00167; + public long l00168; + public long l00169; + public long l00170; + public long l00171; + public long l00172; + public long l00173; + public long l00174; + public long l00175; + public long l00176; + public long l00177; + public long l00178; + public long l00179; + public long l00180; + public long l00181; + public long l00182; + public long l00183; + public long l00184; + public long l00185; + public long l00186; + public long l00187; + public long l00188; + public long l00189; + public long l00190; + public long l00191; + public long l00192; + public long l00193; + public long l00194; + public long l00195; + public long l00196; + public long l00197; + public long l00198; + public long l00199; + public long l00200; + public long l00201; + public long l00202; + public long l00203; + public long l00204; + public long l00205; + public long l00206; + public long l00207; + public long l00208; + public long l00209; + public long l00210; + public long l00211; + public long l00212; + public long l00213; + public long l00214; + public long l00215; + public long l00216; + public long l00217; + public long l00218; + public long l00219; + public long l00220; + public long l00221; + public long l00222; + public long l00223; + public long l00224; + public long l00225; + public long l00226; + public long l00227; + public long l00228; + public long l00229; + public long l00230; + public long l00231; + public long l00232; + public long l00233; + public long l00234; + public long l00235; + public long l00236; + public long l00237; + public long l00238; + public long l00239; + public long l00240; + public long l00241; + public long l00242; + public long l00243; + public long l00244; + public long l00245; + public long l00246; + public long l00247; + public long l00248; + public long l00249; + public long l00250; + public long l00251; + public long l00252; + public long l00253; + public long l00254; + public long l00255; + public long l00256; + public long l00257; + public long l00258; + public long l00259; + public long l00260; + public long l00261; + public long l00262; + public long l00263; + public long l00264; + public long l00265; + public long l00266; + public long l00267; + public long l00268; + public long l00269; + public long l00270; + public long l00271; + public long l00272; + public long l00273; + public long l00274; + public long l00275; + public long l00276; + public long l00277; + public long l00278; + public long l00279; + public long l00280; + public long l00281; + public long l00282; + public long l00283; + public long l00284; + public long l00285; + public long l00286; + public long l00287; + public long l00288; + public long l00289; + public long l00290; + public long l00291; + public long l00292; + public long l00293; + public long l00294; + public long l00295; + public long l00296; + public long l00297; + public long l00298; + public long l00299; + public long l00300; + public long l00301; + public long l00302; + public long l00303; + public long l00304; + public long l00305; + public long l00306; + public long l00307; + public long l00308; + public long l00309; + public long l00310; + public long l00311; + public long l00312; + public long l00313; + public long l00314; + public long l00315; + public long l00316; + public long l00317; + public long l00318; + public long l00319; + public long l00320; + public long l00321; + public long l00322; + public long l00323; + public long l00324; + public long l00325; + public long l00326; + public long l00327; + public long l00328; + public long l00329; + public long l00330; + public long l00331; + public long l00332; + public long l00333; + public long l00334; + public long l00335; + public long l00336; + public long l00337; + public long l00338; + public long l00339; + public long l00340; + public long l00341; + public long l00342; + public long l00343; + public long l00344; + public long l00345; + public long l00346; + public long l00347; + public long l00348; + public long l00349; + public long l00350; + public long l00351; + public long l00352; + public long l00353; + public long l00354; + public long l00355; + public long l00356; + public long l00357; + public long l00358; + public long l00359; + public long l00360; + public long l00361; + public long l00362; + public long l00363; + public long l00364; + public long l00365; + public long l00366; + public long l00367; + public long l00368; + public long l00369; + public long l00370; + public long l00371; + public long l00372; + public long l00373; + public long l00374; + public long l00375; + public long l00376; + public long l00377; + public long l00378; + public long l00379; + public long l00380; + public long l00381; + public long l00382; + public long l00383; + public long l00384; + public long l00385; + public long l00386; + public long l00387; + public long l00388; + public long l00389; + public long l00390; + public long l00391; + public long l00392; + public long l00393; + public long l00394; + public long l00395; + public long l00396; + public long l00397; + public long l00398; + public long l00399; + public long l00400; + public long l00401; + public long l00402; + public long l00403; + public long l00404; + public long l00405; + public long l00406; + public long l00407; + public long l00408; + public long l00409; + public long l00410; + public long l00411; + public long l00412; + public long l00413; + public long l00414; + public long l00415; + public long l00416; + public long l00417; + public long l00418; + public long l00419; + public long l00420; + public long l00421; + public long l00422; + public long l00423; + public long l00424; + public long l00425; + public long l00426; + public long l00427; + public long l00428; + public long l00429; + public long l00430; + public long l00431; + public long l00432; + public long l00433; + public long l00434; + public long l00435; + public long l00436; + public long l00437; + public long l00438; + public long l00439; + public long l00440; + public long l00441; + public long l00442; + public long l00443; + public long l00444; + public long l00445; + public long l00446; + public long l00447; + public long l00448; + public long l00449; + public long l00450; + public long l00451; + public long l00452; + public long l00453; + public long l00454; + public long l00455; + public long l00456; + public long l00457; + public long l00458; + public long l00459; + public long l00460; + public long l00461; + public long l00462; + public long l00463; + public long l00464; + public long l00465; + public long l00466; + public long l00467; + public long l00468; + public long l00469; + public long l00470; + public long l00471; + public long l00472; + public long l00473; + public long l00474; + public long l00475; + public long l00476; + public long l00477; + public long l00478; + public long l00479; + public long l00480; + public long l00481; + public long l00482; + public long l00483; + public long l00484; + public long l00485; + public long l00486; + public long l00487; + public long l00488; + public long l00489; + public long l00490; + public long l00491; + public long l00492; + public long l00493; + public long l00494; + public long l00495; + public long l00496; + public long l00497; + public long l00498; + public long l00499; + public long l00500; + public long l00501; + public long l00502; + public long l00503; + public long l00504; + public long l00505; + public long l00506; + public long l00507; + public long l00508; + public long l00509; + public long l00510; + public long l00511; + public long l00512; + public long l00513; + public long l00514; + public long l00515; + public long l00516; + public long l00517; + public long l00518; + public long l00519; + public long l00520; + public long l00521; + public long l00522; + public long l00523; + public long l00524; + public long l00525; + public long l00526; + public long l00527; + public long l00528; + public long l00529; + public long l00530; + public long l00531; + public long l00532; + public long l00533; + public long l00534; + public long l00535; + public long l00536; + public long l00537; + public long l00538; + public long l00539; + public long l00540; + public long l00541; + public long l00542; + public long l00543; + public long l00544; + public long l00545; + public long l00546; + public long l00547; + public long l00548; + public long l00549; + public long l00550; + public long l00551; + public long l00552; + public long l00553; + public long l00554; + public long l00555; + public long l00556; + public long l00557; + public long l00558; + public long l00559; + public long l00560; + public long l00561; + public long l00562; + public long l00563; + public long l00564; + public long l00565; + public long l00566; + public long l00567; + public long l00568; + public long l00569; + public long l00570; + public long l00571; + public long l00572; + public long l00573; + public long l00574; + public long l00575; + public long l00576; + public long l00577; + public long l00578; + public long l00579; + public long l00580; + public long l00581; + public long l00582; + public long l00583; + public long l00584; + public long l00585; + public long l00586; + public long l00587; + public long l00588; + public long l00589; + public long l00590; + public long l00591; + public long l00592; + public long l00593; + public long l00594; + public long l00595; + public long l00596; + public long l00597; + public long l00598; + public long l00599; + public long l00600; + public long l00601; + public long l00602; + public long l00603; + public long l00604; + public long l00605; + public long l00606; + public long l00607; + public long l00608; + public long l00609; + public long l00610; + public long l00611; + public long l00612; + public long l00613; + public long l00614; + public long l00615; + public long l00616; + public long l00617; + public long l00618; + public long l00619; + public long l00620; + public long l00621; + public long l00622; + public long l00623; + public long l00624; + public long l00625; + public long l00626; + public long l00627; + public long l00628; + public long l00629; + public long l00630; + public long l00631; + public long l00632; + public long l00633; + public long l00634; + public long l00635; + public long l00636; + public long l00637; + public long l00638; + public long l00639; + public long l00640; + public long l00641; + public long l00642; + public long l00643; + public long l00644; + public long l00645; + public long l00646; + public long l00647; + public long l00648; + public long l00649; + public long l00650; + public long l00651; + public long l00652; + public long l00653; + public long l00654; + public long l00655; + public long l00656; + public long l00657; + public long l00658; + public long l00659; + public long l00660; + public long l00661; + public long l00662; + public long l00663; + public long l00664; + public long l00665; + public long l00666; + public long l00667; + public long l00668; + public long l00669; + public long l00670; + public long l00671; + public long l00672; + public long l00673; + public long l00674; + public long l00675; + public long l00676; + public long l00677; + public long l00678; + public long l00679; + public long l00680; + public long l00681; + public long l00682; + public long l00683; + public long l00684; + public long l00685; + public long l00686; + public long l00687; + public long l00688; + public long l00689; + public long l00690; + public long l00691; + public long l00692; + public long l00693; + public long l00694; + public long l00695; + public long l00696; + public long l00697; + public long l00698; + public long l00699; + public long l00700; + public long l00701; + public long l00702; + public long l00703; + public long l00704; + public long l00705; + public long l00706; + public long l00707; + public long l00708; + public long l00709; + public long l00710; + public long l00711; + public long l00712; + public long l00713; + public long l00714; + public long l00715; + public long l00716; + public long l00717; + public long l00718; + public long l00719; + public long l00720; + public long l00721; + public long l00722; + public long l00723; + public long l00724; + public long l00725; + public long l00726; + public long l00727; + public long l00728; + public long l00729; + public long l00730; + public long l00731; + public long l00732; + public long l00733; + public long l00734; + public long l00735; + public long l00736; + public long l00737; + public long l00738; + public long l00739; + public long l00740; + public long l00741; + public long l00742; + public long l00743; + public long l00744; + public long l00745; + public long l00746; + public long l00747; + public long l00748; + public long l00749; + public long l00750; + public long l00751; + public long l00752; + public long l00753; + public long l00754; + public long l00755; + public long l00756; + public long l00757; + public long l00758; + public long l00759; + public long l00760; + public long l00761; + public long l00762; + public long l00763; + public long l00764; + public long l00765; + public long l00766; + public long l00767; + public long l00768; + public long l00769; + public long l00770; + public long l00771; + public long l00772; + public long l00773; + public long l00774; + public long l00775; + public long l00776; + public long l00777; + public long l00778; + public long l00779; + public long l00780; + public long l00781; + public long l00782; + public long l00783; + public long l00784; + public long l00785; + public long l00786; + public long l00787; + public long l00788; + public long l00789; + public long l00790; + public long l00791; + public long l00792; + public long l00793; + public long l00794; + public long l00795; + public long l00796; + public long l00797; + public long l00798; + public long l00799; + public long l00800; + public long l00801; + public long l00802; + public long l00803; + public long l00804; + public long l00805; + public long l00806; + public long l00807; + public long l00808; + public long l00809; + public long l00810; + public long l00811; + public long l00812; + public long l00813; + public long l00814; + public long l00815; + public long l00816; + public long l00817; + public long l00818; + public long l00819; + public long l00820; + public long l00821; + public long l00822; + public long l00823; + public long l00824; + public long l00825; + public long l00826; + public long l00827; + public long l00828; + public long l00829; + public long l00830; + public long l00831; + public long l00832; + public long l00833; + public long l00834; + public long l00835; + public long l00836; + public long l00837; + public long l00838; + public long l00839; + public long l00840; + public long l00841; + public long l00842; + public long l00843; + public long l00844; + public long l00845; + public long l00846; + public long l00847; + public long l00848; + public long l00849; + public long l00850; + public long l00851; + public long l00852; + public long l00853; + public long l00854; + public long l00855; + public long l00856; + public long l00857; + public long l00858; + public long l00859; + public long l00860; + public long l00861; + public long l00862; + public long l00863; + public long l00864; + public long l00865; + public long l00866; + public long l00867; + public long l00868; + public long l00869; + public long l00870; + public long l00871; + public long l00872; + public long l00873; + public long l00874; + public long l00875; + public long l00876; + public long l00877; + public long l00878; + public long l00879; + public long l00880; + public long l00881; + public long l00882; + public long l00883; + public long l00884; + public long l00885; + public long l00886; + public long l00887; + public long l00888; + public long l00889; + public long l00890; + public long l00891; + public long l00892; + public long l00893; + public long l00894; + public long l00895; + public long l00896; + public long l00897; + public long l00898; + public long l00899; + public long l00900; + public long l00901; + public long l00902; + public long l00903; + public long l00904; + public long l00905; + public long l00906; + public long l00907; + public long l00908; + public long l00909; + public long l00910; + public long l00911; + public long l00912; + public long l00913; + public long l00914; + public long l00915; + public long l00916; + public long l00917; + public long l00918; + public long l00919; + public long l00920; + public long l00921; + public long l00922; + public long l00923; + public long l00924; + public long l00925; + public long l00926; + public long l00927; + public long l00928; + public long l00929; + public long l00930; + public long l00931; + public long l00932; + public long l00933; + public long l00934; + public long l00935; + public long l00936; + public long l00937; + public long l00938; + public long l00939; + public long l00940; + public long l00941; + public long l00942; + public long l00943; + public long l00944; + public long l00945; + public long l00946; + public long l00947; + public long l00948; + public long l00949; + public long l00950; + public long l00951; + public long l00952; + public long l00953; + public long l00954; + public long l00955; + public long l00956; + public long l00957; + public long l00958; + public long l00959; + public long l00960; + public long l00961; + public long l00962; + public long l00963; + public long l00964; + public long l00965; + public long l00966; + public long l00967; + public long l00968; + public long l00969; + public long l00970; + public long l00971; + public long l00972; + public long l00973; + public long l00974; + public long l00975; + public long l00976; + public long l00977; + public long l00978; + public long l00979; + public long l00980; + public long l00981; + public long l00982; + public long l00983; + public long l00984; + public long l00985; + public long l00986; + public long l00987; + public long l00988; + public long l00989; + public long l00990; + public long l00991; + public long l00992; + public long l00993; + public long l00994; + public long l00995; + public long l00996; + public long l00997; + public long l00998; + public long l00999; + public long l01000; + public long l01001; + public long l01002; + public long l01003; + public long l01004; + public long l01005; + public long l01006; + public long l01007; + public long l01008; + public long l01009; + public long l01010; + public long l01011; + public long l01012; + public long l01013; + public long l01014; + public long l01015; + public long l01016; + public long l01017; + public long l01018; + public long l01019; + public long l01020; + public long l01021; + public long l01022; + public long l01023; + public long l01024; + public long l01025; + public long l01026; + public long l01027; + public long l01028; + public long l01029; + public long l01030; + public long l01031; + public long l01032; + public long l01033; + public long l01034; + public long l01035; + public long l01036; + public long l01037; + public long l01038; + public long l01039; + public long l01040; + public long l01041; + public long l01042; + public long l01043; + public long l01044; + public long l01045; + public long l01046; + public long l01047; + public long l01048; + public long l01049; + public long l01050; + public long l01051; + public long l01052; + public long l01053; + public long l01054; + public long l01055; + public long l01056; + public long l01057; + public long l01058; + public long l01059; + public long l01060; + public long l01061; + public long l01062; + public long l01063; + public long l01064; + public long l01065; + public long l01066; + public long l01067; + public long l01068; + public long l01069; + public long l01070; + public long l01071; + public long l01072; + public long l01073; + public long l01074; + public long l01075; + public long l01076; + public long l01077; + public long l01078; + public long l01079; + public long l01080; + public long l01081; + public long l01082; + public long l01083; + public long l01084; + public long l01085; + public long l01086; + public long l01087; + public long l01088; + public long l01089; + public long l01090; + public long l01091; + public long l01092; + public long l01093; + public long l01094; + public long l01095; + public long l01096; + public long l01097; + public long l01098; + public long l01099; + public long l01100; + public long l01101; + public long l01102; + public long l01103; + public long l01104; + public long l01105; + public long l01106; + public long l01107; + public long l01108; + public long l01109; + public long l01110; + public long l01111; + public long l01112; + public long l01113; + public long l01114; + public long l01115; + public long l01116; + public long l01117; + public long l01118; + public long l01119; + public long l01120; + public long l01121; + public long l01122; + public long l01123; + public long l01124; + public long l01125; + public long l01126; + public long l01127; + public long l01128; + public long l01129; + public long l01130; + public long l01131; + public long l01132; + public long l01133; + public long l01134; + public long l01135; + public long l01136; + public long l01137; + public long l01138; + public long l01139; + public long l01140; + public long l01141; + public long l01142; + public long l01143; + public long l01144; + public long l01145; + public long l01146; + public long l01147; + public long l01148; + public long l01149; + public long l01150; + public long l01151; + public long l01152; + public long l01153; + public long l01154; + public long l01155; + public long l01156; + public long l01157; + public long l01158; + public long l01159; + public long l01160; + public long l01161; + public long l01162; + public long l01163; + public long l01164; + public long l01165; + public long l01166; + public long l01167; + public long l01168; + public long l01169; + public long l01170; + public long l01171; + public long l01172; + public long l01173; + public long l01174; + public long l01175; + public long l01176; + public long l01177; + public long l01178; + public long l01179; + public long l01180; + public long l01181; + public long l01182; + public long l01183; + public long l01184; + public long l01185; + public long l01186; + public long l01187; + public long l01188; + public long l01189; + public long l01190; + public long l01191; + public long l01192; + public long l01193; + public long l01194; + public long l01195; + public long l01196; + public long l01197; + public long l01198; + public long l01199; + public long l01200; + public long l01201; + public long l01202; + public long l01203; + public long l01204; + public long l01205; + public long l01206; + public long l01207; + public long l01208; + public long l01209; + public long l01210; + public long l01211; + public long l01212; + public long l01213; + public long l01214; + public long l01215; + public long l01216; + public long l01217; + public long l01218; + public long l01219; + public long l01220; + public long l01221; + public long l01222; + public long l01223; + public long l01224; + public long l01225; + public long l01226; + public long l01227; + public long l01228; + public long l01229; + public long l01230; + public long l01231; + public long l01232; + public long l01233; + public long l01234; + public long l01235; + public long l01236; + public long l01237; + public long l01238; + public long l01239; + public long l01240; + public long l01241; + public long l01242; + public long l01243; + public long l01244; + public long l01245; + public long l01246; + public long l01247; + public long l01248; + public long l01249; + public long l01250; + public long l01251; + public long l01252; + public long l01253; + public long l01254; + public long l01255; + public long l01256; + public long l01257; + public long l01258; + public long l01259; + public long l01260; + public long l01261; + public long l01262; + public long l01263; + public long l01264; + public long l01265; + public long l01266; + public long l01267; + public long l01268; + public long l01269; + public long l01270; + public long l01271; + public long l01272; + public long l01273; + public long l01274; + public long l01275; + public long l01276; + public long l01277; + public long l01278; + public long l01279; + public long l01280; + public long l01281; + public long l01282; + public long l01283; + public long l01284; + public long l01285; + public long l01286; + public long l01287; + public long l01288; + public long l01289; + public long l01290; + public long l01291; + public long l01292; + public long l01293; + public long l01294; + public long l01295; + public long l01296; + public long l01297; + public long l01298; + public long l01299; + public long l01300; + public long l01301; + public long l01302; + public long l01303; + public long l01304; + public long l01305; + public long l01306; + public long l01307; + public long l01308; + public long l01309; + public long l01310; + public long l01311; + public long l01312; + public long l01313; + public long l01314; + public long l01315; + public long l01316; + public long l01317; + public long l01318; + public long l01319; + public long l01320; + public long l01321; + public long l01322; + public long l01323; + public long l01324; + public long l01325; + public long l01326; + public long l01327; + public long l01328; + public long l01329; + public long l01330; + public long l01331; + public long l01332; + public long l01333; + public long l01334; + public long l01335; + public long l01336; + public long l01337; + public long l01338; + public long l01339; + public long l01340; + public long l01341; + public long l01342; + public long l01343; + public long l01344; + public long l01345; + public long l01346; + public long l01347; + public long l01348; + public long l01349; + public long l01350; + public long l01351; + public long l01352; + public long l01353; + public long l01354; + public long l01355; + public long l01356; + public long l01357; + public long l01358; + public long l01359; + public long l01360; + public long l01361; + public long l01362; + public long l01363; + public long l01364; + public long l01365; + public long l01366; + public long l01367; + public long l01368; + public long l01369; + public long l01370; + public long l01371; + public long l01372; + public long l01373; + public long l01374; + public long l01375; + public long l01376; + public long l01377; + public long l01378; + public long l01379; + public long l01380; + public long l01381; + public long l01382; + public long l01383; + public long l01384; + public long l01385; + public long l01386; + public long l01387; + public long l01388; + public long l01389; + public long l01390; + public long l01391; + public long l01392; + public long l01393; + public long l01394; + public long l01395; + public long l01396; + public long l01397; + public long l01398; + public long l01399; + public long l01400; + public long l01401; + public long l01402; + public long l01403; + public long l01404; + public long l01405; + public long l01406; + public long l01407; + public long l01408; + public long l01409; + public long l01410; + public long l01411; + public long l01412; + public long l01413; + public long l01414; + public long l01415; + public long l01416; + public long l01417; + public long l01418; + public long l01419; + public long l01420; + public long l01421; + public long l01422; + public long l01423; + public long l01424; + public long l01425; + public long l01426; + public long l01427; + public long l01428; + public long l01429; + public long l01430; + public long l01431; + public long l01432; + public long l01433; + public long l01434; + public long l01435; + public long l01436; + public long l01437; + public long l01438; + public long l01439; + public long l01440; + public long l01441; + public long l01442; + public long l01443; + public long l01444; + public long l01445; + public long l01446; + public long l01447; + public long l01448; + public long l01449; + public long l01450; + public long l01451; + public long l01452; + public long l01453; + public long l01454; + public long l01455; + public long l01456; + public long l01457; + public long l01458; + public long l01459; + public long l01460; + public long l01461; + public long l01462; + public long l01463; + public long l01464; + public long l01465; + public long l01466; + public long l01467; + public long l01468; + public long l01469; + public long l01470; + public long l01471; + public long l01472; + public long l01473; + public long l01474; + public long l01475; + public long l01476; + public long l01477; + public long l01478; + public long l01479; + public long l01480; + public long l01481; + public long l01482; + public long l01483; + public long l01484; + public long l01485; + public long l01486; + public long l01487; + public long l01488; + public long l01489; + public long l01490; + public long l01491; + public long l01492; + public long l01493; + public long l01494; + public long l01495; + public long l01496; + public long l01497; + public long l01498; + public long l01499; + public long l01500; + public long l01501; + public long l01502; + public long l01503; + public long l01504; + public long l01505; + public long l01506; + public long l01507; + public long l01508; + public long l01509; + public long l01510; + public long l01511; + public long l01512; + public long l01513; + public long l01514; + public long l01515; + public long l01516; + public long l01517; + public long l01518; + public long l01519; + public long l01520; + public long l01521; + public long l01522; + public long l01523; + public long l01524; + public long l01525; + public long l01526; + public long l01527; + public long l01528; + public long l01529; + public long l01530; + public long l01531; + public long l01532; + public long l01533; + public long l01534; + public long l01535; + public long l01536; + public long l01537; + public long l01538; + public long l01539; + public long l01540; + public long l01541; + public long l01542; + public long l01543; + public long l01544; + public long l01545; + public long l01546; + public long l01547; + public long l01548; + public long l01549; + public long l01550; + public long l01551; + public long l01552; + public long l01553; + public long l01554; + public long l01555; + public long l01556; + public long l01557; + public long l01558; + public long l01559; + public long l01560; + public long l01561; + public long l01562; + public long l01563; + public long l01564; + public long l01565; + public long l01566; + public long l01567; + public long l01568; + public long l01569; + public long l01570; + public long l01571; + public long l01572; + public long l01573; + public long l01574; + public long l01575; + public long l01576; + public long l01577; + public long l01578; + public long l01579; + public long l01580; + public long l01581; + public long l01582; + public long l01583; + public long l01584; + public long l01585; + public long l01586; + public long l01587; + public long l01588; + public long l01589; + public long l01590; + public long l01591; + public long l01592; + public long l01593; + public long l01594; + public long l01595; + public long l01596; + public long l01597; + public long l01598; + public long l01599; + public long l01600; + public long l01601; + public long l01602; + public long l01603; + public long l01604; + public long l01605; + public long l01606; + public long l01607; + public long l01608; + public long l01609; + public long l01610; + public long l01611; + public long l01612; + public long l01613; + public long l01614; + public long l01615; + public long l01616; + public long l01617; + public long l01618; + public long l01619; + public long l01620; + public long l01621; + public long l01622; + public long l01623; + public long l01624; + public long l01625; + public long l01626; + public long l01627; + public long l01628; + public long l01629; + public long l01630; + public long l01631; + public long l01632; + public long l01633; + public long l01634; + public long l01635; + public long l01636; + public long l01637; + public long l01638; + public long l01639; + public long l01640; + public long l01641; + public long l01642; + public long l01643; + public long l01644; + public long l01645; + public long l01646; + public long l01647; + public long l01648; + public long l01649; + public long l01650; + public long l01651; + public long l01652; + public long l01653; + public long l01654; + public long l01655; + public long l01656; + public long l01657; + public long l01658; + public long l01659; + public long l01660; + public long l01661; + public long l01662; + public long l01663; + public long l01664; + public long l01665; + public long l01666; + public long l01667; + public long l01668; + public long l01669; + public long l01670; + public long l01671; + public long l01672; + public long l01673; + public long l01674; + public long l01675; + public long l01676; + public long l01677; + public long l01678; + public long l01679; + public long l01680; + public long l01681; + public long l01682; + public long l01683; + public long l01684; + public long l01685; + public long l01686; + public long l01687; + public long l01688; + public long l01689; + public long l01690; + public long l01691; + public long l01692; + public long l01693; + public long l01694; + public long l01695; + public long l01696; + public long l01697; + public long l01698; + public long l01699; + public long l01700; + public long l01701; + public long l01702; + public long l01703; + public long l01704; + public long l01705; + public long l01706; + public long l01707; + public long l01708; + public long l01709; + public long l01710; + public long l01711; + public long l01712; + public long l01713; + public long l01714; + public long l01715; + public long l01716; + public long l01717; + public long l01718; + public long l01719; + public long l01720; + public long l01721; + public long l01722; + public long l01723; + public long l01724; + public long l01725; + public long l01726; + public long l01727; + public long l01728; + public long l01729; + public long l01730; + public long l01731; + public long l01732; + public long l01733; + public long l01734; + public long l01735; + public long l01736; + public long l01737; + public long l01738; + public long l01739; + public long l01740; + public long l01741; + public long l01742; + public long l01743; + public long l01744; + public long l01745; + public long l01746; + public long l01747; + public long l01748; + public long l01749; + public long l01750; + public long l01751; + public long l01752; + public long l01753; + public long l01754; + public long l01755; + public long l01756; + public long l01757; + public long l01758; + public long l01759; + public long l01760; + public long l01761; + public long l01762; + public long l01763; + public long l01764; + public long l01765; + public long l01766; + public long l01767; + public long l01768; + public long l01769; + public long l01770; + public long l01771; + public long l01772; + public long l01773; + public long l01774; + public long l01775; + public long l01776; + public long l01777; + public long l01778; + public long l01779; + public long l01780; + public long l01781; + public long l01782; + public long l01783; + public long l01784; + public long l01785; + public long l01786; + public long l01787; + public long l01788; + public long l01789; + public long l01790; + public long l01791; + public long l01792; + public long l01793; + public long l01794; + public long l01795; + public long l01796; + public long l01797; + public long l01798; + public long l01799; + public long l01800; + public long l01801; + public long l01802; + public long l01803; + public long l01804; + public long l01805; + public long l01806; + public long l01807; + public long l01808; + public long l01809; + public long l01810; + public long l01811; + public long l01812; + public long l01813; + public long l01814; + public long l01815; + public long l01816; + public long l01817; + public long l01818; + public long l01819; + public long l01820; + public long l01821; + public long l01822; + public long l01823; + public long l01824; + public long l01825; + public long l01826; + public long l01827; + public long l01828; + public long l01829; + public long l01830; + public long l01831; + public long l01832; + public long l01833; + public long l01834; + public long l01835; + public long l01836; + public long l01837; + public long l01838; + public long l01839; + public long l01840; + public long l01841; + public long l01842; + public long l01843; + public long l01844; + public long l01845; + public long l01846; + public long l01847; + public long l01848; + public long l01849; + public long l01850; + public long l01851; + public long l01852; + public long l01853; + public long l01854; + public long l01855; + public long l01856; + public long l01857; + public long l01858; + public long l01859; + public long l01860; + public long l01861; + public long l01862; + public long l01863; + public long l01864; + public long l01865; + public long l01866; + public long l01867; + public long l01868; + public long l01869; + public long l01870; + public long l01871; + public long l01872; + public long l01873; + public long l01874; + public long l01875; + public long l01876; + public long l01877; + public long l01878; + public long l01879; + public long l01880; + public long l01881; + public long l01882; + public long l01883; + public long l01884; + public long l01885; + public long l01886; + public long l01887; + public long l01888; + public long l01889; + public long l01890; + public long l01891; + public long l01892; + public long l01893; + public long l01894; + public long l01895; + public long l01896; + public long l01897; + public long l01898; + public long l01899; + public long l01900; + public long l01901; + public long l01902; + public long l01903; + public long l01904; + public long l01905; + public long l01906; + public long l01907; + public long l01908; + public long l01909; + public long l01910; + public long l01911; + public long l01912; + public long l01913; + public long l01914; + public long l01915; + public long l01916; + public long l01917; + public long l01918; + public long l01919; + public long l01920; + public long l01921; + public long l01922; + public long l01923; + public long l01924; + public long l01925; + public long l01926; + public long l01927; + public long l01928; + public long l01929; + public long l01930; + public long l01931; + public long l01932; + public long l01933; + public long l01934; + public long l01935; + public long l01936; + public long l01937; + public long l01938; + public long l01939; + public long l01940; + public long l01941; + public long l01942; + public long l01943; + public long l01944; + public long l01945; + public long l01946; + public long l01947; + public long l01948; + public long l01949; + public long l01950; + public long l01951; + public long l01952; + public long l01953; + public long l01954; + public long l01955; + public long l01956; + public long l01957; + public long l01958; + public long l01959; + public long l01960; + public long l01961; + public long l01962; + public long l01963; + public long l01964; + public long l01965; + public long l01966; + public long l01967; + public long l01968; + public long l01969; + public long l01970; + public long l01971; + public long l01972; + public long l01973; + public long l01974; + public long l01975; + public long l01976; + public long l01977; + public long l01978; + public long l01979; + public long l01980; + public long l01981; + public long l01982; + public long l01983; + public long l01984; + public long l01985; + public long l01986; + public long l01987; + public long l01988; + public long l01989; + public long l01990; + public long l01991; + public long l01992; + public long l01993; + public long l01994; + public long l01995; + public long l01996; + public long l01997; + public long l01998; + public long l01999; + public long l02000; + public long l02001; + public long l02002; + public long l02003; + public long l02004; + public long l02005; + public long l02006; + public long l02007; + public long l02008; + public long l02009; + public long l02010; + public long l02011; + public long l02012; + public long l02013; + public long l02014; + public long l02015; + public long l02016; + public long l02017; + public long l02018; + public long l02019; + public long l02020; + public long l02021; + public long l02022; + public long l02023; + public long l02024; + public long l02025; + public long l02026; + public long l02027; + public long l02028; + public long l02029; + public long l02030; + public long l02031; + public long l02032; + public long l02033; + public long l02034; + public long l02035; + public long l02036; + public long l02037; + public long l02038; + public long l02039; + public long l02040; + public long l02041; + public long l02042; + public long l02043; + public long l02044; + public long l02045; + public long l02046; + public long l02047; + public long l02048; + public long l02049; + public long l02050; + public long l02051; + public long l02052; + public long l02053; + public long l02054; + public long l02055; + public long l02056; + public long l02057; + public long l02058; + public long l02059; + public long l02060; + public long l02061; + public long l02062; + public long l02063; + public long l02064; + public long l02065; + public long l02066; + public long l02067; + public long l02068; + public long l02069; + public long l02070; + public long l02071; + public long l02072; + public long l02073; + public long l02074; + public long l02075; + public long l02076; + public long l02077; + public long l02078; + public long l02079; + public long l02080; + public long l02081; + public long l02082; + public long l02083; + public long l02084; + public long l02085; + public long l02086; + public long l02087; + public long l02088; + public long l02089; + public long l02090; + public long l02091; + public long l02092; + public long l02093; + public long l02094; + public long l02095; + public long l02096; + public long l02097; + public long l02098; + public long l02099; + public long l02100; + public long l02101; + public long l02102; + public long l02103; + public long l02104; + public long l02105; + public long l02106; + public long l02107; + public long l02108; + public long l02109; + public long l02110; + public long l02111; + public long l02112; + public long l02113; + public long l02114; + public long l02115; + public long l02116; + public long l02117; + public long l02118; + public long l02119; + public long l02120; + public long l02121; + public long l02122; + public long l02123; + public long l02124; + public long l02125; + public long l02126; + public long l02127; + public long l02128; + public long l02129; + public long l02130; + public long l02131; + public long l02132; + public long l02133; + public long l02134; + public long l02135; + public long l02136; + public long l02137; + public long l02138; + public long l02139; + public long l02140; + public long l02141; + public long l02142; + public long l02143; + public long l02144; + public long l02145; + public long l02146; + public long l02147; + public long l02148; + public long l02149; + public long l02150; + public long l02151; + public long l02152; + public long l02153; + public long l02154; + public long l02155; + public long l02156; + public long l02157; + public long l02158; + public long l02159; + public long l02160; + public long l02161; + public long l02162; + public long l02163; + public long l02164; + public long l02165; + public long l02166; + public long l02167; + public long l02168; + public long l02169; + public long l02170; + public long l02171; + public long l02172; + public long l02173; + public long l02174; + public long l02175; + public long l02176; + public long l02177; + public long l02178; + public long l02179; + public long l02180; + public long l02181; + public long l02182; + public long l02183; + public long l02184; + public long l02185; + public long l02186; + public long l02187; + public long l02188; + public long l02189; + public long l02190; + public long l02191; + public long l02192; + public long l02193; + public long l02194; + public long l02195; + public long l02196; + public long l02197; + public long l02198; + public long l02199; + public long l02200; + public long l02201; + public long l02202; + public long l02203; + public long l02204; + public long l02205; + public long l02206; + public long l02207; + public long l02208; + public long l02209; + public long l02210; + public long l02211; + public long l02212; + public long l02213; + public long l02214; + public long l02215; + public long l02216; + public long l02217; + public long l02218; + public long l02219; + public long l02220; + public long l02221; + public long l02222; + public long l02223; + public long l02224; + public long l02225; + public long l02226; + public long l02227; + public long l02228; + public long l02229; + public long l02230; + public long l02231; + public long l02232; + public long l02233; + public long l02234; + public long l02235; + public long l02236; + public long l02237; + public long l02238; + public long l02239; + public long l02240; + public long l02241; + public long l02242; + public long l02243; + public long l02244; + public long l02245; + public long l02246; + public long l02247; + public long l02248; + public long l02249; + public long l02250; + public long l02251; + public long l02252; + public long l02253; + public long l02254; + public long l02255; + public long l02256; + public long l02257; + public long l02258; + public long l02259; + public long l02260; + public long l02261; + public long l02262; + public long l02263; + public long l02264; + public long l02265; + public long l02266; + public long l02267; + public long l02268; + public long l02269; + public long l02270; + public long l02271; + public long l02272; + public long l02273; + public long l02274; + public long l02275; + public long l02276; + public long l02277; + public long l02278; + public long l02279; + public long l02280; + public long l02281; + public long l02282; + public long l02283; + public long l02284; + public long l02285; + public long l02286; + public long l02287; + public long l02288; + public long l02289; + public long l02290; + public long l02291; + public long l02292; + public long l02293; + public long l02294; + public long l02295; + public long l02296; + public long l02297; + public long l02298; + public long l02299; + public long l02300; + public long l02301; + public long l02302; + public long l02303; + public long l02304; + public long l02305; + public long l02306; + public long l02307; + public long l02308; + public long l02309; + public long l02310; + public long l02311; + public long l02312; + public long l02313; + public long l02314; + public long l02315; + public long l02316; + public long l02317; + public long l02318; + public long l02319; + public long l02320; + public long l02321; + public long l02322; + public long l02323; + public long l02324; + public long l02325; + public long l02326; + public long l02327; + public long l02328; + public long l02329; + public long l02330; + public long l02331; + public long l02332; + public long l02333; + public long l02334; + public long l02335; + public long l02336; + public long l02337; + public long l02338; + public long l02339; + public long l02340; + public long l02341; + public long l02342; + public long l02343; + public long l02344; + public long l02345; + public long l02346; + public long l02347; + public long l02348; + public long l02349; + public long l02350; + public long l02351; + public long l02352; + public long l02353; + public long l02354; + public long l02355; + public long l02356; + public long l02357; + public long l02358; + public long l02359; + public long l02360; + public long l02361; + public long l02362; + public long l02363; + public long l02364; + public long l02365; + public long l02366; + public long l02367; + public long l02368; + public long l02369; + public long l02370; + public long l02371; + public long l02372; + public long l02373; + public long l02374; + public long l02375; + public long l02376; + public long l02377; + public long l02378; + public long l02379; + public long l02380; + public long l02381; + public long l02382; + public long l02383; + public long l02384; + public long l02385; + public long l02386; + public long l02387; + public long l02388; + public long l02389; + public long l02390; + public long l02391; + public long l02392; + public long l02393; + public long l02394; + public long l02395; + public long l02396; + public long l02397; + public long l02398; + public long l02399; + public long l02400; + public long l02401; + public long l02402; + public long l02403; + public long l02404; + public long l02405; + public long l02406; + public long l02407; + public long l02408; + public long l02409; + public long l02410; + public long l02411; + public long l02412; + public long l02413; + public long l02414; + public long l02415; + public long l02416; + public long l02417; + public long l02418; + public long l02419; + public long l02420; + public long l02421; + public long l02422; + public long l02423; + public long l02424; + public long l02425; + public long l02426; + public long l02427; + public long l02428; + public long l02429; + public long l02430; + public long l02431; + public long l02432; + public long l02433; + public long l02434; + public long l02435; + public long l02436; + public long l02437; + public long l02438; + public long l02439; + public long l02440; + public long l02441; + public long l02442; + public long l02443; + public long l02444; + public long l02445; + public long l02446; + public long l02447; + public long l02448; + public long l02449; + public long l02450; + public long l02451; + public long l02452; + public long l02453; + public long l02454; + public long l02455; + public long l02456; + public long l02457; + public long l02458; + public long l02459; + public long l02460; + public long l02461; + public long l02462; + public long l02463; + public long l02464; + public long l02465; + public long l02466; + public long l02467; + public long l02468; + public long l02469; + public long l02470; + public long l02471; + public long l02472; + public long l02473; + public long l02474; + public long l02475; + public long l02476; + public long l02477; + public long l02478; + public long l02479; + public long l02480; + public long l02481; + public long l02482; + public long l02483; + public long l02484; + public long l02485; + public long l02486; + public long l02487; + public long l02488; + public long l02489; + public long l02490; + public long l02491; + public long l02492; + public long l02493; + public long l02494; + public long l02495; + public long l02496; + public long l02497; + public long l02498; + public long l02499; + public long l02500; + public long l02501; + public long l02502; + public long l02503; + public long l02504; + public long l02505; + public long l02506; + public long l02507; + public long l02508; + public long l02509; + public long l02510; + public long l02511; + public long l02512; + public long l02513; + public long l02514; + public long l02515; + public long l02516; + public long l02517; + public long l02518; + public long l02519; + public long l02520; + public long l02521; + public long l02522; + public long l02523; + public long l02524; + public long l02525; + public long l02526; + public long l02527; + public long l02528; + public long l02529; + public long l02530; + public long l02531; + public long l02532; + public long l02533; + public long l02534; + public long l02535; + public long l02536; + public long l02537; + public long l02538; + public long l02539; + public long l02540; + public long l02541; + public long l02542; + public long l02543; + public long l02544; + public long l02545; + public long l02546; + public long l02547; + public long l02548; + public long l02549; + public long l02550; + public long l02551; + public long l02552; + public long l02553; + public long l02554; + public long l02555; + public long l02556; + public long l02557; + public long l02558; + public long l02559; + public long l02560; + public long l02561; + public long l02562; + public long l02563; + public long l02564; + public long l02565; + public long l02566; + public long l02567; + public long l02568; + public long l02569; + public long l02570; + public long l02571; + public long l02572; + public long l02573; + public long l02574; + public long l02575; + public long l02576; + public long l02577; + public long l02578; + public long l02579; + public long l02580; + public long l02581; + public long l02582; + public long l02583; + public long l02584; + public long l02585; + public long l02586; + public long l02587; + public long l02588; + public long l02589; + public long l02590; + public long l02591; + public long l02592; + public long l02593; + public long l02594; + public long l02595; + public long l02596; + public long l02597; + public long l02598; + public long l02599; + public long l02600; + public long l02601; + public long l02602; + public long l02603; + public long l02604; + public long l02605; + public long l02606; + public long l02607; + public long l02608; + public long l02609; + public long l02610; + public long l02611; + public long l02612; + public long l02613; + public long l02614; + public long l02615; + public long l02616; + public long l02617; + public long l02618; + public long l02619; + public long l02620; + public long l02621; + public long l02622; + public long l02623; + public long l02624; + public long l02625; + public long l02626; + public long l02627; + public long l02628; + public long l02629; + public long l02630; + public long l02631; + public long l02632; + public long l02633; + public long l02634; + public long l02635; + public long l02636; + public long l02637; + public long l02638; + public long l02639; + public long l02640; + public long l02641; + public long l02642; + public long l02643; + public long l02644; + public long l02645; + public long l02646; + public long l02647; + public long l02648; + public long l02649; + public long l02650; + public long l02651; + public long l02652; + public long l02653; + public long l02654; + public long l02655; + public long l02656; + public long l02657; + public long l02658; + public long l02659; + public long l02660; + public long l02661; + public long l02662; + public long l02663; + public long l02664; + public long l02665; + public long l02666; + public long l02667; + public long l02668; + public long l02669; + public long l02670; + public long l02671; + public long l02672; + public long l02673; + public long l02674; + public long l02675; + public long l02676; + public long l02677; + public long l02678; + public long l02679; + public long l02680; + public long l02681; + public long l02682; + public long l02683; + public long l02684; + public long l02685; + public long l02686; + public long l02687; + public long l02688; + public long l02689; + public long l02690; + public long l02691; + public long l02692; + public long l02693; + public long l02694; + public long l02695; + public long l02696; + public long l02697; + public long l02698; + public long l02699; + public long l02700; + public long l02701; + public long l02702; + public long l02703; + public long l02704; + public long l02705; + public long l02706; + public long l02707; + public long l02708; + public long l02709; + public long l02710; + public long l02711; + public long l02712; + public long l02713; + public long l02714; + public long l02715; + public long l02716; + public long l02717; + public long l02718; + public long l02719; + public long l02720; + public long l02721; + public long l02722; + public long l02723; + public long l02724; + public long l02725; + public long l02726; + public long l02727; + public long l02728; + public long l02729; + public long l02730; + public long l02731; + public long l02732; + public long l02733; + public long l02734; + public long l02735; + public long l02736; + public long l02737; + public long l02738; + public long l02739; + public long l02740; + public long l02741; + public long l02742; + public long l02743; + public long l02744; + public long l02745; + public long l02746; + public long l02747; + public long l02748; + public long l02749; + public long l02750; + public long l02751; + public long l02752; + public long l02753; + public long l02754; + public long l02755; + public long l02756; + public long l02757; + public long l02758; + public long l02759; + public long l02760; + public long l02761; + public long l02762; + public long l02763; + public long l02764; + public long l02765; + public long l02766; + public long l02767; + public long l02768; + public long l02769; + public long l02770; + public long l02771; + public long l02772; + public long l02773; + public long l02774; + public long l02775; + public long l02776; + public long l02777; + public long l02778; + public long l02779; + public long l02780; + public long l02781; + public long l02782; + public long l02783; + public long l02784; + public long l02785; + public long l02786; + public long l02787; + public long l02788; + public long l02789; + public long l02790; + public long l02791; + public long l02792; + public long l02793; + public long l02794; + public long l02795; + public long l02796; + public long l02797; + public long l02798; + public long l02799; + public long l02800; + public long l02801; + public long l02802; + public long l02803; + public long l02804; + public long l02805; + public long l02806; + public long l02807; + public long l02808; + public long l02809; + public long l02810; + public long l02811; + public long l02812; + public long l02813; + public long l02814; + public long l02815; + public long l02816; + public long l02817; + public long l02818; + public long l02819; + public long l02820; + public long l02821; + public long l02822; + public long l02823; + public long l02824; + public long l02825; + public long l02826; + public long l02827; + public long l02828; + public long l02829; + public long l02830; + public long l02831; + public long l02832; + public long l02833; + public long l02834; + public long l02835; + public long l02836; + public long l02837; + public long l02838; + public long l02839; + public long l02840; + public long l02841; + public long l02842; + public long l02843; + public long l02844; + public long l02845; + public long l02846; + public long l02847; + public long l02848; + public long l02849; + public long l02850; + public long l02851; + public long l02852; + public long l02853; + public long l02854; + public long l02855; + public long l02856; + public long l02857; + public long l02858; + public long l02859; + public long l02860; + public long l02861; + public long l02862; + public long l02863; + public long l02864; + public long l02865; + public long l02866; + public long l02867; + public long l02868; + public long l02869; + public long l02870; + public long l02871; + public long l02872; + public long l02873; + public long l02874; + public long l02875; + public long l02876; + public long l02877; + public long l02878; + public long l02879; + public long l02880; + public long l02881; + public long l02882; + public long l02883; + public long l02884; + public long l02885; + public long l02886; + public long l02887; + public long l02888; + public long l02889; + public long l02890; + public long l02891; + public long l02892; + public long l02893; + public long l02894; + public long l02895; + public long l02896; + public long l02897; + public long l02898; + public long l02899; + public long l02900; + public long l02901; + public long l02902; + public long l02903; + public long l02904; + public long l02905; + public long l02906; + public long l02907; + public long l02908; + public long l02909; + public long l02910; + public long l02911; + public long l02912; + public long l02913; + public long l02914; + public long l02915; + public long l02916; + public long l02917; + public long l02918; + public long l02919; + public long l02920; + public long l02921; + public long l02922; + public long l02923; + public long l02924; + public long l02925; + public long l02926; + public long l02927; + public long l02928; + public long l02929; + public long l02930; + public long l02931; + public long l02932; + public long l02933; + public long l02934; + public long l02935; + public long l02936; + public long l02937; + public long l02938; + public long l02939; + public long l02940; + public long l02941; + public long l02942; + public long l02943; + public long l02944; + public long l02945; + public long l02946; + public long l02947; + public long l02948; + public long l02949; + public long l02950; + public long l02951; + public long l02952; + public long l02953; + public long l02954; + public long l02955; + public long l02956; + public long l02957; + public long l02958; + public long l02959; + public long l02960; + public long l02961; + public long l02962; + public long l02963; + public long l02964; + public long l02965; + public long l02966; + public long l02967; + public long l02968; + public long l02969; + public long l02970; + public long l02971; + public long l02972; + public long l02973; + public long l02974; + public long l02975; + public long l02976; + public long l02977; + public long l02978; + public long l02979; + public long l02980; + public long l02981; + public long l02982; + public long l02983; + public long l02984; + public long l02985; + public long l02986; + public long l02987; + public long l02988; + public long l02989; + public long l02990; + public long l02991; + public long l02992; + public long l02993; + public long l02994; + public long l02995; + public long l02996; + public long l02997; + public long l02998; + public long l02999; + public long l03000; + public long l03001; + public long l03002; + public long l03003; + public long l03004; + public long l03005; + public long l03006; + public long l03007; + public long l03008; + public long l03009; + public long l03010; + public long l03011; + public long l03012; + public long l03013; + public long l03014; + public long l03015; + public long l03016; + public long l03017; + public long l03018; + public long l03019; + public long l03020; + public long l03021; + public long l03022; + public long l03023; + public long l03024; + public long l03025; + public long l03026; + public long l03027; + public long l03028; + public long l03029; + public long l03030; + public long l03031; + public long l03032; + public long l03033; + public long l03034; + public long l03035; + public long l03036; + public long l03037; + public long l03038; + public long l03039; + public long l03040; + public long l03041; + public long l03042; + public long l03043; + public long l03044; + public long l03045; + public long l03046; + public long l03047; + public long l03048; + public long l03049; + public long l03050; + public long l03051; + public long l03052; + public long l03053; + public long l03054; + public long l03055; + public long l03056; + public long l03057; + public long l03058; + public long l03059; + public long l03060; + public long l03061; + public long l03062; + public long l03063; + public long l03064; + public long l03065; + public long l03066; + public long l03067; + public long l03068; + public long l03069; + public long l03070; + public long l03071; + public long l03072; + public long l03073; + public long l03074; + public long l03075; + public long l03076; + public long l03077; + public long l03078; + public long l03079; + public long l03080; + public long l03081; + public long l03082; + public long l03083; + public long l03084; + public long l03085; + public long l03086; + public long l03087; + public long l03088; + public long l03089; + public long l03090; + public long l03091; + public long l03092; + public long l03093; + public long l03094; + public long l03095; + public long l03096; + public long l03097; + public long l03098; + public long l03099; + public long l03100; + public long l03101; + public long l03102; + public long l03103; + public long l03104; + public long l03105; + public long l03106; + public long l03107; + public long l03108; + public long l03109; + public long l03110; + public long l03111; + public long l03112; + public long l03113; + public long l03114; + public long l03115; + public long l03116; + public long l03117; + public long l03118; + public long l03119; + public long l03120; + public long l03121; + public long l03122; + public long l03123; + public long l03124; + public long l03125; + public long l03126; + public long l03127; + public long l03128; + public long l03129; + public long l03130; + public long l03131; + public long l03132; + public long l03133; + public long l03134; + public long l03135; + public long l03136; + public long l03137; + public long l03138; + public long l03139; + public long l03140; + public long l03141; + public long l03142; + public long l03143; + public long l03144; + public long l03145; + public long l03146; + public long l03147; + public long l03148; + public long l03149; + public long l03150; + public long l03151; + public long l03152; + public long l03153; + public long l03154; + public long l03155; + public long l03156; + public long l03157; + public long l03158; + public long l03159; + public long l03160; + public long l03161; + public long l03162; + public long l03163; + public long l03164; + public long l03165; + public long l03166; + public long l03167; + public long l03168; + public long l03169; + public long l03170; + public long l03171; + public long l03172; + public long l03173; + public long l03174; + public long l03175; + public long l03176; + public long l03177; + public long l03178; + public long l03179; + public long l03180; + public long l03181; + public long l03182; + public long l03183; + public long l03184; + public long l03185; + public long l03186; + public long l03187; + public long l03188; + public long l03189; + public long l03190; + public long l03191; + public long l03192; + public long l03193; + public long l03194; + public long l03195; + public long l03196; + public long l03197; + public long l03198; + public long l03199; + public long l03200; + public long l03201; + public long l03202; + public long l03203; + public long l03204; + public long l03205; + public long l03206; + public long l03207; + public long l03208; + public long l03209; + public long l03210; + public long l03211; + public long l03212; + public long l03213; + public long l03214; + public long l03215; + public long l03216; + public long l03217; + public long l03218; + public long l03219; + public long l03220; + public long l03221; + public long l03222; + public long l03223; + public long l03224; + public long l03225; + public long l03226; + public long l03227; + public long l03228; + public long l03229; + public long l03230; + public long l03231; + public long l03232; + public long l03233; + public long l03234; + public long l03235; + public long l03236; + public long l03237; + public long l03238; + public long l03239; + public long l03240; + public long l03241; + public long l03242; + public long l03243; + public long l03244; + public long l03245; + public long l03246; + public long l03247; + public long l03248; + public long l03249; + public long l03250; + public long l03251; + public long l03252; + public long l03253; + public long l03254; + public long l03255; + public long l03256; + public long l03257; + public long l03258; + public long l03259; + public long l03260; + public long l03261; + public long l03262; + public long l03263; + public long l03264; + public long l03265; + public long l03266; + public long l03267; + public long l03268; + public long l03269; + public long l03270; + public long l03271; + public long l03272; + public long l03273; + public long l03274; + public long l03275; + public long l03276; + public long l03277; + public long l03278; + public long l03279; + public long l03280; + public long l03281; + public long l03282; + public long l03283; + public long l03284; + public long l03285; + public long l03286; + public long l03287; + public long l03288; + public long l03289; + public long l03290; + public long l03291; + public long l03292; + public long l03293; + public long l03294; + public long l03295; + public long l03296; + public long l03297; + public long l03298; + public long l03299; + public long l03300; + public long l03301; + public long l03302; + public long l03303; + public long l03304; + public long l03305; + public long l03306; + public long l03307; + public long l03308; + public long l03309; + public long l03310; + public long l03311; + public long l03312; + public long l03313; + public long l03314; + public long l03315; + public long l03316; + public long l03317; + public long l03318; + public long l03319; + public long l03320; + public long l03321; + public long l03322; + public long l03323; + public long l03324; + public long l03325; + public long l03326; + public long l03327; + public long l03328; + public long l03329; + public long l03330; + public long l03331; + public long l03332; + public long l03333; + public long l03334; + public long l03335; + public long l03336; + public long l03337; + public long l03338; + public long l03339; + public long l03340; + public long l03341; + public long l03342; + public long l03343; + public long l03344; + public long l03345; + public long l03346; + public long l03347; + public long l03348; + public long l03349; + public long l03350; + public long l03351; + public long l03352; + public long l03353; + public long l03354; + public long l03355; + public long l03356; + public long l03357; + public long l03358; + public long l03359; + public long l03360; + public long l03361; + public long l03362; + public long l03363; + public long l03364; + public long l03365; + public long l03366; + public long l03367; + public long l03368; + public long l03369; + public long l03370; + public long l03371; + public long l03372; + public long l03373; + public long l03374; + public long l03375; + public long l03376; + public long l03377; + public long l03378; + public long l03379; + public long l03380; + public long l03381; + public long l03382; + public long l03383; + public long l03384; + public long l03385; + public long l03386; + public long l03387; + public long l03388; + public long l03389; + public long l03390; + public long l03391; + public long l03392; + public long l03393; + public long l03394; + public long l03395; + public long l03396; + public long l03397; + public long l03398; + public long l03399; + public long l03400; + public long l03401; + public long l03402; + public long l03403; + public long l03404; + public long l03405; + public long l03406; + public long l03407; + public long l03408; + public long l03409; + public long l03410; + public long l03411; + public long l03412; + public long l03413; + public long l03414; + public long l03415; + public long l03416; + public long l03417; + public long l03418; + public long l03419; + public long l03420; + public long l03421; + public long l03422; + public long l03423; + public long l03424; + public long l03425; + public long l03426; + public long l03427; + public long l03428; + public long l03429; + public long l03430; + public long l03431; + public long l03432; + public long l03433; + public long l03434; + public long l03435; + public long l03436; + public long l03437; + public long l03438; + public long l03439; + public long l03440; + public long l03441; + public long l03442; + public long l03443; + public long l03444; + public long l03445; + public long l03446; + public long l03447; + public long l03448; + public long l03449; + public long l03450; + public long l03451; + public long l03452; + public long l03453; + public long l03454; + public long l03455; + public long l03456; + public long l03457; + public long l03458; + public long l03459; + public long l03460; + public long l03461; + public long l03462; + public long l03463; + public long l03464; + public long l03465; + public long l03466; + public long l03467; + public long l03468; + public long l03469; + public long l03470; + public long l03471; + public long l03472; + public long l03473; + public long l03474; + public long l03475; + public long l03476; + public long l03477; + public long l03478; + public long l03479; + public long l03480; + public long l03481; + public long l03482; + public long l03483; + public long l03484; + public long l03485; + public long l03486; + public long l03487; + public long l03488; + public long l03489; + public long l03490; + public long l03491; + public long l03492; + public long l03493; + public long l03494; + public long l03495; + public long l03496; + public long l03497; + public long l03498; + public long l03499; + public long l03500; + public long l03501; + public long l03502; + public long l03503; + public long l03504; + public long l03505; + public long l03506; + public long l03507; + public long l03508; + public long l03509; + public long l03510; + public long l03511; + public long l03512; + public long l03513; + public long l03514; + public long l03515; + public long l03516; + public long l03517; + public long l03518; + public long l03519; + public long l03520; + public long l03521; + public long l03522; + public long l03523; + public long l03524; + public long l03525; + public long l03526; + public long l03527; + public long l03528; + public long l03529; + public long l03530; + public long l03531; + public long l03532; + public long l03533; + public long l03534; + public long l03535; + public long l03536; + public long l03537; + public long l03538; + public long l03539; + public long l03540; + public long l03541; + public long l03542; + public long l03543; + public long l03544; + public long l03545; + public long l03546; + public long l03547; + public long l03548; + public long l03549; + public long l03550; + public long l03551; + public long l03552; + public long l03553; + public long l03554; + public long l03555; + public long l03556; + public long l03557; + public long l03558; + public long l03559; + public long l03560; + public long l03561; + public long l03562; + public long l03563; + public long l03564; + public long l03565; + public long l03566; + public long l03567; + public long l03568; + public long l03569; + public long l03570; + public long l03571; + public long l03572; + public long l03573; + public long l03574; + public long l03575; + public long l03576; + public long l03577; + public long l03578; + public long l03579; + public long l03580; + public long l03581; + public long l03582; + public long l03583; + public long l03584; + public long l03585; + public long l03586; + public long l03587; + public long l03588; + public long l03589; + public long l03590; + public long l03591; + public long l03592; + public long l03593; + public long l03594; + public long l03595; + public long l03596; + public long l03597; + public long l03598; + public long l03599; + public long l03600; + public long l03601; + public long l03602; + public long l03603; + public long l03604; + public long l03605; + public long l03606; + public long l03607; + public long l03608; + public long l03609; + public long l03610; + public long l03611; + public long l03612; + public long l03613; + public long l03614; + public long l03615; + public long l03616; + public long l03617; + public long l03618; + public long l03619; + public long l03620; + public long l03621; + public long l03622; + public long l03623; + public long l03624; + public long l03625; + public long l03626; + public long l03627; + public long l03628; + public long l03629; + public long l03630; + public long l03631; + public long l03632; + public long l03633; + public long l03634; + public long l03635; + public long l03636; + public long l03637; + public long l03638; + public long l03639; + public long l03640; + public long l03641; + public long l03642; + public long l03643; + public long l03644; + public long l03645; + public long l03646; + public long l03647; + public long l03648; + public long l03649; + public long l03650; + public long l03651; + public long l03652; + public long l03653; + public long l03654; + public long l03655; + public long l03656; + public long l03657; + public long l03658; + public long l03659; + public long l03660; + public long l03661; + public long l03662; + public long l03663; + public long l03664; + public long l03665; + public long l03666; + public long l03667; + public long l03668; + public long l03669; + public long l03670; + public long l03671; + public long l03672; + public long l03673; + public long l03674; + public long l03675; + public long l03676; + public long l03677; + public long l03678; + public long l03679; + public long l03680; + public long l03681; + public long l03682; + public long l03683; + public long l03684; + public long l03685; + public long l03686; + public long l03687; + public long l03688; + public long l03689; + public long l03690; + public long l03691; + public long l03692; + public long l03693; + public long l03694; + public long l03695; + public long l03696; + public long l03697; + public long l03698; + public long l03699; + public long l03700; + public long l03701; + public long l03702; + public long l03703; + public long l03704; + public long l03705; + public long l03706; + public long l03707; + public long l03708; + public long l03709; + public long l03710; + public long l03711; + public long l03712; + public long l03713; + public long l03714; + public long l03715; + public long l03716; + public long l03717; + public long l03718; + public long l03719; + public long l03720; + public long l03721; + public long l03722; + public long l03723; + public long l03724; + public long l03725; + public long l03726; + public long l03727; + public long l03728; + public long l03729; + public long l03730; + public long l03731; + public long l03732; + public long l03733; + public long l03734; + public long l03735; + public long l03736; + public long l03737; + public long l03738; + public long l03739; + public long l03740; + public long l03741; + public long l03742; + public long l03743; + public long l03744; + public long l03745; + public long l03746; + public long l03747; + public long l03748; + public long l03749; + public long l03750; + public long l03751; + public long l03752; + public long l03753; + public long l03754; + public long l03755; + public long l03756; + public long l03757; + public long l03758; + public long l03759; + public long l03760; + public long l03761; + public long l03762; + public long l03763; + public long l03764; + public long l03765; + public long l03766; + public long l03767; + public long l03768; + public long l03769; + public long l03770; + public long l03771; + public long l03772; + public long l03773; + public long l03774; + public long l03775; + public long l03776; + public long l03777; + public long l03778; + public long l03779; + public long l03780; + public long l03781; + public long l03782; + public long l03783; + public long l03784; + public long l03785; + public long l03786; + public long l03787; + public long l03788; + public long l03789; + public long l03790; + public long l03791; + public long l03792; + public long l03793; + public long l03794; + public long l03795; + public long l03796; + public long l03797; + public long l03798; + public long l03799; + public long l03800; + public long l03801; + public long l03802; + public long l03803; + public long l03804; + public long l03805; + public long l03806; + public long l03807; + public long l03808; + public long l03809; + public long l03810; + public long l03811; + public long l03812; + public long l03813; + public long l03814; + public long l03815; + public long l03816; + public long l03817; + public long l03818; + public long l03819; + public long l03820; + public long l03821; + public long l03822; + public long l03823; + public long l03824; + public long l03825; + public long l03826; + public long l03827; + public long l03828; + public long l03829; + public long l03830; + public long l03831; + public long l03832; + public long l03833; + public long l03834; + public long l03835; + public long l03836; + public long l03837; + public long l03838; + public long l03839; + public long l03840; + public long l03841; + public long l03842; + public long l03843; + public long l03844; + public long l03845; + public long l03846; + public long l03847; + public long l03848; + public long l03849; + public long l03850; + public long l03851; + public long l03852; + public long l03853; + public long l03854; + public long l03855; + public long l03856; + public long l03857; + public long l03858; + public long l03859; + public long l03860; + public long l03861; + public long l03862; + public long l03863; + public long l03864; + public long l03865; + public long l03866; + public long l03867; + public long l03868; + public long l03869; + public long l03870; + public long l03871; + public long l03872; + public long l03873; + public long l03874; + public long l03875; + public long l03876; + public long l03877; + public long l03878; + public long l03879; + public long l03880; + public long l03881; + public long l03882; + public long l03883; + public long l03884; + public long l03885; + public long l03886; + public long l03887; + public long l03888; + public long l03889; + public long l03890; + public long l03891; + public long l03892; + public long l03893; + public long l03894; + public long l03895; + public long l03896; + public long l03897; + public long l03898; + public long l03899; + public long l03900; + public long l03901; + public long l03902; + public long l03903; + public long l03904; + public long l03905; + public long l03906; + public long l03907; + public long l03908; + public long l03909; + public long l03910; + public long l03911; + public long l03912; + public long l03913; + public long l03914; + public long l03915; + public long l03916; + public long l03917; + public long l03918; + public long l03919; + public long l03920; + public long l03921; + public long l03922; + public long l03923; + public long l03924; + public long l03925; + public long l03926; + public long l03927; + public long l03928; + public long l03929; + public long l03930; + public long l03931; + public long l03932; + public long l03933; + public long l03934; + public long l03935; + public long l03936; + public long l03937; + public long l03938; + public long l03939; + public long l03940; + public long l03941; + public long l03942; + public long l03943; + public long l03944; + public long l03945; + public long l03946; + public long l03947; + public long l03948; + public long l03949; + public long l03950; + public long l03951; + public long l03952; + public long l03953; + public long l03954; + public long l03955; + public long l03956; + public long l03957; + public long l03958; + public long l03959; + public long l03960; + public long l03961; + public long l03962; + public long l03963; + public long l03964; + public long l03965; + public long l03966; + public long l03967; + public long l03968; + public long l03969; + public long l03970; + public long l03971; + public long l03972; + public long l03973; + public long l03974; + public long l03975; + public long l03976; + public long l03977; + public long l03978; + public long l03979; + public long l03980; + public long l03981; + public long l03982; + public long l03983; + public long l03984; + public long l03985; + public long l03986; + public long l03987; + public long l03988; + public long l03989; + public long l03990; + public long l03991; + public long l03992; + public long l03993; + public long l03994; + public long l03995; + public long l03996; + public long l03997; + public long l03998; + public long l03999; + public long l04000; + public long l04001; + public long l04002; + public long l04003; + public long l04004; + public long l04005; + public long l04006; + public long l04007; + public long l04008; + public long l04009; + public long l04010; + public long l04011; + public long l04012; + public long l04013; + public long l04014; + public long l04015; + public long l04016; + public long l04017; + public long l04018; + public long l04019; + public long l04020; + public long l04021; + public long l04022; + public long l04023; + public long l04024; + public long l04025; + public long l04026; + public long l04027; + public long l04028; + public long l04029; + public long l04030; + public long l04031; + public long l04032; + public long l04033; + public long l04034; + public long l04035; + public long l04036; + public long l04037; + public long l04038; + public long l04039; + public long l04040; + public long l04041; + public long l04042; + public long l04043; + public long l04044; + public long l04045; + public long l04046; + public long l04047; + public long l04048; + public long l04049; + public long l04050; + public long l04051; + public long l04052; + public long l04053; + public long l04054; + public long l04055; + public long l04056; + public long l04057; + public long l04058; + public long l04059; + public long l04060; + public long l04061; + public long l04062; + public long l04063; + public long l04064; + public long l04065; + public long l04066; + public long l04067; + public long l04068; + public long l04069; + public long l04070; + public long l04071; + public long l04072; + public long l04073; + public long l04074; + public long l04075; + public long l04076; + public long l04077; + public long l04078; + public long l04079; + public long l04080; + public long l04081; + public long l04082; + public long l04083; + public long l04084; + public long l04085; + public long l04086; + public long l04087; + public long l04088; + public long l04089; + public long l04090; + public long l04091; + public long l04092; + public long l04093; + public long l04094; + public long l04095; + public long l04096; + public long l04097; + public long l04098; + public long l04099; + public long l04100; + public long l04101; + public long l04102; + public long l04103; + public long l04104; + public long l04105; + public long l04106; + public long l04107; + public long l04108; + public long l04109; + public long l04110; + public long l04111; + public long l04112; + public long l04113; + public long l04114; + public long l04115; + public long l04116; + public long l04117; + public long l04118; + public long l04119; + public long l04120; + public long l04121; + public long l04122; + public long l04123; + public long l04124; + public long l04125; + public long l04126; + public long l04127; + public long l04128; + public long l04129; + public long l04130; + public long l04131; + public long l04132; + public long l04133; + public long l04134; + public long l04135; + public long l04136; + public long l04137; + public long l04138; + public long l04139; + public long l04140; + public long l04141; + public long l04142; + public long l04143; + public long l04144; + public long l04145; + public long l04146; + public long l04147; + public long l04148; + public long l04149; + public long l04150; + public long l04151; + public long l04152; + public long l04153; + public long l04154; + public long l04155; + public long l04156; + public long l04157; + public long l04158; + public long l04159; + public long l04160; + public long l04161; + public long l04162; + public long l04163; + public long l04164; + public long l04165; + public long l04166; + public long l04167; + public long l04168; + public long l04169; + public long l04170; + public long l04171; + public long l04172; + public long l04173; + public long l04174; + public long l04175; + public long l04176; + public long l04177; + public long l04178; + public long l04179; + public long l04180; + public long l04181; + public long l04182; + public long l04183; + public long l04184; + public long l04185; + public long l04186; + public long l04187; + public long l04188; + public long l04189; + public long l04190; + public long l04191; + public long l04192; + public long l04193; + public long l04194; + public long l04195; + public long l04196; + public long l04197; + public long l04198; + public long l04199; + public long l04200; + public long l04201; + public long l04202; + public long l04203; + public long l04204; + public long l04205; + public long l04206; + public long l04207; + public long l04208; + public long l04209; + public long l04210; + public long l04211; + public long l04212; + public long l04213; + public long l04214; + public long l04215; + public long l04216; + public long l04217; + public long l04218; + public long l04219; + public long l04220; + public long l04221; + public long l04222; + public long l04223; + public long l04224; + public long l04225; + public long l04226; + public long l04227; + public long l04228; + public long l04229; + public long l04230; + public long l04231; + public long l04232; + public long l04233; + public long l04234; + public long l04235; + public long l04236; + public long l04237; + public long l04238; + public long l04239; + public long l04240; + public long l04241; + public long l04242; + public long l04243; + public long l04244; + public long l04245; + public long l04246; + public long l04247; + public long l04248; + public long l04249; + public long l04250; + public long l04251; + public long l04252; + public long l04253; + public long l04254; + public long l04255; + public long l04256; + public long l04257; + public long l04258; + public long l04259; + public long l04260; + public long l04261; + public long l04262; + public long l04263; + public long l04264; + public long l04265; + public long l04266; + public long l04267; + public long l04268; + public long l04269; + public long l04270; + public long l04271; + public long l04272; + public long l04273; + public long l04274; + public long l04275; + public long l04276; + public long l04277; + public long l04278; + public long l04279; + public long l04280; + public long l04281; + public long l04282; + public long l04283; + public long l04284; + public long l04285; + public long l04286; + public long l04287; + public long l04288; + public long l04289; + public long l04290; + public long l04291; + public long l04292; + public long l04293; + public long l04294; + public long l04295; + public long l04296; + public long l04297; + public long l04298; + public long l04299; + public long l04300; + public long l04301; + public long l04302; + public long l04303; + public long l04304; + public long l04305; + public long l04306; + public long l04307; + public long l04308; + public long l04309; + public long l04310; + public long l04311; + public long l04312; + public long l04313; + public long l04314; + public long l04315; + public long l04316; + public long l04317; + public long l04318; + public long l04319; + public long l04320; + public long l04321; + public long l04322; + public long l04323; + public long l04324; + public long l04325; + public long l04326; + public long l04327; + public long l04328; + public long l04329; + public long l04330; + public long l04331; + public long l04332; + public long l04333; + public long l04334; + public long l04335; + public long l04336; + public long l04337; + public long l04338; + public long l04339; + public long l04340; + public long l04341; + public long l04342; + public long l04343; + public long l04344; + public long l04345; + public long l04346; + public long l04347; + public long l04348; + public long l04349; + public long l04350; + public long l04351; + public long l04352; + public long l04353; + public long l04354; + public long l04355; + public long l04356; + public long l04357; + public long l04358; + public long l04359; + public long l04360; + public long l04361; + public long l04362; + public long l04363; + public long l04364; + public long l04365; + public long l04366; + public long l04367; + public long l04368; + public long l04369; + public long l04370; + public long l04371; + public long l04372; + public long l04373; + public long l04374; + public long l04375; + public long l04376; + public long l04377; + public long l04378; + public long l04379; + public long l04380; + public long l04381; + public long l04382; + public long l04383; + public long l04384; + public long l04385; + public long l04386; + public long l04387; + public long l04388; + public long l04389; + public long l04390; + public long l04391; + public long l04392; + public long l04393; + public long l04394; + public long l04395; + public long l04396; + public long l04397; + public long l04398; + public long l04399; + public long l04400; + public long l04401; + public long l04402; + public long l04403; + public long l04404; + public long l04405; + public long l04406; + public long l04407; + public long l04408; + public long l04409; + public long l04410; + public long l04411; + public long l04412; + public long l04413; + public long l04414; + public long l04415; + public long l04416; + public long l04417; + public long l04418; + public long l04419; + public long l04420; + public long l04421; + public long l04422; + public long l04423; + public long l04424; + public long l04425; + public long l04426; + public long l04427; + public long l04428; + public long l04429; + public long l04430; + public long l04431; + public long l04432; + public long l04433; + public long l04434; + public long l04435; + public long l04436; + public long l04437; + public long l04438; + public long l04439; + public long l04440; + public long l04441; + public long l04442; + public long l04443; + public long l04444; + public long l04445; + public long l04446; + public long l04447; + public long l04448; + public long l04449; + public long l04450; + public long l04451; + public long l04452; + public long l04453; + public long l04454; + public long l04455; + public long l04456; + public long l04457; + public long l04458; + public long l04459; + public long l04460; + public long l04461; + public long l04462; + public long l04463; + public long l04464; + public long l04465; + public long l04466; + public long l04467; + public long l04468; + public long l04469; + public long l04470; + public long l04471; + public long l04472; + public long l04473; + public long l04474; + public long l04475; + public long l04476; + public long l04477; + public long l04478; + public long l04479; + public long l04480; + public long l04481; + public long l04482; + public long l04483; + public long l04484; + public long l04485; + public long l04486; + public long l04487; + public long l04488; + public long l04489; + public long l04490; + public long l04491; + public long l04492; + public long l04493; + public long l04494; + public long l04495; + public long l04496; + public long l04497; + public long l04498; + public long l04499; + public long l04500; + public long l04501; + public long l04502; + public long l04503; + public long l04504; + public long l04505; + public long l04506; + public long l04507; + public long l04508; + public long l04509; + public long l04510; + public long l04511; + public long l04512; + public long l04513; + public long l04514; + public long l04515; + public long l04516; + public long l04517; + public long l04518; + public long l04519; + public long l04520; + public long l04521; + public long l04522; + public long l04523; + public long l04524; + public long l04525; + public long l04526; + public long l04527; + public long l04528; + public long l04529; + public long l04530; + public long l04531; + public long l04532; + public long l04533; + public long l04534; + public long l04535; + public long l04536; + public long l04537; + public long l04538; + public long l04539; + public long l04540; + public long l04541; + public long l04542; + public long l04543; + public long l04544; + public long l04545; + public long l04546; + public long l04547; + public long l04548; + public long l04549; + public long l04550; + public long l04551; + public long l04552; + public long l04553; + public long l04554; + public long l04555; + public long l04556; + public long l04557; + public long l04558; + public long l04559; + public long l04560; + public long l04561; + public long l04562; + public long l04563; + public long l04564; + public long l04565; + public long l04566; + public long l04567; + public long l04568; + public long l04569; + public long l04570; + public long l04571; + public long l04572; + public long l04573; + public long l04574; + public long l04575; + public long l04576; + public long l04577; + public long l04578; + public long l04579; + public long l04580; + public long l04581; + public long l04582; + public long l04583; + public long l04584; + public long l04585; + public long l04586; + public long l04587; + public long l04588; + public long l04589; + public long l04590; + public long l04591; + public long l04592; + public long l04593; + public long l04594; + public long l04595; + public long l04596; + public long l04597; + public long l04598; + public long l04599; + public long l04600; + public long l04601; + public long l04602; + public long l04603; + public long l04604; + public long l04605; + public long l04606; + public long l04607; + public long l04608; + public long l04609; + public long l04610; + public long l04611; + public long l04612; + public long l04613; + public long l04614; + public long l04615; + public long l04616; + public long l04617; + public long l04618; + public long l04619; + public long l04620; + public long l04621; + public long l04622; + public long l04623; + public long l04624; + public long l04625; + public long l04626; + public long l04627; + public long l04628; + public long l04629; + public long l04630; + public long l04631; + public long l04632; + public long l04633; + public long l04634; + public long l04635; + public long l04636; + public long l04637; + public long l04638; + public long l04639; + public long l04640; + public long l04641; + public long l04642; + public long l04643; + public long l04644; + public long l04645; + public long l04646; + public long l04647; + public long l04648; + public long l04649; + public long l04650; + public long l04651; + public long l04652; + public long l04653; + public long l04654; + public long l04655; + public long l04656; + public long l04657; + public long l04658; + public long l04659; + public long l04660; + public long l04661; + public long l04662; + public long l04663; + public long l04664; + public long l04665; + public long l04666; + public long l04667; + public long l04668; + public long l04669; + public long l04670; + public long l04671; + public long l04672; + public long l04673; + public long l04674; + public long l04675; + public long l04676; + public long l04677; + public long l04678; + public long l04679; + public long l04680; + public long l04681; + public long l04682; + public long l04683; + public long l04684; + public long l04685; + public long l04686; + public long l04687; + public long l04688; + public long l04689; + public long l04690; + public long l04691; + public long l04692; + public long l04693; + public long l04694; + public long l04695; + public long l04696; + public long l04697; + public long l04698; + public long l04699; + public long l04700; + public long l04701; + public long l04702; + public long l04703; + public long l04704; + public long l04705; + public long l04706; + public long l04707; + public long l04708; + public long l04709; + public long l04710; + public long l04711; + public long l04712; + public long l04713; + public long l04714; + public long l04715; + public long l04716; + public long l04717; + public long l04718; + public long l04719; + public long l04720; + public long l04721; + public long l04722; + public long l04723; + public long l04724; + public long l04725; + public long l04726; + public long l04727; + public long l04728; + public long l04729; + public long l04730; + public long l04731; + public long l04732; + public long l04733; + public long l04734; + public long l04735; + public long l04736; + public long l04737; + public long l04738; + public long l04739; + public long l04740; + public long l04741; + public long l04742; + public long l04743; + public long l04744; + public long l04745; + public long l04746; + public long l04747; + public long l04748; + public long l04749; + public long l04750; + public long l04751; + public long l04752; + public long l04753; + public long l04754; + public long l04755; + public long l04756; + public long l04757; + public long l04758; + public long l04759; + public long l04760; + public long l04761; + public long l04762; + public long l04763; + public long l04764; + public long l04765; + public long l04766; + public long l04767; + public long l04768; + public long l04769; + public long l04770; + public long l04771; + public long l04772; + public long l04773; + public long l04774; + public long l04775; + public long l04776; + public long l04777; + public long l04778; + public long l04779; + public long l04780; + public long l04781; + public long l04782; + public long l04783; + public long l04784; + public long l04785; + public long l04786; + public long l04787; + public long l04788; + public long l04789; + public long l04790; + public long l04791; + public long l04792; + public long l04793; + public long l04794; + public long l04795; + public long l04796; + public long l04797; + public long l04798; + public long l04799; + public long l04800; + public long l04801; + public long l04802; + public long l04803; + public long l04804; + public long l04805; + public long l04806; + public long l04807; + public long l04808; + public long l04809; + public long l04810; + public long l04811; + public long l04812; + public long l04813; + public long l04814; + public long l04815; + public long l04816; + public long l04817; + public long l04818; + public long l04819; + public long l04820; + public long l04821; + public long l04822; + public long l04823; + public long l04824; + public long l04825; + public long l04826; + public long l04827; + public long l04828; + public long l04829; + public long l04830; + public long l04831; + public long l04832; + public long l04833; + public long l04834; + public long l04835; + public long l04836; + public long l04837; + public long l04838; + public long l04839; + public long l04840; + public long l04841; + public long l04842; + public long l04843; + public long l04844; + public long l04845; + public long l04846; + public long l04847; + public long l04848; + public long l04849; + public long l04850; + public long l04851; + public long l04852; + public long l04853; + public long l04854; + public long l04855; + public long l04856; + public long l04857; + public long l04858; + public long l04859; + public long l04860; + public long l04861; + public long l04862; + public long l04863; + public long l04864; + public long l04865; + public long l04866; + public long l04867; + public long l04868; + public long l04869; + public long l04870; + public long l04871; + public long l04872; + public long l04873; + public long l04874; + public long l04875; + public long l04876; + public long l04877; + public long l04878; + public long l04879; + public long l04880; + public long l04881; + public long l04882; + public long l04883; + public long l04884; + public long l04885; + public long l04886; + public long l04887; + public long l04888; + public long l04889; + public long l04890; + public long l04891; + public long l04892; + public long l04893; + public long l04894; + public long l04895; + public long l04896; + public long l04897; + public long l04898; + public long l04899; + public long l04900; + public long l04901; + public long l04902; + public long l04903; + public long l04904; + public long l04905; + public long l04906; + public long l04907; + public long l04908; + public long l04909; + public long l04910; + public long l04911; + public long l04912; + public long l04913; + public long l04914; + public long l04915; + public long l04916; + public long l04917; + public long l04918; + public long l04919; + public long l04920; + public long l04921; + public long l04922; + public long l04923; + public long l04924; + public long l04925; + public long l04926; + public long l04927; + public long l04928; + public long l04929; + public long l04930; + public long l04931; + public long l04932; + public long l04933; + public long l04934; + public long l04935; + public long l04936; + public long l04937; + public long l04938; + public long l04939; + public long l04940; + public long l04941; + public long l04942; + public long l04943; + public long l04944; + public long l04945; + public long l04946; + public long l04947; + public long l04948; + public long l04949; + public long l04950; + public long l04951; + public long l04952; + public long l04953; + public long l04954; + public long l04955; + public long l04956; + public long l04957; + public long l04958; + public long l04959; + public long l04960; + public long l04961; + public long l04962; + public long l04963; + public long l04964; + public long l04965; + public long l04966; + public long l04967; + public long l04968; + public long l04969; + public long l04970; + public long l04971; + public long l04972; + public long l04973; + public long l04974; + public long l04975; + public long l04976; + public long l04977; + public long l04978; + public long l04979; + public long l04980; + public long l04981; + public long l04982; + public long l04983; + public long l04984; + public long l04985; + public long l04986; + public long l04987; + public long l04988; + public long l04989; + public long l04990; + public long l04991; + public long l04992; + public long l04993; + public long l04994; + public long l04995; + public long l04996; + public long l04997; + public long l04998; + public long l04999; + public long l05000; + public long l05001; + public long l05002; + public long l05003; + public long l05004; + public long l05005; + public long l05006; + public long l05007; + public long l05008; + public long l05009; + public long l05010; + public long l05011; + public long l05012; + public long l05013; + public long l05014; + public long l05015; + public long l05016; + public long l05017; + public long l05018; + public long l05019; + public long l05020; + public long l05021; + public long l05022; + public long l05023; + public long l05024; + public long l05025; + public long l05026; + public long l05027; + public long l05028; + public long l05029; + public long l05030; + public long l05031; + public long l05032; + public long l05033; + public long l05034; + public long l05035; + public long l05036; + public long l05037; + public long l05038; + public long l05039; + public long l05040; + public long l05041; + public long l05042; + public long l05043; + public long l05044; + public long l05045; + public long l05046; + public long l05047; + public long l05048; + public long l05049; + public long l05050; + public long l05051; + public long l05052; + public long l05053; + public long l05054; + public long l05055; + public long l05056; + public long l05057; + public long l05058; + public long l05059; + public long l05060; + public long l05061; + public long l05062; + public long l05063; + public long l05064; + public long l05065; + public long l05066; + public long l05067; + public long l05068; + public long l05069; + public long l05070; + public long l05071; + public long l05072; + public long l05073; + public long l05074; + public long l05075; + public long l05076; + public long l05077; + public long l05078; + public long l05079; + public long l05080; + public long l05081; + public long l05082; + public long l05083; + public long l05084; + public long l05085; + public long l05086; + public long l05087; + public long l05088; + public long l05089; + public long l05090; + public long l05091; + public long l05092; + public long l05093; + public long l05094; + public long l05095; + public long l05096; + public long l05097; + public long l05098; + public long l05099; + public long l05100; + public long l05101; + public long l05102; + public long l05103; + public long l05104; + public long l05105; + public long l05106; + public long l05107; + public long l05108; + public long l05109; + public long l05110; + public long l05111; + public long l05112; + public long l05113; + public long l05114; + public long l05115; + public long l05116; + public long l05117; + public long l05118; + public long l05119; + public long l05120; + public long l05121; + public long l05122; + public long l05123; + public long l05124; + public long l05125; + public long l05126; + public long l05127; + public long l05128; + public long l05129; + public long l05130; + public long l05131; + public long l05132; + public long l05133; + public long l05134; + public long l05135; + public long l05136; + public long l05137; + public long l05138; + public long l05139; + public long l05140; + public long l05141; + public long l05142; + public long l05143; + public long l05144; + public long l05145; + public long l05146; + public long l05147; + public long l05148; + public long l05149; + public long l05150; + public long l05151; + public long l05152; + public long l05153; + public long l05154; + public long l05155; + public long l05156; + public long l05157; + public long l05158; + public long l05159; + public long l05160; + public long l05161; + public long l05162; + public long l05163; + public long l05164; + public long l05165; + public long l05166; + public long l05167; + public long l05168; + public long l05169; + public long l05170; + public long l05171; + public long l05172; + public long l05173; + public long l05174; + public long l05175; + public long l05176; + public long l05177; + public long l05178; + public long l05179; + public long l05180; + public long l05181; + public long l05182; + public long l05183; + public long l05184; + public long l05185; + public long l05186; + public long l05187; + public long l05188; + public long l05189; + public long l05190; + public long l05191; + public long l05192; + public long l05193; + public long l05194; + public long l05195; + public long l05196; + public long l05197; + public long l05198; + public long l05199; + public long l05200; + public long l05201; + public long l05202; + public long l05203; + public long l05204; + public long l05205; + public long l05206; + public long l05207; + public long l05208; + public long l05209; + public long l05210; + public long l05211; + public long l05212; + public long l05213; + public long l05214; + public long l05215; + public long l05216; + public long l05217; + public long l05218; + public long l05219; + public long l05220; + public long l05221; + public long l05222; + public long l05223; + public long l05224; + public long l05225; + public long l05226; + public long l05227; + public long l05228; + public long l05229; + public long l05230; + public long l05231; + public long l05232; + public long l05233; + public long l05234; + public long l05235; + public long l05236; + public long l05237; + public long l05238; + public long l05239; + public long l05240; + public long l05241; + public long l05242; + public long l05243; + public long l05244; + public long l05245; + public long l05246; + public long l05247; + public long l05248; + public long l05249; + public long l05250; + public long l05251; + public long l05252; + public long l05253; + public long l05254; + public long l05255; + public long l05256; + public long l05257; + public long l05258; + public long l05259; + public long l05260; + public long l05261; + public long l05262; + public long l05263; + public long l05264; + public long l05265; + public long l05266; + public long l05267; + public long l05268; + public long l05269; + public long l05270; + public long l05271; + public long l05272; + public long l05273; + public long l05274; + public long l05275; + public long l05276; + public long l05277; + public long l05278; + public long l05279; + public long l05280; + public long l05281; + public long l05282; + public long l05283; + public long l05284; + public long l05285; + public long l05286; + public long l05287; + public long l05288; + public long l05289; + public long l05290; + public long l05291; + public long l05292; + public long l05293; + public long l05294; + public long l05295; + public long l05296; + public long l05297; + public long l05298; + public long l05299; + public long l05300; + public long l05301; + public long l05302; + public long l05303; + public long l05304; + public long l05305; + public long l05306; + public long l05307; + public long l05308; + public long l05309; + public long l05310; + public long l05311; + public long l05312; + public long l05313; + public long l05314; + public long l05315; + public long l05316; + public long l05317; + public long l05318; + public long l05319; + public long l05320; + public long l05321; + public long l05322; + public long l05323; + public long l05324; + public long l05325; + public long l05326; + public long l05327; + public long l05328; + public long l05329; + public long l05330; + public long l05331; + public long l05332; + public long l05333; + public long l05334; + public long l05335; + public long l05336; + public long l05337; + public long l05338; + public long l05339; + public long l05340; + public long l05341; + public long l05342; + public long l05343; + public long l05344; + public long l05345; + public long l05346; + public long l05347; + public long l05348; + public long l05349; + public long l05350; + public long l05351; + public long l05352; + public long l05353; + public long l05354; + public long l05355; + public long l05356; + public long l05357; + public long l05358; + public long l05359; + public long l05360; + public long l05361; + public long l05362; + public long l05363; + public long l05364; + public long l05365; + public long l05366; + public long l05367; + public long l05368; + public long l05369; + public long l05370; + public long l05371; + public long l05372; + public long l05373; + public long l05374; + public long l05375; + public long l05376; + public long l05377; + public long l05378; + public long l05379; + public long l05380; + public long l05381; + public long l05382; + public long l05383; + public long l05384; + public long l05385; + public long l05386; + public long l05387; + public long l05388; + public long l05389; + public long l05390; + public long l05391; + public long l05392; + public long l05393; + public long l05394; + public long l05395; + public long l05396; + public long l05397; + public long l05398; + public long l05399; + public long l05400; + public long l05401; + public long l05402; + public long l05403; + public long l05404; + public long l05405; + public long l05406; + public long l05407; + public long l05408; + public long l05409; + public long l05410; + public long l05411; + public long l05412; + public long l05413; + public long l05414; + public long l05415; + public long l05416;