< prev index next >

src/hotspot/share/runtime/handles.cpp

Print this page




   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "oops/constantPool.hpp"
  28 #include "oops/oop.inline.hpp"


  29 #include "runtime/handles.inline.hpp"
  30 #include "runtime/thread.inline.hpp"
  31 
  32 #ifdef ASSERT
  33 oop* HandleArea::allocate_handle(oop obj) {
  34   assert(_handle_mark_nesting > 1, "memory leak: allocating handle outside HandleMark");
  35   assert(_no_handle_mark_nesting == 0, "allocating handle inside NoHandleMark");
  36   assert(oopDesc::is_oop(obj), "not an oop: " INTPTR_FORMAT, p2i(obj));
  37   return real_allocate_handle(obj);
  38 }
  39 #endif
  40 
  41 // Copy constructors and destructors for metadata handles
  42 // These do too much to inline.
  43 #define DEF_METADATA_HANDLE_FN_NOINLINE(name, type) \
  44 name##Handle::name##Handle(const name##Handle &h) {                    \
  45   _value = h._value;                                                   \
  46   if (_value != NULL) {                                                \
  47     assert(_value->is_valid(), "obj is valid");                        \
  48     if (h._thread != NULL) {                                           \


  79   if (_value != NULL) {                                                \
  80     int i = _thread->metadata_handles()->find_from_end((Metadata*)_value); \
  81     assert(i!=-1, "not in metadata_handles list");                     \
  82     _thread->metadata_handles()->remove_at(i);                         \
  83   }                                                                    \
  84 }                                                                      \
  85 name##Handle::~name##Handle () { remove(); }                           \
  86 
  87 DEF_METADATA_HANDLE_FN_NOINLINE(method, Method)
  88 DEF_METADATA_HANDLE_FN_NOINLINE(constantPool, ConstantPool)
  89 
  90 
  91 static uintx chunk_oops_do(OopClosure* f, Chunk* chunk, char* chunk_top) {
  92   oop* bottom = (oop*) chunk->bottom();
  93   oop* top    = (oop*) chunk_top;
  94   uintx handles_visited = top - bottom;
  95   assert(top >= bottom && top <= (oop*) chunk->top(), "just checking");
  96   // during GC phase 3, a handle may be a forward pointer that
  97   // is not yet valid, so loosen the assertion
  98   while (bottom < top) {
  99     f->do_oop(bottom++);



 100   }
 101   return handles_visited;
 102 }
 103 
 104 void HandleArea::oops_do(OopClosure* f) {
 105   uintx handles_visited = 0;
 106   // First handle the current chunk. It is filled to the high water mark.
 107   handles_visited += chunk_oops_do(f, _chunk, _hwm);
 108   // Then handle all previous chunks. They are completely filled.
 109   Chunk* k = _first;
 110   while(k != _chunk) {
 111     handles_visited += chunk_oops_do(f, k, k->top());
 112     k = k->next();
 113   }
 114 
 115   if (_prev != NULL) _prev->oops_do(f);
 116 }
 117 
 118 void HandleMark::initialize(Thread* thread) {
 119   _thread = thread;




   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "oops/constantPool.hpp"
  28 #include "oops/oop.inline.hpp"
  29 #include "oops/valueKlass.hpp"
  30 #include "runtime/atomic.hpp"
  31 #include "runtime/handles.inline.hpp"
  32 #include "runtime/thread.inline.hpp"
  33 
  34 #ifdef ASSERT
  35 oop* HandleArea::allocate_handle(oop obj) {
  36   assert(_handle_mark_nesting > 1, "memory leak: allocating handle outside HandleMark");
  37   assert(_no_handle_mark_nesting == 0, "allocating handle inside NoHandleMark");
  38   assert(oopDesc::is_oop(obj), "not an oop: " INTPTR_FORMAT, p2i(obj));
  39   return real_allocate_handle(obj);
  40 }
  41 #endif
  42 
  43 // Copy constructors and destructors for metadata handles
  44 // These do too much to inline.
  45 #define DEF_METADATA_HANDLE_FN_NOINLINE(name, type) \
  46 name##Handle::name##Handle(const name##Handle &h) {                    \
  47   _value = h._value;                                                   \
  48   if (_value != NULL) {                                                \
  49     assert(_value->is_valid(), "obj is valid");                        \
  50     if (h._thread != NULL) {                                           \


  81   if (_value != NULL) {                                                \
  82     int i = _thread->metadata_handles()->find_from_end((Metadata*)_value); \
  83     assert(i!=-1, "not in metadata_handles list");                     \
  84     _thread->metadata_handles()->remove_at(i);                         \
  85   }                                                                    \
  86 }                                                                      \
  87 name##Handle::~name##Handle () { remove(); }                           \
  88 
  89 DEF_METADATA_HANDLE_FN_NOINLINE(method, Method)
  90 DEF_METADATA_HANDLE_FN_NOINLINE(constantPool, ConstantPool)
  91 
  92 
  93 static uintx chunk_oops_do(OopClosure* f, Chunk* chunk, char* chunk_top) {
  94   oop* bottom = (oop*) chunk->bottom();
  95   oop* top    = (oop*) chunk_top;
  96   uintx handles_visited = top - bottom;
  97   assert(top >= bottom && top <= (oop*) chunk->top(), "just checking");
  98   // during GC phase 3, a handle may be a forward pointer that
  99   // is not yet valid, so loosen the assertion
 100   while (bottom < top) {
 101     if (Universe::heap()->is_in_reserved_or_null(*bottom)) {
 102       f->do_oop(bottom);
 103     }
 104     bottom++;
 105   }
 106   return handles_visited;
 107 }
 108 
 109 void HandleArea::oops_do(OopClosure* f) {
 110   uintx handles_visited = 0;
 111   // First handle the current chunk. It is filled to the high water mark.
 112   handles_visited += chunk_oops_do(f, _chunk, _hwm);
 113   // Then handle all previous chunks. They are completely filled.
 114   Chunk* k = _first;
 115   while(k != _chunk) {
 116     handles_visited += chunk_oops_do(f, k, k->top());
 117     k = k->next();
 118   }
 119 
 120   if (_prev != NULL) _prev->oops_do(f);
 121 }
 122 
 123 void HandleMark::initialize(Thread* thread) {
 124   _thread = thread;


< prev index next >