--- old/src/share/vm/memory/universe.cpp Thu Jan 7 10:24:41 2016 +++ new/src/share/vm/memory/universe.cpp Thu Jan 7 10:24:40 2016 @@ -129,6 +129,7 @@ objArrayOop Universe::_preallocated_out_of_memory_error_array = NULL; volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0; bool Universe::_verify_in_progress = false; +long Universe::verify_flags = Universe::Verify_All; oop Universe::_null_ptr_exception_instance = NULL; oop Universe::_arithmetic_exception_instance = NULL; oop Universe::_virtual_machine_error_instance = NULL; @@ -669,6 +670,9 @@ MetaspaceShared::prepare_for_dumping(); } } + if (VerifySubSet[0] != '\0') { + Universe::initialize_verify_flags(); + } return JNI_OK; } @@ -1103,6 +1107,56 @@ } } +void Universe::initialize_verify_flags() { + verify_flags = 0; + + size_t length = strlen(VerifySubSet); + char* subset_list = (char*) os::malloc(length + 1, mtInternal); + if (subset_list == NULL) { + tty->print_cr("VerifySubSet: Could not allocate memory for verify-subset, skipping subset initailization."); + return; + } + strncpy(subset_list, VerifySubSet, length + 1); + + char* token = strtok(subset_list, " ,"); + while (token != NULL) { + if (strcmp(token, "threads") == 0) { + verify_flags |= Verify_Threads; + } else if (strcmp(token, "heap") == 0) { + verify_flags |= Verify_Heap; + } else if (strcmp(token, "symbol_table") == 0) { + verify_flags |= Verify_SymbolTable; + } else if (strcmp(token, "string_table") == 0) { + verify_flags |= Verify_StringTable; + } else if (strcmp(token, "codecache") == 0) { + verify_flags |= Verify_CodeCache; + } else if (strcmp(token, "dictionary") == 0) { + verify_flags |= Verify_SystemDictionary; + } else if (strcmp(token, "classloader_data_graph") == 0) { + verify_flags |= Verify_ClassLoaderDataGraph; + } else if (strcmp(token, "metaspace") == 0) { + verify_flags |= Verify_MetaspaceAux; + } else if (strcmp(token, "jni_handles") == 0) { + verify_flags |= Verify_JNIHandles; + } else if (strcmp(token, "c-heap") == 0) { + verify_flags |= Verify_CHeap; + } else if (strcmp(token, "codecache_oops") == 0) { + verify_flags |= Verify_CodeCacheOops; + } else { + tty->print_cr("VerifySubSet: %s is unknown, skipping it.", token); + } + token = strtok(NULL, " ,"); + } + free(subset_list); +} + +bool Universe::should_verify_subset(uint subset) { + if (verify_flags & subset) { + return true; + } + return false; +} + void Universe::verify(VerifyOption option, const char* prefix) { // The use of _verify_in_progress is a temporary work around for // 6320749. Don't bother with a creating a class to set and clear @@ -1122,33 +1176,55 @@ FormatBuffer<> title("Verifying %s", prefix); GCTraceTime(Info, gc, verify) tm(title.buffer()); - log_debug(gc, verify)("Threads"); - Threads::verify(); - log_debug(gc, verify)("Heap"); - heap()->verify(option); - log_debug(gc, verify)("SymbolTable"); - SymbolTable::verify(); - log_debug(gc, verify)("StringTable"); - StringTable::verify(); + if (should_verify_subset(Verify_Threads)) { + log_debug(gc, verify)("Threads"); + Threads::verify(); + } + if (should_verify_subset(Verify_Heap)) { + log_debug(gc, verify)("Heap"); + heap()->verify(option); + } + if (should_verify_subset(Verify_SymbolTable)) { + log_debug(gc, verify)("SymbolTable"); + SymbolTable::verify(); + } + if (should_verify_subset(Verify_StringTable)) { + log_debug(gc, verify)("StringTable"); + StringTable::verify(); + } + if (should_verify_subset(Verify_CodeCache)) { { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); log_debug(gc, verify)("CodeCache"); CodeCache::verify(); } - log_debug(gc, verify)("SystemDictionary"); - SystemDictionary::verify(); + } + if (should_verify_subset(Verify_SystemDictionary)) { + log_debug(gc, verify)("SystemDictionary"); + SystemDictionary::verify(); + } #ifndef PRODUCT - log_debug(gc, verify)("ClassLoaderDataGraph"); - ClassLoaderDataGraph::verify(); + if (should_verify_subset(Verify_ClassLoaderDataGraph)) { + log_debug(gc, verify)("ClassLoaderDataGraph"); + ClassLoaderDataGraph::verify(); + } #endif - log_debug(gc, verify)("MetaspaceAux"); - MetaspaceAux::verify_free_chunks(); - log_debug(gc, verify)("JNIHandles"); - JNIHandles::verify(); - log_debug(gc, verify)("C-heap"); - os::check_heap(); - log_debug(gc, verify)("CodeCache Oops"); - CodeCache::verify_oops(); + if (should_verify_subset(Verify_MetaspaceAux)) { + log_debug(gc, verify)("MetaspaceAux"); + MetaspaceAux::verify_free_chunks(); + } + if (should_verify_subset(Verify_JNIHandles)) { + log_debug(gc, verify)("JNIHandles"); + JNIHandles::verify(); + } + if (should_verify_subset(Verify_CHeap)) { + log_debug(gc, verify)("C-heap"); + os::check_heap(); + } + if (should_verify_subset(Verify_CodeCacheOops)) { + log_debug(gc, verify)("CodeCache Oops"); + CodeCache::verify_oops(); + } _verify_in_progress = false; } --- old/src/share/vm/memory/universe.hpp Thu Jan 7 10:24:47 2016 +++ new/src/share/vm/memory/universe.hpp Thu Jan 7 10:24:46 2016 @@ -255,6 +255,7 @@ // True during call to verify(). Should only be set/cleared in verify(). static bool _verify_in_progress; + static long verify_flags; static uintptr_t _verify_oop_mask; static uintptr_t _verify_oop_bits; @@ -463,6 +464,22 @@ static void init_self_patching_vtbl_list(void** list, int count); // Debugging + enum VERIFY_FLAGS { + Verify_Threads = 1, + Verify_Heap = 2, + Verify_SymbolTable = 4, + Verify_StringTable = 8, + Verify_CodeCache = 16, + Verify_SystemDictionary = 32, + Verify_ClassLoaderDataGraph = 64, + Verify_MetaspaceAux = 128, + Verify_JNIHandles = 256, + Verify_CHeap = 512, + Verify_CodeCacheOops = 1024, + Verify_All = -1 + }; + static void initialize_verify_flags(); + static bool should_verify_subset(uint subset); static bool verify_in_progress() { return _verify_in_progress; } static void verify(VerifyOption option, const char* prefix); static void verify(const char* prefix) { --- old/src/share/vm/runtime/globals.hpp Thu Jan 7 10:24:52 2016 +++ new/src/share/vm/runtime/globals.hpp Thu Jan 7 10:24:51 2016 @@ -2341,6 +2341,14 @@ diagnostic(bool, VerifyDuringGC, false, \ "Verify memory system during GC (between phases)") \ \ + diagnostic(ccstrlist, VerifySubSet, "", \ + "Memory sub-systems to verify when Verify*GC flag(s) \ + are enabled. One or more sub-systems can be specified \ + in a comma separated string. Sub-systems are: \ + threads, heap, symbol_table, string_table, codecache, \ + dictionary, classloader_data_graph, metaspace, jni_handles, \ + c-heap, codecache_oops") \ + \ diagnostic(bool, GCParallelVerificationEnabled, true, \ "Enable parallel memory system verification") \ \ --- /dev/null Thu Jan 7 10:25:00 2016 +++ new/test/gc/TestVerifySubSet.java Thu Jan 7 10:24:58 2016 @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* @test TestVerifySubSet.java + * @key gc + * @bug 8072725 + * @summary Test VerifySubSet option + * @library /testlibrary + * @modules java.base/sun.misc + * java.management + */ + +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.ProcessTools; +import java.util.ArrayList; +import java.util.Collections; + +class RunSystemGC { + public static void main(String args[]) throws Exception { + System.gc(); + } +} + +public class TestVerifySubSet { + private static String[] getTestJavaOpts() { + String testVmOptsStr = System.getProperty("test.java.opts"); + if (!testVmOptsStr.isEmpty()) { + return testVmOptsStr.split(" "); + } else { + return new String[] {}; + } + } + + private static OutputAnalyzer runTest(String subset) throws Exception { + ArrayList vmOpts = new ArrayList(); + + Collections.addAll(vmOpts, getTestJavaOpts()); + Collections.addAll(vmOpts, new String[] {"-XX:+UnlockDiagnosticVMOptions", + "-XX:+VerifyBeforeGC", + "-XX:+VerifyAfterGC", + "-Xlog:gc+verify=debug", + "-XX:VerifySubSet="+subset, + RunSystemGC.class.getName()}); + ProcessBuilder pb = + ProcessTools.createJavaProcessBuilder(vmOpts.toArray(new String[vmOpts.size()])); + OutputAnalyzer output = new OutputAnalyzer(pb.start()); + + System.out.println("Output:\n" + output.getOutput()); + return output; + } + + + public static void main(String args[]) throws Exception { + + OutputAnalyzer output; + + output = runTest("heap, threads, codecache, metaspace"); + output.shouldContain("Heap"); + output.shouldContain("Threads"); + output.shouldContain("CodeCache"); + output.shouldContain("MetaspaceAux"); + + output.shouldNotContain("SymbolTable"); + output.shouldNotContain("StringTable"); + output.shouldNotContain("SystemDictionary"); + output.shouldNotContain("CodeCache Oops"); + + output.shouldHaveExitValue(0); + } +}