# HG changeset patch # User kbarrett # Date 1511275675 18000 # Node ID 7638bf98a312d885427bb0bdaf55c1c1603cd650 # Parent cc231bd80c8becfea10c8d70b16093720c14abc9 8194312: Support parallel and concurrent JNI global handle processing Summary: Add OopStorage, change JNI gloabl/weak to use OopStorage. Reviewed-by: coleenp, sspitsyn, eosterlund diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/gc/shared/oopStorage.cpp --- /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(_allocated_bitmask) = 0; + const_cast(_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(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(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(owner); + for (unsigned i = 0; i < section_count; ++i, section += section_size) { + Block* candidate = reinterpret_cast(section); + intptr_t* candidate_owner_addr + = reinterpret_cast(&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(next)); + void* fetched = Atomic::cmpxchg(new_next, &_next_block, next); + if (fetched == next) break; // Claimed. + next = fetched; + } + return static_cast(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 diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/gc/shared/oopStorage.hpp --- /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 { +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 bool iterate_safepoint(F f); + template 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 void oops_do(Closure* closure); + template void oops_do(Closure* closure) const; + template void weak_oops_do(Closure* closure); + + template + 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 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 + 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 bool iterate(F f); + template 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 + 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 class OopFn; + template static OopFn oop_fn(Closure* cl); + + // Wrapper for BoolObjectClosure + iteration handler pair, so they + // can be used with iterate. + template class IfAliveFn; + template + static IfAliveFn if_alive_fn(IsAlive* is_alive, F f); + + // Wrapper for iteration handler, automatically skipping NULL entries. + template class SkipNullFn; + template static SkipNullFn skip_null_fn(F f); + + // Wrapper for iteration handler; ignore handler result and return true. + template class AlwaysTrueFn; +}; + +inline OopStorage::Block* OopStorage::BlockList::head() { + return const_cast(_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(_get_entry(block)._prev); +} + +inline OopStorage::Block* OopStorage::BlockList::next(Block& block) { + return const_cast(_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 +class OopStorage::OopFn VALUE_OBJ_CLASS_SPEC { +public: + explicit OopFn(Closure* cl) : _cl(cl) {} + + template // [const] oop* + bool operator()(OopPtr ptr) const { + _cl->do_oop(ptr); + return true; + } + +private: + Closure* _cl; +}; + +template +inline OopStorage::OopFn OopStorage::oop_fn(Closure* cl) { + return OopFn(cl); +} + +template +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 +inline OopStorage::IfAliveFn OopStorage::if_alive_fn(IsAlive* is_alive, F f) { + return IfAliveFn(is_alive, f); +} + +template +class OopStorage::SkipNullFn VALUE_OBJ_CLASS_SPEC { +public: + SkipNullFn(F f) : _f(f) {} + + template // [const] oop* + bool operator()(OopPtr ptr) const { + return (*ptr != NULL) ? _f(ptr) : true; + } + +private: + F _f; +}; + +template +inline OopStorage::SkipNullFn OopStorage::skip_null_fn(F f) { + return SkipNullFn(f); +} + +template +class OopStorage::AlwaysTrueFn VALUE_OBJ_CLASS_SPEC { + F _f; + +public: + AlwaysTrueFn(F f) : _f(f) {} + + template // [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 // 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 +inline bool OopStorage::Block::iterate(F f) { + return iterate_impl(f, this); +} + +template +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 // 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::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 +inline bool OopStorage::iterate_safepoint(F f) { + return iterate_impl(f, this); +} + +template +inline bool OopStorage::iterate_safepoint(F f) const { + return iterate_impl(f, this); +} + +template +inline void OopStorage::oops_do(Closure* cl) { + iterate_safepoint(oop_fn(cl)); +} + +template +inline void OopStorage::oops_do(Closure* cl) const { + iterate_safepoint(oop_fn(cl)); +} + +template +inline void OopStorage::weak_oops_do(Closure* cl) { + iterate_safepoint(skip_null_fn(oop_fn(cl))); +} + +template +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 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 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 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 void weak_oops_do(Closure* cl) +// template +// 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 void iterate(F f) { + // Wrap f in ATF so we can use Block::iterate. + AlwaysTrueFn atf_f(f); + ensure_iteration_started(); + typename Conditional::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 +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(storage), concurrent) + {} + + template + void iterate(F f) { + _basic_state.template iterate(f); + } + + template + void oops_do(Closure* cl) { + this->iterate(oop_fn(cl)); + } +}; + +template<> +class OopStorage::ParState VALUE_OBJ_CLASS_SPEC { + BasicParState _basic_state; + +public: + ParState(OopStorage* storage) : + _basic_state(storage, false) + {} + + template + void iterate(F f) { + _basic_state.template iterate(f); + } + + template + void oops_do(Closure* cl) { + this->iterate(oop_fn(cl)); + } + + template + void weak_oops_do(Closure* cl) { + this->iterate(skip_null_fn(oop_fn(cl))); + } + + template + 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 diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/logging/logTag.hpp --- 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) \ diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/prims/jni.cpp --- 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; diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/prims/jniCheck.cpp --- 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); } diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/prims/jvmtiTagMap.cpp --- 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; } diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/runtime/jniHandles.cpp --- 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(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(ptr) + weak_tag_value; + res = reinterpret_cast(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(res) + weak_tag_value; - res = reinterpret_cast(tptr); } else { CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); } return res; } -template oop JNIHandles::resolve_jweak(jweak handle) { assert(is_jweak(handle), "precondition"); oop result = jweak_ref(handle); - result = guard_value(result); #if INCLUDE_ALL_GCS if (result != NULL && UseG1GC) { G1SATBCardTableModRefBS::enqueue(result); @@ -130,31 +146,30 @@ return result; } -template oop JNIHandles::resolve_jweak(jweak); -template oop JNIHandles::resolve_jweak(jweak); - bool JNIHandles::is_global_weak_cleared(jweak handle) { assert(is_jweak(handle), "not a weak handle"); - return guard_value(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)) { diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/runtime/jniHandles.hpp --- 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 inline static oop guard_value(oop value); template inline static oop resolve_impl(jobject handle); - template 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 -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 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(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(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; } } diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/runtime/mutexLocker.cpp --- 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); diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/runtime/mutexLocker.hpp --- 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 diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/runtime/os.cpp --- 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; } diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/runtime/vmStructs.cpp --- 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) */ \ /**********************/ \ diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/runtime/vm_operations.hpp --- 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 { 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() {} diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/services/heapDumper.cpp --- 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)) { diff -r cc231bd80c8b -r 7638bf98a312 src/hotspot/share/services/serviceUtil.hpp --- 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 diff -r cc231bd80c8b -r 7638bf98a312 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/shared/OopStorage.java --- /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 + } +} diff -r cc231bd80c8b -r 7638bf98a312 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/JNIHandleBlock.java --- 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; diff -r cc231bd80c8b -r 7638bf98a312 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/JNIHandles.java --- 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); } } diff -r cc231bd80c8b -r 7638bf98a312 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java --- 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() { diff -r cc231bd80c8b -r 7638bf98a312 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/PointerFinder.java --- 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; } diff -r cc231bd80c8b -r 7638bf98a312 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/PointerLocation.java --- 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 diff -r cc231bd80c8b -r 7638bf98a312 src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/ReversePtrsAnalysis.java --- 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); + } } diff -r cc231bd80c8b -r 7638bf98a312 test/hotspot/gtest/gc/shared/test_oopStorage.cpp --- /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 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 +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 OopStorageTestBlockReleaseSorted; +typedef OopStorageTestBlockRelease 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(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 +class OopStorageTest::VM_CountAtSafepoint : public VM_GTestExecuteAtSafepoint { +public: + typedef typename Conditional::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(&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 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 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 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 +class OopStorageTestIteration::VM_Verify : public VM_GTestExecuteAtSafepoint { +public: + typedef typename Conditional::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 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 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 class Task; + template 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 +class OopStorageTestParIteration::Task : public AbstractGangTask { + typedef OopStorage::ParState StateType; + + typedef typename Conditional::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 +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 _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 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 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 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 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 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 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 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 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(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(&_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); +} +