8194312: Support parallel and concurrent JNI global handle processing
Summary: Add OopStorage, change JNI gloabl/weak to use OopStorage.
Reviewed-by: coleenp, sspitsyn, eosterlund
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/shared/oopStorage.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -0,0 +1,707 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc/shared/oopStorage.hpp"
+#include "logging/log.hpp"
+#include "memory/allocation.inline.hpp"
+#include "runtime/atomic.hpp"
+#include "runtime/handles.inline.hpp"
+#include "runtime/mutex.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "runtime/orderAccess.inline.hpp"
+#include "runtime/safepoint.hpp"
+#include "runtime/stubRoutines.hpp"
+#include "utilities/align.hpp"
+#include "utilities/count_trailing_zeros.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/macros.hpp"
+#include "utilities/ostream.hpp"
+
+OopStorage::BlockEntry::BlockEntry() : _prev(NULL), _next(NULL) {}
+
+OopStorage::BlockEntry::~BlockEntry() {
+ assert(_prev == NULL, "deleting attached block");
+ assert(_next == NULL, "deleting attached block");
+}
+
+OopStorage::BlockList::BlockList(const BlockEntry& (*get_entry)(const Block& block)) :
+ _head(NULL), _tail(NULL), _get_entry(get_entry)
+{}
+
+OopStorage::BlockList::~BlockList() {
+ // ~OopStorage() empties its lists before destroying them.
+ assert(_head == NULL, "deleting non-empty block list");
+ assert(_tail == NULL, "deleting non-empty block list");
+}
+
+void OopStorage::BlockList::push_front(const Block& block) {
+ const Block* old = _head;
+ if (old == NULL) {
+ assert(_tail == NULL, "invariant");
+ _head = _tail = █
+ } else {
+ _get_entry(block)._next = old;
+ _get_entry(*old)._prev = █
+ _head = █
+ }
+}
+
+void OopStorage::BlockList::push_back(const Block& block) {
+ const Block* old = _tail;
+ if (old == NULL) {
+ assert(_head == NULL, "invariant");
+ _head = _tail = █
+ } else {
+ _get_entry(*old)._next = █
+ _get_entry(block)._prev = old;
+ _tail = █
+ }
+}
+
+void OopStorage::BlockList::unlink(const Block& block) {
+ const BlockEntry& block_entry = _get_entry(block);
+ const Block* prev_blk = block_entry._prev;
+ const Block* next_blk = block_entry._next;
+ block_entry._prev = NULL;
+ block_entry._next = NULL;
+ if ((prev_blk == NULL) && (next_blk == NULL)) {
+ assert(_head == &block, "invariant");
+ assert(_tail == &block, "invariant");
+ _head = _tail = NULL;
+ } else if (prev_blk == NULL) {
+ assert(_head == &block, "invariant");
+ _get_entry(*next_blk)._prev = NULL;
+ _head = next_blk;
+ } else if (next_blk == NULL) {
+ assert(_tail == &block, "invariant");
+ _get_entry(*prev_blk)._next = NULL;
+ _tail = prev_blk;
+ } else {
+ _get_entry(*next_blk)._prev = prev_blk;
+ _get_entry(*prev_blk)._next = next_blk;
+ }
+}
+
+// Blocks start with an array of BitsPerWord oop entries. That array
+// is divided into conceptual BytesPerWord sections of BitsPerWord
+// entries. Blocks are allocated aligned on section boundaries, for
+// the convenience of mapping from an entry to the containing block;
+// see block_for_ptr(). Aligning on section boundary rather than on
+// the full _data wastes a lot less space, but makes for a bit more
+// work in block_for_ptr().
+
+const unsigned section_size = BitsPerByte;
+const unsigned section_count = BytesPerWord;
+const unsigned block_alignment = sizeof(oop) * section_size;
+
+// VS2013 warns (C4351) that elements of _data will be *correctly* default
+// initialized, unlike earlier versions that *incorrectly* did not do so.
+#ifdef _WINDOWS
+#pragma warning(push)
+#pragma warning(disable: 4351)
+#endif // _WINDOWS
+OopStorage::Block::Block(const OopStorage* owner, void* memory) :
+ _data(),
+ _allocated_bitmask(0),
+ _owner(owner),
+ _memory(memory),
+ _active_entry(),
+ _allocate_entry()
+{
+ STATIC_ASSERT(_data_pos == 0);
+ STATIC_ASSERT(section_size * section_count == ARRAY_SIZE(_data));
+ assert(offset_of(Block, _data) == _data_pos, "invariant");
+ assert(owner != NULL, "NULL owner");
+ assert(is_aligned(this, block_alignment), "misaligned block");
+}
+#ifdef _WINDOWS
+#pragma warning(pop)
+#endif
+
+OopStorage::Block::~Block() {
+ // Clear fields used by block_for_ptr and entry validation, which
+ // might help catch bugs. Volatile to prevent dead-store elimination.
+ const_cast<uintx volatile&>(_allocated_bitmask) = 0;
+ const_cast<OopStorage* volatile&>(_owner) = NULL;
+}
+
+const OopStorage::BlockEntry& OopStorage::Block::get_active_entry(const Block& block) {
+ return block._active_entry;
+}
+
+const OopStorage::BlockEntry& OopStorage::Block::get_allocate_entry(const Block& block) {
+ return block._allocate_entry;
+}
+
+size_t OopStorage::Block::allocation_size() {
+ // _data must be first member, so aligning Block aligns _data.
+ STATIC_ASSERT(_data_pos == 0);
+ return sizeof(Block) + block_alignment - sizeof(void*);
+}
+
+size_t OopStorage::Block::allocation_alignment_shift() {
+ return exact_log2(block_alignment);
+}
+
+inline bool is_full_bitmask(uintx bitmask) { return ~bitmask == 0; }
+inline bool is_empty_bitmask(uintx bitmask) { return bitmask == 0; }
+
+bool OopStorage::Block::is_full() const {
+ return is_full_bitmask(allocated_bitmask());
+}
+
+bool OopStorage::Block::is_empty() const {
+ return is_empty_bitmask(allocated_bitmask());
+}
+
+uintx OopStorage::Block::bitmask_for_entry(const oop* ptr) const {
+ return bitmask_for_index(get_index(ptr));
+}
+
+uintx OopStorage::Block::cmpxchg_allocated_bitmask(uintx new_value, uintx compare_value) {
+ return Atomic::cmpxchg(new_value, &_allocated_bitmask, compare_value);
+}
+
+bool OopStorage::Block::contains(const oop* ptr) const {
+ const oop* base = get_pointer(0);
+ return (base <= ptr) && (ptr < (base + ARRAY_SIZE(_data)));
+}
+
+unsigned OopStorage::Block::get_index(const oop* ptr) const {
+ assert(contains(ptr), PTR_FORMAT " not in block " PTR_FORMAT, p2i(ptr), p2i(this));
+ return static_cast<unsigned>(ptr - get_pointer(0));
+}
+
+oop* OopStorage::Block::allocate() {
+ // Use CAS loop because release may change bitmask outside of lock.
+ uintx allocated = allocated_bitmask();
+ while (true) {
+ assert(!is_full_bitmask(allocated), "attempt to allocate from full block");
+ unsigned index = count_trailing_zeros(~allocated);
+ uintx new_value = allocated | bitmask_for_index(index);
+ uintx fetched = cmpxchg_allocated_bitmask(new_value, allocated);
+ if (fetched == allocated) {
+ return get_pointer(index); // CAS succeeded; return entry for index.
+ }
+ allocated = fetched; // CAS failed; retry with latest value.
+ }
+}
+
+OopStorage::Block* OopStorage::Block::new_block(const OopStorage* owner) {
+ // _data must be first member: aligning block => aligning _data.
+ STATIC_ASSERT(_data_pos == 0);
+ size_t size_needed = allocation_size();
+ void* memory = NEW_C_HEAP_ARRAY_RETURN_NULL(char, size_needed, mtGC);
+ if (memory == NULL) {
+ return NULL;
+ }
+ void* block_mem = align_up(memory, block_alignment);
+ assert(sizeof(Block) + pointer_delta(block_mem, memory, 1) <= size_needed,
+ "allocated insufficient space for aligned block");
+ return ::new (block_mem) Block(owner, memory);
+}
+
+void OopStorage::Block::delete_block(const Block& block) {
+ void* memory = block._memory;
+ block.Block::~Block();
+ FREE_C_HEAP_ARRAY(char, memory);
+}
+
+// This can return a false positive if ptr is not contained by some
+// block. For some uses, it is a precondition that ptr is valid,
+// e.g. contained in some block in owner's _active_list. Other uses
+// require additional validation of the result.
+OopStorage::Block*
+OopStorage::Block::block_for_ptr(const OopStorage* owner, const oop* ptr) {
+ assert(CanUseSafeFetchN(), "precondition");
+ STATIC_ASSERT(_data_pos == 0);
+ // Const-ness of ptr is not related to const-ness of containing block.
+ // Blocks are allocated section-aligned, so get the containing section.
+ oop* section_start = align_down(const_cast<oop*>(ptr), block_alignment);
+ // Start with a guess that the containing section is the last section,
+ // so the block starts section_count-1 sections earlier.
+ oop* section = section_start - (section_size * (section_count - 1));
+ // Walk up through the potential block start positions, looking for
+ // the owner in the expected location. If we're below the actual block
+ // start position, the value at the owner position will be some oop
+ // (possibly NULL), which can never match the owner.
+ intptr_t owner_addr = reinterpret_cast<intptr_t>(owner);
+ for (unsigned i = 0; i < section_count; ++i, section += section_size) {
+ Block* candidate = reinterpret_cast<Block*>(section);
+ intptr_t* candidate_owner_addr
+ = reinterpret_cast<intptr_t*>(&candidate->_owner);
+ if (SafeFetchN(candidate_owner_addr, 0) == owner_addr) {
+ return candidate;
+ }
+ }
+ return NULL;
+}
+
+bool OopStorage::is_valid_block_locked_or_safepoint(const Block* check_block) const {
+ assert_locked_or_safepoint(_allocate_mutex);
+ // For now, simple linear search. Do something more clever if this
+ // is a performance bottleneck, particularly for allocation_status.
+ for (const Block* block = _active_list.chead();
+ block != NULL;
+ block = _active_list.next(*block)) {
+ if (check_block == block) {
+ return true;
+ }
+ }
+ return false;
+}
+
+#ifdef ASSERT
+void OopStorage::assert_at_safepoint() {
+ assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
+}
+#endif // ASSERT
+
+//////////////////////////////////////////////////////////////////////////////
+// Allocation
+//
+// Allocation involves the _allocate_list, which contains a subset of the
+// blocks owned by a storage object. This is a doubly-linked list, linked
+// through dedicated fields in the blocks. Full blocks are removed from this
+// list, though they are still present in the _active_list. Empty blocks are
+// kept at the end of the _allocate_list, to make it easy for empty block
+// deletion to find them.
+//
+// allocate(), release(), and delete_empty_blocks_concurrent() all lock the
+// _allocate_mutex while performing any list modifications.
+//
+// allocate() and release() update a block's _allocated_bitmask using CAS
+// loops. This prevents loss of updates even though release() may perform
+// some updates without any locking.
+//
+// allocate() obtains the entry from the first block in the _allocate_list,
+// and updates that block's _allocated_bitmask to indicate the entry is in
+// use. If this makes the block full (all entries in use), the block is
+// removed from the _allocate_list so it won't be considered by future
+// allocations until some entries in it are relased.
+//
+// release() looks up the block for the entry without locking. Once the block
+// has been determined, its _allocated_bitmask needs to be updated, and its
+// position in the _allocate_list may need to be updated. There are two
+// cases:
+//
+// (a) If the block is neither full nor would become empty with the release of
+// the entry, only its _allocated_bitmask needs to be updated. But if the CAS
+// update fails, the applicable case may change for the retry.
+//
+// (b) Otherwise, the _allocate_list will also need to be modified. This
+// requires locking the _allocate_mutex, and then attempting to CAS the
+// _allocated_bitmask. If the CAS fails, the applicable case may change for
+// the retry. If the CAS succeeds, then update the _allocate_list according
+// to the the state changes. If the block changed from full to not full, then
+// it needs to be added to the _allocate_list, for use in future allocations.
+// If the block changed from not empty to empty, then it is moved to the end
+// of the _allocate_list, for ease of empty block deletion processing.
+
+oop* OopStorage::allocate() {
+ MutexLockerEx ml(_allocate_mutex, Mutex::_no_safepoint_check_flag);
+ Block* block = _allocate_list.head();
+ if (block == NULL) {
+ // No available blocks; make a new one, and add to storage.
+ {
+ MutexUnlockerEx mul(_allocate_mutex, Mutex::_no_safepoint_check_flag);
+ block = Block::new_block(this);
+ }
+ if (block != NULL) {
+ // Add new block to storage.
+ log_info(oopstorage, blocks)("%s: new block " PTR_FORMAT, name(), p2i(block));
+
+ // Add to end of _allocate_list. The mutex release allowed
+ // other threads to add blocks to the _allocate_list. We prefer
+ // to allocate from non-empty blocks, to allow empty blocks to
+ // be deleted.
+ _allocate_list.push_back(*block);
+ ++_empty_block_count;
+ // Add to front of _active_list, and then record as the head
+ // block, for concurrent iteration protocol.
+ _active_list.push_front(*block);
+ ++_block_count;
+ // Ensure all setup of block is complete before making it visible.
+ OrderAccess::release_store(&_active_head, block);
+ } else {
+ log_info(oopstorage, blocks)("%s: failed new block allocation", name());
+ }
+ block = _allocate_list.head();
+ if (block == NULL) {
+ // Failed to make new block, and no other thread made a block
+ // available while the mutex was released, so return failure.
+ return NULL;
+ }
+ }
+ // Allocate from first block.
+ assert(block != NULL, "invariant");
+ assert(!block->is_full(), "invariant");
+ if (block->is_empty()) {
+ // Transitioning from empty to not empty.
+ log_debug(oopstorage, blocks)("%s: block not empty " PTR_FORMAT, name(), p2i(block));
+ --_empty_block_count;
+ }
+ oop* result = block->allocate();
+ assert(result != NULL, "allocation failed");
+ assert(!block->is_empty(), "postcondition");
+ Atomic::inc(&_allocation_count); // release updates outside lock.
+ if (block->is_full()) {
+ // Transitioning from not full to full.
+ // Remove full blocks from consideration by future allocates.
+ log_debug(oopstorage, blocks)("%s: block full " PTR_FORMAT, name(), p2i(block));
+ _allocate_list.unlink(*block);
+ }
+ log_info(oopstorage, ref)("%s: allocated " PTR_FORMAT, name(), p2i(result));
+ return result;
+}
+
+OopStorage::Block* OopStorage::find_block_or_null(const oop* ptr) const {
+ assert(ptr != NULL, "precondition");
+ return Block::block_for_ptr(this, ptr);
+}
+
+void OopStorage::release_from_block(Block& block, uintx releasing) {
+ assert(releasing != 0, "invariant");
+ uintx allocated = block.allocated_bitmask();
+ while (true) {
+ assert(releasing == (allocated & releasing), "invariant");
+ uintx new_value = allocated ^ releasing;
+ // CAS new_value into block's allocated bitmask, retrying with
+ // updated allocated bitmask until the CAS succeeds.
+ uintx fetched;
+ if (!is_full_bitmask(allocated) && !is_empty_bitmask(new_value)) {
+ fetched = block.cmpxchg_allocated_bitmask(new_value, allocated);
+ if (fetched == allocated) return;
+ } else {
+ // Need special handling if transitioning from full to not full,
+ // or from not empty to empty. For those cases, must hold the
+ // _allocation_mutex when updating the allocated bitmask, to
+ // ensure the associated list manipulations will be consistent
+ // with the allocation bitmask that is visible to other threads
+ // in allocate() or deleting empty blocks.
+ MutexLockerEx ml(_allocate_mutex, Mutex::_no_safepoint_check_flag);
+ fetched = block.cmpxchg_allocated_bitmask(new_value, allocated);
+ if (fetched == allocated) {
+ // CAS succeeded; handle special cases, which might no longer apply.
+ if (is_full_bitmask(allocated)) {
+ // Transitioning from full to not-full; add to _allocate_list.
+ log_debug(oopstorage, blocks)("%s: block not full " PTR_FORMAT, name(), p2i(&block));
+ _allocate_list.push_front(block);
+ assert(!block.is_full(), "invariant"); // Still not full.
+ }
+ if (is_empty_bitmask(new_value)) {
+ // Transitioning from not-empty to empty; move to end of
+ // _allocate_list, to make it a deletion candidate.
+ log_debug(oopstorage, blocks)("%s: block empty " PTR_FORMAT, name(), p2i(&block));
+ _allocate_list.unlink(block);
+ _allocate_list.push_back(block);
+ ++_empty_block_count;
+ assert(block.is_empty(), "invariant"); // Still empty.
+ }
+ return; // Successful CAS and transitions handled.
+ }
+ }
+ // CAS failed; retry with latest value.
+ allocated = fetched;
+ }
+}
+
+#ifdef ASSERT
+void OopStorage::check_release(const Block* block, const oop* ptr) const {
+ switch (allocation_status_validating_block(block, ptr)) {
+ case INVALID_ENTRY:
+ fatal("Releasing invalid entry: " PTR_FORMAT, p2i(ptr));
+ break;
+
+ case UNALLOCATED_ENTRY:
+ fatal("Releasing unallocated entry: " PTR_FORMAT, p2i(ptr));
+ break;
+
+ case ALLOCATED_ENTRY:
+ assert(block->contains(ptr), "invariant");
+ break;
+
+ default:
+ ShouldNotReachHere();
+ }
+}
+#endif // ASSERT
+
+inline void check_release_entry(const oop* entry) {
+ assert(entry != NULL, "Releasing NULL");
+ assert(*entry == NULL, "Releasing uncleared entry: " PTR_FORMAT, p2i(entry));
+}
+
+void OopStorage::release(const oop* ptr) {
+ check_release_entry(ptr);
+ Block* block = find_block_or_null(ptr);
+ check_release(block, ptr);
+ log_info(oopstorage, ref)("%s: released " PTR_FORMAT, name(), p2i(ptr));
+ release_from_block(*block, block->bitmask_for_entry(ptr));
+ Atomic::dec(&_allocation_count);
+}
+
+void OopStorage::release(const oop* const* ptrs, size_t size) {
+ size_t i = 0;
+ while (i < size) {
+ Block* block = find_block_or_null(ptrs[i]);
+ check_release(block, ptrs[i]);
+ log_info(oopstorage, ref)("%s: released " PTR_FORMAT, name(), p2i(ptrs[i]));
+ size_t count = 0;
+ uintx releasing = 0;
+ for ( ; i < size; ++i) {
+ const oop* entry = ptrs[i];
+ // If entry not in block, finish block and resume outer loop with entry.
+ if (!block->contains(entry)) break;
+ check_release_entry(entry);
+ // Add entry to releasing bitmap.
+ log_info(oopstorage, ref)("%s: released " PTR_FORMAT, name(), p2i(entry));
+ uintx entry_bitmask = block->bitmask_for_entry(entry);
+ assert((releasing & entry_bitmask) == 0,
+ "Duplicate entry: " PTR_FORMAT, p2i(entry));
+ releasing |= entry_bitmask;
+ ++count;
+ }
+ // Release the contiguous entries that are in block.
+ release_from_block(*block, releasing);
+ Atomic::sub(count, &_allocation_count);
+ }
+}
+
+const char* dup_name(const char* name) {
+ char* dup = NEW_C_HEAP_ARRAY(char, strlen(name) + 1, mtGC);
+ strcpy(dup, name);
+ return dup;
+}
+
+OopStorage::OopStorage(const char* name,
+ Mutex* allocate_mutex,
+ Mutex* active_mutex) :
+ _name(dup_name(name)),
+ _active_list(&Block::get_active_entry),
+ _allocate_list(&Block::get_allocate_entry),
+ _active_head(NULL),
+ _allocate_mutex(allocate_mutex),
+ _active_mutex(active_mutex),
+ _allocation_count(0),
+ _block_count(0),
+ _empty_block_count(0),
+ _concurrent_iteration_active(false)
+{
+ assert(_active_mutex->rank() < _allocate_mutex->rank(),
+ "%s: active_mutex must have lower rank than allocate_mutex", _name);
+ assert(_active_mutex->_safepoint_check_required != Mutex::_safepoint_check_always,
+ "%s: active mutex requires safepoint check", _name);
+ assert(_allocate_mutex->_safepoint_check_required != Mutex::_safepoint_check_always,
+ "%s: allocate mutex requires safepoint check", _name);
+}
+
+void OopStorage::delete_empty_block(const Block& block) {
+ assert(block.is_empty(), "discarding non-empty block");
+ log_info(oopstorage, blocks)("%s: delete empty block " PTR_FORMAT, name(), p2i(&block));
+ Block::delete_block(block);
+}
+
+OopStorage::~OopStorage() {
+ Block* block;
+ while ((block = _allocate_list.head()) != NULL) {
+ _allocate_list.unlink(*block);
+ }
+ while ((block = _active_list.head()) != NULL) {
+ _active_list.unlink(*block);
+ Block::delete_block(*block);
+ }
+ FREE_C_HEAP_ARRAY(char, _name);
+}
+
+void OopStorage::delete_empty_blocks_safepoint(size_t retain) {
+ assert_at_safepoint();
+ // Don't interfere with a concurrent iteration.
+ if (_concurrent_iteration_active) return;
+ // Compute the number of blocks to remove, to minimize volatile accesses.
+ size_t empty_blocks = _empty_block_count;
+ if (retain < empty_blocks) {
+ size_t remove_count = empty_blocks - retain;
+ // Update volatile counters once.
+ _block_count -= remove_count;
+ _empty_block_count -= remove_count;
+ do {
+ const Block* block = _allocate_list.ctail();
+ assert(block != NULL, "invariant");
+ assert(block->is_empty(), "invariant");
+ // Remove block from lists, and delete it.
+ _active_list.unlink(*block);
+ _allocate_list.unlink(*block);
+ delete_empty_block(*block);
+ } while (--remove_count > 0);
+ // Update _active_head, in case current value was in deleted set.
+ _active_head = _active_list.head();
+ }
+}
+
+void OopStorage::delete_empty_blocks_concurrent(size_t retain) {
+ MutexLockerEx ml(_allocate_mutex, Mutex::_no_safepoint_check_flag);
+ // Other threads could be adding to the empty block count while we
+ // release the mutex across the block deletions. Set an upper bound
+ // on how many blocks we'll try to release, so other threads can't
+ // cause an unbounded stay in this function.
+ if (_empty_block_count <= retain) return;
+ size_t limit = _empty_block_count - retain;
+ for (size_t i = 0; (i < limit) && (retain < _empty_block_count); ++i) {
+ const Block* block = _allocate_list.ctail();
+ assert(block != NULL, "invariant");
+ assert(block->is_empty(), "invariant");
+ {
+ MutexLockerEx aml(_active_mutex, Mutex::_no_safepoint_check_flag);
+ // Don't interfere with a concurrent iteration.
+ if (_concurrent_iteration_active) return;
+ // Remove block from _active_list, updating head if needed.
+ _active_list.unlink(*block);
+ --_block_count;
+ if (block == _active_head) {
+ _active_head = _active_list.head();
+ }
+ }
+ // Remove block from _allocate_list and delete it.
+ _allocate_list.unlink(*block);
+ --_empty_block_count;
+ // Release mutex while deleting block.
+ MutexUnlockerEx ul(_allocate_mutex, Mutex::_no_safepoint_check_flag);
+ delete_empty_block(*block);
+ }
+}
+
+OopStorage::EntryStatus
+OopStorage::allocation_status_validating_block(const Block* block,
+ const oop* ptr) const {
+ MutexLockerEx ml(_allocate_mutex, Mutex::_no_safepoint_check_flag);
+ if ((block == NULL) || !is_valid_block_locked_or_safepoint(block)) {
+ return INVALID_ENTRY;
+ } else if ((block->allocated_bitmask() & block->bitmask_for_entry(ptr)) != 0) {
+ return ALLOCATED_ENTRY;
+ } else {
+ return UNALLOCATED_ENTRY;
+ }
+}
+
+OopStorage::EntryStatus OopStorage::allocation_status(const oop* ptr) const {
+ return allocation_status_validating_block(find_block_or_null(ptr), ptr);
+}
+
+size_t OopStorage::allocation_count() const {
+ return _allocation_count;
+}
+
+size_t OopStorage::block_count() const {
+ return _block_count;
+}
+
+size_t OopStorage::empty_block_count() const {
+ return _empty_block_count;
+}
+
+size_t OopStorage::total_memory_usage() const {
+ size_t total_size = sizeof(OopStorage);
+ total_size += strlen(name()) + 1;
+ total_size += block_count() * Block::allocation_size();
+ return total_size;
+}
+
+// Parallel iteration support
+#if INCLUDE_ALL_GCS
+
+static char* not_started_marker_dummy = NULL;
+static void* const not_started_marker = ¬_started_marker_dummy;
+
+OopStorage::BasicParState::BasicParState(OopStorage* storage, bool concurrent) :
+ _storage(storage),
+ _next_block(not_started_marker),
+ _concurrent(concurrent)
+{
+ update_iteration_state(true);
+}
+
+OopStorage::BasicParState::~BasicParState() {
+ update_iteration_state(false);
+}
+
+void OopStorage::BasicParState::update_iteration_state(bool value) {
+ if (_concurrent) {
+ MutexLockerEx ml(_storage->_active_mutex, Mutex::_no_safepoint_check_flag);
+ assert(_storage->_concurrent_iteration_active != value, "precondition");
+ _storage->_concurrent_iteration_active = value;
+ }
+}
+
+void OopStorage::BasicParState::ensure_iteration_started() {
+ if (!_concurrent) assert_at_safepoint();
+ assert(!_concurrent || _storage->_concurrent_iteration_active, "invariant");
+ // Ensure _next_block is not the not_started_marker, setting it to
+ // the _active_head to start the iteration if necessary.
+ if (OrderAccess::load_acquire(&_next_block) == not_started_marker) {
+ Atomic::cmpxchg(_storage->_active_head, &_next_block, not_started_marker);
+ }
+ assert(_next_block != not_started_marker, "postcondition");
+}
+
+OopStorage::Block* OopStorage::BasicParState::claim_next_block() {
+ assert(_next_block != not_started_marker, "Iteration not started");
+ void* next = _next_block;
+ while (next != NULL) {
+ void* new_next = _storage->_active_list.next(*static_cast<Block*>(next));
+ void* fetched = Atomic::cmpxchg(new_next, &_next_block, next);
+ if (fetched == next) break; // Claimed.
+ next = fetched;
+ }
+ return static_cast<Block*>(next);
+}
+
+#endif // INCLUDE_ALL_GCS
+
+const char* OopStorage::name() const { return _name; }
+
+#ifndef PRODUCT
+
+void OopStorage::print_on(outputStream* st) const {
+ size_t allocations = _allocation_count;
+ size_t blocks = _block_count;
+ size_t empties = _empty_block_count;
+ // Comparison is being careful about racy accesses.
+ size_t used = (blocks < empties) ? 0 : (blocks - empties);
+
+ double data_size = section_size * section_count;
+ double alloc_percentage = percent_of((double)allocations, used * data_size);
+
+ st->print("%s: " SIZE_FORMAT " entries in " SIZE_FORMAT " blocks (%.F%%), "
+ SIZE_FORMAT " empties, " SIZE_FORMAT " bytes",
+ name(), allocations, used, alloc_percentage,
+ empties, total_memory_usage());
+ if (_concurrent_iteration_active) {
+ st->print(", concurrent iteration active");
+ }
+}
+
+#endif // !PRODUCT
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/shared/oopStorage.hpp Tue Nov 21 09:47:55 2017 -0500
@@ -0,0 +1,734 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SHARED_OOPSTORAGE_HPP
+#define SHARE_GC_SHARED_OOPSTORAGE_HPP
+
+#include "memory/allocation.hpp"
+#include "metaprogramming/conditional.hpp"
+#include "metaprogramming/isConst.hpp"
+#include "oops/oop.hpp"
+#include "utilities/count_trailing_zeros.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/macros.hpp"
+
+class Mutex;
+class outputStream;
+
+// OopStorage supports management of off-heap references to objects allocated
+// in the Java heap. An OopStorage object provides a set of Java object
+// references (oop values), which clients refer to via oop* handles to the
+// associated OopStorage entries. Clients allocate entries to create a
+// (possibly weak) reference to a Java object, use that reference, and release
+// the reference when no longer needed.
+//
+// The garbage collector must know about all OopStorage objects and their
+// reference strength. OopStorage provides the garbage collector with support
+// for iteration over all the allocated entries.
+//
+// There are several categories of interaction with an OopStorage object.
+//
+// (1) allocation and release of entries, by the mutator or the VM.
+// (2) iteration by the garbage collector, possibly concurrent with mutator.
+// (3) iteration by other, non-GC, tools (only at safepoints).
+// (4) cleanup of unused internal storage, possibly concurrent with mutator.
+//
+// A goal of OopStorage is to make these interactions thread-safe, while
+// minimizing potential lock contention issues within and between these
+// categories. In particular, support for concurrent iteration by the garbage
+// collector, under certain restrictions, is required. Further, it must not
+// block nor be blocked by other operations for long periods.
+//
+// Internally, OopStorage is a set of Block objects, from which entries are
+// allocated and released. A block contains an oop[] and a bitmask indicating
+// which entries are in use (have been allocated and not yet released). New
+// blocks are constructed and added to the storage object when an entry
+// allocation request is made and there are no blocks with unused entries.
+// Blocks may be removed and deleted when empty.
+//
+// There are two important (and somewhat intertwined) protocols governing
+// concurrent access to a storage object. These are the Concurrent Iteration
+// Protocol and the Allocation Protocol. See the ParState class for a
+// discussion of concurrent iteration and the management of thread
+// interactions for this protocol. Similarly, see the allocate() function for
+// a discussion of allocation.
+
+class OopStorage : public CHeapObj<mtGC> {
+public:
+ OopStorage(const char* name, Mutex* allocate_mutex, Mutex* active_mutex);
+ ~OopStorage();
+
+ // These count and usage accessors are racy unless at a safepoint.
+
+ // The number of allocated and not yet released entries.
+ size_t allocation_count() const;
+
+ // The number of blocks of entries. Useful for sizing parallel iteration.
+ size_t block_count() const;
+
+ // The number of blocks with no allocated entries. Useful for sizing
+ // parallel iteration and scheduling block deletion.
+ size_t empty_block_count() const;
+
+ // Total number of blocks * memory allocation per block, plus
+ // bookkeeping overhead, including this storage object.
+ size_t total_memory_usage() const;
+
+ enum EntryStatus {
+ INVALID_ENTRY,
+ UNALLOCATED_ENTRY,
+ ALLOCATED_ENTRY
+ };
+
+ // Locks _allocate_mutex.
+ EntryStatus allocation_status(const oop* ptr) const;
+
+ // Allocates and returns a new entry. Returns NULL if memory allocation
+ // failed. Locks _allocate_mutex.
+ // postcondition: *result == NULL.
+ oop* allocate();
+
+ // Deallocates ptr, after setting its value to NULL. Locks _allocate_mutex.
+ // precondition: ptr is a valid allocated entry.
+ // precondition: *ptr == NULL.
+ void release(const oop* ptr);
+
+ // Releases all the ptrs. Possibly faster than individual calls to
+ // release(oop*). Best if ptrs is sorted by address. Locks
+ // _allocate_mutex.
+ // precondition: All elements of ptrs are valid allocated entries.
+ // precondition: *ptrs[i] == NULL, for i in [0,size).
+ void release(const oop* const* ptrs, size_t size);
+
+ // Applies f to each allocated entry's location. f must be a function or
+ // function object. Assume p is either a const oop* or an oop*, depending
+ // on whether the associated storage is const or non-const, respectively.
+ // Then f(p) must be a valid expression. The result of invoking f(p) must
+ // be implicitly convertible to bool. Iteration terminates and returns
+ // false if any invocation of f returns false. Otherwise, the result of
+ // iteration is true.
+ // precondition: at safepoint.
+ template<typename F> bool iterate_safepoint(F f);
+ template<typename F> bool iterate_safepoint(F f) const;
+
+ // oops_do and weak_oops_do are wrappers around iterate_safepoint, providing
+ // an adaptation layer allowing the use of existing is-alive closures and
+ // OopClosures. Assume p is either const oop* or oop*, depending on whether
+ // the associated storage is const or non-const, respectively. Then
+ //
+ // - closure->do_oop(p) must be a valid expression whose value is ignored.
+ //
+ // - is_alive->do_object_b(*p) must be a valid expression whose value is
+ // convertible to bool.
+ //
+ // For weak_oops_do, if *p == NULL then neither is_alive nor closure will be
+ // invoked for p. If is_alive->do_object_b(*p) is false, then closure will
+ // not be invoked on p, and *p will be set to NULL.
+
+ template<typename Closure> void oops_do(Closure* closure);
+ template<typename Closure> void oops_do(Closure* closure) const;
+ template<typename Closure> void weak_oops_do(Closure* closure);
+
+ template<typename IsAliveClosure, typename Closure>
+ void weak_oops_do(IsAliveClosure* is_alive, Closure* closure);
+
+#if INCLUDE_ALL_GCS
+ // Parallel iteration is for the exclusive use of the GC.
+ // Other clients must use serial iteration.
+ template<bool concurrent, bool is_const> class ParState;
+#endif // INCLUDE_ALL_GCS
+
+ // Block cleanup functions are for the exclusive use of the GC.
+ // Both stop deleting if there is an in-progress concurrent iteration.
+ // Concurrent deletion locks both the allocate_mutex and the active_mutex.
+ void delete_empty_blocks_safepoint(size_t retain = 1);
+ void delete_empty_blocks_concurrent(size_t retain = 1);
+
+ // Debugging and logging support.
+ const char* name() const;
+ void print_on(outputStream* st) const PRODUCT_RETURN;
+
+ // Provides access to storage internals, for unit testing.
+ class TestAccess;
+
+private:
+ class Block;
+ class BlockList;
+
+ class BlockEntry VALUE_OBJ_CLASS_SPEC {
+ friend class BlockList;
+
+ // Members are mutable, and we deal exclusively with pointers to
+ // const, to make const blocks easier to use; a block being const
+ // doesn't prevent modifying its list state.
+ mutable const Block* _prev;
+ mutable const Block* _next;
+
+ // Noncopyable.
+ BlockEntry(const BlockEntry&);
+ BlockEntry& operator=(const BlockEntry&);
+
+ public:
+ BlockEntry();
+ ~BlockEntry();
+ };
+
+ class BlockList VALUE_OBJ_CLASS_SPEC {
+ const Block* _head;
+ const Block* _tail;
+ const BlockEntry& (*_get_entry)(const Block& block);
+
+ // Noncopyable.
+ BlockList(const BlockList&);
+ BlockList& operator=(const BlockList&);
+
+ public:
+ BlockList(const BlockEntry& (*get_entry)(const Block& block));
+ ~BlockList();
+
+ Block* head();
+ const Block* chead() const;
+ const Block* ctail() const;
+
+ Block* prev(Block& block);
+ Block* next(Block& block);
+
+ const Block* prev(const Block& block) const;
+ const Block* next(const Block& block) const;
+
+ void push_front(const Block& block);
+ void push_back(const Block& block);
+ void unlink(const Block& block);
+ };
+
+ class Block /* No base class, to avoid messing up alignment requirements */ {
+ // _data must be the first non-static data member, for alignment.
+ oop _data[BitsPerWord];
+ static const unsigned _data_pos = 0; // Position of _data.
+
+ volatile uintx _allocated_bitmask; // One bit per _data element.
+ const OopStorage* _owner;
+ void* _memory; // Unaligned storage containing block.
+ BlockEntry _active_entry;
+ BlockEntry _allocate_entry;
+
+ Block(const OopStorage* owner, void* memory);
+ ~Block();
+
+ void check_index(unsigned index) const;
+ unsigned get_index(const oop* ptr) const;
+
+ template<typename F, typename BlockPtr>
+ static bool iterate_impl(F f, BlockPtr b);
+
+ // Noncopyable.
+ Block(const Block&);
+ Block& operator=(const Block&);
+
+ public:
+ static const BlockEntry& get_active_entry(const Block& block);
+ static const BlockEntry& get_allocate_entry(const Block& block);
+
+ static size_t allocation_size();
+ static size_t allocation_alignment_shift();
+
+ oop* get_pointer(unsigned index);
+ const oop* get_pointer(unsigned index) const;
+
+ uintx bitmask_for_index(unsigned index) const;
+ uintx bitmask_for_entry(const oop* ptr) const;
+
+ // Allocation bitmask accessors are racy.
+ bool is_full() const;
+ bool is_empty() const;
+ uintx allocated_bitmask() const;
+ uintx cmpxchg_allocated_bitmask(uintx new_value, uintx compare_value);
+
+ bool contains(const oop* ptr) const;
+
+ // Returns NULL if ptr is not in a block or not allocated in that block.
+ static Block* block_for_ptr(const OopStorage* owner, const oop* ptr);
+
+ oop* allocate();
+ static Block* new_block(const OopStorage* owner);
+ static void delete_block(const Block& block);
+
+ template<typename F> bool iterate(F f);
+ template<typename F> bool iterate(F f) const;
+ }; // class Block
+
+ const char* _name;
+ BlockList _active_list;
+ BlockList _allocate_list;
+ Block* volatile _active_head;
+
+ Mutex* _allocate_mutex;
+ Mutex* _active_mutex;
+
+ // Counts are volatile for racy unlocked accesses.
+ volatile size_t _allocation_count;
+ volatile size_t _block_count;
+ volatile size_t _empty_block_count;
+ // mutable because this gets set even for const iteration.
+ mutable bool _concurrent_iteration_active;
+
+ Block* find_block_or_null(const oop* ptr) const;
+ bool is_valid_block_locked_or_safepoint(const Block* block) const;
+ EntryStatus allocation_status_validating_block(const Block* block, const oop* ptr) const;
+ void check_release(const Block* block, const oop* ptr) const NOT_DEBUG_RETURN;
+ void release_from_block(Block& block, uintx release_bitmask);
+ void delete_empty_block(const Block& block);
+
+ static void assert_at_safepoint() NOT_DEBUG_RETURN;
+
+ template<typename F, typename Storage>
+ static bool iterate_impl(F f, Storage* storage);
+
+#if INCLUDE_ALL_GCS
+ // Implementation support for parallel iteration
+ class BasicParState;
+#endif // INCLUDE_ALL_GCS
+
+ // Wrapper for OopClosure-style function, so it can be used with
+ // iterate. Assume p is of type oop*. Then cl->do_oop(p) must be a
+ // valid expression whose value may be ignored.
+ template<typename Closure> class OopFn;
+ template<typename Closure> static OopFn<Closure> oop_fn(Closure* cl);
+
+ // Wrapper for BoolObjectClosure + iteration handler pair, so they
+ // can be used with iterate.
+ template<typename IsAlive, typename F> class IfAliveFn;
+ template<typename IsAlive, typename F>
+ static IfAliveFn<IsAlive, F> if_alive_fn(IsAlive* is_alive, F f);
+
+ // Wrapper for iteration handler, automatically skipping NULL entries.
+ template<typename F> class SkipNullFn;
+ template<typename F> static SkipNullFn<F> skip_null_fn(F f);
+
+ // Wrapper for iteration handler; ignore handler result and return true.
+ template<typename F> class AlwaysTrueFn;
+};
+
+inline OopStorage::Block* OopStorage::BlockList::head() {
+ return const_cast<Block*>(_head);
+}
+
+inline const OopStorage::Block* OopStorage::BlockList::chead() const {
+ return _head;
+}
+
+inline const OopStorage::Block* OopStorage::BlockList::ctail() const {
+ return _tail;
+}
+
+inline OopStorage::Block* OopStorage::BlockList::prev(Block& block) {
+ return const_cast<Block*>(_get_entry(block)._prev);
+}
+
+inline OopStorage::Block* OopStorage::BlockList::next(Block& block) {
+ return const_cast<Block*>(_get_entry(block)._next);
+}
+
+inline const OopStorage::Block* OopStorage::BlockList::prev(const Block& block) const {
+ return _get_entry(block)._prev;
+}
+
+inline const OopStorage::Block* OopStorage::BlockList::next(const Block& block) const {
+ return _get_entry(block)._next;
+}
+
+template<typename Closure>
+class OopStorage::OopFn VALUE_OBJ_CLASS_SPEC {
+public:
+ explicit OopFn(Closure* cl) : _cl(cl) {}
+
+ template<typename OopPtr> // [const] oop*
+ bool operator()(OopPtr ptr) const {
+ _cl->do_oop(ptr);
+ return true;
+ }
+
+private:
+ Closure* _cl;
+};
+
+template<typename Closure>
+inline OopStorage::OopFn<Closure> OopStorage::oop_fn(Closure* cl) {
+ return OopFn<Closure>(cl);
+}
+
+template<typename IsAlive, typename F>
+class OopStorage::IfAliveFn VALUE_OBJ_CLASS_SPEC {
+public:
+ IfAliveFn(IsAlive* is_alive, F f) : _is_alive(is_alive), _f(f) {}
+
+ bool operator()(oop* ptr) const {
+ bool result = true;
+ oop v = *ptr;
+ if (v != NULL) {
+ if (_is_alive->do_object_b(v)) {
+ result = _f(ptr);
+ } else {
+ *ptr = NULL; // Clear dead value.
+ }
+ }
+ return result;
+ }
+
+private:
+ IsAlive* _is_alive;
+ F _f;
+};
+
+template<typename IsAlive, typename F>
+inline OopStorage::IfAliveFn<IsAlive, F> OopStorage::if_alive_fn(IsAlive* is_alive, F f) {
+ return IfAliveFn<IsAlive, F>(is_alive, f);
+}
+
+template<typename F>
+class OopStorage::SkipNullFn VALUE_OBJ_CLASS_SPEC {
+public:
+ SkipNullFn(F f) : _f(f) {}
+
+ template<typename OopPtr> // [const] oop*
+ bool operator()(OopPtr ptr) const {
+ return (*ptr != NULL) ? _f(ptr) : true;
+ }
+
+private:
+ F _f;
+};
+
+template<typename F>
+inline OopStorage::SkipNullFn<F> OopStorage::skip_null_fn(F f) {
+ return SkipNullFn<F>(f);
+}
+
+template<typename F>
+class OopStorage::AlwaysTrueFn VALUE_OBJ_CLASS_SPEC {
+ F _f;
+
+public:
+ AlwaysTrueFn(F f) : _f(f) {}
+
+ template<typename OopPtr> // [const] oop*
+ bool operator()(OopPtr ptr) const { _f(ptr); return true; }
+};
+
+// Inline Block accesses for use in iteration inner loop.
+
+inline void OopStorage::Block::check_index(unsigned index) const {
+ assert(index < ARRAY_SIZE(_data), "Index out of bounds: %u", index);
+}
+
+inline oop* OopStorage::Block::get_pointer(unsigned index) {
+ check_index(index);
+ return &_data[index];
+}
+
+inline const oop* OopStorage::Block::get_pointer(unsigned index) const {
+ check_index(index);
+ return &_data[index];
+}
+
+inline uintx OopStorage::Block::allocated_bitmask() const {
+ return _allocated_bitmask;
+}
+
+inline uintx OopStorage::Block::bitmask_for_index(unsigned index) const {
+ check_index(index);
+ return uintx(1) << index;
+}
+
+// Provide const or non-const iteration, depending on whether BlockPtr
+// is const Block* or Block*, respectively.
+template<typename F, typename BlockPtr> // BlockPtr := [const] Block*
+inline bool OopStorage::Block::iterate_impl(F f, BlockPtr block) {
+ uintx bitmask = block->allocated_bitmask();
+ while (bitmask != 0) {
+ unsigned index = count_trailing_zeros(bitmask);
+ bitmask ^= block->bitmask_for_index(index);
+ if (!f(block->get_pointer(index))) {
+ return false;
+ }
+ }
+ return true;
+}
+
+template<typename F>
+inline bool OopStorage::Block::iterate(F f) {
+ return iterate_impl(f, this);
+}
+
+template<typename F>
+inline bool OopStorage::Block::iterate(F f) const {
+ return iterate_impl(f, this);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Support for serial iteration, always at a safepoint.
+
+// Provide const or non-const iteration, depending on whether Storage is
+// const OopStorage* or OopStorage*, respectively.
+template<typename F, typename Storage> // Storage := [const] OopStorage
+inline bool OopStorage::iterate_impl(F f, Storage* storage) {
+ assert_at_safepoint();
+ // Propagate const/non-const iteration to the block layer, by using
+ // const or non-const blocks as corresponding to Storage.
+ typedef typename Conditional<IsConst<Storage>::value, const Block*, Block*>::type BlockPtr;
+ for (BlockPtr block = storage->_active_head;
+ block != NULL;
+ block = storage->_active_list.next(*block)) {
+ if (!block->iterate(f)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+template<typename F>
+inline bool OopStorage::iterate_safepoint(F f) {
+ return iterate_impl(f, this);
+}
+
+template<typename F>
+inline bool OopStorage::iterate_safepoint(F f) const {
+ return iterate_impl(f, this);
+}
+
+template<typename Closure>
+inline void OopStorage::oops_do(Closure* cl) {
+ iterate_safepoint(oop_fn(cl));
+}
+
+template<typename Closure>
+inline void OopStorage::oops_do(Closure* cl) const {
+ iterate_safepoint(oop_fn(cl));
+}
+
+template<typename Closure>
+inline void OopStorage::weak_oops_do(Closure* cl) {
+ iterate_safepoint(skip_null_fn(oop_fn(cl)));
+}
+
+template<typename IsAliveClosure, typename Closure>
+inline void OopStorage::weak_oops_do(IsAliveClosure* is_alive, Closure* cl) {
+ iterate_safepoint(if_alive_fn(is_alive, oop_fn(cl)));
+}
+
+#if INCLUDE_ALL_GCS
+
+//////////////////////////////////////////////////////////////////////////////
+// Support for parallel and optionally concurrent state iteration.
+//
+// Parallel iteration is for the exclusive use of the GC. Other iteration
+// clients must use serial iteration.
+//
+// Concurrent Iteration
+//
+// Iteration involves the _active_list, which contains all of the blocks owned
+// by a storage object. This is a doubly-linked list, linked through
+// dedicated fields in the blocks.
+//
+// At most one concurrent ParState can exist at a time for a given storage
+// object.
+//
+// A concurrent ParState sets the associated storage's
+// _concurrent_iteration_active flag true when the state is constructed, and
+// sets it false when the state is destroyed. These assignments are made with
+// _active_mutex locked. Meanwhile, empty block deletion is not done while
+// _concurrent_iteration_active is true. The flag check and the dependent
+// removal of a block from the _active_list is performed with _active_mutex
+// locked. This prevents concurrent iteration and empty block deletion from
+// interfering with with each other.
+//
+// Both allocate() and delete_empty_blocks_concurrent() lock the
+// _allocate_mutex while performing their respective list manipulations,
+// preventing them from interfering with each other.
+//
+// When allocate() creates a new block, it is added to the front of the
+// _active_list. Then _active_head is set to the new block. When concurrent
+// iteration is started (by a parallel worker thread calling the state's
+// iterate() function), the current _active_head is used as the initial block
+// for the iteration, with iteration proceeding down the list headed by that
+// block.
+//
+// As a result, the list over which concurrent iteration operates is stable.
+// However, once the iteration is started, later allocations may add blocks to
+// the front of the list that won't be examined by the iteration. And while
+// the list is stable, concurrent allocate() and release() operations may
+// change the set of allocated entries in a block at any time during the
+// iteration.
+//
+// As a result, a concurrent iteration handler must accept that some
+// allocations and releases that occur after the iteration started will not be
+// seen by the iteration. Further, some may overlap examination by the
+// iteration. To help with this, allocate() and release() have an invariant
+// that an entry's value must be NULL when it is not in use.
+//
+// An in-progress delete_empty_blocks_concurrent() operation can contend with
+// the start of a concurrent iteration over the _active_mutex. Since both are
+// under GC control, that potential contention can be eliminated by never
+// scheduling both operations to run at the same time.
+//
+// ParState<concurrent, is_const>
+// concurrent must be true if iteration is concurrent with the
+// mutator, false if iteration is at a safepoint.
+//
+// is_const must be true if the iteration is over a constant storage
+// object, false if the iteration may modify the storage object.
+//
+// ParState([const] OopStorage* storage)
+// Construct an object for managing an iteration over storage. For a
+// concurrent ParState, empty block deletion for the associated storage
+// is inhibited for the life of the ParState. There can be no more
+// than one live concurrent ParState at a time for a given storage object.
+//
+// template<typename F> void iterate(F f)
+// Repeatedly claims a block from the associated storage that has
+// not been processed by this iteration (possibly by other threads),
+// and applies f to each entry in the claimed block. Assume p is of
+// type const oop* or oop*, according to is_const. Then f(p) must be
+// a valid expression whose value is ignored. Concurrent uses must
+// be prepared for an entry's value to change at any time, due to
+// mutator activity.
+//
+// template<typename Closure> void oops_do(Closure* cl)
+// Wrapper around iterate, providing an adaptation layer allowing
+// the use of OopClosures and similar objects for iteration. Assume
+// p is of type const oop* or oop*, according to is_const. Then
+// cl->do_oop(p) must be a valid expression whose value is ignored.
+// Concurrent uses must be prepared for the entry's value to change
+// at any time, due to mutator activity.
+//
+// Optional operations, provided only if !concurrent && !is_const.
+// These are not provided when is_const, because the storage object
+// may be modified by the iteration infrastructure, even if the
+// provided closure doesn't modify the storage object. These are not
+// provided when concurrent because any pre-filtering behavior by the
+// iteration infrastructure is inappropriate for concurrent iteration;
+// modifications of the storage by the mutator could result in the
+// pre-filtering being applied (successfully or not) to objects that
+// are unrelated to what the closure finds in the entry.
+//
+// template<typename Closure> void weak_oops_do(Closure* cl)
+// template<typename IsAliveClosure, typename Closure>
+// void weak_oops_do(IsAliveClosure* is_alive, Closure* cl)
+// Wrappers around iterate, providing an adaptation layer allowing
+// the use of is-alive closures and OopClosures for iteration.
+// Assume p is of type oop*. Then
+//
+// - cl->do_oop(p) must be a valid expression whose value is ignored.
+//
+// - is_alive->do_object_b(*p) must be a valid expression whose value
+// is convertible to bool.
+//
+// If *p == NULL then neither is_alive nor cl will be invoked for p.
+// If is_alive->do_object_b(*p) is false, then cl will not be
+// invoked on p.
+
+class OopStorage::BasicParState VALUE_OBJ_CLASS_SPEC {
+public:
+ BasicParState(OopStorage* storage, bool concurrent);
+ ~BasicParState();
+
+ template<bool is_const, typename F> void iterate(F f) {
+ // Wrap f in ATF so we can use Block::iterate.
+ AlwaysTrueFn<F> atf_f(f);
+ ensure_iteration_started();
+ typename Conditional<is_const, const Block*, Block*>::type block;
+ while ((block = claim_next_block()) != NULL) {
+ block->iterate(atf_f);
+ }
+ }
+
+private:
+ OopStorage* _storage;
+ void* volatile _next_block;
+ bool _concurrent;
+
+ // Noncopyable.
+ BasicParState(const BasicParState&);
+ BasicParState& operator=(const BasicParState&);
+
+ void update_iteration_state(bool value);
+ void ensure_iteration_started();
+ Block* claim_next_block();
+};
+
+template<bool concurrent, bool is_const>
+class OopStorage::ParState VALUE_OBJ_CLASS_SPEC {
+ BasicParState _basic_state;
+
+public:
+ ParState(const OopStorage* storage) :
+ // For simplicity, always recorded as non-const.
+ _basic_state(const_cast<OopStorage*>(storage), concurrent)
+ {}
+
+ template<typename F>
+ void iterate(F f) {
+ _basic_state.template iterate<is_const>(f);
+ }
+
+ template<typename Closure>
+ void oops_do(Closure* cl) {
+ this->iterate(oop_fn(cl));
+ }
+};
+
+template<>
+class OopStorage::ParState<false, false> VALUE_OBJ_CLASS_SPEC {
+ BasicParState _basic_state;
+
+public:
+ ParState(OopStorage* storage) :
+ _basic_state(storage, false)
+ {}
+
+ template<typename F>
+ void iterate(F f) {
+ _basic_state.template iterate<false>(f);
+ }
+
+ template<typename Closure>
+ void oops_do(Closure* cl) {
+ this->iterate(oop_fn(cl));
+ }
+
+ template<typename Closure>
+ void weak_oops_do(Closure* cl) {
+ this->iterate(skip_null_fn(oop_fn(cl)));
+ }
+
+ template<typename IsAliveClosure, typename Closure>
+ void weak_oops_do(IsAliveClosure* is_alive, Closure* cl) {
+ this->iterate(if_alive_fn(is_alive, oop_fn(cl)));
+ }
+};
+
+#endif // INCLUDE_ALL_GCS
+
+#endif // include guard
--- a/src/hotspot/share/logging/logTag.hpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/logging/logTag.hpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2018, 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
@@ -101,6 +101,7 @@
LOG_TAG(objecttagging) \
LOG_TAG(obsolete) \
LOG_TAG(oopmap) \
+ LOG_TAG(oopstorage) \
LOG_TAG(os) \
LOG_TAG(pagesize) \
LOG_TAG(patch) \
--- a/src/hotspot/share/prims/jni.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/prims/jni.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012 Red Hat, Inc.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@@ -862,16 +862,7 @@
HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
- jobjectRefType ret;
- if (JNIHandles::is_local_handle(thread, obj) ||
- JNIHandles::is_frame_handle(thread, obj))
- ret = JNILocalRefType;
- else if (JNIHandles::is_global_handle(obj))
- ret = JNIGlobalRefType;
- else if (JNIHandles::is_weak_global_handle(obj))
- ret = JNIWeakGlobalRefType;
- else
- ret = JNIInvalidRefType;
+ jobjectRefType ret = JNIHandles::handle_type(thread, obj);
HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
return ret;
--- a/src/hotspot/share/prims/jniCheck.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/prims/jniCheck.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2018, 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
@@ -435,10 +435,7 @@
}
oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {
- if (JNIHandles::is_frame_handle(thr, obj) ||
- JNIHandles::is_local_handle(thr, obj) ||
- JNIHandles::is_global_handle(obj) ||
- JNIHandles::is_weak_global_handle(obj)) {
+ if (JNIHandles::handle_type(thr, obj) != JNIInvalidRefType) {
ASSERT_OOPS_ALLOWED;
return JNIHandles::resolve_external_guard(obj);
}
--- a/src/hotspot/share/prims/jvmtiTagMap.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/prims/jvmtiTagMap.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2018, 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
@@ -2582,9 +2582,9 @@
return;
}
- // ignore null or deleted handles
oop o = *obj_p;
- if (o == NULL || o == JNIHandles::deleted_handle()) {
+ // ignore null
+ if (o == NULL) {
return;
}
@@ -2641,9 +2641,9 @@
return;
}
- // ignore null or deleted handles
oop o = *obj_p;
- if (o == NULL || o == JNIHandles::deleted_handle()) {
+ // ignore null
+ if (o == NULL) {
return;
}
--- a/src/hotspot/share/runtime/jniHandles.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/runtime/jniHandles.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2018, 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
@@ -23,7 +23,7 @@
*/
#include "precompiled.hpp"
-#include "classfile/systemDictionary.hpp"
+#include "gc/shared/oopStorage.hpp"
#include "logging/log.hpp"
#include "memory/iterator.hpp"
#include "oops/oop.inline.hpp"
@@ -32,13 +32,13 @@
#include "runtime/thread.inline.hpp"
#include "trace/traceMacros.hpp"
#include "utilities/align.hpp"
+#include "utilities/debug.hpp"
#if INCLUDE_ALL_GCS
#include "gc/g1/g1SATBCardTableModRefBS.hpp"
#endif
-JNIHandleBlock* JNIHandles::_global_handles = NULL;
-JNIHandleBlock* JNIHandles::_weak_global_handles = NULL;
-oop JNIHandles::_deleted_handle = NULL;
+OopStorage* JNIHandles::_global_handles = NULL;
+OopStorage* JNIHandles::_weak_global_handles = NULL;
jobject JNIHandles::make_local(oop obj) {
@@ -46,7 +46,7 @@
return NULL; // ignore null handles
} else {
Thread* thread = Thread::current();
- assert(Universe::heap()->is_in_reserved(obj), "sanity check");
+ assert(oopDesc::is_oop(obj), "not an oop");
assert(!current_thread_in_native(), "must not be in native");
return thread->active_handles()->allocate_handle(obj);
}
@@ -59,7 +59,7 @@
if (obj == NULL) {
return NULL; // ignore null handles
} else {
- assert(Universe::heap()->is_in_reserved(obj), "sanity check");
+ assert(oopDesc::is_oop(obj), "not an oop");
assert(thread->is_Java_thread(), "not a Java thread");
assert(!current_thread_in_native(), "must not be in native");
return thread->active_handles()->allocate_handle(obj);
@@ -72,22 +72,39 @@
return NULL; // ignore null handles
} else {
JavaThread* thread = JavaThread::thread_from_jni_environment(env);
- assert(Universe::heap()->is_in_reserved(obj), "sanity check");
+ assert(oopDesc::is_oop(obj), "not an oop");
assert(!current_thread_in_native(), "must not be in native");
return thread->active_handles()->allocate_handle(obj);
}
}
-jobject JNIHandles::make_global(Handle obj) {
+static void report_handle_allocation_failure(AllocFailType alloc_failmode,
+ const char* handle_kind) {
+ if (alloc_failmode == AllocFailStrategy::EXIT_OOM) {
+ // Fake size value, since we don't know the min allocation size here.
+ vm_exit_out_of_memory(sizeof(oop), OOM_MALLOC_ERROR,
+ "Cannot create %s JNI handle", handle_kind);
+ } else {
+ assert(alloc_failmode == AllocFailStrategy::RETURN_NULL, "invariant");
+ }
+}
+
+jobject JNIHandles::make_global(Handle obj, AllocFailType alloc_failmode) {
assert(!Universe::heap()->is_gc_active(), "can't extend the root set during GC");
assert(!current_thread_in_native(), "must not be in native");
jobject res = NULL;
if (!obj.is_null()) {
// ignore null handles
- MutexLocker ml(JNIGlobalHandle_lock);
- assert(Universe::heap()->is_in_reserved(obj()), "sanity check");
- res = _global_handles->allocate_handle(obj());
+ assert(oopDesc::is_oop(obj()), "not an oop");
+ oop* ptr = _global_handles->allocate();
+ // Return NULL on allocation failure.
+ if (ptr != NULL) {
+ *ptr = obj();
+ res = reinterpret_cast<jobject>(ptr);
+ } else {
+ report_handle_allocation_failure(alloc_failmode, "global");
+ }
} else {
CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
}
@@ -96,32 +113,31 @@
}
-jobject JNIHandles::make_weak_global(Handle obj) {
+jobject JNIHandles::make_weak_global(Handle obj, AllocFailType alloc_failmode) {
assert(!Universe::heap()->is_gc_active(), "can't extend the root set during GC");
assert(!current_thread_in_native(), "must not be in native");
jobject res = NULL;
if (!obj.is_null()) {
// ignore null handles
- {
- MutexLocker ml(JNIGlobalHandle_lock);
- assert(Universe::heap()->is_in_reserved(obj()), "sanity check");
- res = _weak_global_handles->allocate_handle(obj());
+ assert(oopDesc::is_oop(obj()), "not an oop");
+ oop* ptr = _weak_global_handles->allocate();
+ // Return NULL on allocation failure.
+ if (ptr != NULL) {
+ *ptr = obj();
+ char* tptr = reinterpret_cast<char*>(ptr) + weak_tag_value;
+ res = reinterpret_cast<jobject>(tptr);
+ } else {
+ report_handle_allocation_failure(alloc_failmode, "weak global");
}
- // Add weak tag.
- assert(is_aligned(res, weak_tag_alignment), "invariant");
- char* tptr = reinterpret_cast<char*>(res) + weak_tag_value;
- res = reinterpret_cast<jobject>(tptr);
} else {
CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
}
return res;
}
-template<bool external_guard>
oop JNIHandles::resolve_jweak(jweak handle) {
assert(is_jweak(handle), "precondition");
oop result = jweak_ref(handle);
- result = guard_value<external_guard>(result);
#if INCLUDE_ALL_GCS
if (result != NULL && UseG1GC) {
G1SATBCardTableModRefBS::enqueue(result);
@@ -130,31 +146,30 @@
return result;
}
-template oop JNIHandles::resolve_jweak<true>(jweak);
-template oop JNIHandles::resolve_jweak<false>(jweak);
-
bool JNIHandles::is_global_weak_cleared(jweak handle) {
assert(is_jweak(handle), "not a weak handle");
- return guard_value<false>(jweak_ref(handle)) == NULL;
+ return jweak_ref(handle) == NULL;
}
void JNIHandles::destroy_global(jobject handle) {
if (handle != NULL) {
- assert(is_global_handle(handle), "Invalid delete of global JNI handle");
- jobject_ref(handle) = deleted_handle();
+ assert(!is_jweak(handle), "wrong method for detroying jweak");
+ jobject_ref(handle) = NULL;
+ _global_handles->release(&jobject_ref(handle));
}
}
void JNIHandles::destroy_weak_global(jobject handle) {
if (handle != NULL) {
- jweak_ref(handle) = deleted_handle();
+ assert(is_jweak(handle), "JNI handle not jweak");
+ jweak_ref(handle) = NULL;
+ _weak_global_handles->release(&jweak_ref(handle));
}
}
void JNIHandles::oops_do(OopClosure* f) {
- f->do_oop(&_deleted_handle);
_global_handles->oops_do(f);
}
@@ -165,19 +180,54 @@
void JNIHandles::weak_oops_do(OopClosure* f) {
- AlwaysTrueClosure always_true;
- weak_oops_do(&always_true, f);
+ _weak_global_handles->weak_oops_do(f);
}
void JNIHandles::initialize() {
- _global_handles = JNIHandleBlock::allocate_block();
- _weak_global_handles = JNIHandleBlock::allocate_block();
- EXCEPTION_MARK;
- // We will never reach the CATCH below since Exceptions::_throw will cause
- // the VM to exit if an exception is thrown during initialization
- Klass* k = SystemDictionary::Object_klass();
- _deleted_handle = InstanceKlass::cast(k)->allocate_instance(CATCH);
+ _global_handles = new OopStorage("JNI Global",
+ JNIGlobalAlloc_lock,
+ JNIGlobalActive_lock);
+ _weak_global_handles = new OopStorage("JNI Weak",
+ JNIWeakAlloc_lock,
+ JNIWeakActive_lock);
+}
+
+
+inline bool is_storage_handle(const OopStorage* storage, const oop* ptr) {
+ return storage->allocation_status(ptr) == OopStorage::ALLOCATED_ENTRY;
+}
+
+
+jobjectRefType JNIHandles::handle_type(Thread* thread, jobject handle) {
+ jobjectRefType result = JNIInvalidRefType;
+ if (is_jweak(handle)) {
+ if (is_storage_handle(_weak_global_handles, &jweak_ref(handle))) {
+ result = JNIWeakGlobalRefType;
+ }
+ } else {
+ switch (_global_handles->allocation_status(&jobject_ref(handle))) {
+ case OopStorage::ALLOCATED_ENTRY:
+ result = JNIGlobalRefType;
+ break;
+
+ case OopStorage::UNALLOCATED_ENTRY:
+ break; // Invalid global handle
+
+ case OopStorage::INVALID_ENTRY:
+ // Not in global storage. Might be a local handle.
+ if (is_local_handle(thread, handle) ||
+ (thread->is_Java_thread() &&
+ is_frame_handle((JavaThread*)thread, handle))) {
+ result = JNILocalRefType;
+ }
+ break;
+
+ default:
+ ShouldNotReachHere();
+ }
+ }
+ return result;
}
@@ -210,36 +260,22 @@
bool JNIHandles::is_global_handle(jobject handle) {
- return _global_handles->chain_contains(handle);
+ return !is_jweak(handle) && is_storage_handle(_global_handles, &jobject_ref(handle));
}
bool JNIHandles::is_weak_global_handle(jobject handle) {
- return _weak_global_handles->chain_contains(handle);
-}
-
-long JNIHandles::global_handle_memory_usage() {
- return _global_handles->memory_usage();
-}
-
-long JNIHandles::weak_global_handle_memory_usage() {
- return _weak_global_handles->memory_usage();
+ return is_jweak(handle) && is_storage_handle(_weak_global_handles, &jweak_ref(handle));
}
+size_t JNIHandles::global_handle_memory_usage() {
+ return _global_handles->total_memory_usage();
+}
-class CountHandleClosure: public OopClosure {
-private:
- int _count;
-public:
- CountHandleClosure(): _count(0) {}
- virtual void do_oop(oop* ooph) {
- if (*ooph != JNIHandles::deleted_handle()) {
- _count++;
- }
- }
- virtual void do_oop(narrowOop* unused) { ShouldNotReachHere(); }
- int count() { return _count; }
-};
+size_t JNIHandles::weak_global_handle_memory_usage() {
+ return _weak_global_handles->total_memory_usage();
+}
+
// We assume this is called at a safepoint: no lock is needed.
void JNIHandles::print_on(outputStream* st) {
@@ -247,16 +283,14 @@
assert(_global_handles != NULL && _weak_global_handles != NULL,
"JNIHandles not initialized");
- CountHandleClosure global_handle_count;
- oops_do(&global_handle_count);
- weak_oops_do(&global_handle_count);
-
- st->print_cr("JNI global references: %d", global_handle_count.count());
+ st->print_cr("JNI global refs: " SIZE_FORMAT ", weak refs: " SIZE_FORMAT,
+ _global_handles->allocation_count(),
+ _weak_global_handles->allocation_count());
st->cr();
st->flush();
}
-class VerifyHandleClosure: public OopClosure {
+class VerifyJNIHandles: public OopClosure {
public:
virtual void do_oop(oop* root) {
(*root)->verify();
@@ -265,7 +299,7 @@
};
void JNIHandles::verify() {
- VerifyHandleClosure verify_handle;
+ VerifyJNIHandles verify_handle;
oops_do(&verify_handle);
weak_oops_do(&verify_handle);
@@ -419,34 +453,6 @@
}
-void JNIHandleBlock::weak_oops_do(BoolObjectClosure* is_alive,
- OopClosure* f) {
- for (JNIHandleBlock* current = this; current != NULL; current = current->_next) {
- assert(current->pop_frame_link() == NULL,
- "blocks holding weak global JNI handles should not have pop frame link set");
- for (int index = 0; index < current->_top; index++) {
- oop* root = &(current->_handles)[index];
- oop value = *root;
- // traverse heap pointers only, not deleted handles or free list pointers
- if (value != NULL && Universe::heap()->is_in_reserved(value)) {
- if (is_alive->do_object_b(value)) {
- // The weakly referenced object is alive, update pointer
- f->do_oop(root);
- } else {
- // The weakly referenced object is not alive, clear the reference by storing NULL
- log_develop_trace(gc, ref)("Clearing JNI weak reference (" INTPTR_FORMAT ")", p2i(root));
- *root = NULL;
- }
- }
- }
- // the next handle block is valid only if current block is full
- if (current->_top < block_size_in_oops) {
- break;
- }
- }
-}
-
-
jobject JNIHandleBlock::allocate_handle(oop obj) {
assert(Universe::heap()->is_in_reserved(obj), "sanity check");
if (_top == 0) {
@@ -514,15 +520,6 @@
return allocate_handle(obj); // retry
}
-void JNIHandleBlock::release_handle(jobject h) {
- if (h != NULL) {
- assert(chain_contains(h), "does not contain the JNI handle");
- // Mark the handle as deleted, allocate will reuse it
- *((oop*)h) = JNIHandles::deleted_handle();
- }
-}
-
-
void JNIHandleBlock::rebuild_free_list() {
assert(_allocate_before_rebuild == 0 && _free_list == NULL, "just checking");
int free = 0;
@@ -530,7 +527,7 @@
for (JNIHandleBlock* current = this; current != NULL; current = current->_next) {
for (int index = 0; index < current->_top; index++) {
oop* handle = &(current->_handles)[index];
- if (*handle == JNIHandles::deleted_handle()) {
+ if (*handle == NULL) {
// this handle was cleared out by a delete call, reuse it
*handle = (oop) _free_list;
_free_list = handle;
@@ -568,29 +565,43 @@
}
-int JNIHandleBlock::length() const {
- int result = 1;
+size_t JNIHandleBlock::length() const {
+ size_t result = 1;
for (JNIHandleBlock* current = _next; current != NULL; current = current->_next) {
result++;
}
return result;
}
+class CountJNIHandleClosure: public OopClosure {
+private:
+ int _count;
+public:
+ CountJNIHandleClosure(): _count(0) {}
+ virtual void do_oop(oop* ooph) { _count++; }
+ virtual void do_oop(narrowOop* unused) { ShouldNotReachHere(); }
+ int count() { return _count; }
+};
+
const size_t JNIHandleBlock::get_number_of_live_handles() {
- CountHandleClosure counter;
+ CountJNIHandleClosure counter;
oops_do(&counter);
return counter.count();
}
// This method is not thread-safe, i.e., must be called while holding a lock on the
// structure.
-long JNIHandleBlock::memory_usage() const {
+size_t JNIHandleBlock::memory_usage() const {
return length() * sizeof(JNIHandleBlock);
}
#ifndef PRODUCT
+bool JNIHandles::is_local_handle(jobject handle) {
+ return JNIHandleBlock::any_contains(handle);
+}
+
bool JNIHandleBlock::any_contains(jobject handle) {
for (JNIHandleBlock* current = _block_list; current != NULL; current = current->_block_list_link) {
if (current->contains(handle)) {
--- a/src/hotspot/share/runtime/jniHandles.hpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/runtime/jniHandles.hpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -29,6 +29,7 @@
#include "runtime/handles.hpp"
class JNIHandleBlock;
+class OopStorage;
// Interface for creating and resolving local/global JNI handles
@@ -36,17 +37,15 @@
class JNIHandles : AllStatic {
friend class VMStructs;
private:
- static JNIHandleBlock* _global_handles; // First global handle block
- static JNIHandleBlock* _weak_global_handles; // First weak global handle block
- static oop _deleted_handle; // Sentinel marking deleted handles
+ static OopStorage* _global_handles;
+ static OopStorage* _weak_global_handles;
inline static bool is_jweak(jobject handle);
inline static oop& jobject_ref(jobject handle); // NOT jweak!
inline static oop& jweak_ref(jobject handle);
- template<bool external_guard> inline static oop guard_value(oop value);
template<bool external_guard> inline static oop resolve_impl(jobject handle);
- template<bool external_guard> static oop resolve_jweak(jweak handle);
+ static oop resolve_jweak(jweak handle);
// This method is not inlined in order to avoid circular includes between
// this header file and thread.hpp.
@@ -80,19 +79,14 @@
inline static void destroy_local(jobject handle);
// Global handles
- static jobject make_global(Handle obj);
+ static jobject make_global(Handle obj, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
static void destroy_global(jobject handle);
// Weak global handles
- static jobject make_weak_global(Handle obj);
+ static jobject make_weak_global(Handle obj, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
static void destroy_weak_global(jobject handle);
static bool is_global_weak_cleared(jweak handle); // Test jweak without resolution
- // Sentinel marking deleted handles in block. Note that we cannot store NULL as
- // the sentinel, since clearing weak global JNI refs are done by storing NULL in
- // the handle. The handle may not be reused before destroy_weak_global is called.
- static oop deleted_handle() { return _deleted_handle; }
-
// Initialization
static void initialize();
@@ -104,8 +98,15 @@
static bool is_frame_handle(JavaThread* thr, jobject obj);
static bool is_global_handle(jobject handle);
static bool is_weak_global_handle(jobject handle);
- static long global_handle_memory_usage();
- static long weak_global_handle_memory_usage();
+ static size_t global_handle_memory_usage();
+ static size_t weak_global_handle_memory_usage();
+
+#ifndef PRODUCT
+ // Is handle from any local block of any thread?
+ static bool is_local_handle(jobject handle);
+#endif
+
+ static jobjectRefType handle_type(Thread* thread, jobject handle);
// Garbage collection support(global handles only, local handles are traversed from thread)
// Traversal of regular global handles
@@ -164,9 +165,6 @@
// Handle allocation
jobject allocate_handle(oop obj);
- // Release Handle
- void release_handle(jobject);
-
// Block allocation and block free list management
static JNIHandleBlock* allocate_block(Thread* thread = NULL);
static void release_block(JNIHandleBlock* block, Thread* thread = NULL);
@@ -179,10 +177,8 @@
static int top_offset_in_bytes() { return offset_of(JNIHandleBlock, _top); }
// Garbage collection support
- // Traversal of regular handles
+ // Traversal of handles
void oops_do(OopClosure* f);
- // Traversal of weak handles. Unreachable oops are cleared.
- void weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f);
// Checked JNI support
void set_planned_capacity(size_t planned_capacity) { _planned_capacity = planned_capacity; }
@@ -192,8 +188,8 @@
// Debugging
bool chain_contains(jobject handle) const; // Does this block or following blocks contain handle
bool contains(jobject handle) const; // Does this block contain handle
- int length() const; // Length of chain starting with this block
- long memory_usage() const;
+ size_t length() const; // Length of chain starting with this block
+ size_t memory_usage() const;
#ifndef PRODUCT
static bool any_contains(jobject handle); // Does any block currently in use contain handle
static void print_statistics();
@@ -218,33 +214,18 @@
}
// external_guard is true if called from resolve_external_guard.
-// Treat deleted (and possibly zapped) as NULL for external_guard,
-// else as (asserted) error.
-template<bool external_guard>
-inline oop JNIHandles::guard_value(oop value) {
- if (!external_guard) {
- assert(value != deleted_handle(), "Used a deleted global handle");
- } else if (value == deleted_handle()) {
- value = NULL;
- }
- return value;
-}
-
-// external_guard is true if called from resolve_external_guard.
template<bool external_guard>
inline oop JNIHandles::resolve_impl(jobject handle) {
assert(handle != NULL, "precondition");
assert(!current_thread_in_native(), "must not be in native");
oop result;
if (is_jweak(handle)) { // Unlikely
- result = resolve_jweak<external_guard>(handle);
+ result = resolve_jweak(handle);
} else {
result = jobject_ref(handle);
// Construction of jobjects canonicalize a null value into a null
// jobject, so for non-jweak the pointee should never be null.
- assert(external_guard || result != NULL,
- "Invalid value read from jni handle");
- result = guard_value<external_guard>(result);
+ assert(external_guard || result != NULL, "Invalid JNI handle");
}
return result;
}
@@ -278,7 +259,8 @@
inline void JNIHandles::destroy_local(jobject handle) {
if (handle != NULL) {
- jobject_ref(handle) = deleted_handle();
+ assert(!is_jweak(handle), "Invalid JNI local handle");
+ jobject_ref(handle) = NULL;
}
}
--- a/src/hotspot/share/runtime/mutexLocker.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/runtime/mutexLocker.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -43,7 +43,10 @@
Mutex* CompiledIC_lock = NULL;
Mutex* InlineCacheBuffer_lock = NULL;
Mutex* VMStatistic_lock = NULL;
-Mutex* JNIGlobalHandle_lock = NULL;
+Mutex* JNIGlobalAlloc_lock = NULL;
+Mutex* JNIGlobalActive_lock = NULL;
+Mutex* JNIWeakAlloc_lock = NULL;
+Mutex* JNIWeakActive_lock = NULL;
Mutex* JNIHandleBlockFreeList_lock = NULL;
Mutex* ResolvedMethodTable_lock = NULL;
Mutex* JmethodIdCreation_lock = NULL;
@@ -245,7 +248,10 @@
def(Terminator_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_sometimes);
def(VtableStubs_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_always);
def(Notify_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always);
- def(JNIGlobalHandle_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_always); // locks JNIHandleBlockFreeList_lock
+ def(JNIGlobalAlloc_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_never);
+ def(JNIGlobalActive_lock , PaddedMutex , nonleaf-1, true, Monitor::_safepoint_check_never);
+ def(JNIWeakAlloc_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_never);
+ def(JNIWeakActive_lock , PaddedMutex , nonleaf-1, true, Monitor::_safepoint_check_never);
def(JNICritical_lock , PaddedMonitor, nonleaf, true, Monitor::_safepoint_check_always); // used for JNI critical regions
def(AdapterHandlerLibrary_lock , PaddedMutex , nonleaf, true, Monitor::_safepoint_check_always);
--- a/src/hotspot/share/runtime/mutexLocker.hpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/runtime/mutexLocker.hpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2018, 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
@@ -36,7 +36,10 @@
extern Mutex* CompiledIC_lock; // a lock used to guard compiled IC patching and access
extern Mutex* InlineCacheBuffer_lock; // a lock used to guard the InlineCacheBuffer
extern Mutex* VMStatistic_lock; // a lock used to guard statistics count increment
-extern Mutex* JNIGlobalHandle_lock; // a lock on creating JNI global handles
+extern Mutex* JNIGlobalAlloc_lock; // JNI global storage allocate list lock
+extern Mutex* JNIGlobalActive_lock; // JNI global storage active list lock
+extern Mutex* JNIWeakAlloc_lock; // JNI weak storage allocate list lock
+extern Mutex* JNIWeakActive_lock; // JNI weak storage active list lock
extern Mutex* JNIHandleBlockFreeList_lock; // a lock on the JNI handle block free list
extern Mutex* ResolvedMethodTable_lock; // a lock on the ResolvedMethodTable updates
extern Mutex* JmethodIdCreation_lock; // a lock on creating JNI method identifiers
--- a/src/hotspot/share/runtime/os.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/runtime/os.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2018, 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
@@ -1087,7 +1087,7 @@
}
#ifndef PRODUCT
// we don't keep the block list in product mode
- if (JNIHandleBlock::any_contains((jobject) addr)) {
+ if (JNIHandles::is_local_handle((jobject) addr)) {
st->print_cr(INTPTR_FORMAT " is a local jni handle", p2i(addr));
return;
}
--- a/src/hotspot/share/runtime/vmStructs.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/runtime/vmStructs.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2018, 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
@@ -55,6 +55,7 @@
#include "gc/shared/genCollectedHeap.hpp"
#include "gc/shared/generation.hpp"
#include "gc/shared/generationSpec.hpp"
+#include "gc/shared/oopStorage.hpp"
#include "gc/shared/space.hpp"
#include "interpreter/bytecodeInterpreter.hpp"
#include "interpreter/bytecodes.hpp"
@@ -948,10 +949,8 @@
/*********************************/ \
/* JNIHandles and JNIHandleBlock */ \
/*********************************/ \
- static_field(JNIHandles, _global_handles, JNIHandleBlock*) \
- static_field(JNIHandles, _weak_global_handles, JNIHandleBlock*) \
- static_field(JNIHandles, _deleted_handle, oop) \
- \
+ static_field(JNIHandles, _global_handles, OopStorage*) \
+ static_field(JNIHandles, _weak_global_handles, OopStorage*) \
unchecked_nonstatic_field(JNIHandleBlock, _handles, JNIHandleBlock::block_size_in_oops * sizeof(Oop)) /* Note: no type */ \
nonstatic_field(JNIHandleBlock, _top, int) \
nonstatic_field(JNIHandleBlock, _next, JNIHandleBlock*) \
@@ -1677,6 +1676,12 @@
declare_toplevel_type(JNIHandleBlock) \
declare_toplevel_type(jobject) \
\
+ /**************/ \
+ /* OopStorage */ \
+ /**************/ \
+ \
+ declare_toplevel_type(OopStorage) \
+ \
/**********************/ \
/* Runtime1 (C1 only) */ \
/**********************/ \
--- a/src/hotspot/share/runtime/vm_operations.hpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/runtime/vm_operations.hpp Tue Nov 21 09:47:55 2017 -0500
@@ -115,6 +115,7 @@
template(ICBufferFull) \
template(ScavengeMonitors) \
template(PrintMetadata) \
+ template(GTestExecuteAtSafepoint) \
class VM_Operation: public CHeapObj<mtInternal> {
public:
@@ -286,6 +287,17 @@
bool is_cheap_allocated() const { return true; }
};
+// Base class for invoking parts of a gtest in a safepoint.
+// Derived classes provide the doit method.
+// Typically also need to transition the gtest thread from native to VM.
+class VM_GTestExecuteAtSafepoint: public VM_Operation {
+ public:
+ VMOp_Type type() const { return VMOp_GTestExecuteAtSafepoint; }
+
+ protected:
+ VM_GTestExecuteAtSafepoint() {}
+};
+
class VM_Deoptimize: public VM_Operation {
public:
VM_Deoptimize() {}
--- a/src/hotspot/share/services/heapDumper.cpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/services/heapDumper.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2018, 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
@@ -1317,9 +1317,9 @@
void JNILocalsDumper::do_oop(oop* obj_p) {
- // ignore null or deleted handles
+ // ignore null handles
oop o = *obj_p;
- if (o != NULL && o != JNIHandles::deleted_handle()) {
+ if (o != NULL) {
writer()->write_u1(HPROF_GC_ROOT_JNI_LOCAL);
writer()->write_objectID(o);
writer()->write_u4(_thread_serial_num);
@@ -1347,7 +1347,7 @@
oop o = *obj_p;
// ignore these
- if (o == NULL || o == JNIHandles::deleted_handle()) return;
+ if (o == NULL) return;
// we ignore global ref to symbols and other internal objects
if (o->is_instance() || o->is_objArray() || o->is_typeArray()) {
@@ -1422,9 +1422,6 @@
};
void HeapObjectDumper::do_object(oop o) {
- // hide the sentinel for deleted handles
- if (o == JNIHandles::deleted_handle()) return;
-
// skip classes as these emitted as HPROF_GC_CLASS_DUMP records
if (o->klass() == SystemDictionary::Class_klass()) {
if (!java_lang_Class::is_primitive(o)) {
--- a/src/hotspot/share/services/serviceUtil.hpp Sat Jan 13 02:56:22 2018 +0100
+++ b/src/hotspot/share/services/serviceUtil.hpp Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2018, 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
@@ -39,11 +39,6 @@
// Return true if oop represents an object that is "visible"
// to the java world.
static inline bool visible_oop(oop o) {
- // the sentinel for deleted handles isn't visible
- if (o == JNIHandles::deleted_handle()) {
- return false;
- }
-
// instance
if (o->is_instance()) {
// instance objects are visible
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/shared/OopStorage.java Tue Nov 21 09:47:55 2017 -0500
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018, 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.
+ *
+ */
+
+package sun.jvm.hotspot.gc.shared;
+
+import java.util.*;
+import sun.jvm.hotspot.debugger.*;
+import sun.jvm.hotspot.runtime.*;
+import sun.jvm.hotspot.types.*;
+import sun.jvm.hotspot.utilities.*;
+
+public class OopStorage extends VMObject {
+
+ static {
+ VM.registerVMInitializedObserver(new Observer() {
+ public void update(Observable o, Object data) {
+ initialize(VM.getVM().getTypeDataBase());
+ }
+ });
+ }
+
+ private static synchronized void initialize(TypeDataBase db) {
+ Type type = db.lookupType("OopStorage");
+ }
+
+ public OopStorage(Address addr) {
+ super(addr);
+ }
+
+ public boolean findOop(Address handle) {
+ // TODO: walk OopStorage to find the Oop
+ return false;
+ }
+
+ public void oopsDo(AddressVisitor visitor) {
+ // TODO: Visit handles in OopStorage
+ }
+}
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/JNIHandleBlock.java Sat Jan 13 02:56:22 2018 +0100
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/JNIHandleBlock.java Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2001, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2018, 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
@@ -103,7 +103,7 @@
/** Debugging routine only. Returns non-null JNIHandleBlock
containing the JNI handle or null if this handle block and its
- successors did not contain it (or if the handle was deleted). */
+ successors did not contain it. */
public JNIHandleBlock blockContainingHandle(Address jniHandle) {
JNIHandleBlock cur = this;
while (cur != null) {
@@ -144,8 +144,8 @@
Address oopAddr = addr.addOffsetTo(handlesField.getOffset() + x * VM.getVM().getOopSize());
OopHandle handle = oopAddr.getOopHandleAt(0);
- if (VM.getVM().getUniverse().isInReserved(handle) && !VM.getVM().getJNIHandles().isDeletedHandle(handle)) {
- /* the oop handle is valid only if it is not freed (i.e. reserved in heap) and is not a deleted oop */
+ if (VM.getVM().getUniverse().isInReserved(handle)) {
+ /* the oop handle is valid only if it is not freed (i.e. reserved in heap) */
return oopAddr;
} else {
return null;
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/JNIHandles.java Sat Jan 13 02:56:22 2018 +0100
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/JNIHandles.java Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,11 +27,11 @@
import java.util.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.types.*;
+import sun.jvm.hotspot.gc.shared.OopStorage;
public class JNIHandles {
private static AddressField globalHandlesField;
private static AddressField weakGlobalHandlesField;
- private static OopField deletedHandleField;
static {
VM.registerVMInitializedObserver(new Observer() {
@@ -46,35 +46,26 @@
globalHandlesField = type.getAddressField("_global_handles");
weakGlobalHandlesField = type.getAddressField("_weak_global_handles");
- deletedHandleField = type.getOopField("_deleted_handle");
}
public JNIHandles() {
}
- public JNIHandleBlock globalHandles() {
+ public OopStorage globalHandles() {
Address handleAddr = globalHandlesField.getValue();
if (handleAddr == null) {
return null;
}
- return new JNIHandleBlock(handleAddr);
+ return new OopStorage(handleAddr);
}
- public JNIHandleBlock weakGlobalHandles() {
+ public OopStorage weakGlobalHandles() {
Address handleAddr = weakGlobalHandlesField.getValue();
if (handleAddr == null) {
return null;
}
- return new JNIHandleBlock(handleAddr);
- }
-
- public OopHandle deletedHandle() {
- return deletedHandleField.getValue();
- }
-
- public boolean isDeletedHandle(OopHandle handle) {
- return (handle != null && handle.equals(deletedHandle()));
+ return new OopStorage(handleAddr);
}
}
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java Sat Jan 13 02:56:22 2018 +0100
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2004, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2004, 2018, 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
@@ -26,6 +26,7 @@
import java.io.*;
import sun.jvm.hotspot.debugger.*;
+import sun.jvm.hotspot.gc.shared.OopStorage;
import sun.jvm.hotspot.memory.*;
import sun.jvm.hotspot.oops.*;
import sun.jvm.hotspot.runtime.*;
@@ -147,7 +148,7 @@
protected void writeGlobalJNIHandles() throws IOException {
JNIHandles handles = VM.getVM().getJNIHandles();
- JNIHandleBlock blk = handles.globalHandles();
+ OopStorage blk = handles.globalHandles();
if (blk != null) {
try {
blk.oopsDo(new AddressVisitor() {
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/PointerFinder.java Sat Jan 13 02:56:22 2018 +0100
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/PointerFinder.java Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2018, 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
@@ -108,41 +108,36 @@
// Check JNIHandles; both local and global
JNIHandles handles = VM.getVM().getJNIHandles();
- JNIHandleBlock handleBlock = handles.globalHandles();
- if (handleBlock != null) {
- handleBlock = handleBlock.blockContainingHandle(a);
+
+ // --- looking in oopstorage should model OopStorage::allocation_status?
+ // --- that is, if in a block but not allocated, then not valid.
+
+ // Look in global handles
+ OopStorage storage = handles.globalHandles();
+ if ((storage != null) && storage.findOop(a)) {
+ loc.inStrongGlobalJNIHandles = true;
+ return loc;
}
- if (handleBlock != null) {
- loc.inStrongGlobalJNIHandleBlock = true;
- loc.handleBlock = handleBlock;
+ // Look in weak global handles
+ storage = handles.weakGlobalHandles();
+ if ((storage != null) && storage.findOop(a)) {
+ loc.inWeakGlobalJNIHandles = true;
return loc;
- } else {
- handleBlock = handles.weakGlobalHandles();
+ }
+ // Look in thread-local handles
+ for (JavaThread t = VM.getVM().getThreads().first(); t != null; t = t.next()) {
+ JNIHandleBlock handleBlock = t.activeHandles();
if (handleBlock != null) {
handleBlock = handleBlock.blockContainingHandle(a);
if (handleBlock != null) {
- loc.inWeakGlobalJNIHandleBlock = true;
+ loc.inLocalJNIHandleBlock = true;
loc.handleBlock = handleBlock;
+ loc.handleThread = t;
return loc;
- } else {
- // Look in thread-local handles
- for (JavaThread t = VM.getVM().getThreads().first(); t != null; t = t.next()) {
- handleBlock = t.activeHandles();
- if (handleBlock != null) {
- handleBlock = handleBlock.blockContainingHandle(a);
- if (handleBlock != null) {
- loc.inLocalJNIHandleBlock = true;
- loc.handleBlock = handleBlock;
- loc.handleThread = t;
- return loc;
- }
- }
- }
}
}
}
-
// Fall through; have to return it anyway.
return loc;
}
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/PointerLocation.java Sat Jan 13 02:56:22 2018 +0100
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/PointerLocation.java Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2018, 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
@@ -69,8 +69,9 @@
boolean inBlobOops;
boolean inBlobUnknownLocation;
- boolean inStrongGlobalJNIHandleBlock;
- boolean inWeakGlobalJNIHandleBlock;
+ boolean inStrongGlobalJNIHandles;
+ boolean inWeakGlobalJNIHandles;
+
boolean inLocalJNIHandleBlock;
JNIHandleBlock handleBlock;
sun.jvm.hotspot.runtime.Thread handleThread;
@@ -149,32 +150,33 @@
return inBlobUnknownLocation;
}
- public boolean isInStrongGlobalJNIHandleBlock() {
- return inStrongGlobalJNIHandleBlock;
+ public boolean isInStrongGlobalJNIHandles() {
+ return inStrongGlobalJNIHandles;
}
- public boolean isInWeakGlobalJNIHandleBlock() {
- return inWeakGlobalJNIHandleBlock;
+ public boolean isInWeakGlobalJNIHandles() {
+ return inWeakGlobalJNIHandles;
}
public boolean isInLocalJNIHandleBlock() {
return inLocalJNIHandleBlock;
}
- /** Only valid if isInStrongGlobalJNIHandleBlock,
- isInWeakGlobalJNIHandleBlock, or isInLocalJNIHandleBlock is true */
+ /** Only valid if isInLocalJNIHandleBlock is true */
public JNIHandleBlock getJNIHandleBlock() {
+ assert isInLocalJNIHandleBlock();
return handleBlock;
}
/** Only valid if isInLocalJNIHandleBlock is true */
public sun.jvm.hotspot.runtime.Thread getJNIHandleThread() {
+ assert isInLocalJNIHandleBlock();
return handleThread;
}
public boolean isUnknown() {
return (!(isInHeap() || isInInterpreter() || isInCodeCache() ||
- isInStrongGlobalJNIHandleBlock() || isInWeakGlobalJNIHandleBlock() || isInLocalJNIHandleBlock()));
+ isInStrongGlobalJNIHandles() || isInWeakGlobalJNIHandles() || isInLocalJNIHandleBlock()));
}
public String toString() {
@@ -236,25 +238,18 @@
b.printOn(tty);
// FIXME: add more detail
- } else if (isInStrongGlobalJNIHandleBlock() ||
- isInWeakGlobalJNIHandleBlock() ||
- isInLocalJNIHandleBlock()) {
- tty.print("In ");
- if (isInStrongGlobalJNIHandleBlock()) {
- tty.print("strong global");
- } else if (isInWeakGlobalJNIHandleBlock()) {
- tty.print("weak global");
+ } else if (isInStrongGlobalJNIHandles()) {
+ tty.print("In JNI strong global");
+ } else if (isInWeakGlobalJNIHandles()) {
+ tty.print("In JNI weak global");
+ } else if (isInLocalJNIHandleBlock()) {
+ tty.print("In thread-local");
+ tty.print(" JNI handle block (" + handleBlock.top() + " handle slots present)");
+ if (handleThread.isJavaThread()) {
+ tty.print(" for JavaThread ");
+ ((JavaThread) handleThread).printThreadIDOn(tty);
} else {
- tty.print("thread-local");
- }
- tty.print(" JNI handle block (" + handleBlock.top() + " handle slots present)");
- if (isInLocalJNIHandleBlock()) {
- if (handleThread.isJavaThread()) {
- tty.print(" for JavaThread ");
- ((JavaThread) handleThread).printThreadIDOn(tty);
- } else {
- tty.print("for a non-Java Thread");
- }
+ tty.print(" for a non-Java Thread");
}
} else {
// This must be last
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/ReversePtrsAnalysis.java Sat Jan 13 02:56:22 2018 +0100
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/ReversePtrsAnalysis.java Tue Nov 21 09:47:55 2017 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2018, 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
@@ -108,10 +108,10 @@
// Do global JNI handles
JNIHandles handles = VM.getVM().getJNIHandles();
- doJNIHandleBlock(handles.globalHandles(),
- new RootVisitor("Global JNI handle root"));
- doJNIHandleBlock(handles.weakGlobalHandles(),
- new RootVisitor("Weak global JNI handle root"));
+ doOopStorage(handles.globalHandles(),
+ new RootVisitor("Global JNI handle root"));
+ doOopStorage(handles.weakGlobalHandles(),
+ new RootVisitor("Weak global JNI handle root"));
// Do Java-level static fields
ClassLoaderDataGraph cldg = VM.getVM().getClassLoaderDataGraph();
@@ -306,4 +306,9 @@
private void doJNIHandleBlock(JNIHandleBlock handles, AddressVisitor oopVisitor) {
handles.oopsDo(oopVisitor);
}
+
+ // Traverse jobjects in global JNIHandles
+ private void doOopStorage(OopStorage oopSet, AddressVisitor oopVisitor) {
+ oopSet.oopsDo(oopVisitor);
+ }
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/hotspot/gtest/gc/shared/test_oopStorage.cpp Tue Nov 21 09:47:55 2017 -0500
@@ -0,0 +1,1381 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "gc/shared/oopStorage.hpp"
+#include "gc/shared/workgroup.hpp"
+#include "memory/allocation.inline.hpp"
+#include "memory/resourceArea.hpp"
+#include "metaprogramming/conditional.hpp"
+#include "metaprogramming/enableIf.hpp"
+#include "runtime/handles.inline.hpp"
+#include "runtime/interfaceSupport.hpp"
+#include "runtime/mutex.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "runtime/thread.hpp"
+#include "runtime/vm_operations.hpp"
+#include "runtime/vmThread.hpp"
+#include "utilities/align.hpp"
+#include "utilities/ostream.hpp"
+#include "utilities/quickSort.hpp"
+#include "unittest.hpp"
+
+// --- FIXME: Disable some tests on 32bit Windows, because SafeFetch
+// (which is used by allocation_status) doesn't currently provide
+// protection in the context where gtests are run; see JDK-8185734.
+#ifdef _WIN32
+#define DISABLE_GARBAGE_ALLOCATION_STATUS_TESTS
+#endif
+
+// Access storage internals.
+class OopStorage::TestAccess : public AllStatic {
+public:
+ typedef OopStorage::Block Block;
+ typedef OopStorage::BlockList BlockList;
+
+ static BlockList& active_list(OopStorage& storage) {
+ return storage._active_list;
+ }
+
+ static BlockList& allocate_list(OopStorage& storage) {
+ return storage._allocate_list;
+ }
+
+ static const BlockList& allocate_list(const OopStorage& storage) {
+ return storage._allocate_list;
+ }
+
+ static Mutex* allocate_mutex(const OopStorage& storage) {
+ return storage._allocate_mutex;
+ }
+
+ static bool block_is_empty(const Block& block) {
+ return block.is_empty();
+ }
+
+ static bool block_is_full(const Block& block) {
+ return block.is_full();
+ }
+
+ static unsigned block_allocation_count(const Block& block) {
+ uintx bitmask = block.allocated_bitmask();
+ unsigned count = 0;
+ for ( ; bitmask != 0; bitmask >>= 1) {
+ if ((bitmask & 1) != 0) {
+ ++count;
+ }
+ }
+ return count;
+ }
+
+ static size_t memory_per_block() {
+ return Block::allocation_size();
+ }
+};
+
+typedef OopStorage::TestAccess TestAccess;
+// --- FIXME: Should be just Block, but that collides with opto Block
+// when building with precompiled headers. There really should be
+// an opto namespace.
+typedef TestAccess::Block OopBlock;
+// --- FIXME: Similarly, this typedef collides with opto BlockList.
+// typedef TestAccess::BlockList BlockList;
+
+static size_t list_length(const TestAccess::BlockList& list) {
+ size_t result = 0;
+ for (const OopBlock* block = list.chead();
+ block != NULL;
+ block = list.next(*block)) {
+ ++result;
+ }
+ return result;
+}
+
+static void clear_list(TestAccess::BlockList& list) {
+ OopBlock* next;
+ for (OopBlock* block = list.head(); block != NULL; block = next) {
+ next = list.next(*block);
+ list.unlink(*block);
+ }
+}
+
+static bool is_list_empty(const TestAccess::BlockList& list) {
+ return list.chead() == NULL;
+}
+
+static void release_entry(OopStorage& storage, oop* entry) {
+ *entry = NULL;
+ storage.release(entry);
+}
+
+class OopStorageTest : public ::testing::Test {
+public:
+ OopStorageTest();
+ ~OopStorageTest();
+
+ Mutex _allocate_mutex;
+ Mutex _active_mutex;
+ OopStorage _storage;
+
+ static const int _active_rank = Mutex::leaf - 1;
+ static const int _allocate_rank = Mutex::leaf;
+
+ class CountingIterateClosure;
+ template<bool is_const> class VM_CountAtSafepoint;
+};
+
+OopStorageTest::OopStorageTest() :
+ _allocate_mutex(_allocate_rank,
+ "test_OopStorage_allocate",
+ false,
+ Mutex::_safepoint_check_never),
+ _active_mutex(_active_rank,
+ "test_OopStorage_active",
+ false,
+ Mutex::_safepoint_check_never),
+ _storage("Test Storage", &_allocate_mutex, &_active_mutex)
+{ }
+
+OopStorageTest::~OopStorageTest() {
+ clear_list(TestAccess::allocate_list(_storage));
+ clear_list(TestAccess::active_list(_storage));
+}
+
+class OopStorageTestWithAllocation : public OopStorageTest {
+public:
+ OopStorageTestWithAllocation();
+
+ static const size_t _max_entries = 1000;
+ oop* _entries[_max_entries];
+
+ class VM_DeleteBlocksAtSafepoint;
+};
+
+OopStorageTestWithAllocation::OopStorageTestWithAllocation() {
+ for (size_t i = 0; i < _max_entries; ++i) {
+ _entries[i] = _storage.allocate();
+ EXPECT_TRUE(_entries[i] != NULL);
+ EXPECT_EQ(i + 1, _storage.allocation_count());
+ }
+};
+
+const size_t OopStorageTestWithAllocation::_max_entries;
+
+class OopStorageTestWithAllocation::VM_DeleteBlocksAtSafepoint
+ : public VM_GTestExecuteAtSafepoint {
+public:
+ VM_DeleteBlocksAtSafepoint(OopStorage* storage, size_t retain) :
+ _storage(storage), _retain(retain)
+ {}
+
+ void doit() {
+ _storage->delete_empty_blocks_safepoint(_retain);
+ }
+
+private:
+ OopStorage* _storage;
+ size_t _retain;
+};
+
+static bool is_allocate_list_sorted(const OopStorage& storage) {
+ // The allocate_list isn't strictly sorted. Rather, all empty
+ // blocks are segregated to the end of the list. And the number of
+ // empty blocks should match empty_block_count().
+ size_t expected_empty = storage.empty_block_count();
+ const TestAccess::BlockList& list = TestAccess::allocate_list(storage);
+ const OopBlock* block = list.ctail();
+ for (size_t i = 0; i < expected_empty; ++i, block = list.prev(*block)) {
+ if ((block == NULL) || !block->is_empty()) {
+ return false;
+ }
+ }
+ for ( ; block != NULL; block = list.prev(*block)) {
+ if (block->is_empty()) {
+ return false;
+ }
+ }
+ return true;
+}
+
+static size_t total_allocation_count(const TestAccess::BlockList& list) {
+ size_t total_count = 0;
+ for (const OopBlock* block = list.chead();
+ block != NULL;
+ block = list.next(*block)) {
+ total_count += TestAccess::block_allocation_count(*block);
+ }
+ return total_count;
+}
+
+TEST_VM_F(OopStorageTest, allocate_one) {
+ EXPECT_TRUE(is_list_empty(TestAccess::active_list(_storage)));
+ EXPECT_TRUE(is_list_empty(TestAccess::allocate_list(_storage)));
+
+ oop* ptr = _storage.allocate();
+ EXPECT_TRUE(ptr != NULL);
+ EXPECT_EQ(1u, _storage.allocation_count());
+
+ EXPECT_EQ(1u, list_length(TestAccess::active_list(_storage)));
+ EXPECT_EQ(1u, _storage.block_count());
+ EXPECT_EQ(1u, list_length(TestAccess::allocate_list(_storage)));
+
+ EXPECT_EQ(0u, _storage.empty_block_count());
+
+ const OopBlock* block = TestAccess::allocate_list(_storage).chead();
+ EXPECT_NE(block, (OopBlock*)NULL);
+ EXPECT_EQ(block, (TestAccess::active_list(_storage).chead()));
+ EXPECT_FALSE(TestAccess::block_is_empty(*block));
+ EXPECT_FALSE(TestAccess::block_is_full(*block));
+ EXPECT_EQ(1u, TestAccess::block_allocation_count(*block));
+
+ release_entry(_storage, ptr);
+ EXPECT_EQ(0u, _storage.allocation_count());
+
+ EXPECT_EQ(1u, list_length(TestAccess::active_list(_storage)));
+ EXPECT_EQ(1u, _storage.block_count());
+ EXPECT_EQ(1u, list_length(TestAccess::allocate_list(_storage)));
+
+ EXPECT_EQ(1u, _storage.empty_block_count());
+
+ const OopBlock* new_block = TestAccess::allocate_list(_storage).chead();
+ EXPECT_EQ(block, new_block);
+ EXPECT_EQ(block, (TestAccess::active_list(_storage).chead()));
+ EXPECT_TRUE(TestAccess::block_is_empty(*block));
+ EXPECT_FALSE(TestAccess::block_is_full(*block));
+ EXPECT_EQ(0u, TestAccess::block_allocation_count(*block));
+}
+
+TEST_VM_F(OopStorageTest, allocation_count) {
+ static const size_t max_entries = 1000;
+ oop* entries[max_entries];
+
+ TestAccess::BlockList& active_list = TestAccess::active_list(_storage);
+ TestAccess::BlockList& allocate_list = TestAccess::allocate_list(_storage);
+
+ EXPECT_TRUE(is_list_empty(active_list));
+ EXPECT_EQ(0u, _storage.block_count());
+ EXPECT_TRUE(is_list_empty(allocate_list));
+
+ size_t allocated = 0;
+ for ( ; allocated < max_entries; ++allocated) {
+ EXPECT_EQ(allocated, _storage.allocation_count());
+ if (!is_list_empty(active_list)) {
+ EXPECT_EQ(1u, list_length(active_list));
+ EXPECT_EQ(1u, _storage.block_count());
+ const OopBlock& block = *active_list.chead();
+ EXPECT_EQ(allocated, TestAccess::block_allocation_count(block));
+ if (TestAccess::block_is_full(block)) {
+ break;
+ } else {
+ EXPECT_FALSE(is_list_empty(allocate_list));
+ EXPECT_EQ(&block, allocate_list.chead());
+ }
+ }
+ entries[allocated] = _storage.allocate();
+ }
+
+ EXPECT_EQ(allocated, _storage.allocation_count());
+ EXPECT_EQ(1u, list_length(active_list));
+ EXPECT_EQ(1u, _storage.block_count());
+ EXPECT_TRUE(is_list_empty(allocate_list));
+ const OopBlock& block = *active_list.chead();
+ EXPECT_TRUE(TestAccess::block_is_full(block));
+ EXPECT_EQ(allocated, TestAccess::block_allocation_count(block));
+
+ for (size_t i = 0; i < allocated; ++i) {
+ release_entry(_storage, entries[i]);
+ size_t remaining = allocated - (i + 1);
+ EXPECT_EQ(remaining, TestAccess::block_allocation_count(block));
+ EXPECT_EQ(remaining, _storage.allocation_count());
+ EXPECT_FALSE(is_list_empty(allocate_list));
+ }
+}
+
+TEST_VM_F(OopStorageTest, allocate_many) {
+ static const size_t max_entries = 1000;
+ oop* entries[max_entries];
+
+ TestAccess::BlockList& active_list = TestAccess::active_list(_storage);
+ TestAccess::BlockList& allocate_list = TestAccess::allocate_list(_storage);
+
+ EXPECT_EQ(0u, _storage.empty_block_count());
+
+ entries[0] = _storage.allocate();
+ ASSERT_TRUE(entries[0] != NULL);
+ EXPECT_EQ(1u, list_length(active_list));
+ EXPECT_EQ(1u, _storage.block_count());
+ EXPECT_EQ(1u, list_length(allocate_list));
+ EXPECT_EQ(0u, _storage.empty_block_count());
+
+ const OopBlock* block = active_list.chead();
+ EXPECT_EQ(1u, TestAccess::block_allocation_count(*block));
+ EXPECT_EQ(block, allocate_list.chead());
+
+ for (size_t i = 1; i < max_entries; ++i) {
+ entries[i] = _storage.allocate();
+ EXPECT_EQ(i + 1, _storage.allocation_count());
+ ASSERT_TRUE(entries[i] != NULL);
+ EXPECT_EQ(0u, _storage.empty_block_count());
+
+ if (block == NULL) {
+ ASSERT_FALSE(is_list_empty(allocate_list));
+ EXPECT_EQ(1u, list_length(allocate_list));
+ block = allocate_list.chead();
+ EXPECT_EQ(1u, TestAccess::block_allocation_count(*block));
+ EXPECT_EQ(block, active_list.chead());
+ } else if (TestAccess::block_is_full(*block)) {
+ EXPECT_TRUE(is_list_empty(allocate_list));
+ block = NULL;
+ } else {
+ EXPECT_FALSE(is_list_empty(allocate_list));
+ EXPECT_EQ(block, allocate_list.chead());
+ EXPECT_EQ(block, active_list.chead());
+ }
+ }
+
+ if (block != NULL) {
+ EXPECT_NE(0u, TestAccess::block_allocation_count(*block));
+ EXPECT_FALSE(is_list_empty(allocate_list));
+ EXPECT_EQ(block, allocate_list.chead());
+ EXPECT_EQ(block, active_list.chead());
+ }
+
+ size_t active_count = list_length(active_list);
+
+ for (size_t i = 0; i < max_entries; ++i) {
+ release_entry(_storage, entries[i]);
+ EXPECT_TRUE(is_allocate_list_sorted(_storage));
+ EXPECT_EQ(max_entries - (i + 1), total_allocation_count(active_list));
+ }
+
+ EXPECT_EQ(list_length(active_list), list_length(allocate_list));
+ EXPECT_EQ(list_length(active_list), _storage.block_count());
+ EXPECT_EQ(list_length(active_list), _storage.empty_block_count());
+ for (const OopBlock* block = allocate_list.chead();
+ block != NULL;
+ block = allocate_list.next(*block)) {
+ EXPECT_TRUE(TestAccess::block_is_empty(*block));
+ }
+}
+
+TEST_VM_F(OopStorageTestWithAllocation, random_release) {
+ static const size_t step = 11;
+ ASSERT_NE(0u, _max_entries % step); // max_entries and step are mutually prime
+
+ EXPECT_EQ(0u, _storage.empty_block_count());
+
+ TestAccess::BlockList& active_list = TestAccess::active_list(_storage);
+ TestAccess::BlockList& allocate_list = TestAccess::allocate_list(_storage);
+
+ EXPECT_EQ(_max_entries, total_allocation_count(active_list));
+ EXPECT_GE(1u, list_length(allocate_list));
+
+ // Release all entries in "random" order.
+ size_t released = 0;
+ for (size_t i = 0; released < _max_entries; i = (i + step) % _max_entries) {
+ if (_entries[i] != NULL) {
+ release_entry(_storage, _entries[i]);
+ _entries[i] = NULL;
+ ++released;
+ EXPECT_EQ(_max_entries - released, total_allocation_count(active_list));
+ EXPECT_TRUE(is_allocate_list_sorted(_storage));
+ }
+ }
+
+ EXPECT_EQ(list_length(active_list), list_length(allocate_list));
+ EXPECT_EQ(list_length(active_list), _storage.block_count());
+ EXPECT_EQ(0u, total_allocation_count(active_list));
+ EXPECT_EQ(list_length(allocate_list), _storage.empty_block_count());
+}
+
+TEST_VM_F(OopStorageTestWithAllocation, random_allocate_release) {
+ static const size_t release_step = 11;
+ static const size_t allocate_step = 5;
+ ASSERT_NE(0u, _max_entries % release_step); // max_entries and step are mutually prime
+
+ EXPECT_EQ(0u, _storage.empty_block_count());
+
+ TestAccess::BlockList& active_list = TestAccess::active_list(_storage);
+ TestAccess::BlockList& allocate_list = TestAccess::allocate_list(_storage);
+
+ EXPECT_EQ(_max_entries, total_allocation_count(active_list));
+ EXPECT_GE(1u, list_length(allocate_list));
+
+ // Release all entries in "random" order, "randomly" interspersed
+ // with additional allocations.
+ size_t released = 0;
+ size_t total_released = 0;
+ for (size_t i = 0; released < _max_entries; i = (i + release_step) % _max_entries) {
+ if (_entries[i] != NULL) {
+ release_entry(_storage, _entries[i]);
+ _entries[i] = NULL;
+ ++released;
+ ++total_released;
+ EXPECT_EQ(_max_entries - released, total_allocation_count(active_list));
+ EXPECT_TRUE(is_allocate_list_sorted(_storage));
+ if (total_released % allocate_step == 0) {
+ _entries[i] = _storage.allocate();
+ --released;
+ EXPECT_EQ(_max_entries - released, total_allocation_count(active_list));
+ EXPECT_TRUE(is_allocate_list_sorted(_storage));
+ }
+ }
+ }
+
+ EXPECT_EQ(list_length(active_list), list_length(allocate_list));
+ EXPECT_EQ(list_length(active_list), _storage.block_count());
+ EXPECT_EQ(0u, total_allocation_count(active_list));
+ EXPECT_EQ(list_length(allocate_list), _storage.empty_block_count());
+}
+
+template<bool sorted>
+class OopStorageTestBlockRelease : public OopStorageTestWithAllocation {
+public:
+ void SetUp() {
+ size_t nrelease = _max_entries / 2;
+ oop** to_release = NEW_C_HEAP_ARRAY(oop*, nrelease, mtInternal);
+
+ for (size_t i = 0; i < nrelease; ++i) {
+ to_release[i] = _entries[2 * i];
+ *to_release[i] = NULL;
+ }
+ if (sorted) {
+ QuickSort::sort(to_release, nrelease, PointerCompare(), false);
+ }
+
+ _storage.release(to_release, nrelease);
+ EXPECT_EQ(_max_entries - nrelease, _storage.allocation_count());
+
+ for (size_t i = 0; i < nrelease; ++i) {
+ release_entry(_storage, _entries[2 * i + 1]);
+ EXPECT_EQ(_max_entries - nrelease - (i + 1), _storage.allocation_count());
+ }
+
+ EXPECT_EQ(_storage.block_count(), _storage.empty_block_count());
+
+ FREE_C_HEAP_ARRAY(oop*, to_release);
+ }
+
+ struct PointerCompare {
+ int operator()(const void* p, const void* q) const {
+ return (p < q) ? -1 : int(p != q);
+ }
+ };
+};
+
+typedef OopStorageTestBlockRelease<true> OopStorageTestBlockReleaseSorted;
+typedef OopStorageTestBlockRelease<false> OopStorageTestBlockReleaseUnsorted;
+
+TEST_VM_F(OopStorageTestBlockReleaseSorted, block_release) {}
+TEST_VM_F(OopStorageTestBlockReleaseUnsorted, block_release) {}
+
+#ifndef DISABLE_GARBAGE_ALLOCATION_STATUS_TESTS
+TEST_VM_F(OopStorageTest, invalid_pointer) {
+ {
+ char* mem = NEW_C_HEAP_ARRAY(char, 1000, mtInternal);
+ oop* ptr = reinterpret_cast<oop*>(align_down(mem + 250, sizeof(oop)));
+ // Predicate returns false for some malloc'ed block.
+ EXPECT_EQ(OopStorage::INVALID_ENTRY, _storage.allocation_status(ptr));
+ FREE_C_HEAP_ARRAY(char, mem);
+ }
+
+ {
+ oop obj;
+ oop* ptr = &obj;
+ // Predicate returns false for some "random" location.
+ EXPECT_EQ(OopStorage::INVALID_ENTRY, _storage.allocation_status(ptr));
+ }
+}
+#endif // DISABLE_GARBAGE_ALLOCATION_STATUS_TESTS
+
+class OopStorageTest::CountingIterateClosure VALUE_OBJ_CLASS_SPEC {
+public:
+ size_t _const_count;
+ size_t _const_non_null;
+ size_t _non_const_count;
+ size_t _non_const_non_null;
+
+ void do_oop(const oop* ptr) {
+ ++_const_count;
+ if (*ptr != NULL) {
+ ++_const_non_null;
+ }
+ }
+
+ void do_oop(oop* ptr) {
+ ++_non_const_count;
+ if (*ptr != NULL) {
+ ++_non_const_non_null;
+ }
+ }
+
+ CountingIterateClosure() :
+ _const_count(0),
+ _const_non_null(0),
+ _non_const_count(0),
+ _non_const_non_null(0)
+ {}
+};
+
+template<bool is_const>
+class OopStorageTest::VM_CountAtSafepoint : public VM_GTestExecuteAtSafepoint {
+public:
+ typedef typename Conditional<is_const,
+ const OopStorage,
+ OopStorage>::type Storage;
+
+ VM_CountAtSafepoint(Storage* storage, CountingIterateClosure* cl) :
+ _storage(storage), _cl(cl)
+ {}
+
+ void doit() { _storage->oops_do(_cl); }
+
+private:
+ Storage* _storage;
+ CountingIterateClosure* _cl;
+};
+
+TEST_VM_F(OopStorageTest, simple_iterate) {
+ // Dummy oop value.
+ intptr_t dummy_oop_value = 0xbadbeaf;
+ oop dummy_oop = reinterpret_cast<oopDesc*>(&dummy_oop_value);
+
+ const size_t max_entries = 1000;
+ oop* entries[max_entries];
+
+ size_t allocated = 0;
+ size_t entries_with_values = 0;
+ for (size_t i = 0; i < max_entries; i += 10) {
+ for ( ; allocated < i; ++allocated) {
+ entries[allocated] = _storage.allocate();
+ ASSERT_TRUE(entries[allocated] != NULL);
+ if ((allocated % 3) != 0) {
+ *entries[allocated] = dummy_oop;
+ ++entries_with_values;
+ }
+ }
+
+ {
+ CountingIterateClosure cl;
+ VM_CountAtSafepoint<false> op(&_storage, &cl);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ EXPECT_EQ(allocated, cl._non_const_count);
+ EXPECT_EQ(entries_with_values, cl._non_const_non_null);
+ EXPECT_EQ(0u, cl._const_count);
+ EXPECT_EQ(0u, cl._const_non_null);
+ }
+
+ {
+ CountingIterateClosure cl;
+ VM_CountAtSafepoint<true> op(&_storage, &cl);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ EXPECT_EQ(allocated, cl._const_count);
+ EXPECT_EQ(entries_with_values, cl._const_non_null);
+ EXPECT_EQ(0u, cl._non_const_count);
+ EXPECT_EQ(0u, cl._non_const_non_null);
+ }
+ }
+
+ while (allocated > 0) {
+ release_entry(_storage, entries[--allocated]);
+ }
+}
+
+class OopStorageTestIteration : public OopStorageTestWithAllocation {
+public:
+ static const size_t _max_workers = 2;
+ unsigned char _states[_max_workers][_max_entries];
+
+ static const unsigned char mark_released = 1u << 0;
+ static const unsigned char mark_invalid = 1u << 1;
+ static const unsigned char mark_const = 1u << 2;
+ static const unsigned char mark_non_const = 1u << 3;
+
+ virtual void SetUp() {
+ OopStorageTestWithAllocation::SetUp();
+
+ memset(_states, 0, sizeof(_states));
+
+ size_t initial_release = 0;
+ for ( ; _storage.empty_block_count() < 2; ++initial_release) {
+ ASSERT_GT(_max_entries, initial_release);
+ release_entry(_storage, _entries[initial_release]);
+ _states[0][initial_release] = mark_released;
+ }
+
+ for (size_t i = initial_release; i < _max_entries; i += 3) {
+ release_entry(_storage, _entries[i]);
+ _states[0][i] = mark_released;
+ }
+ }
+
+ class VerifyState;
+ class VerifyFn;
+ template<bool is_const> class VM_Verify;
+
+ class VerifyClosure;
+ class VM_VerifyUsingOopsDo;
+};
+
+const unsigned char OopStorageTestIteration::mark_released;
+const unsigned char OopStorageTestIteration::mark_invalid;
+const unsigned char OopStorageTestIteration::mark_const;
+const unsigned char OopStorageTestIteration::mark_non_const;
+
+class OopStorageTestIteration::VerifyState VALUE_OBJ_CLASS_SPEC {
+public:
+ unsigned char _expected_mark;
+ const oop* const* _entries;
+ unsigned char (&_states)[_max_workers][_max_entries];
+
+ VerifyState(unsigned char expected_mark,
+ const oop* const* entries,
+ unsigned char (&states)[_max_workers][_max_entries]) :
+ _expected_mark(expected_mark),
+ _entries(entries),
+ _states(states)
+ { }
+
+ bool update(const oop* ptr, uint worker_id, unsigned char mark) const {
+ size_t index = 0;
+ bool found = find_entry(ptr, &index);
+ EXPECT_TRUE(found);
+ EXPECT_GT(_max_entries, index);
+ EXPECT_GT(_max_workers, worker_id);
+ if (!found) {
+ return false;
+ } else if (index >= _max_entries) {
+ return false;
+ } else if (worker_id >= _max_workers) {
+ return false;
+ } else {
+ EXPECT_EQ(0, _states[worker_id][index]);
+ if (_states[worker_id][index] != 0) {
+ _states[worker_id][index] |= mark_invalid;
+ return false;
+ } else {
+ _states[worker_id][index] |= mark;
+ return true;
+ }
+ }
+ }
+
+ void check() const {
+ for (size_t i = 0; i < _max_entries; ++i) {
+ unsigned char mark = 0;
+ for (size_t w = 0; w < _max_workers; ++w) {
+ if (mark == 0) {
+ mark = _states[w][i];
+ } else {
+ EXPECT_EQ(0u, _states[w][i]);
+ }
+ }
+ if (mark == 0) {
+ EXPECT_NE(0u, mark);
+ } else if ((mark & mark_released) != 0) {
+ EXPECT_EQ(mark_released, mark);
+ } else {
+ EXPECT_EQ(_expected_mark, mark);
+ }
+ }
+ }
+
+private:
+ bool find_entry(const oop* ptr, size_t* index) const {
+ for (size_t i = 0; i < _max_entries; ++i) {
+ if (ptr == _entries[i]) {
+ *index = i;
+ return true;
+ }
+ }
+ return false;
+ }
+};
+
+class OopStorageTestIteration::VerifyFn VALUE_OBJ_CLASS_SPEC {
+public:
+ VerifyFn(VerifyState* state, uint worker_id = 0) :
+ _state(state),
+ _worker_id(worker_id)
+ {}
+
+ bool operator()( oop* ptr) const {
+ return _state->update(ptr, _worker_id, mark_non_const);
+ }
+
+ bool operator()(const oop* ptr) const {
+ return _state->update(ptr, _worker_id, mark_const);
+ }
+
+private:
+ VerifyState* _state;
+ uint _worker_id;
+};
+
+class OopStorageTestIteration::VerifyClosure VALUE_OBJ_CLASS_SPEC {
+public:
+ VerifyClosure(VerifyState* state, uint worker_id = 0) :
+ _state(state),
+ _worker_id(worker_id)
+ {}
+
+ void do_oop(oop* ptr) {
+ _state->update(ptr, _worker_id, mark_non_const);
+ }
+
+ void do_oop(const oop* ptr) {
+ _state->update(ptr, _worker_id, mark_const);
+ }
+
+private:
+ VerifyState* _state;
+ uint _worker_id;
+};
+
+const size_t OopStorageTestIteration::_max_workers;
+
+template<bool is_const>
+class OopStorageTestIteration::VM_Verify : public VM_GTestExecuteAtSafepoint {
+public:
+ typedef typename Conditional<is_const,
+ const OopStorage,
+ OopStorage>::type Storage;
+
+ VM_Verify(Storage* storage, VerifyState* vstate) :
+ _storage(storage), _vstate(vstate), _result(false)
+ {}
+
+ void doit() {
+ VerifyFn verifier(_vstate);
+ _result = _storage->iterate_safepoint(verifier);
+ }
+
+ bool result() const { return _result; }
+
+private:
+ Storage* _storage;
+ VerifyState* _vstate;
+ bool _result;
+};
+
+class OopStorageTestIteration::VM_VerifyUsingOopsDo : public VM_GTestExecuteAtSafepoint {
+public:
+ VM_VerifyUsingOopsDo(OopStorage* storage, VerifyState* vstate) :
+ _storage(storage), _vstate(vstate)
+ {}
+
+ void doit() {
+ VerifyClosure verifier(_vstate);
+ _storage->oops_do(&verifier);
+ }
+
+private:
+ OopStorage* _storage;
+ VerifyState* _vstate;
+};
+
+TEST_VM_F(OopStorageTestIteration, iterate_safepoint) {
+ VerifyState vstate(mark_non_const, _entries, _states);
+ VM_Verify<false> op(&_storage, &vstate);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ EXPECT_TRUE(op.result());
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestIteration, const_iterate_safepoint) {
+ VerifyState vstate(mark_const, _entries, _states);
+ VM_Verify<true> op(&_storage, &vstate);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ EXPECT_TRUE(op.result());
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestIteration, oops_do) {
+ VerifyState vstate(mark_non_const, _entries, _states);
+ VM_VerifyUsingOopsDo op(&_storage, &vstate);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ vstate.check();
+}
+
+// Parallel iteration not available unless INCLUDE_ALL_GCS
+#if INCLUDE_ALL_GCS
+
+class OopStorageTestParIteration : public OopStorageTestIteration {
+public:
+ WorkGang* workers();
+
+ class VM_ParStateVerify;
+
+ template<bool concurrent, bool is_const> class Task;
+ template<bool concurrent, bool is_const> class TaskUsingOopsDo;
+
+private:
+ static WorkGang* _workers;
+};
+
+WorkGang* OopStorageTestParIteration::_workers = NULL;
+
+WorkGang* OopStorageTestParIteration::workers() {
+ if (_workers == NULL) {
+ _workers = new WorkGang("OopStorageTestParIteration workers",
+ _max_workers,
+ false,
+ false);
+ _workers->initialize_workers();
+ _workers->update_active_workers(_max_workers);
+ }
+ return _workers;
+}
+
+template<bool concurrent, bool is_const>
+class OopStorageTestParIteration::Task : public AbstractGangTask {
+ typedef OopStorage::ParState<concurrent, is_const> StateType;
+
+ typedef typename Conditional<is_const,
+ const OopStorage,
+ OopStorage>::type Storage;
+
+public:
+ Task(const char* name, Storage* storage, VerifyState* vstate) :
+ AbstractGangTask(name, GCId::undefined()),
+ _state(storage),
+ _vstate(vstate)
+ {}
+
+ virtual void work(uint worker_id) {
+ VerifyFn verifier(_vstate, worker_id);
+ _state.iterate(verifier);
+ }
+
+private:
+ StateType _state;
+ VerifyState* _vstate;
+};
+
+template<bool concurrent, bool is_const>
+class OopStorageTestParIteration::TaskUsingOopsDo : public AbstractGangTask {
+public:
+ TaskUsingOopsDo(const char* name, OopStorage* storage, VerifyState* vstate) :
+ AbstractGangTask(name, GCId::undefined()),
+ _state(storage),
+ _vstate(vstate)
+ {}
+
+ virtual void work(uint worker_id) {
+ VerifyClosure verifier(_vstate, worker_id);
+ _state.oops_do(&verifier);
+ }
+
+private:
+ OopStorage::ParState<concurrent, is_const> _state;
+ VerifyState* _vstate;
+};
+
+class OopStorageTestParIteration::VM_ParStateVerify : public VM_GTestExecuteAtSafepoint {
+public:
+ VM_ParStateVerify(WorkGang* workers, AbstractGangTask* task) :
+ _workers(workers), _task(task)
+ {}
+
+ void doit() {
+ _workers->run_task(_task);
+ }
+
+private:
+ WorkGang* _workers;
+ AbstractGangTask* _task;
+};
+
+TEST_VM_F(OopStorageTestParIteration, par_state_safepoint_iterate) {
+ VerifyState vstate(mark_non_const, _entries, _states);
+ Task<false, false> task("test", &_storage, &vstate);
+ VM_ParStateVerify op(workers(), &task);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestParIteration, par_state_safepoint_const_iterate) {
+ VerifyState vstate(mark_const, _entries, _states);
+ Task<false, true> task("test", &_storage, &vstate);
+ VM_ParStateVerify op(workers(), &task);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestParIteration, par_state_safepoint_oops_do) {
+ VerifyState vstate(mark_non_const, _entries, _states);
+ TaskUsingOopsDo<false, false> task("test", &_storage, &vstate);
+ VM_ParStateVerify op(workers(), &task);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestParIteration, par_state_safepoint_const_oops_do) {
+ VerifyState vstate(mark_const, _entries, _states);
+ TaskUsingOopsDo<false, true> task("test", &_storage, &vstate);
+ VM_ParStateVerify op(workers(), &task);
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VMThread::execute(&op);
+ }
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestParIteration, par_state_concurrent_iterate) {
+ VerifyState vstate(mark_non_const, _entries, _states);
+ Task<true, false> task("test", &_storage, &vstate);
+ workers()->run_task(&task);
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestParIteration, par_state_concurrent_const_iterate) {
+ VerifyState vstate(mark_const, _entries, _states);
+ Task<true, true> task("test", &_storage, &vstate);
+ workers()->run_task(&task);
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestParIteration, par_state_concurrent_oops_do) {
+ VerifyState vstate(mark_non_const, _entries, _states);
+ TaskUsingOopsDo<true, false> task("test", &_storage, &vstate);
+ workers()->run_task(&task);
+ vstate.check();
+}
+
+TEST_VM_F(OopStorageTestParIteration, par_state_concurrent_const_oops_do) {
+ VerifyState vstate(mark_const, _entries, _states);
+ TaskUsingOopsDo<true, true> task("test", &_storage, &vstate);
+ workers()->run_task(&task);
+ vstate.check();
+}
+
+#endif // INCLUDE_ALL_GCS
+
+TEST_VM_F(OopStorageTestWithAllocation, delete_empty_blocks_safepoint) {
+ TestAccess::BlockList& active_list = TestAccess::active_list(_storage);
+
+ size_t initial_active_size = list_length(active_list);
+ EXPECT_EQ(initial_active_size, _storage.block_count());
+ ASSERT_LE(3u, initial_active_size); // Need at least 3 blocks for test
+
+ for (size_t i = 0; _storage.empty_block_count() < 3; ++i) {
+ ASSERT_GT(_max_entries, i);
+ release_entry(_storage, _entries[i]);
+ }
+
+ EXPECT_EQ(initial_active_size, list_length(active_list));
+ EXPECT_EQ(initial_active_size, _storage.block_count());
+ EXPECT_EQ(3u, _storage.empty_block_count());
+
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VM_DeleteBlocksAtSafepoint op(&_storage, 2);
+ VMThread::execute(&op);
+ }
+ EXPECT_EQ(2u, _storage.empty_block_count());
+ EXPECT_EQ(initial_active_size - 1, list_length(active_list));
+ EXPECT_EQ(initial_active_size - 1, _storage.block_count());
+
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VM_DeleteBlocksAtSafepoint op(&_storage, 0);
+ VMThread::execute(&op);
+ }
+ EXPECT_EQ(0u, _storage.empty_block_count());
+ EXPECT_EQ(initial_active_size - 3, list_length(active_list));
+ EXPECT_EQ(initial_active_size - 3, _storage.block_count());
+}
+
+TEST_VM_F(OopStorageTestWithAllocation, delete_empty_blocks_concurrent) {
+ TestAccess::BlockList& active_list = TestAccess::active_list(_storage);
+
+ size_t initial_active_size = list_length(active_list);
+ EXPECT_EQ(initial_active_size, _storage.block_count());
+ ASSERT_LE(3u, initial_active_size); // Need at least 3 blocks for test
+
+ for (size_t i = 0; _storage.empty_block_count() < 3; ++i) {
+ ASSERT_GT(_max_entries, i);
+ release_entry(_storage, _entries[i]);
+ }
+
+ EXPECT_EQ(initial_active_size, list_length(active_list));
+ EXPECT_EQ(initial_active_size, _storage.block_count());
+ EXPECT_EQ(3u, _storage.empty_block_count());
+
+ _storage.delete_empty_blocks_concurrent(2);
+ EXPECT_EQ(2u, _storage.empty_block_count());
+ EXPECT_EQ(initial_active_size - 1, list_length(active_list));
+ EXPECT_EQ(initial_active_size - 1, _storage.block_count());
+
+ _storage.delete_empty_blocks_concurrent(0);
+ EXPECT_EQ(0u, _storage.empty_block_count());
+ EXPECT_EQ(initial_active_size - 3, list_length(active_list));
+ EXPECT_EQ(initial_active_size - 3, _storage.block_count());
+}
+
+TEST_VM_F(OopStorageTestWithAllocation, allocation_status) {
+ oop* retained = _entries[200];
+ oop* released = _entries[300];
+ oop* garbage = reinterpret_cast<oop*>(1024 * 1024);
+ release_entry(_storage, released);
+
+ EXPECT_EQ(OopStorage::ALLOCATED_ENTRY, _storage.allocation_status(retained));
+ EXPECT_EQ(OopStorage::UNALLOCATED_ENTRY, _storage.allocation_status(released));
+#ifndef DISABLE_GARBAGE_ALLOCATION_STATUS_TESTS
+ EXPECT_EQ(OopStorage::INVALID_ENTRY, _storage.allocation_status(garbage));
+#endif
+
+ for (size_t i = 0; i < _max_entries; ++i) {
+ if ((_entries[i] != retained) && (_entries[i] != released)) {
+ release_entry(_storage, _entries[i]);
+ }
+ }
+
+ {
+ ThreadInVMfromNative invm(JavaThread::current());
+ VM_DeleteBlocksAtSafepoint op(&_storage, 0);
+ VMThread::execute(&op);
+ }
+ EXPECT_EQ(OopStorage::ALLOCATED_ENTRY, _storage.allocation_status(retained));
+#ifndef DISABLE_GARBAGE_ALLOCATION_STATUS_TESTS
+ EXPECT_EQ(OopStorage::INVALID_ENTRY, _storage.allocation_status(released));
+ EXPECT_EQ(OopStorage::INVALID_ENTRY, _storage.allocation_status(garbage));
+#endif // DISABLE_GARBAGE_ALLOCATION_STATUS_TESTS
+}
+
+TEST_VM_F(OopStorageTest, usage_info) {
+ size_t goal_blocks = 5;
+ oop* entries[1000];
+ size_t allocated = 0;
+
+ EXPECT_EQ(0u, _storage.block_count());
+ // There is non-block overhead, so always some usage.
+ EXPECT_LT(0u, _storage.total_memory_usage());
+
+ while (_storage.block_count() < goal_blocks) {
+ size_t this_count = _storage.block_count();
+ while (_storage.block_count() == this_count) {
+ ASSERT_GT(ARRAY_SIZE(entries), allocated);
+ entries[allocated] = _storage.allocate();
+ ASSERT_TRUE(entries[allocated] != NULL);
+ ++allocated;
+ }
+ EXPECT_NE(0u, _storage.block_count());
+ EXPECT_NE(0u, _storage.total_memory_usage());
+ }
+
+ EXPECT_LT(TestAccess::memory_per_block() * _storage.block_count(),
+ _storage.total_memory_usage());
+}
+
+#ifndef PRODUCT
+
+TEST_VM_F(OopStorageTestWithAllocation, print_storage) {
+ // Release the first 1/2
+ for (size_t i = 0; i < (_max_entries / 2); ++i) {
+ release_entry(_storage, _entries[i]);
+ _entries[i] = NULL;
+ }
+ // Release every other remaining
+ for (size_t i = _max_entries / 2; i < _max_entries; i += 2) {
+ release_entry(_storage, _entries[i]);
+ _entries[i] = NULL;
+ }
+
+ size_t expected_entries = _max_entries / 4;
+ EXPECT_EQ(expected_entries, _storage.allocation_count());
+
+ size_t entries_per_block = BitsPerWord;
+ size_t expected_blocks = (_max_entries + entries_per_block - 1) / entries_per_block;
+ EXPECT_EQ(expected_blocks, _storage.block_count());
+
+ size_t expected_empties = (_max_entries / 2) / entries_per_block;
+ EXPECT_EQ(expected_empties, _storage.empty_block_count());
+
+ size_t expected_used = expected_blocks - expected_empties;
+
+ double expected_usage = (100.0 * expected_entries) / (expected_used * entries_per_block);
+
+ {
+ ResourceMark rm;
+ stringStream expected_st;
+ expected_st.print("Test Storage: " SIZE_FORMAT
+ " entries in " SIZE_FORMAT
+ " blocks (%.F%%), " SIZE_FORMAT
+ " empties, " SIZE_FORMAT " bytes",
+ expected_entries,
+ expected_used,
+ expected_usage,
+ expected_empties,
+ _storage.total_memory_usage());
+ stringStream st;
+ _storage.print_on(&st);
+ EXPECT_STREQ(expected_st.as_string(), st.as_string());
+ }
+}
+
+#endif // !PRODUCT
+
+//////////////////////////////////////////////////////////////////////////////
+// Unit tests for block lists
+
+class OopStorageBlockListTest : public ::testing::Test {
+public:
+ OopStorageBlockListTest() {
+ for (size_t i = 0; i < nvalues; ++i) {
+ values[i] = OopBlock::new_block(pseudo_owner());
+ }
+ }
+
+ ~OopStorageBlockListTest() {
+ for (size_t i = 0; i < nvalues; ++i) {
+ OopBlock::delete_block(*values[i]);
+ }
+ }
+
+ static const size_t nvalues = 10;
+ OopBlock* values[nvalues];
+
+private:
+ // The only thing we actually care about is the address of the owner.
+ static const size_t pseudo_owner_size = sizeof(OopStorage) / sizeof(void*);
+ static const void* const _pseudo_owner[pseudo_owner_size];
+ static const OopStorage* pseudo_owner() {
+ return reinterpret_cast<const OopStorage*>(&_pseudo_owner);
+ }
+};
+
+const size_t OopStorageBlockListTest::nvalues;
+const void* const OopStorageBlockListTest::_pseudo_owner[] = {};
+
+TEST_F(OopStorageBlockListTest, empty_list) {
+ TestAccess::BlockList list(&OopBlock::get_active_entry);
+
+ EXPECT_TRUE(is_list_empty(list));
+ EXPECT_EQ(NULL, list.head());
+ EXPECT_EQ(NULL, list.chead());
+ EXPECT_EQ(NULL, list.ctail());
+}
+
+TEST_F(OopStorageBlockListTest, push_back) {
+ TestAccess::BlockList list(&OopBlock::get_active_entry);
+
+ for (size_t i = 0; i < nvalues; ++i) {
+ list.push_back(*values[i]);
+ EXPECT_FALSE(is_list_empty(list));
+ EXPECT_EQ(list.ctail(), values[i]);
+ }
+
+ EXPECT_EQ(list.chead(), list.head());
+ EXPECT_EQ(list.chead(), values[0]);
+ EXPECT_EQ(list.ctail(), values[nvalues - 1]);
+
+ const OopBlock* block = list.chead();
+ for (size_t i = 0; i < nvalues; ++i) {
+ EXPECT_EQ(block, values[i]);
+ block = list.next(*block);
+ }
+ EXPECT_EQ(NULL, block);
+
+ block = list.ctail();
+ for (size_t i = 0; i < nvalues; ++i) {
+ EXPECT_EQ(block, values[nvalues - i - 1]);
+ block = list.prev(*block);
+ }
+ EXPECT_EQ(NULL, block);
+
+ clear_list(list);
+}
+
+TEST_F(OopStorageBlockListTest, push_front) {
+ TestAccess::BlockList list(&OopBlock::get_active_entry);
+
+ for (size_t i = 0; i < nvalues; ++i) {
+ list.push_front(*values[i]);
+ EXPECT_FALSE(is_list_empty(list));
+ EXPECT_EQ(list.head(), values[i]);
+ }
+
+ EXPECT_EQ(list.chead(), list.head());
+ EXPECT_EQ(list.chead(), values[nvalues - 1]);
+ EXPECT_EQ(list.ctail(), values[0]);
+
+ const OopBlock* block = list.chead();
+ for (size_t i = 0; i < nvalues; ++i) {
+ EXPECT_EQ(block, values[nvalues - i - 1]);
+ block = list.next(*block);
+ }
+ EXPECT_EQ(NULL, block);
+
+ block = list.ctail();
+ for (size_t i = 0; i < nvalues; ++i) {
+ EXPECT_EQ(block, values[i]);
+ block = list.prev(*block);
+ }
+ EXPECT_EQ(NULL, block);
+
+ clear_list(list);
+}
+
+class OopStorageBlockListTestWithList : public OopStorageBlockListTest {
+public:
+ OopStorageBlockListTestWithList() : list(&OopBlock::get_active_entry) {
+ for (size_t i = 0; i < nvalues; ++i) {
+ list.push_back(*values[i]);
+ }
+ }
+
+ ~OopStorageBlockListTestWithList() {
+ clear_list(list);
+ }
+
+ TestAccess::BlockList list;
+};
+
+TEST_F(OopStorageBlockListTestWithList, unlink_front) {
+ EXPECT_EQ(list.chead(), values[0]);
+ EXPECT_EQ(list.ctail(), values[nvalues - 1]);
+
+ list.unlink(*values[0]);
+ EXPECT_EQ(NULL, list.next(*values[0]));
+ EXPECT_EQ(NULL, list.prev(*values[0]));
+ EXPECT_EQ(list.chead(), values[1]);
+ EXPECT_EQ(list.ctail(), values[nvalues - 1]);
+
+ const OopBlock* block = list.chead();
+ for (size_t i = 1; i < nvalues; ++i) {
+ EXPECT_EQ(block, values[i]);
+ block = list.next(*block);
+ }
+ EXPECT_EQ(NULL, block);
+}
+
+TEST_F(OopStorageBlockListTestWithList, unlink_back) {
+ EXPECT_EQ(list.chead(), values[0]);
+
+ list.unlink(*values[nvalues - 1]);
+ EXPECT_EQ(NULL, list.next(*values[nvalues - 1]));
+ EXPECT_EQ(NULL, list.prev(*values[nvalues - 1]));
+ EXPECT_EQ(list.chead(), values[0]);
+ EXPECT_EQ(list.ctail(), values[nvalues - 2]);
+
+ const OopBlock* block = list.chead();
+ for (size_t i = 0; i < nvalues - 1; ++i) {
+ EXPECT_EQ(block, values[i]);
+ block = list.next(*block);
+ }
+ EXPECT_EQ(NULL, block);
+}
+
+TEST_F(OopStorageBlockListTestWithList, unlink_middle) {
+ EXPECT_EQ(list.chead(), values[0]);
+
+ size_t index = nvalues / 2;
+
+ list.unlink(*values[index]);
+ EXPECT_EQ(NULL, list.next(*values[index]));
+ EXPECT_EQ(NULL, list.prev(*values[index]));
+ EXPECT_EQ(list.chead(), values[0]);
+ EXPECT_EQ(list.ctail(), values[nvalues - 1]);
+
+ const OopBlock* block = list.chead();
+ for (size_t i = 0; i < index; ++i) {
+ EXPECT_EQ(block, values[i]);
+ block = list.next(*block);
+ }
+ for (size_t i = index + 1; i < nvalues; ++i) {
+ EXPECT_EQ(block, values[i]);
+ block = list.next(*block);
+ }
+ EXPECT_EQ(NULL, block);
+}
+
+TEST_F(OopStorageBlockListTest, single) {
+ TestAccess::BlockList list(&OopBlock::get_active_entry);
+
+ list.push_back(*values[0]);
+ EXPECT_EQ(NULL, list.next(*values[0]));
+ EXPECT_EQ(NULL, list.prev(*values[0]));
+ EXPECT_EQ(list.chead(), values[0]);
+ EXPECT_EQ(list.ctail(), values[0]);
+
+ list.unlink(*values[0]);
+ EXPECT_EQ(NULL, list.next(*values[0]));
+ EXPECT_EQ(NULL, list.prev(*values[0]));
+ EXPECT_EQ(NULL, list.chead());
+ EXPECT_EQ(NULL, list.ctail());
+}
+
+TEST_F(OopStorageBlockListTestWithList, two_lists) {
+ TestAccess::BlockList list2(&OopBlock::get_allocate_entry);
+ for (size_t i = 0; i < nvalues; ++i) {
+ list2.push_front(*values[i]);
+ }
+
+ const OopBlock* active_block = list.chead();
+ const OopBlock* allocate_block = list2.ctail();
+ for (size_t i = 0; i < nvalues; ++i) {
+ EXPECT_EQ(active_block, allocate_block);
+ active_block = list.next(*active_block);
+ allocate_block = list2.prev(*allocate_block);
+ }
+ EXPECT_EQ(NULL, active_block);
+ EXPECT_EQ(NULL, allocate_block);
+
+ for (size_t i = 0; i < nvalues; ++i) {
+ list2.unlink(*values[i]);
+ }
+ EXPECT_TRUE(is_list_empty(list2));
+
+ active_block = list.chead();
+ for (size_t i = 0; i < nvalues; ++i) {
+ EXPECT_EQ(active_block, values[i]);
+ active_block = list.next(*active_block);
+ }
+ EXPECT_EQ(NULL, active_block);
+}
+