jdk8-mips64-public/hotspot: comparison src/share/vm/memory/metaspace.cpp

-:1fa6d1542e32
+:b509b7ff561c
 size_t value = (size_t)OrderAccess::load_ptr_acquire(&_capacity_until_GC);
 assert(value >= MetaspaceSize, "Not initialied properly?");
 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) {
 assert_is_size_aligned(v, Metaspace::commit_alignment());
 // increment the HWM.
 size_t expand_bytes = minimum_desired_capacity - capacity_until_GC;
 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);
 if (PrintGCDetails && Verbose) {
 gclog_or_tty->print_cr("    expanding:"
 MetaWord* Metaspace::expand_and_allocate(size_t word_size, MetadataType mdtype) {
 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);
+size_t before = 0;
+size_t after = 0;
-// capacity_until_GC might be updated concurrently, must calculate previous value.
+MetaWord* res;
-size_t before_inc = after_inc - delta_bytes;
+bool incremented;
-tracer()->report_gc_threshold(before_inc, after_inc,
+// Each thread increments the HWM at most once. Even if the thread fails to increment
-MetaspaceGCThresholdUpdater::ExpandAndAllocate);
+// the HWM, an allocation is still attempted. This is because another thread must then
-if (PrintGCDetails && Verbose) {
+// have incremented the HWM and therefore the allocation might still succeed.
-gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
+do {
-" to " SIZE_FORMAT, before_inc, after_inc);
+incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before);
-}
+res = allocate(word_size, mdtype);
+} while (!incremented && res == NULL);
-return allocate(word_size, mdtype);
+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 res;
 }
 // Space allocated in the Metaspace.  This may
 // be across several metadata virtual spaces.
 char* Metaspace::bottom() const {

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/memory/metaspace.cpp

src/share/vm/memory/metaspace.cpp