1 /*
   2  * Copyright (c) 2019, Red Hat, Inc. All rights reserved.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This code is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * version 2 for more details (a copy is included in the LICENSE file that
  12  * accompanied this code).
  13  *
  14  * You should have received a copy of the GNU General Public License version
  15  * 2 along with this work; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  19  * or visit www.oracle.com if you need additional information or have any
  20  * questions.
  21  *
  22  */
  23 
  24 #include "precompiled.hpp"
  25 
  26 #include "runtime/threadCritical.hpp"
  27 #include "services/mallocTracker.hpp"
  28 #include "services/memTracker.hpp"
  29 #include "services/virtualMemoryTracker.hpp"
  30 #include "services/threadStackTracker.hpp"
  31 
  32 volatile size_t ThreadStackTracker::_thread_count = 0;
  33 SortedLinkedList<SimpleThreadStackSite, ThreadStackTracker::compare_thread_stack_base>* ThreadStackTracker::_simple_thread_stacks = NULL;
  34 
  35 bool ThreadStackTracker::late_initialize(NMT_TrackingLevel level) {
  36   if (level == NMT_detail && !track_as_vm()) {
  37     _simple_thread_stacks = new (std::nothrow, ResourceObj::C_HEAP, mtNMT)
  38       SortedLinkedList<SimpleThreadStackSite, ThreadStackTracker::compare_thread_stack_base>();
  39     return (_simple_thread_stacks != NULL);
  40   }
  41   return true;
  42 }
  43 
  44 bool ThreadStackTracker::transition(NMT_TrackingLevel from, NMT_TrackingLevel to) {
  45   assert (from != NMT_minimal, "cannot convert from the lowest tracking level to anything");
  46   if (to == NMT_minimal) {
  47     assert(from == NMT_summary || from == NMT_detail, "Just check");
  48     ThreadCritical tc;
  49     if (_simple_thread_stacks != NULL) {
  50       delete _simple_thread_stacks;
  51       _simple_thread_stacks = NULL;
  52     }
  53   }
  54   return true;
  55 }
  56 
  57 int ThreadStackTracker::compare_thread_stack_base(const SimpleThreadStackSite& s1, const SimpleThreadStackSite& s2) {
  58   return s1.base() - s2.base();
  59 }
  60 
  61 void ThreadStackTracker::new_thread_stack(void* base, size_t size, const NativeCallStack& stack) {
  62   assert(MemTracker::tracking_level() >= NMT_summary, "Must be");
  63   assert(base != NULL, "Should have been filtered");
  64   if (track_as_vm()) {
  65     ThreadCritical tc;
  66     VirtualMemoryTracker::add_reserved_region((address)base, size, stack, mtThreadStack);
  67     _thread_count ++;
  68   } else {
  69     // Use a slot in mallocMemorySummary for thread stack bookkeeping
  70     MallocMemorySummary::record_malloc(size, mtThreadStack);
  71     if (MemTracker::tracking_level() == NMT_detail) {
  72       ThreadCritical tc;
  73       assert(_simple_thread_stacks != NULL, "Must be initialized");
  74       SimpleThreadStackSite site((address)base, size, stack);
  75       _simple_thread_stacks->add(site);
  76     }
  77   }
  78 }
  79 
  80 void ThreadStackTracker::delete_thread_stack(void* base, size_t size) {
  81   assert(MemTracker::tracking_level() >= NMT_summary, "Must be");
  82   assert(base != NULL, "Should have been filtered");
  83   if(track_as_vm()) {
  84     ThreadCritical tc;
  85     VirtualMemoryTracker::remove_released_region((address)base, size);
  86     _thread_count--;
  87   } else {
  88     // Use a slot in mallocMemorySummary for thread stack bookkeeping
  89     MallocMemorySummary::record_free(size, mtThreadStack);
  90     if (MemTracker::tracking_level() == NMT_detail) {
  91       ThreadCritical tc;
  92       assert(_simple_thread_stacks != NULL, "Must be initialized");
  93       SimpleThreadStackSite site((address)base, size);
  94       bool removed = _simple_thread_stacks->remove(site);
  95       assert(removed, "Must exist");
  96     }
  97   }
  98 }
  99 
 100 bool ThreadStackTracker::walk_simple_thread_stack_site(MallocSiteWalker* walker) {
 101   if (!track_as_vm()) {
 102     LinkedListImpl<MallocSite> _sites;
 103     {
 104       ThreadCritical tc;
 105       assert(_simple_thread_stacks != NULL, "Must be initialized");
 106       LinkedListIterator<SimpleThreadStackSite> itr(_simple_thread_stacks->head());
 107       const SimpleThreadStackSite* ts = itr.next();
 108       // Consolidate sites and convert to MallocSites, so we can piggyback into
 109       // malloc snapshot
 110       while (ts != NULL) {
 111         MallocSite site(*ts->call_stack(), mtThreadStack);
 112         MallocSite* exist = _sites.find(site);
 113         if (exist != NULL) {
 114           exist->allocate(ts->size());
 115         } else {
 116           site.allocate(ts->size());
 117           _sites.add(site);
 118         }
 119         ts = itr.next();
 120       }
 121     }
 122 
 123     // Piggyback to malloc snapshot
 124     LinkedListIterator<MallocSite> site_itr(_sites.head());
 125     const MallocSite* s = site_itr.next();
 126     while (s != NULL) {
 127       walker->do_malloc_site(s);
 128       s = site_itr.next();
 129     }
 130   }
 131   return true;
 132 }