jdk8-mips64-public/hotspot: src/share/vm/services/memTracker.hpp@833b0f92429a (annotated)

src/share/vm/services/memTracker.hpp@833b0f92429a (annotated)

src/share/vm/services/memTracker.hpp

Wed, 27 Aug 2014 08:19:12 -0400

author: zgu
date: Wed, 27 Aug 2014 08:19:12 -0400
changeset 7074: 833b0f92429a
parent 5578: 4c84d351cca9
child 7078: c6211b707068
permissions: -rw-r--r--

8046598: Scalable Native memory tracking development
Summary: Enhance scalability of native memory tracking
Reviewed-by: coleenp, ctornqvi, gtriantafill

 /*
  * Copyright (c) 2013, 2014, 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_TRACKER_HPP
 #define SHARE_VM_SERVICES_MEM_TRACKER_HPP
 #include "services/nmtCommon.hpp"
 class NativeCallStack;
 extern NativeCallStack emptyStack;
 #if !INCLUDE_NMT
 #define CURRENT_PC   emptyStack
 #define CALLER_PC    emptyStack
 class Tracker : public StackObj {
  public:
   Tracker() { }
   void record(address addr, size_t size) { }
 };
 class MemTracker : AllStatic {
  public:
   static inline NMT_TrackingLevel tracking_level() { return NMT_off; }
   static inline void shutdown() { }
   static inline void init() { }
   static bool check_launcher_nmt_support(const char* value) { return true; }
   static bool verify_nmt_option() { return true; }
   static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,
     const NativeCallStack& stack, NMT_TrackingLevel level) { return mem_base; }
   static inline size_t malloc_header_size(NMT_TrackingLevel level) { return 0; }
   static inline size_t malloc_header_size(void* memblock) { return 0; }
   static inline void* malloc_base(void* memblock) { return memblock; }
   static inline void* record_free(void* memblock) { return memblock; }
   static inline void record_new_arena(MEMFLAGS flag) { }
   static inline void record_arena_free(MEMFLAGS flag) { }
   static inline void record_arena_size_change(int diff, MEMFLAGS flag) { }
   static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
                        MEMFLAGS flag = mtNone) { }
   static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
     const NativeCallStack& stack, MEMFLAGS flag = mtNone) { }
   static inline void record_virtual_memory_commit(void* addr, size_t size, const NativeCallStack& stack) { }
   static inline Tracker get_virtual_memory_uncommit_tracker() { return Tracker(); }
   static inline Tracker get_virtual_memory_release_tracker() { }
   static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) { }
   static inline void record_thread_stack(void* addr, size_t size) { }
   static inline void release_thread_stack(void* addr, size_t size) { }
   static void final_report(outputStream*) { }
 };
 #else
 #include "runtime/atomic.hpp"
 #include "runtime/threadCritical.hpp"
 #include "services/mallocTracker.hpp"
 #include "services/virtualMemoryTracker.hpp"
 extern volatile bool NMT_stack_walkable;
 #define CURRENT_PC ((MemTracker::tracking_level() == NMT_detail && NMT_stack_walkable) ? \
                     NativeCallStack(0, true) : emptyStack)
 #define CALLER_PC  ((MemTracker::tracking_level() == NMT_detail && NMT_stack_walkable) ?  \
                     NativeCallStack(1, true) : emptyStack)
 class MemBaseline;
 class Mutex;
 // Tracker is used for guarding 'release' semantics of virtual memory operation, to avoid
 // the other thread obtains and records the same region that is just 'released' by current
 // thread but before it can record the operation.
 class Tracker : public StackObj {
  public:
   enum TrackerType {
      uncommit,
      release
   };
  public:
   Tracker(enum TrackerType type) : _type(type) { }
   void record(address addr, size_t size);
  private:
   enum TrackerType  _type;
   // Virtual memory tracking data structures are protected by ThreadCritical lock.
   ThreadCritical    _tc;
 };
 class MemTracker : AllStatic {
  public:
   static inline NMT_TrackingLevel tracking_level() {
     if (_tracking_level == NMT_unknown) {
       // No fencing is needed here, since JVM is in single-threaded
       // mode.
       _tracking_level = init_tracking_level();
       _cmdline_tracking_level = _tracking_level;
     }
     return _tracking_level;
   }
   // A late initialization, for the stuff(s) can not be
   // done in init_tracking_level(), which can NOT malloc
   // any memory.
   static void init();
   // Shutdown native memory tracking
   static void shutdown();
   // Verify native memory tracking command line option.
   // This check allows JVM to detect if compatible launcher
   // is used.
   // If an incompatible launcher is used, NMT may not be
   // able to start, even it is enabled by command line option.
   // A warning message should be given if it is encountered.
   static bool check_launcher_nmt_support(const char* value);
   // This method checks native memory tracking environment
   // variable value passed by launcher.
   // Launcher only obligates to pass native memory tracking
   // option value, but not obligates to validate the value,
   // and launcher has option to discard native memory tracking
   // option from the command line once it sets up the environment
   // variable, so NMT has to catch the bad value here.
   static bool verify_nmt_option();
   // Transition the tracking level to specified level
   static bool transition_to(NMT_TrackingLevel level);
   static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,
     const NativeCallStack& stack, NMT_TrackingLevel level) {
     return MallocTracker::record_malloc(mem_base, size, flag, stack, level);
   }
   static inline size_t malloc_header_size(NMT_TrackingLevel level) {
     return MallocTracker::malloc_header_size(level);
   }
   static size_t malloc_header_size(void* memblock) {
     if (tracking_level() != NMT_off) {
       return MallocTracker::get_header_size(memblock);
     }
     return 0;
   }
   // To malloc base address, which is the starting address
   // of malloc tracking header if tracking is enabled.
   // Otherwise, it returns the same address.
   static void* malloc_base(void* memblock);
   // Record malloc free and return malloc base address
   static inline void* record_free(void* memblock) {
     return MallocTracker::record_free(memblock);
   }
   // Record creation of an arena
   static inline void record_new_arena(MEMFLAGS flag) {
     if (tracking_level() < NMT_summary) return;
     MallocTracker::record_new_arena(flag);
   }
   // Record destruction of an arena
   static inline void record_arena_free(MEMFLAGS flag) {
     if (tracking_level() < NMT_summary) return;
     MallocTracker::record_arena_free(flag);
   }
   // Record arena size change. Arena size is the size of all arena
   // chuncks that backing up the arena.
   static inline void record_arena_size_change(int diff, MEMFLAGS flag) {
     if (tracking_level() < NMT_summary) return;
     MallocTracker::record_arena_size_change(diff, flag);
   }
   static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
     MEMFLAGS flag = mtNone) {
     if (tracking_level() < NMT_summary) return;
     if (addr != NULL) {
       ThreadCritical tc;
       // Recheck to avoid potential racing during NMT shutdown
       if (tracking_level() < NMT_summary) return;
       VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
     }
   }
   static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
     const NativeCallStack& stack, MEMFLAGS flag = mtNone) {
     if (tracking_level() < NMT_summary) return;
     if (addr != NULL) {
       ThreadCritical tc;
       if (tracking_level() < NMT_summary) return;
       VirtualMemoryTracker::add_reserved_region((address)addr, size,
         stack, flag, true);
     }
   }
   static inline void record_virtual_memory_commit(void* addr, size_t size,
     const NativeCallStack& stack) {
     if (tracking_level() < NMT_summary) return;
     if (addr != NULL) {
       ThreadCritical tc;
       if (tracking_level() < NMT_summary) return;
       VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
     }
   }
   static inline Tracker get_virtual_memory_uncommit_tracker() {
     assert(tracking_level() >= NMT_summary, "Check by caller");
     return Tracker(Tracker::uncommit);
   }
   static inline Tracker get_virtual_memory_release_tracker() {
     assert(tracking_level() >= NMT_summary, "Check by caller");
     return Tracker(Tracker::release);
   }
   static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) {
     if (tracking_level() < NMT_summary) return;
     if (addr != NULL) {
       ThreadCritical tc;
       if (tracking_level() < NMT_summary) return;
       VirtualMemoryTracker::set_reserved_region_type((address)addr, flag);
     }
   }
   static inline void record_thread_stack(void* addr, size_t size) {
     if (tracking_level() < NMT_summary) return;
     if (addr != NULL) {
       // uses thread stack malloc slot for book keeping number of threads
       MallocMemorySummary::record_malloc(0, mtThreadStack);
       record_virtual_memory_reserve_and_commit(addr, size, CALLER_PC, mtThreadStack);
     }
   }
   static inline void release_thread_stack(void* addr, size_t size) {
     if (tracking_level() < NMT_summary) return;
     if (addr != NULL) {
       // uses thread stack malloc slot for book keeping number of threads
       MallocMemorySummary::record_free(0, mtThreadStack);
       ThreadCritical tc;
       if (tracking_level() < NMT_summary) return;
       VirtualMemoryTracker::remove_released_region((address)addr, size);
     }
   }
   // Query lock is used to synchronize the access to tracking data.
   // So far, it is only used by JCmd query, but it may be used by
   // other tools.
   static inline Mutex* query_lock() { return _query_lock; }
   // Make a final report and shutdown.
   // This function generates summary report without creating snapshots,
   // to avoid additional memory allocation. It uses native memory summary
   // counters, and makes adjustment to them, once the adjustment is made,
   // the counters are no longer accurate. As the result, this function
   // should only be used for final reporting before shutting down.
   static void final_report(outputStream*);
   // Stored baseline
   static inline MemBaseline& get_baseline() {
     return _baseline;
   }
   static NMT_TrackingLevel cmdline_tracking_level() {
     return _cmdline_tracking_level;
   }
   static void tuning_statistics(outputStream* out);
  private:
   static NMT_TrackingLevel init_tracking_level();
  private:
   // Tracking level
   static volatile NMT_TrackingLevel   _tracking_level;
   // If NMT option value passed by launcher through environment
   // variable is valid
   static bool                         _is_nmt_env_valid;
   // command line tracking level
   static NMT_TrackingLevel            _cmdline_tracking_level;
   // Stored baseline
   static MemBaseline      _baseline;
   // Query lock
   static Mutex*           _query_lock;
 };
 #endif // INCLUDE_NMT
 #endif // SHARE_VM_SERVICES_MEM_TRACKER_HPP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/services/memTracker.hpp@833b0f92429a (annotated)

src/share/vm/services/memTracker.hpp