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

 /*

  * Copyright (c) 2012, 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.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 #ifndef SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP

 #define SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP

 #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 {

  public:

   MemPointerIterator(MemPointerArray* arr):

     MemPointerArrayIteratorImpl(arr) {

     assert(arr != NULL, "null array");

   }

 #ifdef ASSERT

   virtual bool is_dup_pointer(const MemPointer* ptr1,

     const MemPointer* ptr2) const {

     MemPointerRecord* p1 = (MemPointerRecord*)ptr1;

     MemPointerRecord* p2 = (MemPointerRecord*)ptr2;

     if (p1->addr() != p2->addr()) return false;

     if ((p1->flags() & MemPointerRecord::tag_masks) !=

         (p2->flags() & MemPointerRecord::tag_masks)) {

       return false;

     }

     // we do see multiple commit/uncommit on the same memory, it is ok

     return (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_alloc ||

            (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_release;

   }

   virtual bool insert(MemPointer* ptr) {

     if (_pos > 0) {

       MemPointer* p1 = (MemPointer*)ptr;

       MemPointer* p2 = (MemPointer*)_array->at(_pos - 1);

       assert(!is_dup_pointer(p1, p2),

         err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));

     }

      if (_pos < _array->length() -1) {

       MemPointer* p1 = (MemPointer*)ptr;

       MemPointer* p2 = (MemPointer*)_array->at(_pos + 1);

       assert(!is_dup_pointer(p1, p2),

         err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));

      }

     return _array->insert_at(ptr, _pos);

   }

   virtual bool insert_after(MemPointer* ptr) {

     if (_pos > 0) {

       MemPointer* p1 = (MemPointer*)ptr;

       MemPointer* p2 = (MemPointer*)_array->at(_pos - 1);

       assert(!is_dup_pointer(p1, p2),

         err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));

     }

     if (_pos < _array->length() - 1) {

       MemPointer* p1 = (MemPointer*)ptr;

       MemPointer* p2 = (MemPointer*)_array->at(_pos + 1);

       assert(!is_dup_pointer(p1, p2),

         err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));

      }

     if (_array->insert_at(ptr, _pos + 1)) {

       _pos ++;

       return true;

     }

     return false;

   }

 #endif

   virtual MemPointer* locate(address addr) {

     MemPointer* cur = current();

     while (cur != NULL && cur->addr() < addr) {

       cur = next();

     }

     return cur;

   }

 };

 class VMMemPointerIterator : public MemPointerIterator {

  public:

   VMMemPointerIterator(MemPointerArray* arr):

       MemPointerIterator(arr) {

   }

   // locate an existing reserved memory region that contains specified address,

   // or the reserved region just above this address, where the incoming

   // reserved region should be inserted.

   virtual MemPointer* locate(address addr) {

     reset();

     VMMemRegion* reg = (VMMemRegion*)current();

     while (reg != NULL) {

       if (reg->is_reserved_region()) {

         if (reg->contains_address(addr) || addr < reg->base()) {

           return reg;

       }

     }

       reg = (VMMemRegion*)next();

     }

       return NULL;

     }

   // following methods update virtual memory in the context

   // of 'current' position, which is properly positioned by

   // callers via locate method.

   bool add_reserved_region(MemPointerRecord* rec);

   bool add_committed_region(MemPointerRecord* rec);

   bool remove_uncommitted_region(MemPointerRecord* rec);

   bool remove_released_region(MemPointerRecord* rec);

   // split a reserved region to create a new memory region with specified base and size

   bool split_reserved_region(VMMemRegion* rgn, address new_rgn_addr, size_t new_rgn_size);

  private:

   bool insert_record(MemPointerRecord* rec);

   bool insert_record_after(MemPointerRecord* rec);

   bool insert_reserved_region(MemPointerRecord* rec);

   // reset current position

   inline void reset() { _pos = 0; }

 #ifdef ASSERT

   // check integrity of records on current reserved memory region.

   bool check_reserved_region() {

     VMMemRegion* reserved_region = (VMMemRegion*)current();

     assert(reserved_region != NULL && reserved_region->is_reserved_region(),

           "Sanity check");

     // all committed regions that follow current reserved region, should all

     // belong to the reserved region.

     VMMemRegion* next_region = (VMMemRegion*)next();

     for (; next_region != NULL && next_region->is_committed_region();

          next_region = (VMMemRegion*)next() ) {

       if(!reserved_region->contains_region(next_region)) {

         return false;

       }

     }

     return true;

   }

   virtual bool is_dup_pointer(const MemPointer* ptr1,

     const MemPointer* ptr2) const {

     VMMemRegion* p1 = (VMMemRegion*)ptr1;

     VMMemRegion* p2 = (VMMemRegion*)ptr2;

     if (p1->addr() != p2->addr()) return false;

     if ((p1->flags() & MemPointerRecord::tag_masks) !=

         (p2->flags() & MemPointerRecord::tag_masks)) {

       return false;

     }

     // we do see multiple commit/uncommit on the same memory, it is ok

     return (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_alloc ||

            (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_release;

   }

 #endif

 };

 class MallocRecordIterator : public MemPointerArrayIterator {

  private:

   MemPointerArrayIteratorImpl  _itr;

  public:

   MallocRecordIterator(MemPointerArray* arr) : _itr(arr) {

   }

   virtual MemPointer* current() const {

 #ifdef ASSERT

     MemPointer* cur_rec = _itr.current();

     if (cur_rec != NULL) {

       MemPointer* prev_rec = _itr.peek_prev();

       MemPointer* next_rec = _itr.peek_next();

       assert(prev_rec == NULL || prev_rec->addr() < cur_rec->addr(), "Sorting order");

       assert(next_rec == NULL || next_rec->addr() > cur_rec->addr(), "Sorting order");

     }

 #endif

     return _itr.current();

   }

   virtual MemPointer* next() {

     MemPointerRecord* next_rec = (MemPointerRecord*)_itr.next();

     // arena memory record is a special case, which we have to compare

     // sequence number against its associated arena record.

     if (next_rec != NULL && next_rec->is_arena_memory_record()) {

       MemPointerRecord* prev_rec = (MemPointerRecord*)_itr.peek_prev();

       // if there is an associated arena record, it has to be previous

       // record because of sorting order (by address) - NMT generates a pseudo address

       // for arena's size record by offsetting arena's address, that guarantees

       // the order of arena record and it's size record.

       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(); }

   bool insert(MemPointer* ptr)       { ShouldNotReachHere(); return false; }

   bool insert_after(MemPointer* ptr) { ShouldNotReachHere(); return false; }

 };

 // collapse duplicated records. Eliminating duplicated records here, is much

 // 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 MemPointerArrayIterator {

  private:

   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(),

         "pre-sort order");

       if (is_duplicated_record(cur, next)) {

         _itr.next();

         next = (MemPointerRecord*)_itr.peek_next();

       } else {

         break;

       }

     }

   }

   virtual MemPointer* current() const {

     return _itr.current();

   }

   // get next record, but skip the duplicated records

   virtual MemPointer* next() {

     MemPointerRecord* cur = (MemPointerRecord*)_itr.next();

     MemPointerRecord* next = (MemPointerRecord*)_itr.peek_next();

     while (next != NULL) {

       assert(cur != NULL, "Sanity check");

       assert(((SeqMemPointerRecord*)next)->seq() > ((SeqMemPointerRecord*)cur)->seq(),

         "pre-sort order");

       if (is_duplicated_record(cur, next)) {

         _itr.next();

         cur = next;

         next = (MemPointerRecord*)_itr.peek_next();

       } else {

         break;

       }

     }

     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;

   }

 };

 class StagingArea VALUE_OBJ_CLASS_SPEC {

  private:

   MemPointerArray*   _malloc_data;

   MemPointerArray*   _vm_data;

  public:

   StagingArea() : _malloc_data(NULL), _vm_data(NULL) {

     init();

   }

   ~StagingArea() {

     if (_malloc_data != NULL) delete _malloc_data;

     if (_vm_data != NULL) delete _vm_data;

   }

   MallocRecordIterator malloc_record_walker() {

     return MallocRecordIterator(malloc_data());

   }

   VMRecordIterator virtual_memory_record_walker();

   bool init();

   void clear() {

     assert(_malloc_data != NULL && _vm_data != NULL, "Just check");

     _malloc_data->shrink();

     _malloc_data->clear();

     _vm_data->clear();

   }

   inline MemPointerArray* malloc_data() { return _malloc_data; }

   inline MemPointerArray* vm_data()     { return _vm_data; }

 };

 class MemBaseline;

 class MemSnapshot : public CHeapObj<mtNMT> {

  private:

   // the following two arrays contain records of all known lived memory blocks

   // live malloc-ed memory pointers

   MemPointerArray*      _alloc_ptrs;

   // live virtual memory pointers

   MemPointerArray*      _vm_ptrs;

   StagingArea           _staging_area;

   // the lock to protect this snapshot

   Monitor*              _lock;

   // the number of instance classes

   int                   _number_of_classes;

   NOT_PRODUCT(size_t    _untracked_count;)

   friend class MemBaseline;

  public:

   MemSnapshot();

   virtual ~MemSnapshot();

   // if we are running out of native memory

   bool out_of_memory() {

     return (_alloc_ptrs == NULL ||

       _staging_area.malloc_data() == NULL ||

       _staging_area.vm_data() == NULL ||

       _vm_ptrs == NULL || _lock == NULL ||

       _alloc_ptrs->out_of_memory() ||

       _vm_ptrs->out_of_memory());

   }

   // merge a per-thread memory recorder into staging area

   bool merge(MemRecorder* rec);

   // promote staged data to snapshot

   bool promote(int number_of_classes);

   int  number_of_classes() const { return _number_of_classes; }

   void wait(long timeout) {

     assert(_lock != NULL, "Just check");

     MonitorLockerEx locker(_lock);

     locker.wait(true, timeout);

   }

   NOT_PRODUCT(void print_snapshot_stats(outputStream* st);)

   NOT_PRODUCT(void check_staging_data();)

   NOT_PRODUCT(void check_malloc_pointers();)

   NOT_PRODUCT(bool has_allocation_record(address addr);)

   // dump all virtual memory pointers in snapshot

   DEBUG_ONLY( void dump_all_vm_pointers();)

  private:

    // copy sequenced pointer from src to dest

    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);

 };

 #endif // SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP