jdk8-mips64-public/hotspot: comparison src/share/vm/classfile/classLoaderData.cpp

-:4c3cae5323bb
+:654eaca01d61
 /*
-* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2017, 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.
 // An anonymous class loader data doesn't have anything to keep
 // it from being unloaded during parsing of the anonymous class.
 // The null-class-loader should always be kept alive.
 _keep_alive(is_anonymous || h_class_loader.is_null()),
 _metaspace(NULL), _unloading(false), _klasses(NULL),
-_claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL),
+_claimed(0), _jmethod_ids(NULL), _handles(), _deallocate_list(NULL),
 _next(NULL), _dependencies(dependencies),
 _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true)) {
 // empty
 }
 // Create empty dependencies array to add to. CMS requires this to be
 // an oop so that it can track additions via card marks.  We think.
 _list_head = oopFactory::new_objectArray(2, CHECK);
 }
+ClassLoaderData::ChunkedHandleList::~ChunkedHandleList() {
+Chunk* c = _head;
+while (c != NULL) {
+Chunk* next = c->_next;
+delete c;
+c = next;
+}
+}
+oop* ClassLoaderData::ChunkedHandleList::add(oop o) {
+if (_head == NULL || _head->_size == Chunk::CAPACITY) {
+Chunk* next = new Chunk(_head);
+OrderAccess::release_store_ptr(&_head, next);
+}
+oop* handle = &_head->_data[_head->_size];
+*handle = o;
+OrderAccess::release_store(&_head->_size, _head->_size + 1);
+return handle;
+}
+inline void ClassLoaderData::ChunkedHandleList::oops_do_chunk(OopClosure* f, Chunk* c, const juint size) {
+for (juint i = 0; i < size; i++) {
+if (c->_data[i] != NULL) {
+f->do_oop(&c->_data[i]);
+}
+}
+}
+void ClassLoaderData::ChunkedHandleList::oops_do(OopClosure* f) {
+Chunk* head = (Chunk*) OrderAccess::load_ptr_acquire(&_head);
+if (head != NULL) {
+// Must be careful when reading size of head
+oops_do_chunk(f, head, OrderAccess::load_acquire(&head->_size));
+for (Chunk* c = head->_next; c != NULL; c = c->_next) {
+oops_do_chunk(f, c, c->_size);
+}
+}
+}
 bool ClassLoaderData::claim() {
 if (_claimed == 1) {
 return false;
 }
 return;
 }
 f->do_oop(&_class_loader);
 _dependencies.oops_do(f);
-_handles->oops_do(f);
+_handles.oops_do(f);
 if (klass_closure != NULL) {
 classes_do(klass_closure);
 }
 }
 Metaspace *m = _metaspace;
 if (m != NULL) {
 _metaspace = NULL;
 // release the metaspace
 delete m;
-// release the handles
-if (_handles != NULL) {
-JNIHandleBlock::release_block(_handles);
-_handles = NULL;
-}
 }
 // Clear all the JNI handles for methods
 // These aren't deallocated and are going to look like a leak, but that's
 // needed because we can't really get rid of jmethodIDs because we don't
 }
 }
 return _metaspace;
 }
-JNIHandleBlock* ClassLoaderData::handles() const           { return _handles; }
-void ClassLoaderData::set_handles(JNIHandleBlock* handles) { _handles = handles; }
 jobject ClassLoaderData::add_handle(Handle h) {
 MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
-if (handles() == NULL) {
+return (jobject) _handles.add(h());
-set_handles(JNIHandleBlock::allocate_block());
-}
-return handles()->allocate_handle(h());
 }
 // Add this metadata pointer to be freed when it's safe.  This is only during
 // class unloading because Handles might point to this metadata field.
 void ClassLoaderData::add_to_deallocate_list(Metadata* m) {
 out->print("ClassLoaderData CLD: "PTR_FORMAT", loader: "PTR_FORMAT", loader_klass: "PTR_FORMAT" %s {",
 p2i(this), p2i((void *)class_loader()),
 p2i(class_loader() != NULL ? class_loader()->klass() : NULL), loader_name());
 if (claimed()) out->print(" claimed ");
 if (is_unloading()) out->print(" unloading ");
-out->print(" handles " INTPTR_FORMAT, p2i(handles()));
 out->cr();
 if (metaspace_or_null() != NULL) {
 out->print_cr("metaspace: " INTPTR_FORMAT, p2i(metaspace_or_null()));
 metaspace_or_null()->dump(out);
 } else {

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

comparison: src/share/vm/classfile/classLoaderData.cpp

src/share/vm/classfile/classLoaderData.cpp