jdk-sandbox: comparison src/hotspot/share/runtime/jniHandles.cpp

equal deleted inserted replaced

-:cc231bd80c8b
+:7638bf98a312
 /*
-* 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 * questions.
 *
 */
 #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"
 #include "runtime/jniHandles.hpp"
 #include "runtime/mutexLocker.hpp"
 #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;
+OopStorage* JNIHandles::_global_handles = NULL;
-JNIHandleBlock* JNIHandles::_weak_global_handles  = NULL;
+OopStorage* JNIHandles::_weak_global_handles = NULL;
-oop             JNIHandles::_deleted_handle       = NULL;
 jobject JNIHandles::make_local(oop obj) {
 if (obj == NULL) {
 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);
 }
 }
 jobject JNIHandles::make_local(Thread* thread, oop obj) {
 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);
 }
 }
 jobject JNIHandles::make_local(JNIEnv* env, oop obj) {
 if (obj == NULL) {
 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(oopDesc::is_oop(obj()), "not an oop");
-assert(Universe::heap()->is_in_reserved(obj()), "sanity check");
+oop* ptr = _global_handles->allocate();
-res = _global_handles->allocate_handle(obj());
+// Return NULL on allocation failure.
+if (ptr != NULL) {
+*ptr = obj();
+res = reinterpret_cast<jobject>(ptr);
+} else {
+report_handle_allocation_failure(alloc_failmode, "global");
+}
 } else {
 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
 }
 return res;
 }
-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
-{
+assert(oopDesc::is_oop(obj()), "not an oop");
-MutexLocker ml(JNIGlobalHandle_lock);
+oop* ptr = _weak_global_handles->allocate();
-assert(Universe::heap()->is_in_reserved(obj()), "sanity check");
+// Return NULL on allocation failure.
-res = _weak_global_handles->allocate_handle(obj());
+if (ptr != NULL) {
-}
+*ptr = obj();
-// Add weak tag.
+char* tptr = reinterpret_cast<char*>(ptr) + weak_tag_value;
-assert(is_aligned(res, weak_tag_alignment), "invariant");
+res = reinterpret_cast<jobject>(tptr);
-char* tptr = reinterpret_cast<char*>(res) + weak_tag_value;
+} else {
-res = reinterpret_cast<jobject>(tptr);
+report_handle_allocation_failure(alloc_failmode, "weak global");
+}
 } else {
 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
 }
 return res;
 }
-template<bool external_guard>
 oop JNIHandles::resolve_jweak(jweak handle) {
 assert(is_jweak(handle), "precondition");
 oop result = jweak_ref(handle);
-result = guard_value<external_guard>(result);
 #if INCLUDE_ALL_GCS
 if (result != NULL && UseG1GC) {
 G1SATBCardTableModRefBS::enqueue(result);
 }
 #endif // INCLUDE_ALL_GCS
 return result;
 }
-template oop JNIHandles::resolve_jweak<true>(jweak);
-template oop JNIHandles::resolve_jweak<false>(jweak);
 bool JNIHandles::is_global_weak_cleared(jweak handle) {
 assert(is_jweak(handle), "not a weak handle");
-return guard_value<false>(jweak_ref(handle)) == NULL;
+return jweak_ref(handle) == NULL;
 }
 void JNIHandles::destroy_global(jobject handle) {
 if (handle != NULL) {
-assert(is_global_handle(handle), "Invalid delete of global JNI handle");
+assert(!is_jweak(handle), "wrong method for detroying jweak");
-jobject_ref(handle) = deleted_handle();
+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);
 }
 void JNIHandles::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) {
 _weak_global_handles->weak_oops_do(is_alive, f);
 }
 void JNIHandles::weak_oops_do(OopClosure* f) {
-AlwaysTrueClosure always_true;
+_weak_global_handles->weak_oops_do(f);
-weak_oops_do(&always_true, f);
 }
 void JNIHandles::initialize() {
-_global_handles      = JNIHandleBlock::allocate_block();
+_global_handles = new OopStorage("JNI Global",
-_weak_global_handles = JNIHandleBlock::allocate_block();
+JNIGlobalAlloc_lock,
-EXCEPTION_MARK;
+JNIGlobalActive_lock);
-// We will never reach the CATCH below since Exceptions::_throw will cause
+_weak_global_handles = new OopStorage("JNI Weak",
-// the VM to exit if an exception is thrown during initialization
+JNIWeakAlloc_lock,
-Klass* k      = SystemDictionary::Object_klass();
+JNIWeakActive_lock);
-_deleted_handle = InstanceKlass::cast(k)->allocate_instance(CATCH);
+}
+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;
 }
 bool JNIHandles::is_local_handle(Thread* thread, jobject handle) {
 JNIHandleBlock* block = thread->active_handles();
 (void*)obj >= (void*)thr->last_Java_sp());
 }
 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);
+return is_jweak(handle) && is_storage_handle(_weak_global_handles, &jweak_ref(handle));
 }
-long JNIHandles::global_handle_memory_usage() {
+size_t JNIHandles::global_handle_memory_usage() {
-return _global_handles->memory_usage();
+return _global_handles->total_memory_usage();
 }
-long JNIHandles::weak_global_handle_memory_usage() {
+size_t JNIHandles::weak_global_handle_memory_usage() {
-return _weak_global_handles->memory_usage();
+return _weak_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; }
-};
 // We assume this is called at a safepoint: no lock is needed.
 void JNIHandles::print_on(outputStream* st) {
 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 assert(_global_handles != NULL && _weak_global_handles != NULL,
 "JNIHandles not initialized");
-CountHandleClosure global_handle_count;
+st->print_cr("JNI global refs: " SIZE_FORMAT ", weak refs: " SIZE_FORMAT,
-oops_do(&global_handle_count);
+_global_handles->allocation_count(),
-weak_oops_do(&global_handle_count);
+_weak_global_handles->allocation_count());
-st->print_cr("JNI global references: %d", global_handle_count.count());
 st->cr();
 st->flush();
 }
-class VerifyHandleClosure: public OopClosure {
+class VerifyJNIHandles: public OopClosure {
 public:
 virtual void do_oop(oop* root) {
 (*root)->verify();
 }
 virtual void do_oop(narrowOop* root) { ShouldNotReachHere(); }
 };
 void JNIHandles::verify() {
-VerifyHandleClosure verify_handle;
+VerifyJNIHandles verify_handle;
 oops_do(&verify_handle);
 weak_oops_do(&verify_handle);
 }
 current_chain = current_chain->pop_frame_link();
 }
 }
-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) {
 // This is the first allocation or the initial block got zapped when
 // entering a native function. If we have any following blocks they are
 obj = obj_handle();
 }
 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;
 int blocks = 0;
 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;
 free++;
 }
 }
 return false;
 }
-int JNIHandleBlock::length() const {
+size_t JNIHandleBlock::length() const {
-int result = 1;
+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)) {
 return true;

changeset 48787	7638bf98a312
parent 48465	f82e79958beb
child 48808	2b0b7f222800