1 /*

     2  * Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  *

    23  */

    24 

    25 #ifndef SHARE_VM_SERVICES_MEM_TRACKER_HPP

    26 #define SHARE_VM_SERVICES_MEM_TRACKER_HPP

    27 

    28 #include "services/nmtCommon.hpp"

    29 #include "utilities/nativeCallStack.hpp"

    30 

    31 

    32 #if !INCLUDE_NMT

    33 

    34 #define CURRENT_PC   NativeCallStack::EMPTY_STACK

    35 #define CALLER_PC    NativeCallStack::EMPTY_STACK

    36 

    37 class Tracker : public StackObj {

    38  public:

    39   Tracker() { }

    40   void record(address addr, size_t size) { }

    41 };

    42 

    43 class MemTracker : AllStatic {

    44  public:

    45   static inline NMT_TrackingLevel tracking_level() { return NMT_off; }

    46   static inline void shutdown() { }

    47   static inline void init() { }

    48   static bool check_launcher_nmt_support(const char* value) { return true; }

    49   static bool verify_nmt_option() { return true; }

    50 

    51   static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,

    52     const NativeCallStack& stack, NMT_TrackingLevel level) { return mem_base; }

    53   static inline size_t malloc_header_size(NMT_TrackingLevel level) { return 0; }

    54   static inline size_t malloc_header_size(void* memblock) { return 0; }

    55   static inline void* malloc_base(void* memblock) { return memblock; }

    56   static inline void* record_free(void* memblock) { return memblock; }

    57 

    58   static inline void record_new_arena(MEMFLAGS flag) { }

    59   static inline void record_arena_free(MEMFLAGS flag) { }

    60   static inline void record_arena_size_change(int diff, MEMFLAGS flag) { }

    61   static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,

    62                        MEMFLAGS flag = mtNone) { }

    63   static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,

    64     const NativeCallStack& stack, MEMFLAGS flag = mtNone) { }

    65   static inline void record_virtual_memory_commit(void* addr, size_t size, const NativeCallStack& stack) { }

    66   static inline Tracker get_virtual_memory_uncommit_tracker() { return Tracker(); }

    67   static inline Tracker get_virtual_memory_release_tracker() { return Tracker(); }

    68   static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) { }

    69   static inline void record_thread_stack(void* addr, size_t size) { }

    70   static inline void release_thread_stack(void* addr, size_t size) { }

    71 

    72   static void final_report(outputStream*) { }

    73   static void error_report(outputStream*) { }

    74 };

    75 

    76 #else

    77 

    78 #include "runtime/threadCritical.hpp"

    79 #include "services/mallocTracker.hpp"

    80 #include "services/virtualMemoryTracker.hpp"

    81 

    82 extern volatile bool NMT_stack_walkable;

    83 

    84 #define CURRENT_PC ((MemTracker::tracking_level() == NMT_detail && NMT_stack_walkable) ? \

    85                     NativeCallStack(0, true) : NativeCallStack::EMPTY_STACK)

    86 #define CALLER_PC  ((MemTracker::tracking_level() == NMT_detail && NMT_stack_walkable) ?  \

    87                     NativeCallStack(1, true) : NativeCallStack::EMPTY_STACK)

    88 

    89 class MemBaseline;

    90 class Mutex;

    91 

    92 // Tracker is used for guarding 'release' semantics of virtual memory operation, to avoid

    93 // the other thread obtains and records the same region that is just 'released' by current

    94 // thread but before it can record the operation.

    95 class Tracker : public StackObj {

    96  public:

    97   enum TrackerType {

    98      uncommit,

    99      release

   100   };

   101 

   102  public:

   103   Tracker(enum TrackerType type) : _type(type) { }

   104   void record(address addr, size_t size);

   105  private:

   106   enum TrackerType  _type;

   107   // Virtual memory tracking data structures are protected by ThreadCritical lock.

   108   ThreadCritical    _tc;

   109 };

   110 

   111 class MemTracker : AllStatic {

   112  public:

   113   static inline NMT_TrackingLevel tracking_level() {

   114     if (_tracking_level == NMT_unknown) {

   115       // No fencing is needed here, since JVM is in single-threaded

   116       // mode.

   117       _tracking_level = init_tracking_level();

   118       _cmdline_tracking_level = _tracking_level;

   119     }

   120     return _tracking_level;

   121   }

   122 

   123   // A late initialization, for the stuff(s) can not be

   124   // done in init_tracking_level(), which can NOT malloc

   125   // any memory.

   126   static void init();

   127 

   128   // Shutdown native memory tracking

   129   static void shutdown();

   130 

   131   // Verify native memory tracking command line option.

   132   // This check allows JVM to detect if compatible launcher

   133   // is used.

   134   // If an incompatible launcher is used, NMT may not be

   135   // able to start, even it is enabled by command line option.

   136   // A warning message should be given if it is encountered.

   137   static bool check_launcher_nmt_support(const char* value);

   138 

   139   // This method checks native memory tracking environment

   140   // variable value passed by launcher.

   141   // Launcher only obligated to pass native memory tracking

   142   // option value, but not obligated to validate the value,

   143   // and launcher has option to discard native memory tracking

   144   // option from the command line once it sets up the environment

   145   // variable, so NMT has to catch the bad value here.

   146   static bool verify_nmt_option();

   147 

   148   // Transition the tracking level to specified level

   149   static bool transition_to(NMT_TrackingLevel level);

   150 

   151   static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,

   152     const NativeCallStack& stack, NMT_TrackingLevel level) {

   153     return MallocTracker::record_malloc(mem_base, size, flag, stack, level);

   154   }

   155 

   156   static inline size_t malloc_header_size(NMT_TrackingLevel level) {

   157     return MallocTracker::malloc_header_size(level);

   158   }

   159 

   160   static size_t malloc_header_size(void* memblock) {

   161     if (tracking_level() != NMT_off) {

   162       return MallocTracker::get_header_size(memblock);

   163     }

   164     return 0;

   165   }

   166 

   167   // To malloc base address, which is the starting address

   168   // of malloc tracking header if tracking is enabled.

   169   // Otherwise, it returns the same address.

   170   static void* malloc_base(void* memblock);

   171 

   172   // Record malloc free and return malloc base address

   173   static inline void* record_free(void* memblock) {

   174     return MallocTracker::record_free(memblock);

   175   }

   176 

   177 

   178   // Record creation of an arena

   179   static inline void record_new_arena(MEMFLAGS flag) {

   180     if (tracking_level() < NMT_summary) return;

   181     MallocTracker::record_new_arena(flag);

   182   }

   183 

   184   // Record destruction of an arena

   185   static inline void record_arena_free(MEMFLAGS flag) {

   186     if (tracking_level() < NMT_summary) return;

   187     MallocTracker::record_arena_free(flag);

   188   }

   189 

   190   // Record arena size change. Arena size is the size of all arena

   191   // chuncks that backing up the arena.

   192   static inline void record_arena_size_change(int diff, MEMFLAGS flag) {

   193     if (tracking_level() < NMT_summary) return;

   194     MallocTracker::record_arena_size_change(diff, flag);

   195   }

   196 

   197   static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,

   198     MEMFLAGS flag = mtNone) {

   199     if (tracking_level() < NMT_summary) return;

   200     if (addr != NULL) {

   201       ThreadCritical tc;

   202       // Recheck to avoid potential racing during NMT shutdown

   203       if (tracking_level() < NMT_summary) return;

   204       VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);

   205     }

   206   }

   207 

   208   static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,

   209     const NativeCallStack& stack, MEMFLAGS flag = mtNone) {

   210     if (tracking_level() < NMT_summary) return;

   211     if (addr != NULL) {

   212       ThreadCritical tc;

   213       if (tracking_level() < NMT_summary) return;

   214       VirtualMemoryTracker::add_reserved_region((address)addr, size,

   215         stack, flag, true);

   216       VirtualMemoryTracker::add_committed_region((address)addr, size, stack);

   217     }

   218   }

   219 

   220   static inline void record_virtual_memory_commit(void* addr, size_t size,

   221     const NativeCallStack& stack) {

   222     if (tracking_level() < NMT_summary) return;

   223     if (addr != NULL) {

   224       ThreadCritical tc;

   225       if (tracking_level() < NMT_summary) return;

   226       VirtualMemoryTracker::add_committed_region((address)addr, size, stack);

   227     }

   228   }

   229 

   230   static inline Tracker get_virtual_memory_uncommit_tracker() {

   231     assert(tracking_level() >= NMT_summary, "Check by caller");

   232     return Tracker(Tracker::uncommit);

   233   }

   234 

   235   static inline Tracker get_virtual_memory_release_tracker() {

   236     assert(tracking_level() >= NMT_summary, "Check by caller");

   237     return Tracker(Tracker::release);

   238   }

   239 

   240   static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) {

   241     if (tracking_level() < NMT_summary) return;

   242     if (addr != NULL) {

   243       ThreadCritical tc;

   244       if (tracking_level() < NMT_summary) return;

   245       VirtualMemoryTracker::set_reserved_region_type((address)addr, flag);

   246     }

   247   }

   248 

   249   static inline void record_thread_stack(void* addr, size_t size) {

   250     if (tracking_level() < NMT_summary) return;

   251     if (addr != NULL) {

   252       // uses thread stack malloc slot for book keeping number of threads

   253       MallocMemorySummary::record_malloc(0, mtThreadStack);

   254       record_virtual_memory_reserve_and_commit(addr, size, CALLER_PC, mtThreadStack);

   255     }

   256   }

   257 

   258   static inline void release_thread_stack(void* addr, size_t size) {

   259     if (tracking_level() < NMT_summary) return;

   260     if (addr != NULL) {

   261       // uses thread stack malloc slot for book keeping number of threads

   262       MallocMemorySummary::record_free(0, mtThreadStack);

   263       ThreadCritical tc;

   264       if (tracking_level() < NMT_summary) return;

   265       VirtualMemoryTracker::remove_released_region((address)addr, size);

   266     }

   267   }

   268 

   269   // Query lock is used to synchronize the access to tracking data.

   270   // So far, it is only used by JCmd query, but it may be used by

   271   // other tools.

   272   static inline Mutex* query_lock() { return _query_lock; }

   273 

   274   // Make a final report or report for hs_err file.

   275   static void error_report(outputStream* output) {

   276     if (tracking_level() >= NMT_summary) {

   277       report(true, output);  // just print summary for error case.

   278     }

   279    }

   280 

   281   static void final_report(outputStream* output) {

   282     NMT_TrackingLevel level = tracking_level();

   283     if (level >= NMT_summary) {

   284       report(level == NMT_summary, output);

   285     }

   286   }

   287 

   288 

   289   // Stored baseline

   290   static inline MemBaseline& get_baseline() {

   291     return _baseline;

   292   }

   293 

   294   static NMT_TrackingLevel cmdline_tracking_level() {

   295     return _cmdline_tracking_level;

   296   }

   297 

   298   static void tuning_statistics(outputStream* out);

   299 

   300  private:

   301   static NMT_TrackingLevel init_tracking_level();

   302   static void report(bool summary_only, outputStream* output);

   303 

   304  private:

   305   // Tracking level

   306   static volatile NMT_TrackingLevel   _tracking_level;

   307   // If NMT option value passed by launcher through environment

   308   // variable is valid

   309   static bool                         _is_nmt_env_valid;

   310   // command line tracking level

   311   static NMT_TrackingLevel            _cmdline_tracking_level;

   312   // Stored baseline

   313   static MemBaseline      _baseline;

   314   // Query lock

   315   static Mutex*           _query_lock;

   316 };

   317 

   318 #endif // INCLUDE_NMT

   319 

   320 #endif // SHARE_VM_SERVICES_MEM_TRACKER_HPP

   321