Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright 1997-2005 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

  * CA 95054 USA or visit www.sun.com if you need additional information or

  * have any questions.

  *

  */

 # include "incls/_precompiled.incl"

 # include "incls/_sweeper.cpp.incl"

 long      NMethodSweeper::_traversals = 0;   // No. of stack traversals performed

 CodeBlob* NMethodSweeper::_current = NULL;   // Current nmethod

 int       NMethodSweeper::_seen = 0 ;        // No. of blobs we have currently processed in current pass of CodeCache

 int       NMethodSweeper::_invocations = 0;  // No. of invocations left until we are completed with this pass

 jint      NMethodSweeper::_locked_seen = 0;

 jint      NMethodSweeper::_not_entrant_seen_on_stack = 0;

 bool      NMethodSweeper::_rescan = false;

 class MarkActivationClosure: public CodeBlobClosure {

 public:

   virtual void do_code_blob(CodeBlob* cb) {

     // If we see an activation belonging to a non_entrant nmethod, we mark it.

     if (cb->is_nmethod() && ((nmethod*)cb)->is_not_entrant()) {

       ((nmethod*)cb)->mark_as_seen_on_stack();

     }

   }

 };

 static MarkActivationClosure mark_activation_closure;

 void NMethodSweeper::sweep() {

   assert(SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint");

   if (!MethodFlushing) return;

   // No need to synchronize access, since this is always executed at a

   // safepoint.  If we aren't in the middle of scan and a rescan

   // hasn't been requested then just return.

   if (_current == NULL && !_rescan) return;

   // Make sure CompiledIC_lock in unlocked, since we might update some

   // inline caches. If it is, we just bail-out and try later.

   if (CompiledIC_lock->is_locked() || Patching_lock->is_locked()) return;

   // Check for restart

   assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");

   if (_current == NULL) {

     _seen        = 0;

     _invocations = NmethodSweepFraction;

     _current     = CodeCache::first();

     _traversals  += 1;

     if (PrintMethodFlushing) {

       tty->print_cr("### Sweep: stack traversal %d", _traversals);

     }

     Threads::nmethods_do(&mark_activation_closure);

     // reset the flags since we started a scan from the beginning.

     _rescan = false;

     _locked_seen = 0;

     _not_entrant_seen_on_stack = 0;

   }

   if (PrintMethodFlushing && Verbose) {

     tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_blobs(), _invocations);

   }

   // We want to visit all nmethods after NmethodSweepFraction invocations.

   // If invocation is 1 we do the rest

   int todo = CodeCache::nof_blobs();

   if (_invocations != 1) {

     todo = (CodeCache::nof_blobs() - _seen) / _invocations;

     _invocations--;

   }

   for(int i = 0; i < todo && _current != NULL; i++) {

     CodeBlob* next = CodeCache::next(_current); // Read next before we potentially delete current

     if (_current->is_nmethod()) {

       process_nmethod((nmethod *)_current);

     }

     _seen++;

     _current = next;

   }

   // Because we could stop on a codeBlob other than an nmethod we skip forward

   // to the next nmethod (if any). codeBlobs other than nmethods can be freed

   // async to us and make _current invalid while we sleep.

   while (_current != NULL && !_current->is_nmethod()) {

     _current = CodeCache::next(_current);

   }

   if (_current == NULL && !_rescan && (_locked_seen || _not_entrant_seen_on_stack)) {

     // we've completed a scan without making progress but there were

     // nmethods we were unable to process either because they were

     // locked or were still on stack.  We don't have to aggresively

     // clean them up so just stop scanning.  We could scan once more

     // but that complicates the control logic and it's unlikely to

     // matter much.

     if (PrintMethodFlushing) {

       tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");

     }

   }

 }

 void NMethodSweeper::process_nmethod(nmethod *nm) {

   // Skip methods that are currently referenced by the VM

   if (nm->is_locked_by_vm()) {

     // But still remember to clean-up inline caches for alive nmethods

     if (nm->is_alive()) {

       // Clean-up all inline caches that points to zombie/non-reentrant methods

       nm->cleanup_inline_caches();

     } else {

       _locked_seen++;

     }

     return;

   }

   if (nm->is_zombie()) {

     // If it is first time, we see nmethod then we mark it. Otherwise,

     // we reclame it. When we have seen a zombie method twice, we know that

     // there are no inline caches that referes to it.

     if (nm->is_marked_for_reclamation()) {

       assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");

       nm->flush();

     } else {

       nm->mark_for_reclamation();

       _rescan = true;

     }

   } else if (nm->is_not_entrant()) {

     // If there is no current activations of this method on the

     // stack we can safely convert it to a zombie method

     if (nm->can_not_entrant_be_converted()) {

       nm->make_zombie();

       _rescan = true;

     } else {

       // Still alive, clean up its inline caches

       nm->cleanup_inline_caches();

       // we coudn't transition this nmethod so don't immediately

       // request a rescan.  If this method stays on the stack for a

       // long time we don't want to keep rescanning at every safepoint.

       _not_entrant_seen_on_stack++;

     }

   } else if (nm->is_unloaded()) {

     // Unloaded code, just make it a zombie

     if (nm->is_osr_only_method()) {

       // No inline caches will ever point to osr methods, so we can just remove it

       nm->flush();

     } else {

       nm->make_zombie();

       _rescan = true;

     }

   } else {

     assert(nm->is_alive(), "should be alive");

     // Clean-up all inline caches that points to zombie/non-reentrant methods

     nm->cleanup_inline_caches();

   }

 }