1 /*

     2  * Copyright (c) 2015, 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 #include "precompiled.hpp"

    26 #include "code/nmethod.hpp"

    27 #include "code/dependencies.hpp"

    28 #include "code/dependencyContext.hpp"

    29 #include "memory/resourceArea.hpp"

    30 #include "runtime/atomic.hpp"

    31 #include "runtime/perfData.hpp"

    32 #include "utilities/exceptions.hpp"

    33 

    34 PerfCounter* DependencyContext::_perf_total_buckets_allocated_count   = NULL;

    35 PerfCounter* DependencyContext::_perf_total_buckets_deallocated_count = NULL;

    36 PerfCounter* DependencyContext::_perf_total_buckets_stale_count       = NULL;

    37 PerfCounter* DependencyContext::_perf_total_buckets_stale_acc_count   = NULL;

    38 

    39 void dependencyContext_init() {

    40   DependencyContext::init();

    41 }

    42 

    43 void DependencyContext::init() {

    44   if (UsePerfData) {

    45     EXCEPTION_MARK;

    46     _perf_total_buckets_allocated_count =

    47         PerfDataManager::create_counter(SUN_CI, "nmethodBucketsAllocated", PerfData::U_Events, CHECK);

    48     _perf_total_buckets_deallocated_count =

    49         PerfDataManager::create_counter(SUN_CI, "nmethodBucketsDeallocated", PerfData::U_Events, CHECK);

    50     _perf_total_buckets_stale_count =

    51         PerfDataManager::create_counter(SUN_CI, "nmethodBucketsStale", PerfData::U_Events, CHECK);

    52     _perf_total_buckets_stale_acc_count =

    53         PerfDataManager::create_counter(SUN_CI, "nmethodBucketsStaleAccumulated", PerfData::U_Events, CHECK);

    54   }

    55 }

    56 

    57 //

    58 // Walk the list of dependent nmethods searching for nmethods which

    59 // are dependent on the changes that were passed in and mark them for

    60 // deoptimization.  Returns the number of nmethods found.

    61 //

    62 int DependencyContext::mark_dependent_nmethods(DepChange& changes) {

    63   int found = 0;

    64   for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {

    65     nmethod* nm = b->get_nmethod();

    66     // since dependencies aren't removed until an nmethod becomes a zombie,

    67     // the dependency list may contain nmethods which aren't alive.

    68     if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {

    69       if (TraceDependencies) {

    70         ResourceMark rm;

    71         tty->print_cr("Marked for deoptimization");

    72         changes.print();

    73         nm->print();

    74         nm->print_dependencies();

    75       }

    76       changes.mark_for_deoptimization(nm);

    77       found++;

    78     }

    79   }

    80   return found;

    81 }

    82 

    83 //

    84 // Add an nmethod to the dependency context.

    85 // It's possible that an nmethod has multiple dependencies on a klass

    86 // so a count is kept for each bucket to guarantee that creation and

    87 // deletion of dependencies is consistent.

    88 //

    89 void DependencyContext::add_dependent_nmethod(nmethod* nm, bool expunge) {

    90   assert_lock_strong(CodeCache_lock);

    91   for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {

    92     if (nm == b->get_nmethod()) {

    93       b->increment();

    94       return;

    95     }

    96   }

    97   set_dependencies(new nmethodBucket(nm, dependencies()));

    98   if (UsePerfData) {

    99     _perf_total_buckets_allocated_count->inc();

   100   }

   101   if (expunge) {

   102     // Remove stale entries from the list.

   103     expunge_stale_entries();

   104   }

   105 }

   106 

   107 //

   108 // Remove an nmethod dependency from the context.

   109 // Decrement count of the nmethod in the dependency list and, optionally, remove

   110 // the bucket completely when the count goes to 0.  This method must find

   111 // a corresponding bucket otherwise there's a bug in the recording of dependencies.

   112 // Can be called concurrently by parallel GC threads.

   113 //

   114 void DependencyContext::remove_dependent_nmethod(nmethod* nm, bool expunge) {

   115   assert_locked_or_safepoint(CodeCache_lock);

   116   nmethodBucket* first = dependencies();

   117   nmethodBucket* last = NULL;

   118   for (nmethodBucket* b = first; b != NULL; b = b->next()) {

   119     if (nm == b->get_nmethod()) {

   120       int val = b->decrement();

   121       guarantee(val >= 0, "Underflow: %d", val);

   122       if (val == 0) {

   123         if (expunge) {

   124           if (last == NULL) {

   125             set_dependencies(b->next());

   126           } else {

   127             last->set_next(b->next());

   128           }

   129           delete b;

   130           if (UsePerfData) {

   131             _perf_total_buckets_deallocated_count->inc();

   132           }

   133         } else {

   134           // Mark the context as having stale entries, since it is not safe to

   135           // expunge the list right now.

   136           set_has_stale_entries(true);

   137           if (UsePerfData) {

   138             _perf_total_buckets_stale_count->inc();

   139             _perf_total_buckets_stale_acc_count->inc();

   140           }

   141         }

   142       }

   143       if (expunge) {

   144         // Remove stale entries from the list.

   145         expunge_stale_entries();

   146       }

   147       return;

   148     }

   149     last = b;

   150   }

   151 #ifdef ASSERT

   152   tty->print_raw_cr("### can't find dependent nmethod");

   153   nm->print();

   154 #endif // ASSERT

   155   ShouldNotReachHere();

   156 }

   157 

   158 //

   159 // Reclaim all unused buckets.

   160 //

   161 void DependencyContext::expunge_stale_entries() {

   162   assert_locked_or_safepoint(CodeCache_lock);

   163   if (!has_stale_entries()) {

   164     assert(!find_stale_entries(), "inconsistent info");

   165     return;

   166   }

   167   nmethodBucket* first = dependencies();

   168   nmethodBucket* last = NULL;

   169   int removed = 0;

   170   for (nmethodBucket* b = first; b != NULL;) {

   171     assert(b->count() >= 0, "bucket count: %d", b->count());

   172     nmethodBucket* next = b->next();

   173     if (b->count() == 0) {

   174       if (last == NULL) {

   175         first = next;

   176       } else {

   177         last->set_next(next);

   178       }

   179       removed++;

   180       delete b;

   181       // last stays the same.

   182     } else {

   183       last = b;

   184     }

   185     b = next;

   186   }

   187   set_dependencies(first);

   188   set_has_stale_entries(false);

   189   if (UsePerfData && removed > 0) {

   190     _perf_total_buckets_deallocated_count->inc(removed);

   191     _perf_total_buckets_stale_count->dec(removed);

   192   }

   193 }

   194 

   195 //

   196 // Invalidate all dependencies in the context

   197 int DependencyContext::remove_all_dependents() {

   198   assert_locked_or_safepoint(CodeCache_lock);

   199   nmethodBucket* b = dependencies();

   200   set_dependencies(NULL);

   201   int marked = 0;

   202   int removed = 0;

   203   while (b != NULL) {

   204     nmethod* nm = b->get_nmethod();

   205     if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization()) {

   206       nm->mark_for_deoptimization();

   207       marked++;

   208     }

   209     nmethodBucket* next = b->next();

   210     removed++;

   211     delete b;

   212     b = next;

   213   }

   214   set_has_stale_entries(false);

   215   if (UsePerfData && removed > 0) {

   216     _perf_total_buckets_deallocated_count->inc(removed);

   217   }

   218   return marked;

   219 }

   220 

   221 void DependencyContext::wipe() {

   222   assert_locked_or_safepoint(CodeCache_lock);

   223   nmethodBucket* b = dependencies();

   224   set_dependencies(NULL);

   225   set_has_stale_entries(false);

   226   while (b != NULL) {

   227     nmethodBucket* next = b->next();

   228     delete b;

   229     b = next;

   230   }

   231 }

   232 

   233 #ifndef PRODUCT

   234 void DependencyContext::print_dependent_nmethods(bool verbose) {

   235   int idx = 0;

   236   for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {

   237     nmethod* nm = b->get_nmethod();

   238     tty->print("[%d] count=%d { ", idx++, b->count());

   239     if (!verbose) {

   240       nm->print_on(tty, "nmethod");

   241       tty->print_cr(" } ");

   242     } else {

   243       nm->print();

   244       nm->print_dependencies();

   245       tty->print_cr("--- } ");

   246     }

   247   }

   248 }

   249 

   250 bool DependencyContext::is_dependent_nmethod(nmethod* nm) {

   251   for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {

   252     if (nm == b->get_nmethod()) {

   253 #ifdef ASSERT

   254       int count = b->count();

   255       assert(count >= 0, "count shouldn't be negative: %d", count);

   256 #endif

   257       return true;

   258     }

   259   }

   260   return false;

   261 }

   262 

   263 bool DependencyContext::find_stale_entries() {

   264   for (nmethodBucket* b = dependencies(); b != NULL; b = b->next()) {

   265     if (b->count() == 0)  return true;

   266   }

   267   return false;

   268 }

   269 

   270 #endif //PRODUCT

   271 

   272 int nmethodBucket::decrement() {

   273   return Atomic::add(-1, (volatile int *)&_count);

   274 }