src/share/vm/runtime/thread.cpp

rev 5917 : imported patch cldclosure

*** 824,834 ****
    assert(SharedHeap::heap()->workers()->active_workers() > 0,
           "Should only fail when parallel.");
    return false;
  }
  
! void Thread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
    active_handles()->oops_do(f);
    // Do oop for ThreadShadow
    f->do_oop((oop*)&_pending_exception);
    handle_area()->oops_do(f);
  }
--- 824,834 ----
    assert(SharedHeap::heap()->workers()->active_workers() > 0,
           "Should only fail when parallel.");
    return false;
  }
  
! void Thread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
    active_handles()->oops_do(f);
    // Do oop for ThreadShadow
    f->do_oop((oop*)&_pending_exception);
    handle_area()->oops_do(f);
  }
*** 2720,2730 ****
        _cur_thr->set_processed_thread(NULL);
      }
    }
  };
  
! void JavaThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
    // Verify that the deferred card marks have been flushed.
    assert(deferred_card_mark().is_empty(), "Should be empty during GC");
  
    // The ThreadProfiler oops_do is done from FlatProfiler::oops_do
    // since there may be more than one thread using each ThreadProfiler.
--- 2720,2730 ----
        _cur_thr->set_processed_thread(NULL);
      }
    }
  };
  
! void JavaThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
    // Verify that the deferred card marks have been flushed.
    assert(deferred_card_mark().is_empty(), "Should be empty during GC");
  
    // The ThreadProfiler oops_do is done from FlatProfiler::oops_do
    // since there may be more than one thread using each ThreadProfiler.
*** 3243,3253 ****
  #ifndef PRODUCT
    _ideal_graph_printer = NULL;
  #endif
  }
  
! void CompilerThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
    JavaThread::oops_do(f, cld_f, cf);
    if (_scanned_nmethod != NULL && cf != NULL) {
      // Safepoints can occur when the sweeper is scanning an nmethod so
      // process it here to make sure it isn't unloaded in the middle of
      // a scan.
--- 3243,3253 ----
  #ifndef PRODUCT
    _ideal_graph_printer = NULL;
  #endif
  }
  
! void CompilerThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
    JavaThread::oops_do(f, cld_f, cf);
    if (_scanned_nmethod != NULL && cf != NULL) {
      // Safepoints can occur when the sweeper is scanning an nmethod so
      // process it here to make sure it isn't unloaded in the middle of
      // a scan.
*** 4139,4156 ****
  // In particular, these things should never be called when the Threads_lock
  // is held by some other thread. (Note: the Safepoint abstraction also
  // uses the Threads_lock to guarantee this property. It also makes sure that
  // all threads gets blocked when exiting or starting).
  
! void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
    ALL_JAVA_THREADS(p) {
      p->oops_do(f, cld_f, cf);
    }
    VMThread::vm_thread()->oops_do(f, cld_f, cf);
  }
  
! void Threads::possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
    // Introduce a mechanism allowing parallel threads to claim threads as
    // root groups.  Overhead should be small enough to use all the time,
    // even in sequential code.
    SharedHeap* sh = SharedHeap::heap();
    // Cannot yet substitute active_workers for n_par_threads
--- 4139,4156 ----
  // In particular, these things should never be called when the Threads_lock
  // is held by some other thread. (Note: the Safepoint abstraction also
  // uses the Threads_lock to guarantee this property. It also makes sure that
  // all threads gets blocked when exiting or starting).
  
! void Threads::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
    ALL_JAVA_THREADS(p) {
      p->oops_do(f, cld_f, cf);
    }
    VMThread::vm_thread()->oops_do(f, cld_f, cf);
  }
  
! void Threads::possibly_parallel_oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
    // Introduce a mechanism allowing parallel threads to claim threads as
    // root groups.  Overhead should be small enough to use all the time,
    // even in sequential code.
    SharedHeap* sh = SharedHeap::heap();
    // Cannot yet substitute active_workers for n_par_threads