jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp@4dfb2df418f2 (annotated)

src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp@4dfb2df418f2 (annotated)

src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp

Thu, 22 Sep 2011 10:57:37 -0700

author: johnc
date: Thu, 22 Sep 2011 10:57:37 -0700
changeset 3175: 4dfb2df418f2
parent 2314: f95d63e2154a
child 3536: 95f6641e38e0
permissions: -rw-r--r--

6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp

 /*
  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP
 #include "gc_implementation/parallelScavenge/psPromotionLAB.hpp"
 #include "memory/allocation.hpp"
 #include "utilities/taskqueue.hpp"
 //
 // psPromotionManager is used by a single thread to manage object survival
 // during a scavenge. The promotion manager contains thread local data only.
 //
 // NOTE! Be carefull when allocating the stacks on cheap. If you are going
 // to use a promotion manager in more than one thread, the stacks MUST be
 // on cheap. This can lead to memory leaks, though, as they are not auto
 // deallocated.
 //
 // FIX ME FIX ME Add a destructor, and don't rely on the user to drain/flush/deallocate!
 //
 // Move to some global location
 #define HAS_BEEN_MOVED 0x1501d01d
 // End move to some global location
 class MutableSpace;
 class PSOldGen;
 class ParCompactionManager;
 class PSPromotionManager : public CHeapObj {
   friend class PSScavenge;
   friend class PSRefProcTaskExecutor;
  private:
   static PSPromotionManager**         _manager_array;
   static OopStarTaskQueueSet*         _stack_array_depth;
   static PSOldGen*                    _old_gen;
   static MutableSpace*                _young_space;
 #if TASKQUEUE_STATS
   size_t                              _masked_pushes;
   size_t                              _masked_steals;
   size_t                              _arrays_chunked;
   size_t                              _array_chunks_processed;
   void print_taskqueue_stats(uint i) const;
   void print_local_stats(uint i) const;
   static void print_stats();
   void reset_stats();
 #endif // TASKQUEUE_STATS
   PSYoungPromotionLAB                 _young_lab;
   PSOldPromotionLAB                   _old_lab;
   bool                                _young_gen_is_full;
   bool                                _old_gen_is_full;
   OopStarTaskQueue                    _claimed_stack_depth;
   OverflowTaskQueue<oop>              _claimed_stack_breadth;
   bool                                _totally_drain;
   uint                                _target_stack_size;
   uint                                _array_chunk_size;
   uint                                _min_array_size_for_chunking;
   // Accessors
   static PSOldGen* old_gen()         { return _old_gen; }
   static MutableSpace* young_space() { return _young_space; }
   inline static PSPromotionManager* manager_array(int index);
   template <class T> inline void claim_or_forward_internal_depth(T* p);
   // On the task queues we push reference locations as well as
   // partially-scanned arrays (in the latter case, we push an oop to
   // the from-space image of the array and the length on the
   // from-space image indicates how many entries on the array we still
   // need to scan; this is basically how ParNew does partial array
   // scanning too). To be able to distinguish between reference
   // locations and partially-scanned array oops we simply mask the
   // latter oops with 0x01. The next three methods do the masking,
   // unmasking, and checking whether the oop is masked or not. Notice
   // that the signature of the mask and unmask methods looks a bit
   // strange, as they accept and return different types (oop and
   // oop*). This is because of the difference in types between what
   // the task queue holds (oop*) and oops to partially-scanned arrays
   // (oop). We do all the necessary casting in the mask / unmask
   // methods to avoid sprinkling the rest of the code with more casts.
   // These are added to the taskqueue so PS_CHUNKED_ARRAY_OOP_MASK (or any
   // future masks) can't conflict with COMPRESSED_OOP_MASK
 #define PS_CHUNKED_ARRAY_OOP_MASK  0x2
   bool is_oop_masked(StarTask p) {
     // If something is marked chunked it's always treated like wide oop*
     return (((intptr_t)(oop*)p) & PS_CHUNKED_ARRAY_OOP_MASK) ==
                                   PS_CHUNKED_ARRAY_OOP_MASK;
   }
   oop* mask_chunked_array_oop(oop obj) {
     assert(!is_oop_masked((oop*) obj), "invariant");
     oop* ret = (oop*) ((uintptr_t)obj | PS_CHUNKED_ARRAY_OOP_MASK);
     assert(is_oop_masked(ret), "invariant");
     return ret;
   }
   oop unmask_chunked_array_oop(StarTask p) {
     assert(is_oop_masked(p), "invariant");
     assert(!p.is_narrow(), "chunked array oops cannot be narrow");
     oop *chunk = (oop*)p;  // cast p to oop (uses conversion operator)
     oop ret = oop((oop*)((uintptr_t)chunk & ~PS_CHUNKED_ARRAY_OOP_MASK));
     assert(!is_oop_masked((oop*) ret), "invariant");
     return ret;
   }
   template <class T> void  process_array_chunk_work(oop obj,
                                                     int start, int end);
   void process_array_chunk(oop old);
   template <class T> void push_depth(T* p) {
     claimed_stack_depth()->push(p);
   }
  protected:
   static OopStarTaskQueueSet* stack_array_depth()   { return _stack_array_depth; }
  public:
   // Static
   static void initialize();
   static void pre_scavenge();
   static void post_scavenge();
   static PSPromotionManager* gc_thread_promotion_manager(int index);
   static PSPromotionManager* vm_thread_promotion_manager();
   static bool steal_depth(int queue_num, int* seed, StarTask& t) {
     return stack_array_depth()->steal(queue_num, seed, t);
   }
   PSPromotionManager();
   // Accessors
   OopStarTaskQueue* claimed_stack_depth() {
     return &_claimed_stack_depth;
   }
   bool young_gen_is_full()             { return _young_gen_is_full; }
   bool old_gen_is_full()               { return _old_gen_is_full; }
   void set_old_gen_is_full(bool state) { _old_gen_is_full = state; }
   // Promotion methods
   oop copy_to_survivor_space(oop o);
   oop oop_promotion_failed(oop obj, markOop obj_mark);
   void reset();
   void flush_labs();
   void drain_stacks(bool totally_drain) {
     drain_stacks_depth(totally_drain);
   }
  public:
   void drain_stacks_cond_depth() {
     if (claimed_stack_depth()->size() > _target_stack_size) {
       drain_stacks_depth(false);
     }
   }
   void drain_stacks_depth(bool totally_drain);
   bool stacks_empty() {
     return claimed_stack_depth()->is_empty();
   }
   inline void process_popped_location_depth(StarTask p);
   template <class T> inline void claim_or_forward_depth(T* p);
   TASKQUEUE_STATS_ONLY(inline void record_steal(StarTask& p);)
 };
 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp@4dfb2df418f2 (annotated)

src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp