--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp Fri Oct 03 00:21:49 2014 +0200
@@ -128,9 +128,7 @@
}
uint ConcurrentG1Refine::thread_num() {
- uint n_threads = (G1ConcRefinementThreads > 0) ? G1ConcRefinementThreads
- : ParallelGCThreads;
- return MAX2<uint>(n_threads, 1);
+ return G1ConcRefinementThreads;
}
void ConcurrentG1Refine::print_worker_threads_on(outputStream* st) const {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp Fri Oct 03 00:21:49 2014 +0200
@@ -262,12 +262,12 @@
"Percentage (0-100) of the heap size to use as default " \
" maximum young gen size.") \
\
- experimental(uintx, G1MixedGCLiveThresholdPercent, 65, \
+ experimental(uintx, G1MixedGCLiveThresholdPercent, 85, \
"Threshold for regions to be considered for inclusion in the " \
"collection set of mixed GCs. " \
"Regions with live bytes exceeding this will not be collected.") \
\
- product(uintx, G1HeapWastePercent, 10, \
+ product(uintx, G1HeapWastePercent, 5, \
"Amount of space, expressed as a percentage of the heap size, " \
"that G1 is willing not to collect to avoid expensive GCs.") \
\
--- a/hotspot/src/share/vm/memory/collectorPolicy.cpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/memory/collectorPolicy.cpp Fri Oct 03 00:21:49 2014 +0200
@@ -817,7 +817,11 @@
assert(!Heap_lock->owned_by_self(), "Should not be holding the Heap_lock");
do {
- MetaWord* result = NULL;
+ MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
+ if (result != NULL) {
+ return result;
+ }
+
if (GC_locker::is_active_and_needs_gc()) {
// If the GC_locker is active, just expand and allocate.
// If that does not succeed, wait if this thread is not
--- a/hotspot/src/share/vm/memory/metaspace.cpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/memory/metaspace.cpp Fri Oct 03 00:21:49 2014 +0200
@@ -1415,10 +1415,31 @@
return value;
}
-size_t MetaspaceGC::inc_capacity_until_GC(size_t v) {
+bool MetaspaceGC::inc_capacity_until_GC(size_t v, size_t* new_cap_until_GC, size_t* old_cap_until_GC) {
assert_is_size_aligned(v, Metaspace::commit_alignment());
- return (size_t)Atomic::add_ptr(v, &_capacity_until_GC);
+ size_t capacity_until_GC = (size_t) _capacity_until_GC;
+ size_t new_value = capacity_until_GC + v;
+
+ if (new_value < capacity_until_GC) {
+ // The addition wrapped around, set new_value to aligned max value.
+ new_value = align_size_down(max_uintx, Metaspace::commit_alignment());
+ }
+
+ intptr_t expected = (intptr_t) capacity_until_GC;
+ intptr_t actual = Atomic::cmpxchg_ptr((intptr_t) new_value, &_capacity_until_GC, expected);
+
+ if (expected != actual) {
+ return false;
+ }
+
+ if (new_cap_until_GC != NULL) {
+ *new_cap_until_GC = new_value;
+ }
+ if (old_cap_until_GC != NULL) {
+ *old_cap_until_GC = capacity_until_GC;
+ }
+ return true;
}
size_t MetaspaceGC::dec_capacity_until_GC(size_t v) {
@@ -1518,7 +1539,10 @@
expand_bytes = align_size_up(expand_bytes, Metaspace::commit_alignment());
// Don't expand unless it's significant
if (expand_bytes >= MinMetaspaceExpansion) {
- size_t new_capacity_until_GC = MetaspaceGC::inc_capacity_until_GC(expand_bytes);
+ size_t new_capacity_until_GC = 0;
+ bool succeeded = MetaspaceGC::inc_capacity_until_GC(expand_bytes, &new_capacity_until_GC);
+ assert(succeeded, "Should always succesfully increment HWM when at safepoint");
+
Metaspace::tracer()->report_gc_threshold(capacity_until_GC,
new_capacity_until_GC,
MetaspaceGCThresholdUpdater::ComputeNewSize);
@@ -3321,19 +3345,29 @@
size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
assert(delta_bytes > 0, "Must be");
- size_t after_inc = MetaspaceGC::inc_capacity_until_GC(delta_bytes);
-
- // capacity_until_GC might be updated concurrently, must calculate previous value.
- size_t before_inc = after_inc - delta_bytes;
-
- tracer()->report_gc_threshold(before_inc, after_inc,
- MetaspaceGCThresholdUpdater::ExpandAndAllocate);
- if (PrintGCDetails && Verbose) {
- gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
- " to " SIZE_FORMAT, before_inc, after_inc);
+ size_t before = 0;
+ size_t after = 0;
+ MetaWord* res;
+ bool incremented;
+
+ // Each thread increments the HWM at most once. Even if the thread fails to increment
+ // the HWM, an allocation is still attempted. This is because another thread must then
+ // have incremented the HWM and therefore the allocation might still succeed.
+ do {
+ incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before);
+ res = allocate(word_size, mdtype);
+ } while (!incremented && res == NULL);
+
+ if (incremented) {
+ tracer()->report_gc_threshold(before, after,
+ MetaspaceGCThresholdUpdater::ExpandAndAllocate);
+ if (PrintGCDetails && Verbose) {
+ gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
+ " to " SIZE_FORMAT, before, after);
+ }
}
- return allocate(word_size, mdtype);
+ return res;
}
// Space allocated in the Metaspace. This may
--- a/hotspot/src/share/vm/memory/metaspace.hpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/memory/metaspace.hpp Fri Oct 03 00:21:49 2014 +0200
@@ -87,6 +87,7 @@
friend class VM_CollectForMetadataAllocation;
friend class MetaspaceGC;
friend class MetaspaceAux;
+ friend class CollectorPolicy;
public:
enum MetadataType {
@@ -144,6 +145,8 @@
// allocate(ClassLoaderData*, size_t, bool, MetadataType, TRAPS)
MetaWord* allocate(size_t word_size, MetadataType mdtype);
+ MetaWord* expand_and_allocate(size_t size, MetadataType mdtype);
+
// Virtual Space lists for both classes and other metadata
static VirtualSpaceList* _space_list;
static VirtualSpaceList* _class_space_list;
@@ -234,9 +237,6 @@
bool read_only, MetaspaceObj::Type type, TRAPS);
void deallocate(MetaWord* ptr, size_t byte_size, bool is_class);
- MetaWord* expand_and_allocate(size_t size,
- MetadataType mdtype);
-
static bool contains(const void* ptr);
void dump(outputStream* const out) const;
@@ -407,7 +407,9 @@
static void post_initialize();
static size_t capacity_until_GC();
- static size_t inc_capacity_until_GC(size_t v);
+ static bool inc_capacity_until_GC(size_t v,
+ size_t* new_cap_until_GC = NULL,
+ size_t* old_cap_until_GC = NULL);
static size_t dec_capacity_until_GC(size_t v);
static bool should_concurrent_collect() { return _should_concurrent_collect; }
--- a/hotspot/src/share/vm/prims/whitebox.cpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/prims/whitebox.cpp Fri Oct 03 00:21:49 2014 +0200
@@ -820,6 +820,33 @@
MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr);
WB_END
+WB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc))
+ if (inc < 0) {
+ THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
+ err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc));
+ }
+
+ jlong max_size_t = (jlong) ((size_t) -1);
+ if (inc > max_size_t) {
+ THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
+ err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc));
+ }
+
+ size_t new_cap_until_GC = 0;
+ size_t aligned_inc = align_size_down((size_t) inc, Metaspace::commit_alignment());
+ bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC);
+ if (!success) {
+ THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(),
+ "WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC "
+ "due to contention with another thread");
+ }
+ return (jlong) new_cap_until_GC;
+WB_END
+
+WB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb))
+ return (jlong) MetaspaceGC::capacity_until_GC();
+WB_END
+
//Some convenience methods to deal with objects from java
int WhiteBox::offset_for_field(const char* field_name, oop object,
Symbol* signature_symbol) {
@@ -991,6 +1018,8 @@
CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
{CC"freeMetaspace",
CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
+ {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
+ {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
{CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
{CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
(void*)&WB_GetNMethod },
--- a/hotspot/src/share/vm/runtime/arguments.cpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Fri Oct 03 00:21:49 2014 +0200
@@ -1690,13 +1690,18 @@
#ifdef COMPILER1
FastTLABRefill = false;
#endif
- FLAG_SET_DEFAULT(ParallelGCThreads,
- Abstract_VM_Version::parallel_worker_threads());
+ FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads());
if (ParallelGCThreads == 0) {
- FLAG_SET_DEFAULT(ParallelGCThreads,
- Abstract_VM_Version::parallel_worker_threads());
+ assert(!FLAG_IS_DEFAULT(ParallelGCThreads), "The default value for ParallelGCThreads should not be 0.");
+ vm_exit_during_initialization("The flag -XX:+UseG1GC can not be combined with -XX:ParallelGCThreads=0", NULL);
}
+#if INCLUDE_ALL_GCS
+ if (G1ConcRefinementThreads == 0) {
+ FLAG_SET_DEFAULT(G1ConcRefinementThreads, ParallelGCThreads);
+ }
+#endif
+
// MarkStackSize will be set (if it hasn't been set by the user)
// when concurrent marking is initialized.
// Its value will be based upon the number of parallel marking threads.
--- a/hotspot/src/share/vm/utilities/bitMap.cpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.cpp Fri Oct 03 00:21:49 2014 +0200
@@ -342,9 +342,9 @@
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
- idx_t temp = map(index) | other_map[index];
- changed = changed || (temp != map(index));
- map()[index] = temp;
+ idx_t temp = dest_map[index] | other_map[index];
+ changed = changed || (temp != dest_map[index]);
+ dest_map[index] = temp;
}
return changed;
}
@@ -407,10 +407,10 @@
bm_word_t* word = map();
idx_t rest = size();
for (; rest >= (idx_t) BitsPerWord; rest -= BitsPerWord) {
- if (*word != (bm_word_t) AllBits) return false;
+ if (*word != ~(bm_word_t)0) return false;
word++;
}
- return rest == 0 || (*word | ~right_n_bits((int)rest)) == (bm_word_t) AllBits;
+ return rest == 0 || (*word | ~right_n_bits((int)rest)) == ~(bm_word_t)0;
}
@@ -418,10 +418,10 @@
bm_word_t* word = map();
idx_t rest = size();
for (; rest >= (idx_t) BitsPerWord; rest -= BitsPerWord) {
- if (*word != (bm_word_t) NoBits) return false;
+ if (*word != 0) return false;
word++;
}
- return rest == 0 || (*word & right_n_bits((int)rest)) == (bm_word_t) NoBits;
+ return rest == 0 || (*word & right_n_bits((int)rest)) == 0;
}
void BitMap::clear_large() {
@@ -441,7 +441,7 @@
offset < rightOffset && index < endIndex;
offset = (++index) << LogBitsPerWord) {
idx_t rest = map(index) >> (offset & (BitsPerWord - 1));
- for (; offset < rightOffset && rest != (bm_word_t)NoBits; offset++) {
+ for (; offset < rightOffset && rest != 0; offset++) {
if (rest & 1) {
if (!blk->do_bit(offset)) return false;
// resample at each closure application
@@ -468,7 +468,7 @@
(intptr_t) NULL_WORD);
if (res != NULL_WORD) {
guarantee( _pop_count_table == (void*) res, "invariant" );
- FREE_C_HEAP_ARRAY(bm_word_t, table, mtInternal);
+ FREE_C_HEAP_ARRAY(idx_t, table, mtInternal);
}
}
}
--- a/hotspot/src/share/vm/utilities/bitMap.hpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.hpp Fri Oct 03 00:21:49 2014 +0200
@@ -80,7 +80,7 @@
// Set a word to a specified value or to all ones; clear a word.
void set_word (idx_t word, bm_word_t val) { _map[word] = val; }
- void set_word (idx_t word) { set_word(word, ~(uintptr_t)0); }
+ void set_word (idx_t word) { set_word(word, ~(bm_word_t)0); }
void clear_word(idx_t word) { _map[word] = 0; }
// Utilities for ranges of bits. Ranges are half-open [beg, end).
--- a/hotspot/src/share/vm/utilities/bitMap.inline.hpp Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.inline.hpp Fri Oct 03 00:21:49 2014 +0200
@@ -130,7 +130,7 @@
inline void BitMap::set_range_of_words(idx_t beg, idx_t end) {
bm_word_t* map = _map;
- for (idx_t i = beg; i < end; ++i) map[i] = ~(uintptr_t)0;
+ for (idx_t i = beg; i < end; ++i) map[i] = ~(bm_word_t)0;
}
@@ -172,8 +172,8 @@
// check bits including and to the _left_ of offset's position
idx_t pos = bit_in_word(res_offset);
- idx_t res = map(index) >> pos;
- if (res != (uintptr_t)NoBits) {
+ bm_word_t res = map(index) >> pos;
+ if (res != 0) {
// find the position of the 1-bit
for (; !(res & 1); res_offset++) {
res = res >> 1;
@@ -207,7 +207,7 @@
// skip over all word length 0-bit runs
for (index++; index < r_index; index++) {
res = map(index);
- if (res != (uintptr_t)NoBits) {
+ if (res != 0) {
// found a 1, return the offset
for (res_offset = bit_index(index); !(res & 1); res_offset++) {
res = res >> 1;
@@ -235,9 +235,9 @@
// check bits including and to the _left_ of offset's position
idx_t pos = res_offset & (BitsPerWord - 1);
- idx_t res = (map(index) >> pos) | left_n_bits((int)pos);
+ bm_word_t res = (map(index) >> pos) | left_n_bits((int)pos);
- if (res != (uintptr_t)AllBits) {
+ if (res != ~(bm_word_t)0) {
// find the position of the 0-bit
for (; res & 1; res_offset++) {
res = res >> 1;
@@ -248,7 +248,7 @@
// skip over all word length 1-bit runs
for (index++; index < r_index; index++) {
res = map(index);
- if (res != (uintptr_t)AllBits) {
+ if (res != ~(bm_word_t)0) {
// found a 0, return the offset
for (res_offset = index << LogBitsPerWord; res & 1;
res_offset++) {
@@ -277,8 +277,8 @@
idx_t res_offset = l_offset;
// check bits including and to the _left_ of offset's position
- idx_t res = map(index) >> bit_in_word(res_offset);
- if (res != (uintptr_t)NoBits) {
+ bm_word_t res = map(index) >> bit_in_word(res_offset);
+ if (res != 0) {
// find the position of the 1-bit
for (; !(res & 1); res_offset++) {
res = res >> 1;
@@ -290,7 +290,7 @@
// skip over all word length 0-bit runs
for (index++; index < r_index; index++) {
res = map(index);
- if (res != (uintptr_t)NoBits) {
+ if (res != 0) {
// found a 1, return the offset
for (res_offset = bit_index(index); !(res & 1); res_offset++) {
res = res >> 1;
@@ -321,11 +321,11 @@
}
inline void BitMap::set_large_range_of_words(idx_t beg, idx_t end) {
- memset(_map + beg, ~(unsigned char)0, (end - beg) * sizeof(uintptr_t));
+ memset(_map + beg, ~(unsigned char)0, (end - beg) * sizeof(bm_word_t));
}
inline void BitMap::clear_large_range_of_words(idx_t beg, idx_t end) {
- memset(_map + beg, 0, (end - beg) * sizeof(uintptr_t));
+ memset(_map + beg, 0, (end - beg) * sizeof(bm_word_t));
}
inline BitMap::idx_t BitMap::word_index_round_up(idx_t bit) const {
--- a/hotspot/test/TEST.groups Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/test/TEST.groups Fri Oct 03 00:21:49 2014 +0200
@@ -134,6 +134,13 @@
gc/metaspace/TestMetaspaceMemoryPool.java \
gc/arguments/TestDynMinHeapFreeRatio.java \
gc/arguments/TestDynMaxHeapFreeRatio.java \
+ gc/g1/TestShrinkAuxiliaryData00.java \
+ gc/g1/TestShrinkAuxiliaryData05.java \
+ gc/g1/TestShrinkAuxiliaryData10.java \
+ gc/g1/TestShrinkAuxiliaryData15.java \
+ gc/g1/TestShrinkAuxiliaryData20.java \
+ gc/g1/TestShrinkAuxiliaryData25.java \
+ gc/g1/TestShrinkAuxiliaryData30.java \
runtime/InternalApi/ThreadCpuTimesDeadlock.java \
serviceability/threads/TestFalseDeadLock.java \
@@ -221,6 +228,7 @@
gc/arguments/TestG1HeapSizeFlags.java \
gc/arguments/TestMaxHeapSizeTools.java \
gc/arguments/TestMaxNewSize.java \
+ gc/arguments/TestParallelGCThreads.java \
gc/arguments/TestUseCompressedOopsErgo.java \
gc/class_unloading/TestG1ClassUnloadingHWM.java \
gc/g1/ \
@@ -248,6 +256,7 @@
gc/arguments/TestAlignmentToUseLargePages.java \
gc/arguments/TestMaxNewSize.java \
gc/arguments/TestMinInitialErgonomics.java \
+ gc/arguments/TestParallelGCThreads.java \
gc/arguments/TestUseCompressedOopsErgo.java \
gc/metaspace/TestMetaspacePerfCounters.java \
gc/parallelScavenge/ \
@@ -262,6 +271,7 @@
gc/arguments/TestAlignmentToUseLargePages.java \
gc/arguments/TestCMSHeapSizeFlags.java \
gc/arguments/TestMaxNewSize.java \
+ gc/arguments/TestParallelGCThreads.java \
gc/arguments/TestUseCompressedOopsErgo.java \
gc/class_unloading/TestCMSClassUnloadingEnabledHWM.java \
gc/concurrentMarkSweep/ \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/arguments/TestG1ConcRefinementThreads.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,97 @@
+/*
+* Copyright (c) 2014, 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 TestG1ConcRefinementThreads
+ * @key gc
+ * @bug 8047976
+ * @summary Tests argument processing for G1ConcRefinementThreads
+ * @library /testlibrary
+ */
+
+import com.oracle.java.testlibrary.*;
+import java.util.*;
+import java.util.regex.*;
+
+public class TestG1ConcRefinementThreads {
+
+ static final int AUTO_SELECT_THREADS_COUNT = 0;
+ static final int PASSED_THREADS_COUNT = 11;
+
+ public static void main(String args[]) throws Exception {
+ // default case
+ runG1ConcRefinementThreadsTest(
+ new String[]{}, // automatically selected
+ AUTO_SELECT_THREADS_COUNT /* use default setting */);
+
+ // zero setting case
+ runG1ConcRefinementThreadsTest(
+ new String[]{"-XX:G1ConcRefinementThreads=0"}, // automatically selected
+ AUTO_SELECT_THREADS_COUNT /* set to zero */);
+
+ // non-zero sestting case
+ runG1ConcRefinementThreadsTest(
+ new String[]{"-XX:G1ConcRefinementThreads="+Integer.toString(PASSED_THREADS_COUNT)},
+ PASSED_THREADS_COUNT);
+ }
+
+ private static void runG1ConcRefinementThreadsTest(String[] passedOpts,
+ int expectedValue) throws Exception {
+ List<String> vmOpts = new ArrayList<>();
+ if (passedOpts.length > 0) {
+ Collections.addAll(vmOpts, passedOpts);
+ }
+ Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:+PrintFlagsFinal", "-version");
+
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(vmOpts.toArray(new String[vmOpts.size()]));
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+
+ output.shouldHaveExitValue(0);
+ String stdout = output.getStdout();
+ checkG1ConcRefinementThreadsConsistency(stdout, expectedValue);
+ }
+
+ private static void checkG1ConcRefinementThreadsConsistency(String output, int expectedValue) {
+ int actualValue = getIntValue("G1ConcRefinementThreads", output);
+
+ if (expectedValue == 0) {
+ // If expectedValue is automatically selected, set it same as ParallelGCThreads.
+ expectedValue = getIntValue("ParallelGCThreads", output);
+ }
+
+ if (expectedValue != actualValue) {
+ throw new RuntimeException(
+ "Actual G1ConcRefinementThreads(" + Integer.toString(actualValue)
+ + ") is not equal to expected value(" + Integer.toString(expectedValue) + ")");
+ }
+ }
+
+ public static int getIntValue(String flag, String where) {
+ Matcher m = Pattern.compile(flag + "\\s+:?=\\s+\\d+").matcher(where);
+ if (!m.find()) {
+ throw new RuntimeException("Could not find value for flag " + flag + " in output string");
+ }
+ String match = m.group();
+ return Integer.parseInt(match.substring(match.lastIndexOf(" ") + 1, match.length()));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/arguments/TestParallelGCThreads.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,64 @@
+/*
+* Copyright (c) 2014, 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 TestParallelGCThreads
+ * @key gc
+ * @bug 8059527
+ * @summary Tests argument processing for ParallelGCThreads
+ * @library /testlibrary
+ * @run driver TestParallelGCThreads
+ */
+
+import com.oracle.java.testlibrary.*;
+
+public class TestParallelGCThreads {
+
+ public static void main(String args[]) throws Exception {
+
+ // For each parallel collector (G1, Parallel, ParNew/CMS)
+ for (String gc : new String[] {"G1", "Parallel", "ConcMarkSweep"}) {
+
+ // Make sure the VM does not allow ParallelGCThreads set to 0
+ String[] flags = new String[] {"-XX:+Use" + gc + "GC", "-XX:ParallelGCThreads=0", "-XX:+PrintFlagsFinal", "-version"};
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(flags);
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(1);
+
+ // Do some basic testing to ensure the flag updates the count
+ for (long i = 1; i <= 3; i++) {
+ flags = new String[] {"-XX:+Use" + gc + "GC", "-XX:ParallelGCThreads=" + i, "-XX:+PrintFlagsFinal", "-version"};
+ long count = getParallelGCThreadCount(flags);
+ Asserts.assertEQ(count, i, "Specifying ParallelGCThreads=" + i + " for " + gc + "GC does not set the thread count properly!");
+ }
+ }
+ }
+
+ public static long getParallelGCThreadCount(String flags[]) throws Exception {
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(flags);
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(0);
+ String stdout = output.getStdout();
+ return FlagsValue.getFlagLongValue("ParallelGCThreads", stdout);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2014, 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.
+ */
+
+import static com.oracle.java.testlibrary.Asserts.assertLessThanOrEqual;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.ProcessTools;
+import com.oracle.java.testlibrary.Utils;
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import sun.misc.Unsafe;
+
+public class TestShrinkAuxiliaryData {
+
+ private final static String[] initialOpts = new String[]{
+ "-XX:MinHeapFreeRatio=10",
+ "-XX:MaxHeapFreeRatio=11",
+ "-XX:+UseG1GC",
+ "-XX:G1HeapRegionSize=1m",
+ "-XX:+PrintGCDetails"
+ };
+
+ private final int RSetCacheSize;
+
+ protected TestShrinkAuxiliaryData(int RSetCacheSize) {
+ this.RSetCacheSize = RSetCacheSize;
+ }
+
+ protected void test() throws Exception {
+ ArrayList<String> vmOpts = new ArrayList();
+ Collections.addAll(vmOpts, initialOpts);
+
+ int maxCacheSize = Math.max(0, Math.min(31, getMaxCacheSize()));
+ if (maxCacheSize < RSetCacheSize) {
+ System.out.format("Skiping test for %d cache size due max cache size %d",
+ RSetCacheSize, maxCacheSize
+ );
+ return;
+ }
+
+ printTestInfo(maxCacheSize);
+
+ vmOpts.add("-XX:G1ConcRSLogCacheSize=" + RSetCacheSize);
+
+ vmOpts.addAll(Arrays.asList(Utils.getFilteredTestJavaOpts(
+ ShrinkAuxiliaryDataTest.prohibitedVmOptions)));
+
+ // for 32 bits ObjectAlignmentInBytes is not a option
+ if (Platform.is32bit()) {
+ ArrayList<String> vmOptsWithoutAlign = new ArrayList(vmOpts);
+ vmOptsWithoutAlign.add(ShrinkAuxiliaryDataTest.class.getName());
+ performTest(vmOptsWithoutAlign);
+ return;
+ }
+
+ for (int alignment = 3; alignment <= 8; alignment++) {
+ ArrayList<String> vmOptsWithAlign = new ArrayList(vmOpts);
+ vmOptsWithAlign.add("-XX:ObjectAlignmentInBytes="
+ + (int) Math.pow(2, alignment));
+ vmOptsWithAlign.add(ShrinkAuxiliaryDataTest.class.getName());
+
+ performTest(vmOptsWithAlign);
+ }
+ }
+
+ private void performTest(List<String> opts) throws Exception {
+ ProcessBuilder pb
+ = ProcessTools.createJavaProcessBuilder(
+ opts.toArray(new String[opts.size()])
+ );
+
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(0);
+ }
+
+ private void printTestInfo(int maxCacheSize) {
+
+ DecimalFormat grouped = new DecimalFormat("000,000");
+ DecimalFormatSymbols formatSymbols = grouped.getDecimalFormatSymbols();
+ formatSymbols.setGroupingSeparator(' ');
+ grouped.setDecimalFormatSymbols(formatSymbols);
+
+ System.out.format("Test will use %s bytes of memory of %s available%n"
+ + "Available memory is %s with %d bytes pointer size - can save %s pointers%n"
+ + "Max cache size: 2^%d = %s elements%n",
+ grouped.format(ShrinkAuxiliaryDataTest.getMemoryUsedByTest()),
+ grouped.format(Runtime.getRuntime().freeMemory()),
+ grouped.format(Runtime.getRuntime().freeMemory()
+ - ShrinkAuxiliaryDataTest.getMemoryUsedByTest()),
+ Unsafe.ADDRESS_SIZE,
+ grouped.format((Runtime.getRuntime().freeMemory()
+ - ShrinkAuxiliaryDataTest.getMemoryUsedByTest())
+ / Unsafe.ADDRESS_SIZE),
+ maxCacheSize,
+ grouped.format((int) Math.pow(2, maxCacheSize))
+ );
+ }
+
+ /**
+ * Detects maximum possible size of G1ConcRSLogCacheSize available for
+ * current process based on maximum available process memory size
+ *
+ * @return power of two
+ */
+ private static int getMaxCacheSize() {
+ long availableMemory = Runtime.getRuntime().freeMemory()
+ - ShrinkAuxiliaryDataTest.getMemoryUsedByTest() - 1l;
+ if (availableMemory <= 0) {
+ return 0;
+ }
+ long availablePointersCount = availableMemory / Unsafe.ADDRESS_SIZE;
+ return (63 - (int) Long.numberOfLeadingZeros(availablePointersCount));
+ }
+
+ static class ShrinkAuxiliaryDataTest {
+
+ public static void main(String[] args) throws IOException {
+ int iterateCount = DEFAULT_ITERATION_COUNT;
+
+ if (args.length > 0) {
+ try {
+ iterateCount = Integer.parseInt(args[0]);
+ } catch (NumberFormatException e) {
+ //num_iterate remains default
+ }
+ }
+
+ new ShrinkAuxiliaryDataTest().test(iterateCount);
+ }
+
+ class GarbageObject {
+
+ private final List<byte[]> payload = new ArrayList();
+ private final List<GarbageObject> ref = new LinkedList();
+
+ public GarbageObject(int size) {
+ payload.add(new byte[size]);
+ }
+
+ public void addRef(GarbageObject g) {
+ ref.add(g);
+ }
+
+ public void mutate() {
+ if (!payload.isEmpty() && payload.get(0).length > 0) {
+ payload.get(0)[0] = (byte) (Math.random() * Byte.MAX_VALUE);
+ }
+ }
+ }
+
+ private final List<GarbageObject> garbage = new ArrayList();
+
+ public void test(int num_iterate) throws IOException {
+
+ allocate();
+ link();
+ mutate();
+ deallocate();
+
+ MemoryUsage muBeforeHeap
+ = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+ MemoryUsage muBeforeNonHeap
+ = ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
+
+ for (int i = 0; i < num_iterate; i++) {
+ allocate();
+ link();
+ mutate();
+ deallocate();
+ }
+
+ System.gc();
+ MemoryUsage muAfterHeap
+ = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+ MemoryUsage muAfterNonHeap
+ = ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
+
+ assertLessThanOrEqual(muAfterHeap.getCommitted(), muBeforeHeap.getCommitted(),
+ String.format("heap decommit failed - after > before: %d > %d",
+ muAfterHeap.getCommitted(), muBeforeHeap.getCommitted()
+ )
+ );
+
+ if (muAfterHeap.getCommitted() < muBeforeHeap.getCommitted()) {
+ assertLessThanOrEqual(muAfterNonHeap.getCommitted(), muBeforeNonHeap.getCommitted(),
+ String.format("non-heap decommit failed - after > before: %d > %d",
+ muAfterNonHeap.getCommitted(), muBeforeNonHeap.getCommitted()
+ )
+ );
+ }
+ }
+
+ private void allocate() {
+ for (int r = 0; r < REGIONS_TO_ALLOCATE; r++) {
+ for (int i = 0; i < NUM_OBJECTS_PER_REGION; i++) {
+ GarbageObject g = new GarbageObject(REGION_SIZE
+ / NUM_OBJECTS_PER_REGION);
+ garbage.add(g);
+ }
+ }
+ }
+
+ /**
+ * Iterate through all allocated objects, and link to objects in another
+ * regions
+ */
+ private void link() {
+ for (int ig = 0; ig < garbage.size(); ig++) {
+ int regionNumber = ig / NUM_OBJECTS_PER_REGION;
+
+ for (int i = 0; i < NUM_LINKS; i++) {
+ int regionToLink;
+ do {
+ regionToLink = (int) (Math.random()
+ * REGIONS_TO_ALLOCATE);
+ } while (regionToLink == regionNumber);
+
+ // get random garbage object from random region
+ garbage.get(ig).addRef(garbage.get(regionToLink
+ * NUM_OBJECTS_PER_REGION + (int) (Math.random()
+ * NUM_OBJECTS_PER_REGION)));
+ }
+ }
+ }
+
+ private void mutate() {
+ for (int ig = 0; ig < garbage.size(); ig++) {
+ garbage.get(ig).mutate();
+ }
+ }
+
+ private void deallocate() {
+ garbage.clear();
+ System.gc();
+ }
+
+ static long getMemoryUsedByTest() {
+ return REGIONS_TO_ALLOCATE * REGION_SIZE;
+ }
+
+ private static final int REGION_SIZE = 1024 * 1024;
+ private static final int DEFAULT_ITERATION_COUNT = 1; // iterate main scenario
+ private static final int REGIONS_TO_ALLOCATE = 5;
+ private static final int NUM_OBJECTS_PER_REGION = 10;
+ private static final int NUM_LINKS = 20; // how many links create for each object
+
+ private static final String[] prohibitedVmOptions = {
+ // remove this when @requires option will be on duty
+ "-XX:\\+UseParallelGC",
+ "-XX:\\+UseSerialGC",
+ "-XX:\\+UseConcMarkSweepGC",
+ "-XX:\\+UseParallelOldGC",
+ "-XX:\\+UseParNewGC",
+ "-Xconcgc",
+ "-Xincgc"
+ };
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData00.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014, 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 TestShrinkAuxiliaryData00
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData00
+ * @run driver/timeout=720 TestShrinkAuxiliaryData00
+ */
+public class TestShrinkAuxiliaryData00 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(0).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData05.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014, 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 TestShrinkAuxiliaryData05
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData05
+ * @run driver/timeout=720 TestShrinkAuxiliaryData05
+ */
+public class TestShrinkAuxiliaryData05 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(5).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData10.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014, 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 TestShrinkAuxiliaryData10
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData10
+ * @run driver/timeout=720 TestShrinkAuxiliaryData10
+ */
+public class TestShrinkAuxiliaryData10 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(10).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData15.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014, 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 TestShrinkAuxiliaryData15
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData15
+ * @run driver/timeout=720 TestShrinkAuxiliaryData15
+ */
+public class TestShrinkAuxiliaryData15 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(15).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData20.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014, 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 TestShrinkAuxiliaryData20
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData20
+ * @run driver/timeout=720 TestShrinkAuxiliaryData20
+ */
+public class TestShrinkAuxiliaryData20 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(20).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData25.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014, 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 TestShrinkAuxiliaryData25
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData25
+ * @run driver/timeout=720 TestShrinkAuxiliaryData25
+ */
+public class TestShrinkAuxiliaryData25 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(25).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData30.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014, 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 TestShrinkAuxiliaryData30
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData30
+ * @run driver/timeout=720 TestShrinkAuxiliaryData30
+ */
+public class TestShrinkAuxiliaryData30 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(30).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/metaspace/TestCapacityUntilGCWrapAround.java Fri Oct 03 00:21:49 2014 +0200
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2014, 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
+ * @key gc
+ * @bug 8049831
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestCapacityUntilGCWrapAround
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI TestCapacityUntilGCWrapAround
+ */
+
+import sun.hotspot.WhiteBox;
+
+import com.oracle.java.testlibrary.Asserts;
+import com.oracle.java.testlibrary.Platform;
+
+public class TestCapacityUntilGCWrapAround {
+ private static long MB = 1024 * 1024;
+ private static long GB = 1024 * MB;
+ private static long MAX_UINT = 4 * GB - 1; // On 32-bit platforms
+
+ public static void main(String[] args) {
+ if (Platform.is32bit()) {
+ WhiteBox wb = WhiteBox.getWhiteBox();
+
+ long before = wb.metaspaceCapacityUntilGC();
+ // Now force possible overflow of capacity_until_GC.
+ long after = wb.incMetaspaceCapacityUntilGC(MAX_UINT);
+
+ Asserts.assertGTE(after, before,
+ "Increasing with MAX_UINT should not cause wrap around: " + after + " < " + before);
+ Asserts.assertLTE(after, MAX_UINT,
+ "Increasing with MAX_UINT should not cause value larger than MAX_UINT:" + after);
+ }
+ }
+}
--- a/hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Wed Oct 01 15:24:34 2014 -0700
+++ b/hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Fri Oct 03 00:21:49 2014 +0200
@@ -152,6 +152,8 @@
public native void readReservedMemory();
public native long allocateMetaspace(ClassLoader classLoader, long size);
public native void freeMetaspace(ClassLoader classLoader, long addr, long size);
+ public native long incMetaspaceCapacityUntilGC(long increment);
+ public native long metaspaceCapacityUntilGC();
// force Young GC
public native void youngGC();