src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp

rev 8068 : imported patch parallelscavenge_cleanup

*** 87,96 ****
--- 87,97 ----
    // size of the generation as the boundaries currently stand.
    // _max_gen_size is still used as that value.
    double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
    double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
  
+   _psh = this;
    _gens = new AdjoiningGenerations(heap_rs, _collector_policy, generation_alignment());
  
    _old_gen = _gens->old_gen();
    _young_gen = _gens->young_gen();
  
*** 112,122 ****
       young_gen()->virtual_space()->low_boundary()),
      "Boundaries must meet");
    // initialize the policy counters - 2 collectors, 3 generations
    _gc_policy_counters =
      new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 3, _size_policy);
-   _psh = this;
  
    // Set up the GCTaskManager
    _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
  
    if (UseParallelOldGC && !PSParallelCompact::initialize()) {
--- 113,122 ----
*** 257,267 ****
      // the collection count has already changed. To prevent duplicate collections,
      // The policy MUST attempt allocations during the same period it reads the
      // total_collections() value!
      {
        MutexLocker ml(Heap_lock);
!       gc_count = Universe::heap()->total_collections();
  
        result = young_gen()->allocate(size);
        if (result != NULL) {
          return result;
        }
--- 257,267 ----
      // the collection count has already changed. To prevent duplicate collections,
      // The policy MUST attempt allocations during the same period it reads the
      // total_collections() value!
      {
        MutexLocker ml(Heap_lock);
!       gc_count = total_collections();
  
        result = young_gen()->allocate(size);
        if (result != NULL) {
          return result;
        }
*** 307,318 ****
  
        // Did the VM operation execute? If so, return the result directly.
        // This prevents us from looping until time out on requests that can
        // not be satisfied.
        if (op.prologue_succeeded()) {
!         assert(Universe::heap()->is_in_or_null(op.result()),
!           "result not in heap");
  
          // If GC was locked out during VM operation then retry allocation
          // and/or stall as necessary.
          if (op.gc_locked()) {
            assert(op.result() == NULL, "must be NULL if gc_locked() is true");
--- 307,317 ----
  
        // Did the VM operation execute? If so, return the result directly.
        // This prevents us from looping until time out on requests that can
        // not be satisfied.
        if (op.prologue_succeeded()) {
!         assert(is_in_or_null(op.result()), "result not in heap");
  
          // If GC was locked out during VM operation then retry allocation
          // and/or stall as necessary.
          if (op.gc_locked()) {
            assert(op.result() == NULL, "must be NULL if gc_locked() is true");
*** 418,428 ****
  // collection methods. This method decides where to attempt allocations,
  // and when to attempt collections, but no collection specific policy.
  HeapWord* ParallelScavengeHeap::failed_mem_allocate(size_t size) {
    assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
    assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
!   assert(!Universe::heap()->is_gc_active(), "not reentrant");
    assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
  
    // We assume that allocation in eden will fail unless we collect.
  
    // First level allocation failure, scavenge and allocate in young gen.
--- 417,427 ----
  // collection methods. This method decides where to attempt allocations,
  // and when to attempt collections, but no collection specific policy.
  HeapWord* ParallelScavengeHeap::failed_mem_allocate(size_t size) {
    assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
    assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
!   assert(!is_gc_active(), "not reentrant");
    assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
  
    // We assume that allocation in eden will fail unless we collect.
  
    // First level allocation failure, scavenge and allocate in young gen.
*** 506,517 ****
    uint gc_count      = 0;
    uint full_gc_count = 0;
    {
      MutexLocker ml(Heap_lock);
      // This value is guarded by the Heap_lock
!     gc_count      = Universe::heap()->total_collections();
!     full_gc_count = Universe::heap()->total_full_collections();
    }
  
    VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause);
    VMThread::execute(&op);
  }
--- 505,516 ----
    uint gc_count      = 0;
    uint full_gc_count = 0;
    {
      MutexLocker ml(Heap_lock);
      // This value is guarded by the Heap_lock
!     gc_count      = total_collections();
!     full_gc_count = total_full_collections();
    }
  
    VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause);
    VMThread::execute(&op);
  }