truffle: src/share/vm/services/memSnapshot.hpp comparison

comparison src/share/vm/services/memSnapshot.hpp @ 6979:fb3190e77d3c

8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 Summary: Fixed NMT that miscounted arena memory when it is used as value or stack object. Reviewed-by: acorn, coleenp

author	zgu
date	Fri, 09 Nov 2012 19:24:31 -0500
parents	716c64bda5ba
children	49cbd3e25ba9

comparison

equal deleted inserted replaced

-:8940ddc1036f
+:fb3190e77d3c
 #include "memory/allocation.hpp"
 #include "runtime/mutex.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "services/memBaseline.hpp"
 #include "services/memPtrArray.hpp"
 // Snapshot pointer array iterator
 // The pointer array contains malloc-ed pointers
 class MemPointerIterator : public MemPointerArrayIteratorImpl {
 }
 #endif
 };
 class MallocRecordIterator : public MemPointerArrayIterator {
-protected:
+private:
 MemPointerArrayIteratorImpl  _itr;
 public:
 MallocRecordIterator(MemPointerArray* arr) : _itr(arr) {
 }
 virtual MemPointer* current() const {
-MemPointerRecord* cur = (MemPointerRecord*)_itr.current();
+#ifdef ASSERT
-assert(cur == NULL || !cur->is_vm_pointer(), "seek error");
+MemPointer* cur_rec = _itr.current();
-MemPointerRecord* next = (MemPointerRecord*)_itr.peek_next();
+if (cur_rec != NULL) {
-if (next == NULL || next->addr() != cur->addr()) {
+MemPointer* prev_rec = _itr.peek_prev();
-return cur;
+MemPointer* next_rec = _itr.peek_next();
-} else {
+assert(prev_rec == NULL || prev_rec->addr() < cur_rec->addr(), "Sorting order");
-assert(!cur->is_vm_pointer(), "Sanity check");
+assert(next_rec == NULL || next_rec->addr() > cur_rec->addr(), "Sorting order");
-assert(cur->is_allocation_record() && next->is_deallocation_record(),
+}
-"sorting order");
+#endif
-assert(cur->seq() != next->seq(), "Sanity check");
+return _itr.current();
-return cur->seq() >  next->seq() ? cur : next;
+}
-}
-}
 virtual MemPointer* next() {
-MemPointerRecord* cur = (MemPointerRecord*)_itr.current();
+MemPointerRecord* next_rec = (MemPointerRecord*)_itr.next();
-assert(cur == NULL || !cur->is_vm_pointer(), "Sanity check");
+// arena memory record is a special case, which we have to compare
-MemPointerRecord* next = (MemPointerRecord*)_itr.next();
+// sequence number against its associated arena record.
-if (next == NULL) {
+if (next_rec != NULL && next_rec->is_arena_memory_record()) {
-return NULL;
+MemPointerRecord* prev_rec = (MemPointerRecord*)_itr.peek_prev();
-}
+// if there is an associated arena record, it has to be previous
-if (cur->addr() == next->addr()) {
+// record because of sorting order (by address) - NMT generates a pseudo address
-next = (MemPointerRecord*)_itr.next();
+// for arena's size record by offsetting arena's address, that guarantees
-}
+// the order of arena record and it's size record.
-return current();
+if (prev_rec != NULL && prev_rec->is_arena_record() &&
+next_rec->is_memory_record_of_arena(prev_rec)) {
+if (prev_rec->seq() > next_rec->seq()) {
+// Skip this arena memory record
+// Two scenarios:
+//   - if the arena record is an allocation record, this early
+//     size record must be leftover by previous arena,
+//     and the last size record should have size = 0.
+//   - if the arena record is a deallocation record, this
+//     size record should be its cleanup record, which should
+//     also have size = 0. In other world, arena alway reset
+//     its size before gone (see Arena's destructor)
+assert(next_rec->size() == 0, "size not reset");
+return _itr.next();
+} else {
+assert(prev_rec->is_allocation_record(),
+"Arena size record ahead of allocation record");
+}
+}
+}
+return next_rec;
 }
 MemPointer* peek_next() const      { ShouldNotReachHere(); return NULL; }
 MemPointer* peek_prev() const      { ShouldNotReachHere(); return NULL; }
 void remove()                      { ShouldNotReachHere(); }
 // cheaper than during promotion phase. However, it does have limitation - it
 // can only eliminate duplicated records within the generation, there are
 // still chances seeing duplicated records during promotion.
 // We want to use the record with higher sequence number, because it has
 // more accurate callsite pc.
-class VMRecordIterator : public MallocRecordIterator {
+class VMRecordIterator : public MemPointerArrayIterator {
-public:
+private:
-VMRecordIterator(MemPointerArray* arr) : MallocRecordIterator(arr) {
+MemPointerArrayIteratorImpl  _itr;
+public:
+VMRecordIterator(MemPointerArray* arr) : _itr(arr) {
 MemPointerRecord* cur = (MemPointerRecord*)_itr.current();
 MemPointerRecord* next = (MemPointerRecord*)_itr.peek_next();
 while (next != NULL) {
 assert(cur != NULL, "Sanity check");
 assert(((SeqMemPointerRecord*)next)->seq() > ((SeqMemPointerRecord*)cur)->seq(),
 }
 }
 return cur;
 }
+MemPointer* peek_next() const      { ShouldNotReachHere(); return NULL; }
+MemPointer* peek_prev() const      { ShouldNotReachHere(); return NULL; }
+void remove()                      { ShouldNotReachHere(); }
+bool insert(MemPointer* ptr)       { ShouldNotReachHere(); return false; }
+bool insert_after(MemPointer* ptr) { ShouldNotReachHere(); return false; }
 private:
 bool is_duplicated_record(MemPointerRecord* p1, MemPointerRecord* p2) const {
 bool ret = (p1->addr() == p2->addr() && p1->size() == p2->size() && p1->flags() == p2->flags());
 assert(!(ret && FLAGS_TO_MEMORY_TYPE(p1->flags()) == mtThreadStack), "dup on stack record");
 return ret;
 NOT_PRODUCT(bool has_allocation_record(address addr);)
 // dump all virtual memory pointers in snapshot
 DEBUG_ONLY( void dump_all_vm_pointers();)
 private:
-// copy pointer data from src to dest
+// copy sequenced pointer from src to dest
-void copy_pointer(MemPointerRecord* dest, const MemPointerRecord* src);
+void copy_seq_pointer(MemPointerRecord* dest, const MemPointerRecord* src);
+// assign a sequenced pointer to non-sequenced pointer
+void assign_pointer(MemPointerRecord*dest, const MemPointerRecord* src);
 bool promote_malloc_records(MemPointerArrayIterator* itr);
 bool promote_virtual_memory_records(MemPointerArrayIterator* itr);
 };

Mercurial > hg > truffle

comparison src/share/vm/services/memSnapshot.hpp @ 6979:fb3190e77d3c