jdk-sandbox: comparison src/hotspot/share/compiler/oopMap.cpp

equal deleted inserted replaced

-:278600885731
+:7136c9ac56a7
 #include "oops/compressedOops.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/signature.hpp"
 #include "utilities/align.hpp"
+#include "utilities/lockFreeStack.hpp"
 #ifdef COMPILER1
 #include "c1/c1_Defs.hpp"
 #endif
 #ifdef COMPILER2
 #include "opto/optoreg.hpp"
 if (UseJVMCICompiler) {
 ShouldNotReachHere();
 }
 #endif
 #endif // !TIERED
-// Protect the operation on the derived pointers.  This
-// protects the addition of derived pointers to the shared
-// derived pointer table in DerivedPointerTable::add().
-MutexLocker x(DerivedPointerTableGC_lock, Mutex::_no_safepoint_check_flag);
 do {
 omv = oms.current();
 oop* loc = fr->oopmapreg_to_location(omv.reg(),reg_map);
 guarantee(loc != NULL, "missing saved register");
 oop *derived_loc = loc;
 //------------------------------DerivedPointerTable---------------------------
 #if COMPILER2_OR_JVMCI
-class DerivedPointerEntry : public CHeapObj<mtCompiler> {
+class DerivedPointerTable::Entry : public CHeapObj<mtCompiler> {
-private:
+oop* _location;   // Location of derived pointer, also pointing to base
-oop*     _location; // Location of derived pointer (also pointing to the base)
+intptr_t _offset; // Offset from base pointer
-intptr_t _offset;   // Offset from base pointer
+Entry* volatile _next;
-public:
-DerivedPointerEntry(oop* location, intptr_t offset) { _location = location; _offset = offset; }
+static Entry* volatile* next_ptr(Entry& entry) { return &entry._next; }
-oop* location()    { return _location; }
-intptr_t  offset() { return _offset; }
+public:
+Entry(oop* location, intptr_t offset) :
+_location(location), _offset(offset), _next(NULL) {}
+oop* location() const { return _location; }
+intptr_t offset() const { return _offset; }
+Entry* next() const { return _next; }
+typedef LockFreeStack<Entry, &next_ptr> List;
+static List* _list;
 };
+DerivedPointerTable::Entry::List* DerivedPointerTable::Entry::_list = NULL;
-GrowableArray<DerivedPointerEntry*>* DerivedPointerTable::_list = NULL;
 bool DerivedPointerTable::_active = false;
+bool DerivedPointerTable::is_empty() {
+return Entry::_list == NULL || Entry::_list->empty();
+}
 void DerivedPointerTable::clear() {
 // The first time, we create the list.  Otherwise it should be
 // empty.  If not, then we have probably forgotton to call
 // update_pointers after last GC/Scavenge.
 assert (!_active, "should not be active");
-assert(_list == NULL || _list->length() == 0, "table not empty");
+assert(is_empty(), "table not empty");
-if (_list == NULL) {
+if (Entry::_list == NULL) {
-_list = new (ResourceObj::C_HEAP, mtCompiler) GrowableArray<DerivedPointerEntry*>(10, true); // Allocated on C heap
+void* mem = NEW_C_HEAP_OBJ(Entry::List, mtCompiler);
+Entry::_list = ::new (mem) Entry::List();
 }
 _active = true;
 }
 // Returns value of location as an int
-intptr_t value_of_loc(oop *pointer) { return cast_from_oop<intptr_t>((*pointer)); }
+inline intptr_t value_of_loc(oop *pointer) {
+return cast_from_oop<intptr_t>((*pointer));
+}
 void DerivedPointerTable::add(oop *derived_loc, oop *base_loc) {
 assert(Universe::heap()->is_in_or_null(*base_loc), "not an oop");
 assert(derived_loc != base_loc, "Base and derived in same location");
 if (_active) {
 assert(*derived_loc != (void*)base_loc, "location already added");
-assert(_list != NULL, "list must exist");
+assert(Entry::_list != NULL, "list must exist");
 intptr_t offset = value_of_loc(derived_loc) - value_of_loc(base_loc);
 // This assert is invalid because derived pointers can be
 // arbitrarily far away from their base.
 // assert(offset >= -1000000, "wrong derived pointer info");
 p2i(derived_loc), p2i((address)*derived_loc), p2i((address)*base_loc), p2i(base_loc), offset
 );
 }
 // Set derived oop location to point to base.
 *derived_loc = (oop)base_loc;
-assert_lock_strong(DerivedPointerTableGC_lock);
+Entry* entry = new Entry(derived_loc, offset);
-DerivedPointerEntry *entry = new DerivedPointerEntry(derived_loc, offset);
+Entry::_list->push(*entry);
-_list->append(entry);
+}
 }
-}
 void DerivedPointerTable::update_pointers() {
-assert(_list != NULL, "list must exist");
+assert(Entry::_list != NULL, "list must exist");
-for(int i = 0; i < _list->length(); i++) {
+Entry* entries = Entry::_list->pop_all();
-DerivedPointerEntry* entry = _list->at(i);
+while (entries != NULL) {
+Entry* entry = entries;
+entries = entry->next();
 oop* derived_loc = entry->location();
 intptr_t offset  = entry->offset();
 // The derived oop was setup to point to location of base
-oop  base        = **(oop**)derived_loc;
+oop base = **(oop**)derived_loc;
 assert(Universe::heap()->is_in_or_null(base), "must be an oop");
 *derived_loc = (oop)(((address)base) + offset);
 assert(value_of_loc(derived_loc) - value_of_loc(&base) == offset, "sanity check");
 p2i(derived_loc), p2i((address)*derived_loc), p2i((address)base), offset);
 }
 // Delete entry
 delete entry;
-_list->at_put(i, NULL);
+}
-}
+assert(Entry::_list->empty(), "invariant");
-// Clear list, so it is ready for next traversal (this is an invariant)
-if (TraceDerivedPointers && !_list->is_empty()) {
-tty->print_cr("--------------------------");
-}
-_list->clear();
 _active = false;
 }
 #endif // COMPILER2_OR_JVMCI

changeset 54916	7136c9ac56a7
parent 54807	33fe50b6d707
child 54960	e46fe26d7f77