jdk8-mips64-public/hotspot: src/share/vm/runtime/sweeper.cpp@54b3b351d6f9 (annotated)

src/share/vm/runtime/sweeper.cpp@54b3b351d6f9 (annotated)

src/share/vm/runtime/sweeper.cpp

Wed, 23 Sep 2009 23:56:15 -0700

author: jrose
date: Wed, 23 Sep 2009 23:56:15 -0700
changeset 1428: 54b3b351d6f9
parent 1424: 148e5441d916
parent 1376: 8b46c4d82093
child 1435: a1423fe86a18
permissions: -rw-r--r--

Merge

 /*
  * 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");
       if (PrintMethodFlushing && Verbose) {
         tty->print_cr("### Nmethod 0x%x (marked for reclamation) being flushed", nm);
       }
       nm->flush();
     } else {
       if (PrintMethodFlushing && Verbose) {
         tty->print_cr("### Nmethod 0x%x (zombie) being marked for reclamation", nm);
       }
       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()) {
       if (PrintMethodFlushing && Verbose) {
         tty->print_cr("### Nmethod 0x%x (not entrant) being made zombie", nm);
       }
       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 (PrintMethodFlushing && Verbose)
       tty->print_cr("### Nmethod 0x%x (unloaded) being made zombie", nm);
     if (nm->is_osr_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();
   }
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/runtime/sweeper.cpp@54b3b351d6f9 (annotated)

src/share/vm/runtime/sweeper.cpp