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_BASELINE_HPP

 #define SHARE_VM_SERVICES_MEM_BASELINE_HPP

 #include "memory/allocation.hpp"

 #include "runtime/mutex.hpp"

 #include "services/memPtr.hpp"

 #include "services/memSnapshot.hpp"

 // compare unsigned number

 #define UNSIGNED_COMPARE(a, b)  ((a > b) ? 1 : ((a == b) ? 0 : -1))

 /*

  * MallocCallsitePointer and VMCallsitePointer are used

  * to baseline memory blocks with their callsite information.

  * They are only available when detail tracking is turned

  * on.

  */

 /* baselined malloc record aggregated by callsite */

 class MallocCallsitePointer : public MemPointer {

  private:

   size_t    _count;   // number of malloc invocation from this callsite

   size_t    _amount;  // total amount of memory malloc-ed from this callsite

  public:

   MallocCallsitePointer() {

     _count = 0;

     _amount = 0;

   }

   MallocCallsitePointer(address pc) : MemPointer(pc) {

     _count = 0;

     _amount = 0;

   }

   MallocCallsitePointer& operator=(const MallocCallsitePointer& p) {

     MemPointer::operator=(p);

     _count = p.count();

     _amount = p.amount();

     return *this;

   }

   inline void inc(size_t size) {

     _count ++;

     _amount += size;

   };

   inline size_t count() const {

     return _count;

   }

   inline size_t amount() const {

     return _amount;

   }

 };

 // baselined virtual memory record aggregated by callsite

 class VMCallsitePointer : public MemPointer {

  private:

   size_t     _count;              // number of invocation from this callsite

   size_t     _reserved_amount;    // total reserved amount

   size_t     _committed_amount;   // total committed amount

  public:

   VMCallsitePointer() {

     _count = 0;

     _reserved_amount = 0;

     _committed_amount = 0;

   }

   VMCallsitePointer(address pc) : MemPointer(pc) {

     _count = 0;

     _reserved_amount = 0;

     _committed_amount = 0;

   }

   VMCallsitePointer& operator=(const VMCallsitePointer& p) {

     MemPointer::operator=(p);

     _count = p.count();

     _reserved_amount = p.reserved_amount();

     _committed_amount = p.committed_amount();

     return *this;

   }

   inline void inc(size_t reserved, size_t committed) {

     _count ++;

     _reserved_amount += reserved;

     _committed_amount += committed;

   }

   inline size_t count() const {

     return _count;

   }

   inline size_t reserved_amount() const {

     return _reserved_amount;

   }

   inline size_t committed_amount() const {

     return _committed_amount;

   }

 };

 // maps a memory type flag to readable name

 typedef struct _memType2Name {

   MEMFLAGS     _flag;

   const char*  _name;

 } MemType2Name;

 // This class aggregates malloc'd records by memory type

 class MallocMem : public _ValueObj {

  private:

   MEMFLAGS       _type;

   size_t         _count;

   size_t         _amount;

  public:

   MallocMem() {

     _type = mtNone;

     _count = 0;

     _amount = 0;

   }

   MallocMem(MEMFLAGS flags) {

     assert(HAS_VALID_MEMORY_TYPE(flags), "no type");

     _type = FLAGS_TO_MEMORY_TYPE(flags);

     _count = 0;

     _amount = 0;

   }

   inline void set_type(MEMFLAGS flag) {

     _type = flag;

   }

   inline void clear() {

     _count = 0;

     _amount = 0;

     _type = mtNone;

   }

   MallocMem& operator=(const MallocMem& m) {

     assert(_type == m.type(), "different type");

     _count = m.count();

     _amount = m.amount();

     return *this;

   }

   inline void inc(size_t amt) {

     _amount += amt;

     _count ++;

   }

   inline void reduce(size_t amt) {

     assert(_amount >= amt, "Just check");

     _amount -= amt;

   }

   inline void overwrite_counter(size_t count) {

     _count = count;

   }

   inline MEMFLAGS type() const {

     return _type;

   }

   inline bool is_type(MEMFLAGS flags) const {

     return FLAGS_TO_MEMORY_TYPE(flags) == _type;

   }

   inline size_t count() const {

     return _count;

   }

   inline size_t amount() const {

     return _amount;

   }

 };

 // This class records live arena's memory usage

 class ArenaMem : public MallocMem {

  public:

   ArenaMem(MEMFLAGS typeflag): MallocMem(typeflag) {

   }

   ArenaMem() { }

 };

 // This class aggregates virtual memory by its memory type

 class VMMem : public _ValueObj {

  private:

   MEMFLAGS       _type;

   size_t         _count;

   size_t         _reserved_amount;

   size_t         _committed_amount;

  public:

   VMMem() {

     _type = mtNone;

     _count = 0;

     _reserved_amount = 0;

     _committed_amount = 0;

   }

   VMMem(MEMFLAGS flags) {

     assert(HAS_VALID_MEMORY_TYPE(flags), "no type");

     _type = FLAGS_TO_MEMORY_TYPE(flags);

     _count = 0;

     _reserved_amount = 0;

     _committed_amount = 0;

   }

   inline void clear() {

     _type = mtNone;

     _count = 0;

     _reserved_amount = 0;

     _committed_amount = 0;

   }

   inline void set_type(MEMFLAGS flags) {

     _type = FLAGS_TO_MEMORY_TYPE(flags);

   }

   VMMem& operator=(const VMMem& m) {

     assert(_type == m.type(), "different type");

     _count = m.count();

     _reserved_amount = m.reserved_amount();

     _committed_amount = m.committed_amount();

     return *this;

   }

   inline MEMFLAGS type() const {

     return _type;

   }

   inline bool is_type(MEMFLAGS flags) const {

     return FLAGS_TO_MEMORY_TYPE(flags) == _type;

   }

   inline void inc(size_t reserved_amt, size_t committed_amt) {

     _reserved_amount += reserved_amt;

     _committed_amount += committed_amt;

     _count ++;

   }

   inline size_t count() const {

     return _count;

   }

   inline size_t reserved_amount() const {

     return _reserved_amount;

   }

   inline size_t committed_amount() const {

     return _committed_amount;

   }

 };

 #define NUMBER_OF_MEMORY_TYPE    (mt_number_of_types + 1)

 class BaselineReporter;

 class BaselineComparisonReporter;

 /*

  * This class baselines current memory snapshot.

  * A memory baseline summarizes memory usage by memory type,

  * aggregates memory usage by callsites when detail tracking

  * is on.

  */

 class MemBaseline : public _ValueObj {

   friend class BaselineReporter;

   friend class BaselineComparisonReporter;

  private:

   // overall summaries

   size_t        _total_malloced;

   size_t        _total_vm_reserved;

   size_t        _total_vm_committed;

   size_t        _number_of_classes;

   size_t        _number_of_threads;

   // if it has properly baselined

   bool          _baselined;

   // we categorize memory into three categories within the memory type

   MallocMem     _malloc_data[NUMBER_OF_MEMORY_TYPE];

   VMMem         _vm_data[NUMBER_OF_MEMORY_TYPE];

   ArenaMem      _arena_data[NUMBER_OF_MEMORY_TYPE];

   // memory records that aggregate memory usage by callsites.

   // only available when detail tracking is on.

   MemPointerArray*  _malloc_cs;

   MemPointerArray*  _vm_cs;

   // virtual memory map

   MemPointerArray*  _vm_map;

  private:

   static MemType2Name  MemType2NameMap[NUMBER_OF_MEMORY_TYPE];

  private:

   // should not use copy constructor

   MemBaseline(MemBaseline& copy) { ShouldNotReachHere(); }

  public:

   // create a memory baseline

   MemBaseline();

   virtual ~MemBaseline();

   inline bool baselined() const {

     return _baselined;

   }

   MemBaseline& operator=(const MemBaseline& other);

   // reset the baseline for reuse

   void clear();

   // baseline the snapshot

   bool baseline(MemSnapshot& snapshot, bool summary_only = true);

   bool baseline(const MemPointerArray* malloc_records,

                 const MemPointerArray* vm_records,

                 bool summary_only = true);

   // total malloc'd memory of specified memory type

   inline size_t malloc_amount(MEMFLAGS flag) const {

     return _malloc_data[flag2index(flag)].amount();

   }

   // number of malloc'd memory blocks of specified memory type

   inline size_t malloc_count(MEMFLAGS flag) const {

     return _malloc_data[flag2index(flag)].count();

   }

   // total memory used by arenas of specified memory type

   inline size_t arena_amount(MEMFLAGS flag) const {

     return _arena_data[flag2index(flag)].amount();

   }

   // number of arenas of specified memory type

   inline size_t arena_count(MEMFLAGS flag) const {

     return _arena_data[flag2index(flag)].count();

   }

   // total reserved memory of specified memory type

   inline size_t reserved_amount(MEMFLAGS flag) const {

     return _vm_data[flag2index(flag)].reserved_amount();

   }

   // total committed memory of specified memory type

   inline size_t committed_amount(MEMFLAGS flag) const {

     return _vm_data[flag2index(flag)].committed_amount();

   }

   // total memory (malloc'd + mmap'd + arena) of specified

   // memory type

   inline size_t total_amount(MEMFLAGS flag) const {

     int index = flag2index(flag);

     return _malloc_data[index].amount() +

            _vm_data[index].reserved_amount() +

            _arena_data[index].amount();

   }

   /* overall summaries */

   // total malloc'd memory in snapshot

   inline size_t total_malloc_amount() const {

     return _total_malloced;

   }

   // total mmap'd memory in snapshot

   inline size_t total_reserved_amount() const {

     return _total_vm_reserved;

   }

   // total committed memory in snapshot

   inline size_t total_committed_amount() const {

     return _total_vm_committed;

   }

   // number of loaded classes

   inline size_t number_of_classes() const {

     return _number_of_classes;

   }

   // number of running threads

   inline size_t number_of_threads() const {

     return _number_of_threads;

   }

   // lookup human readable name of a memory type

   static const char* type2name(MEMFLAGS type);

  private:

   // convert memory flag to the index to mapping table

   int         flag2index(MEMFLAGS flag) const;

   // reset baseline values

   void reset();

   // summarize the records in global snapshot

   bool baseline_malloc_summary(const MemPointerArray* malloc_records);

   bool baseline_vm_summary(const MemPointerArray* vm_records);

   bool baseline_malloc_details(const MemPointerArray* malloc_records);

   bool baseline_vm_details(const MemPointerArray* vm_records);

   // print a line of malloc'd memory aggregated by callsite

   void print_malloc_callsite(outputStream* st, address pc, size_t size,

     size_t count, int diff_amt, int diff_count) const;

   // print a line of mmap'd memory aggregated by callsite

   void print_vm_callsite(outputStream* st, address pc, size_t rsz,

     size_t csz, int diff_rsz, int diff_csz) const;

   // sorting functions for raw records

   static int malloc_sort_by_pc(const void* p1, const void* p2);

   static int malloc_sort_by_addr(const void* p1, const void* p2);

  private:

   // sorting functions for baselined records

   static int bl_malloc_sort_by_size(const void* p1, const void* p2);

   static int bl_vm_sort_by_size(const void* p1, const void* p2);

   static int bl_malloc_sort_by_pc(const void* p1, const void* p2);

   static int bl_vm_sort_by_pc(const void* p1, const void* p2);

 };

 #endif // SHARE_VM_SERVICES_MEM_BASELINE_HPP